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]
============================================================
9Toá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áchDanh 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
2Sau 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
- Sử dụng khả năng hiểu danh sách để lặp lại danh sách
- Kiểm tra xem mỗi mục không có số dư khi chia cho 2
- 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]
============================================================
9Nế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ớiDanh 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]
============================================================
92Xó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
- Truyền hàm
93 và danh sách cho hàmList 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] ============================================================
92List 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] ============================================================
- Hàm lambda sẽ kiểm tra xem mỗi số không có phần dư khi chia cho
9List 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] ============================================================
- Sử dụng lớp
96 để chuyển đổi đối tượngList 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áchList 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] ============================================================
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áchHà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ố 8Ngườ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]
1Sử 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]
2Là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]
0Hã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]
2Ghi 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]
3Ok, 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]
4Ví 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]
5Về 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]
6Et 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]
7Số 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
2Sau 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
3Hã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
4Nó 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