Làm phẳng python tuple lồng nhau

Trong hướng dẫn này, chúng ta sẽ xem cách làm phẳng danh sách các bộ dữ liệu trong Python thành một danh sách duy nhất thông qua một số ví dụ

Làm thế nào để làm phẳng một danh sách các bộ dữ liệu?

Làm phẳng python tuple lồng nhau
Làm phẳng python tuple lồng nhau

Có một số cách để làm phẳng danh sách các bộ dữ liệu trong python. Bạn có thể sử dụng tính năng hiểu danh sách, thư viện

print('one')
print('two')

if x == 1:
    print('one')

cond1 = <complex comparison>
cond2 = <other complex comparison>
if cond1 and cond2:
    # do something
6 hoặc chỉ cần lặp qua danh sách các bộ dữ liệu thêm từng mục vào danh sách riêng, v.v. Hãy xem chúng hoạt động thông qua các ví dụ, sau đó là đánh giá thời gian chạy của từng

1. Phương pháp ngây thơ - Lặp lại danh sách các bộ dữ liệu

Ở đây, chúng tôi lặp qua từng mục của tất cả các bộ trong một vòng lặp lồng nhau và nối chúng vào một danh sách riêng

# list of tuples
ls = [('a','b','c'),('d','e','f'),('g','h','i')]
 
# iterate through list of tuples in a nested loop
flat_ls = []
for tup in ls:
    for item in tup:
        flat_ls.append(item)

# display the lists
print("Original list:", ls)
print("Flattened list:", flat_ls)

đầu ra

Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']] 
Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']

Trong ví dụ trên, vòng lặp bên ngoài lặp qua tất cả các bộ trong khi vòng lặp bên trong lặp qua từng mục của bộ bổ sung nó vào danh sách

print('one')
print('two')

if x == 1:
    print('one')

cond1 = <complex comparison>
cond2 = <other complex comparison>
if cond1 and cond2:
    # do something
7

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

Về cơ bản, bạn cũng có thể sử dụng cách hiểu danh sách để làm điều tương tự như trong bước trước nhưng với khả năng đọc tốt hơn và thực thi nhanh hơn

# list of tuples
ls = [('a','b','c'),('d','e','f'),('g','h','i')]

# flatten using list comprehension
flat_ls = [item for tup in ls for item in tup]
 
# print
print("Original list:", ls)
print("Flattened list:", flat_ls)

đầu ra

Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']]
Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']

Ở đây, chúng tôi sử dụng khả năng hiểu danh sách để tạo danh sách phẳng bằng cách giữ từng mục của từng bộ trong danh sách gốc. Sử dụng khả năng hiểu danh sách tương tự như vòng lặp lồng nhau nhưng có khả năng đọc tốt hơn (trong trường hợp sử dụng này)

3. Sử dụng thư viện print('one') print('two') if x == 1: print('one') cond1 = cond2 = if cond1 and cond2: # do something 6 để làm phẳng danh sách các bộ dữ liệu

Thư viện chuẩn

print('one')
print('two')

if x == 1:
    print('one')

cond1 = <complex comparison>
cond2 = <other complex comparison>
if cond1 and cond2:
    # do something
6 của python cung cấp các chức năng tiện dụng để làm việc với các lần lặp. Ở đây, chúng tôi chia danh sách các bộ dữ liệu thành các phần riêng lẻ và sau đó xâu chuỗi chúng lại với nhau thành một bộ lặp duy nhất

import itertools

# list of tuples
ls = [('a','b','c'),('d','e','f'),('g','h','i')]
 
# using itertools
flat_ls = list(itertools.chain(*ls))
 
# print
print("Original list:", ls)
print("Flattened list:", flat_ls)

đầu ra

Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']]
Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']

Chúng tôi nhận được danh sách phẳng kết quả với tất cả các phần tử từ mỗi bộ

Bạn cũng có thể quan tâm đến -

  • Python – Làm phẳng danh sách các danh sách thành một danh sách
  • Chuyển đổi Tuple thành Set trong Python – Với các ví dụ
  • Chuyển đổi Tuple thành Danh sách trong Python – Với các ví dụ


Đăng ký nhận bản tin của chúng tôi để biết thêm thông tin và hướng dẫn.
Chúng tôi không gửi thư rác và bạn có thể chọn không tham gia bất kỳ lúc nào.


Tác giả

  • Làm phẳng python tuple lồng nhau
    Làm phẳng python tuple lồng nhau

    Piyush Raj

    Piyush là một chuyên gia dữ liệu đam mê sử dụng dữ liệu để hiểu mọi thứ tốt hơn và đưa ra quyết định sáng suốt. Trước đây, anh ấy từng là Nhà khoa học dữ liệu cho ZS và có bằng kỹ sư của IIT Roorkee. Sở thích của anh ấy bao gồm xem cricket, đọc sách và làm việc trong các dự án phụ

    Trong cả hai chức năng, mỗi phần tử được kiểm tra là một danh sách, bộ hoặc tập hợp. Nếu đúng, thì hàm làm phẳng được gọi đệ quy cho đến khi phần tử cuối cùng chỉ đơn giản là một mục. Mục này được trả lại và thêm vào danh sách giá trị tuyến tính cuối cùng. Nếu chúng ta không thực hiện đệ quy, thì chức năng làm phẳng sẽ dừng ở một độ sâu nhất định

    Nếu bạn hỏi các lập trình viên Python rằng họ thích điều gì nhất ở Python, họ thường sẽ trích dẫn khả năng đọc cao của nó. Thật vậy, mức độ dễ đọc cao là trọng tâm của thiết kế ngôn ngữ Python, theo một thực tế đã được công nhận là mã được đọc thường xuyên hơn nhiều so với mã được viết.

    Một lý do khiến mã Python có khả năng đọc cao là bộ hướng dẫn Kiểu mã và thành ngữ “Pythonic” tương đối hoàn chỉnh của nó.

    Khi một nhà phát triển Python kỳ cựu (một Pythonista) gọi các phần mã không phải là “Pythonic”, điều đó thường có nghĩa là những dòng mã này không tuân theo các nguyên tắc chung và không thể hiện ý định của nó theo cách được coi là tốt nhất (hãy nghe. cách dễ đọc nhất)

    Trong một số trường hợp biên giới, không có cách tốt nhất nào được thống nhất về cách thể hiện ý định trong mã Python, nhưng những trường hợp này rất hiếm

    Khái niệm chung¶

    Mã rõ ràng¶

    Mặc dù bất kỳ loại ma thuật đen nào cũng có thể thực hiện được với Python, nhưng cách rõ ràng và đơn giản nhất được ưu tiên hơn

    Xấu

    def make_complex(*args):
        x, y = args
        return dict(**locals())
    

    Tốt

    def make_complex(x, y):
        return {'x': x, 'y': y}
    

    Trong đoạn mã tốt ở trên, x và y được nhận rõ ràng từ người gọi và một từ điển rõ ràng được trả về. Nhà phát triển sử dụng chức năng này biết chính xác phải làm gì bằng cách đọc dòng đầu tiên và dòng cuối cùng, điều này không xảy ra với ví dụ xấu

    Một câu lệnh trên mỗi dòng¶

    Mặc dù một số câu lệnh phức hợp như khả năng hiểu danh sách được cho phép và đánh giá cao về tính ngắn gọn và tính biểu cảm của chúng, nhưng thực tế không tốt khi có hai câu lệnh rời rạc trên cùng một dòng mã

    Xấu

    ________số 8

    Tốt

    print('one')
    print('two')
    
    if x == 1:
        print('one')
    
    cond1 = <complex comparison>
    cond2 = <other complex comparison>
    if cond1 and cond2:
        # do something
    

    Đối số hàm¶

    Các đối số có thể được chuyển đến các hàm theo bốn cách khác nhau

    1. Đối số vị trí là bắt buộc và không có giá trị mặc định. Chúng là dạng đối số đơn giản nhất và chúng có thể được sử dụng cho một vài đối số hàm hoàn toàn là một phần ý nghĩa của hàm và thứ tự của chúng là tự nhiên. Chẳng hạn, trong
      Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']] 
      Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
      03 hoặc
      Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']] 
      Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
      04, người dùng hàm dễ dàng ghi nhớ rằng hai hàm đó yêu cầu hai đối số và theo thứ tự nào

    Trong hai trường hợp đó, có thể sử dụng tên đối số khi gọi các hàm và, làm như vậy, có thể chuyển đổi thứ tự của các đối số, gọi ví dụ

    Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']] 
    Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
    05 và
    Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']] 
    Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
    06 nhưng điều này làm giảm khả năng đọc và dài dòng không cần thiết, so với nhiều hơn

    1. Đối số từ khóa không bắt buộc và có giá trị mặc định. Chúng thường được sử dụng cho các tham số tùy chọn được gửi đến hàm. Khi một hàm có nhiều hơn hai hoặc ba tham số vị trí, chữ ký của nó sẽ khó nhớ hơn và việc sử dụng các đối số từ khóa với các giá trị mặc định sẽ hữu ích. Chẳng hạn, một hàm
      Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']] 
      Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
      09 hoàn chỉnh hơn có thể được định nghĩa là
      Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']] 
      Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
      70. Ở đây
      Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']] 
      Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
      71 và
      Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']] 
      Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
      72 là tùy chọn và đánh giá thành
      Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']] 
      Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
      73 khi chúng không được truyền một giá trị khác

    Gọi một hàm với các đối số từ khóa có thể được thực hiện theo nhiều cách trong Python; . Cũng có thể đặt tên cho các đối số theo thứ tự khác, như trong

    Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']] 
    Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
    75. Tốt hơn hết là nên tránh hai khả năng đó mà không có bất kỳ lý do chính đáng nào để không tuân theo cú pháp gần nhất với định nghĩa hàm.
    Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']] 
    Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
    76

    Lưu ý thêm, theo nguyên tắc YAGNI, thường khó loại bỏ một đối số tùy chọn (và logic của nó bên trong hàm) đã được thêm vào “chỉ trong trường hợp” và dường như không bao giờ được sử dụng, hơn là thêm một đối số tùy chọn mới và đối số của nó.

    1. Danh sách đối số tùy ý là cách thứ ba để truyền đối số cho hàm. Nếu ý định chức năng được thể hiện tốt hơn bằng chữ ký với số lượng đối số vị trí có thể mở rộng, thì nó có thể được xác định bằng cấu trúc
      Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']] 
      Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
      77. Trong thân hàm,
      Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']] 
      Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
      78 sẽ là một bộ của tất cả các đối số vị trí còn lại. Ví dụ: có thể gọi
      Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']] 
      Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
      79 với mỗi người nhận làm đối số.
      # list of tuples
      ls = [('a','b','c'),('d','e','f'),('g','h','i')]
      
      # flatten using list comprehension
      flat_ls = [item for tup in ls for item in tup]
       
      # print
      print("Original list:", ls)
      print("Flattened list:", flat_ls)
      70, và trong thân hàm
      Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']] 
      Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
      78 sẽ bằng với
      # list of tuples
      ls = [('a','b','c'),('d','e','f'),('g','h','i')]
      
      # flatten using list comprehension
      flat_ls = [item for tup in ls for item in tup]
       
      # print
      print("Original list:", ls)
      print("Flattened list:", flat_ls)
      72

    Tuy nhiên, cấu trúc này có một số nhược điểm và nên thận trọng khi sử dụng. Nếu một hàm nhận được một danh sách các đối số có cùng bản chất, thì sẽ rõ ràng hơn nếu định nghĩa nó là một hàm của một đối số, đối số đó là một danh sách hoặc bất kỳ chuỗi nào. Ở đây, nếu

    Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']] 
    Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
    09 có nhiều người nhận, tốt hơn là nên xác định rõ ràng.
    # list of tuples
    ls = [('a','b','c'),('d','e','f'),('g','h','i')]
    
    # flatten using list comprehension
    flat_ls = [item for tup in ls for item in tup]
     
    # print
    print("Original list:", ls)
    print("Flattened list:", flat_ls)
    74 và gọi nó bằng
    # list of tuples
    ls = [('a','b','c'),('d','e','f'),('g','h','i')]
    
    # flatten using list comprehension
    flat_ls = [item for tup in ls for item in tup]
     
    # print
    print("Original list:", ls)
    print("Flattened list:", flat_ls)
    75. Bằng cách này, người dùng hàm có thể thao tác trước danh sách người nhận dưới dạng danh sách và nó mở ra khả năng chuyển bất kỳ chuỗi nào, bao gồm cả trình vòng lặp, không thể giải nén như các chuỗi khác

    1. Từ điển đối số từ khóa tùy ý là cách cuối cùng để truyền đối số cho hàm. Nếu hàm yêu cầu một loạt các đối số được đặt tên không xác định, thì có thể sử dụng cấu trúc
      # list of tuples
      ls = [('a','b','c'),('d','e','f'),('g','h','i')]
      
      # flatten using list comprehension
      flat_ls = [item for tup in ls for item in tup]
       
      # print
      print("Original list:", ls)
      print("Flattened list:", flat_ls)
      76. Trong thân hàm,
      # list of tuples
      ls = [('a','b','c'),('d','e','f'),('g','h','i')]
      
      # flatten using list comprehension
      flat_ls = [item for tup in ls for item in tup]
       
      # print
      print("Original list:", ls)
      print("Flattened list:", flat_ls)
      77 sẽ là một từ điển chứa tất cả các đối số được đặt tên đã truyền mà không bị bắt bởi các đối số từ khóa khác trong chữ ký hàm

    Thận trọng giống như trong trường hợp danh sách đối số tùy ý là cần thiết, vì những lý do tương tự. những kỹ thuật mạnh mẽ này sẽ được sử dụng khi có sự cần thiết đã được chứng minh để sử dụng chúng và chúng không nên được sử dụng nếu cấu trúc đơn giản và rõ ràng hơn là đủ để thể hiện ý định của chức năng

    Việc lập trình viên viết hàm quyết định xem đối số nào là đối số vị trí và đối số nào là đối số từ khóa tùy chọn, đồng thời quyết định có sử dụng các kỹ thuật nâng cao của việc truyền đối số tùy ý hay không. Nếu lời khuyên ở trên được làm theo một cách khôn ngoan, thì việc viết các hàm Python

    • dễ đọc (tên và đối số không cần giải thích)
    • dễ thay đổi (thêm đối số từ khóa mới không phá vỡ các phần khác của mã)

    Tránh cây đũa thần¶

    Một công cụ mạnh mẽ dành cho tin tặc, Python đi kèm với một bộ móc và công cụ rất phong phú cho phép bạn thực hiện hầu hết mọi loại thủ thuật phức tạp. Chẳng hạn, có thể thực hiện từng điều sau đây

    • thay đổi cách các đối tượng được tạo và khởi tạo
    • thay đổi cách trình thông dịch Python nhập các mô-đun
    • Thậm chí có thể (và được khuyến nghị nếu cần) để nhúng các thói quen C trong Python

    Tuy nhiên, tất cả các tùy chọn này đều có nhiều nhược điểm và tốt hơn hết là sử dụng cách đơn giản nhất để đạt được mục tiêu của bạn. Hạn chế chính là khả năng đọc bị ảnh hưởng rất nhiều khi sử dụng các cấu trúc này. Nhiều công cụ phân tích mã, chẳng hạn như pylint hoặc pyflakes, sẽ không thể phân tích mã "ma thuật" này

    Chúng tôi cho rằng một nhà phát triển Python nên biết về những khả năng gần như vô tận này, bởi vì điều đó giúp tạo niềm tin rằng sẽ không có vấn đề nan giải nào xảy ra. Tuy nhiên, biết cách và đặc biệt khi nào không sử dụng chúng là rất quan trọng.

    Giống như một bậc thầy kung fu, một Pythonista biết cách giết người chỉ bằng một ngón tay và không bao giờ thực sự làm điều đó

    Tất cả chúng ta đều là những người dùng có trách nhiệm¶

    Như đã thấy ở trên, Python cho phép nhiều thủ thuật và một số trong số chúng có khả năng gây nguy hiểm. Một ví dụ điển hình là bất kỳ mã máy khách nào cũng có thể ghi đè lên các thuộc tính và phương thức của đối tượng. không có từ khóa “riêng tư” trong Python. Triết lý này, rất khác với các ngôn ngữ phòng thủ cao như Java, vốn đưa ra rất nhiều cơ chế để ngăn chặn bất kỳ hành vi lạm dụng nào, được thể hiện bằng câu nói. “Tất cả chúng ta đều là những người dùng có trách nhiệm”

    Điều này không có nghĩa là, chẳng hạn, không có thuộc tính nào được coi là riêng tư và không thể đóng gói thích hợp trong Python. Thay vào đó, thay vì dựa vào những bức tường bê tông do các nhà phát triển dựng lên giữa mã của họ và của những người khác, cộng đồng Python thích dựa vào một tập hợp các quy ước chỉ ra rằng những phần tử này không nên được truy cập trực tiếp

    Quy ước chính cho các thuộc tính riêng tư và chi tiết triển khai là thêm tiền tố vào tất cả các "nội bộ" bằng dấu gạch dưới. Nếu mã máy khách vi phạm quy tắc này và truy cập các phần tử được đánh dấu này, thì bất kỳ hành vi sai trái hoặc sự cố nào gặp phải nếu mã bị sửa đổi đều thuộc trách nhiệm của mã máy khách

    Sử dụng quy ước này một cách hào phóng được khuyến khích. bất kỳ phương thức hoặc thuộc tính nào không được sử dụng bởi mã máy khách phải được thêm tiền tố bằng dấu gạch dưới. Điều này sẽ đảm bảo phân chia nhiệm vụ tốt hơn và sửa đổi mã hiện có dễ dàng hơn;

    Giá trị trả về¶

    Khi một hàm trở nên phức tạp hơn, việc sử dụng nhiều câu lệnh trả về bên trong phần thân của hàm là điều bình thường. Tuy nhiên, để giữ mục đích rõ ràng và mức độ dễ đọc bền vững, tốt nhất là tránh trả về các giá trị có ý nghĩa từ nhiều điểm đầu ra trong nội dung

    Có hai trường hợp chính để trả về các giá trị trong một hàm. kết quả của hàm trả về khi nó đã được xử lý bình thường và các trường hợp lỗi do nhập sai tham số hoặc bất kỳ lý do nào khác khiến hàm không thể hoàn thành tính toán hoặc tác vụ của mình

    Nếu bạn không muốn đưa ra ngoại lệ cho trường hợp thứ hai, thì việc trả về một giá trị, chẳng hạn như Không có hoặc Sai, cho biết rằng có thể cần phải thực hiện đúng chức năng. Trong trường hợp này, tốt hơn hết là bạn nên quay lại ngay khi phát hiện thấy ngữ cảnh không chính xác. Nó sẽ giúp làm phẳng cấu trúc của hàm. tất cả mã sau câu lệnh trả về do lỗi có thể cho rằng điều kiện được đáp ứng để tính toán thêm kết quả chính của hàm. Có nhiều câu trả lời như vậy thường là cần thiết

    Tuy nhiên, khi một hàm có nhiều điểm thoát chính cho quá trình bình thường của nó, thì việc gỡ lỗi kết quả trả về sẽ trở nên khó khăn, do đó, tốt hơn là nên giữ một điểm thoát duy nhất. Điều này cũng sẽ giúp xác định một số đường dẫn mã và nhiều điểm thoát là một dấu hiệu có thể xảy ra rằng việc tái cấu trúc như vậy là cần thiết

    Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']] 
    Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
    0

    Thành ngữ¶

    Một thành ngữ lập trình, nói một cách đơn giản, là một cách để viết mã. Khái niệm về thành ngữ lập trình được thảo luận rộng rãi tại c2 và tại Stack Overflow

    Mã Python thành ngữ thường được gọi là Pythonic

    Mặc dù thường có một — và tốt nhất là chỉ một — cách rõ ràng để làm điều đó; . Vì vậy, thành ngữ tốt phải được tiếp thu một cách có ý thức

    Một số thành ngữ Python phổ biến sau

    Giải nén¶

    Nếu bạn biết độ dài của danh sách hoặc bộ, bạn có thể gán tên cho các thành phần của nó bằng cách giải nén. Ví dụ: vì

    # list of tuples
    ls = [('a','b','c'),('d','e','f'),('g','h','i')]
    
    # flatten using list comprehension
    flat_ls = [item for tup in ls for item in tup]
     
    # print
    print("Original list:", ls)
    print("Flattened list:", flat_ls)
    78 sẽ cung cấp một bộ gồm hai phần tử cho mỗi mục trong danh sách

    Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']] 
    Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
    7

    Bạn cũng có thể sử dụng điều này để trao đổi các biến

    # list of tuples
    ls = [('a','b','c'),('d','e','f'),('g','h','i')]
    
    # flatten using list comprehension
    flat_ls = [item for tup in ls for item in tup]
     
    # print
    print("Original list:", ls)
    print("Flattened list:", flat_ls)
    7

    Giải nén lồng nhau cũng hoạt động

    Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']]
    Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
    9

    Trong Python 3, PEP 3132 đã giới thiệu một phương pháp giải nén mở rộng mới

    import itertools
    
    # list of tuples
    ls = [('a','b','c'),('d','e','f'),('g','h','i')]
     
    # using itertools
    flat_ls = list(itertools.chain(*ls))
     
    # print
    print("Original list:", ls)
    print("Flattened list:", flat_ls)
    0

    Tạo một biến bị bỏ qua¶

    Nếu bạn cần gán thứ gì đó (ví dụ: trong Unpacking ) nhưng không cần biến đó, hãy sử dụng

    # list of tuples
    ls = [('a','b','c'),('d','e','f'),('g','h','i')]
    
    # flatten using list comprehension
    flat_ls = [item for tup in ls for item in tup]
     
    # print
    print("Original list:", ls)
    print("Flattened list:", flat_ls)
    79.

    import itertools
    
    # list of tuples
    ls = [('a','b','c'),('d','e','f'),('g','h','i')]
     
    # using itertools
    flat_ls = list(itertools.chain(*ls))
     
    # print
    print("Original list:", ls)
    print("Flattened list:", flat_ls)
    2

    Ghi chú

    Nhiều hướng dẫn về phong cách Python khuyên bạn nên sử dụng một dấu gạch dưới “

    Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']]
    Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
    90” cho các biến bỏ đi thay vì dấu gạch dưới kép “
    # list of tuples
    ls = [('a','b','c'),('d','e','f'),('g','h','i')]
    
    # flatten using list comprehension
    flat_ls = [item for tup in ls for item in tup]
     
    # print
    print("Original list:", ls)
    print("Flattened list:", flat_ls)
    79” được khuyến nghị tại đây. Vấn đề là “
    Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']]
    Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
    90” thường được sử dụng làm bí danh cho hàm
    Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']]
    Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
    93 và cũng được sử dụng tại dấu nhắc tương tác để giữ giá trị của thao tác cuối cùng. Thay vào đó, sử dụng dấu gạch dưới kép cũng rõ ràng và gần như thuận tiện, đồng thời loại bỏ nguy cơ vô tình can thiệp vào một trong hai trường hợp sử dụng khác này

    Tạo một danh sách dài-N của cùng một thứ¶

    Sử dụng danh sách Python toán tử

    Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']]
    Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
    94

    def make_complex(x, y):
        return {'x': x, 'y': y}
    
    0

    Tạo danh sách dài-N danh sách¶

    Vì các danh sách có thể thay đổi, nên toán tử

    Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']]
    Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
    94 (như trên) sẽ tạo một danh sách gồm N tham chiếu đến cùng một danh sách, đây không phải là điều bạn muốn. Thay vào đó, hãy sử dụng cách hiểu danh sách

    def make_complex(x, y):
        return {'x': x, 'y': y}
    
    1

    Tạo một chuỗi từ một danh sách¶

    Một thành ngữ phổ biến để tạo chuỗi là sử dụng

    Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']]
    Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
    96 trên một chuỗi trống

    def make_complex(x, y):
        return {'x': x, 'y': y}
    
    2

    Điều này sẽ đặt giá trị của từ biến thành 'thư rác'. Thành ngữ này có thể được áp dụng cho danh sách và bộ dữ liệu

    Tìm kiếm một mục trong bộ sưu tập¶

    Đôi khi chúng ta cần tìm kiếm thông qua một bộ sưu tập các thứ. Hãy xem xét hai lựa chọn. danh sách và bộ

    Lấy đoạn mã sau làm ví dụ

    def make_complex(x, y):
        return {'x': x, 'y': y}
    
    3

    Mặc dù cả hai chức năng trông giống hệt nhau, bởi vì lookup_set đang sử dụng thực tế là các bộ trong Python là các bảng băm, nên hiệu suất tra cứu giữa hai chức năng này rất khác nhau. Để xác định xem một mục có trong danh sách hay không, Python sẽ phải duyệt qua từng mục cho đến khi tìm thấy mục phù hợp. Điều này tốn thời gian, đặc biệt là đối với các danh sách dài. Mặt khác, trong một tập hợp, hàm băm của mục sẽ cho Python biết vị trí trong tập hợp để tìm một mục phù hợp. Kết quả là, việc tìm kiếm có thể được thực hiện nhanh chóng, ngay cả khi tập hợp lớn. Tìm kiếm trong từ điển hoạt động theo cùng một cách. Để biết thêm thông tin, hãy xem trang StackOverflow này. Để biết thông tin chi tiết về lượng thời gian các hoạt động chung khác nhau thực hiện trên từng cấu trúc dữ liệu này, hãy xem trang này

    Do những khác biệt về hiệu suất này, nên sử dụng bộ hoặc từ điển thay vì danh sách trong trường hợp

    • Bộ sưu tập sẽ chứa một số lượng lớn các mặt hàng
    • Bạn sẽ liên tục tìm kiếm các mục trong bộ sưu tập
    • Bạn không có mục trùng lặp

    Đối với các bộ sưu tập nhỏ hoặc các bộ sưu tập mà bạn sẽ không thường xuyên tìm kiếm, thời gian và bộ nhớ bổ sung cần thiết để thiết lập bảng băm thường sẽ lớn hơn thời gian tiết kiệm được nhờ tốc độ tìm kiếm được cải thiện

    Thiền của Python¶

    Còn được gọi là PEP 20, các nguyên tắc hướng dẫn cho thiết kế của Python

    def make_complex(x, y):
        return {'x': x, 'y': y}
    
    4

    Để biết một số ví dụ về phong cách Python tốt, hãy xem các trang trình bày này từ nhóm người dùng Python

    PEP 8¶

    PEP 8 là hướng dẫn kiểu mã thực tế cho Python. Phiên bản PEP 8 chất lượng cao, dễ đọc cũng có sẵn tại pep8. tổ chức

    Đây là rất khuyến khích đọc. Toàn bộ cộng đồng Python cố gắng hết sức để tuân thủ các nguyên tắc được nêu trong tài liệu này. Một số dự án có thể thay đổi theo thời gian, trong khi những dự án khác có thể sửa đổi các khuyến nghị của nó

    Nói như vậy, việc tuân thủ mã Python của bạn theo PEP 8 nói chung là một ý tưởng hay và giúp làm cho mã nhất quán hơn khi làm việc trên các dự án với các nhà phát triển khác. Có một chương trình dòng lệnh, pycodestyle (trước đây gọi là

    Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']]
    Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
    97), có thể kiểm tra sự tuân thủ của mã của bạn. Cài đặt nó bằng cách chạy lệnh sau trong thiết bị đầu cuối của bạn

    def make_complex(x, y):
        return {'x': x, 'y': y}
    
    5

    Sau đó chạy nó trên một tệp hoặc một loạt tệp để nhận báo cáo về bất kỳ vi phạm nào

    def make_complex(x, y):
        return {'x': x, 'y': y}
    
    6

    Tự động định dạng¶

    Có một số công cụ định dạng tự động có thể định dạng lại mã của bạn để tuân thủ PEP 8

    autopep8

    Chương trình autopep8 có thể được sử dụng để tự động định dạng lại mã theo kiểu PEP 8. Cài đặt chương trình với

    def make_complex(x, y):
        return {'x': x, 'y': y}
    
    7

    Sử dụng nó để định dạng tệp tại chỗ với

    def make_complex(x, y):
        return {'x': x, 'y': y}
    
    8

    Việc loại trừ cờ

    Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']]
    Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
    98 sẽ khiến chương trình xuất trực tiếp mã đã sửa đổi ra bàn điều khiển để xem xét. Cờ
    Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']]
    Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
    99 sẽ thực hiện nhiều thay đổi quan trọng hơn và có thể được áp dụng nhiều lần để có hiệu quả cao hơn

    yapf

    Trong khi autopep8 tập trung vào việc giải quyết các vi phạm PEP 8, yapf cố gắng cải thiện định dạng mã của bạn ngoài việc tuân thủ PEP 8. Trình định dạng này nhằm mục đích cung cấp mã đẹp mắt như một lập trình viên viết mã tuân thủ PEP 8. Nó được cài đặt với

    def make_complex(x, y):
        return {'x': x, 'y': y}
    
    9

    Chạy tự động định dạng tệp với

    print('one'); print('two')
    
    if x == 1: print('one')
    
    if <complex comparison> and <other complex comparison>:
        # do something
    
    0

    Tương tự như autopep8, chạy lệnh không có cờ

    Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']]
    Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
    98 sẽ xuất ra khác biệt để xem xét trước khi áp dụng các thay đổi

    đen

    Trình định dạng tự động màu đen cung cấp định dạng lại chắc chắn và cố định cho cơ sở mã của bạn. Trọng tâm chính của nó nằm ở việc cung cấp một kiểu mã thống nhất mà không cần cấu hình cho người dùng của nó. Do đó, người dùng màu đen có thể quên hoàn toàn việc định dạng. Ngoài ra, do cách tiếp cận xác định, git diff tối thiểu chỉ với những thay đổi có liên quan được đảm bảo. Bạn có thể cài đặt công cụ như sau

    print('one'); print('two')
    
    if x == 1: print('one')
    
    if <complex comparison> and <other complex comparison>:
        # do something
    
    1

    Một tệp python có thể được định dạng bằng

    print('one'); print('two')
    
    if x == 1: print('one')
    
    if <complex comparison> and <other complex comparison>:
        # do something
    
    2

    Thêm cờ

    import itertools
    
    # list of tuples
    ls = [('a','b','c'),('d','e','f'),('g','h','i')]
     
    # using itertools
    flat_ls = list(itertools.chain(*ls))
     
    # print
    print("Original list:", ls)
    print("Flattened list:", flat_ls)
    01 cung cấp sửa đổi mã để xem xét mà không cần áp dụng trực tiếp

    Quy ước¶

    Dưới đây là một số quy ước bạn nên tuân theo để làm cho mã của bạn dễ đọc hơn

    Kiểm tra xem một biến có bằng một hằng¶

    Bạn không cần phải so sánh rõ ràng một giá trị với True, hoặc Không có hoặc 0 – bạn chỉ cần thêm nó vào câu lệnh if. Xem Kiểm tra giá trị thật để biết danh sách những gì được coi là sai

    Xấu

    print('one'); print('two')
    
    if x == 1: print('one')
    
    if <complex comparison> and <other complex comparison>:
        # do something
    
    3

    Tốt

    print('one'); print('two')
    
    if x == 1: print('one')
    
    if <complex comparison> and <other complex comparison>:
        # do something
    
    4

    Truy cập một phần tử từ điển¶

    Không sử dụng phương pháp

    import itertools
    
    # list of tuples
    ls = [('a','b','c'),('d','e','f'),('g','h','i')]
     
    # using itertools
    flat_ls = list(itertools.chain(*ls))
     
    # print
    print("Original list:", ls)
    print("Flattened list:", flat_ls)
    02. Thay vào đó, hãy sử dụng cú pháp
    import itertools
    
    # list of tuples
    ls = [('a','b','c'),('d','e','f'),('g','h','i')]
     
    # using itertools
    flat_ls = list(itertools.chain(*ls))
     
    # print
    print("Original list:", ls)
    print("Flattened list:", flat_ls)
    03 hoặc chuyển đối số mặc định cho
    import itertools
    
    # list of tuples
    ls = [('a','b','c'),('d','e','f'),('g','h','i')]
     
    # using itertools
    flat_ls = list(itertools.chain(*ls))
     
    # print
    print("Original list:", ls)
    print("Flattened list:", flat_ls)
    04

    Xấu

    print('one'); print('two')
    
    if x == 1: print('one')
    
    if <complex comparison> and <other complex comparison>:
        # do something
    
    5

    Tốt

    print('one'); print('two')
    
    if x == 1: print('one')
    
    if <complex comparison> and <other complex comparison>:
        # do something
    
    6

    Các cách ngắn để thao tác với danh sách¶

    Khả năng hiểu danh sách cung cấp một cách mạnh mẽ, súc tích để làm việc với danh sách

    Các biểu thức trình tạo tuân theo cú pháp gần giống như việc hiểu danh sách nhưng trả về một trình tạo thay vì một danh sách

    Tạo một danh sách mới đòi hỏi nhiều công việc hơn và sử dụng nhiều bộ nhớ hơn. Nếu bạn chỉ định lặp qua danh sách mới, thay vào đó, hãy sử dụng một trình vòng lặp

    Xấu

    print('one'); print('two')
    
    if x == 1: print('one')
    
    if <complex comparison> and <other complex comparison>:
        # do something
    
    7

    Tốt

    print('one'); print('two')
    
    if x == 1: print('one')
    
    if <complex comparison> and <other complex comparison>:
        # do something
    
    8

    Sử dụng khả năng hiểu danh sách khi bạn thực sự cần tạo danh sách thứ hai, chẳng hạn như nếu bạn cần sử dụng kết quả nhiều lần

    Nếu logic của bạn quá phức tạp đối với biểu thức trình tạo hoặc hiểu danh sách ngắn, hãy cân nhắc sử dụng hàm trình tạo thay vì trả về danh sách

    Tốt

    print('one'); print('two')
    
    if x == 1: print('one')
    
    if <complex comparison> and <other complex comparison>:
        # do something
    
    9

    Không bao giờ sử dụng cách hiểu danh sách chỉ vì tác dụng phụ của nó

    Xấu

    print('one')
    print('two')
    
    if x == 1:
        print('one')
    
    cond1 = <complex comparison>
    cond2 = <other complex comparison>
    if cond1 and cond2:
        # do something
    
    0

    Tốt

    print('one')
    print('two')
    
    if x == 1:
        print('one')
    
    cond1 = <complex comparison>
    cond2 = <other complex comparison>
    if cond1 and cond2:
        # do something
    
    1

    Lọc danh sách¶

    Xấu

    Không bao giờ xóa các mục khỏi danh sách trong khi bạn đang lặp qua nó

    print('one')
    print('two')
    
    if x == 1:
        print('one')
    
    cond1 = <complex comparison>
    cond2 = <other complex comparison>
    if cond1 and cond2:
        # do something
    
    2

    Đừng thực hiện nhiều lần thông qua danh sách

    print('one')
    print('two')
    
    if x == 1:
        print('one')
    
    cond1 = <complex comparison>
    cond2 = <other complex comparison>
    if cond1 and cond2:
        # do something
    
    3

    Tốt

    Sử dụng biểu thức hiểu danh sách hoặc trình tạo

    print('one')
    print('two')
    
    if x == 1:
        print('one')
    
    cond1 = <complex comparison>
    cond2 = <other complex comparison>
    if cond1 and cond2:
        # do something
    
    4

    Các tác dụng phụ có thể xảy ra khi sửa đổi danh sách ban đầu¶

    Việc sửa đổi danh sách ban đầu có thể gặp rủi ro nếu có các biến khác tham chiếu đến nó. Nhưng bạn có thể sử dụng phép gán lát cắt nếu bạn thực sự muốn làm điều đó

    print('one')
    print('two')
    
    if x == 1:
        print('one')
    
    cond1 = <complex comparison>
    cond2 = <other complex comparison>
    if cond1 and cond2:
        # do something
    
    5

    Sửa đổi các giá trị trong một danh sách¶

    Xấu

    Hãy nhớ rằng nhiệm vụ không bao giờ tạo ra một đối tượng mới. Nếu hai hoặc nhiều biến tham chiếu đến cùng một danh sách, việc thay đổi một trong số chúng sẽ thay đổi tất cả

    print('one')
    print('two')
    
    if x == 1:
        print('one')
    
    cond1 = <complex comparison>
    cond2 = <other complex comparison>
    if cond1 and cond2:
        # do something
    
    6

    Tốt

    Sẽ an toàn hơn nếu tạo một đối tượng danh sách mới và để nguyên đối tượng gốc

    print('one')
    print('two')
    
    if x == 1:
        print('one')
    
    cond1 = <complex comparison>
    cond2 = <other complex comparison>
    if cond1 and cond2:
        # do something
    
    7

    Sử dụng

    # list of tuples
    ls = [('a','b','c'),('d','e','f'),('g','h','i')]
    
    # flatten using list comprehension
    flat_ls = [item for tup in ls for item in tup]
     
    # print
    print("Original list:", ls)
    print("Flattened list:", flat_ls)
    78 giữ số lượng vị trí của bạn trong danh sách

    print('one')
    print('two')
    
    if x == 1:
        print('one')
    
    cond1 = <complex comparison>
    cond2 = <other complex comparison>
    if cond1 and cond2:
        # do something
    
    8

    Hàm

    # list of tuples
    ls = [('a','b','c'),('d','e','f'),('g','h','i')]
    
    # flatten using list comprehension
    flat_ls = [item for tup in ls for item in tup]
     
    # print
    print("Original list:", ls)
    print("Flattened list:", flat_ls)
    78 có khả năng đọc tốt hơn so với xử lý bộ đếm theo cách thủ công. Hơn nữa, nó được tối ưu hóa tốt hơn cho các trình vòng lặp

    Đọc từ một tập tin¶

    Sử dụng cú pháp

    import itertools
    
    # list of tuples
    ls = [('a','b','c'),('d','e','f'),('g','h','i')]
     
    # using itertools
    flat_ls = list(itertools.chain(*ls))
     
    # print
    print("Original list:", ls)
    print("Flattened list:", flat_ls)
    07 để đọc từ tệp. Thao tác này sẽ tự động đóng tệp cho bạn

    Xấu

    print('one')
    print('two')
    
    if x == 1:
        print('one')
    
    cond1 = <complex comparison>
    cond2 = <other complex comparison>
    if cond1 and cond2:
        # do something
    
    9

    Tốt

    Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']] 
    Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
    00

    Câu lệnh

    import itertools
    
    # list of tuples
    ls = [('a','b','c'),('d','e','f'),('g','h','i')]
     
    # using itertools
    flat_ls = list(itertools.chain(*ls))
     
    # print
    print("Original list:", ls)
    print("Flattened list:", flat_ls)
    08 tốt hơn vì nó sẽ đảm bảo bạn luôn đóng tệp, ngay cả khi một ngoại lệ được đưa ra bên trong khối
    import itertools
    
    # list of tuples
    ls = [('a','b','c'),('d','e','f'),('g','h','i')]
     
    # using itertools
    flat_ls = list(itertools.chain(*ls))
     
    # print
    print("Original list:", ls)
    print("Flattened list:", flat_ls)
    08

    Dòng tiếp tục¶

    Khi một dòng mã logic dài hơn giới hạn được chấp nhận, bạn cần chia nó thành nhiều dòng vật lý. Trình thông dịch Python sẽ nối các dòng liên tiếp nếu ký tự cuối cùng của dòng là dấu gạch chéo ngược. Điều này hữu ích trong một số trường hợp, nhưng thường nên tránh vì tính dễ vỡ của nó. một khoảng trắng được thêm vào cuối dòng, sau dấu gạch chéo ngược, sẽ phá vỡ mã và có thể có kết quả không mong muốn

    Một giải pháp tốt hơn là sử dụng dấu ngoặc đơn xung quanh các phần tử của bạn. Còn lại với dấu ngoặc đơn không đóng ở cuối dòng, trình thông dịch Python sẽ nối dòng tiếp theo cho đến khi đóng dấu ngoặc đơn. Hành vi tương tự giữ cho dấu ngoặc nhọn và vuông

    Xấu

    Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']] 
    Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
    01

    Tốt

    Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']] 
    Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
    02

    Tuy nhiên, thường thì việc phải chia một dòng logic dài là dấu hiệu cho thấy bạn đang cố gắng làm quá nhiều việc cùng một lúc, điều này có thể cản trở khả năng đọc.