Hướng dẫn python line length best practices - các phương pháp hay nhất về độ dài dòng python

Như Guido Van Rossum đã nói, mã Code được đọc thường xuyên hơn nhiều so với viết. Bạn có thể dành một vài phút, hoặc cả ngày, viết một đoạn mã để xử lý xác thực người dùng. Một khi bạn đã viết nó, bạn sẽ không bao giờ viết nó nữa. Nhưng bạn chắc chắn sẽ phải đọc nó một lần nữa. Món mã đó có thể vẫn là một phần của một dự án mà bạn đang làm việc. Mỗi khi bạn quay lại tệp đó, bạn sẽ phải nhớ mã đó làm gì và tại sao bạn viết nó, vì vậy khả năng đọc có vấn đề.

Nếu bạn mới sử dụng Python, có thể khó có thể nhớ một đoạn mã làm gì trong vài ngày, hoặc vài tuần, sau khi bạn viết nó. Nếu bạn theo PEP 8, bạn có thể chắc chắn rằng bạn đã đặt tên cho các biến của mình tốt. Bạn có thể biết rằng bạn đã thêm đủ khoảng trắng để nó dễ dàng hơn để làm theo các bước logic trong mã của bạn. Bạn cũng đã nhận xét mã của bạn tốt. Tất cả điều này sẽ có nghĩa là mã của bạn dễ đọc hơn và dễ dàng trở lại. Là người mới bắt đầu, tuân theo các quy tắc của PEP 8 có thể làm cho việc học Python trở thành một nhiệm vụ dễ chịu hơn nhiều.

class MyClass:
    def first_method(self):
        return None

    def second_method(self):
        return None

class MyClass:
    def first_method(self):
        return None

    def second_method(self):
        return None

class MyClass:
    def first_method(self):
        return None

    def second_method(self):
        return None

class MyClass:
    def first_method(self):
        return None

    def second_method(self):
        return None

class MyClass:
    def first_method(self):
        return None

    def second_method(self):
        return None

class MyClass:
    def first_method(self):
        return None

    def second_method(self):
        return None

def calculate_variance(number_list):
    sum_list = 0
    for number in number_list:
        sum_list = sum_list + number
    mean = sum_list / len(number_list)

    sum_squares = 0
    for number in number_list:
        sum_squares = sum_squares + number**2
    mean_squares = sum_squares / len(number_list)

    return mean_squares - mean**2

def calculate_variance(number_list):
    sum_list = 0
    for number in number_list:
        sum_list = sum_list + number
    mean = sum_list / len(number_list)

    sum_squares = 0
    for number in number_list:
        sum_squares = sum_squares + number**2
    mean_squares = sum_squares / len(number_list)

    return mean_squares - mean**2

def calculate_variance(number_list):
    sum_list = 0
    for number in number_list:
        sum_list = sum_list + number
    mean = sum_list / len(number_list)

    sum_squares = 0
    for number in number_list:
        sum_squares = sum_squares + number**2
    mean_squares = sum_squares / len(number_list)

    return mean_squares - mean**2

def calculate_variance(number_list):
    sum_list = 0
    for number in number_list:
        sum_list = sum_list + number
    mean = sum_list / len(number_list)

    sum_squares = 0
    for number in number_list:
        sum_squares = sum_squares + number**2
    mean_squares = sum_squares / len(number_list)

    return mean_squares - mean**2

def calculate_variance(number_list):
    sum_list = 0
    for number in number_list:
        sum_list = sum_list + number
    mean = sum_list / len(number_list)

    sum_squares = 0
    for number in number_list:
        sum_squares = sum_squares + number**2
    mean_squares = sum_squares / len(number_list)

    return mean_squares - mean**2

def calculate_variance(number_list):
    sum_list = 0
    for number in number_list:
        sum_list = sum_list + number
    mean = sum_list / len(number_list)

    sum_squares = 0
    for number in number_list:
        sum_squares = sum_squares + number**2
    mean_squares = sum_squares / len(number_list)

    return mean_squares - mean**2

Mô -đun

Sử dụng một từ hoặc từ ngắn, chữ thường. Các từ riêng biệt với dấu gạch dưới để cải thiện khả năng đọc.

def calculate_variance(number_list):
    sum_list = 0
    for number in number_list:
        sum_list = sum_list + number
    mean = sum_list / len(number_list)

    sum_squares = 0
    for number in number_list:
        sum_squares = sum_squares + number**2
    mean_squares = sum_squares / len(number_list)

    return mean_squares - mean**2

def calculate_variance(number_list):
    sum_list = 0
    for number in number_list:
        sum_list = sum_list + number
    mean = sum_list / len(number_list)

    sum_squares = 0
    for number in number_list:
        sum_squares = sum_squares + number**2
    mean_squares = sum_squares / len(number_list)

    return mean_squares - mean**2

>>>

>>> # Not recommended
>>> x = 'John Smith'
>>> y, z = x.split()
>>> print(z, y, sep=', ')
'Smith, John'

Điều này sẽ hoạt động, nhưng bạn sẽ phải theo dõi những gì

class MyClass:
    def first_method(self):
        return None

    def second_method(self):
        return None

def function(arg_one, arg_two,
             arg_three, arg_four):
    return arg_one

def function(arg_one, arg_two,
             arg_three, arg_four):
    return arg_one

>>>

>>> # Recommended
>>> name = 'John Smith'
>>> first_name, last_name = name.split()
>>> print(last_name, first_name, sep=', ')
'Smith, John'

Tương tự, để giảm số lượng gõ bạn làm, việc sử dụng chữ viết tắt khi chọn tên. Trong ví dụ dưới đây, tôi đã xác định một hàm

def function(arg_one, arg_two,
             arg_three, arg_four):
    return arg_one

class MyClass:
    def first_method(self):
        return None

    def second_method(self):
        return None

# Not recommended
def db(x):
    return x * 2

Thoạt nhìn, điều này có vẻ như là một lựa chọn hợp lý.

def function(arg_one, arg_two,
             arg_three, arg_four):
    return arg_one

Ví dụ sau đây rõ ràng hơn nhiều. Nếu bạn quay lại mã này một vài ngày sau khi viết nó, bạn sẽ vẫn có thể đọc và hiểu mục đích của chức năng này:

# Recommended
def multiply_by_two(x):
    return x * 2

Triết lý tương tự áp dụng cho tất cả các loại dữ liệu và đối tượng khác trong Python. Luôn cố gắng sử dụng các tên ngắn gọn nhưng mô tả nhất có thể.

Các dòng trống

Khoảng trắng dọc, hoặc các dòng trống, có thể cải thiện đáng kể khả năng đọc mã của bạn. Mã mà Lừa bị bó lại với nhau có thể quá sức và khó đọc. Tương tự, quá nhiều dòng trống trong mã của bạn làm cho nó trông rất thưa thớt và người đọc có thể cần phải cuộn nhiều hơn mức cần thiết. Dưới đây là ba hướng dẫn chính về cách sử dụng khoảng trắng dọc.

Các chức năng và lớp cấp cao nhất với hai dòng trống. Các chức năng và các lớp cấp cao nhất nên được khép kín và xử lý các chức năng riêng biệt. Thật hợp lý khi đặt thêm không gian thẳng đứng xung quanh chúng, để nó rõ ràng chúng là riêng biệt: Top-level functions and classes should be fairly self-contained and handle separate functionality. It makes sense to put extra vertical space around them, so that it’s clear they are separate:

class MyFirstClass:
    pass


class MySecondClass:
    pass


def top_level_function():
    return None

Định nghĩa phương thức xung quanh bên trong các lớp với một dòng trống duy nhất. Bên trong một lớp, các chức năng đều liên quan đến nhau. Nó thực hành tốt chỉ để lại một dòng duy nhất giữa họ: Inside a class, functions are all related to one another. It’s good practice to leave only a single line between them:

class MyClass:
    def first_method(self):
        return None

    def second_method(self):
        return None

Sử dụng các dòng trống một cách tiết kiệm các chức năng để hiển thị các bước rõ ràng. Đôi khi, một chức năng phức tạp phải hoàn thành một số bước trước câu lệnh

def function(arg_one, arg_two,
             arg_three, arg_four):
    return arg_one

def function(arg_one, arg_two,
             arg_three, arg_four):
    return arg_one

Trong ví dụ dưới đây, có một hàm để tính phương sai của danh sách. Đây là vấn đề hai bước, vì vậy tôi đã chỉ ra mỗi bước bằng cách để lại một đường trống giữa chúng. Ngoài ra còn có một dòng trống trước câu lệnh

def function(arg_one, arg_two,
             arg_three, arg_four):
    return arg_one

def calculate_variance(number_list):
    sum_list = 0
    for number in number_list:
        sum_list = sum_list + number
    mean = sum_list / len(number_list)

    sum_squares = 0
    for number in number_list:
        sum_squares = sum_squares + number**2
    mean_squares = sum_squares / len(number_list)

    return mean_squares - mean**2

Nếu bạn sử dụng một khoảng trắng dọc, nó có thể cải thiện đáng kể khả năng đọc mã của bạn. Nó giúp người đọc hiểu trực quan cách mã của bạn chia thành các phần và cách các phần đó liên quan đến nhau.

Độ dài dòng tối đa và phá vỡ đường

PEP 8 gợi ý các dòng nên được giới hạn ở 79 ký tự. Điều này là do nó cho phép bạn mở nhiều tệp bên cạnh nhau, đồng thời tránh việc gói dòng.

Tất nhiên, việc giữ tuyên bố cho 79 ký tự hoặc ít hơn không phải lúc nào cũng có thể. PEP 8 phác thảo các cách để cho phép các câu lệnh chạy qua một số dòng.

Python sẽ giả định tiếp tục dòng nếu mã được chứa trong ngoặc đơn, dấu ngoặc hoặc niềng răng:

def function(arg_one, arg_two,
             arg_three, arg_four):
    return arg_one

Nếu không thể sử dụng tiếp tục ngụ ý, thì bạn có thể sử dụng dấu gạch chéo ngược để phá vỡ các dòng thay thế:

from mypkg import example1, \
    example2, example3

Tuy nhiên, nếu bạn có thể sử dụng tiếp tục ngụ ý, thì bạn nên làm như vậy.

Nếu phá vỡ dòng cần xảy ra xung quanh các toán tử nhị phân, như

from mypkg import example1, \
    example2, example3

from mypkg import example1, \
    example2, example3

Dưới đây là một ví dụ về việc phá vỡ trước một toán tử nhị phân:

# Recommended
total = (first_variable
         + second_variable
         - third_variable)

Bạn có thể ngay lập tức thấy biến nào đang được thêm hoặc trừ, vì toán tử nằm ngay bên cạnh biến được vận hành.

Bây giờ, hãy để Lừa xem một ví dụ về việc phá vỡ sau một nhà điều hành nhị phân:

>>> # Recommended
>>> name = 'John Smith'
>>> first_name, last_name = name.split()
>>> print(last_name, first_name, sep=', ')
'Smith, John'

Ở đây, nó khó hơn để xem biến nào đang được thêm vào và cái nào được trừ đi.

Phá vỡ trước khi các nhà khai thác nhị phân tạo ra mã dễ đọc hơn, vì vậy PEP 8 khuyến khích nó. Mã liên tục bị phá vỡ sau khi một toán tử nhị phân vẫn tuân thủ PEP 8. Tuy nhiên, bạn đã khuyến khích phá vỡ trước một nhà điều hành nhị phân.

Tab so với không gian

Như đã đề cập ở trên, bạn nên sử dụng không gian thay vì các tab khi thụt mã. Bạn có thể điều chỉnh các cài đặt trong trình soạn thảo văn bản của mình để xuất 4 khoảng trắng thay vì ký tự tab, khi bạn nhấn phím tab.Tab key.

Nếu bạn sử dụng Python 2 và đã sử dụng hỗn hợp các tab và không gian để thụt mã mã của bạn, bạn đã giành được lỗi khi cố gắng chạy nó. Để giúp bạn kiểm tra tính nhất quán, bạn có thể thêm cờ

from mypkg import example1, \
    example2, example3

>>> # Recommended
>>> name = 'John Smith'
>>> first_name, last_name = name.split()
>>> print(last_name, first_name, sep=', ')
'Smith, John'

Thay vào đó, nếu bạn sử dụng cờ

from mypkg import example1, \
    example2, example3

>>> # Recommended
>>> name = 'John Smith'
>>> first_name, last_name = name.split()
>>> print(last_name, first_name, sep=', ')
'Smith, John'

Python 3 không cho phép trộn các tab và không gian. Do đó, nếu bạn đang sử dụng Python 3, thì các lỗi này sẽ được cấp tự động:

>>> # Recommended
>>> name = 'John Smith'
>>> first_name, last_name = name.split()
>>> print(last_name, first_name, sep=', ')
'Smith, John'

Bạn có thể viết mã Python bằng các tab hoặc không gian cho biết thụt lề. Nhưng, nếu bạn sử dụng Python 3, bạn phải phù hợp với sự lựa chọn của mình. Nếu không, mã của bạn sẽ không chạy. PEP 8 khuyên bạn nên luôn sử dụng 4 không gian liên tiếp để chỉ ra thụt lề.

Vết lõm sau khi phá vỡ dòng

Khi bạn sử dụng các tiếp tục dòng để giữ các dòng dưới 79 ký tự, sẽ rất hữu ích khi sử dụng thụt vào để cải thiện khả năng đọc. Nó cho phép người đọc phân biệt giữa hai dòng mã và một dòng mã duy nhất kéo dài hai dòng. Có hai kiểu thụt bạn có thể sử dụng.

Đầu tiên trong số này là căn chỉnh khối thụt lề với dấu phân cách mở:

def function(arg_one, arg_two,
             arg_three, arg_four):
    return arg_one

Đôi khi bạn có thể thấy rằng chỉ cần 4 khoảng trống để sắp xếp với dấu phân cách mở. Điều này thường sẽ xảy ra trong các câu lệnh

from mypkg import example1, \
    example2, example3

from mypkg import example1, \
    example2, example3

from mypkg import example1, \
    example2, example3

>>> # Recommended
>>> name = 'John Smith'
>>> first_name, last_name = name.split()
>>> print(last_name, first_name, sep=', ')
'Smith, John'

Trong trường hợp này, PEP 8 cung cấp hai lựa chọn thay thế để giúp cải thiện khả năng đọc:

• Thêm một bình luận sau điều kiện cuối cùng. Do sự nổi bật của cú pháp trong hầu hết các biên tập viên, điều này sẽ tách các điều kiện khỏi mã lồng nhau:

  >>> # Recommended
  >>> name = 'John Smith'
  >>> first_name, last_name = name.split()
  >>> print(last_name, first_name, sep=', ')
  'Smith, John'
  

  7

• Thêm thụt thêm vào tiếp tục dòng:

  >>> # Recommended
  >>> name = 'John Smith'
  >>> first_name, last_name = name.split()
  >>> print(last_name, first_name, sep=', ')
  'Smith, John'
  

  8

Một phong cách thay thế của thụt sau khi phá vỡ dòng là một thụt lề treo. Đây là một thuật ngữ đánh máy có nghĩa là mỗi dòng nhưng đầu tiên trong một đoạn hoặc câu lệnh được thụt vào. Bạn có thể sử dụng thụt lề treo để biểu thị trực quan một dòng mã. Đây là một ví dụ:hanging indent. This is a typographical term meaning that every line but the first in a paragraph or statement is indented. You can use a hanging indent to visually represent a continuation of a line of code. Here’s an example:

>>> # Recommended
>>> name = 'John Smith'
>>> first_name, last_name = name.split()
>>> print(last_name, first_name, sep=', ')
'Smith, John'

Khi sử dụng thụt lề treo, hãy thêm thụt lề để phân biệt dòng tiếp tục với mã chứa bên trong hàm. Ví dụ sau rất khó đọc vì mã bên trong hàm ở cùng mức thụt với các dòng tiếp tục:

# Not recommended
def db(x):
    return x * 2

Thay vào đó, nó tốt hơn để sử dụng một thụt lề kép trên tiếp tục dòng. Điều này giúp bạn phân biệt giữa các đối số chức năng và cơ thể chức năng, cải thiện khả năng đọc:

# Not recommended
def db(x):
    return x * 2

Khi bạn viết mã tuân thủ PEP 8, giới hạn dòng 79 ký tự buộc bạn phải thêm các lần phá vỡ dòng trong mã của bạn. Để cải thiện khả năng đọc, bạn nên thụt vào một dòng tiếp tục để cho thấy rằng đó là một dòng tiếp tục. Có hai cách để làm điều này. Đầu tiên là căn chỉnh khối thụt lề với dấu phân cách mở. Thứ hai là sử dụng một thụt lề treo. Bạn có thể tự do chọn phương pháp nào bạn sử dụng sau khi phá vỡ dòng.

Đâu để đặt nẹp đóng cửa ở đâu

Tiếp tục dòng cho phép bạn phá vỡ các đường bên trong dấu ngoặc đơn, ngoặc hoặc niềng răng. Nó dễ dàng quên đi nẹp đóng, nhưng nó rất quan trọng để đặt nó ở đâu đó hợp lý. Nếu không, nó có thể gây nhầm lẫn cho người đọc. PEP 8 cung cấp hai tùy chọn cho vị trí của nẹp đóng trong các tiếp tục dòng ngụ ý:

• Xếp hàng nẹp đóng với ký tự không phải là màu đầu tiên của dòng trước:

  # Not recommended
  def db(x):
      return x * 2
  

  2

• Xếp hàng nẹp đóng với ký tự đầu tiên của dòng bắt đầu cấu trúc:

  # Not recommended
  def db(x):
      return x * 2
  

  3

Bạn có thể tự do chọn tùy chọn bạn sử dụng. Nhưng, như mọi khi, tính nhất quán là chìa khóa, vì vậy hãy cố gắng gắn bó với một trong các phương pháp trên.

Khoảng trắng xung quanh các nhà khai thác nhị phân

Bao quanh các toán tử nhị phân sau với một không gian ở hai bên:

• Toán tử chuyển nhượng (

  # Recommended
  total = (first_variable
           + second_variable
           - third_variable)
  

  1,

  # Recommended
  total = (first_variable
           + second_variable
           - third_variable)
  

  2,

  # Recommended
  total = (first_variable
           + second_variable
           - third_variable)
  

  3, v.v.)

• So sánh (

  # Recommended
  total = (first_variable
           + second_variable
           - third_variable)
  

  4,

  # Recommended
  total = (first_variable
           + second_variable
           - third_variable)
  

  5,

  # Recommended
  total = (first_variable
           + second_variable
           - third_variable)
  

  6,

  # Recommended
  total = (first_variable
           + second_variable
           - third_variable)
  

  7.

• Booleans (

  >>> # Recommended
  >>> name = 'John Smith'
  >>> first_name, last_name = name.split()
  >>> print(last_name, first_name, sep=', ')
  'Smith, John'
  

  04,

  >>> # Recommended
  >>> name = 'John Smith'
  >>> first_name, last_name = name.split()
  >>> print(last_name, first_name, sep=', ')
  'Smith, John'
  

  05,

  >>> # Recommended
  >>> name = 'John Smith'
  >>> first_name, last_name = name.split()
  >>> print(last_name, first_name, sep=', ')
  'Smith, John'
  

  06)

Khi có nhiều hơn một toán tử trong một câu lệnh, việc thêm một khoảng trống trước và sau mỗi người vận hành có thể trông khó hiểu. Thay vào đó, tốt hơn là chỉ thêm khoảng trắng xung quanh các toán tử với mức độ ưu tiên thấp nhất, đặc biệt là khi thực hiện thao tác toán học. Dưới đây là một vài ví dụ:

# Not recommended
def db(x):
    return x * 2

Bạn cũng có thể áp dụng điều này cho các câu lệnh

from mypkg import example1, \
    example2, example3

# Not recommended
def db(x):
    return x * 2

Trong ví dụ trên, toán tử

>>> # Recommended
>>> name = 'John Smith'
>>> first_name, last_name = name.split()
>>> print(last_name, first_name, sep=', ')
'Smith, John'

from mypkg import example1, \
    example2, example3

# Not recommended
def db(x):
    return x * 2

Bạn có thể tự do chọn loại nào rõ ràng hơn, với cảnh báo rằng bạn phải sử dụng cùng một lượng khoảng trắng ở hai bên của toán tử.

Điều sau đây không được chấp nhận:

# Not recommended
def db(x):
    return x * 2

Trong các lát cắt, các dấu chấm là một nhà khai thác nhị phân. Do đó, các quy tắc được nêu trong phần trước được áp dụng và phải có cùng một lượng khoảng trắng ở hai bên. Các ví dụ sau đây về các lát danh sách là hợp lệ:

# Not recommended
def db(x):
    return x * 2

Tóm lại, bạn nên bao quanh hầu hết các nhà khai thác với khoảng trắng. Tuy nhiên, có một số cảnh báo cho quy tắc này, chẳng hạn như trong các đối số chức năng hoặc khi bạn kết hợp nhiều toán tử trong một câu lệnh.

Khi nào nên tránh thêm khoảng trắng

Trong một số trường hợp, việc thêm khoảng trắng có thể làm cho mã khó đọc hơn. Quá nhiều khoảng trắng có thể làm cho mã quá thưa và khó theo dõi. PEP 8 phác thảo các ví dụ rất rõ ràng trong đó khoảng trắng là không phù hợp.

Nơi quan trọng nhất để tránh thêm khoảng trắng là ở cuối dòng. Điều này được gọi là khoảng trắng theo dõi. Nó là vô hình và có thể tạo ra các lỗi khó theo dõi.trailing whitespace. It is invisible and can produce errors that are difficult to trace.

Danh sách sau đây phác thảo một số trường hợp bạn nên tránh thêm khoảng trắng:

• Ngay bên trong dấu ngoặc đơn, dấu ngoặc hoặc niềng răng:

  # Not recommended
  def db(x):
      return x * 2
  

  9

• Trước dấu phẩy, dấu chấm phẩy hoặc ruột kết:

  # Recommended
  def multiply_by_two(x):
      return x * 2
  

  0

• Trước dấu ngoặc đơn mở ra danh sách đối số của một cuộc gọi chức năng:

  # Recommended
  def multiply_by_two(x):
      return x * 2
  

  1

• Trước khung mở bắt đầu một chỉ mục hoặc lát cắt:

  # Recommended
  def multiply_by_two(x):
      return x * 2
  

  2

• Giữa dấu phẩy kéo dài và dấu ngoặc đơn kết thúc:

  # Recommended
  def multiply_by_two(x):
      return x * 2
  

  3

• Để sắp xếp các toán tử chuyển nhượng:

  # Recommended
  def multiply_by_two(x):
      return x * 2
  

  4

Hãy chắc chắn rằng không có khoảng trắng nào ở bất cứ đâu trong mã của bạn. Có những trường hợp khác trong đó PEP 8 không khuyến khích thêm khoảng trắng, chẳng hạn như ngay bên trong ngoặc, cũng như trước dấu phẩy và đại quý. Bạn cũng không bao giờ nên thêm khoảng trắng bổ sung để sắp xếp các nhà khai thác.

Linters

Linters là các chương trình phân tích lỗi mã và cờ. Họ cung cấp các đề xuất về cách khắc phục lỗi. Linters đặc biệt hữu ích khi được cài đặt làm phần mở rộng cho trình soạn thảo văn bản của bạn, vì chúng gắn cờ lỗi và các vấn đề về phong cách trong khi bạn viết. Trong phần này, bạn sẽ thấy một phác thảo về cách các linters hoạt động, với các liên kết đến các phần mở rộng trình soạn thảo văn bản ở cuối.

Các lớp lót tốt nhất cho mã Python là như sau:

• >>> # Recommended
  >>> name = 'John Smith'
  >>> first_name, last_name = name.split()
  >>> print(last_name, first_name, sep=', ')
  'Smith, John'
  

  48 là một công cụ để kiểm tra mã Python của bạn đối với một số quy ước về kiểu trong PEP 8. is a tool to check your Python code against some of the style conventions in PEP 8.

  Cài đặt

  >>> # Recommended
  >>> name = 'John Smith'
  >>> first_name, last_name = name.split()
  >>> print(last_name, first_name, sep=', ')
  'Smith, John'
  

  48 bằng cách sử dụng

  >>> # Recommended
  >>> name = 'John Smith'
  >>> first_name, last_name = name.split()
  >>> print(last_name, first_name, sep=', ')
  'Smith, John'
  

  50:

  class MyFirstClass:
      pass
  
  
  class MySecondClass:
      pass
  
  
  def top_level_function():
      return None
  

  7

  Bạn có thể chạy

  >>> # Recommended
  >>> name = 'John Smith'
  >>> first_name, last_name = name.split()
  >>> print(last_name, first_name, sep=', ')
  'Smith, John'
  

  48 từ thiết bị đầu cuối bằng lệnh sau:

  class MyFirstClass:
      pass
  
  
  class MySecondClass:
      pass
  
  
  def top_level_function():
      return None
  

  8

• >>> # Recommended
  >>> name = 'John Smith'
  >>> first_name, last_name = name.split()
  >>> print(last_name, first_name, sep=', ')
  'Smith, John'
  

  52 là một công cụ kết hợp trình gỡ lỗi,

  >>> # Recommended
  >>> name = 'John Smith'
  >>> first_name, last_name = name.split()
  >>> print(last_name, first_name, sep=', ')
  'Smith, John'
  

  53, với

  >>> # Recommended
  >>> name = 'John Smith'
  >>> first_name, last_name = name.split()
  >>> print(last_name, first_name, sep=', ')
  'Smith, John'
  

  48. is a tool that combines a debugger,

  >>> # Recommended
  >>> name = 'John Smith'
  >>> first_name, last_name = name.split()
  >>> print(last_name, first_name, sep=', ')
  'Smith, John'
  

  53, with

  >>> # Recommended
  >>> name = 'John Smith'
  >>> first_name, last_name = name.split()
  >>> print(last_name, first_name, sep=', ')
  'Smith, John'
  

  48.

  Cài đặt

  >>> # Recommended
  >>> name = 'John Smith'
  >>> first_name, last_name = name.split()
  >>> print(last_name, first_name, sep=', ')
  'Smith, John'
  

  52 bằng cách sử dụng

  >>> # Recommended
  >>> name = 'John Smith'
  >>> first_name, last_name = name.split()
  >>> print(last_name, first_name, sep=', ')
  'Smith, John'
  

  50:

  Chạy

  >>> # Recommended
  >>> name = 'John Smith'
  >>> first_name, last_name = name.split()
  >>> print(last_name, first_name, sep=', ')
  'Smith, John'
  

  52 từ thiết bị đầu cuối bằng lệnh sau:

  class MyFirstClass:
      pass
  
  
  class MySecondClass:
      pass
  
  
  def top_level_function():
      return None
  

  9

  Một ví dụ về đầu ra cũng được hiển thị.

Chúng cũng có sẵn dưới dạng tiện ích mở rộng cho Atom, văn bản tuyệt vời, mã Visual Studio và VIM. Bạn cũng có thể tìm thấy các hướng dẫn về thiết lập văn bản siêu phàm và vim để phát triển Python, cũng như tổng quan về một số biên tập viên văn bản phổ biến tại Real Python.

Autoformatters

AutoforMatters là các chương trình tái cấu trúc mã của bạn để tự động tuân thủ PEP 8. Khi chương trình như vậy là

>>> # Recommended
>>> name = 'John Smith'
>>> first_name, last_name = name.split()
>>> print(last_name, first_name, sep=', ')
'Smith, John'

Cài đặt

>>> # Recommended
>>> name = 'John Smith'
>>> first_name, last_name = name.split()
>>> print(last_name, first_name, sep=', ')
'Smith, John'

>>> # Recommended
>>> name = 'John Smith'
>>> first_name, last_name = name.split()
>>> print(last_name, first_name, sep=', ')
'Smith, John'

Nó có thể được chạy qua dòng lệnh, như với các linters. Hãy nói rằng bạn bắt đầu với mã sau đó là PEP 8 tuân thủ trong một tệp có tên

>>> # Recommended
>>> name = 'John Smith'
>>> first_name, last_name = name.split()
>>> print(last_name, first_name, sep=', ')
'Smith, John'

class MyClass:
    def first_method(self):
        return None

    def second_method(self):
        return None

Sau đó, bạn có thể chạy lệnh sau thông qua dòng lệnh:

class MyClass:
    def first_method(self):
        return None

    def second_method(self):
        return None

>>> # Recommended
>>> name = 'John Smith'
>>> first_name, last_name = name.split()
>>> print(last_name, first_name, sep=', ')
'Smith, John'

class MyClass:
    def first_method(self):
        return None

    def second_method(self):
        return None

Nếu bạn muốn thay đổi giới hạn độ dài dòng, thì bạn có thể sử dụng cờ

>>> # Recommended
>>> name = 'John Smith'
>>> first_name, last_name = name.split()
>>> print(last_name, first_name, sep=', ')
'Smith, John'

class MyClass:
    def first_method(self):
        return None

    def second_method(self):
        return None

Hai tự động tự động khác,

>>> # Recommended
>>> name = 'John Smith'
>>> first_name, last_name = name.split()
>>> print(last_name, first_name, sep=', ')
'Smith, John'

>>> # Recommended
>>> name = 'John Smith'
>>> first_name, last_name = name.split()
>>> print(last_name, first_name, sep=', ')
'Smith, John'

>>> # Recommended
>>> name = 'John Smith'
>>> first_name, last_name = name.split()
>>> print(last_name, first_name, sep=', ')
'Smith, John'

Một hướng dẫn Python thực sự khác, Chất lượng mã Python: Công cụ & Thực tiễn tốt nhất của Alexander Van Tol, đưa ra lời giải thích kỹ lưỡng về cách sử dụng các công cụ này.