Hướng dẫn what is parameter passing in python - tham số truyền trong python là gì

Tránh các đối tượng trùng lặp

Như bạn đã thấy, việc chuyển một biến theo giá trị sẽ khiến một bản sao của giá trị đó được tạo và lưu trữ trong bộ nhớ. Trong các ngôn ngữ mặc định để truyền theo giá trị, bạn có thể tìm thấy lợi ích hiệu suất từ ​​việc truyền biến bằng cách tham chiếu thay thế, đặc biệt là khi biến chứa rất nhiều dữ liệu. Điều này sẽ rõ ràng hơn khi mã của bạn đang chạy trên các máy bị hạn chế tài nguyên.

Tuy nhiên, trong Python, đây không bao giờ là vấn đề. Bạn sẽ thấy tại sao trong phần tiếp theo.

Trả về nhiều giá trị

Một trong những ứng dụng phổ biến nhất của việc truyền bằng tham chiếu là tạo một hàm làm thay đổi giá trị của các tham số tham chiếu trong khi trả về một giá trị riêng biệt. Bạn có thể sửa đổi ví dụ C# Pass-By-Reference của mình để minh họa kỹ thuật này:

using System;

class Program
{
    static void Main(string[] args)
    {
        int counter = 0;

        // Passing by reference.
        // The value of counter in Main is changed.
        Console.WriteLine(greet("Alice", ref counter));
        Console.WriteLine("Counter is {0}", counter);
        Console.WriteLine(greet("Bob", ref counter));
        Console.WriteLine("Counter is {0}", counter);
        // Output:
        // Hi, Alice!
        // Counter is 1
        // Hi, Bob!
        // Counter is 2
    }

    static string greet(string name, ref int counter)
    {
        string greeting = "Hi, " + name + "!";
        counter++;
        return greeting;
    }
}

Trong ví dụ trên,

>>> def main():
...     counter = 0
...     print(greet("Alice", counter))
...     print(f"Counter is {counter}")
...     print(greet("Bob", counter))
...     print(f"Counter is {counter}")
...
>>> def greet(name, counter):
...     counter += 1
...     return f"Hi, {name}!"
...
>>> main()
Hi, Alice!
Counter is 0
Hi, Bob!
Counter is 0

>>> def main():
...     counter = 0
...     print(greet("Alice", counter))
...     print(f"Counter is {counter}")
...     print(greet("Bob", counter))
...     print(f"Counter is {counter}")
...
>>> def greet(name, counter):
...     counter += 1
...     return f"Hi, {name}!"
...
>>> main()
Hi, Alice!
Counter is 0
Hi, Bob!
Counter is 0

>>>

>>> def main():
...     counter = 0
...     print(greet("Alice", counter))
...     print(f"Counter is {counter}")
...     print(greet("Bob", counter))
...     print(f"Counter is {counter}")
...
>>> def greet(name, counter):
...     counter += 1
...     return f"Hi, {name}!"
...
>>> main()
Hi, Alice!
Counter is 0
Hi, Bob!
Counter is 0

>>> def main():
...     counter = 0
...     print(greet("Alice", counter))
...     print(f"Counter is {counter}")
...     print(greet("Bob", counter))
...     print(f"Counter is {counter}")
...
>>> def greet(name, counter):
...     counter += 1
...     return f"Hi, {name}!"
...
>>> main()
Hi, Alice!
Counter is 0
Hi, Bob!
Counter is 0

Về bản chất, các tham số tham chiếu trong C# cho phép hàm không chỉ trả về một giá trị mà còn hoạt động trên các tham số bổ sung. Điều này tương đương với việc trả về nhiều giá trị!

May mắn thay, Python đã hỗ trợ trả về nhiều giá trị. Nói đúng ra, một hàm Python trả về nhiều giá trị thực sự trả về một tuple chứa mỗi giá trị:

>>>

>>> def multiple_return():
...     return 1, 2
...
>>> t = multiple_return()
>>> t  # A tuple
(1, 2)

>>> # You can unpack the tuple into two variables:
>>> x, y = multiple_return()
>>> x
1
>>> y
2

Như bạn có thể thấy, để trả về nhiều giá trị, bạn chỉ có thể sử dụng từ khóa

>>> def main():
...     counter = 0
...     print(greet("Alice", counter))
...     print(f"Counter is {counter}")
...     print(greet("Bob", counter))
...     print(f"Counter is {counter}")
...
>>> def greet(name, counter):
...     counter += 1
...     return f"Hi, {name}!"
...
>>> main()
Hi, Alice!
Counter is 0
Hi, Bob!
Counter is 0

Được trang bị kỹ thuật này, bạn có thể thay đổi câu lệnh

>>> def main():
...     counter = 0
...     print(greet("Alice", counter))
...     print(f"Counter is {counter}")
...     print(greet("Bob", counter))
...     print(f"Counter is {counter}")
...
>>> def greet(name, counter):
...     counter += 1
...     return f"Hi, {name}!"
...
>>> main()
Hi, Alice!
Counter is 0
Hi, Bob!
Counter is 0

>>> def main():
...     counter = 0
...     print(greet("Alice", counter))
...     print(f"Counter is {counter}")
...     print(greet("Bob", counter))
...     print(f"Counter is {counter}")
...
>>> def greet(name, counter):
...     counter += 1
...     return f"Hi, {name}!"
...
>>> main()
Hi, Alice!
Counter is 0
Hi, Bob!
Counter is 0

>>>

>>> def main():
...     counter = 0
...     print(greet("Alice", counter))
...     print(f"Counter is {counter}")
...     print(greet("Bob", counter))
...     print(f"Counter is {counter}")
...
>>> def greet(name, counter):
...     return f"Hi, {name}!", counter + 1
...
>>> main()
('Hi, Alice!', 1)
Counter is 0
('Hi, Bob!', 1)
Counter is 0

Điều đó vẫn không có vẻ đúng. Mặc dù

>>> def main():
...     counter = 0
...     print(greet("Alice", counter))
...     print(f"Counter is {counter}")
...     print(greet("Bob", counter))
...     print(f"Counter is {counter}")
...
>>> def greet(name, counter):
...     counter += 1
...     return f"Hi, {name}!"
...
>>> main()
Hi, Alice!
Counter is 0
Hi, Bob!
Counter is 0

>>> def multiple_return():
...     return 1, 2
...
>>> t = multiple_return()
>>> t  # A tuple
(1, 2)

>>> # You can unpack the tuple into two variables:
>>> x, y = multiple_return()
>>> x
1
>>> y
2

>>> def main():
...     counter = 0
...     print(greet("Alice", counter))
...     print(f"Counter is {counter}")
...     print(greet("Bob", counter))
...     print(f"Counter is {counter}")
...
>>> def greet(name, counter):
...     counter += 1
...     return f"Hi, {name}!"
...
>>> main()
Hi, Alice!
Counter is 0
Hi, Bob!
Counter is 0

>>> def multiple_return():
...     return 1, 2
...
>>> t = multiple_return()
>>> t  # A tuple
(1, 2)

>>> # You can unpack the tuple into two variables:
>>> x, y = multiple_return()
>>> x
1
>>> y
2

Để làm sạch đầu ra của bạn và nhận kết quả mong muốn, bạn sẽ phải gán lại biến

>>> def main():
...     counter = 0
...     print(greet("Alice", counter))
...     print(f"Counter is {counter}")
...     print(greet("Bob", counter))
...     print(f"Counter is {counter}")
...
>>> def greet(name, counter):
...     counter += 1
...     return f"Hi, {name}!"
...
>>> main()
Hi, Alice!
Counter is 0
Hi, Bob!
Counter is 0

>>> def main():
...     counter = 0
...     print(greet("Alice", counter))
...     print(f"Counter is {counter}")
...     print(greet("Bob", counter))
...     print(f"Counter is {counter}")
...
>>> def greet(name, counter):
...     counter += 1
...     return f"Hi, {name}!"
...
>>> main()
Hi, Alice!
Counter is 0
Hi, Bob!
Counter is 0

>>> def main():
...     counter = 0
...     print(greet("Alice", counter))
...     print(f"Counter is {counter}")
...     print(greet("Bob", counter))
...     print(f"Counter is {counter}")
...
>>> def greet(name, counter):
...     counter += 1
...     return f"Hi, {name}!"
...
>>> main()
Hi, Alice!
Counter is 0
Hi, Bob!
Counter is 0

>>> def main():
...     counter = 0
...     print(greet("Alice", counter))
...     print(f"Counter is {counter}")
...     print(greet("Bob", counter))
...     print(f"Counter is {counter}")
...
>>> def greet(name, counter):
...     counter += 1
...     return f"Hi, {name}!"
...
>>> main()
Hi, Alice!
Counter is 0
Hi, Bob!
Counter is 0

>>>

>>> def main():
...     counter = 0
...     greeting, counter = greet("Alice", counter)
...     print(f"{greeting}\nCounter is {counter}")
...     greeting, counter = greet("Bob", counter)
...     print(f"{greeting}\nCounter is {counter}")
...
>>> def greet(name, counter):
...     return f"Hi, {name}!", counter + 1
...
>>> main()
Hi, Alice!
Counter is 1
Hi, Bob!
Counter is 2

Bây giờ, sau khi chỉ định lại từng biến với một cuộc gọi đến

>>> def main():
...     counter = 0
...     print(greet("Alice", counter))
...     print(f"Counter is {counter}")
...     print(greet("Bob", counter))
...     print(f"Counter is {counter}")
...
>>> def greet(name, counter):
...     counter += 1
...     return f"Hi, {name}!"
...
>>> main()
Hi, Alice!
Counter is 0
Hi, Bob!
Counter is 0

Gán các giá trị trả về cho các biến là cách tốt nhất để đạt được kết quả tương tự như truyền bằng cách tham chiếu trong Python. Bạn sẽ tìm hiểu lý do tại sao, cùng với một số phương pháp bổ sung, trong phần về các thực tiễn tốt nhất.

Tạo các chức năng đa hoàn trả có điều kiện

Đây là một trường hợp sử dụng cụ thể của việc trả về nhiều giá trị trong đó hàm có thể được sử dụng trong một câu lệnh có điều kiện và có các tác dụng phụ bổ sung như sửa đổi một biến bên ngoài được truyền như một đối số.

Hãy xem xét chức năng Int32.TryParse tiêu chuẩn trong C#, trả về Boolean và hoạt động trên một tham chiếu đến một đối số số nguyên cùng một lúc:

public static bool TryParse (string s, out int result);

Hàm này cố gắng chuyển đổi

>>> def multiple_return():
...     return 1, 2
...
>>> t = multiple_return()
>>> t  # A tuple
(1, 2)

>>> # You can unpack the tuple into two variables:
>>> x, y = multiple_return()
>>> x
1
>>> y
2

>>> def multiple_return():
...     return 1, 2
...
>>> t = multiple_return()
>>> t  # A tuple
(1, 2)

>>> # You can unpack the tuple into two variables:
>>> x, y = multiple_return()
>>> x
1
>>> y
2

1. Nếu phân tích cú pháp thành công, thì tham số đầu ra sẽ được đặt thành số nguyên kết quả và hàm sẽ trả về

   >>> def multiple_return():
   ...     return 1, 2
   ...
   >>> t = multiple_return()
   >>> t  # A tuple
   (1, 2)
   
   >>> # You can unpack the tuple into two variables:
   >>> x, y = multiple_return()
   >>> x
   1
   >>> y
   2
   

   8., then the output parameter will be set to the resulting integer, and the function will return

   >>> def multiple_return():
   ...     return 1, 2
   ...
   >>> t = multiple_return()
   >>> t  # A tuple
   (1, 2)
   
   >>> # You can unpack the tuple into two variables:
   >>> x, y = multiple_return()
   >>> x
   1
   >>> y
   2
   

   8.
2. Nếu phân tích cú pháp không thành công, thì tham số đầu ra sẽ được đặt thành

   >>> def multiple_return():
   ...     return 1, 2
   ...
   >>> t = multiple_return()
   >>> t  # A tuple
   (1, 2)
   
   >>> # You can unpack the tuple into two variables:
   >>> x, y = multiple_return()
   >>> x
   1
   >>> y
   2
   

   2 và hàm sẽ trả về

   >>> def main():
   ...     counter = 0
   ...     print(greet("Alice", counter))
   ...     print(f"Counter is {counter}")
   ...     print(greet("Bob", counter))
   ...     print(f"Counter is {counter}")
   ...
   >>> def greet(name, counter):
   ...     return f"Hi, {name}!", counter + 1
   ...
   >>> main()
   ('Hi, Alice!', 1)
   Counter is 0
   ('Hi, Bob!', 1)
   Counter is 0
   

   0., then the output parameter will be set to

   >>> def multiple_return():
   ...     return 1, 2
   ...
   >>> t = multiple_return()
   >>> t  # A tuple
   (1, 2)
   
   >>> # You can unpack the tuple into two variables:
   >>> x, y = multiple_return()
   >>> x
   1
   >>> y
   2
   

   2, and the function will return

   >>> def main():
   ...     counter = 0
   ...     print(greet("Alice", counter))
   ...     print(f"Counter is {counter}")
   ...     print(greet("Bob", counter))
   ...     print(f"Counter is {counter}")
   ...
   >>> def greet(name, counter):
   ...     return f"Hi, {name}!", counter + 1
   ...
   >>> main()
   ('Hi, Alice!', 1)
   Counter is 0
   ('Hi, Bob!', 1)
   Counter is 0
   

   0.

Bạn có thể thấy điều này trong thực tế trong ví dụ sau, cố gắng chuyển đổi một số chuỗi khác nhau:

>>> def main():
...     arg = 4
...     square(arg)
...     print(arg)
...
>>> def square(n):
...     n *= n
...
>>> main()
4

Mã trên, cố gắng chuyển đổi các chuỗi được định dạng khác nhau thành số nguyên thông qua

>>> def main():
...     counter = 0
...     print(greet("Alice", counter))
...     print(f"Counter is {counter}")
...     print(greet("Bob", counter))
...     print(f"Counter is {counter}")
...
>>> def greet(name, counter):
...     return f"Hi, {name}!", counter + 1
...
>>> main()
('Hi, Alice!', 1)
Counter is 0
('Hi, Bob!', 1)
Counter is 0

>>> def main():
...     arg = 4
...     square(arg)
...     print(arg)
...
>>> def square(n):
...     n *= n
...
>>> main()
4

Để thực hiện một chức năng tương tự trong Python, bạn có thể sử dụng nhiều giá trị trả về như bạn đã thấy trước đây:

>>> def main():
...     arg = 4
...     square(arg)
...     print(arg)
...
>>> def square(n):
...     n *= n
...
>>> main()
4

>>> def main():
...     counter = 0
...     print(greet("Alice", counter))
...     print(f"Counter is {counter}")
...     print(greet("Bob", counter))
...     print(f"Counter is {counter}")
...
>>> def greet(name, counter):
...     return f"Hi, {name}!", counter + 1
...
>>> main()
('Hi, Alice!', 1)
Counter is 0
('Hi, Bob!', 1)
Counter is 0

>>> def main():
...     counter = 0
...     print(greet("Alice", counter))
...     print(f"Counter is {counter}")
...     print(greet("Bob", counter))
...     print(f"Counter is {counter}")
...
>>> def greet(name, counter):
...     return f"Hi, {name}!", counter + 1
...
>>> main()
('Hi, Alice!', 1)
Counter is 0
('Hi, Bob!', 1)
Counter is 0

Tuy nhiên, sử dụng chức năng này là một chút lộn xộn vì bạn cần giải nén các giá trị trả về với mỗi cuộc gọi. Điều này có nghĩa là bạn có thể sử dụng chức năng trong câu lệnh

>>> def main():
...     counter = 0
...     print(greet("Alice", counter))
...     print(f"Counter is {counter}")
...     print(greet("Bob", counter))
...     print(f"Counter is {counter}")
...
>>> def greet(name, counter):
...     return f"Hi, {name}!", counter + 1
...
>>> main()
('Hi, Alice!', 1)
Counter is 0
('Hi, Bob!', 1)
Counter is 0

>>>

>>> def main():
...     arg = 4
...     square(arg)
...     print(arg)
...
>>> def square(n):
...     n *= n
...
>>> main()
4

Mặc dù nó thường hoạt động bằng cách trả về nhiều giá trị,

>>> def main():
...     counter = 0
...     print(greet("Alice", counter))
...     print(f"Counter is {counter}")
...     print(greet("Bob", counter))
...     print(f"Counter is {counter}")
...
>>> def greet(name, counter):
...     return f"Hi, {name}!", counter + 1
...
>>> main()
('Hi, Alice!', 1)
Counter is 0
('Hi, Bob!', 1)
Counter is 0

Bạn có thể tận dụng tính linh hoạt của Python và đơn giản hóa chức năng để trả về một giá trị duy nhất của các loại khác nhau tùy thuộc vào việc chuyển đổi có thành công hay không:

>>> def main():
...     arg = 4
...     square(arg)
...     print(arg)
...
>>> def square(n):
...     n *= n
...
>>> main()
4

Với khả năng các chức năng Python trả về các loại dữ liệu khác nhau, giờ đây bạn có thể sử dụng chức năng này trong một câu lệnh có điều kiện. Nhưng bằng cách nào? Bạn sẽ phải gọi hàm trước, gán giá trị trả về của nó và sau đó kiểm tra giá trị?

Bằng cách tận dụng tính linh hoạt của Python, trong các loại đối tượng, cũng như các biểu thức gán mới trong Python 3.8, bạn có thể gọi hàm đơn giản này trong câu lệnh

>>> def main():
...     counter = 0
...     print(greet("Alice", counter))
...     print(f"Counter is {counter}")
...     print(greet("Bob", counter))
...     print(f"Counter is {counter}")
...
>>> def greet(name, counter):
...     return f"Hi, {name}!", counter + 1
...
>>> main()
('Hi, Alice!', 1)
Counter is 0
('Hi, Bob!', 1)
Counter is 0

>>>

>>> def main():
...     arg = 4
...     square(arg)
...     print(arg)
...
>>> def square(n):
...     n *= n
...
>>> main()
4

Mặc dù nó thường hoạt động bằng cách trả về nhiều giá trị,

>>> def main():
...     counter = 0
...     print(greet("Alice", counter))
...     print(f"Counter is {counter}")
...     print(greet("Bob", counter))
...     print(f"Counter is {counter}")
...
>>> def greet(name, counter):
...     return f"Hi, {name}!", counter + 1
...
>>> main()
('Hi, Alice!', 1)
Counter is 0
('Hi, Bob!', 1)
Counter is 0

Bạn có thể tận dụng tính linh hoạt của Python và đơn giản hóa chức năng để trả về một giá trị duy nhất của các loại khác nhau tùy thuộc vào việc chuyển đổi có thành công hay không:assigning return values when using the assignment expression operator(

>>> def main():
...     counter = 0
...     print(greet("Alice", counter))
...     print(f"Counter is {counter}")
...     print(greet("Bob", counter))
...     print(f"Counter is {counter}")
...
>>> def greet(name, counter):
...     return f"Hi, {name}!", counter + 1
...
>>> main()
('Hi, Alice!', 1)
Counter is 0
('Hi, Bob!', 1)
Counter is 0

Với khả năng các chức năng Python trả về các loại dữ liệu khác nhau, giờ đây bạn có thể sử dụng chức năng này trong một câu lệnh có điều kiện. Nhưng bằng cách nào? Bạn sẽ phải gọi hàm trước, gán giá trị trả về của nó và sau đó kiểm tra giá trị?

Cho đến nay, bạn đã học được những gì vượt qua bằng cách tham khảo có nghĩa là, nó khác với việc vượt qua giá trị như thế nào và cách tiếp cận của Python khác với cả hai. Bây giờ bạn đã sẵn sàng để xem xét kỹ hơn về cách Python xử lý các đối số chức năng!

Vượt qua các cuộc tranh luận trong Python

• Python chuyển các đối số bằng cách chuyển nhượng. Đó là, khi bạn gọi hàm python, mỗi đối số hàm trở thành một biến mà giá trị truyền được gán.
• Do đó, bạn có thể tìm hiểu các chi tiết quan trọng về cách Python xử lý các đối số chức năng bằng cách hiểu cách thức cơ chế gán hoạt động, ngay cả các chức năng bên ngoài.

Hiểu nhiệm vụ trong Python

Tham khảo ngôn ngữ Python cho các câu lệnh gán cung cấp các chi tiết sau:

1. Nếu mục tiêu gán là một định danh hoặc tên biến, thì tên này bị ràng buộc với đối tượng. Ví dụ, trong

   >>> def main():
   ...     counter = 0
   ...     print(greet("Alice", counter))
   ...     print(f"Counter is {counter}")
   ...     print(greet("Bob", counter))
   ...     print(f"Counter is {counter}")
   ...
   >>> def greet(name, counter):
   ...     return f"Hi, {name}!", counter + 1
   ...
   >>> main()
   ('Hi, Alice!', 1)
   Counter is 0
   ('Hi, Bob!', 1)
   Counter is 0
   

   9,

   using System;
   
   class Program
   {
       static void Main(string[] args)
       {
           int counter = 0;
   
           // Passing by reference.
           // The value of counter in Main is changed.
           Console.WriteLine(greet("Alice", ref counter));
           Console.WriteLine("Counter is {0}", counter);
           Console.WriteLine(greet("Bob", ref counter));
           Console.WriteLine("Counter is {0}", counter);
           // Output:
           // Hi, Alice!
           // Counter is 1
           // Hi, Bob!
           // Counter is 2
       }
   
       static string greet(string name, ref int counter)
       {
           string greeting = "Hi, " + name + "!";
           counter++;
           return greeting;
       }
   }
   

   4 là tên và

   >>> def main():
   ...     counter = 0
   ...     greeting, counter = greet("Alice", counter)
   ...     print(f"{greeting}\nCounter is {counter}")
   ...     greeting, counter = greet("Bob", counter)
   ...     print(f"{greeting}\nCounter is {counter}")
   ...
   >>> def greet(name, counter):
   ...     return f"Hi, {name}!", counter + 1
   ...
   >>> main()
   Hi, Alice!
   Counter is 1
   Hi, Bob!
   Counter is 2
   

   1 là đối tượng.
2. Nếu tên đã bị ràng buộc với một đối tượng riêng biệt, thì nó sẽ liên kết lại với đối tượng mới. Ví dụ: nếu

   using System;
   
   class Program
   {
       static void Main(string[] args)
       {
           int counter = 0;
   
           // Passing by reference.
           // The value of counter in Main is changed.
           Console.WriteLine(greet("Alice", ref counter));
           Console.WriteLine("Counter is {0}", counter);
           Console.WriteLine(greet("Bob", ref counter));
           Console.WriteLine("Counter is {0}", counter);
           // Output:
           // Hi, Alice!
           // Counter is 1
           // Hi, Bob!
           // Counter is 2
       }
   
       static string greet(string name, ref int counter)
       {
           string greeting = "Hi, " + name + "!";
           counter++;
           return greeting;
       }
   }
   

   4 đã

   >>> def main():
   ...     counter = 0
   ...     greeting, counter = greet("Alice", counter)
   ...     print(f"{greeting}\nCounter is {counter}")
   ...     greeting, counter = greet("Bob", counter)
   ...     print(f"{greeting}\nCounter is {counter}")
   ...
   >>> def greet(name, counter):
   ...     return f"Hi, {name}!", counter + 1
   ...
   >>> main()
   Hi, Alice!
   Counter is 1
   Hi, Bob!
   Counter is 2
   

   1 và bạn phát hành

   >>> def main():
   ...     counter = 0
   ...     greeting, counter = greet("Alice", counter)
   ...     print(f"{greeting}\nCounter is {counter}")
   ...     greeting, counter = greet("Bob", counter)
   ...     print(f"{greeting}\nCounter is {counter}")
   ...
   >>> def greet(name, counter):
   ...     return f"Hi, {name}!", counter + 1
   ...
   >>> main()
   Hi, Alice!
   Counter is 1
   Hi, Bob!
   Counter is 2
   

   4, thì tên biến

   using System;
   
   class Program
   {
       static void Main(string[] args)
       {
           int counter = 0;
   
           // Passing by reference.
           // The value of counter in Main is changed.
           Console.WriteLine(greet("Alice", ref counter));
           Console.WriteLine("Counter is {0}", counter);
           Console.WriteLine(greet("Bob", ref counter));
           Console.WriteLine("Counter is {0}", counter);
           // Output:
           // Hi, Alice!
           // Counter is 1
           // Hi, Bob!
           // Counter is 2
       }
   
       static string greet(string name, ref int counter)
       {
           string greeting = "Hi, " + name + "!";
           counter++;
           return greeting;
       }
   }
   

   4 được giới hạn lại thành

   >>> def main():
   ...     counter = 0
   ...     greeting, counter = greet("Alice", counter)
   ...     print(f"{greeting}\nCounter is {counter}")
   ...     greeting, counter = greet("Bob", counter)
   ...     print(f"{greeting}\nCounter is {counter}")
   ...
   >>> def greet(name, counter):
   ...     return f"Hi, {name}!", counter + 1
   ...
   >>> main()
   Hi, Alice!
   Counter is 1
   Hi, Bob!
   Counter is 2
   

   6.
3. Tất cả các đối tượng Python được thực hiện trong một cấu trúc cụ thể. Một trong những thuộc tính của cấu trúc này là một bộ đếm theo dõi số lượng tên đã bị ràng buộc với đối tượng này.

Hãy để ví dụ về ví dụ

>>> def main():
...     counter = 0
...     print(greet("Alice", counter))
...     print(f"Counter is {counter}")
...     print(greet("Bob", counter))
...     print(f"Counter is {counter}")
...
>>> def greet(name, counter):
...     return f"Hi, {name}!", counter + 1
...
>>> main()
('Hi, Alice!', 1)
Counter is 0
('Hi, Bob!', 1)
Counter is 0

1. Nếu một đối tượng đại diện cho giá trị

   >>> def main():
   ...     counter = 0
   ...     greeting, counter = greet("Alice", counter)
   ...     print(f"{greeting}\nCounter is {counter}")
   ...     greeting, counter = greet("Bob", counter)
   ...     print(f"{greeting}\nCounter is {counter}")
   ...
   >>> def greet(name, counter):
   ...     return f"Hi, {name}!", counter + 1
   ...
   >>> main()
   Hi, Alice!
   Counter is 1
   Hi, Bob!
   Counter is 2
   

   1 đã tồn tại, thì nó đã được truy xuất. Nếu không, nó đã tạo ra.
2. Bộ đếm tham chiếu của đối tượng này được tăng lên.
3. Một mục được thêm vào không gian tên hiện tại để liên kết định danh

   using System;
   
   class Program
   {
       static void Main(string[] args)
       {
           int counter = 0;
   
           // Passing by reference.
           // The value of counter in Main is changed.
           Console.WriteLine(greet("Alice", ref counter));
           Console.WriteLine("Counter is {0}", counter);
           Console.WriteLine(greet("Bob", ref counter));
           Console.WriteLine("Counter is {0}", counter);
           // Output:
           // Hi, Alice!
           // Counter is 1
           // Hi, Bob!
           // Counter is 2
       }
   
       static string greet(string name, ref int counter)
       {
           string greeting = "Hi, " + name + "!";
           counter++;
           return greeting;
       }
   }
   

   4 với đối tượng đại diện cho

   >>> def main():
   ...     counter = 0
   ...     greeting, counter = greet("Alice", counter)
   ...     print(f"{greeting}\nCounter is {counter}")
   ...     greeting, counter = greet("Bob", counter)
   ...     print(f"{greeting}\nCounter is {counter}")
   ...
   >>> def greet(name, counter):
   ...     return f"Hi, {name}!", counter + 1
   ...
   >>> main()
   Hi, Alice!
   Counter is 1
   Hi, Bob!
   Counter is 2
   

   1. Mục nhập này trên thực tế là một cặp giá trị khóa được lưu trữ trong một từ điển! Một đại diện của từ điển đó được trả lại bởi

   public static bool TryParse (string s, out int result);
   

   1 hoặc

   public static bool TryParse (string s, out int result);
   

   2.

Bây giờ ở đây, những gì xảy ra nếu bạn phân công lại

using System;

class Program
{
    static void Main(string[] args)
    {
        int counter = 0;

        // Passing by reference.
        // The value of counter in Main is changed.
        Console.WriteLine(greet("Alice", ref counter));
        Console.WriteLine("Counter is {0}", counter);
        Console.WriteLine(greet("Bob", ref counter));
        Console.WriteLine("Counter is {0}", counter);
        // Output:
        // Hi, Alice!
        // Counter is 1
        // Hi, Bob!
        // Counter is 2
    }

    static string greet(string name, ref int counter)
    {
        string greeting = "Hi, " + name + "!";
        counter++;
        return greeting;
    }
}

>>> def main():
...     arg = 4
...     square(arg)
...     print(arg)
...
>>> def square(n):
...     n *= n
...
>>> main()
4

Bộ đếm tham chiếu của đối tượng đại diện cho

>>> def main():
...     counter = 0
...     greeting, counter = greet("Alice", counter)
...     print(f"{greeting}\nCounter is {counter}")
...     greeting, counter = greet("Bob", counter)
...     print(f"{greeting}\nCounter is {counter}")
...
>>> def greet(name, counter):
...     return f"Hi, {name}!", counter + 1
...
>>> main()
Hi, Alice!
Counter is 1
Hi, Bob!
Counter is 2