Hướng dẫn python store reference to function - tham chiếu cửa hàng python đến chức năng

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,

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

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

>>>

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

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

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

def append_one(li):
    li = [0, 1]
x = [0]
append_one(x)
print x

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

def append_one(li):
    li = [0, 1]
x = [0]
append_one(x)
print x

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

def append_one(li):
    li = [0, 1]
x = [0]
append_one(x)
print x

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

>>>

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

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

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

def append_one(li):
    li = [0, 1]
x = [0]
append_one(x)
print x

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

def append_one(li):
    li = [0, 1]
x = [0]
append_one(x)
print x

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

def append_one(li):
    li = [0, 1]
x = [0]
append_one(x)
print x

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.

>>>

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

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

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

def append_one(li):
    li = [0, 1]
x = [0]
append_one(x)
print x

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

def append_one(li):
    li = [0, 1]
x = [0]
append_one(x)
print x

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

def append_one(li):
    li = [0, 1]
x = [0]
append_one(x)
print x

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.reassign your

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

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

>>>

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

Bây giờ, sau khi chỉ định lại từng biến với một cuộc gọi đế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;
    }
}

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:

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

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

>>> 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. 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():
   ...     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
   

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

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

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

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

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

   1., then the output parameter will be set 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
   

   3, and the function will return

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

   1.

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 append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

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

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 append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

Để 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 append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

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

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

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

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 append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

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

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

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 append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

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

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

>>>

[0, 1]

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

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 (____ 99) và sử dụng giá trị trả về trực tiếp trong các biểu thức python.assigning return values when using the assignment expression operator(

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

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!

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 append_one(li):
      li.append(1)
  x = [0]
  append_one(x)
  print x
  

  00,

  def append_one(li):
      li = [0, 1]
  x = [0]
  append_one(x)
  print x
  

  8 là tên và

  def append_one(li):
      li.append(1)
  x = [0]
  append_one(x)
  print x
  

  02 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

  def append_one(li):
      li = [0, 1]
  x = [0]
  append_one(x)
  print x
  

  8 đã

  def append_one(li):
      li.append(1)
  x = [0]
  append_one(x)
  print x
  

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

  def append_one(li):
      li.append(1)
  x = [0]
  append_one(x)
  print x
  

  05, thì tên biến

  def append_one(li):
      li = [0, 1]
  x = [0]
  append_one(x)
  print x
  

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

  def append_one(li):
      li.append(1)
  x = [0]
  append_one(x)
  print x
  

  07.

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 append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

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

   def append_one(li):
       li.append(1)
   x = [0]
   append_one(x)
   print x
   

   02 đã 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

   def append_one(li):
       li = [0, 1]
   x = [0]
   append_one(x)
   print x
   

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

   def append_one(li):
       li.append(1)
   x = [0]
   append_one(x)
   print x
   

   02. 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 append_one(li):
       li.append(1)
   x = [0]
   append_one(x)
   print x
   

   12 hoặc

   def append_one(li):
       li.append(1)
   x = [0]
   append_one(x)
   print x
   

   13.

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

def append_one(li):
    li = [0, 1]
x = [0]
append_one(x)
print x

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

   def append_one(li):
       li.append(1)
   x = [0]
   append_one(x)
   print x
   

   02 bị giảm.
2. Bộ đếm tham chiếu của đối tượng đại diện cho giá trị mới được tăng lên.
3. Từ điển cho không gian tên hiện tại được cập nhật để liên hệ

   def append_one(li):
       li = [0, 1]
   x = [0]
   append_one(x)
   print x
   

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

Python cho phép bạn có được số lượng tham chiếu cho các giá trị tùy ý với hàm

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

[0, 1]

Tập lệnh này sẽ hiển thị số lượng tham chiếu cho từng giá trị trước khi gán, sau khi gán và sau khi phân công lại:

[0, 1]

Những kết quả này minh họa mối quan hệ giữa các định danh (tên biến) và các đối tượng Python đại diện cho các giá trị riêng biệt. Khi bạn gán nhiều biến cho cùng một giá trị, Python sẽ tăng bộ đếm tham chiếu cho đối tượng hiện có và cập nhật không gian tên hiện tại thay vì tạo các đối tượng trùng lặp trong bộ nhớ.

Trong phần tiếp theo, bạn sẽ xây dựng dựa trên sự hiểu biết hiện tại của mình về các hoạt động chuyển nhượng bằng cách khám phá cách Python xử lý các đối số chức năng.

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 append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

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

>>>

[0, 1]

Sử dụng

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

>>>

[0, 1]

Sử dụng

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

>>>

[0, 1]

Sử dụng

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

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

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

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

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

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

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

Các đầu ra tập lệnh trên được tính tham chiếu cho def append_one(li): li.append(1) x = [0] append_one(x) print x 23 đầu tiên bên ngoài, sau đó bên trong def append_one(li): li.append(1) x = [0] append_one(x) print x 24, 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

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

Nhằm mục đích viết các hàm đơn mục đích trả về một giá trị, sau đó (Re) gán giá trị đó cho các biến, như trong ví dụ sau:

[0, 1]

Trả lại và gán các giá trị cũng làm cho ý định của bạn rõ ràng và mã của bạn dễ hiểu và kiểm tra hơn.

Đối với các chức năng hoạt động trên nhiều giá trị, bạn đã thấy rằng Python có khả năng trả lại một bộ giá trị. Bạn thậm chí đã vượt qua sự thanh lịch của int32.tryparse () trong C# nhờ sự linh hoạt của Python!

Nếu bạn cần vận hành trên nhiều giá trị, thì bạn có thể viết các hàm đơn mục đích trả về nhiều giá trị, sau đó (Re) gán các giá trị đó cho các biến. Đây là một ví dụ:

[0, 1]

Khi gọi một hàm trả về nhiều giá trị, bạn có thể gán nhiều biến cùng một lúc.

Thực hành tốt nhất: Sử dụng các thuộc tính đối tượng

Các thuộc tính đối tượng có vị trí riêng của chúng trong chiến lược chuyển nhượng Python. Tham chiếu ngôn ngữ Python sườn cho các câu lệnh gán cho thấy rằng nếu mục tiêu là thuộc tính đối tượng hỗ trợ gán, thì đối tượng sẽ được yêu cầu thực hiện bài tập trên thuộc tính đó. Nếu bạn chuyển đối tượng như một đối số cho một hàm, thì các thuộc tính của nó có thể được sửa đổi tại chỗ.

Viết các chức năng chấp nhận các đối tượng với các thuộc tính, sau đó hoạt động trực tiếp trên các thuộc tính đó, như trong ví dụ sau:

>>>

def append_one(li):
    li = [0, 1]
x = [0]
append_one(x)
print x

Lưu ý rằng

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

Nó có giá trị lặp lại rằng bạn nên đảm bảo thuộc tính hỗ trợ chuyển nhượng! Ở đây, ví dụ tương tự với

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

>>>

def append_one(li):
    li = [0, 1]
x = [0]
append_one(x)
print x

Lưu ý rằng

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

Nó có giá trị lặp lại rằng bạn nên đảm bảo thuộc tính hỗ trợ chuyển nhượng! Ở đây, ví dụ tương tự với

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

>>>

def append_one(li):
    li = [0, 1]
x = [0]
append_one(x)
print x

Lưu ý rằng

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

Nó có giá trị lặp lại rằng bạn nên đảm bảo thuộc tính hỗ trợ chuyển nhượng! Ở đây, ví dụ tương tự với def append_one(li): li.append(1) x = [0] append_one(x) print x 35, có thuộc tính chỉ đọc:

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

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

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:

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.

>>>

def append_one(li):
    li = [0, 1]
x = [0]
append_one(x)
print x

Lưu ý rằng

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

Nó có giá trị lặp lại rằng bạn nên đảm bảo thuộc tính hỗ trợ chuyển nhượng! Ở đây, ví dụ tương tự với

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

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

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

>>>

def append_one(li):
    li = [0, 1]
x = [0]
append_one(x)
print x

Lưu ý rằng

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

Nó có giá trị lặp lại rằng bạn nên đảm bảo thuộc tính hỗ trợ chuyển nhượng! Ở đây, ví dụ tương tự với

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

>>>

def append_one(li):
    li = [0, 1]
x = [0]
append_one(x)
print x

Lưu ý rằng

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

Nó có giá trị lặp lại rằng bạn nên đảm bảo thuộc tính hỗ trợ chuyển nhượng! Ở đây, ví dụ tương tự với

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

>>>

def append_one(li):
    li = [0, 1]
x = [0]
append_one(x)
print x

Lưu ý rằng

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x