programming python

Vì không có trong python

Trang web này được hỗ trợ rộng rãi bởi DataCamp. DataCamp cung cấp Hướng dẫn Python tương tác trực tuyến cho Khoa học dữ liệu. Tham gia cùng 575.000 người học khác và bắt đầu học Python cho khoa học dữ liệu ngay hôm nay

Chào mừng đến với LearnPython. hướng dẫn Python tương tác org

Cho dù bạn có phải là một lập trình viên có kinh nghiệm hay không, trang web này dành cho tất cả những ai muốn học ngôn ngữ lập trình Python

Bạn được hoan nghênh tham gia nhóm của chúng tôi trên Facebook để đặt câu hỏi, thảo luận và cập nhật

Sau khi bạn hoàn thành các hướng dẫn, bạn có thể được chứng nhận tại LearnX và thêm chứng nhận của bạn vào hồ sơ LinkedIn của bạn

Python là ngôn ngữ động chính được sử dụng tại Google. Hướng dẫn về phong cách này là danh sách những điều nên làm và không nên làm đối với các chương trình Python

Để giúp bạn định dạng mã chính xác, chúng tôi đã tạo tệp cài đặt cho Vim. Đối với Emacs, cài đặt mặc định sẽ ổn

Nhiều nhóm sử dụng trình định dạng tự động yapf để tránh tranh cãi về định dạng

2 Quy tắc ngôn ngữ Python

2. 1 xơ vải

Chạy

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

18 trên mã của bạn bằng cách sử dụng pylintrc này

2. 1. 1 Định nghĩa

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

18 là một công cụ để tìm lỗi và các vấn đề về kiểu dáng trong mã nguồn Python. Nó tìm thấy các vấn đề thường được trình biên dịch bắt gặp đối với các ngôn ngữ kém năng động hơn như C và C++. Do tính chất động của Python, một số cảnh báo có thể không chính xác;

2. 1. 2 Ưu điểm

Bắt các lỗi dễ bỏ sót như lỗi chính tả, sử dụng-vars-trước khi gán, v.v.

2. 1. 3 nhược điểm

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

18 không hoàn hảo. Để tận dụng lợi thế của nó, đôi khi chúng ta cần phải viết xung quanh nó, loại bỏ các cảnh báo của nó hoặc sửa chữa nó

2. 1. 4 Quyết định

Hãy chắc chắn rằng bạn chạy

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

18 trên mã của bạn

Loại bỏ các cảnh báo nếu chúng không phù hợp để các vấn đề khác không bị ẩn. Để chặn cảnh báo, bạn có thể đặt nhận xét cấp dòng

dict = 'something awful'  # Bad Idea.. pylint: disable=redefined-builtin

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

18 cảnh báo, mỗi cảnh báo được xác định bằng tên tượng trưng [

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

23] Cảnh báo dành riêng cho Google bắt đầu bằng

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

Nếu lý do ngăn chặn không rõ ràng từ tên biểu tượng, hãy thêm một lời giải thích

Loại bỏ theo cách này có lợi thế là chúng ta có thể dễ dàng tìm kiếm các loại bỏ và xem lại chúng

Bạn có thể nhận danh sách

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

18 cảnh báo bằng cách thực hiện

Để có thêm thông tin về một tin nhắn cụ thể, hãy sử dụng

Thích

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

26 hơn mẫu cũ hơn không dùng nữa

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

Có thể loại bỏ các cảnh báo đối số không sử dụng bằng cách xóa các biến ở đầu hàm. Luôn bao gồm một bình luận giải thích lý do tại sao bạn xóa nó. “Không sử dụng. " là đủ. Ví dụ

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

Các hình thức phổ biến khác để loại bỏ cảnh báo này bao gồm sử dụng '

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

28' làm mã định danh cho đối số không được sử dụng hoặc thêm tiền tố vào tên đối số bằng '

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

29' hoặc gán chúng cho '

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

28'. Các hình thức này được cho phép nhưng không còn được khuyến khích. Những trình gọi ngắt này chuyển đối số theo tên và không thực thi rằng đối số thực sự không được sử dụng

2. 2 nhập khẩu

Chỉ sử dụng các câu lệnh

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

31 cho các gói và mô-đun, không dùng cho các lớp hoặc chức năng riêng lẻ

2. 2. 1 Định nghĩa

Cơ chế tái sử dụng để chia sẻ mã từ mô-đun này sang mô-đun khác

2. 2. 2 Ưu điểm

Quy ước quản lý không gian tên rất đơn giản. Nguồn của mỗi mã định danh được chỉ định một cách nhất quán;

2. 2. 3 nhược điểm

Tên mô-đun vẫn có thể xung đột. Một số tên mô-đun dài bất tiện

2. 2. 4 Quyết định

Sử dụng

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

35 để nhập các gói và mô-đun

Sử dụng

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

36 trong đó

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

34 là tiền tố gói và

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

38 là tên mô-đun không có tiền tố

Sử dụng

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

39 nếu hai mô-đun có tên

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

38 được nhập, nếu

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

38 xung đột với tên cấp cao nhất được xác định trong mô-đun hiện tại hoặc nếu

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

38 là một tên dài bất tiện

Chỉ sử dụng

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

43 khi

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

44 là cách viết tắt tiêu chuẩn [e. g. ,

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

45 cho

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

46]

Ví dụ: mô-đun

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

47 có thể được nhập như sau

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

Không sử dụng tên họ hàng trong nhập khẩu. Ngay cả khi mô-đun nằm trong cùng một gói, hãy sử dụng tên gói đầy đủ. Điều này giúp ngăn việc vô tình nhập một gói hai lần

2. 2. 4. 1 miễn trừ

Miễn trừ từ quy tắc này

Các ký hiệu từ các mô-đun sau được sử dụng để hỗ trợ phân tích tĩnh và kiểm tra kiểu
Chuyển hướng từ

2. 3 gói

Nhập từng mô-đun bằng vị trí tên đường dẫn đầy đủ của mô-đun

2. 3. 1 Ưu điểm

Tránh xung đột về tên mô-đun hoặc nhập sai do đường dẫn tìm kiếm mô-đun không như tác giả mong đợi. Giúp tìm kiếm các mô-đun dễ dàng hơn

2. 3. 2 nhược điểm

Làm cho việc triển khai mã trở nên khó khăn hơn vì bạn phải sao chép hệ thống phân cấp gói. Không thực sự là một vấn đề với các cơ chế triển khai hiện đại

2. 3. 3 Quyết định

Tất cả mã mới phải nhập từng mô-đun theo tên gói đầy đủ của nó

Nhập khẩu phải như sau

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

Yes:
  # Reference flags in code with just the module name [common].
  from absl import flags
  from doctor.who import jodie

  _FOO = flags.DEFINE_string[...]

[giả sử tệp này tồn tại ở

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

48 nơi mà

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

49 cũng tồn tại]

No:
  # Unclear what module the author wanted and what will be imported.  The actual
  # import behavior depends on external factors controlling sys.path.
  # Which possible jodie module did the author intend to import?
  import jodie

Thư mục chứa tệp nhị phân chính không nên được coi là ở trong

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

50 mặc dù điều đó xảy ra trong một số môi trường. Trong trường hợp này, mã phải giả định rằng

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

51 đề cập đến bên thứ ba hoặc gói cấp cao nhất có tên là

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

52, không phải là địa phương

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

2. 4 ngoại lệ

Ngoại lệ được cho phép nhưng phải được sử dụng cẩn thận

2. 4. 1 Định nghĩa

Ngoại lệ là phương tiện thoát ra khỏi luồng điều khiển thông thường để xử lý lỗi hoặc các điều kiện ngoại lệ khác

2. 4. 2 Ưu điểm

Luồng điều khiển của mã hoạt động bình thường không bị lộn xộn bởi mã xử lý lỗi. Nó cũng cho phép luồng điều khiển bỏ qua nhiều khung khi một điều kiện nhất định xảy ra, e. g. , quay lại từ N hàm lồng nhau trong một bước thay vì phải tìm mã lỗi thông qua

2. 4. 3 nhược điểm

Có thể khiến luồng điều khiển bị nhầm lẫn. Dễ bỏ sót các trường hợp lỗi khi gọi thư viện

2. 4. 4 Quyết định

Ngoại lệ phải tuân theo các điều kiện nhất định

Sử dụng các lớp ngoại lệ tích hợp khi nó hợp lý. Ví dụ: tăng

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

54 để chỉ ra lỗi lập trình như điều kiện tiên quyết bị vi phạm [chẳng hạn như nếu bạn được thông qua số âm nhưng yêu cầu số dương]. Không sử dụng câu lệnh

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

55 để xác thực giá trị đối số của API công khai.

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

55 được sử dụng để đảm bảo tính đúng đắn bên trong, không phải để bắt buộc sử dụng đúng cách cũng như không chỉ ra rằng một số sự kiện bất ngờ đã xảy ra. Nếu một ngoại lệ được mong muốn trong các trường hợp sau, hãy sử dụng câu lệnh nâng cao. Ví dụ

Yes:
  def connect_to_next_port[self, minimum: int] -> int:
    """Connects to the next available port.

    Args:
      minimum: A port value greater or equal to 1024.

    Returns:
      The new minimum port.

    Raises:
      ConnectionError: If no available port is found.
    """
    if minimum < 1024:
      # Note that this raising of ValueError is not mentioned in the doc
      # string's "Raises:" section because it is not appropriate to
      # guarantee this specific behavioral reaction to API misuse.
      raise ValueError[f'Min. port must be at least 1024, not {minimum}.']
    port = self._find_next_open_port[minimum]
    if port is None:
      raise ConnectionError[
          f'Could not connect to service on port {minimum} or higher.']
    assert port >= minimum, [
        f'Unexpected port {port} when minimum was {minimum}.']
    return port

No:
  def connect_to_next_port[self, minimum: int] -> int:
    """Connects to the next available port.

    Args:
      minimum: A port value greater or equal to 1024.

    Returns:
      The new minimum port.
    """
    assert minimum >= 1024, 'Minimum port must be at least 1024.'
    port = self._find_next_open_port[minimum]
    assert port is not None
    return port

Thư viện hoặc gói có thể xác định ngoại lệ của riêng họ. Khi làm như vậy, họ phải kế thừa từ một lớp ngoại lệ hiện có. Tên ngoại lệ phải kết thúc bằng

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

57 và không nên lặp lại [

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

58]

Không bao giờ sử dụng câu lệnh bắt tất cả
```
def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam
```
59 hoặc bắt
```
def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam
```
60 hoặc
```
def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam
```
61, trừ khi bạn
- tăng lại ngoại lệ, hoặc
- tạo một điểm cách ly trong chương trình nơi các ngoại lệ không được lan truyền mà thay vào đó được ghi lại và loại bỏ, chẳng hạn như bảo vệ một chuỗi khỏi sự cố bằng cách bảo vệ khối ngoài cùng của nó
Python rất khoan dung về vấn đề này và
```
def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam
```
59 sẽ thực sự nắm bắt mọi thứ kể cả tên sai chính tả, sys. các cuộc gọi exit[], Ctrl+C ngắt, lỗi nhỏ nhất và tất cả các loại ngoại lệ khác mà bạn đơn giản là không muốn nắm bắt

Giảm thiểu số lượng mã trong một khối

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

63/

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

64. Phần thân của

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

63 càng lớn thì càng có nhiều khả năng một ngoại lệ sẽ được đưa ra bởi một dòng mã mà bạn không mong đợi sẽ đưa ra một ngoại lệ. Trong những trường hợp đó, khối

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

63/

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

64 ẩn một lỗi thực sự

Sử dụng mệnh đề

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

68 để thực thi mã cho dù có hay không một ngoại lệ được đưa ra trong khối

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

63. Điều này thường hữu ích cho việc dọn dẹp, tôi. e. , đóng một tập tin

2. 5 trạng thái toàn cầu có thể thay đổi

Tránh trạng thái toàn cầu có thể thay đổi

2. 5. 1 Định nghĩa

Các giá trị cấp mô-đun hoặc thuộc tính lớp có thể bị thay đổi trong quá trình thực thi chương trình

2. 5. 2 Ưu điểm

Thỉnh thoảng hữu ích

2. 5. 3 nhược điểm

Phá vỡ đóng gói. Thiết kế như vậy có thể gây khó khăn cho việc đạt được các mục tiêu hợp lệ. Ví dụ: nếu trạng thái chung được sử dụng để quản lý kết nối cơ sở dữ liệu, thì việc kết nối với hai cơ sở dữ liệu khác nhau cùng một lúc [chẳng hạn như đối với sự khác biệt về tính toán trong quá trình di chuyển] sẽ trở nên khó khăn. Các vấn đề tương tự dễ dàng phát sinh với các cơ quan đăng ký toàn cầu
Có khả năng thay đổi hành vi của mô-đun trong quá trình nhập, vì việc gán cho các biến toàn cục được thực hiện khi mô-đun được nhập lần đầu

2. 5. 4 Quyết định

Tránh trạng thái toàn cầu có thể thay đổi

Trong những trường hợp hiếm hoi khi sử dụng trạng thái toàn cầu được đảm bảo, các thực thể toàn cầu có thể thay đổi phải được khai báo ở cấp độ mô-đun hoặc dưới dạng thuộc tính lớp và được tạo nội bộ bằng cách thêm một _______28 vào tên. Nếu cần, quyền truy cập bên ngoài vào trạng thái toàn cầu có thể thay đổi phải được thực hiện thông qua các hàm công khai hoặc phương thức lớp. Xem bên dưới. Vui lòng giải thích lý do thiết kế tại sao trạng thái chung có thể thay đổi đang được sử dụng trong nhận xét hoặc tài liệu được liên kết từ nhận xét

Hằng số cấp mô-đun được cho phép và khuyến khích. Ví dụ.

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

71 cho hằng số sử dụng nội bộ hoặc

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

72 cho hằng số API công khai. Các hằng số phải được đặt tên bằng cách sử dụng tất cả các chữ hoa có dấu gạch dưới. Xem bên dưới

2. 6 Các lớp và hàm lồng nhau/cục bộ/bên trong

Các hàm hoặc lớp cục bộ lồng nhau vẫn ổn khi được sử dụng để đóng trên một biến cục bộ. Các lớp bên trong vẫn ổn

2. 6. 1 Định nghĩa

Một lớp có thể được định nghĩa bên trong một phương thức, hàm hoặc lớp. Một hàm có thể được định nghĩa bên trong một phương thức hoặc hàm. Các hàm lồng nhau có quyền truy cập chỉ đọc vào các biến được xác định trong phạm vi kèm theo

2. 6. 2 Ưu điểm

Cho phép định nghĩa các lớp và chức năng tiện ích chỉ được sử dụng bên trong phạm vi rất hạn chế. Rất ADT-y. Thường được sử dụng để thực hiện trang trí

2. 6. 3 nhược điểm

Các hàm và lớp lồng nhau không thể được kiểm tra trực tiếp. Việc lồng nhau có thể làm cho chức năng bên ngoài dài hơn và khó đọc hơn

2. 6. 4 Quyết định

Họ ổn với một số lưu ý. Tránh các hàm hoặc lớp lồng nhau trừ khi đóng trên một giá trị cục bộ khác với

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

73 hoặc

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

74. Không lồng chức năng chỉ để ẩn nó khỏi người dùng mô-đun. Thay vào đó, hãy đặt tiền tố tên của nó bằng _ ở cấp độ mô-đun để nó vẫn có thể được truy cập bằng các thử nghiệm

2. 7 cách hiểu và biểu thức trình tạo

Được rồi để sử dụng cho các trường hợp đơn giản

2. 7. 1 Định nghĩa

Khả năng hiểu List, Dict và Set cũng như các biểu thức trình tạo cung cấp một cách ngắn gọn và hiệu quả để tạo các loại bộ chứa và bộ lặp mà không cần sử dụng các vòng lặp truyền thống,

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

75,

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

76 hoặc

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

2. 7. 2 Ưu điểm

Việc hiểu đơn giản có thể rõ ràng và đơn giản hơn các kỹ thuật tạo chính tả, danh sách hoặc tập hợp khác. Biểu thức trình tạo có thể rất hiệu quả, vì chúng tránh hoàn toàn việc tạo danh sách

2. 7. 3 nhược điểm

Có thể khó đọc các biểu thức trình tạo hoặc hiểu phức tạp

2. 7. 4 Quyết định

Được rồi để sử dụng cho các trường hợp đơn giản. Mỗi phần phải vừa trên một dòng. biểu thức ánh xạ, mệnh đề

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

78, biểu thức bộ lọc. Nhiều mệnh đề

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

78 hoặc biểu thức bộ lọc không được phép. Thay vào đó, hãy sử dụng các vòng lặp khi mọi thứ trở nên phức tạp hơn

Yes:
  result = [mapping_expr for value in iterable if filter_expr]

  result = [{'key': value} for value in iterable
            if a_long_filter_expression[value]]

  result = [complicated_transform[x]
            for x in iterable if predicate[x]]

  descriptive_name = [
      transform[{'key': key, 'value': value}, color='black']
      for key, value in generate_iterable[some_input]
      if complicated_condition_is_met[key, value]
  ]

  result = []
  for x in range[10]:
      for y in range[5]:
          if x * y > 10:
              result.append[[x, y]]

  return {x: complicated_transform[x]
          for x in long_generator_function[parameter]
          if x is not None}

  squares_generator = [x**2 for x in range[10]]

  unique_names = {user.name for user in users if user is not None}

  eat[jelly_bean for jelly_bean in jelly_beans
      if jelly_bean.color == 'black']

No:
  result = [complicated_transform[
                x, some_argument=x+1]
            for x in iterable if predicate[x]]

  result = [[x, y] for x in range[10] for y in range[5] if x * y > 10]

  return [[x, y, z]
          for x in range[5]
          for y in range[5]
          if x != y
          for z in range[5]
          if y != z]

2. 8 Iterator và Operator mặc định

Sử dụng các trình lặp và toán tử mặc định cho các loại hỗ trợ chúng, như danh sách, từ điển và tệp

2. 8. 1 Định nghĩa

Các loại vùng chứa, như từ điển và danh sách, xác định các trình vòng lặp mặc định và toán tử kiểm tra tư cách thành viên [“in” và “not in”]

2. 8. 2 Ưu điểm

Các trình vòng lặp và toán tử mặc định rất đơn giản và hiệu quả. Chúng thể hiện thao tác trực tiếp mà không cần gọi thêm phương thức. Một hàm sử dụng các toán tử mặc định là chung chung. Nó có thể được sử dụng với bất kỳ loại nào hỗ trợ hoạt động

2. 8. 3 nhược điểm

Bạn không thể biết loại đối tượng bằng cách đọc tên phương thức [trừ khi biến có chú thích loại]. Đây cũng là một lợi thế

2. 8. 4 Quyết định

Sử dụng các trình lặp và toán tử mặc định cho các loại hỗ trợ chúng, như danh sách, từ điển và tệp. Các loại tích hợp cũng xác định các phương thức lặp. Ưu tiên các phương thức này hơn các phương thức trả về danh sách, ngoại trừ việc bạn không nên thay đổi vùng chứa trong khi lặp lại nó

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

2. 9 máy phát điện

Sử dụng máy phát điện khi cần thiết

2. 9. 1 Định nghĩa

Hàm tạo trả về một trình vòng lặp mang lại một giá trị mỗi khi nó thực thi câu lệnh năng suất. Sau khi nó mang lại một giá trị, trạng thái thời gian chạy của hàm tạo bị tạm dừng cho đến khi cần giá trị tiếp theo

2. 9. 2 Ưu điểm

Mã đơn giản hơn, vì trạng thái của các biến cục bộ và luồng điều khiển được giữ nguyên cho mỗi cuộc gọi. Trình tạo sử dụng ít bộ nhớ hơn so với hàm tạo toàn bộ danh sách giá trị cùng một lúc

2. 9. 3 nhược điểm

Các biến cục bộ trong trình tạo sẽ không được thu gom rác cho đến khi trình tạo bị tiêu thụ đến mức cạn kiệt hoặc chính nó đã được thu gom rác

2. 9. 4 Quyết định

Khỏe. Sử dụng “Năng suất. ” thay vì “Trả về. ” trong chuỗi tài liệu cho các hàm tạo

Nếu trình tạo quản lý một tài nguyên đắt tiền, hãy đảm bảo buộc dọn dẹp

Một cách hay để dọn dẹp là bọc trình tạo bằng trình quản lý ngữ cảnh PEP-0533

2. 10 Hàm Lambda

Được rồi cho một lớp lót. Thích các biểu thức trình tạo hơn

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

75 hoặc

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

76 với một

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

2. 10. 1 Định nghĩa

Lambdas định nghĩa các hàm ẩn danh trong một biểu thức, trái ngược với một câu lệnh

2. 10. 2 Ưu điểm

Tiện lợi

2. 10. 3 nhược điểm

Khó đọc và gỡ lỗi hơn các chức năng cục bộ. Việc thiếu tên có nghĩa là dấu vết ngăn xếp khó hiểu hơn. Tính biểu cảm bị hạn chế vì chức năng chỉ có thể chứa một biểu thức

2. 10. 4 Quyết định

Được rồi để sử dụng chúng cho một lớp lót. Nếu mã bên trong hàm lambda dài hơn 60-80 ký tự, thì có lẽ tốt hơn nên xác định mã đó là mã thông thường

Đối với các hoạt động phổ biến như phép nhân, hãy sử dụng các hàm từ mô-đun

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

83 thay vì các hàm lambda. Ví dụ: thích

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

84 hơn là

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

2. 11 Biểu thức điều kiện

Được rồi cho các trường hợp đơn giản

2. 11. 1 Định nghĩa

Biểu thức điều kiện [đôi khi được gọi là “toán tử bậc ba”] là cơ chế cung cấp cú pháp ngắn hơn cho câu lệnh if. Ví dụ.

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

2. 11. 2 Ưu điểm

Ngắn gọn và thuận tiện hơn câu lệnh if

2. 11. 3 nhược điểm

Có thể khó đọc hơn câu lệnh if. Điều kiện có thể khó xác định nếu biểu thức dài

2. 11. 4 Quyết định

Được rồi để sử dụng cho các trường hợp đơn giản. Mỗi phần phải vừa trên một dòng. biểu thức đúng, biểu thức if, biểu thức khác. Sử dụng câu lệnh if hoàn chỉnh khi mọi thứ trở nên phức tạp hơn

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

2. 12 giá trị đối số mặc định

Được rồi trong hầu hết các trường hợp

2. 12. 1 Định nghĩa

Bạn có thể chỉ định giá trị cho các biến ở cuối danh sách tham số của hàm, chẳng hạn như. g. ,

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

87. Nếu

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

88 được gọi chỉ với một đối số, thì

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

89 được đặt thành 0. Nếu nó được gọi với hai đối số, thì

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

89 có giá trị của đối số thứ hai

2. 12. 2 Ưu điểm

Thường thì bạn có một hàm sử dụng nhiều giá trị mặc định, nhưng trong một số trường hợp hiếm hoi, bạn muốn ghi đè lên các giá trị mặc định. Các giá trị đối số mặc định cung cấp một cách dễ dàng để thực hiện việc này mà không cần phải xác định nhiều hàm cho các trường hợp ngoại lệ hiếm gặp. Vì Python không hỗ trợ các phương thức/hàm quá tải, nên các đối số mặc định là một cách dễ dàng để “làm giả” hành vi quá tải

2. 12. 3 nhược điểm

Các đối số mặc định được đánh giá một lần tại thời điểm tải mô-đun. Điều này có thể gây ra sự cố nếu đối số là đối tượng có thể thay đổi, chẳng hạn như danh sách hoặc từ điển. Nếu chức năng sửa đổi đối tượng [e. g. , bằng cách thêm một mục vào danh sách], giá trị mặc định được sửa đổi

2. 12. 4 Quyết định

Được rồi để sử dụng với cảnh báo sau

Không sử dụng các đối tượng có thể thay đổi làm giá trị mặc định trong định nghĩa hàm hoặc phương thức

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

2. 13 thuộc tính

Các thuộc tính có thể được sử dụng để kiểm soát việc nhận hoặc thiết lập các thuộc tính yêu cầu tính toán hoặc logic thông thường. Việc triển khai thuộc tính phải phù hợp với kỳ vọng chung của quyền truy cập thuộc tính thông thường. rằng chúng rẻ, đơn giản và không gây ngạc nhiên

2. 13. 1 Định nghĩa

Một cách để gói các cuộc gọi phương thức để nhận và đặt thuộc tính làm quyền truy cập thuộc tính tiêu chuẩn

2. 13. 2 Ưu điểm

Cho phép API gán và truy cập thuộc tính thay vì gọi phương thức
Có thể được sử dụng để tạo thuộc tính chỉ đọc
Allows calculations to be lazy
Provides a way to maintain the public interface of a class when the internals evolve independently of class users

2. 13. 3 nhược điểm

Có thể ẩn các tác dụng phụ giống như quá tải toán tử
Can be confusing for subclasses

2. 13. 4 Quyết định

Các thuộc tính được cho phép, nhưng, giống như quá tải toán tử, chỉ nên được sử dụng khi cần thiết và phù hợp với mong đợi của truy cập thuộc tính điển hình;

For example, using a property to simply both get and set an internal attribute isn’t allowed. không có tính toán xảy ra, vì vậy thuộc tính là không cần thiết []. Trong khi đó, việc sử dụng một thuộc tính để kiểm soát quyền truy cập thuộc tính hoặc để tính toán một giá trị có nguồn gốc tầm thường được cho phép. logic rất đơn giản và không có gì đáng ngạc nhiên

Các thuộc tính nên được tạo bằng

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

91. Thực hiện thủ công một bộ mô tả thuộc tính được coi là một

Inheritance with properties can be non-obvious. Do not use properties to implement computations a subclass may ever want to override and extend

2. 14 True/False Evaluations

Use the “implicit” false if at all possible

2. 14. 1 Definition

Python evaluates certain values as

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

92 when in a boolean context. A quick “rule of thumb” is that all “empty” values are considered false, so

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

93 all evaluate as false in a boolean context

2. 14. 2 Pros

Conditions using Python booleans are easier to read and less error-prone. In most cases, they’re also faster

2. 14. 3 Cons

May look strange to C/C++ developers

2. 14. 4 Decision

Use the “implicit” false if possible, e. g. ,

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

94 rather than

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

95. There are a few caveats that you should keep in mind though

Always use

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

96 [or

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

97] to check for a

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

98 value. E. g. , when testing whether a variable or argument that defaults to

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

98 was set to some other value. The other value might be a value that’s false in a boolean context

Never compare a boolean variable to

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

92 using

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

01. Use

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

02 instead. If you need to distinguish

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

92 from

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

98 then chain the expressions, such as

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

For sequences [strings, lists, tuples], use the fact that empty sequences are false, so

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

06 and

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

07 are preferable to

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

08 and

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

09 respectively

When handling integers, implicit false may involve more risk than benefit [i. e. , accidentally handling

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

98 as 0]. You may compare a value which is known to be an integer [and is not the result of

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

11] against the integer 0

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

Note that

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

12 [i. e. ,

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

13 as string] evaluates to true

Note that Numpy arrays may raise an exception in an implicit boolean context. Prefer the

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

14 attribute when testing emptiness of a

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

15 [e. g.

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

16]

2. 16 Lexical Scoping

Okay to use

2. 16. 1 Definition

A nested Python function can refer to variables defined in enclosing functions, but cannot assign to them. Variable bindings are resolved using lexical scoping, that is, based on the static program text. Any assignment to a name in a block will cause Python to treat all references to that name as a local variable, even if the use precedes the assignment. If a global declaration occurs, the name is treated as a global variable

Một ví dụ về việc sử dụng tính năng này là

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

2. 16. 2 Pros

Often results in clearer, more elegant code. Especially comforting to experienced Lisp and Scheme [and Haskell and ML and …] programmers

2. 16. 3 Cons

Can lead to confusing bugs. Such as this example based on PEP-0227

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

17 will print

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

18, not

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

2. 16. 4 Decision

Okay to use

2. 17 Trình trang trí chức năng và phương thức

Sử dụng decorators một cách thận trọng khi có một lợi thế rõ ràng. Tránh

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

20 và hạn chế sử dụng

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

2. 17. 1 Định nghĩa

[một. k. một “ký hiệu

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

22”]. Một trình trang trí phổ biến là

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

91, được sử dụng để chuyển đổi các phương thức thông thường thành các thuộc tính được tính toán động. Tuy nhiên, cú pháp của trình trang trí cũng cho phép các trình trang trí do người dùng định nghĩa. Cụ thể, đối với một số chức năng

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

24, điều này

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

tương đương với

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

2. 17. 2 Ưu điểm

Chỉ định một cách trang nhã một số chuyển đổi trên một phương thức;

2. 17. 3 nhược điểm

Trình trang trí có thể thực hiện các thao tác tùy ý trên đối số của hàm hoặc trả về giá trị, dẫn đến hành vi ngầm đáng ngạc nhiên. Ngoài ra, các trình trang trí thực thi tại thời điểm xác định đối tượng. Đối với các đối tượng cấp mô-đun [lớp, chức năng mô-đun,…] điều này xảy ra tại thời điểm nhập. Lỗi trong mã trang trí hầu như không thể phục hồi từ

2. 17. 4 Quyết định

Sử dụng decorators một cách thận trọng khi có một lợi thế rõ ràng. Người trang trí phải tuân theo các nguyên tắc nhập và đặt tên giống như các chức năng. Trình trang trí pydoc phải nêu rõ rằng chức năng này là một trình trang trí. Viết bài kiểm tra đơn vị cho người trang trí

Tránh các phụ thuộc bên ngoài trong chính trình trang trí [e. g. không dựa vào tệp, ổ cắm, kết nối cơ sở dữ liệu, v.v. ], vì chúng có thể không khả dụng khi trình trang trí chạy [tại thời điểm nhập, có thể từ

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

25 hoặc các công cụ khác]. Một trình trang trí được gọi với các tham số hợp lệ phải [càng nhiều càng tốt] được đảm bảo thành công trong mọi trường hợp

Trình trang trí là trường hợp đặc biệt của “mã cấp cao nhất” - xem để thảo luận thêm

Không bao giờ sử dụng

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

20 trừ khi bị buộc phải tích hợp với API được xác định trong thư viện hiện có. Thay vào đó hãy viết một hàm cấp mô-đun

Chỉ sử dụng

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

21 khi viết một hàm tạo được đặt tên hoặc một quy trình dành riêng cho lớp để sửa đổi trạng thái chung cần thiết, chẳng hạn như bộ đệm trên toàn quy trình

2. 18 luồng

Không dựa vào tính nguyên tử của các loại tích hợp

Mặc dù các kiểu dữ liệu tích hợp sẵn của Python, chẳng hạn như từ điển, dường như có các hoạt động nguyên tử, nhưng có một số trường hợp chúng không phải là nguyên tử [e. g. nếu

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

28 hoặc

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

29 được triển khai dưới dạng phương thức Python] và không nên dựa vào tính nguyên tử của chúng. Bạn cũng không nên dựa vào phép gán biến nguyên tử [vì điều này lại phụ thuộc vào từ điển]

Sử dụng kiểu dữ liệu

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

30 của mô-đun Hàng đợi làm cách ưu tiên để giao tiếp dữ liệu giữa các luồng. Nếu không, hãy sử dụng mô-đun luồng và các nguyên hàm khóa của nó. Ưu tiên các biến điều kiện và

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

31 thay vì sử dụng các khóa cấp thấp hơn

2. 19 Tính năng nguồn

Tránh các tính năng này

2. 19. 1 Định nghĩa

Python là một ngôn ngữ cực kỳ linh hoạt và cung cấp cho bạn nhiều tính năng ưa thích như siêu dữ liệu tùy chỉnh, quyền truy cập vào mã byte, biên dịch nhanh, kế thừa động, sửa chữa đối tượng, hack nhập, phản chiếu [e. g. một số cách sử dụng của

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

32], sửa đổi bên trong hệ thống, phương pháp

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

33 thực hiện dọn dẹp tùy chỉnh, v.v.

2. 19. 2 Ưu điểm

Đây là những tính năng ngôn ngữ mạnh mẽ. Họ có thể làm cho mã của bạn gọn hơn

2. 19. 3 nhược điểm

Rất hấp dẫn khi sử dụng những tính năng “hay ho” này khi chúng không thực sự cần thiết. Khó đọc, hiểu và gỡ lỗi mã đang sử dụng các tính năng bất thường bên dưới. Thoạt đầu có vẻ không phải như vậy [đối với tác giả gốc], nhưng khi xem lại mã, nó có xu hướng khó hơn mã dài hơn nhưng đơn giản

2. 19. 4 Quyết định

Tránh các tính năng này trong mã của bạn

Các mô-đun và lớp thư viện tiêu chuẩn sử dụng nội bộ các tính năng này đều được phép sử dụng [ví dụ:

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

34,

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

35 và

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

36]

2. 20 con trăn hiện đại. từ future nhập khẩu

Các thay đổi ngữ nghĩa của phiên bản ngôn ngữ mới có thể được kiểm soát sau quá trình nhập đặc biệt trong tương lai để kích hoạt chúng trên cơ sở từng tệp trong thời gian chạy trước đó

2. 20. 1 Định nghĩa

Có thể bật một số tính năng hiện đại hơn thông qua câu lệnh

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

37 cho phép sử dụng sớm các tính năng từ các phiên bản Python dự kiến trong tương lai

2. 20. 2 Ưu điểm

Điều này đã được chứng minh là giúp nâng cấp phiên bản thời gian chạy mượt mà hơn vì các thay đổi có thể được thực hiện trên cơ sở từng tệp trong khi khai báo tính tương thích và ngăn chặn hồi quy trong các tệp đó. Mã hiện đại dễ bảo trì hơn vì ít có khả năng tích lũy nợ kỹ thuật sẽ gây ra sự cố trong quá trình nâng cấp thời gian chạy trong tương lai

2. 20. 3 nhược điểm

Mã như vậy có thể không hoạt động trên các phiên bản thông dịch viên rất cũ trước khi đưa ra câu lệnh tương lai cần thiết. Nhu cầu này phổ biến hơn trong các dự án hỗ trợ rất nhiều môi trường

2. 20. 4 Quyết định

từ __future__ nhập khẩu

Việc sử dụng các câu lệnh

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

37 được khuyến khích. Nó cho phép một tệp nguồn nhất định bắt đầu sử dụng các tính năng cú pháp Python hiện đại hơn ngày nay. Sau khi bạn không còn cần chạy trên phiên bản mà các tính năng bị ẩn đằng sau lần nhập

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

39, vui lòng xóa các dòng đó

Trong mã có thể thực thi trên các phiên bản cũ như 3. 5 thay vì >= 3. 7, nhập khẩu

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

For more information read the Python future statement definitions documentation

Vui lòng không xóa các mục nhập này cho đến khi bạn tin rằng mã này chỉ được sử dụng trong một môi trường đủ hiện đại. Even if you do not currently use the feature a specific future import enables in your code today, keeping it in place in the file prevents later modifications of the code from inadvertently depending on the older behavior

Sử dụng các câu lệnh nhập khẩu

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

40 khác khi bạn thấy phù hợp

2. 21 Loại mã chú thích

Bạn có thể chú thích mã Python bằng gợi ý loại theo PEP-484 và kiểm tra loại mã khi xây dựng bằng công cụ kiểm tra loại như pytype

Type annotations can be in the source or in a . Bất cứ khi nào có thể, chú thích nên ở trong nguồn. Use pyi files for third-party or extension modules

2. 21. 1 Definition

Type annotations [or “type hints”] are for function or method arguments and return values

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

You can also declare the type of a variable using similar PEP-526 syntax

2. 21. 2 Pros

Loại chú thích cải thiện khả năng đọc và bảo trì mã của bạn. Trình kiểm tra loại sẽ chuyển đổi nhiều lỗi thời gian chạy thành lỗi thời gian xây dựng và giảm khả năng sử dụng của bạn

2. 21. 3 Cons

Bạn sẽ phải cập nhật các khai báo kiểu. You might see type errors that you think are valid code. Use of a type checker may reduce your ability to use

2. 21. 4 Decision

You are strongly encouraged to enable Python type analysis when updating code. When adding or modifying public APIs, include type annotations and enable checking via pytype in the build system. Vì phân tích tĩnh còn tương đối mới đối với Python, chúng tôi thừa nhận rằng các tác dụng phụ không mong muốn [chẳng hạn như các loại được suy luận sai] có thể ngăn một số dự án áp dụng. In those situations, authors are encouraged to add a comment with a TODO or link to a bug describing the issue[s] currently preventing type annotation adoption in the BUILD file or in the code itself as appropriate

3 quy tắc kiểu Python

3. 1 dấu chấm phẩy

Không kết thúc dòng của bạn bằng dấu chấm phẩy và không sử dụng dấu chấm phẩy để đặt hai câu lệnh trên cùng một dòng

3. 2 Line length

Maximum line length is 80 characters

Explicit exceptions to the 80 character limit

Long import statements
URLs, pathnames, or long flags in comments
Long string module level constants not containing whitespace that would be inconvenient to split across lines such as URLs or pathnames
- Pylint vô hiệu hóa bình luận. [e. g.
```
from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]
```
  41]

Do not use backslash line continuation except for

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

42 statements requiring three or more context managers

Make use of Python’s . If necessary, you can add an extra pair of parentheses around an expression

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

When a literal string won’t fit on a single line, use parentheses for implicit line joining

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

Trong các nhận xét, hãy đặt các URL dài trên dòng riêng của chúng nếu cần

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

It is permissible to use backslash continuation when defining a

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

42 statement with three or more context managers. Đối với hai trình quản lý bối cảnh, hãy sử dụng câu lệnh

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

42 lồng nhau

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

Lưu ý về sự thụt đầu dòng của các phần tử trong các ví dụ tiếp tục dòng ở trên;

Trong tất cả các trường hợp khác khi một dòng vượt quá 80 ký tự và trình định dạng tự động yapf không giúp đưa dòng xuống dưới giới hạn, thì dòng đó được phép vượt quá mức tối đa này. Authors are encouraged to manually break the line up per the notes above when it is sensible

3. 3 Parentheses

Use parentheses sparingly

It is fine, though not required, to use parentheses around tuples. Do not use them in return statements or conditional statements unless using parentheses for implied line continuation or to indicate a tuple

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

3. 4 Indentation

Indent your code blocks with 4 spaces

Never use tabs. Implied line continuation should align wrapped elements vertically [see ], or use a hanging 4-space indent. Closing [round, square or curly] brackets can be placed at the end of the expression, or on separate lines, but then should be indented the same as the line with the corresponding opening bracket

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

3. 4. 1 Trailing commas in sequences of items?

Trailing commas in sequences of items are recommended only when the closing container token

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

45,

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

46, or

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

47 does not appear on the same line as the final element. The presence of a trailing comma is also used as a hint to our Python code auto-formatter YAPF to direct it to auto-format the container of items to one item per line when the

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

48 after the final element is present

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

3. 5 Blank Lines

Two blank lines between top-level definitions, be they function or class definitions. One blank line between method definitions and between the docstring of a

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

49 and the first method. No blank line following a

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

50 line. Use single blank lines as you judge appropriate within functions or methods

Blank lines need not be anchored to the definition. For example, related comments immediately preceding function, class, and method definitions can make sense. Consider if your comment might be more useful as part of the docstring

3. 6 Whitespace

Follow standard typographic rules for the use of spaces around punctuation

No whitespace inside parentheses, brackets or braces

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

No whitespace before a comma, semicolon, or colon. Do use whitespace after a comma, semicolon, or colon, except at the end of the line

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

No whitespace before the open paren/bracket that starts an argument list, indexing or slicing

Yes:
  # Reference flags in code with just the module name [common].
  from absl import flags
  from doctor.who import jodie

  _FOO = flags.DEFINE_string[...]

Yes:
  # Reference flags in code with just the module name [common].
  from absl import flags
  from doctor.who import jodie

  _FOO = flags.DEFINE_string[...]

No trailing whitespace

Surround binary operators with a single space on either side for assignment [

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

51], comparisons [

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

52], and Booleans [

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

53]. Use your better judgment for the insertion of spaces around arithmetic operators [

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

54,

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

55,

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

56,

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

57,

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

58,

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

59,

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

60,

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

22]

Never use spaces around

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

51 when passing keyword arguments or defining a default parameter value, with one exception. , do use spaces around the

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

51 for the default parameter value

Yes:
  # Reference flags in code with just the module name [common].
  from absl import flags
  from doctor.who import jodie

  _FOO = flags.DEFINE_string[...]

Yes:
  # Reference flags in code with just the module name [common].
  from absl import flags
  from doctor.who import jodie

  _FOO = flags.DEFINE_string[...]

Don’t use spaces to vertically align tokens on consecutive lines, since it becomes a maintenance burden [applies to

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

64,

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

65,

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

51, etc. ]

Yes:
  # Reference flags in code with just the module name [common].
  from absl import flags
  from doctor.who import jodie

  _FOO = flags.DEFINE_string[...]

Yes:
  # Reference flags in code with just the module name [common].
  from absl import flags
  from doctor.who import jodie

  _FOO = flags.DEFINE_string[...]

3. 7 Shebang Line

Most

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

67 files do not need to start with a

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

68 line. Start the main file of a program with

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

69 [to support virtualenvs] or

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

70 per PEP-394

This line is used by the kernel to find the Python interpreter, but is ignored by Python when importing modules. It is only necessary on a file intended to be executed directly

Be sure to use the right style for module, function, method docstrings and inline comments

3. 8. 1 Docstrings

Python uses docstrings to document code. A docstring is a string that is the first statement in a package, module, class or function. These strings can be extracted automatically through the

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

71 member of the object and are used by

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

25. [Try running

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

25 on your module to see how it looks. ] Always use the three double-quote

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

74 format for docstrings [per PEP 257]. A docstring should be organized as a summary line [one physical line not exceeding 80 characters] terminated by a period, question mark, or exclamation point. When writing more [encouraged], this must be followed by a blank line, followed by the rest of the docstring starting at the same cursor position as the first quote of the first line. There are more formatting guidelines for docstrings below

3. 8. 2 Modules

Mỗi tệp phải chứa giấy phép soạn sẵn. Choose the appropriate boilerplate for the license used by the project [for example, Apache 2. 0, BSD, LGPL, GPL]

Files should start with a docstring describing the contents and usage of the module

Yes:
  # Reference flags in code with just the module name [common].
  from absl import flags
  from doctor.who import jodie

  _FOO = flags.DEFINE_string[...]

3. 8. 2. 1 Test modules

Module-level docstrings for test files are not required. They should be included only when there is additional information that can be provided

Examples include some specifics on how the test should be run, an explanation of an unusual setup pattern, dependency on the external environment, and so on

Yes:
  # Reference flags in code with just the module name [common].
  from absl import flags
  from doctor.who import jodie

  _FOO = flags.DEFINE_string[...]

Docstrings that do not provide any new information should not be used

3. 8. 3 Functions and Methods

In this section, “function” means a method, function, generator, or property

A docstring is mandatory for every function that has one or more of the following properties

being part of the public API
nontrivial size
non-obvious logic

A docstring should give enough information to write a call to the function without reading the function’s code. The docstring should describe the function’s calling syntax and its semantics, but generally not its implementation details, unless those details are relevant to how the function is to be used. For example, a function that mutates one of its arguments as a side effect should note that in its docstring. Otherwise, subtle but important details of a function’s implementation that are not relevant to the caller are better expressed as comments alongside the code than within the function’s docstring

The docstring may be descriptive-style [

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

75] or imperative-style [

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

76], but the style should be consistent within a file. The docstring for a

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

91 data descriptor should use the same style as the docstring for an attribute or a [

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

78, rather than

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

79]

A method that overrides a method from a base class may have a simple docstring sending the reader to its overridden method’s docstring, such as

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

80. The rationale is that there is no need to repeat in many places documentation that is already present in the base method’s docstring. Tuy nhiên, nếu hành vi của phương thức ghi đè về cơ bản khác với phương thức bị ghi đè hoặc cần cung cấp thông tin chi tiết [e. g. , documenting additional side effects], a docstring with at least those differences is required on the overriding method

Certain aspects of a function should be documented in special sections, listed below. Each section begins with a heading line, which ends with a colon. All sections other than the heading should maintain a hanging indent of two or four spaces [be consistent within a file]. These sections can be omitted in cases where the function’s name and signature are informative enough that it can be aptly described using a one-line docstring

List each parameter by name. A description should follow the name, and be separated by a colon followed by either a space or newline. If the description is too long to fit on a single 80-character line, use a hanging indent of 2 or 4 spaces more than the parameter name [be consistent with the rest of the docstrings in the file]. The description should include required type[s] if the code does not contain a corresponding type annotation. If a function accepts

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

81 [variable length argument lists] and/or

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

82 [arbitrary keyword arguments], they should be listed as

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

81 and

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

82. Describe the type and semantics of the return value. If the function only returns None, this section is not required. It may also be omitted if the docstring starts with Returns or Yields [e. g.

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

85] và câu mở đầu đủ để mô tả giá trị trả về. Không bắt chước 'kiểu NumPy' [ví dụ], kiểu này thường ghi lại giá trị trả về của bộ dữ liệu như thể đó là nhiều giá trị trả về với các tên riêng lẻ [không bao giờ đề cập đến bộ dữ liệu]. Thay vào đó, hãy mô tả một giá trị trả về như. “Trả về. Một bộ [mat_a, mat_b], trong đó mat_a là …, và…”. Các tên phụ trợ trong chuỗi tài liệu không nhất thiết phải tương ứng với bất kỳ tên nội bộ nào được sử dụng trong thân hàm [vì chúng không phải là một phần của API]. Liệt kê tất cả các ngoại lệ có liên quan đến giao diện theo sau là mô tả. Sử dụng tên ngoại lệ tương tự + dấu hai chấm + dấu cách hoặc dòng mới và kiểu thụt lề treo như được mô tả trong Args. Bạn không nên ghi lại các trường hợp ngoại lệ được nêu ra nếu API được chỉ định trong chuỗi tài liệu bị vi phạm [vì điều này nghịch lý sẽ tạo ra hành vi vi phạm phần API của API]

Yes:
  # Reference flags in code with just the module name [common].
  from absl import flags
  from doctor.who import jodie

  _FOO = flags.DEFINE_string[...]

Tương tự, biến thể này trên

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

86 với ngắt dòng cũng được cho phép

Yes:
  # Reference flags in code with just the module name [common].
  from absl import flags
  from doctor.who import jodie

  _FOO = flags.DEFINE_string[...]

3. 8. 4 lớp

Các lớp nên có một chuỗi tài liệu bên dưới định nghĩa lớp mô tả lớp. Nếu lớp của bạn có các thuộc tính công khai, chúng phải được ghi lại ở đây trong phần

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

87 và tuân theo cùng định dạng như phần

No:
  # Unclear what module the author wanted and what will be imported.  The actual
  # import behavior depends on external factors controlling sys.path.
  # Which possible jodie module did the author intend to import?
  import jodie

Tất cả các chuỗi tài liệu lớp phải bắt đầu bằng một bản tóm tắt một dòng mô tả nội dung mà thể hiện của lớp đại diện. Điều này ngụ ý rằng các lớp con của

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

60 cũng nên mô tả nội dung của ngoại lệ chứ không phải bối cảnh mà ngoại lệ đó có thể xảy ra. Chuỗi tài liệu lớp không được lặp lại thông tin không cần thiết, chẳng hạn như lớp là một lớp

No:
  # Unclear what module the author wanted and what will be imported.  The actual
  # import behavior depends on external factors controlling sys.path.
  # Which possible jodie module did the author intend to import?
  import jodie

No:
  # Unclear what module the author wanted and what will be imported.  The actual
  # import behavior depends on external factors controlling sys.path.
  # Which possible jodie module did the author intend to import?
  import jodie

3. 8. 5 Khối và Nhận xét Nội tuyến

Nơi cuối cùng để có nhận xét là ở những phần phức tạp của mã. Nếu bạn phải giải thích nó trong lần đánh giá mã tiếp theo, bạn nên bình luận ngay bây giờ. Các hoạt động phức tạp nhận được một vài dòng nhận xét trước khi các hoạt động bắt đầu. Những người không rõ ràng nhận được bình luận ở cuối dòng

No:
  # Unclear what module the author wanted and what will be imported.  The actual
  # import behavior depends on external factors controlling sys.path.
  # Which possible jodie module did the author intend to import?
  import jodie

Để cải thiện mức độ dễ đọc, các nhận xét này phải bắt đầu cách mã ít nhất 2 khoảng trắng với ký tự nhận xét

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

65, theo sau là ít nhất một khoảng trắng trước văn bản của chính nhận xét đó

On the other hand, never describe the code. Assume the person reading the code knows Python [though not what you’re trying to do] better than you do

No:
  # Unclear what module the author wanted and what will be imported.  The actual
  # import behavior depends on external factors controlling sys.path.
  # Which possible jodie module did the author intend to import?
  import jodie

3. 8. 6 Dấu câu, Chính tả và Ngữ pháp

Pay attention to punctuation, spelling, and grammar; it is easier to read well-written comments than badly written ones

Nhận xét phải dễ đọc như văn bản tường thuật, với cách viết hoa và dấu câu thích hợp. Trong nhiều trường hợp, các câu hoàn chỉnh dễ đọc hơn các đoạn câu. Các chú thích ngắn hơn, chẳng hạn như chú thích ở cuối dòng mã, đôi khi có thể kém trang trọng hơn, nhưng bạn nên nhất quán với phong cách của mình

Although it can be frustrating to have a code reviewer point out that you are using a comma when you should be using a semicolon, it is very important that source code maintain a high level of clarity and readability. Dấu chấm câu, chính tả và ngữ pháp phù hợp giúp đạt được mục tiêu đó

3. 10 Dây

Sử dụng toán tử ,

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

59 hoặc phương pháp

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

92 để định dạng chuỗi, ngay cả khi các tham số đều là chuỗi. Sử dụng phán đoán tốt nhất của bạn để quyết định giữa các tùy chọn định dạng chuỗi. Một liên kết duy nhất với

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

54 thì được nhưng không định dạng với

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

No:
  # Unclear what module the author wanted and what will be imported.  The actual
  # import behavior depends on external factors controlling sys.path.
  # Which possible jodie module did the author intend to import?
  import jodie

No:
  # Unclear what module the author wanted and what will be imported.  The actual
  # import behavior depends on external factors controlling sys.path.
  # Which possible jodie module did the author intend to import?
  import jodie

Tránh sử dụng các toán tử

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

54 và

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

96 để tích lũy một chuỗi trong một vòng lặp. Trong một số điều kiện, tích lũy một chuỗi với phép cộng có thể dẫn đến thời gian chạy bậc hai thay vì tuyến tính. Mặc dù các tích lũy phổ biến thuộc loại này có thể được tối ưu hóa trên CPython, nhưng đó là chi tiết triển khai. Các điều kiện áp dụng tối ưu hóa không dễ dự đoán và có thể thay đổi. Thay vào đó, hãy thêm từng chuỗi con vào danh sách và

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

97 danh sách sau khi vòng lặp kết thúc hoặc ghi từng chuỗi con vào bộ đệm

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

98. Các kỹ thuật này luôn có độ phức tạp thời gian chạy tuyến tính được khấu hao

No:
  # Unclear what module the author wanted and what will be imported.  The actual
  # import behavior depends on external factors controlling sys.path.
  # Which possible jodie module did the author intend to import?
  import jodie

No:
  # Unclear what module the author wanted and what will be imported.  The actual
  # import behavior depends on external factors controlling sys.path.
  # Which possible jodie module did the author intend to import?
  import jodie

Hãy nhất quán với sự lựa chọn của bạn về ký tự trích dẫn chuỗi trong một tệp. Pick

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

99 or

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

00 and stick with it. Bạn có thể sử dụng ký tự trích dẫn khác trên một chuỗi để tránh phải ký tự trích dẫn thoát dấu gạch chéo ngược trong chuỗi

No:
  # Unclear what module the author wanted and what will be imported.  The actual
  # import behavior depends on external factors controlling sys.path.
  # Which possible jodie module did the author intend to import?
  import jodie

Yes:
  def connect_to_next_port[self, minimum: int] -> int:
    """Connects to the next available port.

    Args:
      minimum: A port value greater or equal to 1024.

    Returns:
      The new minimum port.

    Raises:
      ConnectionError: If no available port is found.
    """
    if minimum < 1024:
      # Note that this raising of ValueError is not mentioned in the doc
      # string's "Raises:" section because it is not appropriate to
      # guarantee this specific behavioral reaction to API misuse.
      raise ValueError[f'Min. port must be at least 1024, not {minimum}.']
    port = self._find_next_open_port[minimum]
    if port is None:
      raise ConnectionError[
          f'Could not connect to service on port {minimum} or higher.']
    assert port >= minimum, [
        f'Unexpected port {port} when minimum was {minimum}.']
    return port

Thích

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

74 cho các chuỗi nhiều dòng hơn là

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

02. Projects may choose to use

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

02 for all non-docstring multi-line strings if and only if they also use

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

99 for regular strings. Docstrings must use

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

74 regardless

Multi-line strings do not flow with the indentation of the rest of the program. If you need to avoid embedding extra space in the string, use either concatenated single-line strings or a multi-line string with to remove the initial space on each line

Yes:
  def connect_to_next_port[self, minimum: int] -> int:
    """Connects to the next available port.

    Args:
      minimum: A port value greater or equal to 1024.

    Returns:
      The new minimum port.

    Raises:
      ConnectionError: If no available port is found.
    """
    if minimum < 1024:
      # Note that this raising of ValueError is not mentioned in the doc
      # string's "Raises:" section because it is not appropriate to
      # guarantee this specific behavioral reaction to API misuse.
      raise ValueError[f'Min. port must be at least 1024, not {minimum}.']
    port = self._find_next_open_port[minimum]
    if port is None:
      raise ConnectionError[
          f'Could not connect to service on port {minimum} or higher.']
    assert port >= minimum, [
        f'Unexpected port {port} when minimum was {minimum}.']
    return port

Yes:
  def connect_to_next_port[self, minimum: int] -> int:
    """Connects to the next available port.

    Args:
      minimum: A port value greater or equal to 1024.

    Returns:
      The new minimum port.

    Raises:
      ConnectionError: If no available port is found.
    """
    if minimum < 1024:
      # Note that this raising of ValueError is not mentioned in the doc
      # string's "Raises:" section because it is not appropriate to
      # guarantee this specific behavioral reaction to API misuse.
      raise ValueError[f'Min. port must be at least 1024, not {minimum}.']
    port = self._find_next_open_port[minimum]
    if port is None:
      raise ConnectionError[
          f'Could not connect to service on port {minimum} or higher.']
    assert port >= minimum, [
        f'Unexpected port {port} when minimum was {minimum}.']
    return port

Yes:
  def connect_to_next_port[self, minimum: int] -> int:
    """Connects to the next available port.

    Args:
      minimum: A port value greater or equal to 1024.

    Returns:
      The new minimum port.

    Raises:
      ConnectionError: If no available port is found.
    """
    if minimum < 1024:
      # Note that this raising of ValueError is not mentioned in the doc
      # string's "Raises:" section because it is not appropriate to
      # guarantee this specific behavioral reaction to API misuse.
      raise ValueError[f'Min. port must be at least 1024, not {minimum}.']
    port = self._find_next_open_port[minimum]
    if port is None:
      raise ConnectionError[
          f'Could not connect to service on port {minimum} or higher.']
    assert port >= minimum, [
        f'Unexpected port {port} when minimum was {minimum}.']
    return port

Yes:
  def connect_to_next_port[self, minimum: int] -> int:
    """Connects to the next available port.

    Args:
      minimum: A port value greater or equal to 1024.

    Returns:
      The new minimum port.

    Raises:
      ConnectionError: If no available port is found.
    """
    if minimum < 1024:
      # Note that this raising of ValueError is not mentioned in the doc
      # string's "Raises:" section because it is not appropriate to
      # guarantee this specific behavioral reaction to API misuse.
      raise ValueError[f'Min. port must be at least 1024, not {minimum}.']
    port = self._find_next_open_port[minimum]
    if port is None:
      raise ConnectionError[
          f'Could not connect to service on port {minimum} or higher.']
    assert port >= minimum, [
        f'Unexpected port {port} when minimum was {minimum}.']
    return port

Yes:
  def connect_to_next_port[self, minimum: int] -> int:
    """Connects to the next available port.

    Args:
      minimum: A port value greater or equal to 1024.

    Returns:
      The new minimum port.

    Raises:
      ConnectionError: If no available port is found.
    """
    if minimum < 1024:
      # Note that this raising of ValueError is not mentioned in the doc
      # string's "Raises:" section because it is not appropriate to
      # guarantee this specific behavioral reaction to API misuse.
      raise ValueError[f'Min. port must be at least 1024, not {minimum}.']
    port = self._find_next_open_port[minimum]
    if port is None:
      raise ConnectionError[
          f'Could not connect to service on port {minimum} or higher.']
    assert port >= minimum, [
        f'Unexpected port {port} when minimum was {minimum}.']
    return port

3. 10. 1 nhật ký

Đối với các chức năng ghi nhật ký yêu cầu một chuỗi mẫu [với %-placeholders] làm đối số đầu tiên của chúng. Luôn gọi chúng bằng một chuỗi ký tự [không phải chuỗi f. ] làm đối số đầu tiên của chúng với tham số mẫu làm đối số tiếp theo. Một số triển khai ghi nhật ký thu thập chuỗi mẫu chưa được mở rộng dưới dạng trường có thể truy vấn. Nó cũng ngăn việc dành thời gian hiển thị thông báo mà không có trình ghi nhật ký nào được định cấu hình để xuất

Yes:
  def connect_to_next_port[self, minimum: int] -> int:
    """Connects to the next available port.

    Args:
      minimum: A port value greater or equal to 1024.

    Returns:
      The new minimum port.

    Raises:
      ConnectionError: If no available port is found.
    """
    if minimum < 1024:
      # Note that this raising of ValueError is not mentioned in the doc
      # string's "Raises:" section because it is not appropriate to
      # guarantee this specific behavioral reaction to API misuse.
      raise ValueError[f'Min. port must be at least 1024, not {minimum}.']
    port = self._find_next_open_port[minimum]
    if port is None:
      raise ConnectionError[
          f'Could not connect to service on port {minimum} or higher.']
    assert port >= minimum, [
        f'Unexpected port {port} when minimum was {minimum}.']
    return port

Yes:
  def connect_to_next_port[self, minimum: int] -> int:
    """Connects to the next available port.

    Args:
      minimum: A port value greater or equal to 1024.

    Returns:
      The new minimum port.

    Raises:
      ConnectionError: If no available port is found.
    """
    if minimum < 1024:
      # Note that this raising of ValueError is not mentioned in the doc
      # string's "Raises:" section because it is not appropriate to
      # guarantee this specific behavioral reaction to API misuse.
      raise ValueError[f'Min. port must be at least 1024, not {minimum}.']
    port = self._find_next_open_port[minimum]
    if port is None:
      raise ConnectionError[
          f'Could not connect to service on port {minimum} or higher.']
    assert port >= minimum, [
        f'Unexpected port {port} when minimum was {minimum}.']
    return port

Yes:
  def connect_to_next_port[self, minimum: int] -> int:
    """Connects to the next available port.

    Args:
      minimum: A port value greater or equal to 1024.

    Returns:
      The new minimum port.

    Raises:
      ConnectionError: If no available port is found.
    """
    if minimum < 1024:
      # Note that this raising of ValueError is not mentioned in the doc
      # string's "Raises:" section because it is not appropriate to
      # guarantee this specific behavioral reaction to API misuse.
      raise ValueError[f'Min. port must be at least 1024, not {minimum}.']
    port = self._find_next_open_port[minimum]
    if port is None:
      raise ConnectionError[
          f'Could not connect to service on port {minimum} or higher.']
    assert port >= minimum, [
        f'Unexpected port {port} when minimum was {minimum}.']
    return port

3. 10. 2 thông báo lỗi

Error messages [such as. chuỗi thông báo về các trường hợp ngoại lệ như

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

54 hoặc thông báo được hiển thị cho người dùng] phải tuân theo ba nguyên tắc

The message needs to precisely match the actual error condition
Interpolated pieces need to always be clearly identifiable as such
They should allow simple automated processing [e. g. grepping]

Yes:
  def connect_to_next_port[self, minimum: int] -> int:
    """Connects to the next available port.

    Args:
      minimum: A port value greater or equal to 1024.

    Returns:
      The new minimum port.

    Raises:
      ConnectionError: If no available port is found.
    """
    if minimum < 1024:
      # Note that this raising of ValueError is not mentioned in the doc
      # string's "Raises:" section because it is not appropriate to
      # guarantee this specific behavioral reaction to API misuse.
      raise ValueError[f'Min. port must be at least 1024, not {minimum}.']
    port = self._find_next_open_port[minimum]
    if port is None:
      raise ConnectionError[
          f'Could not connect to service on port {minimum} or higher.']
    assert port >= minimum, [
        f'Unexpected port {port} when minimum was {minimum}.']
    return port

No:
  def connect_to_next_port[self, minimum: int] -> int:
    """Connects to the next available port.

    Args:
      minimum: A port value greater or equal to 1024.

    Returns:
      The new minimum port.
    """
    assert minimum >= 1024, 'Minimum port must be at least 1024.'
    port = self._find_next_open_port[minimum]
    assert port is not None
    return port

3. 11 Tệp, Ổ cắm và Tài nguyên có trạng thái tương tự

Explicitly close files and sockets when done with them. Quy tắc này tự nhiên mở rộng cho các tài nguyên có thể đóng sử dụng ổ cắm bên trong, chẳng hạn như kết nối cơ sở dữ liệu và cả các tài nguyên khác cần được đóng theo cách tương tự. To name only a few examples, this also includes mmap mappings, h5py File objects, and matplotlib. pyplot figure windows

Để các tệp, ổ cắm hoặc các đối tượng trạng thái khác mở một cách không cần thiết có nhiều nhược điểm

Chúng có thể tiêu tốn tài nguyên hệ thống hạn chế, chẳng hạn như bộ mô tả tệp. Mã xử lý nhiều đối tượng như vậy có thể làm cạn kiệt các tài nguyên đó một cách không cần thiết nếu chúng không được trả lại hệ thống ngay sau khi sử dụng
Việc giữ các tệp đang mở có thể ngăn các hành động khác như di chuyển hoặc xóa chúng hoặc ngắt kết nối hệ thống tệp
Các tệp và ổ cắm được chia sẻ trong toàn bộ chương trình có thể vô tình được đọc từ hoặc ghi vào sau khi đóng một cách hợp lý. Nếu chúng thực sự bị đóng, các nỗ lực đọc hoặc ghi từ chúng sẽ đưa ra các ngoại lệ, làm cho vấn đề được biết đến sớm hơn

Furthermore, while files and sockets [and some similarly behaving resources] are automatically closed when the object is destructed, coupling the lifetime of the object to the state of the resource is poor practice

Không có gì đảm bảo khi nào bộ thực thi sẽ thực sự gọi phương thức
```
from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]
```
33. Các triển khai Python khác nhau sử dụng các kỹ thuật quản lý bộ nhớ khác nhau, chẳng hạn như bộ sưu tập rác bị trì hoãn, điều này có thể làm tăng tuổi thọ của đối tượng một cách tùy ý và vô thời hạn
Các tham chiếu không mong muốn đến tệp, e. g. trong toàn cầu hoặc theo dõi ngoại lệ, có thể giữ nó lâu hơn dự định

Relying on finalizers to do automatic cleanup that has observable side effects has been rediscovered over and over again to lead to major problems, across many decades and multiple languages [see e. g. this article for Java]

Cách ưu tiên để quản lý tệp và các tài nguyên tương tự là sử dụng

No:
  def connect_to_next_port[self, minimum: int] -> int:
    """Connects to the next available port.

    Args:
      minimum: A port value greater or equal to 1024.

    Returns:
      The new minimum port.
    """
    assert minimum >= 1024, 'Minimum port must be at least 1024.'
    port = self._find_next_open_port[minimum]
    assert port is not None
    return port

For file-like objects that do not support the

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

42 statement, use

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

No:
  def connect_to_next_port[self, minimum: int] -> int:
    """Connects to the next available port.

    Args:
      minimum: A port value greater or equal to 1024.

    Returns:
      The new minimum port.
    """
    assert minimum >= 1024, 'Minimum port must be at least 1024.'
    port = self._find_next_open_port[minimum]
    assert port is not None
    return port

In rare cases where context-based resource management is infeasible, code documentation must explain clearly how resource lifetime is managed

Sử dụng

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

12 nhận xét cho mã tạm thời, giải pháp ngắn hạn hoặc đủ tốt nhưng không hoàn hảo

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

12 comment begins with the word

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

12 in all caps, and a parenthesized context identifier. Ideally a bug reference, sometimes a username. Một tài liệu tham khảo lỗi như

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

15 là thích hợp hơn, bởi vì các lỗi được theo dõi và có các nhận xét tiếp theo, trong khi các cá nhân di chuyển xung quanh và có thể mất ngữ cảnh theo thời gian.

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

12 được theo sau bởi một lời giải thích về những việc phải làm

Mục đích là để có một định dạng

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

12 nhất quán có thể được tìm kiếm để tìm hiểu cách biết thêm chi tiết. A

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

12 is not a commitment that the person referenced will fix the problem. Do đó, khi bạn tạo một

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

12 với tên người dùng, thì hầu như tên người dùng của bạn luôn được cung cấp

No:
  def connect_to_next_port[self, minimum: int] -> int:
    """Connects to the next available port.

    Args:
      minimum: A port value greater or equal to 1024.

    Returns:
      The new minimum port.
    """
    assert minimum >= 1024, 'Minimum port must be at least 1024.'
    port = self._find_next_open_port[minimum]
    assert port is not None
    return port

Nếu

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

12 của bạn thuộc dạng “Vào một ngày trong tương lai, hãy làm điều gì đó”, hãy đảm bảo rằng bạn bao gồm một ngày cụ thể [“Khắc phục trước tháng 11 năm 2009”] hoặc một sự kiện rất cụ thể [“Xóa mã này khi tất cả khách hàng có thể xử lý phản hồi XML. ”] mà những người bảo trì mã trong tương lai sẽ hiểu

3. 13 Imports formatting

Imports should be on separate lines; there are

E. g

No:
  def connect_to_next_port[self, minimum: int] -> int:
    """Connects to the next available port.

    Args:
      minimum: A port value greater or equal to 1024.

    Returns:
      The new minimum port.
    """
    assert minimum >= 1024, 'Minimum port must be at least 1024.'
    port = self._find_next_open_port[minimum]
    assert port is not None
    return port

Các mục nhập luôn được đặt ở đầu tệp, ngay sau bất kỳ nhận xét và chuỗi tài liệu nào của mô-đun cũng như trước các hằng số và toàn cầu của mô-đun. Nhập khẩu nên được nhóm từ chung chung nhất đến ít chung chung nhất

Python future import statements. Ví dụ

No:
  def connect_to_next_port[self, minimum: int] -> int:
    """Connects to the next available port.

    Args:
      minimum: A port value greater or equal to 1024.

    Returns:
      The new minimum port.
    """
    assert minimum >= 1024, 'Minimum port must be at least 1024.'
    port = self._find_next_open_port[minimum]
    assert port is not None
    return port

Xem để biết thêm thông tin về những

Nhập thư viện chuẩn Python. Ví dụ
nhập mô-đun hoặc gói của bên thứ ba. Ví dụ

Nhập gói con kho lưu trữ mã. Ví dụ

No:
  def connect_to_next_port[self, minimum: int] -> int:
    """Connects to the next available port.

    Args:
      minimum: A port value greater or equal to 1024.

    Returns:
      The new minimum port.
    """
    assert minimum >= 1024, 'Minimum port must be at least 1024.'
    port = self._find_next_open_port[minimum]
    assert port is not None
    return port

không dùng nữa. nhập dành riêng cho ứng dụng là một phần của gói con cấp cao nhất giống như tệp này. Ví dụ
```
No:
  def connect_to_next_port[self, minimum: int] -> int:
    """Connects to the next available port.

    Args:
      minimum: A port value greater or equal to 1024.

    Returns:
      The new minimum port.
    """
    assert minimum >= 1024, 'Minimum port must be at least 1024.'
    port = self._find_next_open_port[minimum]
    assert port is not None
    return port
```
7
Bạn có thể tìm thấy mã Google Python Style cũ hơn để thực hiện việc này, nhưng nó không còn cần thiết nữa. Mã mới được khuyến khích không bận tâm với điều này. Đơn giản chỉ cần xử lý các lần nhập gói phụ dành riêng cho ứng dụng giống như các lần nhập gói phụ khác

Trong mỗi nhóm, các mục nhập phải được sắp xếp theo từ điển, bỏ qua trường hợp, theo đường dẫn gói đầy đủ của từng mô-đun [_______33_______23 trong ____33_______24]. Code may optionally place a blank line between import sections

No:
  def connect_to_next_port[self, minimum: int] -> int:
    """Connects to the next available port.

    Args:
      minimum: A port value greater or equal to 1024.

    Returns:
      The new minimum port.
    """
    assert minimum >= 1024, 'Minimum port must be at least 1024.'
    port = self._find_next_open_port[minimum]
    assert port is not None
    return port

3. 14 Statements

Nói chung chỉ có một tuyên bố trên mỗi dòng

Tuy nhiên, bạn chỉ có thể đặt kết quả của một bài kiểm tra trên cùng một dòng với bài kiểm tra nếu toàn bộ câu lệnh nằm trên một dòng. Đặc biệt, bạn không bao giờ có thể làm như vậy với

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

63/

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

64 vì

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

63 và

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

64 không thể vừa trên cùng một dòng và bạn chỉ có thể làm như vậy với

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

29 nếu không có

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

No:
  def connect_to_next_port[self, minimum: int] -> int:
    """Connects to the next available port.

    Args:
      minimum: A port value greater or equal to 1024.

    Returns:
      The new minimum port.
    """
    assert minimum >= 1024, 'Minimum port must be at least 1024.'
    port = self._find_next_open_port[minimum]
    assert port is not None
    return port

3. 15 Getters và Setters

Các hàm getter và setter [còn được gọi là bộ truy cập và bộ biến đổi] nên được sử dụng khi chúng cung cấp vai trò hoặc hành vi có ý nghĩa để nhận hoặc đặt giá trị của biến

Đặc biệt, chúng nên được sử dụng khi nhận hoặc thiết lập biến phức tạp hoặc chi phí đáng kể, hiện tại hoặc trong tương lai hợp lý

Ví dụ: nếu một cặp getters/setters chỉ đọc và ghi một thuộc tính nội bộ, thì thuộc tính nội bộ sẽ được công khai thay thế. Để so sánh, nếu việc đặt một biến có nghĩa là một số trạng thái bị vô hiệu hóa hoặc được xây dựng lại, thì đó phải là một hàm setter. Lời gọi hàm gợi ý rằng một hoạt động có khả năng không tầm thường đang xảy ra. Ngoài ra, có thể là một tùy chọn khi cần logic đơn giản hoặc tái cấu trúc để không còn cần getters và setters nữa

Getters và setters nên tuân theo các hướng dẫn, chẳng hạn như

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

31 và

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

Nếu hành vi trong quá khứ cho phép truy cập thông qua một thuộc tính, không liên kết các hàm getter/setter mới với thuộc tính. Bất kỳ mã nào vẫn đang cố truy cập vào biến theo phương pháp cũ sẽ bị hỏng rõ ràng để chúng nhận thức được sự thay đổi về độ phức tạp

3. 16 đặt tên

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

33,

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

34,

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

35,

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

36,

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

37,

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

38,

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

39,

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

40,

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

41,

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

42,

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

43,

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

44,

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

Tên hàm, tên biến và tên tệp phải mang tính mô tả; . Đặc biệt, không sử dụng các từ viết tắt mơ hồ hoặc không quen thuộc với người đọc bên ngoài dự án của bạn và không viết tắt bằng cách xóa các chữ cái trong một từ

Luôn sử dụng phần mở rộng tên tệp

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

67. Không bao giờ sử dụng dấu gạch ngang

3. 16. 1 Tên cần tránh

tên ký tự đơn, ngoại trừ các trường hợp được phép cụ thể

bộ đếm hoặc bộ lặp [e. g.

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

47,

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

48,

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

49,

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

50, v.v. ]

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

51 làm định danh ngoại lệ trong câu lệnh

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

53 dưới dạng xử lý tệp trong câu lệnh

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

riêng tư không có ràng buộc [e. g.

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

56,

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

57,

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

58]

Xin lưu ý không lạm dụng đặt tên một ký tự. Nói chung, tính mô tả phải tỷ lệ thuận với phạm vi hiển thị của tên. Ví dụ:

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

47 có thể là một tên hay cho khối mã 5 dòng nhưng trong nhiều phạm vi lồng nhau, nó có thể quá mơ hồ

dấu gạch ngang [

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

55] trong bất kỳ tên gói/mô-đun nào

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

61 tên [được đặt trước bởi Python]

điều khoản xúc phạm

những tên không cần thiết bao gồm loại biến [ví dụ:.

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

62]

3. 16. 2 Quy ước đặt tên

“Nội bộ” có nghĩa là nội bộ của một mô-đun hoặc được bảo vệ hoặc riêng tư trong một lớp
Đặt trước một dấu gạch dưới [
```
def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam
```
28] có một số hỗ trợ để bảo vệ các biến và chức năng của mô-đun [linters sẽ gắn cờ quyền truy cập của thành viên được bảo vệ]
Việc thêm trước một dấu gạch dưới kép [
```
Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]
```
64 hay còn gọi là “dunder”] vào một biến thể hiện hoặc phương thức sẽ làm cho biến hoặc phương thức đó trở nên riêng tư đối với lớp của nó một cách hiệu quả [sử dụng xáo trộn tên]; . Thích một dấu gạch dưới
Đặt các lớp liên quan và các chức năng cấp cao nhất cùng nhau trong một mô-đun. Không giống như Java, không cần giới hạn bản thân trong một lớp cho mỗi mô-đun

Sử dụng CapWords cho tên lớp, nhưng Lower_with_under. py cho tên mô-đun. Mặc dù có một số mô-đun cũ có tên là CapWords. py, điều này hiện không được khuyến khích vì thật khó hiểu khi mô-đun được đặt tên theo một lớp. [“chờ đã – tôi đã viết

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

65 hay

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

66?”]

Dấu gạch dưới có thể xuất hiện trong các tên phương thức kém nhất bắt đầu bằng

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

67 để phân tách các thành phần logic của tên, ngay cả khi các thành phần đó sử dụng CapWords. One possible pattern is

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

68; for example

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

69 is okay. Không có một cách chính xác nào để đặt tên cho các phương pháp thử nghiệm

3. 16. 3 Đặt tên tệp

Tên tệp Python phải có phần mở rộng

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

67 và không được chứa dấu gạch ngang [

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

55]. Điều này cho phép chúng được nhập và kiểm tra. Nếu bạn muốn một tệp thực thi có thể truy cập được mà không cần tiện ích mở rộng, hãy sử dụng liên kết tượng trưng hoặc trình bao bọc bash đơn giản có chứa

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

3. 16. 4 Nguyên tắc rút ra từ Khuyến nghị của Guido

TypePublicInternalPackages

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

73Modules

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

75Classes

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

77Exceptions

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

76Functions

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

80Global/Class Constants

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

82Global/Class Variables

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

75Instance Variables

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

75 [protected]Method Names

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

80 [protected]Function/Method Parameters

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

73Local Variables

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

3. 16. 5 Ký hiệu toán học

Đối với mã nặng về mặt toán học, các tên biến ngắn sẽ vi phạm hướng dẫn kiểu được ưu tiên hơn khi chúng khớp với ký hiệu đã thiết lập trong tài liệu tham khảo hoặc thuật toán. Khi làm như vậy, hãy tham khảo nguồn của tất cả các quy ước đặt tên trong một nhận xét hoặc chuỗi tài liệu hoặc, nếu nguồn không thể truy cập được, hãy ghi lại rõ ràng các quy ước đặt tên. Ưu tiên

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

91 tuân thủ PEP8 cho các API công khai, có nhiều khả năng gặp phải ngoài ngữ cảnh hơn

3. 17 chính

Trong Python,

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

25 cũng như các bài kiểm tra đơn vị yêu cầu các mô-đun có thể nhập được. Nếu một tệp được dùng làm tệp thực thi, thì chức năng chính của nó phải ở hàm

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

93 và mã của bạn phải luôn kiểm tra

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

94 trước khi thực thi chương trình chính của bạn, để nó không được thực thi khi mô-đun được nhập

Khi sử dụng absl, hãy sử dụng

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

Yes:
  result = [mapping_expr for value in iterable if filter_expr]

  result = [{'key': value} for value in iterable
            if a_long_filter_expression[value]]

  result = [complicated_transform[x]
            for x in iterable if predicate[x]]

  descriptive_name = [
      transform[{'key': key, 'value': value}, color='black']
      for key, value in generate_iterable[some_input]
      if complicated_condition_is_met[key, value]
  ]

  result = []
  for x in range[10]:
      for y in range[5]:
          if x * y > 10:
              result.append[[x, y]]

  return {x: complicated_transform[x]
          for x in long_generator_function[parameter]
          if x is not None}

  squares_generator = [x**2 for x in range[10]]

  unique_names = {user.name for user in users if user is not None}

  eat[jelly_bean for jelly_bean in jelly_beans
      if jelly_bean.color == 'black']

Nếu không, hãy sử dụng

Yes:
  result = [mapping_expr for value in iterable if filter_expr]

  result = [{'key': value} for value in iterable
            if a_long_filter_expression[value]]

  result = [complicated_transform[x]
            for x in iterable if predicate[x]]

  descriptive_name = [
      transform[{'key': key, 'value': value}, color='black']
      for key, value in generate_iterable[some_input]
      if complicated_condition_is_met[key, value]
  ]

  result = []
  for x in range[10]:
      for y in range[5]:
          if x * y > 10:
              result.append[[x, y]]

  return {x: complicated_transform[x]
          for x in long_generator_function[parameter]
          if x is not None}

  squares_generator = [x**2 for x in range[10]]

  unique_names = {user.name for user in users if user is not None}

  eat[jelly_bean for jelly_bean in jelly_beans
      if jelly_bean.color == 'black']

Tất cả mã ở cấp cao nhất sẽ được thực thi khi mô-đun được nhập. Cẩn thận không gọi hàm, tạo đối tượng hoặc thực hiện các thao tác khác không được thực hiện khi tệp đang được ____32_______25ed

3. 18 Chiều dài chức năng

Thích các chức năng nhỏ và tập trung

Chúng tôi nhận ra rằng các hàm dài đôi khi phù hợp, vì vậy không có giới hạn cứng nào được đặt cho độ dài của hàm. Nếu một hàm vượt quá khoảng 40 dòng, hãy nghĩ xem có thể chia nhỏ hàm đó mà không làm hại cấu trúc của chương trình hay không

Ngay cả khi chức năng lâu dài của bạn hiện đang hoạt động hoàn hảo, ai đó sửa đổi nó sau vài tháng có thể thêm hành vi mới. Điều này có thể dẫn đến các lỗi khó tìm. Giữ chức năng của bạn ngắn gọn và đơn giản giúp người khác đọc và sửa đổi mã của bạn dễ dàng hơn

Bạn có thể tìm thấy các hàm dài và phức tạp khi làm việc với một số mã. Đừng bị đe dọa bằng cách sửa đổi mã hiện có. nếu làm việc với một chức năng như vậy tỏ ra khó khăn, bạn thấy rằng các lỗi khó gỡ lỗi hoặc bạn muốn sử dụng một phần của nó trong nhiều ngữ cảnh khác nhau, hãy cân nhắc chia chức năng thành các phần nhỏ hơn và dễ quản lý hơn

3. 19 Chú thích loại

3. 19. 1 Quy tắc chung

Làm quen với PEP-484

Trong các phương thức, chỉ chú thích

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

73 hoặc

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

74 nếu cần thiết cho thông tin loại phù hợp. e. g. ,

Yes:
  result = [mapping_expr for value in iterable if filter_expr]

  result = [{'key': value} for value in iterable
            if a_long_filter_expression[value]]

  result = [complicated_transform[x]
            for x in iterable if predicate[x]]

  descriptive_name = [
      transform[{'key': key, 'value': value}, color='black']
      for key, value in generate_iterable[some_input]
      if complicated_condition_is_met[key, value]
  ]

  result = []
  for x in range[10]:
      for y in range[5]:
          if x * y > 10:
              result.append[[x, y]]

  return {x: complicated_transform[x]
          for x in long_generator_function[parameter]
          if x is not None}

  squares_generator = [x**2 for x in range[10]]

  unique_names = {user.name for user in users if user is not None}

  eat[jelly_bean for jelly_bean in jelly_beans
      if jelly_bean.color == 'black']

Tương tự, đừng cảm thấy bắt buộc phải chú thích giá trị trả về của

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

99 [trong đó

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

98 là tùy chọn hợp lệ duy nhất]

Nếu không thể biểu thị bất kỳ biến nào khác hoặc kiểu trả về, hãy sử dụng

Yes:
  # Reference flags in code with just the module name [common].
  from absl import flags
  from doctor.who import jodie

  _FOO = flags.DEFINE_string[...]

Bạn không bắt buộc phải chú thích tất cả các chức năng trong một mô-đun
- Ít nhất hãy chú thích các API công khai của bạn
- Sử dụng phán đoán để đạt được sự cân bằng tốt giữa một mặt là an toàn và rõ ràng, mặt khác là linh hoạt
- Chú thích mã dễ bị lỗi liên quan đến loại [lỗi trước đó hoặc độ phức tạp]
- Chú thích mã khó hiểu
- Chú thích mã khi nó trở nên ổn định từ góc độ loại. Trong nhiều trường hợp, bạn có thể chú thích tất cả các chức năng trong mã trưởng thành mà không mất quá nhiều tính linh hoạt

3. 19. Ngắt 2 dòng

Cố gắng tuân theo các quy tắc hiện có

Sau khi chú thích, nhiều chữ ký hàm sẽ trở thành “mỗi dòng một tham số”. Để đảm bảo kiểu trả về cũng được cung cấp dòng riêng, có thể đặt dấu phẩy sau tham số cuối cùng

Yes:
  result = [mapping_expr for value in iterable if filter_expr]

  result = [{'key': value} for value in iterable
            if a_long_filter_expression[value]]

  result = [complicated_transform[x]
            for x in iterable if predicate[x]]

  descriptive_name = [
      transform[{'key': key, 'value': value}, color='black']
      for key, value in generate_iterable[some_input]
      if complicated_condition_is_met[key, value]
  ]

  result = []
  for x in range[10]:
      for y in range[5]:
          if x * y > 10:
              result.append[[x, y]]

  return {x: complicated_transform[x]
          for x in long_generator_function[parameter]
          if x is not None}

  squares_generator = [x**2 for x in range[10]]

  unique_names = {user.name for user in users if user is not None}

  eat[jelly_bean for jelly_bean in jelly_beans
      if jelly_bean.color == 'black']

Luôn ưu tiên ngắt giữa các biến và không, ví dụ, giữa tên biến và chú thích loại. Tuy nhiên, nếu mọi thứ phù hợp trên cùng một dòng, hãy tiếp tục

Yes:
  result = [mapping_expr for value in iterable if filter_expr]

  result = [{'key': value} for value in iterable
            if a_long_filter_expression[value]]

  result = [complicated_transform[x]
            for x in iterable if predicate[x]]

  descriptive_name = [
      transform[{'key': key, 'value': value}, color='black']
      for key, value in generate_iterable[some_input]
      if complicated_condition_is_met[key, value]
  ]

  result = []
  for x in range[10]:
      for y in range[5]:
          if x * y > 10:
              result.append[[x, y]]

  return {x: complicated_transform[x]
          for x in long_generator_function[parameter]
          if x is not None}

  squares_generator = [x**2 for x in range[10]]

  unique_names = {user.name for user in users if user is not None}

  eat[jelly_bean for jelly_bean in jelly_beans
      if jelly_bean.color == 'black']

Nếu tổ hợp tên hàm, tham số cuối cùng và kiểu trả về quá dài, hãy thụt lề 4 trong một dòng mới. Khi sử dụng ngắt dòng, hãy ưu tiên đặt từng tham số và kiểu trả về trên các dòng riêng của chúng và căn chỉnh dấu ngoặc đơn đóng với

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

Yes:
  result = [mapping_expr for value in iterable if filter_expr]

  result = [{'key': value} for value in iterable
            if a_long_filter_expression[value]]

  result = [complicated_transform[x]
            for x in iterable if predicate[x]]

  descriptive_name = [
      transform[{'key': key, 'value': value}, color='black']
      for key, value in generate_iterable[some_input]
      if complicated_condition_is_met[key, value]
  ]

  result = []
  for x in range[10]:
      for y in range[5]:
          if x * y > 10:
              result.append[[x, y]]

  return {x: complicated_transform[x]
          for x in long_generator_function[parameter]
          if x is not None}

  squares_generator = [x**2 for x in range[10]]

  unique_names = {user.name for user in users if user is not None}

  eat[jelly_bean for jelly_bean in jelly_beans
      if jelly_bean.color == 'black']

Tùy chọn, kiểu trả về có thể được đặt trên cùng một dòng với tham số cuối cùng

Yes:
  result = [mapping_expr for value in iterable if filter_expr]

  result = [{'key': value} for value in iterable
            if a_long_filter_expression[value]]

  result = [complicated_transform[x]
            for x in iterable if predicate[x]]

  descriptive_name = [
      transform[{'key': key, 'value': value}, color='black']
      for key, value in generate_iterable[some_input]
      if complicated_condition_is_met[key, value]
  ]

  result = []
  for x in range[10]:
      for y in range[5]:
          if x * y > 10:
              result.append[[x, y]]

  return {x: complicated_transform[x]
          for x in long_generator_function[parameter]
          if x is not None}

  squares_generator = [x**2 for x in range[10]]

  unique_names = {user.name for user in users if user is not None}

  eat[jelly_bean for jelly_bean in jelly_beans
      if jelly_bean.color == 'black']

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

18 cho phép bạn di chuyển dấu ngoặc đơn đóng sang một dòng mới và căn chỉnh với dòng mở đầu, nhưng điều này khó đọc hơn

Yes:
  result = [mapping_expr for value in iterable if filter_expr]

  result = [{'key': value} for value in iterable
            if a_long_filter_expression[value]]

  result = [complicated_transform[x]
            for x in iterable if predicate[x]]

  descriptive_name = [
      transform[{'key': key, 'value': value}, color='black']
      for key, value in generate_iterable[some_input]
      if complicated_condition_is_met[key, value]
  ]

  result = []
  for x in range[10]:
      for y in range[5]:
          if x * y > 10:
              result.append[[x, y]]

  return {x: complicated_transform[x]
          for x in long_generator_function[parameter]
          if x is not None}

  squares_generator = [x**2 for x in range[10]]

  unique_names = {user.name for user in users if user is not None}

  eat[jelly_bean for jelly_bean in jelly_beans
      if jelly_bean.color == 'black']

Như trong các ví dụ trên, không muốn ngắt các loại. Tuy nhiên, đôi khi chúng quá dài để nằm trên một dòng [cố gắng giữ cho các loại phụ không bị gián đoạn]

Yes:
  result = [mapping_expr for value in iterable if filter_expr]

  result = [{'key': value} for value in iterable
            if a_long_filter_expression[value]]

  result = [complicated_transform[x]
            for x in iterable if predicate[x]]

  descriptive_name = [
      transform[{'key': key, 'value': value}, color='black']
      for key, value in generate_iterable[some_input]
      if complicated_condition_is_met[key, value]
  ]

  result = []
  for x in range[10]:
      for y in range[5]:
          if x * y > 10:
              result.append[[x, y]]

  return {x: complicated_transform[x]
          for x in long_generator_function[parameter]
          if x is not None}

  squares_generator = [x**2 for x in range[10]]

  unique_names = {user.name for user in users if user is not None}

  eat[jelly_bean for jelly_bean in jelly_beans
      if jelly_bean.color == 'black']

Nếu một tên và loại quá dài, hãy xem xét sử dụng một loại cho. Phương án cuối cùng là ngắt sau dấu hai chấm và thụt vào 4

Yes:
  result = [mapping_expr for value in iterable if filter_expr]

  result = [{'key': value} for value in iterable
            if a_long_filter_expression[value]]

  result = [complicated_transform[x]
            for x in iterable if predicate[x]]

  descriptive_name = [
      transform[{'key': key, 'value': value}, color='black']
      for key, value in generate_iterable[some_input]
      if complicated_condition_is_met[key, value]
  ]

  result = []
  for x in range[10]:
      for y in range[5]:
          if x * y > 10:
              result.append[[x, y]]

  return {x: complicated_transform[x]
          for x in long_generator_function[parameter]
          if x is not None}

  squares_generator = [x**2 for x in range[10]]

  unique_names = {user.name for user in users if user is not None}

  eat[jelly_bean for jelly_bean in jelly_beans
      if jelly_bean.color == 'black']

No:
  result = [complicated_transform[
                x, some_argument=x+1]
            for x in iterable if predicate[x]]

  result = [[x, y] for x in range[10] for y in range[5] if x * y > 10]

  return [[x, y, z]
          for x in range[5]
          for y in range[5]
          if x != y
          for z in range[5]
          if y != z]

3. 19. 3 Tuyên bố chuyển tiếp

Nếu bạn cần sử dụng một tên lớp [từ cùng một mô-đun] chưa được xác định – ví dụ: nếu bạn cần tên lớp bên trong phần khai báo của lớp đó hoặc nếu bạn sử dụng một lớp được xác định sau trong mã –

No:
  result = [complicated_transform[
                x, some_argument=x+1]
            for x in iterable if predicate[x]]

  result = [[x, y] for x in range[10] for y in range[5] if x * y > 10]

  return [[x, y, z]
          for x in range[5]
          for y in range[5]
          if x != y
          for z in range[5]
          if y != z]

No:
  result = [complicated_transform[
                x, some_argument=x+1]
            for x in iterable if predicate[x]]

  result = [[x, y] for x in range[10] for y in range[5] if x * y > 10]

  return [[x, y, z]
          for x in range[5]
          for y in range[5]
          if x != y
          for z in range[5]
          if y != z]

3. 19. 4 giá trị mặc định

Theo , chỉ sử dụng khoảng trắng xung quanh

from sound.effects import echo
...
echo.EchoFilter[input, output, delay=0.7, atten=4]

51 cho các đối số có cả chú thích loại và giá trị mặc định

No:
  result = [complicated_transform[
                x, some_argument=x+1]
            for x in iterable if predicate[x]]

  result = [[x, y] for x in range[10] for y in range[5] if x * y > 10]

  return [[x, y, z]
          for x in range[5]
          for y in range[5]
          if x != y
          for z in range[5]
          if y != z]

No:
  result = [complicated_transform[
                x, some_argument=x+1]
            for x in iterable if predicate[x]]

  result = [[x, y] for x in range[10] for y in range[5] if x * y > 10]

  return [[x, y, z]
          for x in range[5]
          for y in range[5]
          if x != y
          for z in range[5]
          if y != z]

3. 19. 5 Không có Loại

Trong hệ thống kiểu Python,

Yes:
  # Reference flags in code with just the module name [common].
  from absl import flags
  from doctor.who import jodie

  _FOO = flags.DEFINE_string[...]

06 là kiểu "hạng nhất" và vì mục đích đánh máy,

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

98 là bí danh của

Yes:
  # Reference flags in code with just the module name [common].
  from absl import flags
  from doctor.who import jodie

  _FOO = flags.DEFINE_string[...]

06. Nếu một đối số có thể là

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

98, thì nó phải được khai báo. Bạn có thể sử dụng

Yes:
  # Reference flags in code with just the module name [common].
  from absl import flags
  from doctor.who import jodie

  _FOO = flags.DEFINE_string[...]

10, nhưng nếu chỉ có một loại khác, hãy sử dụng

Yes:
  # Reference flags in code with just the module name [common].
  from absl import flags
  from doctor.who import jodie

  _FOO = flags.DEFINE_string[...]

Sử dụng

Yes:
  # Reference flags in code with just the module name [common].
  from absl import flags
  from doctor.who import jodie

  _FOO = flags.DEFINE_string[...]

11 rõ ràng thay vì ngầm ẩn

Yes:
  # Reference flags in code with just the module name [common].
  from absl import flags
  from doctor.who import jodie

  _FOO = flags.DEFINE_string[...]

11. Earlier versions of PEP 484 allowed

Yes:
  # Reference flags in code with just the module name [common].
  from absl import flags
  from doctor.who import jodie

  _FOO = flags.DEFINE_string[...]

14 to be interpreted as

Yes:
  # Reference flags in code with just the module name [common].
  from absl import flags
  from doctor.who import jodie

  _FOO = flags.DEFINE_string[...]

15, but that is no longer the preferred behavior

No:
  result = [complicated_transform[
                x, some_argument=x+1]
            for x in iterable if predicate[x]]

  result = [[x, y] for x in range[10] for y in range[5] if x * y > 10]

  return [[x, y, z]
          for x in range[5]
          for y in range[5]
          if x != y
          for z in range[5]
          if y != z]

No:
  result = [complicated_transform[
                x, some_argument=x+1]
            for x in iterable if predicate[x]]

  result = [[x, y] for x in range[10] for y in range[5] if x * y > 10]

  return [[x, y, z]
          for x in range[5]
          for y in range[5]
          if x != y
          for z in range[5]
          if y != z]

3. 19. 6 bí danh loại

Bạn có thể khai báo bí danh của các loại phức tạp. Tên của bí danh phải là CapWorded. Nếu bí danh chỉ được sử dụng trong mô-đun này, thì bí danh đó phải là _Private

Ví dụ: nếu tên của mô-đun cùng với tên của loại quá dài

No:
  result = [complicated_transform[
                x, some_argument=x+1]
            for x in iterable if predicate[x]]

  result = [[x, y] for x in range[10] for y in range[5] if x * y > 10]

  return [[x, y, z]
          for x in range[5]
          for y in range[5]
          if x != y
          for z in range[5]
          if y != z]

Các ví dụ khác là các kiểu lồng nhau phức tạp và nhiều biến trả về từ một hàm [dưới dạng một bộ]

3. 19. 7 kiểu phớt lờ

Bạn có thể tắt kiểm tra loại trên một dòng bằng chú thích đặc biệt

Yes:
  # Reference flags in code with just the module name [common].
  from absl import flags
  from doctor.who import jodie

  _FOO = flags.DEFINE_string[...]

Yes:
  # Reference flags in code with just the module name [common].
  from absl import flags
  from doctor.who import jodie

  _FOO = flags.DEFINE_string[...]

17 có tùy chọn tắt đối với các lỗi cụ thể [tương tự như xơ vải]

No:
  result = [complicated_transform[
                x, some_argument=x+1]
            for x in iterable if predicate[x]]

  result = [[x, y] for x in range[10] for y in range[5] if x * y > 10]

  return [[x, y, z]
          for x in range[5]
          for y in range[5]
          if x != y
          for z in range[5]
          if y != z]

3. 19. 8 biến gõ

Nếu một biến nội bộ có loại khó hoặc không thể suy luận, hãy chỉ định loại của biến đó bằng một phép gán được chú thích - sử dụng dấu hai chấm và nhập giữa tên và giá trị của biến [tương tự như được thực hiện với các đối số hàm có giá trị mặc định]

No:
  result = [complicated_transform[
                x, some_argument=x+1]
            for x in iterable if predicate[x]]

  result = [[x, y] for x in range[10] for y in range[5] if x * y > 10]

  return [[x, y, z]
          for x in range[5]
          for y in range[5]
          if x != y
          for z in range[5]
          if y != z]

Mặc dù bạn có thể thấy chúng còn lại trong cơ sở mã [chúng cần thiết trước Python 3. 6], không thêm bất kỳ cách sử dụng nào nữa của nhận xét

Yes:
  # Reference flags in code with just the module name [common].
  from absl import flags
  from doctor.who import jodie

  _FOO = flags.DEFINE_string[...]

18 ở cuối dòng

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

3. 19. 9 Tuples vs Danh sách

Danh sách đã nhập chỉ có thể chứa các đối tượng thuộc một loại. Các bộ dữ liệu đã nhập có thể có một loại lặp lại duy nhất hoặc một số phần tử được đặt với các loại khác nhau. Cái sau thường được sử dụng làm kiểu trả về từ một hàm

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

3. 19. 10 LoạiVars

Hệ thống kiểu Python có. Chức năng nhà máy

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

55 là một cách phổ biến để sử dụng chúng

Thí dụ

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

Một TypeVar có thể bị ràng buộc

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

Biến loại được xác định trước phổ biến trong mô-đun

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

21 là

Yes:
  # Reference flags in code with just the module name [common].
  from absl import flags
  from doctor.who import jodie

  _FOO = flags.DEFINE_string[...]

21. Sử dụng nó cho nhiều chú thích có thể là

Yes:
  # Reference flags in code with just the module name [common].
  from absl import flags
  from doctor.who import jodie

  _FOO = flags.DEFINE_string[...]

22 hoặc

Yes:
  # Reference flags in code with just the module name [common].
  from absl import flags
  from doctor.who import jodie

  _FOO = flags.DEFINE_string[...]

23 và tất cả phải cùng loại

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

TypeVar phải có tên mô tả, trừ khi nó đáp ứng tất cả các tiêu chí sau

không thể nhìn thấy bên ngoài
không bị hạn chế

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

3. 19. 11 loại Chuỗi

Không sử dụng
Yes:
  # Reference flags in code with just the module name [common].
  from absl import flags
  from doctor.who import jodie

  _FOO = flags.DEFINE_string[...]
24 trong mã mới. Nó chỉ tương thích với Python 2/3

Sử dụng

Yes:
  # Reference flags in code with just the module name [common].
  from absl import flags
  from doctor.who import jodie

  _FOO = flags.DEFINE_string[...]

23 cho dữ liệu chuỗi/văn bản. Đối với mã liên quan đến dữ liệu nhị phân, hãy sử dụng

Yes:
  # Reference flags in code with just the module name [common].
  from absl import flags
  from doctor.who import jodie

  _FOO = flags.DEFINE_string[...]

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

Nếu tất cả các kiểu chuỗi của một hàm luôn giống nhau, chẳng hạn nếu kiểu trả về giống với kiểu đối số trong đoạn mã trên, hãy sử dụng

3. 19. 12 Nhập khẩu để gõ

Đối với các ký hiệu từ các mô-đun

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

21 và

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

22 được sử dụng để hỗ trợ phân tích tĩnh và kiểm tra loại, hãy luôn nhập chính ký hiệu đó. Điều này giữ cho các chú thích phổ biến ngắn gọn hơn và phù hợp với các cách gõ được sử dụng trên khắp thế giới. Bạn rõ ràng được phép nhập nhiều lớp cụ thể trên một dòng từ các mô-đun

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

21 và

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

22. Bán tại

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

Cho rằng cách nhập này thêm các mục vào không gian tên cục bộ, các tên trong

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

21 hoặc

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

22 phải được xử lý tương tự như các từ khóa và không được xác định trong mã Python của bạn, được nhập hay không. Nếu có sự xung đột giữa một loại và một tên hiện có trong một mô-đun, hãy nhập nó bằng cách sử dụng

Yes:
  # Reference flags in code with just the module name [common].
  from absl import flags
  from doctor.who import jodie

  _FOO = flags.DEFINE_string[...]

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

Ưu tiên sử dụng các loại tích hợp làm chú thích nếu có. Python hỗ trợ các chú thích loại bằng cách sử dụng các loại vùng chứa tham số qua PEP-585, được giới thiệu trong Python 3. 9

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

GHI CHÚ. Người dùng Apache Beam nên tiếp tục nhập vùng chứa tham số từ

Yes:
  # Reference absl.flags in code with the complete name [verbose].
  import absl.flags
  from doctor.who import jodie

  _FOO = absl.flags.DEFINE_string[...]

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

3. 19. 13 Nhập khẩu có điều kiện

Chỉ sử dụng nhập có điều kiện trong các trường hợp đặc biệt khi phải tránh nhập bổ sung cần thiết để kiểm tra loại trong thời gian chạy. Mô hình này không được khuyến khích;

Các mục nhập chỉ cần thiết cho chú thích loại có thể được đặt trong một khối

Yes:
  # Reference flags in code with just the module name [common].
  from absl import flags
  from doctor.who import jodie

  _FOO = flags.DEFINE_string[...]

Các loại được nhập có điều kiện cần được tham chiếu dưới dạng chuỗi, để tương thích chuyển tiếp với Python 3. 6 nơi các biểu thức chú thích thực sự được đánh giá
Chỉ các thực thể được sử dụng duy nhất để nhập mới được xác định ở đây; . Nếu không, đó sẽ là lỗi thời gian chạy, vì mô-đun sẽ không được nhập vào thời gian chạy
Khối phải ở ngay sau tất cả các lần nhập thông thường
Không được có dòng trống nào trong danh sách nhập nhập

Sắp xếp danh sách này như thể nó là một danh sách nhập thông thường

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

3. 19. 14 phụ thuộc tuần hoàn

Các phụ thuộc tròn gây ra bởi việc gõ là mã có mùi. Mã như vậy là một ứng cử viên tốt để tái cấu trúc. Mặc dù về mặt kỹ thuật, có thể giữ các phụ thuộc vòng tròn, nhưng các hệ thống xây dựng khác nhau sẽ không cho phép bạn làm như vậy vì mỗi mô-đun phải phụ thuộc vào mô-đun khác

Thay thế các mô-đun tạo nhập khẩu phụ thuộc vòng tròn bằng

Yes:
  # Reference flags in code with just the module name [common].
  from absl import flags
  from doctor.who import jodie

  _FOO = flags.DEFINE_string[...]

01. Đặt một tên có ý nghĩa và sử dụng tên loại thực từ mô-đun này [bất kỳ thuộc tính nào của Any là Any]. Các định nghĩa bí danh phải được phân tách khỏi lần nhập cuối cùng bằng một dòng

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

3. 19. 15 thuốc gốc

Khi chú thích, ưu tiên chỉ định tham số loại cho các loại chung;

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

Nếu tham số loại tốt nhất cho một tên chung là

Yes:
  # Reference flags in code with just the module name [common].
  from absl import flags
  from doctor.who import jodie

  _FOO = flags.DEFINE_string[...]

01, hãy làm cho nó rõ ràng, nhưng hãy nhớ rằng trong nhiều trường hợp có thể phù hợp hơn

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

def viking_cafe_order[spam: str, beans: str, eggs: Optional[str] = None] -> str:
    del beans, eggs  # Unused by vikings.
    return spam + spam + spam

4 Lời Chia Tay

HÃY KIÊN NHẪN

Nếu bạn đang chỉnh sửa mã, hãy dành vài phút để xem mã xung quanh bạn và xác định phong cách của nó. Nếu họ sử dụng khoảng trắng xung quanh tất cả các toán tử số học của họ, thì bạn cũng nên. Nếu nhận xét của họ có các hộp dấu thăng nhỏ xung quanh, hãy làm cho nhận xét của bạn cũng có các hộp dấu thăng nhỏ xung quanh chúng

Mục đích của việc có các hướng dẫn về phong cách là có một vốn từ vựng chung về viết mã để mọi người có thể tập trung vào những gì bạn đang nói hơn là vào cách bạn nói. Chúng tôi trình bày các quy tắc phong cách toàn cầu ở đây để mọi người biết từ vựng, nhưng phong cách địa phương cũng rất quan trọng. Nếu mã bạn thêm vào một tệp trông khác hẳn so với mã hiện có xung quanh nó, nó sẽ khiến người đọc mất nhịp khi họ đọc nó. Tránh điều này