Cách xác định một phương thức trong python

Tính trừu tượng và khả năng sử dụng lại

Giả sử bạn viết một số mã làm điều gì đó hữu ích. Khi bạn tiếp tục phát triển, bạn thấy rằng tác vụ do mã đó thực hiện là tác vụ bạn cần thường xuyên, ở nhiều vị trí khác nhau trong ứng dụng của bạn. Những gì bạn nên làm?

Sau này, có thể bạn sẽ quyết định rằng mã được đề cập cần phải được sửa đổi. Bạn sẽ tìm thấy điều gì đó không ổn với nó cần được sửa chữa hoặc bạn sẽ muốn cải thiện nó theo một cách nào đó. Nếu các bản sao của mã nằm rải rác khắp ứng dụng của bạn, thì bạn sẽ cần thực hiện các thay đổi cần thiết ở mọi vị trí

Ghi chú. Thoạt nhìn, đó có vẻ là một giải pháp hợp lý, nhưng về lâu dài, nó có thể là một cơn ác mộng về bảo trì. Mặc dù trình soạn thảo mã của bạn có thể trợ giúp bằng cách cung cấp chức năng tìm kiếm và thay thế, nhưng phương pháp này dễ bị lỗi và bạn có thể dễ dàng đưa các lỗi vào mã của mình mà rất khó tìm thấy

Một giải pháp tốt hơn là xác định hàm Python thực hiện tác vụ. Bất cứ nơi nào trong ứng dụng của bạn mà bạn cần hoàn thành tác vụ, bạn chỉ cần gọi hàm. Cuối cùng, nếu bạn quyết định thay đổi cách thức hoạt động của nó, thì bạn chỉ cần thay đổi mã ở một vị trí, đó là nơi xác định chức năng. Các thay đổi sẽ tự động được chọn ở bất kỳ đâu mà chức năng được gọi

Việc trừu tượng hóa chức năng thành một định nghĩa chức năng là một ví dụ về Nguyên tắc không lặp lại chính mình (DRY) trong phát triển phần mềm. Đây được cho là động lực mạnh nhất để sử dụng các chức năng

tính mô đun

Các chức năng cho phép chia các quy trình phức tạp thành các bước nhỏ hơn. Ví dụ, hãy tưởng tượng rằng bạn có một chương trình đọc tệp, xử lý nội dung tệp và sau đó ghi tệp đầu ra. Mã của bạn có thể trông như thế này

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Trong ví dụ này, chương trình chính là một loạt mã được xâu thành một chuỗi dài, với khoảng trắng và nhận xét để giúp tổ chức chương trình. Tuy nhiên, nếu mã trở nên dài hơn và phức tạp hơn nhiều, thì bạn sẽ ngày càng gặp khó khăn trong việc xoay sở với nó.

Ngoài ra, bạn có thể cấu trúc mã giống như sau

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Ví dụ này được mô đun hóa. Thay vì tất cả mã được xâu chuỗi lại với nhau, nó được chia thành các chức năng riêng biệt, mỗi chức năng tập trung vào một nhiệm vụ cụ thể. Những tác vụ đó được đọc, xử lý và ghi. Chương trình chính bây giờ chỉ cần gọi lần lượt từng cái này

Ghi chú. Từ khóa

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Trong cuộc sống, bạn luôn làm những việc như thế này, ngay cả khi bạn không nghĩ rõ ràng về nó theo cách đó. Nếu bạn muốn di chuyển một số kệ chứa đầy đồ đạc từ bên này sang bên kia ga-ra của mình, thì hy vọng rằng bạn sẽ không chỉ đứng đó và nghĩ vẩn vơ, “Ôi trời. Tôi cần phải di chuyển tất cả những thứ đó ở đó. Làm thế nào để làm điều đó???"

1. Lấy tất cả những thứ ra khỏi kệ
2. Tháo rời các kệ
3. Mang các bộ phận của kệ qua nhà để xe đến vị trí mới
4. Lắp ráp lại các kệ
5. Mang đồ qua nhà để xe
6. Đặt lại những thứ trên kệ

Chia một nhiệm vụ lớn thành các nhiệm vụ nhỏ hơn, nhỏ hơn giúp làm cho nhiệm vụ lớn dễ suy nghĩ và quản lý hơn. Khi các chương trình trở nên phức tạp hơn, việc mô đun hóa chúng theo cách này ngày càng trở nên có lợi.

Tách không gian tên

Không gian tên là một vùng của chương trình trong đó các mã định danh có ý nghĩa. Như bạn sẽ thấy bên dưới, khi một hàm Python được gọi, một không gian tên mới được tạo cho hàm đó, một không gian tên khác với tất cả các không gian tên khác đã tồn tại

Kết quả thực tế của điều này là các biến có thể được xác định và sử dụng trong một hàm Python ngay cả khi chúng có cùng tên với các biến được xác định trong các hàm khác hoặc trong chương trình chính. Trong những trường hợp này, sẽ không có sự nhầm lẫn hoặc can thiệp vì chúng được giữ trong các không gian tên riêng biệt

Điều này có nghĩa là khi bạn viết mã trong một hàm, bạn có thể sử dụng tên biến và mã định danh mà không phải lo lắng về việc liệu chúng đã được sử dụng ở đâu khác bên ngoài hàm chưa. Điều này giúp giảm thiểu đáng kể các lỗi trong mã

Ghi chú. Bạn sẽ tìm hiểu thêm về không gian tên ở phần sau của loạt bài này

Hy vọng rằng bạn đã đủ thuyết phục về ưu điểm của các chức năng và mong muốn tạo ra một số. Hãy xem làm thế nào

Đối số vị trí

Cách đơn giản nhất để truyền đối số cho hàm Python là sử dụng đối số vị trí (còn gọi là đối số bắt buộc). Trong định nghĩa hàm, bạn chỉ định danh sách tham số được phân tách bằng dấu phẩy bên trong dấu ngoặc đơn

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Khi hàm được gọi, bạn chỉ định một danh sách các đối số tương ứng

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Các tham số (

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Đối số tham số

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Trong một số văn bản lập trình, các tham số được đưa ra trong định nghĩa hàm được gọi là tham số hình thức và các đối số trong lệnh gọi hàm được gọi là tham số thực

Mặc dù các đối số vị trí là cách đơn giản nhất để truyền dữ liệu đến một hàm, nhưng chúng cũng kém linh hoạt nhất. Đối với người mới bắt đầu, thứ tự của các đối số trong lệnh gọi phải khớp với thứ tự của các tham số trong định nghĩa. Tất nhiên, không có gì ngăn bạn chỉ định các đối số vị trí không theo thứ tự

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Hàm thậm chí có thể vẫn chạy, như trong ví dụ trên, nhưng rất khó có thể tạo ra kết quả chính xác. Lập trình viên có trách nhiệm xác định chức năng để ghi lại các đối số phù hợp và trách nhiệm của người dùng chức năng là nhận thức được thông tin đó và tuân theo thông tin đó

Với các đối số vị trí, các đối số trong lệnh gọi và các tham số trong định nghĩa phải thống nhất không chỉ về thứ tự mà còn về số lượng. Đó là lý do đối số vị trí cũng được gọi là đối số bắt buộc. Bạn không thể bỏ bất kỳ phần nào khi gọi hàm

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Bạn cũng không thể chỉ định những cái bổ sung

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Đối số vị trí dễ sử dụng về mặt khái niệm, nhưng chúng không dễ tha thứ. Bạn phải chỉ định cùng một số đối số trong lệnh gọi hàm như có các tham số trong định nghĩa và theo đúng thứ tự. Trong các phần tiếp theo, bạn sẽ thấy một số kỹ thuật chuyển đối số giúp nới lỏng các hạn chế này

Đối số từ khóa

Khi gọi một hàm, bạn có thể chỉ định các đối số ở dạng

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Tham chiếu một từ khóa không khớp với bất kỳ tham số nào đã khai báo sẽ tạo ra một ngoại lệ

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Sử dụng các đối số từ khóa sẽ loại bỏ hạn chế về thứ tự đối số. Mỗi đối số từ khóa chỉ định rõ ràng một tham số cụ thể theo tên, vì vậy bạn có thể chỉ định chúng theo bất kỳ thứ tự nào và Python sẽ vẫn biết đối số nào đi với tham số nào

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Tuy nhiên, giống như đối số vị trí, số lượng đối số và tham số vẫn phải khớp với nhau

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Vì vậy, các đối số từ khóa cho phép linh hoạt trong thứ tự các đối số chức năng được chỉ định, nhưng số lượng đối số vẫn còn cứng nhắc

Bạn có thể gọi một hàm bằng cách sử dụng cả đối số vị trí và từ khóa

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Khi cả hai đối số vị trí và từ khóa đều xuất hiện, tất cả các đối số vị trí phải xuất hiện trước

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Khi bạn đã chỉ định một đối số từ khóa, không thể có bất kỳ đối số vị trí nào ở bên phải của nó

Để tìm hiểu thêm về các tham số vị trí và từ khóa, hãy xem khóa học Real Python Khám phá các tham số chức năng đặc biệt

Thông số mặc định

Nếu một tham số được chỉ định trong định nghĩa hàm Python có dạng

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Khi phiên bản này của

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Tóm tắt

• Các đối số vị trí phải thống nhất về thứ tự và số với các tham số được khai báo trong định nghĩa hàm
• Các đối số từ khóa phải phù hợp với các tham số đã khai báo về số lượng, nhưng chúng có thể được chỉ định theo thứ tự tùy ý
• Tham số mặc định cho phép bỏ qua một số đối số khi gọi hàm

Giá trị tham số mặc định có thể thay đổi

Mọi thứ có thể trở nên kỳ lạ nếu bạn chỉ định một giá trị tham số mặc định là một đối tượng có thể thay đổi. Xem xét định nghĩa hàm Python này

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Giá trị mặc định cho tham số

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Mọi thứ đều có ý nghĩa cho đến nay. Bây giờ, bạn mong đợi điều gì sẽ xảy ra nếu

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Ối. Bạn có thể mong đợi mỗi cuộc gọi tiếp theo cũng trả về danh sách đơn lẻ

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Trong Python, các giá trị tham số mặc định chỉ được xác định một lần khi hàm được xác định (nghĩa là khi câu lệnh

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Bạn có thể chứng minh điều này với

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Mã định danh đối tượng được hiển thị xác nhận rằng, khi

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Như một giải pháp thay thế, hãy cân nhắc sử dụng một giá trị đối số mặc định báo hiệu rằng không có đối số nào được chỉ định. Hầu hết mọi giá trị sẽ hoạt động, nhưng

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Lưu ý cách điều này đảm bảo rằng giờ đây

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Pass-By-Value vs Pass-By-Reference trong Pascal

Trong thiết kế ngôn ngữ lập trình, có hai mô hình phổ biến để truyền đối số cho hàm

1. Pass-by-giá trị. Một bản sao của đối số được chuyển đến hàm
2. Chuyển qua tham chiếu. Một tham chiếu đến đối số được chuyển đến hàm

Các cơ chế khác tồn tại, nhưng về cơ bản chúng là các biến thể của hai cơ chế này. Trong phần này, bạn sẽ đi một đoạn ngắn từ Python và xem xét ngắn gọn về Pascal, một ngôn ngữ lập trình tạo ra sự khác biệt đặc biệt rõ ràng giữa hai ngôn ngữ này.

Ghi chú. Đừng lo lắng nếu bạn không quen thuộc với Pascal. Các khái niệm này tương tự như các khái niệm của Python và các ví dụ được hiển thị kèm theo lời giải thích đủ chi tiết để bạn có được ý tưởng chung. Khi bạn đã thấy cách truyền đối số hoạt động trong Pascal, chúng ta sẽ quay lại Python và bạn sẽ thấy nó so sánh như thế nào

Đây là những gì bạn cần biết về cú pháp Pascal

• thủ tục. Một thủ tục trong Pascal tương tự như một hàm trong Python
• Dấu hai chấm bằng. Toán tử này (

  >>> a = ['foo', 'bar', 'baz', 'qux']
  >>> len(a)
  4
  

  86) dùng để gán trong Pascal. Nó tương tự như dấu bằng (

  >>> a = ['foo', 'bar', 'baz', 'qux']
  >>> len(a)
  4
  

  87) trong Python

• >>> a = ['foo', 'bar', 'baz', 'qux']
  >>> len(a)
  4
  

  88. Hàm này hiển thị dữ liệu ra bàn điều khiển, tương tự như hàm

  >>> a = ['foo', 'bar', 'baz', 'qux']
  >>> len(a)
  4
  

  48 của Python

Với một chút nền tảng đó, đây là ví dụ Pascal đầu tiên

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Đây là những gì đang xảy ra

• Dòng 12. Chương trình chính xác định một biến số nguyên

  >>> a = ['foo', 'bar', 'baz', 'qux']
  >>> len(a)
  4
  

  17
• Dòng 15. Ban đầu nó gán cho

  >>> a = ['foo', 'bar', 'baz', 'qux']
  >>> len(a)
  4
  

  17 giá trị

  >>> a = ['foo', 'bar', 'baz', 'qux']
  >>> len(a)
  4
  

  92
• Dòng 17. Sau đó, nó gọi thủ tục

  >>> a = ['foo', 'bar', 'baz', 'qux']
  >>> len(a)
  4
  

  36, chuyển

  >>> a = ['foo', 'bar', 'baz', 'qux']
  >>> len(a)
  4
  

  17 làm đối số
• Dòng 5. Bên trong

  >>> a = ['foo', 'bar', 'baz', 'qux']
  >>> len(a)
  4
  

  36, câu lệnh

  >>> a = ['foo', 'bar', 'baz', 'qux']
  >>> len(a)
  4
  

  88 cho thấy tham số tương ứng

  >>> a = ['foo', 'bar', 'baz', 'qux']
  >>> len(a)
  4
  

  97 ban đầu là

  >>> a = ['foo', 'bar', 'baz', 'qux']
  >>> len(a)
  4
  

  92, giá trị được truyền vào
• Dòng 6.

  >>> a = ['foo', 'bar', 'baz', 'qux']
  >>> len(a)
  4
  

  97 sau đó được gán giá trị

  >>> a = ['foo', 'bar', 'baz', 'qux']
  >>> len(a)
  4
  

  000
• dòng 7. Giá trị này được xác minh bởi câu lệnh

  >>> a = ['foo', 'bar', 'baz', 'qux']
  >>> len(a)
  4
  

  88 này được thực thi ngay trước khi thoát

  >>> a = ['foo', 'bar', 'baz', 'qux']
  >>> len(a)
  4
  

  36
• Dòng 18. Trở lại môi trường gọi của chương trình chính, câu lệnh

  >>> a = ['foo', 'bar', 'baz', 'qux']
  >>> len(a)
  4
  

  88 này cho thấy rằng sau khi

  >>> a = ['foo', 'bar', 'baz', 'qux']
  >>> len(a)
  4
  

  36 trả về,

  >>> a = ['foo', 'bar', 'baz', 'qux']
  >>> len(a)
  4
  

  17 vẫn là

  >>> a = ['foo', 'bar', 'baz', 'qux']
  >>> len(a)
  4
  

  92, giống như trước khi gọi thủ tục

Chạy mã này tạo ra đầu ra sau

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Trong ví dụ này,

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Ghi chú. Nếu bạn muốn thấy điều này hoạt động, thì bạn có thể tự chạy mã bằng trình biên dịch Pascal trực tuyến

Chỉ cần làm theo các bước sau

1. Sao chép mã từ hộp mã ở trên
2. Truy cập Trình biên dịch Pascal trực tuyến
3. Trong hộp mã ở bên trái, hãy thay thế mọi nội dung hiện có bằng mã bạn đã sao chép ở bước 1
4. Nhấp vào Thực hiện

Bạn sẽ thấy đầu ra tương tự như trên

Bây giờ, hãy so sánh điều này với ví dụ tiếp theo

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Mã này giống với ví dụ đầu tiên, với một thay đổi. Đó là sự hiện diện của từ

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Đầu ra từ mã này giống như trước, ngoại trừ dòng cuối cùng

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Một lần nữa,

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Trong nhiều ngôn ngữ lập trình, về cơ bản đó là sự khác biệt giữa pass-by-value và pass-by-reference

• Nếu một biến được truyền theo giá trị, thì hàm có một bản sao để hoạt động, nhưng nó không thể sửa đổi giá trị ban đầu trong môi trường gọi
• Nếu một biến được truyền theo tham chiếu, thì bất kỳ thay đổi nào mà hàm thực hiện đối với tham số tương ứng sẽ ảnh hưởng đến giá trị trong môi trường gọi

Lý do tại sao xuất phát từ ý nghĩa của một tài liệu tham khảo trong các ngôn ngữ này. Các giá trị biến được lưu trữ trong bộ nhớ. Trong Pascal và các ngôn ngữ tương tự, tham chiếu về cơ bản là địa chỉ của vị trí bộ nhớ đó, như minh họa bên dưới

Trong sơ đồ bên trái,

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Trong sơ đồ bên phải,

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Pass-By-Value vs Pass-By-Reference trong Python

Các tham số trong Python có truyền theo giá trị hoặc theo tham chiếu không? . Đó là bởi vì một tham chiếu không có nghĩa hoàn toàn giống như trong Python như trong Pascal

Nhớ lại rằng trong Python, mọi phần dữ liệu đều là một đối tượng. Một tham chiếu trỏ đến một đối tượng, không phải là một vị trí bộ nhớ cụ thể. Điều đó có nghĩa là phép gán không được hiểu theo cùng một cách trong Python như trong Pascal. Xét cặp câu lệnh sau trong Pascal

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Chúng được giải thích theo cách này

• Biến

  >>> a = ['foo', 'bar', 'baz', 'qux']
  >>> len(a)
  4
  

  17 tham chiếu đến một vị trí bộ nhớ cụ thể
• Câu lệnh đầu tiên đặt giá trị

  >>> a = ['foo', 'bar', 'baz', 'qux']
  >>> len(a)
  4
  

  92 vào vị trí đó
• Câu lệnh tiếp theo ghi đè lên

  >>> a = ['foo', 'bar', 'baz', 'qux']
  >>> len(a)
  4
  

  92 và thay vào đó đặt

  >>> a = ['foo', 'bar', 'baz', 'qux']
  >>> len(a)
  4
  

  000 ở đó

Ngược lại, trong Python, các câu lệnh gán tương tự như sau

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Các câu lệnh gán này có ý nghĩa như sau

• Câu lệnh đầu tiên làm cho

  >>> a = ['foo', 'bar', 'baz', 'qux']
  >>> len(a)
  4
  

  17 trỏ đến một đối tượng có giá trị là

  >>> a = ['foo', 'bar', 'baz', 'qux']
  >>> len(a)
  4
  

  92
• Câu lệnh tiếp theo gán lại

  >>> a = ['foo', 'bar', 'baz', 'qux']
  >>> len(a)
  4
  

  17 làm tham chiếu mới cho một đối tượng khác có giá trị là

  >>> a = ['foo', 'bar', 'baz', 'qux']
  >>> len(a)
  4
  

  000. Nói cách khác, phép gán thứ hai liên kết lại

  >>> a = ['foo', 'bar', 'baz', 'qux']
  >>> len(a)
  4
  

  17 với một đối tượng khác có giá trị

  >>> a = ['foo', 'bar', 'baz', 'qux']
  >>> len(a)
  4
  

  000

Trong Python, khi bạn truyền một đối số cho một hàm, một rebinding tương tự sẽ xảy ra. Hãy xem xét ví dụ này

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Trong chương trình chính, câu lệnh

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Tuy nhiên, khi câu lệnh

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Bạn có thể xác nhận tất cả điều này bằng cách sử dụng

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Khi

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Truyền đối số trong Python có phần kết hợp giữa truyền theo giá trị và truyền theo tham chiếu. Những gì được truyền cho hàm là một tham chiếu đến một đối tượng, nhưng tham chiếu được truyền theo giá trị

Ghi chú. Cơ chế truyền đối số của Python đã được gọi là chuyển từng lần gán. Điều này là do các tên tham số được liên kết với các đối tượng trên mục nhập hàm trong Python và phép gán cũng là quá trình liên kết tên với một đối tượng. Bạn cũng có thể thấy các thuật ngữ truyền theo đối tượng, tham chiếu theo đối tượng hoặc chia sẻ theo đối tượng

Điểm mấu chốt ở đây là một hàm Python không thể thay đổi giá trị của một đối số bằng cách gán lại tham số tương ứng cho một thứ khác. Ví dụ sau minh họa điều này

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Ở đây, các đối tượng kiểu

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Điều đó có nghĩa là một hàm Python không bao giờ có thể sửa đổi các đối số của nó? . Xem những gì xảy ra ở đây

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Trong trường hợp này, đối số của

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Tuy nhiên,

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Ở đây,

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Tóm tắt thông qua đối số

Truyền đối số trong Python có thể được tóm tắt như sau. Truyền một đối tượng bất biến, chẳng hạn như

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Truyền một đối tượng có thể thay đổi, chẳng hạn như ,

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Phản ứng phụ

Vì vậy, trong Python, bạn có thể sửa đổi một đối số từ bên trong một hàm để thay đổi được phản ánh trong môi trường gọi. Nhưng bạn có nên làm điều này?

Tổng quát hơn, một hàm Python được cho là gây ra tác dụng phụ nếu nó sửa đổi môi trường gọi của nó theo bất kỳ cách nào. Thay đổi giá trị của đối số hàm chỉ là một trong những khả năng

Ghi chú. Có lẽ bạn đã quen thuộc với các tác dụng phụ trong lĩnh vực sức khỏe con người, trong đó thuật ngữ này thường đề cập đến hậu quả không mong muốn của thuốc. Thông thường, hậu quả là không mong muốn, chẳng hạn như nôn mửa hoặc an thần. Mặt khác, tác dụng phụ có thể được sử dụng có chủ ý. Ví dụ, một số loại thuốc gây kích thích thèm ăn, có thể được sử dụng để tạo lợi thế, ngay cả khi đó không phải là mục đích chính của thuốc

Khái niệm này tương tự trong lập trình. Nếu tác dụng phụ là một phần được ghi chép rõ ràng trong đặc tả chức năng và người dùng chức năng nhận thức rõ ràng về thời điểm và cách thức môi trường gọi có thể được sửa đổi, thì điều đó có thể ổn. Nhưng một lập trình viên có thể không phải lúc nào cũng ghi lại chính xác các tác dụng phụ hoặc thậm chí họ có thể không biết rằng các tác dụng phụ đang xảy ra

Khi chúng bị ẩn hoặc không mong đợi, các tác dụng phụ có thể dẫn đến các lỗi chương trình rất khó theo dõi. Nói chung, tốt nhất là tránh chúng

Thoát khỏi một chức năng

Trong một hàm, câu lệnh

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Trong ví dụ này, câu lệnh

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Tuy nhiên, câu lệnh

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Hai lệnh gọi đầu tiên đến

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Loại mô hình này có thể hữu ích để kiểm tra lỗi trong một chức năng. Bạn có thể kiểm tra một số điều kiện lỗi khi bắt đầu chức năng, với các câu lệnh

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Nếu không gặp phải tình trạng lỗi nào, thì chức năng có thể tiến hành xử lý bình thường

Trả lại dữ liệu cho người gọi

Ngoài việc thoát khỏi một chức năng, câu lệnh

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Ở đây, giá trị của biểu thức

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Một hàm có thể trả về bất kỳ loại đối tượng nào. Trong Python, điều đó có nghĩa là bất cứ thứ gì. Trong môi trường gọi, lệnh gọi hàm có thể được sử dụng về mặt cú pháp theo bất kỳ cách nào phù hợp với loại đối tượng mà hàm trả về

Ví dụ, trong mã này,

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Trong ví dụ tiếp theo,

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Ở đây,

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Nếu nhiều biểu thức được phân tách bằng dấu phẩy được chỉ định trong câu lệnh

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Khi không có giá trị trả về nào được đưa ra, một hàm Python trả về giá trị Python đặc biệt

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Điều tương tự cũng xảy ra nếu thân hàm hoàn toàn không chứa câu lệnh

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Nhớ lại điều đó là sai khi được đánh giá trong ngữ cảnh Boolean

Vì các hàm thoát ra thông qua một câu lệnh

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Ở đây, các cuộc gọi đến cả

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Xem lại tác dụng phụ

Giả sử bạn muốn viết một hàm nhận một đối số nguyên và nhân đôi nó. Nghĩa là, bạn muốn truyền một biến số nguyên cho hàm và khi hàm trả về, giá trị của biến trong môi trường gọi phải gấp đôi giá trị ban đầu. Trong Pascal, bạn có thể thực hiện việc này bằng cách sử dụng tham chiếu chuyển qua

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Việc thực thi mã này tạo ra kết quả sau, xác minh rằng

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Trong Python, điều này sẽ không hoạt động. Như bạn đã biết, số nguyên trong Python là bất biến, do đó, hàm Python không thể thay đổi đối số số nguyên bằng tác dụng phụ

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Tuy nhiên, bạn có thể sử dụng giá trị trả về để có được hiệu ứng tương tự. Chỉ cần viết

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Điều này được cho là thích hợp hơn để sửa đổi bởi tác dụng phụ. Rất rõ ràng rằng

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Tuy nhiên, ngay cả trong trường hợp có thể sửa đổi đối số bằng tác dụng phụ, việc sử dụng giá trị trả về vẫn có thể rõ ràng hơn. Giả sử bạn muốn nhân đôi mọi mục trong danh sách. Vì danh sách có thể thay đổi, nên bạn có thể xác định hàm Python để sửa đổi danh sách tại chỗ

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Không giống như

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Tuy nhiên, bạn cũng có thể viết

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Một trong hai cách tiếp cận hoạt động tốt như nhau. Như thường lệ, đây là vấn đề về phong cách và sở thích cá nhân khác nhau. Các tác dụng phụ không nhất thiết phải hoàn toàn xấu xa và chúng có vị trí của chúng, nhưng vì hầu như mọi thứ đều có thể được trả về từ một hàm, nên điều tương tự cũng có thể được thực hiện thông qua các giá trị trả về.

Đối số Tuple đóng gói

Khi một tên tham số trong định nghĩa hàm Python được đặt trước dấu hoa thị (

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Trong định nghĩa của

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Sử dụng đóng gói tuple, bạn có thể dọn sạch

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Tốt hơn nữa, bạn có thể dọn dẹp nó hơn nữa bằng cách thay thế vòng lặp

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Bây giờ,

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Tuy nhiên, tùy thuộc vào cách mã này sẽ được sử dụng, có thể vẫn còn nhiều việc phải làm. Như đã viết,

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Để mạnh mẽ nhất có thể, bạn nên thêm mã để kiểm tra xem các đối số có thuộc loại phù hợp không. Ở phần sau của loạt bài hướng dẫn này, bạn sẽ học cách nắm bắt các ngoại lệ như

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Giải nén Tuple đối số

Một hoạt động tương tự có sẵn ở phía bên kia của phương trình trong lệnh gọi hàm Python. Khi một đối số trong lệnh gọi hàm được đặt trước dấu hoa thị (

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Trong ví dụ này,

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Mặc dù kiểu giải nén này được gọi là giải nén theo bộ, nhưng nó không chỉ hoạt động với các bộ. Toán tử dấu hoa thị (

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Bạn thậm chí có thể sử dụng đóng gói và giải nén tuple cùng một lúc

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Ở đây,

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Đóng gói từ điển đối số

Python có một toán tử tương tự, dấu hoa thị kép (

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Trong trường hợp này, các đối số

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Giải nén từ điển đối số

Giải nén từ điển đối số tương tự như giải nén bộ dữ liệu đối số. Khi dấu hoa thị kép (

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Các mục trong từ điển

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Trên thực tế, hãy kiểm tra điều này

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Ở đây,

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Để tất cả chúng cùng nhau

Hãy coi

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Ghi chú. Để có cái nhìn khác về

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Tất cả ba—tham số vị trí tiêu chuẩn,

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Điều này mang lại sự linh hoạt gần như bạn có thể cần trong một giao diện chức năng

Nhiều lần giải nén trong một lệnh gọi hàm Python

Python phiên bản 3. 5 đã giới thiệu hỗ trợ cho các khái quát hóa giải nén bổ sung, như được nêu trong PEP 448. Một điều mà những cải tiến này cho phép là nhiều lần giải nén trong một lệnh gọi hàm Python

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Bạn cũng có thể chỉ định nhiều lần giải nén từ điển trong lệnh gọi hàm Python

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Ghi chú. Cải tiến này chỉ có trong phiên bản Python 3. 5 hoặc muộn hơn. Nếu bạn thử điều này trong phiên bản cũ hơn, thì bạn sẽ nhận được một ngoại lệ

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

Nhân tiện, các toán tử giải nén

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> len(a)
4