Làm cách nào để lọc danh sách các số lẻ trong python?

Trên mỗi lần lặp, chúng tôi sử dụng toán tử modulo

List Before --> [4, 5, 4]
List After --> [4, 4]
============================================================
List Before --> [4, 5, 4, 7, 9, 11]
List After --> [4, 4]
============================================================
List Before --> [4, 5, 4, 7, 9, 11, 12, 13]
List After --> [4, 4, 12]
============================================================

8 để kiểm tra xem số hiện tại có phần còn lại khi chia cho

List Before --> [4, 5, 4]
List After --> [4, 4]
============================================================
List Before --> [4, 5, 4, 7, 9, 11]
List After --> [4, 4]
============================================================
List Before --> [4, 5, 4, 7, 9, 11, 12, 13]
List After --> [4, 4, 12]
============================================================

9

Toán tử modulo (%) trả về phần còn lại từ phép chia giá trị thứ nhất cho giá trị thứ hai

Nếu số có dư khi chia cho 2 thì nó là số lẻ, vì vậy chúng tôi sử dụng phương pháp

def get_odd_numbers(numbers):
    odd_numbers = []

    for number in numbers:
        if number % 2 == 1:
            odd_numbers.append(number)

    return odd_numbers

0 để xóa nó khỏi danh sách

Danh sách. phương thức remove() loại bỏ mục đầu tiên khỏi danh sách có giá trị bằng với đối số được truyền vào

Phương thức

def get_odd_numbers(numbers):
    odd_numbers = []

    for number in numbers:
        if number % 2 == 1:
            odd_numbers.append(number)

    return odd_numbers

1 thay đổi danh sách ban đầu và trả về

def get_odd_numbers(numbers):
    odd_numbers = []

    for number in numbers:
        if number % 2 == 1:
            odd_numbers.append(number)

    return odd_numbers

2

Sau lần lặp cuối cùng, danh sách chỉ chứa các số chẵn

Ngoài ra, bạn có thể sử dụng cách hiểu danh sách đơn giản

Xóa các số Lẻ khỏi Danh sách bằng cách hiểu danh sách #

Để xóa các số lẻ khỏi danh sách

1. Sử dụng khả năng hiểu danh sách để lặp lại danh sách
2. Kiểm tra xem mỗi mục không có số dư khi chia cho 2
3. Danh sách mới sẽ chỉ chứa các số chẵn

Chúng tôi đã sử dụng cách hiểu danh sách để lặp lại danh sách

Khả năng hiểu danh sách được sử dụng để thực hiện một số thao tác cho mọi phần tử hoặc chọn một tập hợp con các phần tử đáp ứng một điều kiện

Trên mỗi lần lặp, chúng tôi sử dụng toán tử modulo

List Before --> [4, 5, 4]
List After --> [4, 4]
============================================================
List Before --> [4, 5, 4, 7, 9, 11]
List After --> [4, 4]
============================================================
List Before --> [4, 5, 4, 7, 9, 11, 12, 13]
List After --> [4, 4, 12]
============================================================

8 để kiểm tra xem số hiện tại không có phần còn lại khi chia cho

List Before --> [4, 5, 4]
List After --> [4, 4]
============================================================
List Before --> [4, 5, 4, 7, 9, 11]
List After --> [4, 4]
============================================================
List Before --> [4, 5, 4, 7, 9, 11, 12, 13]
List After --> [4, 4, 12]
============================================================

9

Nếu số không có phần dư khi chia cho

List Before --> [4, 5, 4]
List After --> [4, 4]
============================================================
List Before --> [4, 5, 4, 7, 9, 11]
List After --> [4, 4]
============================================================
List Before --> [4, 5, 4, 7, 9, 11, 12, 13]
List After --> [4, 4, 12]
============================================================

9, thì đó là một số chẵn và được thêm vào danh sách mới

Danh sách mới chỉ chứa các số chẵn từ danh sách ban đầu

Ngoài ra, bạn có thể sử dụng phương pháp

List Before --> [4, 5, 4]
List After --> [4, 4]
============================================================
List Before --> [4, 5, 4, 7, 9, 11]
List After --> [4, 4]
============================================================
List Before --> [4, 5, 4, 7, 9, 11, 12, 13]
List After --> [4, 4, 12]
============================================================

92

Xóa các số Lẻ khỏi Danh sách bằng bộ lọc() #

Để xóa các số lẻ khỏi danh sách

1. Truyền hàm

   List Before --> [4, 5, 4]
   List After --> [4, 4]
   ============================================================
   List Before --> [4, 5, 4, 7, 9, 11]
   List After --> [4, 4]
   ============================================================
   List Before --> [4, 5, 4, 7, 9, 11, 12, 13]
   List After --> [4, 4, 12]
   ============================================================
   

   93 và danh sách cho hàm

   List Before --> [4, 5, 4]
   List After --> [4, 4]
   ============================================================
   List Before --> [4, 5, 4, 7, 9, 11]
   List After --> [4, 4]
   ============================================================
   List Before --> [4, 5, 4, 7, 9, 11, 12, 13]
   List After --> [4, 4, 12]
   ============================================================
   

   92
2. Hàm lambda sẽ kiểm tra xem mỗi số không có phần dư khi chia cho

   List Before --> [4, 5, 4]
   List After --> [4, 4]
   ============================================================
   List Before --> [4, 5, 4, 7, 9, 11]
   List After --> [4, 4]
   ============================================================
   List Before --> [4, 5, 4, 7, 9, 11, 12, 13]
   List After --> [4, 4, 12]
   ============================================================
   

   9
3. Sử dụng lớp

   List Before --> [4, 5, 4]
   List After --> [4, 4]
   ============================================================
   List Before --> [4, 5, 4, 7, 9, 11]
   List After --> [4, 4]
   ============================================================
   List Before --> [4, 5, 4, 7, 9, 11, 12, 13]
   List After --> [4, 4, 12]
   ============================================================
   

   96 để chuyển đổi đối tượng

   List Before --> [4, 5, 4]
   List After --> [4, 4]
   ============================================================
   List Before --> [4, 5, 4, 7, 9, 11]
   List After --> [4, 4]
   ============================================================
   List Before --> [4, 5, 4, 7, 9, 11, 12, 13]
   List After --> [4, 4, 12]
   ============================================================
   

   97 thành danh sách

Hàm bộ lọc lấy một hàm và một iterable làm đối số và xây dựng một iterator từ các phần tử của iterable mà hàm trả về một giá trị trung thực

Hàm

List Before --> [4, 5, 4]
List After --> [4, 4]
============================================================
List Before --> [4, 5, 4, 7, 9, 11]
List After --> [4, 4]
============================================================
List Before --> [4, 5, 4, 7, 9, 11, 12, 13]
List After --> [4, 4, 12]
============================================================

93 mà chúng tôi đã chuyển đến bộ lọc được gọi với từng mục trong danh sách

Hàm kiểm tra xem mặt hàng được cung cấp có dư không khi chia cho

List Before --> [4, 5, 4]
List After --> [4, 4]
============================================================
List Before --> [4, 5, 4, 7, 9, 11]
List After --> [4, 4]
============================================================
List Before --> [4, 5, 4, 7, 9, 11, 12, 13]
List After --> [4, 4, 12]
============================================================

9 và trả về kết quả

Tại đây Một triển khai khác và một số thử nghiệm về hiệu suất, mục tiêu Thực tế là không thay đổi danh sách thực nhưng xóa số tỷ lệ cược trong cùng một danh sách

Cách tiếp cận đầu tiên

# --- Naive Approach Brute Force
def remove_odd(array):
    """Very unefficient Funciton, it has to copy the arr then iterate through it, then calls
    remove function, however it does the job, good for small Lists"""
    array_copy = array.copy()
    for n in array_copy:
        if n % 2 != 0:
            array.remove(n)
    return array

tests = [[4,5,4], [4,5,4,7,9,11], [4,5,4,7,9,11,12,13]]
for test in tests:
    print(f'List Before --> {test}')
    result = remove_odd(test)
    print(f'List After --> {test}')
    print('===='*15)

---

## Other Solution ##

def remove_odd(array):
    """Better Solution, it iterates through the Array once"""
    idx = 0
    offset = 0  # NOTE: Offset keeps tracks of the jumps after each iteration
    max_iter = len(array)
    while max_iter:
        n = array[idx-offset]

        if n % 2 != 0:
            offset += 1
            array.remove(n)

        idx += 1
        max_iter -= 1

tests = [[4,5,4], [4,5,4,7,9,11], [4,5,4,7,9,11,12,13]]
for test in tests:
    print(f'List Before --> {test}')
    result = remove_odd(test)
    print(f'List After --> {test}')
    print('===='*15)

Xuất cả hai chức năng##

List Before --> [4, 5, 4]
List After --> [4, 4]
============================================================
List Before --> [4, 5, 4, 7, 9, 11]
List After --> [4, 4]
============================================================
List Before --> [4, 5, 4, 7, 9, 11, 12, 13]
List After --> [4, 4, 12]
============================================================

---

Băng ghế dự bịĐánh dấu

In các số chẵn và số lẻ từ danh sách Python là một bài tập tốt nếu bạn mới bắt đầu với Python và bạn muốn tìm hiểu kiến ​​thức cơ bản về nó

Để trích xuất các số chẵn và số lẻ từ danh sách Python, bạn có thể sử dụng vòng lặp for và toán tử modulo Python. Tùy chọn thứ hai là thay thế vòng lặp for bằng khả năng hiểu danh sách. Cú pháp mở rộng của toán tử lát cũng cho phép thực hiện điều đó với một dòng mã nhưng chỉ khi bạn có danh sách các số liên tiếp

Chúng ta sẽ xem qua một vài ví dụ trong hướng dẫn này và mục đích của việc triển khai nhiều cách để giải quyết cùng một vấn đề là phát triển khả năng sáng tạo mà bạn cần với tư cách là nhà phát triển Python

Bắt đầu nào

Mục lục

• Làm cách nào để bạn in các số lẻ từ danh sách bằng Python?
• Làm thế nào để bạn in các số chẵn từ một danh sách trong Python?
• Cách tạo một hàm chia số lẻ và số chẵn trong danh sách
• Chương Trình In Các Số Chẵn Và Lẻ Từ 1 Đến 100
• Làm cách nào để bạn in các số lẻ từ danh sách các số liên tiếp trong Python?
• Làm cách nào để bạn in các số chẵn từ danh sách các số liên tiếp trong Python?
• Chương trình Python để in số chẵn lớn nhất và số lẻ lớn nhất trong danh sách
• Phát triển chương trình Python đếm số chẵn và số lẻ trong danh sách do người dùng cung cấp
• Phần kết luận

Làm cách nào để bạn in các số lẻ từ danh sách bằng Python?

Để in các số lẻ từ danh sách các số, bạn có thể sử dụng toán tử modulo Python, liên quan đến khái niệm toán học về phần dư

Khi bạn chia một số lẻ cho 2, số dư của phép chia là 1. Khi bạn chia một số chẵn cho 2, phần còn lại của phép chia là 0

Hãy sử dụng khái niệm này và vòng lặp Python for để in các số lẻ từ danh sách

def get_odd_numbers(numbers):
    odd_numbers = []

    for number in numbers:
        if number % 2 == 1:
            odd_numbers.append(number)

    return odd_numbers

Trước khi bắt đầu vòng lặp for, chúng tôi xác định một danh sách trống, sau đó ở mỗi lần lặp lại của vòng lặp for, chúng tôi thêm các số lẻ vào danh sách

numbers = [2, 3, 6, 8, 13, 45, 67, 88, 99, 100]
print(get_odd_numbers(numbers))

[output]
[3, 13, 45, 67, 99]

Làm thế nào để bạn in các số chẵn từ một danh sách trong Python?

Điều này rất giống với những gì chúng ta đã thấy trong phần trước…

Để in các số chẵn từ danh sách các số, chúng ta có thể trích xuất các số chia cho 2 trả về phần còn lại bằng 0

Mã này giống với mã chúng tôi đã tạo để trích xuất các số lẻ với một sự khác biệt nhỏ trong điều kiện if bên trong vòng lặp for

def get_even_numbers(numbers):
    even_numbers = []

    for number in numbers:
        if number % 2 == 0:
            even_numbers.append(number)

    return even_numbers

Và đầu ra của hàm là…

numbers = [2, 3, 6, 8, 13, 45, 67, 88, 99, 100]
print(get_even_numbers(numbers))

[output]
[2, 6, 8, 88, 100]

Cách tạo một hàm chia số lẻ và số chẵn trong danh sách

Để tách các số lẻ và số chẵn trong một danh sách, chúng ta có thể sử dụng cùng một cách tiếp cận dựa trên vòng lặp for đã sử dụng trước đó và tạo hai danh sách khác nhau, một cho số lẻ và một cho số chẵn

Thay vì làm điều đó, tôi muốn làm cho mã của chúng tôi ngắn gọn hơn bằng cách sử dụng khả năng hiểu danh sách

Chúng tôi vẫn sẽ sử dụng khái niệm về phần còn lại…

Hãy tạo một hàm cơ bản lấy một danh sách làm đối số và trả về hai danh sách, một danh sách chứa các số lẻ và một danh sách chứa các số chẵn

def split_list_even_odd(numbers):
    odd_numbers = [number for number in numbers if number % 2 == 1]
    even_numbers = [number for number in numbers if number % 2 == 0]
    return odd_numbers, even_numbers

Lưu ý rằng hàm này trả về hai danh sách Python

Bạn có biết người gọi hàm nhận được những danh sách này ở định dạng nào không?

Hãy cùng tìm hiểu…

________số 8

Người gọi hàm nhận một bộ có hai phần tử. Chúng ta có thể truy cập từng trong số chúng bằng cách sử dụng dấu ngoặc vuông và chỉ mục

print("The odd numbers are {}".format(split_list_even_odd(numbers)[0]))
print("The even numbers are {}".format(split_list_even_odd(numbers)[1]))

[output]
The odd numbers are [3, 13, 45, 67, 99]
The even numbers are [2, 6, 8, 88, 100]                                                                       

Nếu bạn muốn biết thêm về. format() cú pháp được sử dụng trong câu lệnh in, bạn có thể xem hướng dẫn này về cách nối các chuỗi Python

Chương Trình In Các Số Chẵn Và Lẻ Từ 1 Đến 100

Để in các số chẵn và lẻ từ 1 đến 100, trước tiên chúng ta có thể tạo danh sách các số theo cách thủ công nhưng sẽ mất nhiều thời gian

Thay vào đó, chúng ta sẽ sử dụng hàm range() của Python

Đây là cách bạn có thể tạo các số từ 1 đến 100 bằng cách sử dụng hàm range() trong Python

## Other Solution ##

def remove_odd(array):
    """Better Solution, it iterates through the Array once"""
    idx = 0
    offset = 0  # NOTE: Offset keeps tracks of the jumps after each iteration
    max_iter = len(array)
    while max_iter:
        n = array[idx-offset]

        if n % 2 != 0:
            offset += 1
            array.remove(n)

        idx += 1
        max_iter -= 1

tests = [[4,5,4], [4,5,4,7,9,11], [4,5,4,7,9,11,12,13]]
for test in tests:
    print(f'List Before --> {test}')
    result = remove_odd(test)
    print(f'List After --> {test}')
    print('===='*15)

0

Điều thú vị là loại đối tượng được hàm range() trả về không phải là một danh sách

Vì vậy, chúng ta có thể làm gì với nó?

Chúng ta vẫn có thể sử dụng vòng lặp for hoặc cách hiểu danh sách để duyệt qua tất cả các số…

## Other Solution ##

def remove_odd(array):
    """Better Solution, it iterates through the Array once"""
    idx = 0
    offset = 0  # NOTE: Offset keeps tracks of the jumps after each iteration
    max_iter = len(array)
    while max_iter:
        n = array[idx-offset]

        if n % 2 != 0:
            offset += 1
            array.remove(n)

        idx += 1
        max_iter -= 1

tests = [[4,5,4], [4,5,4,7,9,11], [4,5,4,7,9,11,12,13]]
for test in tests:
    print(f'List Before --> {test}')
    result = remove_odd(test)
    print(f'List After --> {test}')
    print('===='*15)

1

Sử dụng chức năng chúng tôi đã tạo trước đó để in số chẵn và số lẻ

## Other Solution ##

def remove_odd(array):
    """Better Solution, it iterates through the Array once"""
    idx = 0
    offset = 0  # NOTE: Offset keeps tracks of the jumps after each iteration
    max_iter = len(array)
    while max_iter:
        n = array[idx-offset]

        if n % 2 != 0:
            offset += 1
            array.remove(n)

        idx += 1
        max_iter -= 1

tests = [[4,5,4], [4,5,4,7,9,11], [4,5,4,7,9,11,12,13]]
for test in tests:
    print(f'List Before --> {test}')
    result = remove_odd(test)
    print(f'List After --> {test}')
    print('===='*15)

2

Làm cách nào để bạn in các số lẻ từ danh sách các số liên tiếp trong Python?

Cách đơn giản nhất để in các số lẻ từ danh sách các số liên tiếp là sử dụng cú pháp mở rộng của toán tử lát

Toán tử lát trả về một đoạn của danh sách được cung cấp chỉ mục bắt đầu (bao gồm) và chỉ mục kết thúc (không bao gồm)

numbers = [2, 3, 6, 8, 13, 45, 67, 88, 99, 100]
print(get_odd_numbers(numbers))

[output]
[3, 13, 45, 67, 99]

0

Hãy tạo một danh sách chứa các số từ 1 đến 10

numbers = [2, 3, 6, 8, 13, 45, 67, 88, 99, 100]
print(get_odd_numbers(numbers))

[output]
[3, 13, 45, 67, 99]

1

Để lấy 4 phần tử đầu tiên của danh sách với cú pháp toán tử lát tiêu chuẩn, chúng ta có thể sử dụng biểu thức sau

numbers = [2, 3, 6, 8, 13, 45, 67, 88, 99, 100]
print(get_odd_numbers(numbers))

[output]
[3, 13, 45, 67, 99]

2

Ghi chú. như đã đề cập trước khi chỉ mục kết thúc không được bao gồm trong danh sách được trả về bởi toán tử lát cắt

Để lấy lại danh sách đầy đủ bằng toán tử lát, bạn có thể sử dụng cú pháp sau

numbers = [2, 3, 6, 8, 13, 45, 67, 88, 99, 100]
print(get_odd_numbers(numbers))

[output]
[3, 13, 45, 67, 99]

3

Ok, nhưng làm cách nào để điều này giúp chúng tôi chỉ truy xuất các số lẻ?

Để làm được điều đó, chúng ta phải thêm một cái gì đó vào cú pháp cơ bản của toán tử lát cắt, đó là lý do tại sao nó được gọi là cú pháp mở rộng

Với cú pháp mở rộng, bạn có thể chuyển đối số thứ ba cho toán tử lát cắt, đối số này xác định bước giữa các mục sẽ được truy xuất từ ​​danh sách

numbers = [2, 3, 6, 8, 13, 45, 67, 88, 99, 100]
print(get_odd_numbers(numbers))

[output]
[3, 13, 45, 67, 99]

4

Ví dụ: nếu giá trị của bước là 2, toán tử lát cắt sẽ truy xuất cứ sau 2 số

Bây giờ chúng ta đã biết điều này, chúng ta đã sẵn sàng truy xuất các số lẻ từ danh sách của mình…

numbers = [2, 3, 6, 8, 13, 45, 67, 88, 99, 100]
print(get_odd_numbers(numbers))

[output]
[3, 13, 45, 67, 99]

5

Về cơ bản, chúng tôi lấy lại danh sách đầy đủ vì chúng tôi chưa cung cấp chỉ mục bắt đầu và kết thúc. Ngoài ra, chúng tôi chỉ nhận được các số lẻ vì chúng tôi đã chỉ định một bước bằng 2

Làm cách nào để bạn in các số chẵn từ danh sách các số liên tiếp trong Python?

Điều này rất giống với những gì chúng ta đã thấy trong phần trước…

Để in các số chẵn từ danh sách các số liên tiếp trong Python, bạn có thể sử dụng cú pháp lát cắt mở rộng với chỉ số bắt đầu bằng 1, chỉ số kết thúc trống và bước bằng 2

numbers = [2, 3, 6, 8, 13, 45, 67, 88, 99, 100]
print(get_odd_numbers(numbers))

[output]
[3, 13, 45, 67, 99]

6

Et voilà

Điều này khá đơn giản khi bạn đã quen với cú pháp của toán tử lát cắt

Chương trình Python để in số chẵn lớn nhất và số lẻ lớn nhất trong danh sách

Để in số chẵn và số lẻ lớn nhất trong danh sách Python, chúng ta có thể bắt đầu từ các khái niệm mà chúng ta đã thấy trước đây liên quan đến toán tử lát

Điều bổ sung mà chúng ta phải làm là áp dụng hàm max() cho danh sách được trả về bởi toán tử lát cắt

Số Lẻ Lớn Nhất

numbers = [2, 3, 6, 8, 13, 45, 67, 88, 99, 100]
print(get_odd_numbers(numbers))

[output]
[3, 13, 45, 67, 99]

7

Số chẵn lớn nhất

numbers = [2, 3, 6, 8, 13, 45, 67, 88, 99, 100]
print(get_odd_numbers(numbers))

[output]
[3, 13, 45, 67, 99]

8

Đẹp và đơn giản 🙂

Phát triển chương trình Python đếm số chẵn và số lẻ trong danh sách do người dùng cung cấp

Trước khi hoàn thành hướng dẫn này, hãy xem cách chúng ta có thể sử dụng hàm nhập Python để lấy danh sách các số từ đầu vào của người dùng

Trước hết, tôi muốn xem loại dữ liệu nào chúng tôi nhận được từ đầu vào của người dùng

numbers = [2, 3, 6, 8, 13, 45, 67, 88, 99, 100]
print(get_odd_numbers(numbers))

[output]
[3, 13, 45, 67, 99]

9

Đầu vào của người dùng là một chuỗi đơn, vì vậy chúng tôi phải thực hiện một chút thao tác chuỗi để chuyển đổi nó thành danh sách trước

Phương thức tách chuỗi Python() cho phép chuyển đổi một chuỗi thành một danh sách

def get_even_numbers(numbers):
    even_numbers = []

    for number in numbers:
        if number % 2 == 0:
            even_numbers.append(number)

    return even_numbers

0

Đó là một bước tiến, nhưng chúng tôi vẫn có một danh sách các chuỗi và thay vào đó chúng tôi muốn có một danh sách các số nguyên

Có thể sử dụng cách hiểu danh sách và hàm int() của Python để chuyển đổi danh sách chuỗi thành danh sách số nguyên

def get_even_numbers(numbers):
    even_numbers = []

    for number in numbers:
        if number % 2 == 0:
            even_numbers.append(number)

    return even_numbers

1

Đẹp 🙂

Và bây giờ chúng ta đã sẵn sàng để tạo hàm chuyển đổi chuỗi do người dùng cung cấp thành danh sách các số nguyên

def get_even_numbers(numbers):
    even_numbers = []

    for number in numbers:
        if number % 2 == 0:
            even_numbers.append(number)

    return even_numbers

2

Sau khi chuyển đổi đầu vào của người dùng thành danh sách các số nguyên, chúng ta có thể gọi hàm split_list_even_odd() đã tạo trước đó

Đây là chương trình đầy đủ

def get_even_numbers(numbers):
    even_numbers = []

    for number in numbers:
        if number % 2 == 0:
            even_numbers.append(number)

    return even_numbers

3

Hãy thực hiện chương trình của chúng ta…

def get_even_numbers(numbers):
    even_numbers = []

    for number in numbers:
        if number % 2 == 0:
            even_numbers.append(number)

    return even_numbers

4

Nó hoạt động

Phần kết luận

Nếu bạn có bất kỳ nghi ngờ nào về việc trích xuất các số chẵn và lẻ từ danh sách Python trước khi đọc bài viết này…

…bây giờ bạn đã có tất cả kiến ​​thức cần thiết để làm điều đó

Nếu bạn cảm thấy một số điều vẫn chưa rõ ràng, hãy quay lại và tự mình viết lại các ví dụ trong hướng dẫn này từ đầu

Thực hành là cách tốt nhất để học và ghi nhớ các cấu trúc Python

Mã hóa vui vẻ. 😀

Bài viết liên quan

Lỗi Python. Quá nhiều giá trị để giải nén. Hãy sửa chữa nó

Cách đảo ngược chuỗi Python. Cải thiện kỹ năng Python của bạn

Làm cách nào để mở trình duyệt web bằng Python?

Claudio Sabato

Tôi là Trưởng nhóm công nghệ, Kỹ sư phần mềm và Huấn luyện viên lập trình. Tôi muốn giúp bạn trong hành trình trở thành Super Developer