Python đặt biến toàn cục trong câu lệnh if

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

Có thể ngạc nhiên khi nhận được mã

>>> 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ả là 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 gán một biến trong một phạm vi, biến đó sẽ trở thành cục bộ của phạm vi đó và che khuất 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ó là toàn cầu

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

Khai báo rõ ràng này là cần thiết để 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à đối tượng), bạn thực sự đang sửa đổi giá trị của biến trong phạm vi bên ngoài

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

Bạn có thể làm đ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

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

Các quy tắc cho biến cục bộ và biến toàn cục 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ục. Nếu một biến được gán một giá trị ở bất kỳ đâu trong phần thân của hàm, thì biến đó được coi là biến cục bộ trừ khi được khai báo rõ ràng là biến toàn cục

Mặc dù hơi ngạc nhiên lúc đầu, nhưng một khoảnh khắc cân nhắc sẽ giải thích điều này. Một mặt, yêu cầu

>>> 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

Tại sao lambdas được xác định trong một vòng lặp với các giá trị khác nhau đều trả về cùng một kết quả?¶

Giả sử bạn sử dụng vòng lặp for để định nghĩa một số lambda khác nhau (hoặc thậm chí là các hàm đơn giản), e. g

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

Điều này cung cấp cho bạn một danh sách chứa 5 lambda tính toá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

>>> 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

Điều này xảy ra vì

>>> 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 bar():
..     print(x)
...
>>> bar()
10

Để tránh điều này, bạn cần lưu các giá trị trong các biến cục bộ vào lambdas để chúng không dựa vào giá trị của biến toàn cầu

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

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

Ở đâ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

Lưu ý rằng hành vi này không đặc biệt đối với lambdas, nhưng cũng áp dụng cho các chức năng thông thường

Làm cách nào để chia sẻ các biến toàn cục giữa các mô-đun?¶

Cách thông thường để chia sẻ thông tin giữa các mô-đun trong một chương trình là tạo một mô-đun đặc biệt (thường được gọi là config hoặc cfg). Chỉ cần nhập mô-đun cấu hình trong tất cả các mô-đun của ứng dụng của bạn; . Bởi vì chỉ có một phiên bản của mỗi mô-đun, mọi thay đổi được thực hiện đối với đối tượng mô-đun sẽ được phản ánh ở mọi nơi. Ví dụ

cấu hình. py

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

chế độ. py

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

chủ yếu. py

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

Lưu ý rằng việc sử dụng một mô-đun cũng là cơ sở để triển khai mẫu thiết kế đơn lẻ, vì lý do tương tự

"Các phương pháp hay nhất" để sử dụng tính năng nhập trong một mô-đun là gì?¶

Nói chung, không sử dụng

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

Nhập các mô-đun ở đầu tệp. Làm như vậy sẽ làm rõ những mô-đun khác mà mã của bạn yêu cầu và tránh các câu hỏi liệu tên mô-đun có nằm trong phạm vi hay không. Sử dụng một lần nhập trên mỗi dòng giúp dễ dàng thêm và xóa các lần nhập mô-đun, nhưng sử dụng nhiều lần nhập trên mỗi dòng sẽ sử dụng ít không gian màn hình hơn

Đó là cách thực hành tốt nếu bạn nhập các mô-đun theo thứ tự sau

1. mô-đun thư viện tiêu chuẩn – e. g.

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

   48,

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

   49,

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

   50,

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

   51

2. mô-đun thư viện của bên thứ ba (bất kỳ thứ gì được cài đặt trong thư mục gói trang web của Python) – e. g.

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

   52,

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

   53,

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

   54

3. các mô-đun được phát triển tại địa phương

Đôi khi cần phải di chuyển quá trình nhập vào một hàm hoặc lớp để tránh các sự cố với quá trình nhập tuần hoàn. Gordon McMillan nói

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.

Trong trường hợp này, nếu mô-đun thứ hai chỉ được sử dụng trong một chức năng, thì quá trình nhập có thể dễ dàng được chuyển sang chức năng đó. Vào thời điểm quá trình nhập được gọi, mô-đun đầu tiên sẽ khởi tạo xong và mô-đun thứ hai có thể thực hiện quá trình nhập của nó

Cũng có thể cần phải di chuyển các mục nhập ra khỏi cấp mã cao nhất nếu một số mô-đun dành riêng cho nền tảng. Trong trường hợp đó, thậm chí có thể không nhập được tất cả các mô-đun ở đầu tệp. Trong trường hợp này, nhập đúng mô-đun trong mã dành riêng cho nền tảng tương ứng là một lựa chọn tốt

Chỉ di chuyển quá trình nhập vào phạm vi cục bộ, chẳng hạn như bên trong định nghĩa hàm, nếu điều đó là cần thiết để giải quyết vấn đề chẳng hạn như tránh nhập vòng tròn hoặc đang cố gắng giảm thời gian khởi tạo mô-đun. Kỹ thuật này đặc biệt hữu ích nếu nhiều lần nhập là không cần thiết tùy thuộc vào cách chương trình thực thi. Bạn cũng có thể muốn chuyển các mục nhập vào một chức năng nếu các mô-đun chỉ được sử dụng trong chức năng đó. Lưu ý rằng việc tải một mô-đun lần đầu tiên có thể tốn kém do khởi tạo mô-đun một lần, nhưng tải một mô-đun nhiều lần hầu như miễn phí, chỉ tốn một vài lần tra cứu từ điển. Ngay cả khi tên mô-đun vượt ra ngoài phạm vi, thì mô-đun đó vẫn có sẵn trong

>>> 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 mới vào nghề. Hãy 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 mong đợi rằng một lệnh gọi hàm sẽ tạo 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. Giá trị mặc định được tạo chính xác một lần, khi chức năng được xác định. Nếu đối tượng đó bị thay đổi, giống như từ điển trong ví dụ này, các lần gọi hàm tiếp theo sẽ tham chiếu đế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, nên thực hành 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

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

nhưng

>>> 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 nhiều thời gian để tính toán, một kỹ thuật phổ biến là lưu vào bộ nhớ đệm các tham số và giá trị kết quả của mỗi lệnh gọi hàm, đồng thời trả về giá trị đã lưu trong bộ nhớ cache nếu giá trị tương tự được yêu cầu lại. Điều này được gọi là "ghi nhớ", 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ục chứa từ điển thay vì giá trị mặc định;

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 hàm khác?¶

Thu thập các đối số bằng cách sử dụng các chỉ đị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 đối số và tham số là gì?¶

Tham số được xác định bằng tên xuất hiện trong định nghĩa hàm, trong khi đối số là giá trị . 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 hàm.

>>> 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

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

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ư

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

bạn có thể thắc mắc tại sao việc thêm một phần 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 tham chiếu đến các đối tượng. Thực hiện

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

   74 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
   

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

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

   19 đề 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
   

   19 và

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

   72 đều đề cập đến nó

2. Danh sách có thể thay đổi , nghĩa là bạn có thể thay đổi nội dung của chúng.

Sau khi 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

Thay vào đó, nếu chúng ta 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

ta thấy 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

Một số thao tác (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

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

>>> 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 loại 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. toán tử gán tăng cường. 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

>>> 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 cách khác

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

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

  11,

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

  12,

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

  13, v.v. ), chúng ta có thể sử dụng một số thao tác cụ thể để thay đổi nó và tất cả các biến tham chiếu đế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
  

  14,

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

  15,

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

  16, v.v. ), tất cả các biến tham chiếu đến nó sẽ luôn nhì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 hai biến có tham chiếu đế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

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

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

Hãy nhớ rằng các đối số được truyền bằng phép gán trong Python. Vì phép gán chỉ tạo các tham chiếu đến các đối tượng, nên không có bí danh giữa tên đối số trong trình gọi và callee, và do đó không có tham chiếu theo từng cuộc gọi. Bạn có thể đạt được hiệu quả mong muốn theo một số cách

1. Bằng cách trả về một bộ kết quả

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

   3

   Đây hầu như 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ục. Điều này không an toàn cho luồng và không được khuyến nghị

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

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

   4

4. Bằng cách chuyển vào một từ điển bị biến đổi

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

   5

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

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

   6

   Hầu như không bao giờ có một lý do chính đáng để làm cho điều này trở nên phức tạp

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

Làm thế nào để bạn tạo một hàm bậc cao hơn trong Python?¶

Bạn có hai sự 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,

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

đưa ra 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 có nhược điểm là 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 tập hợp các callable có thể chia sẻ chữ ký của chúng thông qua kế thừa

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

Đối tượng có thể đóng gói trạng thái cho một số phương thức

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

Ở đây ________ 623, ________ 624 và ________ 625 đóng vai trò như các hàm chia sẻ cùng một biến đếm

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 thức

>>> 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

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

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

Làm cách 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 cách nào mã của tôi có thể khám phá tên của một đối tượng?¶

Nói chung là không thể, bởi vì các đối tượng không thực sự có tên. Về cơ bản, phép gán luôn gắn tên với giá trị; . Hãy xem xét đoạn mã sau

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

Có thể cho rằng lớp có một tên. mặc dù nó được liên kết với hai tên và được gọi thông 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, mã của bạn không cần thiết phải “biết tên” của các giá trị cụ thể. Trừ khi bạn đang cố tình viết các chương trình hướng nội, đây thường là dấu hiệu cho thấy việc thay đổi cách tiếp cận có thể có lợi

trong comp. lang thang. trăn, Fredrik Lundh đã từng đưa ra một phép loại suy tuyệt vời để trả lời cho câu hỏi này

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

…. và đừng ngạc nhiên nếu bạn thấy rằng nó được biết đến với nhiều tên hoặc không có tên nào cả

Điều gì xảy ra với quyền ưu tiên của toán tử dấu phẩy?¶

Dấu phẩy không phải là toán tử trong Python. Hãy 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à dấu phân cách giữa các biểu thức, phần trên được đánh giá như thể bạn đã nhập

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

không phải

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

Điều này 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

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

Có tương đương với C's không?. ” toán tử bậc ba?¶

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 hết là sử dụng biểu mẫu

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

Có thể viết các dòng một lớp bị xáo trộn bằng Python không?¶

Đúng. Thông thường, điều này được thực hiện bằng cách lồ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

Đừng thử điều này ở nhà, trẻ em

Dấu gạch chéo (/) trong danh sách tham số của hàm có nghĩa là gì?¶

Dấu gạch chéo trong danh sách đối số của hàm biểu thị rằng các tham số trước nó chỉ là vị trí. Tham số chỉ vị trí là những tham số không có tên có thể sử dụng bên ngoài. Khi gọi một hàm chỉ chấp nhận các tham số chỉ 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 foo():
..     print(x)
..     x += 1

Dấu gạch chéo ở cuối danh sách tham số có nghĩa là cả hai tham số đều chỉ có vị trí. Do đó, gọi

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

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

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, hãy đặt trước giá trị bát phân bằng số 0, sau đó là chữ "o" viết thường hoặc viết hoa. Ví dụ: để đặt biến “a” thành giá trị bát phân “10” (8 ở dạng thập phân), hãy nhập

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

Hệ thập lục phân thật dễ dàng. Chỉ cần đặt trước số thập lục phân bằng số 0, sau đó là chữ "x" viết thường hoặc viết hoa. Các chữ số thập lục phân có thể được chỉ định bằng chữ thường hoặc chữ hoa. Ví dụ, trong trình thông dịch Python

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

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

Nó chủ yếu được thúc đẩy 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 foo():
..     print(x)
..     x += 1

sau đó phép chia số nguyên phải trả về sàn. C cũng yêu cầu giữ danh tính đó, và sau đó các trình biên dịch cắt bớ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

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

Có rất ít 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

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

Cố gắng tra cứu thuộc tính chữ

>>> 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

The solution is to separate the literal from the period with either a space or parentheses

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

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

Đối với số nguyên, hãy sử dụng hàm tạo kiểu

>>> 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ố dưới dạng số 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

Do not use the built-in function

>>> 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

How do I convert a number to a string?¶

Để chuyển đổi, e. g. , the number

>>> 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

How do I modify a string in place?¶

You can’t, because strings are immutable. In most situations, you should simply construct a new string from the various parts you want to assemble it from. However, if you need an object with the ability to modify in-place unicode data, try using an

>>> 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

How do I use strings to call functions/methods?¶

There are various techniques

• The best is to use a dictionary that maps strings to functions. The primary advantage of this technique is that the strings do not need to match the names of the functions. This is also the primary technique used to emulate a case construct

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

  09

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

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

  83

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

  20

  Note that

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

  83 works on any object, including classes, class instances, modules, and so on

  This is used in several places in the standard library, like this

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

  21

• Use

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

  85 to resolve the function name

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

  22

Is there an equivalent to Perl’s chomp() for removing trailing newlines from strings?¶

You can use

>>> 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 foo():
..     print(x)
..     x += 1

Since this is typically only desired when reading text one line at a time, using

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

Is there a scanf() or sscanf() equivalent?¶

Not as such

For simple input parsing, the easiest approach is usually to split the line into whitespace-delimited words using the

>>> 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

For more complicated input parsing, regular expressions are more powerful than C’s

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

What does ‘UnicodeDecodeError’ or ‘UnicodeEncodeError’ error mean?¶

See the Unicode HOWTO .

My program is too slow. How do I speed it up?¶

That’s a tough one, in general. First, here are a list of things to remember before diving further

• Performance characteristics vary across Python implementations. This FAQ focuses on CPython .

• Behaviour can vary across operating systems, especially when talking about I/O or multi-threading

• You should always find the hot spots in your program before attempting to optimize any code (see the

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

  95 module)

• Writing benchmark scripts will allow you to iterate quickly when searching for improvements (see the

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

  96 module)

• It is highly recommended to have good code coverage (through unit testing or any other technique) before potentially introducing regressions hidden in sophisticated optimizations

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

• Làm cho thuật toán của bạn nhanh hơn (hoặc thay đổi thành 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 rải các thủ thuật tối ưu hóa vi mô lên toàn bộ mã của bạn

• Sử dụng đúng cấu trúc dữ liệu. Nghiên cứu tài liệu về Các loại tích hợp sẵn và mô-đun

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

  97.

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

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

  98 hoặc hàm

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

  99 có liên quan để thực hiện sắp xếp (và xem phần Sắp xếp CÁCH để biết ví dụ về .

• Sự trừu tượng hóa có xu hướng tạo ra sự gián tiếp và buộc trình thông dịch phải làm việc nhiều hơn. Nếu mức độ gián tiếp lớn hơn 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 thức 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 mà Python thuần túy có thể cho phép, sẽ có những công cụ giúp bạn tiến xa hơn. Ví dụ: Cython có thể biên dịch phiên bản mã Python được sửa đổi một chút thành phần 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 quá trình biên dịch (và các 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 diễn giải. Nếu tự tin vào kỹ năng lập trình C của mình, bạn cũng có thể viết mô-đun mở rộng C cho mình.

Xem thêm

Trang wiki dành cho mẹo hiệu suất

Cách hiệu quả nhất để nối nhiều chuỗi lại với nhau là gì?¶

Các đối tượng

>>> 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

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

>>> 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 foo():
..     print(x)
..     x += 1

(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

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

>>> 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

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

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

Hàm tạo kiểu

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

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

Hàm tạo kiể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

>>> 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

Chỉ số âm là gì?¶

Chuỗi 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ố đầu tiên 1 là chỉ số thứ hai, v.v. Đối với các chỉ số âm -1 là chỉ số cuối cùng và -2 là chỉ số áp chót (kế tiếp đến cuối cùng), v.v. 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 chỉ số âm có thể rất thuận tiện. Ví dụ:

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

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

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

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

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

Điều này sẽ không chạm vào trình tự ban đầu của bạn, nhưng tạo một bản sao mới với thứ tự đảo ngược để lặp lại

Làm cách nào để loại bỏ các mục trùng lặp khỏi danh sách?¶

Xem Sách dạy nấu ăn Python để biết một cuộc thảo luận dài về nhiều cách để thực hiện việc này

https. //mã số. trạng thái kích hoạt. com/công thức nấu ăn/52560/

Nếu bạn không ngại sắp xếp lại danh sách, hãy sắp xếp nó rồi quét từ cuối danh sách, xóa các mục trùng lặp khi bạn thực hiện

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

Nếu tất cả các phần tử của danh sách có thể được sử dụng làm khóa thiết lập (i. e. tất cả chúng đều có thể băm ), điều này thường nhanh hơn

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

Đ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 cách nào để xóa nhiều mục khỏi danh sách¶

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

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

Việc hiểu danh sách có thể nhanh nhất

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

Sử dụng một danh sách

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

Các danh sách tương đương với các mảng C hoặc Pascal về độ phức tạp về thời gian của chúng;

Mô-đun

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

Để có danh sách được liên kết 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

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

Nếu muốn có khả năng thay đổi, bạn có thể sử dụng danh sách thay vì bộ dữ liệu. Ở đây, dạng tương tự của ô tô 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 danh sách đa chiều?¶

Có thể bạn đã thử tạo một mảng nhiều chiều như thế này

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

Điều này có vẻ đúng nếu bạn in nó

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

Nhưng khi bạn chỉ định một giá trị, nó sẽ hiển thị ở nhiều nơi

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

Lý do là việc sao chép danh sách bằng

>>> 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à trước tiên hãy tạo một danh sách có độ dài mong muốn và sau đó điền vào từng phần tử bằng một danh sách mới được tạo

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

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

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

Hoặc, bạn có thể sử dụng tiện ích mở rộng cung cấp kiểu dữ liệu ma trận;

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 hàm và tích lũy các giá trị trả về là một danh sách, việc hiểu danh sách là một giải pháp tinh tế.

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

Để 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

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

Tại sao a_tuple[i] += [‘item’] đưa ra một ngoại lệ khi phép cộng 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à không thể thay đổi trong Python

Cuộc thảo luận này áp dụng chung khi các toán tử gán tăng cường được áp dụng cho các phần tử của bộ trỏ đến các đối tượng có thể thay đổi, nhưng chúng tôi sẽ 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

Nếu bạn đã viết

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

Lý do 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

Dưới vỏ bọc, điều mà câu lệnh gán tăng cường này đang thực hiện là xấp xỉ điều này

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

Đó là phần gán của hoạt động tạo ra lỗi, vì một bộ dữ liệu là bất biến

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

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

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

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

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

>>> 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

>>> 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 foo():
..     print(x)
..     x += 1

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

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

Đối tượng được trỏ tới bởi a_list đã bị thay đổi và con trỏ tới đối tượng bị thay đổi được gán lại 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

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

>>> 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 foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

Tôi muốn làm một sắp xếp phức tạp. bạn có thể thực hiện Biến đổi Schwartzian bằng Python không?¶

Kỹ thuật này, do Randal Schwartz của cộng đồng Perl, sắp xếp các phần tử của danh sách theo một số liệu ánh xạ từng phần tử tới “giá trị sắp xếp” của nó. Trong Python, 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

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

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

Hợp nhất chúng thành một bộ lặp gồm các bộ, sắp xếp danh sách kết quả, sau đó chọn ra phần tử bạn muốn

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

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 hiện 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 một 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à (các) 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 tục bằng 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 chức năng 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

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

Bản ngã là gì?¶

Bản thân chỉ là một tên quy ước 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

Xem thêm Tại sao phải sử dụng 'self' một cách rõ ràng trong các định nghĩa và lệnh gọi phương thức? .

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 đã cho hay một lớp con của nó?¶

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

>>> 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 foo():
..     print(x)
..     x += 1

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

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

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

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

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

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

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

Ủy quyền là gì?¶

Ủy quyền là một kỹ thuật hướng đối tượng (còn được gọi là mẫu thiết kế). Giả sử 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 ủy quyền. Ví dụ, lớp sau triển khai một lớp hoạt động như một tệp nhưng chuyển đổi tất cả dữ liệu được viết thành chữ hoa

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

Ở đâ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

Note that for more general cases delegation can get trickier. When attributes must be set as well as retrieved, the class must define a

>>> 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 bar():
..     print(x)
...
>>> bar()
10

Most

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

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

How do I call a method defined in a base class from a derived class that extends it?¶

Use the built-in

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

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

In the example,

>>> 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

How can I organize my code to make it easier to change the base class?¶

You could assign the base class to an alias and derive from the alias. Then all you have to change is the value assigned to the alias. Incidentally, this trick is also handy if you want to decide dynamically (e. g. depending on availability of resources) which base class to use. Example

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

How do I create static class data and static class methods?¶

Both static data and static methods (in the sense of C++ or Java) are supported in Python

For static data, simply define a class attribute. To assign a new value to the attribute, you have to explicitly use the class name in the assignment

>>> x = 10
>>> def bar():
..     print(x)
...
>>> bar()
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

Caution. within a method of C, an assignment like

>>> 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 bar():
..     print(x)
...
>>> bar()
10

Static methods are possible

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

However, a far more straightforward way to get the effect of a static method is via a simple module-level function

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

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

How can I overload constructors (or methods) in Python?¶

This answer actually applies to all methods, but the question usually comes up first in the context of constructors

In C++ you’d write

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

In Python you have to write a single constructor that catches all cases using default arguments. For example

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

This is not entirely equivalent, but close enough in practice

You could also try a variable-length argument list, e. g

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

The same approach works for all method definitions

I try to use __spam and I get an error about _SomeClassName__spam. ¶

Variable names with double leading underscores are “mangled” to provide a simple but effective way to define class private variables. Any identifier of the form

>>> 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

This doesn’t guarantee privacy. an outside user can still deliberately access the “_classname__spam” attribute, and private values are visible in the object’s

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

My class defines __del__ but it is not called when I delete the object. ¶

There are several possible reasons for this

The

>>> 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

Nếu cấu trúc dữ liệu của bạn chứa các liên kết vòng (e. g. a tree where each child has a parent reference and each parent has a list of children) the reference counts will never go back to zero. Once in a while Python runs an algorithm to detect such cycles, but the garbage collector might run some time after the last reference to your data structure vanishes, so your

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

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

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

Despite the cycle collector, it’s still a good idea to define an explicit

>>> 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

Another way to avoid cyclical references is to use the

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

Finally, if your

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

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

Làm cách nào để tôi có được danh sách tất cả các phiên bản của một lớp nhất định?¶

Python không theo dõi tất cả các phiên bản của một lớp (hoặc của một kiểu dựng sẵn). You can program the class’s constructor to keep track of all instances by keeping a list of weak references to each instance

Why does the result of >>> x = 10 >>> def foo(): .. print(x) .. x += 1 14 appear to be not unique?¶

The

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

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

Hai id thuộc về các đối tượng số nguyên khác nhau được tạo trước đó và bị xóa ngay sau khi thực hiện lệnh gọi

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

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

Khi nào tôi có thể dựa vào kiểm tra nhận dạng với toán tử is?¶

Toán tử

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

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

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

Thuộc tính quan trọng nhất của kiểm tra danh tính là một đối tượng luôn giống với chính nó,

>>> 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

Tuy nhiên, các bài kiểm tra nhận dạng chỉ có thể được thay thế cho các bài kiểm tra đẳng thức khi nhận dạng đối tượng được đảm bảo. Nói chung, có ba trường hợp mà danh tính được đảm bảo

1) Bài tập tạo tên mới nhưng không thay đổi nhận dạng đối tượng. Sau khi chuyển nhượng

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

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

2) Đặt một đối tượng vào vùng chứa lưu trữ các tham chiếu đối tượng không thay đổi danh tính đối tượng. Sau khi gán danh sách

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

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

3) Nếu một đối tượng là một singleton, điều đó có nghĩa là chỉ có thể tồn tại một phiên bản của đối tượng đó. Sau phép gá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

Trong hầu hết các trường hợp khác, các bài kiểm tra danh tính là không nên và các bài kiểm tra bình đẳng được ưa thích hơn. Cụ thể, không nên sử dụng các kiểm tra nhận dạng để kiểm tra các hằng số 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

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

Tương tự như vậy, các phiên bản mới của vùng chứa có thể thay đổi không bao giờ giống hệt nhau

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

Trong mã thư viện tiêu chuẩn, bạn sẽ thấy một số mẫu phổ biến để sử dụng chính xác các bài kiểm tra danh tính

1) Theo khuyến nghị của PEP 8, kiểm tra danh tính là cách ưu tiên để kiểm tra

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

2) Việc phát hiện các đối số tùy chọn có thể phức tạp khi

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

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

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