Hướng dẫn python global variable across modules - biến toàn cục python trên các mô-đun

Có trình gỡ lỗi cấp mã nguồn với các điểm dừng, một bước, v.v ...

Yes.

Một số trình gỡ lỗi cho Python được mô tả dưới đây và chức năng tích hợp

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

Mô-đun PDB là một trình gỡ lỗi chế độ điều khiển đơn giản nhưng đầy đủ cho Python. Nó là một phần của thư viện Python tiêu chuẩn và là

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

Môi trường phát triển tương tác nhàn rỗi, là một phần của phân phối Python tiêu chuẩn (thường có sẵn dưới dạng Công cụ/SCRIPT/IDLE3), bao gồm trình gỡ lỗi đồ họa.

Pythonwin là một IDE Python bao gồm một trình gỡ lỗi GUI dựa trên PDB. Các điểm dừng màu sắc của Pythonwin và có khá nhiều tính năng thú vị như gỡ lỗi các chương trình phi Pythonwin. Pythonwin có sẵn như là một phần của Dự án PyWin32 và là một phần của phân phối ActivePython.

Eric là một IDE được xây dựng trên PYQT và thành phần chỉnh sửa Scintilla.

Trepan3K là một trình gỡ lỗi giống như GDB.

Visual Studio Code là một IDE với các công cụ gỡ lỗi tích hợp với phần mềm kiểm soát phiên bản.

Có một số IDE Python thương mại bao gồm các trình gỡ lỗi đồ họa. Chúng bao gồm:

• Cánh ide

• Komodo ide

• Pycharm

Có công cụ nào giúp tìm lỗi hoặc thực hiện phân tích tĩnh không? ¶

Yes.

Pylint và Pyflakes kiểm tra cơ bản sẽ giúp bạn bắt lỗi sớm hơn.

Các trình kiểm tra loại tĩnh như mypy, pyre và pytype có thể kiểm tra các gợi ý loại trong mã nguồn python.

Làm thế nào tôi có thể tạo một nhị phân độc lập từ kịch bản Python? ¶

Bạn không cần khả năng biên dịch mã Python với C nếu tất cả những gì bạn muốn là một chương trình độc lập mà người dùng có thể tải xuống và chạy mà không phải cài đặt phân phối Python trước. Có một số công cụ xác định tập hợp các mô -đun theo yêu cầu của một chương trình và liên kết các mô -đun này cùng với một nhị phân Python để tạo ra một thực thi duy nhất.

Một là sử dụng công cụ đóng băng, được bao gồm trong cây nguồn Python làm công cụ/đóng băng. Nó chuyển đổi mã byte python thành m mảng C; Với trình biên dịch C, bạn có thể nhúng tất cả các mô -đun của mình vào một chương trình mới, sau đó được liên kết với các mô -đun Python tiêu chuẩn.

Nó hoạt động bằng cách quét nguồn của bạn một cách đệ quy cho các câu lệnh nhập (ở cả hai dạng) và tìm kiếm các mô-đun trong đường dẫn Python tiêu chuẩn cũng như trong thư mục nguồn (cho các mô-đun tích hợp). Sau đó, nó biến mã byte cho các mô-đun được viết bằng python thành mã C (các bộ khởi tạo mảng có thể được chuyển thành các đối tượng mã bằng mô-đun Nguyên soái) và tạo tệp cấu hình tùy chỉnh chỉ chứa các mô-đun tích hợp đó thực sự được sử dụng trong chương trình. Sau đó, nó biên dịch mã C được tạo và liên kết nó với phần còn lại của trình thông dịch Python để tạo thành một nhị phân khép kín hoạt động giống hệt như tập lệnh của bạn.

Các gói sau đây có thể giúp tạo ra bảng điều khiển và thực thi GUI:

• Nuitka (đa nền tảng)

• Pyinstaller (đa nền tảng)

• Pyoxidizer (đa nền tảng)

• CX_Freeze (đa nền tảng)

• PY2App (chỉ có macOS)

• py2exe (chỉ Windows)

Có tiêu chuẩn mã hóa hoặc hướng dẫn phong cách cho các chương trình Python không? ¶

Đúng. Kiểu mã hóa cần thiết cho các mô -đun thư viện tiêu chuẩn được ghi nhận là PEP 8.PEP 8.

Tại sao tôi lại nhận được không liên lạc khi biến có giá trị? ¶

Có thể là một bất ngờ khi có được

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

Mã này:

>>> x = 10
>>> def bar():
...     print(x)
...
>>> bar()
10

hoạt động, nhưng mã này:

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

kết quả trong một

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Điều này là do khi bạn thực hiện một gán cho một biến trong một phạm vi, biến đó trở thành cục bộ với phạm vi đó và bóng tối bất kỳ biến có tên tương tự nào trong phạm vi bên ngoài. Vì câu lệnh cuối cùng trong FOO gán một giá trị mới cho

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

Trong ví dụ trên, bạn có thể truy cập biến phạm vi bên ngoài bằng cách khai báo nó toàn cầu:

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

Tuyên bố rõ ràng này được yêu cầu để nhắc nhở bạn rằng (không giống như tình huống tương tự bề ngoài với các biến lớp và phiên bản), bạn thực sự đang sửa đổi giá trị của biến trong phạm vi bên ngoài:

Bạn có thể làm một điều tương tự trong phạm vi lồng nhau bằng cách sử dụng từ khóa

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> def foo():
...    x = 10
...    def bar():
...        nonlocal x
...        print(x)
...        x += 1
...    bar()
...    print(x)
...
>>> foo()
10
11

Các quy tắc cho các biến địa phương và toàn cầu trong Python là gì? ¶

Trong Python, các biến chỉ được tham chiếu bên trong một hàm là toàn cầu ngầm. Nếu một biến được gán một giá trị ở bất cứ đâu trong cơ thể chức năng, thì nó được coi là địa phương trừ khi được tuyên bố rõ ràng là toàn cầu.

Though a bit surprising at first, a moment’s consideration explains this. On one hand, requiring

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

Why do lambdas defined in a loop with different values all return the same result?¶

Assume you use a for loop to define a few different lambdas (or even plain functions), e.g.:

>>> squares = []
>>> for x in range(5):
...     squares.append(lambda: x**2)

This gives you a list that contains 5 lambdas that calculate

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> squares[2]()
16
>>> squares[4]()
16

This happens because

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 8
>>> squares[2]()
64

In order to avoid this, you need to save the values in variables local to the lambdas, so that they don’t rely on the value of the global

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> squares = []
>>> for x in range(5):
...     squares.append(lambda n=x: n**2)

Here,

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> squares[2]()
4
>>> squares[4]()
16

Note that this behaviour is not peculiar to lambdas, but applies to regular functions too.

How do I share global variables across modules?¶

The canonical way to share information across modules within a single program is to create a special module (often called config or cfg). Just import the config module in all modules of your application; the module then becomes available as a global name. Because there is only one instance of each module, any changes made to the module object get reflected everywhere. For example:

config.py:

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

mod.py:

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

main.py:

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

Note that using a module is also the basis for implementing the singleton design pattern, for the same reason.

What are the “best practices” for using import in a module?¶

In general, don’t use

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

Import modules at the top of a file. Doing so makes it clear what other modules your code requires and avoids questions of whether the module name is in scope. Using one import per line makes it easy to add and delete module imports, but using multiple imports per line uses less screen space.

It’s good practice if you import modules in the following order:

1. standard library modules – e.g.

   >>> x = 10
   >>> def foo():
   ...     print(x)
   ...     x += 1
   

   36,

   >>> x = 10
   >>> def foo():
   ...     print(x)
   ...     x += 1
   

   37,

   >>> x = 10
   >>> def foo():
   ...     print(x)
   ...     x += 1
   

   38,

   >>> x = 10
   >>> def foo():
   ...     print(x)
   ...     x += 1
   

   39

2. third-party library modules (anything installed in Python’s site-packages directory) – e.g.

   >>> x = 10
   >>> def foo():
   ...     print(x)
   ...     x += 1
   

   40,

   >>> x = 10
   >>> def foo():
   ...     print(x)
   ...     x += 1
   

   41,

   >>> x = 10
   >>> def foo():
   ...     print(x)
   ...     x += 1
   

   42

3. locally developed modules

It is sometimes necessary to move imports to a function or class to avoid problems with circular imports. Gordon McMillan says:

Circular imports are fine where both modules use the “import ” form of import. They fail when the 2nd module wants to grab a name out of the first (“from module import name”) and the import is at the top level. That’s because names in the 1st are not yet available, because the first module is busy importing the 2nd.

In this case, if the second module is only used in one function, then the import can easily be moved into that function. By the time the import is called, the first module will have finished initializing, and the second module can do its import.

It may also be necessary to move imports out of the top level of code if some of the modules are platform-specific. In that case, it may not even be possible to import all of the modules at the top of the file. In this case, importing the correct modules in the corresponding platform-specific code is a good option.

Only move imports into a local scope, such as inside a function definition, if it’s necessary to solve a problem such as avoiding a circular import or are trying to reduce the initialization time of a module. This technique is especially helpful if many of the imports are unnecessary depending on how the program executes. You may also want to move imports into a function if the modules are only ever used in that function. Note that loading a module the first time may be expensive because of the one time initialization of the module, but loading a module multiple times is virtually free, costing only a couple of dictionary lookups. Even if the module name has gone out of scope, the module is probably available in

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

Tại sao các giá trị mặc định được chia sẻ giữa các đối tượng? ¶

Loại lỗi này thường cắn các lập trình viên neophyte. Xem xét chức năng này:

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

Lần đầu tiên bạn gọi chức năng này,

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

Người ta thường hy vọng rằng một cuộc gọi hàm tạo ra các đối tượng mới cho các giá trị mặc định. Đây không phải là những gì xảy ra. Các giá trị mặc định được tạo chính xác một lần, khi hàm được xác định. Nếu đối tượng đó được thay đổi, giống như từ điển trong ví dụ này, các cuộc gọi tiếp theo đến hàm sẽ đề cập đến đối tượng đã thay đổi này.

Theo định nghĩa, các đối tượng bất biến như số, chuỗi, bộ dữ liệu và

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

Do tính năng này, thực tế lập trình tốt là không sử dụng các đối tượng có thể thay đổi làm giá trị mặc định. Thay vào đó, hãy sử dụng

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

but:

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

Tính năng này có thể hữu ích. Khi bạn có một hàm tốn thời gian để tính toán, một kỹ thuật phổ biến là lưu trữ các tham số và giá trị kết quả của mỗi cuộc gọi cho hàm và trả lại giá trị được lưu trữ nếu cùng một giá trị được yêu cầu. Đây được gọi là ghi nhớ của người Hồi giáo, và có thể được thực hiện như thế này:

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

Bạn có thể sử dụng biến toàn cầu chứa từ điển thay vì giá trị mặc định; Nó là một vấn đề của hương vị.

Làm cách nào để chuyển các tham số từ khóa hoặc tùy chọn từ hàm này sang chức năng khác? ¶

Thu thập các đối số bằng cách sử dụng các nhà xác định

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

Sự khác biệt giữa các đối số và tham số là gì? ¶

Các tham số được xác định bởi các tên xuất hiện trong một định nghĩa hàm, trong khi các đối số là các giá trị thực sự được truyền đến một hàm khi gọi nó. Các tham số xác định loại đối số mà một hàm có thể chấp nhận. Ví dụ, đưa ra định nghĩa chức năng: are defined by the names that appear in a function definition, whereas arguments are the values actually passed to a function when calling it. Parameters define what kind of arguments a function can accept. For example, given the function definition:

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

Foo, Bar và Kwargs là các tham số của

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

Các giá trị

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

Tại sao thay đổi danh sách ‘Y, cũng thay đổi danh sách‘ X,? ¶

Nếu bạn đã viết mã như:

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

Bạn có thể tự hỏi tại sao lại thêm một yếu tố vào

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

Có hai yếu tố tạo ra kết quả này:

1. Các biến chỉ đơn giản là tên đề cập đến các đối tượng. Thực hiện

   >>> x = 10
   >>> def foo():
   ...     print(x)
   ...     x += 1
   

   62 không tạo ra một bản sao của danh sách - nó tạo ra một biến mới

   >>> x = 10
   >>> def foo():
   ...     print(x)
   ...     x += 1
   

   60 đề cập đến cùng một đối tượng

   >>> x = 10
   >>> def foo():
   ...     print(x)
   ...     x += 1
   

   07 đề cập đến. Điều này có nghĩa là chỉ có một đối tượng (danh sách) và cả

   >>> x = 10
   >>> def foo():
   ...     print(x)
   ...     x += 1
   

   07 và

   >>> x = 10
   >>> def foo():
   ...     print(x)
   ...     x += 1
   

   60 đều đề cập đến nó.

2. Danh sách có thể thay đổi, điều đó có nghĩa là bạn có thể thay đổi nội dung của họ.mutable, which means that you can change their content.

Sau cuộc gọi đến

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

Nếu chúng ta thay vào đó gán một đối tượng bất biến cho

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Chúng ta có thể thấy rằng trong trường hợp này

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

Một số hoạt động (ví dụ

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

Tuy nhiên, có một lớp hoạt động trong đó cùng một hoạt động đôi khi có các hành vi khác nhau với các loại khác nhau: các toán tử phân công tăng cường. Ví dụ,

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

Nói cách khác:

• Nếu chúng ta có một đối tượng có thể thay đổi (

  >>> x = 10
  >>> def foo():
  ...     print(x)
  ...     x += 1
  

  99,

  >>> foo()
  Traceback (most recent call last):
    ...
  UnboundLocalError: local variable 'x' referenced before assignment
  

  00,

  >>> foo()
  Traceback (most recent call last):
    ...
  UnboundLocalError: local variable 'x' referenced before assignment
  

  01, v.v.), chúng ta có thể sử dụng một số hoạt động cụ thể để biến đổi nó và tất cả các biến đề cập đến nó sẽ thấy sự thay đổi.

• Nếu chúng ta có một đối tượng bất biến (

  >>> foo()
  Traceback (most recent call last):
    ...
  UnboundLocalError: local variable 'x' referenced before assignment
  

  02,

  >>> foo()
  Traceback (most recent call last):
    ...
  UnboundLocalError: local variable 'x' referenced before assignment
  

  03,

  >>> foo()
  Traceback (most recent call last):
    ...
  UnboundLocalError: local variable 'x' referenced before assignment
  

  04, v.v.), tất cả các biến đề cập đến nó sẽ luôn thấy cùng một giá trị, nhưng các hoạt động chuyển đổi giá trị đó thành một giá trị mới luôn trả về một đối tượng mới.

Nếu bạn muốn biết liệu hai biến có đề cập đến cùng một đối tượng hay không, bạn có thể sử dụng toán tử

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Làm cách nào để viết một hàm với các tham số đầu ra (gọi theo tham chiếu)? ¶

Hãy nhớ rằng các lập luận được thông qua bằng cách chuyển nhượng trong Python. Vì nhiệm vụ chỉ tạo ra các tham chiếu đến các đối tượng, nên không có bí danh nào giữa một tên đối số trong người gọi và callee, và do đó, không có tham chiếu nào. Bạn có thể đạt được hiệu ứng mong muốn theo một số cách.

1. Bằng cách trả lại kết quả:

   >>> foo()
   Traceback (most recent call last):
     ...
   UnboundLocalError: local variable 'x' referenced before assignment
   

   1

   Đây hầu như luôn luôn là giải pháp rõ ràng nhất.

2. Bằng cách sử dụng các biến toàn cầu. Đây không phải là chủ đề an toàn, và không được khuyến khích.

3. Bằng cách chuyển một đối tượng có thể thay đổi (thay đổi tại chỗ):

   >>> foo()
   Traceback (most recent call last):
     ...
   UnboundLocalError: local variable 'x' referenced before assignment
   

   2

4. Bằng cách truyền trong một từ điển bị đột biến:

   >>> foo()
   Traceback (most recent call last):
     ...
   UnboundLocalError: local variable 'x' referenced before assignment
   

   3

5. Hoặc gói các giá trị trong một thể hiện lớp:

   >>> foo()
   Traceback (most recent call last):
     ...
   UnboundLocalError: local variable 'x' referenced before assignment
   

   4

   Có hầu như không bao giờ là một lý do chính đáng để có được điều này phức tạp.

Lựa chọn tốt nhất của bạn là trả về một tuple chứa nhiều kết quả.

Làm thế nào để bạn thực hiện một chức năng bậc cao hơn trong Python? ¶

Bạn có hai lựa chọn: Bạn có thể sử dụng phạm vi lồng nhau hoặc bạn có thể sử dụng các đối tượng có thể gọi được. Ví dụ: giả sử bạn muốn xác định

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Hoặc sử dụng một đối tượng có thể gọi được:

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Trong cả hai trường hợp,

cho một đối tượng có thể gọi được trong đó

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Cách tiếp cận đối tượng có thể gọi có bất lợi rằng nó chậm hơn một chút và dẫn đến mã dài hơn một chút. Tuy nhiên, lưu ý rằng một bộ sưu tập các thiết bị gọi có thể chia sẻ chữ ký của chúng thông qua kế thừa:

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Đối tượng có thể gói gọn trạng thái cho một số phương pháp:

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Ở đây

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Làm cách nào để sao chép một đối tượng trong Python? ¶

Nói chung, hãy thử

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Một số đối tượng có thể được sao chép dễ dàng hơn. Từ điển có phương pháp

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Trình tự có thể được sao chép bằng cách cắt:

Làm thế nào tôi có thể tìm thấy các phương thức hoặc thuộc tính của một đối tượng? ¶

Đối với một thể hiện

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Làm thế nào mã của tôi có thể khám phá tên của một đối tượng? ¶

Nói chung, nó có thể, bởi vì các đối tượng không thực sự có tên. Về cơ bản, gán luôn liên kết một tên với một giá trị; Điều tương tự cũng đúng với các câu lệnh

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Có thể cho rằng lớp có một tên: mặc dù nó bị ràng buộc với hai tên và được gọi qua tên

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Nói chung, không cần thiết cho mã của bạn để biết tên của các giá trị cụ thể. Trừ khi bạn cố tình viết các chương trình nội tâm, đây thường là một dấu hiệu cho thấy sự thay đổi của phương pháp có thể có lợi.

Trong comp.lang.python, Fredrik Lundh đã từng đưa ra một sự tương tự tuyệt vời trong câu trả lời cho câu hỏi này:

Giống như cách bạn nhận được tên của con mèo mà bạn tìm thấy trên hiên nhà của bạn: con mèo (đối tượng) không thể cho bạn biết tên của nó và nó không thực sự quan tâm - vì vậy cách duy nhất để tìm hiểu những gì nó được gọi là hỏi Tất cả hàng xóm của bạn (không gian tên) nếu đó là con mèo của họ (đối tượng)

Càng. Và don rất ngạc nhiên nếu bạn sẽ thấy rằng nó được biết đến bởi nhiều cái tên, hoặc không có tên nào cả!

Những gì mà lên với sự ưu tiên của nhà điều hành dấu phẩy? ¶

Dấu phẩy không phải là một nhà điều hành trong Python. Xem xét phiên này:

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

Vì dấu phẩy không phải là toán tử, mà là một dấu phân cách giữa các biểu thức, các biểu thức ở trên được đánh giá như thể bạn đã nhập:

not:

Điều tương tự cũng đúng với các toán tử gán khác nhau (

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

Có một tương đương với C Cùi?: Nhà điều hành Ternary?

Có, có. Cú pháp như sau:

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

Trước khi cú pháp này được giới thiệu trong Python 2.5, một thành ngữ phổ biến là sử dụng các toán tử logic:

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

Tuy nhiên, thành ngữ này không an toàn, vì nó có thể cho kết quả sai khi on_true có giá trị boolean sai. Do đó, tốt hơn là sử dụng mẫu

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Có thể viết một lớp lót bị che giấu trong Python không? ¶

Đúng. Thông thường điều này được thực hiện bằng cách làm tổ

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

Don Hãy thử điều này ở nhà, trẻ em!

Slash (/) trong danh sách tham số của một hàm có nghĩa là gì? ¶

Một dấu gạch chéo trong danh sách đối số của một hàm biểu thị rằng các tham số trước đó chỉ là vị trí. Các tham số chỉ có vị trí là các tham số không có tên có thể sử dụng bên ngoài. Khi gọi một hàm chấp nhận các tham số chỉ có vị trí, các đối số được ánh xạ tới các tham số chỉ dựa trên vị trí của chúng. Ví dụ,

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

Việc chém ở cuối danh sách tham số có nghĩa là cả hai tham số chỉ dành cho vị trí. Do đó, việc gọi

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

Làm cách nào để chỉ định số nguyên thập lục phân và bát phân? ¶

Để chỉ định một chữ số bát phân, đi trước giá trị bát phân với số 0, và sau đó là một chữ số thấp hơn hoặc dưới đây. Ví dụ: để đặt biến có thể thay đổi thành giá trị octal 10 10 (8 trong thập phân), loại:

Hexadecimal cũng dễ dàng như vậy. Đơn giản chỉ cần đi trước số thập lục phân với số 0, và sau đó là một bản nhạc thấp hơn hoặc dưới đây. Các chữ số thập lục phân có thể được chỉ định ở cấp dưới hoặc chữ hoa. Ví dụ, trong phiên dịch Python:

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

Tại sao -22 // 10 trả về -3? ¶

Nó chủ yếu được điều khiển bởi mong muốn rằng

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

Sau đó, phân chia số nguyên phải trả lại sàn. C cũng yêu cầu danh tính đó phải giữ, và sau đó các trình biên dịch cắt ngắn

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Có một vài trường hợp sử dụng thực tế cho

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Làm cách nào để nhận thuộc tính int theo nghĩa đen thay vì cú pháp? ¶

Cố gắng tra cứu một thuộc tính theo nghĩa đen

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

Giải pháp là tách chữ theo nghĩa đen với khoảng thời gian bằng một không gian hoặc dấu ngoặc đơn.

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

Làm cách nào để chuyển đổi một chuỗi thành một số? ¶

Đối với các số nguyên, hãy sử dụng hàm tạo loại

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Theo mặc định, chúng diễn giải số là thập phân, do đó

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Không sử dụng chức năng tích hợp

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Làm cách nào để chuyển đổi một số thành một chuỗi? ¶

Để chuyển đổi, ví dụ: số

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Làm cách nào để sửa đổi một chuỗi tại chỗ? ¶

Bạn có thể, vì dây là bất biến. Trong hầu hết các tình huống, bạn chỉ nên xây dựng một chuỗi mới từ các phần khác nhau mà bạn muốn lắp ráp. Tuy nhiên, nếu bạn cần một đối tượng có khả năng sửa đổi dữ liệu Unicode tại chỗ, hãy thử sử dụng đối tượng

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> def foo():
...    x = 10
...    def bar():
...        nonlocal x
...        print(x)
...        x += 1
...    bar()
...    print(x)
...
>>> foo()
10
11

Làm cách nào để sử dụng chuỗi để gọi các chức năng/phương thức? ¶

Có nhiều kỹ thuật khác nhau.

• Tốt nhất là sử dụng một từ điển ánh xạ các chuỗi theo các chức năng. Ưu điểm chính của kỹ thuật này là các chuỗi không cần phải khớp với tên của các chức năng. Đây cũng là kỹ thuật chính được sử dụng để mô phỏng cấu trúc trường hợp:

  >>> def foo():
  ...    x = 10
  ...    def bar():
  ...        nonlocal x
  ...        print(x)
  ...        x += 1
  ...    bar()
  ...    print(x)
  ...
  >>> foo()
  10
  11
  

  1

• Sử dụng chức năng tích hợp

  >>> foo()
  Traceback (most recent call last):
    ...
  UnboundLocalError: local variable 'x' referenced before assignment
  

  71:

  >>> def foo():
  ...    x = 10
  ...    def bar():
  ...        nonlocal x
  ...        print(x)
  ...        x += 1
  ...    bar()
  ...    print(x)
  ...
  >>> foo()
  10
  11
  

  2

  Lưu ý rằng

  >>> foo()
  Traceback (most recent call last):
    ...
  UnboundLocalError: local variable 'x' referenced before assignment
  

  71 hoạt động trên bất kỳ đối tượng nào, bao gồm các lớp, phiên bản lớp, mô -đun, v.v.

  Điều này được sử dụng ở một số nơi trong thư viện tiêu chuẩn, như thế này:

  >>> def foo():
  ...    x = 10
  ...    def bar():
  ...        nonlocal x
  ...        print(x)
  ...        x += 1
  ...    bar()
  ...    print(x)
  ...
  >>> foo()
  10
  11
  

  3

• Sử dụng

  >>> foo()
  Traceback (most recent call last):
    ...
  UnboundLocalError: local variable 'x' referenced before assignment
  

  73 để giải quyết tên chức năng:

  >>> def foo():
  ...    x = 10
  ...    def bar():
  ...        nonlocal x
  ...        print(x)
  ...        x += 1
  ...    bar()
  ...    print(x)
  ...
  >>> foo()
  10
  11
  

  4

Có tương đương với Perl xông Chomp () để loại bỏ các dòng mới ra khỏi dây không? ¶

Bạn có thể sử dụng

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> def foo():
...    x = 10
...    def bar():
...        nonlocal x
...        print(x)
...        x += 1
...    bar()
...    print(x)
...
>>> foo()
10
11

Vì điều này thường chỉ mong muốn khi đọc văn bản một dòng tại một thời điểm, sử dụng

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Có tương đương với scanf () hoặc sscanf () không? ¶

Không như vậy.

Đối với phân tích cú pháp đầu vào đơn giản, cách tiếp cận dễ nhất thường là chia dòng thành các từ được phân phối bằng khoảng trắng bằng phương pháp

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Đối với phân tích cú pháp đầu vào phức tạp hơn, các biểu thức chính quy mạnh hơn C Lau

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Unicodedecodeerror, hoặc unicodeEncodeError có nghĩa là gì? ¶

Xem Unicode Howto.Unicode HOWTO.

Chương trình của tôi quá chậm. Làm cách nào để tăng tốc nó? ¶

Nói chung, đó là một điều khó khăn. Đầu tiên, đây là danh sách những điều cần nhớ trước khi lặn thêm:

• Đặc điểm hiệu suất khác nhau giữa việc triển khai Python. Câu hỏi thường gặp này tập trung vào Cpython.CPython.

• Hành vi có thể thay đổi trên các hệ điều hành, đặc biệt là khi nói về I/O hoặc đa luồng.

• Bạn nên luôn luôn tìm thấy các điểm nóng trong chương trình của mình trước khi cố gắng tối ưu hóa bất kỳ mã nào (xem mô -đun

  >>> foo()
  Traceback (most recent call last):
    ...
  UnboundLocalError: local variable 'x' referenced before assignment
  

  83).

• Viết các tập lệnh điểm chuẩn sẽ cho phép bạn lặp lại nhanh chóng khi tìm kiếm các cải tiến (xem mô -đun

  >>> foo()
  Traceback (most recent call last):
    ...
  UnboundLocalError: local variable 'x' referenced before assignment
  

  84).

• Rất khuyến khích có phạm vi bảo hiểm mã tốt (thông qua kiểm tra đơn vị hoặc bất kỳ kỹ thuật nào khác) trước khi có khả năng giới thiệu các hồi quy ẩn trong các tối ưu hóa tinh vi.

Điều đó đang được nói, có nhiều thủ thuật để tăng tốc mã Python. Dưới đây là một số nguyên tắc chung đi một chặng đường dài để đạt được mức hiệu suất chấp nhận được:

• Làm cho các thuật toán của bạn nhanh hơn (hoặc thay đổi thành những thuật toán nhanh hơn) có thể mang lại lợi ích lớn hơn nhiều so với việc cố gắng thực hiện các thủ thuật tối ưu hóa vi mô trên tất cả các mã của bạn.

• Sử dụng các cấu trúc dữ liệu phù hợp. Tài liệu nghiên cứu cho các loại tích hợp và mô-đun

  >>> foo()
  Traceback (most recent call last):
    ...
  UnboundLocalError: local variable 'x' referenced before assignment
  

  85.Built-in Types and the

  >>> foo()
  Traceback (most recent call last):
    ...
  UnboundLocalError: local variable 'x' referenced before assignment
  

  85 module.

• Khi thư viện tiêu chuẩn cung cấp một nguyên thủy để làm một cái gì đó, có khả năng (mặc dù không được đảm bảo) nhanh hơn bất kỳ sự thay thế nào bạn có thể nghĩ ra. Điều này có thể đúng với các nguyên thủy được viết bằng C, chẳng hạn như tích hợp và một số loại mở rộng. Ví dụ: đảm bảo sử dụng phương thức tích hợp

  >>> foo()
  Traceback (most recent call last):
    ...
  UnboundLocalError: local variable 'x' referenced before assignment
  

  86 hoặc hàm

  >>> foo()
  Traceback (most recent call last):
    ...
  UnboundLocalError: local variable 'x' referenced before assignment
  

  87 liên quan để sắp xếp (và xem cách sắp xếp cách để biết các ví dụ về cách sử dụng nâng cao vừa phải).Sorting HOW TO for examples of moderately advanced usage).

• Trừu tượng có xu hướng tạo ra sự bất công và buộc thông dịch viên làm việc nhiều hơn. Nếu mức độ liên tục vượt xa số lượng công việc hữu ích được thực hiện, chương trình của bạn sẽ chậm hơn. Bạn nên tránh sự trừu tượng quá mức, đặc biệt là dưới dạng các hàm hoặc phương pháp nhỏ (cũng thường gây bất lợi cho khả năng đọc).

Nếu bạn đã đạt đến giới hạn của những gì Python thuần túy có thể cho phép, có những công cụ để đưa bạn đi xa hơn. Ví dụ, Cython có thể biên dịch một phiên bản Python được sửa đổi một chút thành tiện ích mở rộng C và có thể được sử dụng trên nhiều nền tảng khác nhau. Cython có thể tận dụng việc biên dịch (và chú thích loại tùy chọn) để làm cho mã của bạn nhanh hơn đáng kể so với khi được giải thích. Nếu bạn tự tin vào các kỹ năng lập trình C của mình, bạn cũng có thể tự viết mô -đun mở rộng C.write a C extension module yourself.

Cách hiệu quả nhất để kết hợp nhiều chuỗi với nhau là gì? ¶

Các đối tượng

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Để tích lũy nhiều đối tượng

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> def foo():
...    x = 10
...    def bar():
...        nonlocal x
...        print(x)
...        x += 1
...    bar()
...    print(x)
...
>>> foo()
10
11

(Một thành ngữ hiệu quả hợp lý khác là sử dụng

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Để tích lũy nhiều đối tượng

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> def foo():
...    x = 10
...    def bar():
...        nonlocal x
...        print(x)
...        x += 1
...    bar()
...    print(x)
...
>>> foo()
10
11

Làm cách nào để chuyển đổi giữa các bộ đếm và danh sách? ¶

Loại cấu trúc loại

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Ví dụ,

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

Loại xây dựng

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

Những gì một chỉ số tiêu cực? ¶

Trình tự Python được lập chỉ mục với số dương và số âm. Đối với các số dương 0 là chỉ số 1 đầu tiên là chỉ số thứ hai và vv. Đối với các chỉ số âm -1 là chỉ số cuối cùng và -2 là chỉ mục áp chót (bên cạnh cuối cùng) và vv. Hãy nghĩ về

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

Sử dụng các chỉ số tiêu cực có thể rất thuận tiện. Ví dụ:

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

Làm thế nào để tôi lặp lại theo một chuỗi theo thứ tự ngược lại? ¶

Sử dụng chức năng tích hợp

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> def foo():
...    x = 10
...    def bar():
...        nonlocal x
...        print(x)
...        x += 1
...    bar()
...    print(x)
...
>>> foo()
10
11

Điều này giành được chạm vào chuỗi ban đầu của bạn, nhưng xây dựng một bản sao mới với thứ tự đảo ngược để lặp lại.

Làm thế nào để bạn xóa các bản sao khỏi danh sách? ¶

Xem Sách nấu ăn Python để thảo luận dài về nhiều cách để làm điều này:

Nếu bạn không có tâm trí sắp xếp lại danh sách, hãy sắp xếp nó và sau đó quét từ cuối danh sách, xóa các bản sao khi bạn đi:

>>> def foo():
...    x = 10
...    def bar():
...        nonlocal x
...        print(x)
...        x += 1
...    bar()
...    print(x)
...
>>> foo()
10
11

Nếu tất cả các yếu tố của danh sách có thể được sử dụng làm khóa tập hợp (tức là tất cả chúng đều có thể băm) thì điều này thường nhanh hơnhashable) this is often faster

>>> squares = []
>>> for x in range(5):
...     squares.append(lambda: x**2)

Điều này chuyển đổi danh sách thành một tập hợp, do đó loại bỏ các bản sao, và sau đó quay lại danh sách.

Làm thế nào để bạn xóa nhiều mục khỏi danh sách

Như với việc loại bỏ các bản sao, việc lặp lại một cách rõ ràng với một điều kiện xóa là một khả năng. Tuy nhiên, việc sử dụng thay thế lát cắt bằng một lần lặp về phía trước hoặc rõ ràng sẽ dễ dàng và nhanh hơn. Đây là ba biến thể .:

>>> squares = []
>>> for x in range(5):
...     squares.append(lambda: x**2)

Danh sách hiểu có thể nhanh nhất.

Làm thế nào để bạn tạo ra một mảng trong Python? ¶

Sử dụng danh sách:

>>> squares = []
>>> for x in range(5):
...     squares.append(lambda: x**2)

Danh sách tương đương với các mảng C hoặc Pascal trong độ phức tạp thời gian của chúng; Sự khác biệt chính là danh sách Python có thể chứa các đối tượng thuộc nhiều loại khác nhau.

Mô -đun

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Để có được danh sách liên kết theo kiểu LISP, bạn có thể mô phỏng các ô khuyết điểm bằng cách sử dụng các bộ dữ liệu:

>>> squares = []
>>> for x in range(5):
...     squares.append(lambda: x**2)

Nếu khả năng đột biến là mong muốn, bạn có thể sử dụng danh sách thay vì bộ dữ liệu. Ở đây, tương tự của một chiếc xe LISP là

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

Làm cách nào để tạo một danh sách đa chiều? ¶

Bạn có thể đã cố gắng tạo ra một mảng đa chiều như thế này:

Điều này có vẻ chính xác nếu bạn in nó:

>>> squares = []
>>> for x in range(5):
...     squares.append(lambda: x**2)

Nhưng khi bạn gán một giá trị, nó sẽ xuất hiện ở nhiều nơi:

>>> squares = []
>>> for x in range(5):
...     squares.append(lambda: x**2)

Lý do là sao chép một danh sách với

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

Cách tiếp cận được đề xuất là tạo một danh sách độ dài mong muốn trước và sau đó điền vào mỗi phần tử với một danh sách mới được tạo:

>>> squares = []
>>> for x in range(5):
...     squares.append(lambda: x**2)

Điều này tạo ra một danh sách chứa 3 danh sách khác nhau về độ dài hai. Bạn cũng có thể sử dụng danh sách hiểu biết:

>>> squares = []
>>> for x in range(5):
...     squares.append(lambda: x**2)

Hoặc, bạn có thể sử dụng một tiện ích mở rộng cung cấp kiểu dữ liệu ma trận; Numpy là người nổi tiếng nhất.

Làm cách nào để áp dụng một phương thức hoặc hàm cho một chuỗi các đối tượng? ¶

Để gọi một phương thức hoặc chức năng và tích lũy các giá trị trả về là một danh sách, khả năng hiểu danh sách là một giải pháp thanh lịch:list comprehension is an elegant solution:

>>> squares = []
>>> for x in range(5):
...     squares.append(lambda: x**2)

Để chỉ chạy phương thức hoặc hàm mà không lưu các giá trị trả về, một vòng lặp

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> squares = []
>>> for x in range(5):
...     squares.append(lambda: x**2)

Tại sao a_tuple [i] += [‘item,] tăng một ngoại lệ khi bổ sung hoạt động? ¶

Điều này là do sự kết hợp của thực tế là các toán tử gán tăng cường là các toán tử gán và sự khác biệt giữa các đối tượng có thể thay đổi và bất biến trong Python.

Cuộc thảo luận này áp dụng nói chung khi các nhà khai thác gán tăng cường được áp dụng cho các yếu tố của một tuple chỉ ra các đối tượng có thể thay đổi, nhưng chúng tôi sẽ sử dụng

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

Nếu bạn đã viết:

>>> squares[2]()
16
>>> squares[4]()
16

Lý do cho ngoại lệ phải rõ ràng ngay lập tức:

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

Theo bìa, những gì mà câu lệnh gán tăng cường này đang làm là khoảng này:

>>> squares[2]()
16
>>> squares[4]()
16

Đây là phần gán của hoạt động tạo ra lỗi, vì một tuple là bất biến.

Khi bạn viết một cái gì đó như:

>>> squares[2]()
16
>>> squares[4]()
16

Ngoại lệ là đáng ngạc nhiên hơn một chút, và thậm chí còn ngạc nhiên hơn là mặc dù có một lỗi, nhưng phần phụ đã hoạt động:

>>> squares[2]()
16
>>> squares[4]()
16

Để xem lý do tại sao điều này xảy ra, bạn cần biết rằng (a) nếu một đối tượng thực hiện phương thức ma thuật

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> squares[2]()
16
>>> squares[4]()
16

Điều này tương đương với:

>>> squares[2]()
16
>>> squares[4]()
16

Đối tượng được chỉ ra bởi a_list đã bị đột biến và con trỏ đến đối tượng bị đột biến được gán lại cho

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

Do đó, trong ví dụ Tuple của chúng tôi, những gì đang xảy ra tương đương với:

>>> squares[2]()
16
>>> squares[4]()
16

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

Tôi muốn thực hiện một loại phức tạp: Bạn có thể thực hiện một phép biến đổi Schwartzian trong Python không?

Kỹ thuật này, được quy cho Randal Schwartz của cộng đồng Perl, sắp xếp các yếu tố của một danh sách theo một số liệu ánh xạ từng yếu tố theo giá trị sắp xếp của nó. Trong Python, hãy sử dụng đối số

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> squares[2]()
16
>>> squares[4]()
16

Làm cách nào để sắp xếp một danh sách theo các giá trị từ danh sách khác? ¶

Hợp nhất chúng thành một trình lặp của các bộ dữ liệu, sắp xếp danh sách kết quả, và sau đó chọn ra phần tử bạn muốn.

>>> squares[2]()
16
>>> squares[4]()
16

Lớp học là gì? ¶

Một lớp là loại đối tượng cụ thể được tạo bằng cách thực thi một câu lệnh lớp. Các đối tượng lớp được sử dụng làm mẫu để tạo các đối tượng thể hiện, thể hiện cả dữ liệu (thuộc tính) và mã (phương thức) cụ thể cho kiểu dữ liệu.

Một lớp có thể dựa trên một hoặc nhiều lớp khác, được gọi là lớp cơ sở của nó. Sau đó, nó kế thừa các thuộc tính và phương thức của các lớp cơ sở của nó. Điều này cho phép một mô hình đối tượng được tinh chỉnh liên tiếp bởi sự kế thừa. Bạn có thể có một lớp

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

Phương pháp là gì? ¶

Một phương thức là một hàm trên một số đối tượng

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> squares[2]()
16
>>> squares[4]()
16

Bản thân là gì? ¶

Bản thân chỉ là một tên thông thường cho đối số đầu tiên của một phương thức. Một phương thức được định nghĩa là

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

Xem thêm tại sao phải ’tự được sử dụng rõ ràng trong các định nghĩa và cuộc gọi phương thức ?.Why must ‘self’ be used explicitly in method definitions and calls?.

Làm cách nào để kiểm tra xem một đối tượng là một thể hiện của một lớp nhất định hoặc của một lớp con của nó? ¶

Sử dụng chức năng tích hợp

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

Lưu ý rằng

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 8
>>> squares[2]()
64

>>> x = 8
>>> squares[2]()
64

Lưu ý rằng hầu hết các chương trình không sử dụng

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 8
>>> squares[2]()
64

Một cách tiếp cận tốt hơn là xác định phương thức

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 8
>>> squares[2]()
64

Đoàn là gì? ¶

Phái đoàn là một kỹ thuật định hướng đối tượng (còn được gọi là mẫu thiết kế). Hãy nói rằng bạn có một đối tượng

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

Các lập trình viên Python có thể dễ dàng thực hiện phái đoàn. Ví dụ: lớp sau thực hiện một lớp hoạt động giống như một tệp nhưng chuyển đổi tất cả dữ liệu bằng văn bản thành chữ hoa:

>>> x = 8
>>> squares[2]()
64

Ở đây, lớp

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

Lưu ý rằng đối với các trường hợp chung hơn, phái đoàn có thể trở nên khó khăn hơn. Khi các thuộc tính phải được đặt cũng như truy xuất, lớp cũng phải xác định phương thức

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 8
>>> squares[2]()
64

Hầu hết các triển khai

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

Làm cách nào để gọi một phương thức được xác định trong một lớp cơ sở từ một lớp dẫn xuất mở rộng nó? ¶

Sử dụng chức năng

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 8
>>> squares[2]()
64

Trong ví dụ,

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

Làm cách nào để sắp xếp mã của mình để giúp thay đổi lớp cơ sở dễ dàng hơn? ¶

Bạn có thể gán lớp cơ sở cho một bí danh và xuất phát từ bí danh. Sau đó, tất cả những gì bạn phải thay đổi là giá trị được gán cho bí danh. Ngẫu nhiên, thủ thuật này cũng rất tiện dụng nếu bạn muốn quyết định một cách linh hoạt (ví dụ: tùy thuộc vào tính khả dụng của tài nguyên) sẽ sử dụng lớp cơ sở nào. Thí dụ:

>>> x = 8
>>> squares[2]()
64

Làm cách nào để tạo dữ liệu lớp tĩnh và phương thức lớp tĩnh? ¶

Cả dữ liệu tĩnh và phương pháp tĩnh (theo nghĩa C ++ hoặc Java) đều được hỗ trợ trong Python.

Đối với dữ liệu tĩnh, chỉ cần xác định một thuộc tính lớp. Để gán một giá trị mới cho thuộc tính, bạn phải sử dụng rõ ràng tên lớp trong bài tập:

>>> x = 8
>>> squares[2]()
64

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

THẬN TRỌNG: Trong một phương thức của C, một nhiệm vụ như

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

Phương pháp tĩnh là có thể:

>>> x = 8
>>> squares[2]()
64

Tuy nhiên, một cách đơn giản hơn nhiều để có được hiệu ứng của phương pháp tĩnh là thông qua hàm cấp độ mô-đun đơn giản:

>>> squares = []
>>> for x in range(5):
...     squares.append(lambda n=x: n**2)

Nếu mã của bạn được cấu trúc để xác định một lớp (hoặc phân cấp lớp liên quan chặt chẽ) cho mỗi mô -đun, điều này sẽ cung cấp các đóng gói mong muốn.

Làm thế nào tôi có thể quá tải các hàm tạo (hoặc phương pháp) trong Python? ¶

Câu trả lời này thực sự áp dụng cho tất cả các phương pháp, nhưng câu hỏi thường xuất hiện đầu tiên trong bối cảnh các nhà xây dựng.

Trong c ++ bạn viết

>>> squares = []
>>> for x in range(5):
...     squares.append(lambda n=x: n**2)

Trong Python, bạn phải viết một hàm tạo duy nhất để bắt tất cả các trường hợp bằng cách sử dụng các đối số mặc định. Ví dụ:

>>> squares = []
>>> for x in range(5):
...     squares.append(lambda n=x: n**2)

Điều này không hoàn toàn tương đương, nhưng đủ gần trong thực tế.

Bạn cũng có thể thử một danh sách đối số có độ dài thay đổi, ví dụ:

>>> squares = []
>>> for x in range(5):
...     squares.append(lambda n=x: n**2)

Cách tiếp cận tương tự hoạt động cho tất cả các định nghĩa phương pháp.

Tôi cố gắng sử dụng __spam và tôi gặp lỗi về _someclassname__spam.¶

Các tên biến với các dấu gạch dưới hàng đầu là có thể cung cấp một cách đơn giản nhưng hiệu quả để xác định các biến riêng của lớp. Bất kỳ định danh nào của mẫu

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

Điều này không đảm bảo quyền riêng tư: Người dùng bên ngoài vẫn có thể cố tình truy cập vào thuộc tính _ classname__spam và các giá trị riêng tư được hiển thị trong đối tượng

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10