Danh sách tăng python

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

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

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

if <complex comparison> and <other complex comparison>:
    # do something

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
    def complex_function(a, b, c):
        if not a:
            return None  # Raising an exception might be better
        if not b:
            return None  # Raising an exception might be better
        # Some complex code trying to compute x from a, b and c
        # Resist temptation to return x if succeeded
        if not x:
            # Some Plan-B computation of x
        return x  # One single exit point for the returned value x will help
                  # when maintaining the code.
    
    3 hoặc
    def complex_function(a, b, c):
        if not a:
            return None  # Raising an exception might be better
        if not b:
            return None  # Raising an exception might be better
        # Some complex code trying to compute x from a, b and c
        # Resist temptation to return x if succeeded
        if not x:
            # Some Plan-B computation of x
        return x  # One single exit point for the returned value x will help
                  # when maintaining the code.
    
    4, 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ụ

def complex_function(a, b, c):
    if not a:
        return None  # Raising an exception might be better
    if not b:
        return None  # Raising an exception might be better
    # Some complex code trying to compute x from a, b and c
    # Resist temptation to return x if succeeded
    if not x:
        # Some Plan-B computation of x
    return x  # One single exit point for the returned value x will help
              # when maintaining the code.
5 và
def complex_function(a, b, c):
    if not a:
        return None  # Raising an exception might be better
    if not b:
        return None  # Raising an exception might be better
    # Some complex code trying to compute x from a, b and c
    # Resist temptation to return x if succeeded
    if not x:
        # Some Plan-B computation of x
    return x  # One single exit point for the returned value x will help
              # when maintaining the code.
6 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
    def complex_function(a, b, c):
        if not a:
            return None  # Raising an exception might be better
        if not b:
            return None  # Raising an exception might be better
        # Some complex code trying to compute x from a, b and c
        # Resist temptation to return x if succeeded
        if not x:
            # Some Plan-B computation of x
        return x  # One single exit point for the returned value x will help
                  # when maintaining the code.
    
    9 hoàn chỉnh hơn có thể được định nghĩa là
    def make_complex(x, y):
        return {'x': x, 'y': y}
    
    10. Ở đây
    def make_complex(x, y):
        return {'x': x, 'y': y}
    
    11 và
    def make_complex(x, y):
        return {'x': x, 'y': y}
    
    12 là tùy chọn và đánh giá thành
    def make_complex(x, y):
        return {'x': x, 'y': y}
    
    13 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

def make_complex(x, y):
    return {'x': x, 'y': y}
15. 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.
def make_complex(x, y):
    return {'x': x, 'y': y}
16

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
    def make_complex(x, y):
        return {'x': x, 'y': y}
    
    17. Trong thân hàm,
    def make_complex(x, y):
        return {'x': x, 'y': y}
    
    18 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
    def make_complex(x, y):
        return {'x': x, 'y': y}
    
    19 với mỗi người nhận làm đối số.
    print('one'); print('two')
    
    if x == 1: print('one')
    
    if <complex comparison> and <other complex comparison>:
        # do something
    
    10, và trong thân hàm
    def make_complex(x, y):
        return {'x': x, 'y': y}
    
    18 sẽ bằng với
    print('one'); print('two')
    
    if x == 1: print('one')
    
    if <complex comparison> and <other complex comparison>:
        # do something
    
    12

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

def complex_function(a, b, c):
    if not a:
        return None  # Raising an exception might be better
    if not b:
        return None  # Raising an exception might be better
    # Some complex code trying to compute x from a, b and c
    # Resist temptation to return x if succeeded
    if not x:
        # Some Plan-B computation of x
    return x  # One single exit point for the returned value x will help
              # when maintaining the code.
9 có nhiều người nhận, tốt hơn là nên xác định rõ ràng.
print('one'); print('two')

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

if <complex comparison> and <other complex comparison>:
    # do something
14 và gọi nó bằng
print('one'); print('two')

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

if <complex comparison> and <other complex comparison>:
    # do something
15. 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
    print('one'); print('two')
    
    if x == 1: print('one')
    
    if <complex comparison> and <other complex comparison>:
        # do something
    
    16. Trong thân hàm,
    print('one'); print('two')
    
    if x == 1: print('one')
    
    if <complex comparison> and <other complex comparison>:
        # do something
    
    17 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

def complex_function(a, b, c):
    if not a:
        return None  # Raising an exception might be better
    if not b:
        return None  # Raising an exception might be better
    # Some complex code trying to compute x from a, b and c
    # Resist temptation to return x if succeeded
    if not x:
        # Some Plan-B computation of x
    return x  # One single exit point for the returned value x will help
              # when maintaining the code.

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ì

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

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

if <complex comparison> and <other complex comparison>:
    # do something
18 sẽ cung cấp một bộ gồm hai phần tử cho mỗi mục trong danh sách

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

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

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

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

if <complex comparison> and <other complex comparison>:
    # do something
1

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

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

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

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

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

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

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

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

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

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

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

if <complex comparison> and <other complex comparison>:
    # do something
19.

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

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

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

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 duy nhất “

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

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

cond1 = <complex comparison>
cond2 = <other complex comparison>
if cond1 and cond2:
    # do something
30” cho các biến bỏ đi thay vì dấu gạch dưới kép “
print('one'); print('two')

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

if <complex comparison> and <other complex comparison>:
    # do something
19” được khuyến nghị tại đây. Vấn đề là “
print('one')
print('two')

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

cond1 = <complex comparison>
cond2 = <other complex comparison>
if cond1 and cond2:
    # do something
30” thường được sử dụng làm bí danh cho hàm
print('one')
print('two')

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

cond1 = <complex comparison>
cond2 = <other complex comparison>
if cond1 and cond2:
    # do something
33 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 đó, việc 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ử

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

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

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

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ử

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

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

cond1 = <complex comparison>
cond2 = <other complex comparison>
if cond1 and cond2:
    # do something
34 (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

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

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

cond1 = <complex comparison>
cond2 = <other complex comparison>
if cond1 and cond2:
    # do something
36 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à

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

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

cond1 = <complex comparison>
cond2 = <other complex comparison>
if cond1 and cond2:
    # do something
37), 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ờ

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

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

cond1 = <complex comparison>
cond2 = <other complex comparison>
if cond1 and cond2:
    # do something
38 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ờ
print('one')
print('two')

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

cond1 = <complex comparison>
cond2 = <other complex comparison>
if cond1 and cond2:
    # do something
39 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ờ

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

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

cond1 = <complex comparison>
cond2 = <other complex comparison>
if cond1 and cond2:
    # do something
38 sẽ xuất ra khác biệt để xem xét trước khi áp dụng các thay đổi

màu đ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ờ

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

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

cond1 = <complex comparison>
cond2 = <other complex comparison>
if cond1 and cond2:
    # do something
41 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

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

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

cond1 = <complex comparison>
cond2 = <other complex comparison>
if cond1 and cond2:
    # do something
42. Thay vào đó, hãy sử dụng cú pháp
print('one')
print('two')

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

cond1 = <complex comparison>
cond2 = <other complex comparison>
if cond1 and cond2:
    # do something
43 hoặc chuyển đối số mặc định cho
print('one')
print('two')

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

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

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

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

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

if <complex comparison> and <other complex comparison>:
    # do something
18 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

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

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

if <complex comparison> and <other complex comparison>:
    # do something
18 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

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

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

cond1 = <complex comparison>
cond2 = <other complex comparison>
if cond1 and cond2:
    # do something
47 để đọ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

def complex_function(a, b, c):
    if not a:
        return None  # Raising an exception might be better
    if not b:
        return None  # Raising an exception might be better
    # Some complex code trying to compute x from a, b and c
    # Resist temptation to return x if succeeded
    if not x:
        # Some Plan-B computation of x
    return x  # One single exit point for the returned value x will help
              # when maintaining the code.
0

Câu lệnh

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

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

cond1 = <complex comparison>
cond2 = <other complex comparison>
if cond1 and cond2:
    # do something
48 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
print('one')
print('two')

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

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

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

def complex_function(a, b, c):
    if not a:
        return None  # Raising an exception might be better
    if not b:
        return None  # Raising an exception might be better
    # Some complex code trying to compute x from a, b and c
    # Resist temptation to return x if succeeded
    if not x:
        # Some Plan-B computation of x
    return x  # One single exit point for the returned value x will help
              # when maintaining the code.
1

Tốt

def complex_function(a, b, c):
    if not a:
        return None  # Raising an exception might be better
    if not b:
        return None  # Raising an exception might be better
    # Some complex code trying to compute x from a, b and c
    # Resist temptation to return x if succeeded
    if not x:
        # Some Plan-B computation of x
    return x  # One single exit point for the returned value x will help
              # when maintaining the code.
2

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.