前言
前面我们学习了 python 函数的基本使用，那么今天我将继续带大家深入了解 python 函数的更多操作。
变量的作用域
变量分为局部变量和全局变量，两种变量的作用域不同。
- 局部变量是指定义在函数体内部的变量，只在函数体的内部生效。
- 全局变量是指在函数的内部和外部都能生效的变量。
局部变量
def test1():
a = 100 # 这里a属于局部变量
print(a)
当出了函数体之后，局部变量 a 会被销毁。
def test1():
a = 100
print(a)
print(a)
全局变量
a = 100
def test1():
print(f'在函数内部使用全局变量{a}')
test1()
print(f'在函数外部使用全局变量{a}')
在函数体外部修改全部变量，全局变量会被修改，那么如果我们在函数体内部修改全局变量会怎样呢？
a = 100
def test1():
a = 200
print(a)
test1()
print(a)
可以发现：在函数体内部修改全局变量只是修改的是函数体内部的变量，实际上全局变量并未改变，也就是说函数体内部修改的其实还是局部变量，那么如何在函数体内部修改全局变量呢？
global 变量 声明此变量为全局变量，然后对全局变量进行修改。
a = 100
def test1():
global a
a = 200
print(a)
test1()
print(a)
函数的返回值
前面我们说过的函数的返回值都是一个数据，那么如果我们想要返回多个数据该怎么办呢？
- 使用逗号 , 来分割多个数据，但是这多个数据最总会被合并为一个元组返回。
- 以列表、元组、字典、集合的形式返回多个数据。
以逗号 , 形式返回
def test1():
return 1,2,3
print(test1())
以列表形式返回
def test1():
return [1,2,3]
print(test1())
以元组的形式返回
def test1():
return (1,2,3)
print(test1())
以集合的形式返回
def test1():
return {1,1,2,3}
print(test1())
对此，我们可以根据需要来选择以哪种形式返回数据
函数的参数
函数传参的方式有四种：
- 位置传参
- 关键字传参
- 缺省传参
- 不定长传参
1.位置参数
调用函数的时候，根据函数定义的参数的位置顺序和数量进行传参。
def test1(name,age,gender):
print(f'姓名：{name} 年龄：{age} 性别：{gender}')
test1('zhangsan',18,'man')
当传入的参数的数量与函数定义时的参数数量不同时，会报错。
def test1(name,age,gender):
print(f'姓名：{name} 年龄：{age} 性别：{gender}')
test1('zhangsan',18)
传参时，顺序与定义时参数顺序不同，可以运行通过，但代码无意义。
def test1(name,age,gender):
print(f'姓名：{name} 年龄：{age} 性别：{gender}')
test1(18,'zhangsan','man')
2.关键字参数
通过“键 = 值” 的形式加以制定，可以让函数更加清晰、容易使用，同时也不需要遵守传参的顺序。
def test1(name,age,gender):
print(f'姓名：{name} 年龄：{age} 性别：{gender}')
test1(gender = 'man',name = 'zhangsan',age = 18)
使用关键字传参时，可以有位置参数，但是位置参数必须在关键字参数之前。位置参数必须要和函数定义时的参数的位置对应。
def test1(name,age,gender):
print(f'姓名：{name} 年龄：{age} 性别：{gender}')
test1('zhangsan',gender = 'man',age = 18)
当位置参数与函数定义时参数不对应时，会报错。
def test1(name,age,gender):
print(f'姓名：{name} 年龄：{age} 性别：{gender}')
test1('man',name = 'zhangsan',age = 18)
3.缺省参数
缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调用）。
在函数定义的时候，我们可以为参数指定默认值，这样当我们不为这个参数传入值的时候，这个参数就会使用默认值，如果我们为这个参数传入数据，这个参数也会变成我们传入的数据。
def test1(name,age,gender = 'man'):
print(f'姓名：{name} 年龄：{age} 性别：{gender}')
test1('zhangsan',18)
def test1(name,age,gender = 'man'):
print(f'姓名：{name} 年龄：{age} 性别：{gender}')
test1('zhangsan',18,'woman')
test1(age = 19,name = 'lisi')
一旦你开始在函数定义中使用默认参数，那么所有在该默认参数后面的参数都必须是默认参数。换言之，所有无默认值的参数（位置参数）都必须出现在带有默认值的参数（关键字参数）前面。
def test1(name,age = 18,gender):
print(f'姓名：{name} 年龄：{age} 性别：{gender}')
test1('zahngsan','man')
4.不定长参数
不定长参数也叫可变参数。用于不确定调用的时候会传递多少个参数(不传参也可以)的场景。此时，可用包裹(packing)位置参数，或者包裹关键字参数，来进行参数传递，会显得非常方便。
1）包裹位置传递def 函数名(*args):
这个 * 不可省略，是包裹位置传递的标志，后面的args可以更换，但是实际生活中建议使用args，因为 python 底层也是使用的args。
使用位置包裹传递的参数会被合并成一个元组传入函数中。
def test1(*args):
print(args)
test1()
test1(1)
test1(1,2)
2）包裹关键字传递def 函数名(**args):
传入参数时，以 “键 = 值” 的形式传递。并且以包裹关键字传递的形式传参的时候，这些参数会被合并为一个字典传入参数中。
def test1(**args):
print(args)
test1(name = 'zhangsan',age = 18,gender = 'man')
上面的包裹位置传递和包裹关键字传递都是一个组包的过程，我们也可以进行拆包过程。
拆包
1）元组拆包
def test1():
return 100,200
a,b = test1()
print(a)
print(b)
这里注意：拆包过程中，接收的变量的数量要与元组中的元素个数相同。
2）字典拆包
字典拆包，变量中存储的是字典的 key ，我们可以根据拆包获得的 key ，来操作 value 值
dict1 = {'name':'zhangsan','age':18,'gender':'man'}
a,b,c = dict1
print(a)
print(b)
print(c)
print(dict1[a])
print(dict1[b])
print(dict1[c])
交换变量的值
在 python 中，常见的交换两个变量的值有两种方法。
- 采用中间值的方法。
- a,b = b,a
采用中间值的方法
a = 100
b = 200
c = 0
c = a
a = b
b = c
print(a)
print(b)
采用中间值c来存储其中一个数据，防止在交换过程中被替换掉。
b,a = a,b
a = 100
b = 200
a,b = b,a
print(a)
print(b)
引用
在Python中，引用对于对象的处理有着举足轻重的作用。
-
对象赋值：在Python中，当你创建一个对象并给它赋一个变量名时，这个变量名只是指向那个对象的引用，而并非对象本身。例如，当你创建一个列表a = [1, 2, 3]，a实际上是对列表[1, 2, 3]的引用。
-
函数参数传递：Python使用引用传递（pass-by-reference）方式向函数传递参数。所以，如果你在函数内部改变了传入对象的值，那么在函数外面的那个对象的值也会随之改变。需要注意的是，对于不可变类型（如整数、字符串、元组），由于其不可变的特性，函数内部对其进行的操作不会影响外部实际对象。
-
共享和复制：Python中对象的赋值，实际上是在创建一个新的引用，而不是创建一个全新的对象。例如，当你写b = a，你实际上只是创建了一个新的引用b，并没有创建一个新的列表。这就是所谓的浅复制（shallow copy）。如果你要创建一个对象的深度副本（deep copy），即一个全新的对象，可以使用copy模块的deepcopy函数。尤其是对于复杂的数据结构如列表、字典或者自定义的对象，理解Python中的引用模型非常重要。
这里第三点我们先做了解，后面再给大家讲解。
在了解引用之前，我们需要了解在 python 中，哪些数据类型是可变数据类型，哪些类型是不可变类型。
可变数据类型和不可变数据类型
可变类型
- 列表
- 字典
- 集合
不可变类型
- 整型
- 浮点型
- 字符串
- 元组
我们用一段代码来了解什么是引用。id() 函数可以知道引用所引用的内容的地址。
a = 1
b = a
print(id(a))
print(id(b))
a 引用的是 1 ，b 引用 a 引用的引用。
a = 1
b = a
a = 2
print(a)
print(b)
print(id(a))
print(id(b))
这里因为 int 类型是不可变类型，所以当 a 的值由1变为2的时候，会另外开辟一个空间存储2，然后引用 a 指向该地址。
当引用指向的类型是可变类型时，会不会发生这种情况呢？
a = [1,2,3]
b = a
a.append(4)
print(a)
print(b)
print(id(a))
print(id(b))
我们看到，当引用的是可变数据类型时，当改变数据内容时，引用的地址不会改变。
我们可以将引用作为参数传递参数。
def test1(a):
print(id(a))
a = 2
print(id(a))
a = 1
print(id(a))
test1(a)
print(id(a))
print(a)
在这里，函数内部的引用 a 其实是一个临时变量，并且 a 引用的数据类型是 int 型，是不可变类型，当改变临时变量 a 的值时，会额外创建一个值为 2 的 int 类型的内存，然后临时变量 a 指向该内存，当出了函数时，临时变量 a 会被销毁，打印的 a 的值还是之前的值。
当传入的引用引用的数据类型是可变类型时
def test1(a):
print(id(a))
a[0] = 4
print(id(a))
a = [1,2,3]
print(id(a))
test1(a)
print(id(a))
print(a)
文章来源：https://www.toymoban.com/news/detail-529677.html
文章来源地址https://www.toymoban.com/news/detail-529677.html
到了这里，关于揭秘python函数：编程艺术的核心力量（2）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
