Hướng dẫn are ints passed by reference in python? - int có được truyền bằng tham chiếu trong python không?

Question

Các số nguyên là bất biến trong Python và một khi chúng được tạo ra, chúng tôi không thể thay đổi giá trị của chúng bằng cách sử dụng toán tử gán thành một biến, chúng tôi sẽ chỉ ra một số địa chỉ khác không phải là địa chỉ trước đó.immutable in python and once they are created we cannot change their value by using assignment operator to a variable we are making it to point to some other address not the previous address.

Nội dung chính Show

Xác định vượt qua theo tham chiếu
Tương phản vượt qua bằng cách tham chiếu và vượt qua giá trị
Sử dụng các cấu trúc tham chiếu vượt qua
Tránh các đối tượng trùng lặp
Trả về nhiều giá trị
Tạo các chức năng đa hoàn trả có điều kiện
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): ... counter += 1 ... return f"Hi, {name}!" ... >>> main() Hi, Alice! Counter is 0 Hi, Bob! Counter is 0 6 có điều kiện và nhận giá trị trả về nếu kiểm tra vượt qua:
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!
Khám phá các đối số chức năng
Bằng cách kiểm tra các không gian tên và số lượng tham chiếu bên trong các hàm, bạn có thể thấy rằng các đối số chức năng hoạt động chính xác giống như các bài tập: Python tạo các ràng buộc trong hàm tên tên cục bộ giữa các định danh và đối tượng Python đại diện cho các giá trị đối số. Mỗi ràng buộc này sẽ tăng bộ đếm tham chiếu đối tượng.
Các đầu ra tập lệnh trên được tính tham chiếu cho #var is an instance of dictionary type def change(var,key,new_value): var[key]=new_value var =dict() var['a']=33 change(var,'a',2625) print(var['a']) 04 đầu tiên bên ngoài, sau đó bên trong #var is an instance of dictionary type def change(var,key,new_value): var[key]=new_value var =dict() var['a']=33 change(var,'a',2625) print(var['a']) 05, cho thấy mức tăng số lượng tham chiếu không phải một, mà là hai!
Các biến miễn phí, dường như không liên quan đến bất cứ điều gì
Thực hành tốt nhất: Sử dụng từ điển và danh sách
Sự kết luận
Python có vượt qua tham chiếu hay theo giá trị không?
Các số được truyền theo giá trị trong Python?
Làm thế nào để INT hoạt động trong Python?
Các mảng Python có được thông qua bởi tham chiếu không?

Trong Python, một hàm có thể trả về nhiều giá trị, chúng ta có thể sử dụng nó:return multiple values we can make use of it:

def swap(a,b):
    return b,a

a,b=22,55
a,b=swap(a,b)
print(a,b)

Để thay đổi tham chiếu, một biến là chỉ ra chúng ta có thể bọc các loại dữ liệu bất biến (int, long, float, phức tạp, str, byte, truple, frozenset) bên trong các loại dữ liệu có thể thay đổi (bytearray, danh sách, tập hợp, dict).int, long, float, complex, str, bytes, truple, frozenset) inside of mutable data types (bytearray, list, set, dict).

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

Xem bây giờ hướng dẫn này có một khóa học video liên quan được tạo bởi nhóm Python thực sự. Xem cùng với hướng dẫn bằng văn bản để hiểu sâu hơn về sự hiểu biết của bạn: vượt qua tham chiếu trong Python: Thực tiễn tốt nhất This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Pass by Reference in Python: Best Practices

Sau khi đạt được sự quen thuộc với Python, bạn có thể nhận thấy các trường hợp trong đó các chức năng của bạn không sửa đổi các đối số như bạn có thể mong đợi, đặc biệt là nếu bạn quen thuộc với các ngôn ngữ lập trình khác. Một số ngôn ngữ xử lý các đối số chức năng như các tham chiếu đến các biến hiện có, được gọi là vượt qua bởi tham chiếu. Các ngôn ngữ khác xử lý chúng là giá trị độc lập, một cách tiếp cận được gọi là vượt qua giá trị.references to existing variables, which is known as pass by reference. Other languages handle them as independent values, an approach known as pass by value.

Nếu bạn là một lập trình viên Python trung gian, người muốn hiểu cách xử lý các đối số chức năng đặc biệt của Python, thì hướng dẫn này là dành cho bạn. Bạn sẽ thực hiện các trường hợp sử dụng thực sự của các cấu trúc ngang qua trong Python và tìm hiểu một số thực tiễn tốt nhất để tránh những cạm bẫy với các đối số chức năng của bạn.

Trong hướng dẫn này, bạn sẽ học:

Ý nghĩa của việc vượt qua tham chiếu và lý do tại sao bạn muốn làm như vậypass by reference and why you’d want to do so
Làm thế nào vượt qua bởi tham chiếu khác với cả hai vượt qua giá trị và cách tiếp cận độc đáo của Pythonpassing by value and Python’s unique approach
Cách các đối số chức năng hoạt động trong Pythonfunction arguments behave in Python
Cách bạn có thể sử dụng một số loại có thể thay đổi để vượt qua tham chiếu trong Pythonmutable types to pass by reference in Python
Thực tiễn tốt nhất là gì để sao chép vượt qua bằng cách tham khảo trong Pythonbest practices are for replicating pass by reference in Python

Xác định vượt qua theo tham chiếu

Trước khi bạn đi sâu vào các chi tiết kỹ thuật của việc truyền qua tài liệu tham khảo, nó rất hữu ích để xem xét kỹ hơn thuật ngữ này bằng cách chia nó thành các thành phần:

Pass có nghĩa là cung cấp một đối số cho một chức năng. means to provide an argument to a function.
Bằng cách tham khảo có nghĩa là đối số mà bạn chuyển đến hàm là một tham chiếu đến một biến đã tồn tại trong bộ nhớ thay vì một bản sao độc lập của biến đó. means that the argument you’re passing to the function is a reference to a variable that already exists in memory rather than an independent copy of that variable.

Vì bạn đã cung cấp cho chức năng một tham chiếu đến một biến hiện có, tất cả các hoạt động được thực hiện trên tài liệu tham khảo này sẽ ảnh hưởng trực tiếp đến biến mà nó đề cập đến. Hãy cùng xem xét một số ví dụ về cách thức hoạt động trong thực tế.

Dưới đây, bạn sẽ thấy cách truyền các biến bằng cách tham chiếu trong C#. Lưu ý việc sử dụng từ khóa

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

4 trong các dòng được tô sáng:

using System;

// Source:
// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/passing-parameters
class Program
{
    static void Main(string[] args)
    {
        int arg;

        // Passing by reference.
        // The value of arg in Main is changed.
        arg = 4;
        squareRef(ref arg);
        Console.WriteLine(arg);
        // Output: 16
    }

    static void squareRef(ref int refParameter)
    {
        refParameter *= refParameter;
    }
}

Như bạn có thể thấy,

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

5 của

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

6 phải được khai báo với từ khóa

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

4 và bạn cũng phải sử dụng từ khóa khi gọi hàm. Sau đó, đối số sẽ được chuyển qua bằng cách tham chiếu và có thể được sửa đổi tại chỗ.

Python không có từ khóa

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

4 hoặc bất cứ điều gì tương đương với nó. Nếu bạn cố gắng sao chép ví dụ trên càng gần càng tốt trong Python, thì bạn sẽ thấy các kết quả khác nhau:

>>>

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

Trong trường hợp này, biến

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

9 không bị thay đổi tại chỗ. Có vẻ như Python coi đối số được cung cấp của bạn là một giá trị độc lập hơn là một tham chiếu đến một biến hiện có. Điều này có nghĩa là Python chuyển các đối số theo giá trị chứ không phải bằng tham chiếu?

Không hẳn. Python chuyển các đối số không bằng cách tham chiếu cũng như giá trị, mà bằng cách gán. Dưới đây, bạn sẽ nhanh chóng khám phá các chi tiết về việc chuyển bằng giá trị và vượt qua bằng cách tham khảo trước khi xem xét kỹ hơn theo cách tiếp cận của Python. Sau đó, bạn sẽ đi qua một số thực tiễn tốt nhất để đạt được sự tương đương của việc vượt qua bằng cách tham khảo trong Python.by assignment. Below, you’ll quickly explore the details of passing by value and passing by reference before looking more closely at Python’s approach. After that, you’ll walk through some best practices for achieving the equivalent of passing by reference in Python.

Tương phản vượt qua bằng cách tham chiếu và vượt qua giá trị

Khi bạn vượt qua các đối số chức năng bằng tham chiếu, các đối số đó chỉ tham khảo các giá trị hiện có. Ngược lại, khi bạn vượt qua các đối số theo giá trị, những đối số đó trở thành bản sao độc lập của các giá trị ban đầu.

Hãy để xem lại ví dụ C#, lần này mà không cần sử dụng từ khóa

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

4. Điều này sẽ khiến chương trình sử dụng hành vi mặc định chuyển bằng giá trị:

using System;

// Source:
// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/passing-parameters
class Program
{
    static void Main(string[] args)
    {
        int arg;

        // Passing by value.
        // The value of arg in Main is not changed.
        arg = 4;
        squareVal(arg);
        Console.WriteLine(arg);
        // Output: 4
    }

    static void squareVal(int valParameter)
    {
        valParameter *= valParameter;
    }
}

Ở đây, bạn có thể thấy rằng

using System;

// Source:
// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/passing-parameters
class Program
{
    static void Main(string[] args)
    {
        int arg;

        // Passing by value.
        // The value of arg in Main is not changed.
        arg = 4;
        squareVal(arg);
        Console.WriteLine(arg);
        // Output: 4
    }

    static void squareVal(int valParameter)
    {
        valParameter *= valParameter;
    }
}

1 không sửa đổi biến ban đầu. Thay vào đó,

using System;

// Source:
// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/passing-parameters
class Program
{
    static void Main(string[] args)
    {
        int arg;

        // Passing by value.
        // The value of arg in Main is not changed.
        arg = 4;
        squareVal(arg);
        Console.WriteLine(arg);
        // Output: 4
    }

    static void squareVal(int valParameter)
    {
        valParameter *= valParameter;
    }
}

2 là một bản sao độc lập của biến ban đầu

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

9. Mặc dù điều đó phù hợp với hành vi mà bạn sẽ thấy trong Python, hãy nhớ rằng Python không chính xác vượt qua giá trị. Hãy để chứng minh điều đó.

Python sườn tích hợp

using System;

// Source:
// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/passing-parameters
class Program
{
    static void Main(string[] args)
    {
        int arg;

        // Passing by value.
        // The value of arg in Main is not changed.
        arg = 4;
        squareVal(arg);
        Console.WriteLine(arg);
        // Output: 4
    }

    static void squareVal(int valParameter)
    {
        valParameter *= valParameter;
    }
}

4 trả về một số nguyên đại diện cho địa chỉ bộ nhớ của đối tượng mong muốn. Sử dụng

using System;

// Source:
// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/passing-parameters
class Program
{
    static void Main(string[] args)
    {
        int arg;

        // Passing by value.
        // The value of arg in Main is not changed.
        arg = 4;
        squareVal(arg);
        Console.WriteLine(arg);
        // Output: 4
    }

    static void squareVal(int valParameter)
    {
        valParameter *= valParameter;
    }
}

4, bạn có thể xác minh các xác nhận sau:

Các đối số chức năng ban đầu đề cập đến cùng một địa chỉ với các biến ban đầu của chúng.
Việc chỉ định lại đối số trong hàm cung cấp cho nó một địa chỉ mới trong khi biến ban đầu vẫn chưa được sửa đổi.

Trong ví dụ dưới đây, lưu ý rằng địa chỉ của

using System;

// Source:
// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/passing-parameters
class Program
{
    static void Main(string[] args)
    {
        int arg;

        // Passing by value.
        // The value of arg in Main is not changed.
        arg = 4;
        squareVal(arg);
        Console.WriteLine(arg);
        // Output: 4
    }

    static void squareVal(int valParameter)
    {
        valParameter *= valParameter;
    }
}

6 ban đầu khớp với

using System;

// Source:
// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/passing-parameters
class Program
{
    static void Main(string[] args)
    {
        int arg;

        // Passing by value.
        // The value of arg in Main is not changed.
        arg = 4;
        squareVal(arg);
        Console.WriteLine(arg);
        // Output: 4
    }

    static void squareVal(int valParameter)
    {
        valParameter *= valParameter;
    }
}

7 nhưng thay đổi sau khi phân công lại, trong khi địa chỉ của

using System;

// Source:
// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/passing-parameters
class Program
{
    static void Main(string[] args)
    {
        int arg;

        // Passing by value.
        // The value of arg in Main is not changed.
        arg = 4;
        squareVal(arg);
        Console.WriteLine(arg);
        // Output: 4
    }

    static void squareVal(int valParameter)
    {
        valParameter *= valParameter;
    }
}

7 không bao giờ thay đổi:

>>>

>>> def main():
...     n = 9001
...     print(f"Initial address of n: {id(n)}")
...     increment(n)
...     print(f"  Final address of n: {id(n)}")
...
>>> def increment(x):
...     print(f"Initial address of x: {id(x)}")
...     x += 1
...     print(f"  Final address of x: {id(x)}")
...
>>> main()
Initial address of n: 140562586057840
Initial address of x: 140562586057840
  Final address of x: 140562586057968
  Final address of n: 140562586057840

Thực tế là các địa chỉ ban đầu của

using System;

// Source:
// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/passing-parameters
class Program
{
    static void Main(string[] args)
    {
        int arg;

        // Passing by value.
        // The value of arg in Main is not changed.
        arg = 4;
        squareVal(arg);
        Console.WriteLine(arg);
        // Output: 4
    }

    static void squareVal(int valParameter)
    {
        valParameter *= valParameter;
    }
}

7 và

using System;

// Source:
// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/passing-parameters
class Program
{
    static void Main(string[] args)
    {
        int arg;

        // Passing by value.
        // The value of arg in Main is not changed.
        arg = 4;
        squareVal(arg);
        Console.WriteLine(arg);
        // Output: 4
    }

    static void squareVal(int valParameter)
    {
        valParameter *= valParameter;
    }
}

6 là như nhau khi bạn gọi

>>> def main():
...     n = 9001
...     print(f"Initial address of n: {id(n)}")
...     increment(n)
...     print(f"  Final address of n: {id(n)}")
...
>>> def increment(x):
...     print(f"Initial address of x: {id(x)}")
...     x += 1
...     print(f"  Final address of x: {id(x)}")
...
>>> main()
Initial address of n: 140562586057840
Initial address of x: 140562586057840
  Final address of x: 140562586057968
  Final address of n: 140562586057840

1 chứng minh rằng đối số

using System;

// Source:
// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/passing-parameters
class Program
{
    static void Main(string[] args)
    {
        int arg;

        // Passing by value.
        // The value of arg in Main is not changed.
        arg = 4;
        squareVal(arg);
        Console.WriteLine(arg);
        // Output: 4
    }

    static void squareVal(int valParameter)
    {
        valParameter *= valParameter;
    }
}

6 không được truyền bởi giá trị. Mặt khác,

using System;

// Source:
// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/passing-parameters
class Program
{
    static void Main(string[] args)
    {
        int arg;

        // Passing by value.
        // The value of arg in Main is not changed.
        arg = 4;
        squareVal(arg);
        Console.WriteLine(arg);
        // Output: 4
    }

    static void squareVal(int valParameter)
    {
        valParameter *= valParameter;
    }
}

7 và

using System;

// Source:
// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/passing-parameters
class Program
{
    static void Main(string[] args)
    {
        int arg;

        // Passing by value.
        // The value of arg in Main is not changed.
        arg = 4;
        squareVal(arg);
        Console.WriteLine(arg);
        // Output: 4
    }

    static void squareVal(int valParameter)
    {
        valParameter *= valParameter;
    }
}

6 sẽ có địa chỉ bộ nhớ riêng biệt.

Trước khi bạn tìm hiểu các chi tiết về cách Python xử lý các đối số, hãy để Lôi xem xét một số trường hợp sử dụng thực tế để đi qua bằng cách tham khảo.

Sử dụng các cấu trúc tham chiếu vượt qua

Vượt qua các biến bằng tham chiếu là một trong một số chiến lược bạn có thể sử dụng để thực hiện các mẫu lập trình nhất định. Mặc dù nó hiếm khi cần thiết, nhưng đi qua tham chiếu có thể là một công cụ hữu ích.

Trong phần này, bạn sẽ xem xét ba trong số các mẫu phổ biến nhất mà đi qua bằng cách tham khảo là một cách tiếp cận thực tế. Sau đó, bạn sẽ xem cách bạn có thể thực hiện từng mẫu này với Python.

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():
...     n = 9001
...     print(f"Initial address of n: {id(n)}")
...     increment(n)
...     print(f"  Final address of n: {id(n)}")
...
>>> def increment(x):
...     print(f"Initial address of x: {id(x)}")
...     x += 1
...     print(f"  Final address of x: {id(x)}")
...
>>> main()
Initial address of n: 140562586057840
Initial address of x: 140562586057840
  Final address of x: 140562586057968
  Final address of n: 140562586057840

5 trả về một chuỗi lời chào và cũng sửa đổi giá trị của

>>> def main():
...     n = 9001
...     print(f"Initial address of n: {id(n)}")
...     increment(n)
...     print(f"  Final address of n: {id(n)}")
...
>>> def increment(x):
...     print(f"Initial address of x: {id(x)}")
...     x += 1
...     print(f"  Final address of x: {id(x)}")
...
>>> main()
Initial address of n: 140562586057840
Initial address of x: 140562586057840
  Final address of x: 140562586057968
  Final address of n: 140562586057840

6. Bây giờ hãy cố gắng tái tạo điều này càng gần càng tốt trong Python:

>>>

>>> 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():
...     n = 9001
...     print(f"Initial address of n: {id(n)}")
...     increment(n)
...     print(f"  Final address of n: {id(n)}")
...
>>> def increment(x):
...     print(f"Initial address of x: {id(x)}")
...     x += 1
...     print(f"  Final address of x: {id(x)}")
...
>>> main()
Initial address of n: 140562586057840
Initial address of x: 140562586057840
  Final address of x: 140562586057968
  Final address of n: 140562586057840

6 được tăng lên trong ví dụ trên bởi vì, như bạn đã học trước đây, Python không có cách nào để vượt qua các giá trị bằng cách tham khảo. Vậy làm thế nào bạn có thể đạt được kết quả tương tự như bạn đã làm với C#?

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():
...     n = 9001
...     print(f"Initial address of n: {id(n)}")
...     increment(n)
...     print(f"  Final address of n: {id(n)}")
...
>>> def increment(x):
...     print(f"Initial address of x: {id(x)}")
...     x += 1
...     print(f"  Final address of x: {id(x)}")
...
>>> main()
Initial address of n: 140562586057840
Initial address of x: 140562586057840
  Final address of x: 140562586057968
  Final address of n: 140562586057840

8 theo sau là các giá trị hoặc biến được phân tách bằng dấu phẩy.

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

>>> def main():
...     n = 9001
...     print(f"Initial address of n: {id(n)}")
...     increment(n)
...     print(f"  Final address of n: {id(n)}")
...
>>> def increment(x):
...     print(f"Initial address of x: {id(x)}")
...     x += 1
...     print(f"  Final address of x: {id(x)}")
...
>>> main()
Initial address of n: 140562586057840
Initial address of x: 140562586057840
  Final address of x: 140562586057968
  Final address of n: 140562586057840

8 trong

>>> def main():
...     n = 9001
...     print(f"Initial address of n: {id(n)}")
...     increment(n)
...     print(f"  Final address of n: {id(n)}")
...
>>> def increment(x):
...     print(f"Initial address of x: {id(x)}")
...     x += 1
...     print(f"  Final address of x: {id(x)}")
...
>>> main()
Initial address of n: 140562586057840
Initial address of x: 140562586057840
  Final address of x: 140562586057968
  Final address of n: 140562586057840

5 từ mã Python trước đó của bạn để trả về cả lời chào và một bộ đếm:

>>>

>>> 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():
...     n = 9001
...     print(f"Initial address of n: {id(n)}")
...     increment(n)
...     print(f"  Final address of n: {id(n)}")
...
>>> def increment(x):
...     print(f"Initial address of x: {id(x)}")
...     x += 1
...     print(f"  Final address of x: {id(x)}")
...
>>> main()
Initial address of n: 140562586057840
Initial address of x: 140562586057840
  Final address of x: 140562586057968
  Final address of n: 140562586057840

5 hiện trả về nhiều giá trị, nhưng chúng được in dưới dạng

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

2, đó là ý định của bạn. Hơn nữa, biến

>>> def main():
...     n = 9001
...     print(f"Initial address of n: {id(n)}")
...     increment(n)
...     print(f"  Final address of n: {id(n)}")
...
>>> def increment(x):
...     print(f"Initial address of x: {id(x)}")
...     x += 1
...     print(f"  Final address of x: {id(x)}")
...
>>> main()
Initial address of n: 140562586057840
Initial address of x: 140562586057840
  Final address of x: 140562586057968
  Final address of n: 140562586057840

6 ban đầu vẫn ở mức

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à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():
...     n = 9001
...     print(f"Initial address of n: {id(n)}")
...     increment(n)
...     print(f"  Final address of n: {id(n)}")
...
>>> def increment(x):
...     print(f"Initial address of x: {id(x)}")
...     x += 1
...     print(f"  Final address of x: {id(x)}")
...
>>> main()
Initial address of n: 140562586057840
Initial address of x: 140562586057840
  Final address of x: 140562586057968
  Final address of n: 140562586057840

6 của mình với mỗi cuộc gọi đến

>>> def main():
...     n = 9001
...     print(f"Initial address of n: {id(n)}")
...     increment(n)
...     print(f"  Final address of n: {id(n)}")
...
>>> def increment(x):
...     print(f"Initial address of x: {id(x)}")
...     x += 1
...     print(f"  Final address of x: {id(x)}")
...
>>> main()
Initial address of n: 140562586057840
Initial address of x: 140562586057840
  Final address of x: 140562586057968
  Final address of n: 140562586057840

5:reassign your

>>> def main():
...     n = 9001
...     print(f"Initial address of n: {id(n)}")
...     increment(n)
...     print(f"  Final address of n: {id(n)}")
...
>>> def increment(x):
...     print(f"Initial address of x: {id(x)}")
...     x += 1
...     print(f"  Final address of x: {id(x)}")
...
>>> main()
Initial address of n: 140562586057840
Initial address of x: 140562586057840
  Final address of x: 140562586057968
  Final address of n: 140562586057840

6 variable with each call to

>>> def main():
...     n = 9001
...     print(f"Initial address of n: {id(n)}")
...     increment(n)
...     print(f"  Final address of n: {id(n)}")
...
>>> def increment(x):
...     print(f"Initial address of x: {id(x)}")
...     x += 1
...     print(f"  Final address of x: {id(x)}")
...
>>> main()
Initial address of n: 140562586057840
Initial address of x: 140562586057840
  Final address of x: 140562586057968
  Final address of n: 140562586057840

5:

>>>

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

0

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

>>> def main():
...     n = 9001
...     print(f"Initial address of n: {id(n)}")
...     increment(n)
...     print(f"  Final address of n: {id(n)}")
...
>>> def increment(x):
...     print(f"Initial address of x: {id(x)}")
...     x += 1
...     print(f"  Final address of x: {id(x)}")
...
>>> main()
Initial address of n: 140562586057840
Initial address of x: 140562586057840
  Final address of x: 140562586057968
  Final address of n: 140562586057840

5, bạn có thể thấy kết quả mong muốn!

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:

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

1

Hàm này cố gắng chuyển đổ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;
    }
}

8 thành số nguyên có chữ ký 32 bit bằng cách sử dụng từ khóa

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

9. Có hai kết quả có thể xảy ra:

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 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
0., then the output parameter will be set to the resulting integer, 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):
...     counter += 1
...     return f"Hi, {name}!"
...
>>> main()
Hi, Alice!
Counter is 0
Hi, Bob!
Counter is 0

0.

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
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à 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): ... counter += 1 ... return f"Hi, {name}!" ... >>> main() Hi, Alice! Counter is 0 Hi, Bob! Counter is 0
2., then the output parameter will be set to

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, 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):
...     counter += 1
...     return f"Hi, {name}!"
...
>>> main()
Hi, Alice!
Counter is 0
Hi, Bob!
Counter is 0

2.

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:

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

2

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):
...     counter += 1
...     return f"Hi, {name}!"
...
>>> main()
Hi, Alice!
Counter is 0
Hi, Bob!
Counter is 0

3, xuất ra như sau:

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

3

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

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

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):
...     counter += 1
...     return f"Hi, {name}!"
...
>>> main()
Hi, Alice!
Counter is 0
Hi, Bob!
Counter is 0

4 này trả về hai giá trị. Giá trị đầu tiên cho biết việc chuyển đổi có thành công hay không và lần thứ hai giữ kết quả (hoặc

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

5, trong trường hợp thất bại).

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):
...     counter += 1
...     return f"Hi, {name}!"
...
>>> main()
Hi, Alice!
Counter is 0
Hi, Bob!
Counter is 0

6:

>>>

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

5

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):
...     counter += 1
...     return f"Hi, {name}!"
...
>>> main()
Hi, Alice!
Counter is 0
Hi, Bob!
Counter is 0

4 có thể được sử dụng trong kiểm tra điều kiện. Điều đó có nghĩa là bạn có thêm một số việc phải làm.

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:

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

6

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):
...     counter += 1
...     return f"Hi, {name}!"
...
>>> main()
Hi, Alice!
Counter is 0
Hi, Bob!
Counter is 0

6 có điều kiện và nhận giá trị trả về nếu kiểm tra vượt qua:

>>>

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

7

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):
...     counter += 1
...     return f"Hi, {name}!"
...
>>> main()
Hi, Alice!
Counter is 0
Hi, Bob!
Counter is 0

4 có thể được sử dụng trong kiểm tra điều kiện. Điều đó có nghĩa là bạn có thêm một số việc phải làm.

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

0) and using the return value directly in Python expressions.

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): ... counter += 1 ... return f"Hi, {name}!" ... >>> main() Hi, Alice! Counter is 0 Hi, Bob! Counter is 0 6 có điều kiện và nhận giá trị trả về nếu kiểm tra vượt qua:

Ồ! Phiên bản Python này củ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

4 thậm chí còn mạnh hơn phiên bản C#, cho phép bạn sử dụng nó trong các câu lệnh có điều kiện và trong các biểu thức số học.

Với một chút khéo léo, bạn đã sao chép một mô hình chuyển qua cụ thể và hữu ích mà không thực sự truyền cho các đối số bằng cách tham khảo. Trên thực tế, bạn lại một lần nữa gán các giá trị trả về khi sử dụng toán tử biểu thức gán (________ 80) và sử dụng giá trị trả về trực tiếp trong các biểu thức Python.

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:

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

using System;

// Source:
// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/passing-parameters
class Program
{
    static void Main(string[] args)
    {
        int arg;

        // Passing by value.
        // The value of arg in Main is not changed.
        arg = 4;
        squareVal(arg);
        Console.WriteLine(arg);
        // Output: 4
    }

    static void squareVal(int valParameter)
    {
        valParameter *= valParameter;
    }
}

6 là tên 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

3 là đối tượng.

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;

// Source:
// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/passing-parameters
class Program
{
    static void Main(string[] args)
    {
        int arg;

        // Passing by value.
        // The value of arg in Main is not changed.
        arg = 4;
        squareVal(arg);
        Console.WriteLine(arg);
        // Output: 4
    }

    static void squareVal(int valParameter)
    {
        valParameter *= valParameter;
    }
}

6 đã

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

3 và bạn phát hà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

6, thì tên biến

using System;

// Source:
// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/passing-parameters
class Program
{
    static void Main(string[] args)
    {
        int arg;

        // Passing by value.
        // The value of arg in Main is not changed.
        arg = 4;
        squareVal(arg);
        Console.WriteLine(arg);
        // Output: 4
    }

    static void squareVal(int valParameter)
    {
        valParameter *= valParameter;
    }
}

6 được giới hạn lại 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

8.

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 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 và kiểm tra điều gì xảy ra khi bạn gán giá trị cho một biến mới:

Nếu một đối tượng đại diện cho 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

3 đã tồn tại, thì nó đã được truy xuất. Nếu không, nó đã tạo ra.

Bộ đếm tham chiếu của đối tượng này được tăng lên.

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;

// Source:
// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/passing-parameters
class Program
{
    static void Main(string[] args)
    {
        int arg;

        // Passing by value.
        // The value of arg in Main is not changed.
        arg = 4;
        squareVal(arg);
        Console.WriteLine(arg);
        // Output: 4
    }

    static void squareVal(int valParameter)
    {
        valParameter *= valParameter;
    }
}

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

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

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

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

3 hoặc

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

4.

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

using System;

// Source:
// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/passing-parameters
class Program
{
    static void Main(string[] args)
    {
        int arg;

        // Passing by value.
        // The value of arg in Main is not changed.
        arg = 4;
        squareVal(arg);
        Console.WriteLine(arg);
        // Output: 4
    }

    static void squareVal(int valParameter)
    {
        valParameter *= valParameter;
    }
}

6 thành một giá trị khác:

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

8

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

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

3 bị giảm.

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

9

Bộ đếm tham chiếu của đối tượng đại diện cho giá trị mới được tăng lên.

Từ điển cho không gian tên hiện tại được cập nhật để liên hệ

using System;

// Source:
// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/passing-parameters
class Program
{
    static void Main(string[] args)
    {
        int arg;

        // Passing by value.
        // The value of arg in Main is not changed.
        arg = 4;
        squareVal(arg);
        Console.WriteLine(arg);
        // Output: 4
    }

    static void squareVal(int valParameter)
    {
        valParameter *= valParameter;
    }
}

6 với đối tượng đại diện cho giá trị mới.

Khám phá các đối số chức năng

Đối số chức năng trong Python là các biến cục bộ. Điều đó nghĩa là gì? Địa phương là một trong những phạm vi Python. Các phạm vi này được thể hiện bằng từ điển không gian tên được đề cập trong phần trước. Bạn có thể sử dụng

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

3 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

4 để truy xuất từ điển không gian tên địa phương và toàn cầu, tương ứng.local variables. What does that mean? Local is one of Python’s scopes. These scopes are represented by the namespace dictionaries mentioned in the previous section. You can use

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

3 and

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

4 to retrieve the local and global namespace dictionaries, respectively.

Sau khi thực hiện, mỗi hàm có không gian tên cục bộ riêng:

>>>

using System;

// Source:
// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/passing-parameters
class Program
{
    static void Main(string[] args)
    {
        int arg;

        // Passing by reference.
        // The value of arg in Main is changed.
        arg = 4;
        squareRef(ref arg);
        Console.WriteLine(arg);
        // Output: 16
    }

    static void squareRef(ref int refParameter)
    {
        refParameter *= refParameter;
    }
}

0

Sử dụng

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

3, bạn có thể chứng minh rằng các đối số chức năng trở thành các biến thường xuyên trong không gian tên cục bộ của hàm. Hãy để thêm một đối số,

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

02, vào chức năng:

>>>

using System;

// Source:
// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/passing-parameters
class Program
{
    static void Main(string[] args)
    {
        int arg;

        // Passing by reference.
        // The value of arg in Main is changed.
        arg = 4;
        squareRef(ref arg);
        Console.WriteLine(arg);
        // Output: 16
    }

    static void squareRef(ref int refParameter)
    {
        refParameter *= refParameter;
    }
}

1

Sử dụng

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

3, bạn có thể chứng minh rằng các đối số chức năng trở thành các biến thường xuyên trong không gian tên cục bộ của hàm. Hãy để thêm một đối số,

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

02, vào chức năng:

>>>

using System;

// Source:
// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/passing-parameters
class Program
{
    static void Main(string[] args)
    {
        int arg;

        // Passing by reference.
        // The value of arg in Main is changed.
        arg = 4;
        squareRef(ref arg);
        Console.WriteLine(arg);
        // Output: 16
    }

    static void squareRef(ref int refParameter)
    {
        refParameter *= refParameter;
    }
}

2

Sử dụng

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

3, bạn có thể chứng minh rằng các đối số chức năng trở thành các biến thường xuyên trong không gian tên cục bộ của hàm. Hãy để thêm một đối số,

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

02, vào chức năng:

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

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

8 để hiển thị cách các đối số chức năng tăng bộ đếm tham chiếu cho một đối tượng:

Các đầu ra tập lệnh trên được tính tham chiếu cho

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

04 đầu tiên bên ngoài, sau đó bên trong

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

05, cho thấy mức tăng số lượng tham chiếu không phải một, mà là hai!

Điều đó bởi vì, ngoài chính

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

05, 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):
...     return f"Hi, {name}!", counter + 1
...
>>> main()
('Hi, Alice!', 1)
Counter is 0
('Hi, Bob!', 1)
Counter is 0

8 bên trong

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

05 cũng nhận được

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

02 như một đối số. Điều này đặt

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

02 trong không gian tên địa phương cho

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

8, thêm một tham chiếu bổ sung vào

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

04.

Bằng cách kiểm tra các không gian tên và số lượng tham chiếu bên trong các hàm, bạn có thể thấy rằng các đối số chức năng hoạt động chính xác giống như các bài tập: Python tạo các ràng buộc trong hàm tên tên cục bộ giữa các định danh và đối tượng Python đại diện cho các giá trị đối số. Mỗi ràng buộc này sẽ tăng bộ đếm tham chiếu đối tượng.

Bây giờ bạn có thể thấy Python vượt qua các đối số bằng cách chuyển nhượng!

>>>

using System;

// Source:
// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/passing-parameters
class Program
{
    static void Main(string[] args)
    {
        int arg;

        // Passing by reference.
        // The value of arg in Main is changed.
        arg = 4;
        squareRef(ref arg);
        Console.WriteLine(arg);
        // Output: 16
    }

    static void squareRef(ref int refParameter)
    {
        refParameter *= refParameter;
    }
}

3

Sử dụng

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

3, bạn có thể chứng minh rằng các đối số chức năng trở thành các biến thường xuyên trong không gian tên cục bộ của hàm. Hãy để thêm một đối số,

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

02, vào chức năng:

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

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

8 để hiển thị cách các đối số chức năng tăng bộ đếm tham chiếu cho một đối tượng:

Các đầu ra tập lệnh trên được tính tham chiếu cho

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

04 đầu tiên bên ngoài, sau đó bên trong

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

05, cho thấy mức tăng số lượng tham chiếu không phải một, mà là hai!

Điều đó bởi vì, ngoài chính

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

05, 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):
...     return f"Hi, {name}!", counter + 1
...
>>> main()
('Hi, Alice!', 1)
Counter is 0
('Hi, Bob!', 1)
Counter is 0

8 bên trong

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

05 cũng nhận được

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

02 như một đối số. Điều này đặt

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

02 trong không gian tên địa phương cho

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

8, thêm một tham chiếu bổ sung vào

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

04.

Bằng cách kiểm tra các không gian tên và số lượng tham chiếu bên trong các hàm, bạn có thể thấy rằng các đối số chức năng hoạt động chính xác giống như các bài tập: Python tạo các ràng buộc trong hàm tên tên cục bộ giữa các định danh và đối tượng Python đại diện cho các giá trị đối số. Mỗi ràng buộc này sẽ tăng bộ đếm tham chiếu đối tượng.

Bây giờ bạn có thể thấy Python vượt qua các đối số bằng cách chuyển nhượng!

>>>

using System;

// Source:
// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/passing-parameters
class Program
{
    static void Main(string[] args)
    {
        int arg;

        // Passing by reference.
        // The value of arg in Main is changed.
        arg = 4;
        squareRef(ref arg);
        Console.WriteLine(arg);
        // Output: 16
    }

    static void squareRef(ref int refParameter)
    {
        refParameter *= refParameter;
    }
}

4

Sử dụng

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

3, bạn có thể chứng minh rằng các đối số chức năng trở thành các biến thường xuyên trong không gian tên cục bộ của hàm. Hãy để thêm một đối số,

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

02, vào chức năng:

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

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

8 để hiển thị cách các đối số chức năng tăng bộ đếm tham chiếu cho một đối tượng:

Các đầu ra tập lệnh trên được tính tham chiếu cho #var is an instance of dictionary type def change(var,key,new_value): var[key]=new_value var =dict() var['a']=33 change(var,'a',2625) print(var['a']) 04 đầu tiên bên ngoài, sau đó bên trong #var is an instance of dictionary type def change(var,key,new_value): var[key]=new_value var =dict() var['a']=33 change(var,'a',2625) print(var['a']) 05, cho thấy mức tăng số lượng tham chiếu không phải một, mà là hai!

Điều đó bởi vì, ngoài chính

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

05, 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):
...     return f"Hi, {name}!", counter + 1
...
>>> main()
('Hi, Alice!', 1)
Counter is 0
('Hi, Bob!', 1)
Counter is 0

8 bên trong

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

05 cũng nhận được

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

02 như một đối số. Điều này đặt

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

02 trong không gian tên địa phương cho

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

8, thêm một tham chiếu bổ sung vào

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

04.

Bằng cách kiểm tra các không gian tên và số lượng tham chiếu bên trong các hàm, bạn có thể thấy rằng các đối số chức năng hoạt động chính xác giống như các bài tập: Python tạo các ràng buộc trong hàm tên tên cục bộ giữa các định danh và đối tượng Python đại diện cho các giá trị đối số. Mỗi ràng buộc này sẽ tăng bộ đếm tham chiếu đối tượng.

using System;

// Source:
// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/passing-parameters
class Program
{
    static void Main(string[] args)
    {
        int arg;

        // Passing by reference.
        // The value of arg in Main is changed.
        arg = 4;
        squareRef(ref arg);
        Console.WriteLine(arg);
        // Output: 16
    }

    static void squareRef(ref int refParameter)
    {
        refParameter *= refParameter;
    }
}

5

Bây giờ bạn có thể thấy Python vượt qua các đối số bằng cách chuyển nhượng!

Sao chép vượt qua bằng cách tham khảo với Python

Sau khi kiểm tra các không gian tên trong phần trước, bạn có thể hỏi tại sao

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

13 đã được đề cập như một cách để sửa đổi các biến như thể chúng được thông qua bởi tham chiếu:

using System;

// Source:
// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/passing-parameters
class Program
{
    static void Main(string[] args)
    {
        int arg;

        // Passing by reference.
        // The value of arg in Main is changed.
        arg = 4;
        squareRef(ref arg);
        Console.WriteLine(arg);
        // Output: 16
    }

    static void squareRef(ref int refParameter)
    {
        refParameter *= refParameter;
    }
}

6

Sử dụng câu lệnh

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

13 thường lấy đi sự rõ ràng của mã của bạn. Nó có thể tạo ra một số vấn đề, bao gồm cả những vấn đề sau:

Các biến miễn phí, dường như không liên quan đến bất cứ điều gì

Các chức năng mà không có các đối số rõ ràng cho các biến nói trên

Các chức năng có thể được sử dụng chung với các biến hoặc đối số khác vì chúng dựa vào một biến toàn cầu duy nhất

>>>

using System;

// Source:
// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/passing-parameters
class Program
{
    static void Main(string[] args)
    {
        int arg;

        // Passing by reference.
        // The value of arg in Main is changed.
        arg = 4;
        squareRef(ref arg);
        Console.WriteLine(arg);
        // Output: 16
    }

    static void squareRef(ref int refParameter)
    {
        refParameter *= refParameter;
    }
}

7

Thiếu an toàn sợi chỉ khi sử dụng các biến toàn cầu

Tương phản ví dụ trước với các điều sau đây, trong đó trả về một giá trị rõ ràng:

>>>

using System;

// Source:
// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/passing-parameters
class Program
{
    static void Main(string[] args)
    {
        int arg;

        // Passing by reference.
        // The value of arg in Main is changed.
        arg = 4;
        squareRef(ref arg);
        Console.WriteLine(arg);
        // Output: 16
    }

    static void squareRef(ref int refParameter)
    {
        refParameter *= refParameter;
    }
}

8

Nỗ lực sửa đổi các thuộc tính mà don lồng cho phép sửa đổi dẫn đến

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

17.

Ngoài ra, bạn nên chú ý đến các thuộc tính lớp. Chúng sẽ không thay đổi và một thuộc tính thể hiện sẽ được tạo và sửa đổi:

>>>

using System;

// Source:
// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/passing-parameters
class Program
{
    static void Main(string[] args)
    {
        int arg;

        // Passing by reference.
        // The value of arg in Main is changed.
        arg = 4;
        squareRef(ref arg);
        Console.WriteLine(arg);
        // Output: 16
    }

    static void squareRef(ref int refParameter)
    {
        refParameter *= refParameter;
    }
}

9

Vì các thuộc tính lớp vẫn không thay đổi khi được sửa đổi thông qua một thể hiện lớp, bạn sẽ cần nhớ tham chiếu thuộc tính thể hiện.

Thực hành tốt nhất: Sử dụng từ điển và danh sách

Từ điển trong Python là một loại đối tượng khác với tất cả các loại tích hợp khác. Họ được gọi là loại ánh xạ. Tài liệu Python sườn về các loại ánh xạ cung cấp một số cái nhìn sâu sắc về thuật ngữ:mapping types. Python’s documentation on mapping types provides some insight into the term:

Một bản đồ đối tượng ánh xạ các giá trị băm vào các đối tượng tùy ý. Ánh xạ là các đối tượng có thể thay đổi. Hiện tại chỉ có một loại ánh xạ tiêu chuẩn, từ điển. (Nguồn)

Hướng dẫn này không bao gồm cách thực hiện một loại ánh xạ tùy chỉnh, nhưng bạn có thể sao chép thẻ bằng cách tham chiếu bằng từ điển khiêm tốn. Ở đây, một ví dụ sử dụng chức năng hoạt động trực tiếp trên các yếu tố từ điển:

>>>

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

0

Vì bạn đã chỉ định lại một giá trị cho khóa từ điển, hoạt động trên các phần tử từ điển vẫn là một hình thức gán. Với từ điển, bạn có được tính thực tế bổ sung khi truy cập giá trị sửa đổi thông qua cùng một đối tượng từ điển.

Mặc dù danh sách các loại ánh xạ aren, bạn có thể sử dụng chúng theo cách tương tự như từ điển vì hai đặc điểm quan trọng: khả năng đăng ký và khả năng đột biến. Những đặc điểm này đáng để giải thích thêm một chút, nhưng trước tiên, hãy để xem các thực tiễn tốt nhất để bắt chước vượt qua bằng cách tham khảo bằng danh sách Python.subscriptability and mutability. These characteristics are worthy of a little more explanation, but let’s first take a look at best practices for mimicking pass by reference using Python lists.

Để sao chép Pass bằng tham chiếu bằng danh sách, hãy viết một chức năng hoạt động trực tiếp trên các yếu tố danh sách:

>>>

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

1

Vì bạn đã chỉ định lại một giá trị cho một yếu tố trong danh sách, hoạt động trên các yếu tố danh sách vẫn là một hình thức gán. Tương tự như từ điển, danh sách cho phép bạn truy cập giá trị sửa đổi thông qua cùng một đối tượng danh sách.

Bây giờ, hãy để khám phá khả năng đăng ký. Một đối tượng có thể đăng ký khi một tập hợp con của cấu trúc của nó có thể được truy cập bởi các vị trí chỉ mục:subscriptable when a subset of its structure can be accessed by index positions:

>>>

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

2

Danh sách, bộ dữ liệu và chuỗi là có thể đăng ký, nhưng các bộ thì không. Cố gắng truy cập vào một yếu tố của một đối tượng không thể đăng ký sẽ tăng

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

18.

Khả năng đột biến là một chủ đề rộng hơn yêu cầu tham chiếu tài liệu và thăm dò bổ sung. Để giữ cho mọi thứ ngắn gọn, một đối tượng có thể thay đổi nếu cấu trúc của nó có thể được thay đổi tại chỗ thay vì yêu cầu phân công lại:mutable if its structure can be changed in place rather than requiring reassignment:

>>>

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

3

Danh sách và bộ có thể thay đổi, cũng như từ điển và các loại ánh xạ khác. Chuỗi và bộ dữ liệu không thể thay đổi. Cố gắng sửa đổi một yếu tố của một đối tượng bất biến sẽ tăng

#var is an instance of dictionary type

def change(var,key,new_value):
    var[key]=new_value

var =dict()
var['a']=33
change(var,'a',2625)
print(var['a'])

18.

Sự kết luận

Python hoạt động khác với các ngôn ngữ hỗ trợ các đối số truyền theo tham chiếu hoặc theo giá trị. Các đối số chức năng trở thành các biến cục bộ được gán cho từng giá trị được truyền cho hàm. Nhưng điều này không ngăn cản bạn đạt được kết quả tương tự mà bạn mong đợi khi chuyển các đối số bằng cách tham khảo bằng các ngôn ngữ khác.

Trong hướng dẫn này, bạn đã học được:

Cách Python xử lý việc gán các giá trị cho các biếnassigning values to variables
Cách các đối số chức năng được truyền bằng cách chuyển nhượng trong Pythonpassed by assignment in Python
Tại sao các giá trị trả lại là một thực tiễn tốt nhất để sao chép vượt qua bằng cách tham khảoreturning values is a best practice for replicating pass by reference
Cách sử dụng các thuộc tính, từ điển và danh sách như các thực tiễn tốt nhất thay thếattributes, dictionaries, and lists as alternative best practices

Bạn cũng đã học được một số thực tiễn tốt nhất bổ sung để sao chép các cấu trúc tham chiếu theo từng tham chiếu trong Python. Bạn có thể sử dụng kiến thức này để thực hiện các mẫu có truyền thống cần hỗ trợ để truyền qua tham chiếu.

Để tiếp tục hành trình Python của bạn, tôi khuyến khích bạn đi sâu hơn vào một số chủ đề liên quan mà bạn đã gặp ở đây, như tính biến đổi, biểu thức chuyển nhượng, và không gian tên và phạm vi Python.

Hãy tò mò, và hẹn gặp lại lần sau!

Xem bây giờ hướng dẫn này có một khóa học video liên quan được tạo bởi nhóm Python thực sự. Xem cùng với hướng dẫn bằng văn bản để hiểu sâu hơn về sự hiểu biết của bạn: vượt qua tham chiếu trong Python: Thực tiễn tốt nhất This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Pass by Reference in Python: Best Practices

Python có vượt qua tham chiếu hay theo giá trị không?

Mô hình truyền cho đối số của Python không phải là người vượt qua giá trị, hay vượt qua bằng cách tham chiếu, nhưng đó là cách vượt qua tham chiếu đối tượng.Pass by Object Reference”.

Các số được truyền theo giá trị trong Python?

Các số nguyên (và tất cả các giá trị khác) trong Python luôn được truyền bởi giá trị.Tuy nhiên, bạn có thể vượt qua các tài liệu tham khảo, khác nhau.Nói cách khác, bạn có thể vượt qua tài liệu tham khảo theo giá trị.. You can, however, pass references, which is different. In other words, you can pass references by value.

Làm thế nào để INT hoạt động trong Python?

Hàm python int () chuyển đổi giá trị được chỉ định thành số nguyên.Hàm int () sẽ trả về một đối tượng số nguyên được xây dựng từ một số hoặc chuỗi hãy nói x hoặc trả về 0 nếu không có ents ents nào được chỉ định.converts the specified value into an integer number. The int() function will returns an integer object constructed from a number or string let say x, or return 0 if no argum ents are specified.

Các mảng Python có được thông qua bởi tham chiếu không?

Mảng chuỗi, danh sách, bộ dữ liệu và từ điển được truyền đến và từ giá trị.Các mảng số được truyền qua tham chiếu khi chúng được sử dụng làm đối số hoặc từ khóa cho các phương thức Python.Các mảng số được truyền theo giá trị khi chúng được chuyển từ IDL sang cấp độ Python __main__ và khi Python trả về kết quả cho IDL.Numeric arrays are passed by reference when they are used as arguments or keywords to Python methods. Numeric arrays are passed by value when they are passed from IDL to the Python __main__ level and when Python returns a result to IDL.

programming python In Python Function reference Python Pointer Python Python reference Int object python

Hướng dẫn are ints passed by reference in python? - int có được truyền bằng tham chiếu trong python không?

Xác định vượt qua theo tham chiếu

Tương phản vượt qua bằng cách tham chiếu và vượt qua giá trị

Sử dụng các cấu trúc tham chiếu vượt qua

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

Trả về nhiều giá trị

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

Khám phá các đối số chức năng

Các biến miễn phí, dường như không liên quan đến bất cứ điều gì

Thực hành tốt nhất: Sử dụng từ điển và danh sách

Sự kết luận

Python có vượt qua tham chiếu hay theo giá trị không?

Các số được truyền theo giá trị trong Python?

Làm thế nào để INT hoạt động trong Python?

Các mảng Python có được thông qua bởi tham chiếu không?

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội