Làm cách nào để bạn chọn người dùng từ danh sách trong python?

Sử dụng vòng lặp >>> squares = [i * i for i in range(10)] >>> squares [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] 6

Loại vòng lặp phổ biến nhất là vòng lặp

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

1. Khởi tạo một danh sách trống
2. Lặp lại một lần lặp hoặc phạm vi phần tử
3. Nối từng phần tử vào cuối danh sách

Nếu bạn muốn tạo một danh sách chứa mười ô vuông hoàn hảo đầu tiên, thì bạn có thể hoàn thành các bước này trong ba dòng mã

>>>

>>> squares = []
>>> for i in range(10):
..     squares.append(i * i)
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Ở đây, bạn khởi tạo một danh sách trống,

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

new_list = [expression for member in iterable]

Sử dụng đối tượng >>> squares = [i * i for i in range(10)] >>> squares [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] 3

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Ví dụ, hãy xem xét một tình huống trong đó bạn cần tính giá sau thuế cho một danh sách các giao dịch

>>>

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Ở đây, bạn có một

new_list = [expression for member in iterable]

new_list = [expression for member in iterable]

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

new_list = [expression for member in iterable]

new_list = [expression for member in iterable]

Sử dụng danh sách hiểu

Hiểu danh sách là cách thứ ba để tạo danh sách. Với cách tiếp cận tao nhã này, bạn có thể viết lại vòng lặp

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>>

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Thay vì tạo một danh sách trống và thêm từng phần tử vào cuối, bạn chỉ cần xác định đồng thời danh sách và nội dung của nó bằng cách tuân theo định dạng này

>>>

new_list = [expression for member in iterable]

Mọi khả năng hiểu danh sách trong Python bao gồm ba yếu tố

1. >>> squares = [i * i for i in range(10)]
   >>> squares
   [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
   

   21 là chính thành viên, lệnh gọi phương thức hoặc bất kỳ biểu thức hợp lệ nào khác trả về giá trị. Trong ví dụ trên, biểu thức

   >>> squares = [i * i for i in range(10)]
   >>> squares
   [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
   

   22 là bình phương của giá trị phần tử

2. >>> squares = [i * i for i in range(10)]
   >>> squares
   [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
   

   23 là đối tượng hoặc giá trị trong danh sách hoặc có thể lặp lại. Trong ví dụ trên, giá trị thành viên là

   >>> squares = [i * i for i in range(10)]
   >>> squares
   [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
   

   24

3. >>> squares = [i * i for i in range(10)]
   >>> squares
   [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
   

   25 là một danh sách, tập hợp, trình tự, trình tạo hoặc bất kỳ đối tượng nào khác có thể trả về từng phần tử của nó cùng một lúc. Trong ví dụ trên, iterable là

   new_list = [expression for member in iterable]
   

   1

Bởi vì yêu cầu về biểu thức rất linh hoạt nên khả năng hiểu danh sách trong Python hoạt động tốt ở nhiều nơi mà bạn sẽ sử dụng

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>>

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Điểm khác biệt duy nhất giữa cách triển khai này và

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Lợi ích của việc sử dụng danh sách hiểu

Khả năng hiểu danh sách thường được mô tả là Pythonic hơn các vòng lặp hoặc

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Một lợi ích chính của việc sử dụng khả năng hiểu danh sách trong Python là nó là một công cụ duy nhất mà bạn có thể sử dụng trong nhiều tình huống khác nhau. Ngoài việc tạo danh sách tiêu chuẩn, khả năng hiểu danh sách cũng có thể được sử dụng để ánh xạ và lọc. Bạn không phải sử dụng một cách tiếp cận khác cho từng tình huống

Đây là lý do chính tại sao khả năng hiểu danh sách được coi là Pythonic, vì Python bao gồm các công cụ đơn giản, mạnh mẽ mà bạn có thể sử dụng trong nhiều tình huống khác nhau. Là một lợi ích bổ sung, bất cứ khi nào bạn sử dụng khả năng hiểu danh sách trong Python, bạn sẽ không cần phải nhớ thứ tự thích hợp của các đối số như khi bạn gọi

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Khả năng hiểu danh sách cũng mang tính khai báo hơn so với vòng lặp, điều đó có nghĩa là chúng dễ đọc và dễ hiểu hơn. Vòng lặp yêu cầu bạn tập trung vào cách tạo danh sách. Bạn phải tạo danh sách trống theo cách thủ công, lặp qua các phần tử và thêm từng phần tử vào cuối danh sách. Với khả năng hiểu danh sách trong Python, thay vào đó, bạn có thể tập trung vào những gì bạn muốn đưa vào danh sách và tin tưởng rằng Python sẽ đảm nhận việc xây dựng danh sách diễn ra như thế nào

Sử dụng logic có điều kiện

Trước đó, bạn đã thấy công thức này về cách tạo khả năng hiểu danh sách

>>>

new_list = [expression for member in iterable]

Mặc dù công thức này chính xác nhưng nó cũng hơi thiếu sót. Một mô tả đầy đủ hơn về công thức hiểu thêm hỗ trợ cho các điều kiện tùy chọn. Cách phổ biến nhất để thêm logic điều kiện vào khả năng hiểu danh sách là thêm điều kiện vào cuối biểu thức

>>>

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Ở đây, câu điều kiện của bạn xuất hiện ngay trước dấu ngoặc đóng

Các điều kiện rất quan trọng vì chúng cho phép hiểu danh sách để lọc ra các giá trị không mong muốn, thông thường sẽ yêu cầu gọi tới

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>>

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Trong khối mã này, câu lệnh điều kiện lọc ra bất kỳ ký tự nào trong

new_list = [expression for member in iterable]

Điều kiện có thể kiểm tra bất kỳ biểu thức hợp lệ nào. Nếu bạn cần một bộ lọc phức tạp hơn, thì bạn thậm chí có thể chuyển logic điều kiện sang một chức năng riêng biệt

>>>

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Tại đây, bạn tạo một bộ lọc phức tạp

new_list = [expression for member in iterable]

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Bạn có thể đặt điều kiện ở cuối câu lệnh để lọc đơn giản, nhưng nếu bạn muốn thay đổi giá trị thành phần thay vì lọc ra thì sao?

>>>

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Với công thức này, bạn có thể sử dụng logic có điều kiện để chọn từ nhiều tùy chọn đầu ra có thể. Ví dụ: nếu bạn có một danh sách giá, thì bạn có thể muốn thay thế giá âm bằng

new_list = [expression for member in iterable]

>>>

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Ở đây, biểu thức của bạn

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

new_list = [expression for member in iterable]

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

new_list = [expression for member in iterable]

>>>

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Bây giờ, câu lệnh điều kiện của bạn được chứa trong

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Sử dụng cách hiểu tập hợp và từ điển

Mặc dù khả năng hiểu danh sách trong Python là một công cụ phổ biến, nhưng bạn cũng có thể tạo khả năng hiểu bộ và từ điển. Khả năng hiểu tập hợp gần giống hệt như khả năng hiểu danh sách trong Python. Sự khác biệt là thiết lập mức độ hiểu đảm bảo đầu ra không chứa bản sao. Bạn có thể tạo khả năng hiểu tập hợp bằng cách sử dụng dấu ngoặc nhọn thay vì dấu ngoặc

>>>

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Khả năng hiểu tập hợp của bạn đưa ra tất cả các nguyên âm duy nhất mà nó tìm thấy trong

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Việc hiểu từ điển cũng tương tự, với yêu cầu bổ sung là xác định khóa

>>>

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Để tạo từ điển

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Sử dụng toán tử Walrus

Trăn 3. 8 sẽ giới thiệu biểu thức gán hay còn gọi là toán tử hải mã. Để hiểu cách bạn có thể sử dụng nó, hãy xem xét ví dụ sau

Giả sử bạn cần thực hiện 10 yêu cầu đối với API sẽ trả về dữ liệu nhiệt độ. Bạn chỉ muốn trả lại kết quả lớn hơn 100 độ F. Giả sử rằng mỗi yêu cầu sẽ trả về dữ liệu khác nhau. Trong trường hợp này, không có cách nào sử dụng khả năng hiểu danh sách trong Python để giải quyết vấn đề. Công thức

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Toán tử hải mã giải quyết vấn đề này. Nó cho phép bạn chạy một biểu thức đồng thời gán giá trị đầu ra cho một biến. Ví dụ sau đây cho thấy điều này có thể thực hiện được như thế nào, sử dụng

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>>

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Bạn sẽ không thường xuyên cần sử dụng biểu thức gán bên trong phần hiểu danh sách trong Python, nhưng đó là một công cụ hữu ích để bạn sử dụng khi cần thiết

Coi chừng hiểu lồng nhau

Khả năng hiểu có thể được lồng vào nhau để tạo các tổ hợp danh sách, từ điển và bộ trong một bộ sưu tập. Ví dụ: giả sử một phòng thí nghiệm khí hậu đang theo dõi nhiệt độ cao ở năm thành phố khác nhau trong tuần đầu tiên của tháng Sáu. Cấu trúc dữ liệu hoàn hảo để lưu trữ dữ liệu này có thể là cách hiểu danh sách Python được lồng trong cách hiểu từ điển

>>>

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Bạn tạo bộ sưu tập bên ngoài

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Danh sách lồng nhau là một cách phổ biến để tạo ma trận, thường được sử dụng cho mục đích toán học. Hãy nhìn vào khối mã dưới đây

>>>

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Khả năng hiểu danh sách bên ngoài

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Cho đến nay, mục đích của mỗi cách hiểu lồng nhau là khá trực quan. Tuy nhiên, có những tình huống khác, chẳng hạn như làm phẳng các danh sách lồng nhau, trong đó logic được cho là khiến mã của bạn trở nên khó hiểu hơn. Lấy ví dụ này, sử dụng cách hiểu danh sách lồng nhau để làm phẳng ma trận

>>>

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Mã để làm phẳng ma trận ngắn gọn nhưng có thể không trực quan để hiểu cách thức hoạt động của nó. Mặt khác, nếu bạn sử dụng vòng lặp

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>>

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Bây giờ bạn có thể thấy rằng mã đi qua một hàng của ma trận tại một thời điểm, lấy ra tất cả các phần tử trong hàng đó trước khi chuyển sang hàng tiếp theo

Mặc dù cách hiểu danh sách lồng nhau một dòng có vẻ giống Pythonic hơn, nhưng điều quan trọng nhất là viết mã mà nhóm của bạn có thể dễ dàng hiểu và sửa đổi. Khi bạn chọn cách tiếp cận của mình, bạn sẽ phải đưa ra quyết định dựa trên việc bạn nghĩ rằng khả năng hiểu giúp ích hay làm tổn hại khả năng đọc

Chọn Trình tạo cho Bộ dữ liệu lớn

Khả năng hiểu danh sách trong Python hoạt động bằng cách tải toàn bộ danh sách đầu ra vào bộ nhớ. Đối với các danh sách nhỏ hoặc thậm chí có kích thước trung bình, điều này thường ổn. Nếu bạn muốn tính tổng bình phương của một nghìn số nguyên đầu tiên, thì việc hiểu danh sách sẽ giải quyết vấn đề này một cách đáng ngưỡng mộ

>>>

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Nhưng nếu bạn muốn tính tổng bình phương của một tỷ số nguyên đầu tiên thì sao? . Đó là bởi vì Python đang cố gắng tạo một danh sách với một tỷ số nguyên, tiêu tốn nhiều bộ nhớ hơn so với máy tính của bạn muốn. Máy tính của bạn có thể không có tài nguyên cần thiết để tạo một danh sách khổng lồ và lưu trữ nó trong bộ nhớ. Nếu bạn vẫn cố làm thì máy của bạn có thể chạy chậm hoặc thậm chí bị hỏng

Khi kích thước của danh sách trở nên có vấn đề, việc sử dụng trình tạo thay vì hiểu danh sách trong Python thường hữu ích. Trình tạo không tạo một cấu trúc dữ liệu lớn, duy nhất trong bộ nhớ mà thay vào đó trả về một cấu trúc có thể lặp lại. Mã của bạn có thể yêu cầu giá trị tiếp theo từ khả năng lặp lại nhiều lần nếu cần hoặc cho đến khi bạn đi đến cuối chuỗi của mình, trong khi chỉ lưu trữ một giá trị tại một thời điểm

Nếu bạn tính tổng một tỷ ô vuông đầu tiên bằng một trình tạo, thì chương trình của bạn có thể sẽ chạy trong một thời gian, nhưng nó sẽ không khiến máy tính của bạn bị treo. Ví dụ dưới đây sử dụng một trình tạo

>>>

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Bạn có thể biết đây là trình tạo vì biểu thức không được bao quanh bởi dấu ngoặc hoặc dấu ngoặc nhọn. Tùy chọn, các trình tạo có thể được bao quanh bởi dấu ngoặc đơn

Ví dụ trên vẫn đòi hỏi nhiều công việc, nhưng nó thực hiện các thao tác một cách lười biếng. Do lười đánh giá, các giá trị chỉ được tính khi chúng được yêu cầu rõ ràng. Sau khi trình tạo tạo ra một giá trị (ví dụ:

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>>

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Tùy thuộc vào việc bạn thích biểu thức trình tạo hay

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Hồ sơ để tối ưu hóa hiệu suất

Vì vậy, cách tiếp cận nào nhanh hơn? . Nếu không, thì tốt nhất là chọn bất kỳ cách tiếp cận nào dẫn đến mã sạch nhất

Nếu bạn đang ở trong một tình huống mà hiệu suất là quan trọng, thì tốt nhất bạn nên lập hồ sơ các cách tiếp cận khác nhau và lắng nghe dữ liệu.

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>>

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Tại đây, bạn xác định ba phương thức, mỗi phương thức sử dụng một cách tiếp cận khác nhau để tạo danh sách. Sau đó, bạn yêu cầu

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Như mã chứng minh, sự khác biệt lớn nhất là giữa cách tiếp cận dựa trên vòng lặp và

>>> squares = [i * i for i in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]