Hướng dẫn python list colon comma - danh sách python dấu hai chấm

Nói chung:

foo[somestuff]

gọi là __getitem__ hoặc __setitem__. . Bây giờ, nếu somestuff có dấu phẩy trong đó, Python sẽ chuyển tuple cho chức năng cơ bản:

foo[1,2]  # passes a tuple

Nếu có

foo[1,2]  # passes a tuple
0, Python sẽ vượt qua một lát cắt:

foo[:]  # passes `slice(None, None, None)`
foo[1:2]  # passes `slice(1, 2, None)`
foo[1:2:3]  # passes `slice(1, 2, 3)
foo[1::3]  # passes `slice(1, None, 3)

Hy vọng bạn có được ý tưởng. Bây giờ nếu có dấu phẩy và đại tràng, Python sẽ vượt qua một tuple có chứa một lát cắt. Trong ví dụ của bạn:

foo[:, 1]  # passes the tuple `(slice(None, None, None), 1)`

Những gì đối tượng (

foo[1,2]  # passes a tuple
1) làm với đầu vào hoàn toàn tùy thuộc vào đối tượng.

Hãy nói về việc sử dụng dấu chấm phẩy trong Python. Ý nghĩa chung của dấu chấm phẩy [;] trong các ngôn ngữ lập trình khác nhau là chấm dứt hoặc ngừng tuyên bố hiện tại. & NBSP;

Nội phân Chính showShow

  • Tại sao dấu chấm phẩy được phép trong Python?
  • Làm thế nào để in một dấu chấm phẩy trong Python?
  • Phân chia các tuyên bố với dấu chấm phẩy
  • Sử dụng dấu chấm phẩy với các vòng trong Python
  • Giới thiệu
  • Một quán ngu si là tinh nghịch của tâm trí nhỏ
  • Bố trí mã
  • Vết lõm
  • Tab hoặc không gian?
  • Chiều dài đường tối đa
  • Có nên phá vỡ dòng trước hoặc sau khi vận hành nhị phân?
  • Các dòng trống
  • Mã hóa tập tin nguồn
  • Tên Dunder cấp độ mô -đun
  • Trích dẫn chuỗi
  • Khoảng trắng trong biểu thức và câu lệnh
  • Các khuyến nghị khác
  • Khi nào nên sử dụng dấu phẩy kéo dài
  • Đặt tên quy ước
  • Nguyên tắc ghi đè
  • Mô tả: Kiểu đặt tên
  • Quy định: Đặt tên quy ước
  • Giao diện công khai và nội bộ
  • Khuyến nghị lập trình
  • Chú thích chức năng
  • Chú thích biến

Nội phân chính

  • Tại sao dấu chấm phẩy được phép trong Python?
  • Làm thế nào để in một dấu chấm phẩy trong Python?
  • Phân chia các tuyên bố với dấu chấm phẩy
  • Sử dụng dấu chấm phẩy với các vòng trong Python
  • Giới thiệu
  • Một quán ngu si là tinh nghịch của tâm trí nhỏ
  • Bố trí mã
  • Vết lõm
  • Tab hoặc không gian?
  • Chiều dài đường tối đa
  • Có nên phá vỡ dòng trước hoặc sau khi vận hành nhị phân?
  • Các dòng trống
  • Mã hóa tập tin nguồn
  • Tên Dunder cấp độ mô -đun
  • Trích dẫn chuỗi
  • Khoảng trắng trong biểu thức và câu lệnh
  • Các khuyến nghị khác
  • Khi nào nên sử dụng dấu phẩy kéo dài
  • Đặt tên quy ước
  • Nguyên tắc ghi đè
  • Mô tả: Kiểu đặt tên
  • Quy định: Đặt tên quy ước
  • Giao diện công khai và nội bộ
  • Khuyến nghị lập trình
  • Chú thích chức năng
  • Chú thích biến

Nội phân chính

  • Tại sao dấu chấm phẩy được phép trong Python?
  • Làm thế nào để in một dấu chấm phẩy trong Python?
  • Phân chia các tuyên bố với dấu chấm phẩy
  • Sử dụng dấu chấm phẩy với các vòng trong Python
  • Giới thiệu
  • Một quán ngu si là tinh nghịch của tâm trí nhỏ
  • Bố trí mã
  • Vết lõm
  • Tab hoặc không gian?
  • Chiều dài đường tối đa
  • Có nên phá vỡ dòng trước hoặc sau khi vận hành nhị phân?
  • Các dòng trống
  • Mã hóa tập tin nguồn
  • Tên Dunder cấp độ mô -đun
  • Trích dẫn chuỗi
  • Khoảng trắng trong biểu thức và câu lệnh
  • Các khuyến nghị khác
  • Khi nào nên sử dụng dấu phẩy kéo dài
  • Đặt tên quy ước
  • Nguyên tắc ghi đè
  • Mô tả: Kiểu đặt tên
  • Quy định: Đặt tên quy ước
  • Giao diện công khai và nội bộ
  • Khuyến nghị lập trình
  • Chú thích chức năng
  • Chú thích biến

Nội phân chính

Tại sao dấu chấm phẩy được phép trong Python?

Trong các ngôn ngữ lập trình như C, C ++ và Java, sử dụng dấu chấm phẩy là cần thiết để chấm dứt dòng mã. Tuy nhiên, đó không phải là trường hợp với Python. Vậy sử dụng dấu chấm phẩy có tạo ra sự khác biệt nào trong lập trình Python không? Hãy cùng tìm hiểu.

Python không & nbsp; yêu cầu & nbsp; bán đại hội để chấm dứt các câu lệnh. Semicolons & nbsp; Can & nbsp; được sử dụng để phân định các câu lệnh nếu bạn muốn đặt nhiều câu lệnh trên cùng một dòng.semicolon in Python denotes separation, rather than termination. It allows you to write multiple statements on the same line. This syntax also makes it legal to put a semicolon at the end of a single statement. So, it’s actually two statements where the second one is empty.

Làm thế nào để in một dấu chấm phẩy trong Python?

A & nbsp; semicolon & nbsp; in & nbsp; python & nbsp; biểu thị sự tách biệt, thay vì chấm dứt. Nó cho phép bạn viết nhiều câu lệnh trên cùng một dòng. Cú pháp này cũng làm cho nó & nbsp; Legal & nbsp; để đặt a & nbsp; semicolon & nbsp; vào cuối một tuyên bố. Vì vậy, nó thực sự là hai tuyên bố trong đó câu thứ hai trống rỗng.

Output:

Hãy để xem những gì xảy ra khi chúng ta cố gắng in một dấu chấm phẩy như một chuỗi thông thường trong Python

Phân chia các tuyên bố với dấu chấm phẩy

Nó đối xử với dấu chấm phẩy không khác nhau và in nó ra.

Syntax:

Bây giờ, hãy để Lừa xem làm thế nào chúng ta có thể phân chia các tuyên bố trong Python với việc sử dụng dấu chấm phẩy. Trong trường hợp này, chúng tôi sẽ cố gắng có nhiều hơn 2 câu trên cùng một dòng với việc sử dụng dấu chấm phẩy.

Ví dụ:

Dưới đây là ba tuyên bố trong Python mà không có dấu chấm phẩy

>>> in ['HI'] >>> in ['Xin chào'] >>> in ['hola!']]

Bây giờ, hãy để sử dụng cùng ba câu lệnh với dấu chấm phẩy

Output:

In ['Hi']; In ['Xin chào']; In ['Hola!']]

Sử dụng dấu chấm phẩy với các vòng trong Python

Như bạn có thể thấy, Python thực hiện ba tuyên bố riêng lẻ sau khi chúng tôi chia chúng bằng dấu chấm phẩy. Nếu không sử dụng điều đó, thông dịch viên sẽ cho chúng ta một lỗi.

Example:

Trong các vòng như ‘cho vòng lặp‘, một dấu chấm phẩy có thể được sử dụng nếu toàn bộ câu lệnh bắt đầu bằng một vòng lặp và bạn sử dụng một dấu chấm phẩy để tạo thành một câu lệnh mạch lạc như thân của vòng lặp.

Output:

cho tôi trong phạm vi [4]: ​​in ['hi']; In ['Xin chào']

Xin chào xin chào xin chào xin chào xin chào xin chào xin chào

Example:

Python sẽ ném một lỗi nếu bạn sử dụng dấu chấm phẩy để tách biệt biểu thức bình thường từ một câu lệnh khối i.e vòng lặp.

In ['Hi']; Đối với tôi trong phạm vi [4]: ​​in ['xin chào']]

Đầu ra:

Sự kết luận

  • Điều này đưa chúng ta đến cuối mô -đun ngắn gọn này về việc sử dụng dấu chấm phẩy trong Python. Hãy để tóm tắt hướng dẫn với hai con trỏ:
  • Một dấu chấm phẩy trong Python chủ yếu được sử dụng để phân tách nhiều câu lệnh được viết trên một dòng.

Semicolon được sử dụng để viết tuyên bố nhỏ và dự trữ một chút không gian - như name = marie; Tuổi = 23; In [Tên, Tuổi]

Tác giả: Guido Van Rossum, Barry Warsaw, Nick Coghlan Tình trạng: Activetype: ProcessCreated: 05-Jul-2001post-History: 05-Jul-2001, 01-Aug-2013:Guido van Rossum , Barry Warsaw , Nick Coghlan Status:ActiveType:ProcessCreated:05-Jul-2001Post-History:05-Jul-2001, 01-Aug-2013
Mục lục
  • Giới thiệu
  • Một quán ngu si là tinh nghịch của tâm trí nhỏ
  • Bố trí mã
    • Vết lõm
    • Tab hoặc không gian?
    • Chiều dài đường tối đa
    • Có nên phá vỡ dòng trước hoặc sau khi vận hành nhị phân?
    • Các dòng trống
    • Mã hóa tập tin nguồn
    • Nhập khẩu
    • Tên Dunder cấp độ mô -đun
  • Trích dẫn chuỗi
  • Khoảng trắng trong biểu thức và câu lệnh
    • Thói xấu
    • Các khuyến nghị khác
  • Khi nào nên sử dụng dấu phẩy kéo dài
  • Bình luận
    • Khối ý kiến
    • Ý kiến ​​nội tuyến
    • Chuỗi tài liệu
  • Đặt tên quy ước
    • Nguyên tắc ghi đè
    • Mô tả: Kiểu đặt tên
    • Quy định: Đặt tên quy ước
      • Tên cần tránh
      • Khả năng tương thích ASCII
      • Tên gói và tên mô -đun
      • Tên lớp
      • Nhập tên biến
      • Tên ngoại lệ
      • Tên biến toàn cầu
      • Tên chức năng và tên biến
      • Các đối số chức năng và phương thức
      • Tên phương thức và biến thể hiện
      • Hằng số
      • Thiết kế cho thừa kế
    • Giao diện công khai và nội bộ
  • Khuyến nghị lập trình
    • Chú thích chức năng
    • Chú thích biến
  • Người giới thiệu
  • Bản quyền

Giới thiệu

Một quán ngu si là tinh nghịch của tâm trí nhỏ

Bố trí mã

Vết lõm

Tab hoặc không gian?

Một quán ngu si là tinh nghịch của tâm trí nhỏ

Bố trí mã

Vết lõm

Tab hoặc không gian?

Chiều dài đường tối đa

Có nên phá vỡ dòng trước hoặc sau khi vận hành nhị phân?

  1. Các dòng trống
  2. Mã hóa tập tin nguồn
  3. Bởi vì mã trong câu hỏi có trước việc giới thiệu hướng dẫn và không có lý do nào khác để sửa đổi mã đó.
  4. Khi mã cần giữ tương thích với các phiên bản Python cũ hơn mà không ủng hộ tính năng được đề xuất bởi Hướng dẫn kiểu.

Bố trí mã

Vết lõm

Sử dụng 4 không gian trên mỗi cấp độ thụt.

Các dòng tiếp tục nên căn chỉnh các phần tử được bọc theo chiều dọc bằng cách sử dụng đường thẳng của Python, nối bên trong dấu ngoặc đơn, dấu ngoặc và niềng răng hoặc sử dụng thụt lề treo [1]. Khi sử dụng thụt lề treo sau đây nên được xem xét; Không nên có đối số trên dòng đầu tiên và nên sử dụng thụt thêm để phân biệt rõ ràng là một dòng tiếp tục:

# Đúng:# được căn chỉnh với mở delimiter.foo = long_function_name [var_one, var_two, var_three, var_four] print [var_one]# treo indents nên thêm một cấp.foo = long_function_name [var_one, var_two, var_three, var_four]# sai:# đối số trên dòng đầu tiên bị cấm ]# Yêu cầu thụt thêm như thụt lề không phân biệt được.deflong_function_name [var_one, var_two, var_three, var_four]: in [var_one] # Aligned with opening delimiter. foo = long_function_name[var_one, var_two, var_three, var_four] # Add 4 spaces [an extra level of indentation] to distinguish arguments from the rest. def long_function_name[ var_one, var_two, var_three, var_four]: print[var_one] # Hanging indents should add a level. foo = long_function_name[ var_one, var_two, var_three, var_four] # Wrong: # Arguments on first line forbidden when not using vertical alignment. foo = long_function_name[var_one, var_two, var_three, var_four] # Further indentation required as indentation is not distinguishable. def long_function_name[ var_one, var_two, var_three, var_four]: print[var_one]

Quy tắc 4 không gian là tùy chọn cho các dòng tiếp tục.

Optional:

# Treo indents * có thể * được thụt vào khác với 4 không gian.foo = long_function_name [var_one, var_two, var_three, var_four] foo = long_function_name[ var_one, var_two, var_three, var_four]

Khi phần có điều kiện của một câu chuyện if đủ dài để yêu cầu nó được viết trên nhiều dòng, nó đáng chú ý là sự kết hợp của một từ khóa hai ký tự [tức là. Nếu], cộng với một không gian duy nhất, cộng với dấu ngoặc đơn tạo ra một thụt 4 không gian tự nhiên cho các dòng tiếp theo của điều kiện đa dòng. Điều này có thể tạo ra một cuộc xung đột trực quan với bộ mã được thụt vào lồng bên trong sự tuyên bố của IF, cũng sẽ tự nhiên được thụt vào 4 không gian. PEP này không có vị trí rõ ràng về cách [hoặc liệu] có phân biệt trực quan các dòng có điều kiện như vậy với bộ lồng nhau bên trong sự tuyên bố của IF hay không. Các tùy chọn chấp nhận được trong tình huống này bao gồm, nhưng không giới hạn ở:if-statement is long enough to require that it be written across multiple lines, it’s worth noting that the combination of a two character keyword [i.e. if], plus a single space, plus an opening parenthesis creates a natural 4-space indent for the subsequent lines of the multiline conditional. This can produce a visual conflict with the indented suite of code nested inside the if-statement, which would also naturally be indented to 4 spaces. This PEP takes no explicit position on how [or whether] to further visually distinguish such conditional lines from the nested suite inside the if-statement. Acceptable options in this situation include, but are not limited to:

# Không có thêm thụt lề.if [this_is_one_thingandthat_is_another_thing]: do_somoth Thêm một số thụt thêm vào dòng tiếp tục có điều kiện.if [this_is_one_thingandthat_is_another_thing]: do_somothing [] if [this_is_one_thing and that_is_another_thing]: do_something[] # Add a comment, which will provide some distinction in editors # supporting syntax highlighting. if [this_is_one_thing and that_is_another_thing]: # Since both conditions are true, we can frobnicate. do_something[] # Add some extra indentation on the conditional continuation line. if [this_is_one_thing and that_is_another_thing]: do_something[]

[Cũng xem các cuộc thảo luận về việc nên phá vỡ trước hay sau các nhà khai thác nhị phân bên dưới.]

Đóng nẹp/giá đỡ/dấu ngoặc đơn trên các cấu trúc đa dòng có thể xếp theo ký tự không phải là màu đầu tiên của dòng danh sách cuối cùng, như trong:

my_list=[1,2,3,4,5,6,]result=some_function_that_takes_arguments['a','b','c','d','e','f',] = [ 1, 2, 3, 4, 5, 6, ] result = some_function_that_takes_arguments[ 'a', 'b', 'c', 'd', 'e', 'f', ]

Hoặc nó có thể được xếp hàng dưới ký tự đầu tiên của dòng bắt đầu cấu trúc đa dòng, như trong:

my_list=[1,2,3,4,5,6,]result=some_function_that_takes_arguments['a','b','c','d','e','f',] = [ 1, 2, 3, 4, 5, 6, ] result = some_function_that_takes_arguments[ 'a', 'b', 'c', 'd', 'e', 'f', ]

Tab hoặc không gian?

Không gian là phương pháp thụt đầu tiên ưa thích.

Các tab chỉ nên được sử dụng để duy trì sự phù hợp với mã đã được thụt vào với các tab.

Python không hoàn toàn trộn lẫn các tab và không gian để thụt vào.

Chiều dài đường tối đa

Giới hạn tất cả các dòng ở mức tối đa 79 ký tự.

Đối với các khối văn bản dài với các hạn chế cấu trúc ít hơn [DocStrings hoặc nhận xét], độ dài dòng phải được giới hạn ở 72 ký tự.

Giới hạn chiều rộng cửa sổ Trình soạn thảo cần thiết cho phép có một số tệp mở cạnh nhau và hoạt động tốt khi sử dụng các công cụ đánh giá mã trình bày hai phiên bản trong các cột liền kề.

Việc gói mặc định trong hầu hết các công cụ phá vỡ cấu trúc trực quan của mã, khiến nó khó hiểu hơn. Các giới hạn được chọn để tránh bọc trong các trình chỉnh sửa với chiều rộng cửa sổ được đặt thành 80, ngay cả khi công cụ đặt một glyph điểm trong cột cuối cùng khi các dòng gói. Một số công cụ dựa trên web có thể không cung cấp kết thúc dòng động.

Một số đội thích mạnh mẽ một dòng dài hơn. Đối với mã được duy trì độc quyền hoặc chủ yếu bởi một nhóm có thể đạt được thỏa thuận về vấn đề này, có thể tăng giới hạn độ dài dòng lên tới 99 ký tự, với điều kiện là nhận xét và tài liệu vẫn được gói ở 72 ký tự.

Thư viện tiêu chuẩn Python là bảo thủ và yêu cầu giới hạn các dòng cho 79 ký tự [và docstrings/bình luận đến 72].

Cách ưa thích để gói các đường dài là bằng cách sử dụng sự tiếp tục dòng ngụ ý của Python, bên trong ngoặc đơn, ngoặc và thanh giằng. Các đường dài có thể được phá vỡ trên nhiều dòng bằng cách gói các biểu thức trong ngoặc đơn. Chúng nên được sử dụng theo sở thích để sử dụng dấu gạch chéo ngược để tiếp tục dòng.

Backslashes vẫn có thể phù hợp đôi khi. Ví dụ, dài, nhiều người không thể sử dụng tiếp tục ngầm trước Python 3.10, do đó, các dấu gạch chéo ngược được chấp nhận cho trường hợp đó:with-statements could not use implicit continuation before Python 3.10, so backslashes were acceptable for that case:

withopen ['/path/to/some/file/bạn/want/to/read'] asfile_1, \ open ['/path/to/some/file/breat/writing', 'w'] [file_1.read []] open['/path/to/some/file/you/want/to/read'] as file_1, \ open['/path/to/some/file/being/written', 'w'] as file_2: file_2.write[file_1.read[]]

[Xem các cuộc thảo luận trước đây về các câu chuyện if đa dòng để biết thêm về suy nghĩ về thụt lề của các câu chuyện đa dòng như vậy.]with-statements.]

Một trường hợp như vậy là với các tuyên bố khẳng định.assert statements.

Hãy chắc chắn để thụt dòng dòng tiếp tục một cách thích hợp.

Có nên phá vỡ dòng trước hoặc sau khi vận hành nhị phân?

Trong nhiều thập kỷ, phong cách được đề xuất là phá vỡ sau khi các nhà khai thác nhị phân. Nhưng điều này có thể làm tổn thương khả năng đọc theo hai cách: các nhà khai thác có xu hướng nằm rải rác trên các cột khác nhau trên màn hình và mỗi toán tử được chuyển ra khỏi toán hạng của nó và vào dòng trước. Ở đây, mắt phải làm thêm để cho biết mục nào được thêm vào và cái nào được trừ:

# Sai:# Các nhà khai thác ngồi cách xa Toán tử của họ = [Gross_Wages+Taxable_interest+[Cổ tức-đủ điều kiện_dividends] -IRA_DEDIONSTION-student_loan_interest] # operators sit far away from their operands income = [gross_wages + taxable_interest + [dividends - qualified_dividends] - ira_deduction - student_loan_interest]

Để giải quyết vấn đề dễ đọc này, các nhà toán học và các nhà xuất bản của họ tuân theo quy ước ngược lại. Donald Knuth giải thích quy tắc truyền thống trong các máy tính và loạt sắp xếp của mình: Mặc dù các công thức trong một đoạn văn luôn bị phá vỡ sau các hoạt động và quan hệ nhị phân, các công thức hiển thị luôn bị phá vỡ trước khi hoạt động nhị phân [3].

Theo truyền thống từ toán học thường dẫn đến mã dễ đọc hơn:

# Đúng:# Dễ dàng phù hợp với các toán tử với operandsincome = [gross_wages+Taxable_interest+[cổ tức-đủ điều kiện_dividends] -IRA_DEDUSION-student_loan_interest] # easy to match operators with operands income = [gross_wages + taxable_interest + [dividends - qualified_dividends] - ira_deduction - student_loan_interest]

Trong mã Python, được phép phá vỡ trước hoặc sau một toán tử nhị phân, miễn là quy ước là nhất quán tại địa phương. Đối với phong cách mới Knuth Knuth được đề xuất.

Các dòng trống

Chức năng cấp cao nhất và định nghĩa lớp với hai dòng trống.

Các định nghĩa phương pháp bên trong một lớp được bao quanh bởi một dòng trống duy nhất.

Các dòng trống thêm có thể được sử dụng [một cách tiết kiệm] cho các nhóm chức năng liên quan riêng biệt. Các dòng trống có thể được bỏ qua giữa một loạt các lớp lót liên quan [ví dụ: một tập hợp các triển khai giả].

Sử dụng các dòng trống trong các chức năng, một cách tiết kiệm, để chỉ ra các phần logic.

Python chấp nhận điều khiển-l [tức là ^L] tạo thành ký tự thức ăn là khoảng trắng; Nhiều công cụ coi các ký tự này là dấu phân cách trang, vì vậy bạn có thể sử dụng chúng để tách các trang liên quan đến tệp của mình. Lưu ý, một số trình chỉnh sửa và người xem mã dựa trên web có thể không nhận ra Control-L là nguồn cấp dữ liệu biểu mẫu và sẽ hiển thị một glyph khác ở vị trí của nó.

Mã hóa tập tin nguồn

Mã trong phân phối Python cốt lõi phải luôn luôn sử dụng UTF-8 và không nên có khai báo mã hóa.

Trong thư viện tiêu chuẩn, các mã hóa không phải UTF-8 chỉ nên được sử dụng cho mục đích thử nghiệm. Sử dụng các ký tự không phải ASCII một cách tiết kiệm, tốt nhất là chỉ để biểu thị địa điểm và tên người. Nếu sử dụng các ký tự không phải ASCII làm dữ liệu, hãy tránh các ký tự unicode ồn ào như z̯̯͡a̧͎̺l̡͓̫g̹̲o̡̼̘ và các dấu lệnh byte.

Tất cả các định danh trong thư viện tiêu chuẩn Python phải sử dụng các định danh chỉ ASCII-ASCII và nên sử dụng các từ tiếng Anh ở bất cứ nơi nào khả thi [trong nhiều trường hợp, viết tắt và thuật ngữ kỹ thuật được sử dụng mà tiếng Anh].

Các dự án nguồn mở với khán giả toàn cầu được khuyến khích áp dụng chính sách tương tự.

Nhập khẩu

  • Nhập khẩu thường phải ở trên các dòng riêng biệt:# Đúng: Nhập trí# Correct: import os import sys

    Nó có thể nói điều này mặc dù:

    # Đúng: FromsubProcessImportPopen, ống from subprocess import Popen, PIPE
  • Nhập khẩu luôn được đặt ở đầu tệp, ngay sau khi bất kỳ bình luận và tài liệu mô -đun nào, và trước khi mô -đun toàn cầu và hằng số.

    Nhập khẩu phải được nhóm theo thứ tự sau:

    1. Nhập khẩu thư viện tiêu chuẩn.
    2. Nhập khẩu của bên thứ ba liên quan.
    3. Ứng dụng cục bộ/Thư viện nhập khẩu cụ thể.

    Bạn nên đặt một dòng trống giữa mỗi nhóm nhập khẩu.

  • Nhập khẩu tuyệt đối được khuyến nghị, vì chúng thường dễ đọc hơn và có xu hướng hoạt động tốt hơn [hoặc ít nhất là đưa ra thông báo lỗi tốt hơn] nếu hệ thống nhập được cấu hình không chính xác [chẳng hạn như khi thư mục bên trong gói kết thúc trên sys.path]: Nhập khẩuMypkg.SiBlingFrommyPkGimportsiBlingFrommypkg.SiBlingImportExamplesys.path]:import mypkg.sibling from mypkg import sibling from mypkg.sibling import example

    Tuy nhiên, nhập khẩu tương đối rõ ràng là một sự thay thế có thể chấp nhận được đối với nhập khẩu tuyệt đối, đặc biệt là khi xử lý các bố cục gói phức tạp trong đó sử dụng nhập khẩu tuyệt đối sẽ là dòng chảy không cần thiết:

    from.importsiblingfrom.siblingimportexample . import sibling from .sibling import example

    Mã thư viện tiêu chuẩn nên tránh bố cục gói phức tạp và luôn sử dụng nhập khẩu tuyệt đối.

  • Khi nhập một lớp từ một mô-đun chứa lớp, nó thường ổn khi đánh vần điều này: FromMyClassImportMyClassFromfoo.bar.yourClassImportyourClassfrom myclass import MyClass from foo.bar.yourclass import YourClass

    Nếu chính tả này gây ra tiếng vang địa phương, thì hãy đánh vần chúng một cách rõ ràng:

    importmyclassimportfoo.bar.yourclass myclass import foo.bar.yourclass

    và sử dụng các loại myclass.myclass và và foo.bar.yourclass.yourclass.

  • Nên tránh nhập ký tự đại diện [FromImport*], vì chúng làm cho nó không rõ tên nào có trong không gian tên, gây nhầm lẫn cho cả người đọc và nhiều công cụ tự động. Có một trường hợp sử dụng có thể phòng thủ để nhập thẻ đại diện, đó là tái xuất bản giao diện nội bộ như một phần của API công khai [ví dụ, ghi đè lên việc triển khai Python thuần túy của giao diện với các định nghĩa từ mô -đun tăng tốc tùy chọn và chính xác định nghĩa nào sẽ là Ghi đè không được biết trước].from import *] should be avoided, as they make it unclear which names are present in the namespace, confusing both readers and many automated tools. There is one defensible use case for a wildcard import, which is to republish an internal interface as part of a public API [for example, overwriting a pure Python implementation of an interface with the definitions from an optional accelerator module and exactly which definitions will be overwritten isn’t known in advance].

    Khi xuất bản lại tên theo cách này, các hướng dẫn dưới đây liên quan đến giao diện công cộng và nội bộ vẫn được áp dụng.

Tên Dunder cấp độ mô -đun

Mức độ mô -đun Dunders Dunders [tức là Tên có hai dấu gạch dưới hàng đầu và hai dấu gạch ngang] như __all__, __Author__, __version__, v.v. Python bắt buộc rằng các phiên bản tương lai phải xuất hiện trong mô-đun trước bất kỳ mã nào khác ngoại trừ DocStrings:__all__, __author__, __version__, etc. should be placed after the module docstring but before any import statements except from __future__ imports. Python mandates that future-imports must appear in the module before any other code except docstrings:

"" "Đây là mô -đun ví dụ. Mô -đun này làm công cụ." " This module does stuff. """ from __future__ import barry_as_FLUFL __all__ = ['a', 'b', 'c'] __version__ = '0.1' __author__ = 'Cardinal Biggles' import os import sys

Trích dẫn chuỗi

Trong Python, các chuỗi được trích xuất đơn và chuỗi được trích xuất kép là như nhau. PEP này không đưa ra khuyến nghị cho việc này. Chọn một quy tắc và bám vào nó. Tuy nhiên, khi một chuỗi chứa các ký tự trích dẫn đơn hoặc kép, hãy sử dụng chuỗi khác để tránh dấu gạch chéo ngược trong chuỗi. Nó cải thiện khả năng đọc.

Đối với các chuỗi được trích dẫn ba, luôn sử dụng các ký tự trích dẫn kép để phù hợp với quy ước DocString trong PEP 257.

Khoảng trắng trong biểu thức và câu lệnh

Thói xấu

Tránh khoảng trắng bên ngoài trong các tình huống sau:

  • Ngay lập tức bên trong dấu ngoặc đơn, ngoặc hoặc niềng răng:# đúng: spam [HAM [1], {trứng: 2}]# sai: spam [Ham [1], {trứng: 2}]# Correct: spam[ham[1], {eggs: 2}] # Wrong: spam[ ham[ 1 ], { eggs: 2 } ]
  • Giữa dấu phẩy kéo dài và dấu ngoặc đơn sau:
  • Ngay lập tức trước dấu phẩy, dấu chấm phẩy hoặc dấu hai chấm:# đúng: ifx == 4: in [x, y]; x, y = y, x# sai: ifx == 4: in [x, y]; x, y = y = y, x# Correct: if x == 4: print[x, y]; x, y = y, x # Wrong: if x == 4 : print[x , y] ; x , y = y , x
  • Tuy nhiên, trong một lát cắt, ruột kết hoạt động giống như một toán tử nhị phân và nên có số lượng bằng nhau ở hai bên [coi nó là người vận hành có mức độ ưu tiên thấp nhất]. Trong một lát mở rộng, cả hai dấu chấm đều phải có cùng một khoảng cách được áp dụng. Ngoại lệ: Khi một tham số lát cắt bị bỏ qua, không gian bị bỏ qua:# đúng: Ham [1: 9], Ham [1: 9: 3], Ham [: 9: 3], Ham [1 :: 3], Ham [1: 9:] Ham [Lower: Upper], Ham [Lower: Upper ], ham [:: Step_fn [x]] ham [thấp hơn+bù: trên+bù] 1: 9: 3] HAM [LOWER :: Upper] Ham [: Upper]# Correct: ham[1:9], ham[1:9:3], ham[:9:3], ham[1::3], ham[1:9:] ham[lower:upper], ham[lower:upper:], ham[lower::step] ham[lower+offset : upper+offset] ham[: upper_fn[x] : step_fn[x]], ham[:: step_fn[x]] ham[lower + offset : upper + offset] # Wrong: ham[lower + offset:upper + offset] ham[1: 9], ham[1 :9], ham[1:9 :3] ham[lower : : upper] ham[ : upper]
  • Ngay trước khi dấu ngoặc đơn khởi động danh sách đối số của một cuộc gọi chức năng:
  • Ngay trước dấu ngoặc đơn mở bắt đầu lập chỉ mục hoặc cắt:# đúng: dct ['key'] = lst [index]# sai: dct ['key'] = lst [index]# Correct: dct['key'] = lst[index] # Wrong: dct ['key'] = lst [index]
  • Nhiều hơn một khoảng trống xung quanh một toán tử [hoặc khác] để căn chỉnh nó với một toán tử khác:# đúng: x = 1y = 2Long_varable = 3# sai: x = 1y = 2Long_varable = 3# Correct: x = 1 y = 2 long_variable = 3 # Wrong: x = 1 y = 2 long_variable = 3

Các khuyến nghị khác

  • Tránh kéo theo khoảng trắng ở bất cứ đâu. Bởi vì nó thường vô hình, nó có thể gây nhầm lẫn: ví dụ: Một dấu gạch chéo ngược theo sau là một không gian và một dòng mới không được tính là điểm đánh dấu tiếp tục dòng. Một số biên tập viên don don bảo tồn nó và nhiều dự án [như chính Cpython] có các móc tiền trước từ chối nó.
  • Luôn bao quanh các toán tử nhị phân này với một không gian duy nhất ở hai bên: gán [=], gán tăng cường [+=, -= v.v.], so sánh [==,,! =,, =, In, notin, is, isnot] , Booleans [và, hoặc, không].=], augmented assignment [+=, -= etc.], comparisons [==, <, >, !=, <>, <=, >=, in, not in, is, is not], Booleans [and, or, not].
  • Nếu các toán tử có các ưu tiên khác nhau được sử dụng, hãy xem xét thêm khoảng trắng xung quanh các toán tử có mức ưu tiên thấp nhất [IES]. Sử dụng phán đoán của riêng bạn; Tuy nhiên, không bao giờ sử dụng nhiều hơn một không gian và luôn có cùng một lượng khoảng trắng ở cả hai bên của toán tử nhị phân:# đúng: i = i+1Submited+= 1x = x*2-1 -hypot2 = x*x+y*yc = .# Correct: i = i + 1 submitted += 1 x = x*2 - 1 hypot2 = x*x + y*y c = [a+b] * [a-b] # Wrong: i=i+1 submitted +=1 x = x * 2 - 1 hypot2 = x * x + y * y c = [a + b] * [a - b]
  • Chú thích chức năng nên sử dụng các quy tắc thông thường cho các dấu chấm và luôn có khoảng trống xung quanh mũi tên -> nếu có. [Xem các chú thích chức năng bên dưới để biết thêm về chú thích chức năng.] []-> Rồi: ...-> arrow if present. [See Function Annotations below for more about function annotations.]:# Correct: def munge[input: AnyStr]: ... def munge[] -> PosInt: ... # Wrong: def munge[input:AnyStr]: ... def munge[]->PosInt: ...
  • Không sử dụng các khoảng trắng xung quanh = dấu khi được sử dụng để chỉ ra đối số từ khóa hoặc khi được sử dụng để chỉ ra giá trị mặc định cho tham số hàm không được bảo vệ:# đúng: defcomplex [real, hình ảnh = 0,0] = hình ảnh]# Sai: defcomplex [real, hình ảnh = 0,0]: returnMagic [r = real, i = imag]= sign when used to indicate a keyword argument, or when used to indicate a default value for an unannotated function parameter:# Correct: def complex[real, imag=0.0]: return magic[r=real, i=imag] # Wrong: def complex[real, imag = 0.0]: return magic[r = real, i = imag]

    Tuy nhiên, khi kết hợp chú thích đối số với giá trị mặc định, hãy sử dụng các khoảng trống xung quanh = dấu hiệu:= sign:

    # Đúng: defmunge [sep: anystr = none]: ... defmunge [input: anystr, sep: anystr = none, limitS defmunge [đầu vào: anystr, giới hạn = 1000]: ... def munge[sep: AnyStr = None]: ... def munge[input: AnyStr, sep: AnyStr = None, limit=1000]: ... # Wrong: def munge[input: AnyStr=None]: ... def munge[input: AnyStr, limit = 1000]: ...
  • Các câu lệnh ghép [Nhiều câu lệnh trên cùng một dòng] thường không được khuyến khích:# đúng: iffoo == 'blah': do_blah_thing [] do_one [] do_two [] do_three []# Correct: if foo == 'blah': do_blah_thing[] do_one[] do_two[] do_three[]

    Thay vì không:

    # Sai: iffoo == 'blah': do_blah_thing [] do_one []; do_two []; do_three [] if foo == 'blah': do_blah_thing[] do_one[]; do_two[]; do_three[]
  • Mặc dù đôi khi, nó có thể đặt một if/for/trong khi có một cơ thể nhỏ trên cùng một dòng, không bao giờ làm điều này cho các câu lệnh đa điểm. Cũng tránh gấp những dòng dài như vậy!

    Thay vì không:

    # Sai: iffoo == 'blah': do_blah_thing [] do_one []; do_two []; do_three [] if foo == 'blah': do_blah_thing[] for x in lst: total += x while t < 10: t = delay[]

    Mặc dù đôi khi, nó có thể đặt một if/for/trong khi có một cơ thể nhỏ trên cùng một dòng, không bao giờ làm điều này cho các câu lệnh đa điểm. Cũng tránh gấp những dòng dài như vậy!

    # Sai: iffoo == 'blah': do_blah_thing [] Forxinlst: Total+= xwhilet if foo == 'blah': do_blah_thing[] else: do_non_blah_thing[] try: something[] finally: cleanup[] do_one[]; do_two[]; do_three[long, argument, list, like, this] if foo == 'blah': one[]; two[]; three[]

Chắc chắn không phải:

# Sai: iffoo == 'blah': do_blah_thing [] khác: do_non_blah_thing [] thử: cái gì đó [] cuối cùng: làm sạch [] do_one []; do_two []; = 'blah': một []; hai []; ba []

Khi nào nên sử dụng dấu phẩy kéo dài FILES = ['setup.cfg',] # Wrong: FILES = 'setup.cfg',

Dấu phẩy thường là tùy chọn, ngoại trừ chúng là bắt buộc khi tạo ra một yếu tố. Để rõ ràng, nên bao quanh phần sau trong các dấu ngoặc đơn [về mặt kỹ thuật]:

# Đúng: files = ['setup.cfg',]# sai: file = 'setup.cfg', FILES = [ 'setup.cfg', 'tox.ini', ] initialize[FILES, error=True, ] # Wrong: FILES = ['setup.cfg', 'tox.ini',] initialize[FILES, error=True,]

Khi dấu phẩy kéo dài, chúng thường hữu ích khi sử dụng hệ thống kiểm soát phiên bản, khi danh sách các giá trị, đối số hoặc các mục nhập được dự kiến ​​sẽ được mở rộng theo thời gian. Mẫu là tự đặt mỗi giá trị [v.v. Tuy nhiên, không có ý nghĩa gì khi có dấu phẩy theo cùng một dòng với dấu phân cách đóng [ngoại trừ trong trường hợp trên của các bộ dữ liệu singleton]:

# Đúng: files = ['setup.cfg', 'tox.ini',] khởi tạo [files, error = true,]# sai: files = ['setup.cfg', 'tox.ini',] Khởi tạo [tệp , error = true,]

Nguyên tắc ghi đè

Các tên có thể nhìn thấy cho người dùng là các phần công khai của API nên tuân theo các quy ước phản ánh việc sử dụng thay vì thực hiện.

Mô tả: Kiểu đặt tên

Có rất nhiều phong cách đặt tên khác nhau. Nó giúp có thể nhận ra phong cách đặt tên đang được sử dụng, độc lập với những gì chúng được sử dụng.

Các kiểu đặt tên sau đây thường được phân biệt:

  • B [Thư viết thường đơn] [single lowercase letter]
  • B [Thư viết hoa đơn] [single uppercase letter]
  • chữ thường
  • lower_case_with_underscores
  • Hậu quả
  • UPPER_CASE_WITH_UNDERSCORES
  • Viết hoa [hoặc capwords, hoặc Camelcase - được đặt tên như vậy vì vẻ ngoài gập ghềnh của các chữ cái của nó [4]]. Điều này đôi khi cũng được gọi là nghiên cứu. [or CapWords, or CamelCase – so named because of the bumpy look of its letters [4]]. This is also sometimes known as StudlyCaps.

    Lưu ý: Khi sử dụng các từ viết tắt trong Capwords, viết hoa tất cả các chữ cái của từ viết tắt. Do đó, httpservererror tốt hơn httpservererror.

  • MIXEDCASE [Khác với chữ viết hoa bằng ký tự viết thường ban đầu!] [differs from CapitalizedWords by initial lowercase character!]
  • Viết hoa_words_with_underscores [xấu xí!] [ugly!]

Ngoài ra, còn có phong cách sử dụng một tiền tố ngắn độc đáo để nhóm liên quan đến nhóm lại với nhau. Điều này không được sử dụng nhiều trong Python, nhưng nó được đề cập để hoàn thiện. Ví dụ: hàm os.stat [] trả về một bộ có các mục có tên truyền thống có tên như st_mode, st_size, st_mtime, v.v. [Điều này được thực hiện để nhấn mạnh sự tương ứng với các trường của cấu trúc cuộc gọi hệ thống POSIX, giúp các lập trình viên quen thuộc với điều đó.]os.stat[] function returns a tuple whose items traditionally have names like st_mode, st_size, st_mtime and so on. [This is done to emphasize the correspondence with the fields of the POSIX system call struct, which helps programmers familiar with that.]

Thư viện X11 sử dụng X hàng đầu cho tất cả các chức năng công cộng của nó. Trong Python, phong cách này thường được coi là không cần thiết bởi vì tên thuộc tính và phương thức được đặt trước với một đối tượng và tên hàm được đặt trước với một tên mô -đun.

Ngoài ra, các hình thức đặc biệt sau đây sử dụng dấu gạch dưới hàng đầu hoặc dấu vết được công nhận [chúng thường có thể được kết hợp với bất kỳ quy ước nào]:

  • _single_leading_underscore: Chỉ báo sử dụng nội bộ yếu. Ví dụ. FromMimport* không nhập các đối tượng có tên bắt đầu bằng dấu gạch dưới.: weak “internal use” indicator. E.g. from M import * does not import objects whose names start with an underscore.
  • single_trailing_underscore_: Được sử dụng bởi quy ước để tránh xung đột với từ khóa Python, ví dụ :Tkinter.toplevel [Master, Class _ = 'ClassName']]]: used by convention to avoid conflicts with Python keyword, e.g.tkinter.Toplevel[master, class_='ClassName']
  • __double_leading_underscore: Khi đặt tên một thuộc tính lớp, gọi tên Mangling [bên trong lớp foobar, __boo trở thành _foobar__boo; xem bên dưới].: when naming a class attribute, invokes name mangling [inside class FooBar, __boo becomes _FooBar__boo; see below].
  • __double_leading_and_trailing_underscore__: Các đối tượng hoặc thuộc tính ma thuật của người Hồi giáo sống trong các không gian tên do người dùng điều khiển. Ví dụ. __init__, __Import__ hoặc __file__. Không bao giờ phát minh ra những cái tên như vậy; Chỉ sử dụng chúng như tài liệu.: “magic” objects or attributes that live in user-controlled namespaces. E.g. __init__, __import__ or __file__. Never invent such names; only use them as documented.

Quy định: Đặt tên quy ước

Tên cần tránh

Không bao giờ sử dụng các ký tự ’Lát [chữ thường el],‘ O, [chữ hoa oh], hoặc ‘I, [mắt chữ hoa] dưới dạng tên biến ký tự đơn.

Trong một số phông chữ, các ký tự này không thể phân biệt được với số một và không. Khi bị cám dỗ sử dụng ‘L, hãy sử dụng‘ L, thay vào đó.

Khả năng tương thích ASCII

Các định danh được sử dụng trong thư viện tiêu chuẩn phải tương thích ASCII như được mô tả trong phần chính sách của PEP 3131.

Tên gói và tên mô -đun

Các mô-đun nên có tên ngắn, toàn bộ. Dấu gạch dưới có thể được sử dụng trong tên mô -đun nếu nó cải thiện khả năng đọc. Các gói Python cũng nên có tên ngắn, toàn bộ, mặc dù việc sử dụng dấu gạch dưới không được khuyến khích.

Khi một mô -đun mở rộng được viết bằng C hoặc C ++ có mô -đun Python đi kèm cung cấp mức cao hơn [ví dụ: Giao diện định hướng đối tượng hơn], mô -đun C/C ++ có dấu gạch dưới hàng đầu [ví dụ: _ổ cắm]._socket].

Tên lớp

Tên lớp thường nên sử dụng quy ước Capwords.

Thay vào đó, quy ước đặt tên cho các chức năng có thể được sử dụng trong trường hợp giao diện được ghi lại và sử dụng chủ yếu là có thể gọi được.

Lưu ý rằng có một quy ước riêng cho các tên tích hợp: hầu hết các tên được xây dựng là các từ đơn [hoặc hai từ chạy cùng nhau], với quy ước Capwords chỉ được sử dụng cho các tên ngoại lệ và hằng số tích hợp.

Nhập tên biến

Tên của các biến loại được giới thiệu trong PEP 484 thường sử dụng Capwords thích tên ngắn: T, Anystr, Num. Nên thêm hậu tố _Co hoặc _Contra vào các biến được sử dụng để khai báo hành vi hiệp phương hoặc contravariant tương ứng:T, AnyStr, Num. It is recommended to add suffixes _co or _contra to the variables used to declare covariant or contravariant behavior correspondingly:

fromtypingimportTypeVarVT_co=TypeVar['VT_co',covariant=True]KT_contra=TypeVar['KT_contra',contravariant=True] typing import TypeVar VT_co = TypeVar['VT_co', covariant=True] KT_contra = TypeVar['KT_contra', contravariant=True]

Tên ngoại lệ

Bởi vì các trường hợp ngoại lệ nên là các lớp, quy ước đặt tên lớp được áp dụng ở đây. Tuy nhiên, bạn nên sử dụng lỗi hậu tố lỗi trên tên ngoại lệ của bạn [nếu ngoại lệ thực sự là một lỗi].

Tên biến toàn cầu

[Hãy để hy vọng rằng các biến này chỉ được sử dụng để sử dụng bên trong một mô -đun.] Các quy ước giống như các biến cho các chức năng.

Các mô-đun được thiết kế để sử dụng thông qua FromMimport* nên sử dụng cơ chế __all__ để ngăn chặn xuất khẩu toàn cầu hoặc sử dụng quy ước cũ của tiền tố như vậy với một dấu gạch dưới [mà bạn có thể muốn làm để chỉ ra những thế giới này là mô-đun không công khai]] .from M import * should use the __all__ mechanism to prevent exporting globals, or use the older convention of prefixing such globals with an underscore [which you might want to do to indicate these globals are “module non-public”].

Tên chức năng và tên biến

Tên chức năng phải là chữ thường, với các từ được phân tách bằng dấu gạch dưới khi cần thiết để cải thiện khả năng đọc.

Tên biến theo cùng một quy ước với tên chức năng.

Mixedcase chỉ được phép trong các bối cảnh mà đó đã là kiểu phổ biến [ví dụ: Chủ đề.py], để giữ lại khả năng tương thích ngược.

Các đối số chức năng và phương thức

Luôn luôn sử dụng bản thân cho đối số đầu tiên cho các phương thức thể hiện.self for the first argument to instance methods.

Luôn luôn sử dụng CLS cho đối số đầu tiên cho các phương thức lớp.cls for the first argument to class methods.

Nếu một đối số chức năng Tên tên xung đột với một từ khóa dành riêng, thì tốt hơn là nên nối một dấu gạch ngang duy nhất thay vì sử dụng viết tắt hoặc tham nhũng chính tả. Do đó, class_ tốt hơn CLSS. [Có lẽ tốt hơn là tránh các cuộc đụng độ như vậy bằng cách sử dụng từ đồng nghĩa.]class_ is better than clss. [Perhaps better is to avoid such clashes by using a synonym.]

Tên phương thức và biến thể hiện

Sử dụng các quy tắc đặt tên chức năng: chữ thường với các từ được phân tách bằng dấu gạch dưới khi cần thiết để cải thiện khả năng đọc.

Sử dụng một dấu gạch dưới hàng đầu cho các phương thức và biến thể hiện không công khai.

Để tránh các cuộc đụng độ tên với các lớp con, hãy sử dụng hai dấu gạch dưới hàng đầu để gọi tên Python tên quy tắc.

Python mang các tên này với tên lớp: Nếu lớp foo có thuộc tính có tên __a, nó không thể được truy cập bởi foo .__ a. .__a, it cannot be accessed by Foo.__a. [An insistent user could still gain access by calling Foo._Foo__a.] Generally, double leading underscores should be used only to avoid name conflicts with attributes in classes designed to be subclassed.

Lưu ý: Có một số tranh cãi về việc sử dụng __names [xem bên dưới].

Hằng số

Các hằng số thường được xác định ở cấp độ mô -đun và được viết bằng tất cả các chữ cái viết hoa với dấu gạch dưới tách các từ. Ví dụ bao gồm MAX_OVERFLOW và TOTAL.MAX_OVERFLOW and TOTAL.

Thiết kế cho thừa kế

Luôn quyết định xem các phương thức và biến thể hiện của lớp có phải [tập thể không: thuộc tính của người Hồi giáo] nên được công khai hoặc không công khai. Nếu nghi ngờ, chọn không công khai; Nó dễ dàng hơn để công khai muộn hơn là làm cho một thuộc tính công khai không công khai.

Các thuộc tính công khai là những thuộc tính mà bạn mong đợi các máy khách không liên quan trong lớp của bạn sẽ sử dụng, với cam kết của bạn để tránh những thay đổi không tương thích ngược. Các thuộc tính không công khai là những thuộc tính không được sử dụng bởi các bên thứ ba; Bạn không đảm bảo rằng các thuộc tính không công khai đã giành được sự thay đổi hoặc thậm chí bị xóa.

Chúng tôi không sử dụng thuật ngữ riêng tư ở đây, vì không có thuộc tính nào thực sự riêng tư trong Python [không có số lượng công việc nói chung không cần thiết].

Một loại thuộc tính khác là một phần của API phân lớp con [thường được gọi là được bảo vệ bởi các ngôn ngữ khác]. Một số lớp được thiết kế để được kế thừa, để mở rộng hoặc sửa đổi các khía cạnh của hành vi lớp học. Khi thiết kế một lớp như vậy, hãy cẩn thận để đưa ra các quyết định rõ ràng về các thuộc tính nào là công khai, là một phần của API phân lớp và thực sự chỉ được sử dụng bởi lớp cơ sở của bạn.

Với suy nghĩ này, đây là các hướng dẫn Pythonic:

  • Các thuộc tính công cộng nên không có dấu gạch dưới hàng đầu.
  • Nếu tên thuộc tính công khai của bạn va chạm với một từ khóa dành riêng, hãy nối một dấu ngoặc đơn nhấn mạnh vào tên thuộc tính của bạn. Điều này tốt hơn là viết tắt hoặc chính tả bị hỏng. [Tuy nhiên, mặc dù quy tắc này, ‘CLS, là cách đánh vần ưa thích cho bất kỳ biến hoặc đối số nào được biết đến là một lớp, đặc biệt là đối số đầu tiên đối với phương thức lớp.]

    Lưu ý 1: Xem đề xuất tên đối số ở trên cho các phương thức lớp.

  • Đối với các thuộc tính dữ liệu công khai đơn giản, tốt nhất là chỉ để hiển thị tên thuộc tính mà không có các phương thức accessor/đột biến phức tạp. Hãy nhớ rằng Python cung cấp một con đường dễ dàng để tăng cường trong tương lai, nếu bạn thấy rằng một thuộc tính dữ liệu đơn giản cần phát triển hành vi chức năng. Trong trường hợp đó, sử dụng các thuộc tính để ẩn triển khai chức năng đằng sau cú pháp truy cập thuộc tính dữ liệu đơn giản.

    Lưu ý 1: Cố gắng giữ cho hành vi chức năng miễn phí tác dụng phụ, mặc dù các tác dụng phụ như bộ nhớ đệm nói chung là tốt.

    Lưu ý 2: Tránh sử dụng các thuộc tính cho các hoạt động tốn kém về mặt tính toán; Ký hiệu thuộc tính làm cho người gọi tin rằng quyền truy cập là [tương đối] giá rẻ.

  • Nếu lớp của bạn được dự định sẽ được phân nhóm và bạn có các thuộc tính mà bạn không muốn các lớp con sử dụng, hãy xem xét việc đặt tên chúng bằng các dấu gạch dưới hàng đầu và không có dấu gạch dưới. Điều này gọi thuật toán mang tên Python, trong đó tên của lớp được đưa vào tên thuộc tính. Điều này giúp tránh các vụ va chạm tên thuộc tính nên các lớp con vô tình chứa các thuộc tính có cùng tên.

    Lưu ý 1: Lưu ý rằng chỉ có tên lớp đơn giản được sử dụng trong tên bị xáo trộn, vì vậy nếu một lớp con chọn cả cùng tên lớp và tên thuộc tính, bạn vẫn có thể có được sự va chạm tên.

    Lưu ý 2: Tên Mangling có thể sử dụng một số cách sử dụng nhất định, chẳng hạn như gỡ lỗi và __getAttr __ [], ít thuận tiện hơn. Tuy nhiên, tên thuật toán mang tên được ghi lại tốt và dễ thực hiện bằng tay.__getattr__[], less convenient. However the name mangling algorithm is well documented and easy to perform manually.

    Lưu ý 3: Không phải ai cũng thích tên Mangling. Cố gắng cân bằng sự cần thiết phải tránh các cuộc đụng độ tên ngẫu nhiên với khả năng sử dụng của những người gọi nâng cao.

Giao diện công khai và nội bộ

Bất kỳ đảm bảo khả năng tương thích ngược chỉ áp dụng cho giao diện công cộng. Theo đó, điều quan trọng là người dùng có thể phân biệt rõ ràng giữa các giao diện công cộng và nội bộ.

Các giao diện được ghi nhận được coi là công khai, trừ khi tài liệu tuyên bố rõ ràng chúng là giao diện tạm thời hoặc nội bộ được miễn trừ khỏi các đảm bảo khả năng tương thích ngược thông thường. Tất cả các giao diện không có giấy tờ nên được coi là nội bộ.

Để hỗ trợ nội tâm tốt hơn, các mô -đun nên khai báo rõ ràng các tên trong API công khai của họ bằng thuộc tính __all__. Cài đặt __all__ thành một danh sách trống cho thấy mô -đun không có API công khai.__all__ attribute. Setting __all__ to an empty list indicates that the module has no public API.

Ngay cả với __all__ đặt một cách thích hợp, giao diện nội bộ [gói, mô -đun, lớp, chức năng, thuộc tính hoặc tên khác] vẫn phải được đặt trước với một dấu gạch dưới hàng đầu.__all__ set appropriately, internal interfaces [packages, modules, classes, functions, attributes or other names] should still be prefixed with a single leading underscore.

Một giao diện cũng được coi là nội bộ nếu bất kỳ không gian tên nào [Gói, mô -đun hoặc lớp] được coi là bên trong.

Tên nhập khẩu phải luôn được coi là một chi tiết thực hiện. Các mô -đun khác không được dựa vào quyền truy cập gián tiếp vào các tên đã nhập như vậy trừ khi chúng là một phần được ghi chép rõ ràng của API mô -đun có chứa API, chẳng hạn như OS.Path hoặc một gói __init__ Mô -đun hiển thị chức năng từ các mô hình con.os.path or a package’s __init__ module that exposes functionality from submodules.

Khuyến nghị lập trình

  • Mã nên được viết theo cách không gây bất lợi cho các triển khai khác của Python [Pypy, Jython, Ironpython, Cython, Psyco, và như vậy].

    Ví dụ: không dựa vào việc triển khai hiệu quả chuỗi chuỗi tại chỗ cho các câu lệnh trong Mẫu A+= B hoặc A = A+B. Tối ưu hóa này rất mong manh ngay cả trong Cpython [nó chỉ hoạt động cho một số loại] và có mặt ở tất cả các triển khai mà don don sử dụng refcounting. Trong các phần nhạy cảm hiệu suất của thư viện, mẫu '' .Join [] nên được sử dụng thay thế. Điều này sẽ đảm bảo rằng sự kết hợp xảy ra trong thời gian tuyến tính trên các triển khai khác nhau.a += b or a = a + b. This optimization is fragile even in CPython [it only works for some types] and isn’t present at all in implementations that don’t use refcounting. In performance sensitive parts of the library, the ''.join[] form should be used instead. This will ensure that concatenation occurs in linear time across various implementations.

  • So sánh với những người độc thân như không nên luôn luôn được thực hiện với IS hoặc không, không bao giờ là người vận hành bình đẳng.is or is not, never the equality operators.

    Ngoài ra, hãy cẩn thận với việc viết IFX khi bạn thực sự có nghĩa là ifxisnotnone - ví dụ: Khi kiểm tra xem một biến hoặc đối số mặc định là không có được đặt ở một số giá trị khác. Giá trị khác có thể có một loại [chẳng hạn như một container] có thể sai trong bối cảnh boolean!if x when you really mean if x is not None – e.g. when testing whether a variable or argument that defaults to None was set to some other value. The other value might have a type [such as a container] that could be false in a boolean context!

  • Sử dụng toán tử không phải là không ... là ... Mặc dù cả hai biểu thức đều giống hệt nhau về mặt chức năng, nhưng trước đây dễ đọc và ưa thích hơn:# đúng: iffooisnotnone:# sai: ifnotfooisnone:is not operator rather than not ... is. While both expressions are functionally identical, the former is more readable and preferred:# Correct: if foo is not None: # Wrong: if not foo is None:
  • Khi thực hiện các hoạt động đặt hàng với các so sánh phong phú, tốt nhất là thực hiện tất cả sáu hoạt động [__eq__, __ne__, __lt__, __le__, __gt__, __ge__] thay vì dựa vào mã khác để chỉ thực hiện một so sánh cụ thể.__eq__, __ne__, __lt__, __le__, __gt__, __ge__] rather than relying on other code to only exercise a particular comparison.

    Để giảm thiểu nỗ lực liên quan, FuncTools.total_ordering [] Decorator cung cấp một công cụ để tạo ra các phương pháp so sánh bị thiếu.functools.total_ordering[] decorator provides a tool to generate missing comparison methods.

    PEP 207 chỉ ra rằng các quy tắc phản xạ được giả định bởi Python. Do đó, trình thông dịch có thể hoán đổi y> x với x = x với xy > x with x < y, y >= x with x <= y, and may swap the arguments of x == y and x != y. The sort[] and min[] operations are guaranteed to use the < operator and the max[] function uses the > operator. However, it is best to implement all six operations so that confusion doesn’t arise in other contexts.

  • Luôn sử dụng câu lệnh DEF thay vì câu lệnh gán liên kết trực tiếp biểu thức lambda với định danh:# đúng: deff [x]: return2*x# sai: f = lambdax: 2*x# Correct: def f[x]: return 2*x # Wrong: f = lambda x: 2*x

    Biểu mẫu đầu tiên có nghĩa là tên của đối tượng chức năng kết quả cụ thể là ‘f, thay vì chung chung. Điều này hữu ích hơn cho các dấu vết và biểu diễn chuỗi nói chung. Việc sử dụng câu lệnh gán loại bỏ lợi ích duy nhất mà biểu thức Lambda có thể cung cấp trên một tuyên bố DEF rõ ràng [tức là. rằng nó có thể được nhúng bên trong một biểu thức lớn hơn]

  • Xuất hiện ngoại lệ từ ngoại lệ chứ không phải Baseexception. Di truyền trực tiếp từ Baseexception được dành riêng cho các trường hợp ngoại lệ trong đó việc bắt chúng hầu như luôn luôn là điều sai trái.Exception rather than BaseException. Direct inheritance from BaseException is reserved for exceptions where catching them is almost always the wrong thing to do.

    Thiết kế hệ thống phân cấp ngoại lệ dựa trên sự khác biệt rằng mã bắt các ngoại lệ có thể cần, thay vì các vị trí nơi các trường hợp ngoại lệ được nêu ra. Nhằm mục đích trả lời câu hỏi "Điều gì đã xảy ra?" Về mặt chương trình, thay vì chỉ nói rằng, một vấn đề đã xảy ra, [xem PEP 3151 để biết ví dụ về bài học này được học cho hệ thống phân cấp ngoại lệ tích hợp]]

    Các quy ước đặt tên lớp áp dụng ở đây, mặc dù bạn nên thêm hậu tố lỗi lỗi vào các lớp ngoại lệ của bạn nếu ngoại lệ là lỗi. Các ngoại lệ không lỗi được sử dụng để kiểm soát dòng không địa phương hoặc các hình thức tín hiệu khác không cần hậu tố đặc biệt.

  • Sử dụng chuỗi ngoại lệ một cách thích hợp. RaiseXfromy nên được sử dụng để chỉ ra sự thay thế rõ ràng mà không mất dấu vết ban đầu.raise X from Y should be used to indicate explicit replacement without losing the original traceback.

    Khi cố tình thay thế một ngoại lệ bên trong [sử dụng RAISEXFROMNONE], hãy đảm bảo rằng các chi tiết liên quan được chuyển sang ngoại lệ mới [chẳng hạn như bảo tồn tên thuộc tính khi chuyển đổi KeyError thành thuộc tính hoặc nhúng văn bản của ngoại lệ ban đầu trong thông báo ngoại lệ mới].raise X from None], ensure that relevant details are transferred to the new exception [such as preserving the attribute name when converting KeyError to AttributeError, or embedding the text of the original exception in the new exception message].

  • Khi bắt các ngoại lệ, hãy đề cập đến các ngoại lệ cụ thể bất cứ khi nào có thể thay vì sử dụng trần ngoại trừ: mệnh đề: Hãy thử: Nhập khẩuexcept: clause:try: import platform_specific_module except ImportError: platform_specific_module = None

    Một cái trần ngoại trừ: mệnh đề sẽ bắt được các ngoại lệ của SystemExit và bàn phím, khiến việc làm gián đoạn một chương trình với Control-C và có thể ngụy trang các vấn đề khác khó khăn hơn. Nếu bạn muốn nắm bắt tất cả các ngoại lệ rằng các lỗi của chương trình tín hiệu, hãy sử dụng trừ: [Bare ngoại trừ tương đương với ngoại trừBaseeException:].except: clause will catch SystemExit and KeyboardInterrupt exceptions, making it harder to interrupt a program with Control-C, and can disguise other problems. If you want to catch all exceptions that signal program errors, use except Exception: [bare except is equivalent to except BaseException:].

    Một quy tắc tốt là hạn chế sử dụng trần ‘ngoại trừ các mệnh đề của đối với hai trường hợp:

    1. Nếu trình xử lý ngoại lệ sẽ được in ra hoặc ghi lại dấu vết; Ít nhất người dùng sẽ biết rằng đã xảy ra lỗi.
    2. Nếu mã cần thực hiện một số công việc dọn dẹp, nhưng sau đó cho phép ngoại lệ tuyên truyền lên trên khi tăng. Hãy thử ... cuối cùng có thể là một cách tốt hơn để xử lý trường hợp này.raise. try...finally can be a better way to handle this case.
  • Khi bắt các lỗi hệ điều hành, thích hệ thống phân cấp ngoại lệ rõ ràng được giới thiệu trong Python 3.3 hơn nội tâm của các giá trị ERRNO.errno values.
  • Ngoài ra, đối với tất cả các thử nghiệm/ngoại trừ các điều khoản, giới hạn mệnh đề thử ở số lượng mã tối thiểu tuyệt đối cần thiết. Một lần nữa, điều này tránh được các lỗi mặt nạ:# Đúng: thử: value = com thu [key] ngoại trừ Cũng bắt được keyerror được nâng lên bởi tay cầm_value [] returnKey_not_found [khóa]try clause to the absolute minimum amount of code necessary. Again, this avoids masking bugs:# Correct: try: value = collection[key] except KeyError: return key_not_found[key] else: return handle_value[value] # Wrong: try: # Too broad! return handle_value[collection[key]] except KeyError: # Will also catch KeyError raised by handle_value[] return key_not_found[key]
  • Khi một tài nguyên là cục bộ cho một phần mã cụ thể, hãy sử dụng một câu lệnh để đảm bảo nó được làm sạch kịp thời và đáng tin cậy sau khi sử dụng. Một tuyên bố thử/cuối cùng cũng được chấp nhận.with statement to ensure it is cleaned up promptly and reliably after use. A try/finally statement is also acceptable.
  • Các nhà quản lý bối cảnh nên được gọi thông qua các chức năng hoặc phương thức riêng biệt bất cứ khi nào họ làm một cái gì đó khác ngoài việc thu thập và phát hành tài nguyên:# Đúng: withconn.begin_transaction []: do_stuff_in_transaction [Conn]# Sai: withConn: do_stuff_in_transaction [Conn]# Correct: with conn.begin_transaction[]: do_stuff_in_transaction[conn] # Wrong: with conn: do_stuff_in_transaction[conn]

    Ví dụ thứ hai không cung cấp bất kỳ thông tin nào để chỉ ra rằng các phương thức __enter__ và __exit__ đang thực hiện một cái gì đó khác ngoài việc đóng kết nối sau một giao dịch. Rõ ràng là quan trọng trong trường hợp này.__enter__ and __exit__ methods are doing something other than closing the connection after a transaction. Being explicit is important in this case.

  • Hãy nhất quán trong các tuyên bố trả lại. Tất cả các câu lệnh trả về trong một hàm sẽ trả về một biểu thức hoặc không ai trong số chúng nên làm. Nếu bất kỳ câu lệnh trả về nào trả về một biểu thức, bất kỳ câu lệnh trả về nào trong đó không có giá trị nào được trả về một cách rõ ràng điều này là returnNone và một câu lệnh trả về rõ ràng sẽ có mặt ở cuối hàm [nếu có thể truy cập]:# đúng: deffoo [x]: ifx> = 0: returnMath.sqrt [x]return None, and an explicit return statement should be present at the end of the function [if reachable]:# Correct: def foo[x]: if x >= 0: return math.sqrt[x] else: return None def bar[x]: if x < 0: return None return math.sqrt[x] # Wrong: def foo[x]: if x >= 0: return math.sqrt[x] def bar[x]: if x < 0: return return math.sqrt[x]
  • Sử dụng '' .startswith [] và '' .endswith [] thay vì cắt chuỗi để kiểm tra tiền tố hoặc hậu tố.''.startswith[] and ''.endswith[] instead of string slicing to check for prefixes or suffixes.

    startswith [] và endswith [] là sạch hơn và ít lỗi hơn:

    # Đúng: iffoo.startswith ['bar']:# sai: iffoo [: 3] == 'thanh': if foo.startswith['bar']: # Wrong: if foo[:3] == 'bar':
  • So sánh loại đối tượng phải luôn luôn sử dụng isInstance [] thay vì so sánh trực tiếp các loại:# đúng: ifisInstance [obj, int]:# sai: iftype [obj] isttype [1]:# Correct: if isinstance[obj, int]: # Wrong: if type[obj] is type[1]:
  • Đối với các chuỗi, [chuỗi, danh sách, bộ dữ liệu], sử dụng thực tế là các chuỗi trống là sai:# đúng: ifnotseq: ifseq:# sai: iflen [seq]: ifnotlen [seq]:# Correct: if not seq: if seq: # Wrong: if len[seq]: if not len[seq]:
  • Don Tiết viết các chuỗi chữ dựa trên khoảng trắng đáng kể. Một khoảng trắng kéo dài như vậy là không thể phân biệt trực quan và một số biên tập viên [hoặc gần đây hơn, Reindent.py] sẽ cắt giảm chúng.
  • Don Tiết so sánh các giá trị boolean với đúng hoặc sai bằng cách sử dụng ==: # sai: ifgreeting == true:==: # Wrong: if greeting == True:

    Worse:

    # Sai: ifgreetingistrue: if greeting is True:
  • Việc sử dụng các câu lệnh điều khiển dòng trả về/phá/tiếp tục trong bộ cuối cùng của một thử ... Cuối cùng, trong đó câu lệnh điều khiển dòng sẽ nhảy ra ngoài bộ cuối cùng, không được khuyến khích. Điều này là do các câu như vậy sẽ hoàn toàn hủy bỏ bất kỳ ngoại lệ hoạt động nào đang lan truyền qua bộ cuối cùng:# Sai: Deffoo []: Hãy thử: 1/0finally: return42return/break/continue within the finally suite of a try...finally, where the flow control statement would jump outside the finally suite, is discouraged. This is because such statements will implicitly cancel any active exception that is propagating through the finally suite:# Wrong: def foo[]: try: 1 / 0 finally: return 42

Chú thích chức năng

Với sự chấp nhận của PEP 484, các quy tắc phong cách cho các chú thích chức năng đã thay đổi.

  • Chú thích chức năng nên sử dụng cú pháp PEP 484 [có một số đề xuất định dạng để chú thích trong phần trước].
  • Thử nghiệm với các phong cách chú thích được khuyến nghị trước đây trong PEP này không còn được khuyến khích nữa.
  • Tuy nhiên, bên ngoài STDLIB, các thí nghiệm trong các quy tắc của PEP 484 hiện được khuyến khích. Ví dụ, đánh dấu một thư viện hoặc ứng dụng của bên thứ ba lớn với các chú thích kiểu kiểu PEP 484, xem xét mức độ dễ dàng để thêm các chú thích đó và quan sát xem sự hiện diện của chúng có tăng khả năng hiểu của mã hay không.
  • Thư viện tiêu chuẩn Python phải bảo thủ trong việc áp dụng các chú thích như vậy, nhưng việc sử dụng chúng được cho phép cho mã mới và cho các chất tái cấu trúc lớn.
  • Đối với mã muốn sử dụng các chú thích chức năng khác, nên đặt nhận xét của biểu mẫu:

    gần đầu tập tin; Điều này bảo kiểm tra loại để bỏ qua tất cả các chú thích. [Có thể tìm thấy nhiều cách khác để vô hiệu hóa các khiếu nại từ người kiểm tra loại trong PEP 484.]

  • Giống như linter, người kiểm tra loại là các công cụ riêng biệt, riêng biệt. Theo mặc định, các phiên dịch viên Python không nên phát hành bất kỳ tin nhắn nào do kiểm tra loại và không nên thay đổi hành vi của họ dựa trên các chú thích.
  • Người dùng không muốn sử dụng người kiểm tra loại có thể tự do bỏ qua chúng. Tuy nhiên, người dùng của các gói thư viện bên thứ ba có thể muốn chạy trình kiểm tra loại qua các gói đó. Đối với mục đích này, PEP 484 khuyến nghị sử dụng các tệp sơ khai: Các tệp .pyi được đọc bởi Trình kiểm tra loại theo sở thích của các tệp .py tương ứng. Các tệp sơ khai có thể được phân phối với một thư viện hoặc riêng biệt [với quyền của tác giả thư viện] thông qua repo được đánh máy [5].

Chú thích biến

PEP 526 giới thiệu các chú thích thay đổi. Các đề xuất về kiểu cho chúng tương tự như các chú thích chức năng được mô tả ở trên:

  • Chú thích cho các biến cấp mô -đun, các biến lớp và thể hiện và các biến cục bộ phải có một không gian duy nhất sau đại tràng.
  • Không nên có không gian trước đại tràng.
  • Nếu một bài tập có phía bên tay phải, thì dấu hiệu bình đẳng sẽ có chính xác một khoảng trống ở cả hai bên:# đúng Không có khoảng trống sau Coloncode: Int# Space trước Đại tá# Correct: code: int class Point: coords: Tuple[int, int] label: str = '' # Wrong: code:int # No space after colon code : int # Space before colon class Test: result: int=0 # No spaces around equality sign
  • Mặc dù PEP 526 được chấp nhận cho Python 3.6, cú pháp chú thích thay đổi là cú pháp ưa thích cho các tệp sơ khai trên tất cả các phiên bản của Python [xem PEP 484 để biết chi tiết].

Chú thích

Người giới thiệu

Bản quyền

Tài liệu này đã được đặt trong phạm vi công cộng.