• Python参数传递方式

Python定义函数时的值传递和引用传递

- 在Python中，当我们向函数传递参数时，参数可以是值类型或引用类型。
-值传递：当我们向函数传递一个值类型的参数时，函数会创建一个参数的副本，并对副本进行操作。这意味着在函数内部对参数的修改不会影响原始变量的值。当函数返回时，参数的副本被销毁，不会影响到原始变量。

为什么会出现值传递和引用传递这种情况？

• 这种情况是由于Python中变量的赋值方式和内存管理机制所导致的。

• 在Python中，变量是对对象的引用。当我们将一个对象赋值给一个变量时，实际上是将变量的引用指向了这个对象。如果我们将一个变量赋值给另一个变量，那么两个变量将引用同一个对象。

• 当我们将一个可变对象（如列表）传递给一个函数时，函数的参数将会引用同一个对象。这意味着在函数内部对该对象的修改将会影响到原始对象。

• 当我们将一个不可变对象（如整数、字符串、元组等）传递给一个函数时，函数的参数将会引用一个新的对象。这是因为不可变对象在Python中是不可变的，所以无法在原始对象上进行修改，必须创建一个新的对象来代表修改后的值。因此，在函数内部对参数的修改不会影响到原始对象。

• 需要注意的是，在Python中并没有像C++中那样的值传递和引用传递之分，而是根据参数的类型来决定是将对象的引用传递给函数，还是将对象的副本传递给函数。但是，在可变对象和不可变对象的情况下，这种方式很容易被理解为值传递和引用传递。

• 引用传递：当我们向函数传递一个引用类型的参数时，函数会操作原始变量的引用。这意味着在函数内部对参数的修改将会影响到原始变量的值。当函数返回时，参数的引用仍然指向原始变量。

例如，以下代码演示了值传递：

def func(x):
    x = 10
    print("Inside the function, x is:", x)

y = 5
func(y)
print("Outside the function, y is:", y)```
输出结果为：

`Inside the function, x is: 10`
`Outside the function, y is: 5`

这里我们将变量y传递给了函数func。在函数内部，我们将参数x的值更改为10。但是，在函数外部，y的值仍然是5，因为函数内部对x的更改不会影响到原始变量y。

例如，以下代码演示了引用传递：

```python
def func(lst):
    lst.append(4)
    print("Inside the function, lst is:", lst)

my_list = [1, 2, 3]
func(my_list)
print("Outside the function, my_list is:", my_list)```
输出结果为：
``Inside the function, lst is: [1, 2, 3, 4]
`Outside the function, my_list is: [1, 2, 3, 4]`


这里我们将变量my_list传递给了函数func。在函数内部，我们使用append方法向参数lst添加一个值。这也会影响到原始变量my_list，因为它们引用相同的对象。因此，函数外部和内部的输出结果都是[1, 2, 3, 4]。

函数

• Python中函数参数传递非常灵活，主要有以下原因：

  • 必传参数：必传参数是指函数定义时必须要传递的参数，这是最基本的参数传递方式。调用函数时，必传参数必须按照函数定义时的参数顺序进行传递，否则会引发参数不匹配的错误。

  • 关键字参数：关键字参数是指调用函数时，使用参数名和参数值的方式进行传递，可以不按照函数定义时的参数顺序传递。使用关键字参数的好处是可以提高代码的可读性和可维护性。

  • 默认参数：默认参数是指在函数定义时，给参数设置默认值。在调用函数时，如果没有传递对应的参数值，则会使用默认值。使用默认参数可以减少函数调用时必须要传递的参数数量，同时也可以增强代码的可读性。

  • 可变参数：可变参数是指在函数定义时，允许传递任意数量的参数。在Python中，可变参数有两种类型：*args和**kwargs。使用可变参数可以在函数定义时不确定需要传递多少个参数，提高函数的灵活性。

  • 总之，Python中函数参数传递的灵活性，使得我们能够更加方便地调用函数，并且可以根据具体的需求，选择不同的参数传递方式。

  • 拓展：如果要将字典和元组传入函数中的可变参数，只需要分别将元组和字典分别加上args和kwargs对应的星号即可，*在函数传递参数时代表解包，在函数定义时代表拆包```

实战

# coding:utf-8  
# @Time:2023-4-19  
# @Author:dx  
# @File:def_args.py  
  
"""  
说明：  
*和**在函数定义中代表打包，在函数定义的时候代表解包  
"""  
def add(a, b, c=3):  
return a + b + c  
  
  
print(add(1, 2))  
print(add(1, 2, 6))  
  
  
def test_args(*args, **kwargs):  
print(args, type(args))  
print(kwargs, type(kwargs))  
  
  
test_args(1, 2, 3, 4, name='dx', age=19, top=176)  
  
  
def test_args_super(*args, **kwargs):  
if len(args) >= 1:  
print(args[0])  
if 'name' in kwargs:  
print(kwargs['name'])  
else:  
print('no name')  
print(args, len(args))  
print(kwargs, len(kwargs))  
  
  
test_args_super(1, name='dx')  
a = ('python', 'django')  
b = {'name': 'dx'}  
test_args_super(a, b)  
test_args_super(*a, **b)  
  
  
def add(a, b=1):  
return a + b  
  
  
add(1, 2)  
add(1)  
add(a=1, b=2)  
  
  
# add(b=2)会报错  
  
def test(a, b=1, *args):  
print(a, b, *args)  
  
  
s = (1, 2)  
test(1, 2, *s)  
  
  
# test(a=1, b=2, *s) # 会报错，当有可变参数的时候，应将其放置在第一位;  
# 当我们的必选参数。默认参数，可选元组参数在一起的时候，如果需要使用赋值的形式的传参，则需要在定义函数参数的时候，将可变的元组类型放在第一位，之后是必传与默认参数，这是一个特例。  
def test2(*args, a, b=1):  
print(a, b, args)  
  
  
test2(a=1, b=2, *s)  
  
  
def test3(a=1, b=1, **kwargs):  
print(a, b, kwargs)  
  
  
test3(1, 2, name="dx")  
test3(a=1, b=2, name='dx')  
test3(name='dx', age=19, a=1, b=2)  
  
d = {'name': 'dx'}  
test3(a=1, b=2, **d)  
test3(**d, a=1, b=2)  
# test3(**d, 1, 2) # 会报错，顺序发生改变要使用赋值语句的方式，不然会报错
——结果：
6
9
(1, 2, 3, 4) <class 'tuple'>
{'name': 'dx', 'age': 19, 'top': 176} <class 'dict'>
1
dx
(1,) 1
{'name': 'dx'} 1
('python', 'django')
no name
(('python', 'django'), {'name': 'dx'}) 2
{} 0
python
dx
('python', 'django') 2
{'name': 'dx'} 1
1 2 1 2
1 2 (1, 2)
1 2 {'name': 'dx'}
1 2 {'name': 'dx'}
1 2 {'name': 'dx', 'age': 19}
1 2 {'name': 'dx'}
1 2 {'name': 'dx'}

进程已结束,退出代码0