25-Python函数

05-函数\01-函数一.pdf
05-函数\02-函数二.pdf

1. 函数的说明文档

思考：定义一个函数后，程序员如何书写程序能够快速提示这个函数的作用？

答：注释

思考：如果代码多，我们是不是需要在很多代码中找到这个函数定义的位置才能看到注释？如果想更方
便的查看函数的作用怎么办？

答：函数的说明文档

函数的说明文档也叫函数的文档说明。

1. 语法

定义函数的说明文档

def 函数名(参数):
	""" 说明⽂文档的位置 """
	代码
	......

查看函数的说明文档

help(函数名)

2.快速体验

def sum_num(a, b):
	""" 求和函数 """
	return a + b
help(sum_num)

输出：

Help on function sum_num in module __main__:

sum_num(a, b)
    求和函数

2. 如何在函数体内修改全局变量

有下面这样的代码：

a = 100
def testA():
    print(a)    #这里的a应该是全局变量
def testB():
    a = 200     #这里的a应该是局部变量
    print(a)

testA() # 全局变量的值100
testB() # 局部的变量的值200

print(f'全局变量量a = {a}') # 全局变量量a = 100

程序输出：

100
200
全局变量量a = 100

思考：如何在函数体testB()内部修改全局变量？
答：使用global 关键字进行声明

a = 100
def testA():
    print(a)
def testB():
    # global 关键字声明a是全局变量量
    global a
    a = 200
    print(a)


testA() # 100
testB() # 200

print(f'全局变量量a = {a}') # 全局变量量a = 200

程序的输出：

100
200
200
全局变量量a = 200

3. 函数有多个返回值

思考：如果一个函数要有多个返回值，该如何书写代码

def return_num():
    return 1, 2
result = return_num()
print(result) # (1, 2)

程序的输出结果：

(1, 2)

注意：

1. return a, b 写法，返回多个数据的时候，默认是元组类型。
2. return后面可以连接列表、元组或字典，以返回多个值。

4. 函数的参数

1. 位置参数

位置参数：调用函数时根据函数定义的参数位置来传递参数。

def user_info(name, age, gender):
	print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')
user_info('TOM', 20, '男')

程序输出：

您的名字是TOM, 年龄是20, 性别是男

注意：传递和定义参数的顺序及个数必须一致。

2. 关键字参数

函数调用，通过"键=值"形式加以指定。可以让函数更加清晰、容易易使用，同时也清除了参数的顺序需求。

def user_info(name, age, gender):
	print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')
user_info('Rose', age=20, gender='女')
user_info('小明', gender='男', age=16)

程序输出：

您的名字是Rose, 年龄是20, 性别是女
您的名字是小明, 年龄是16, 性别是男

3. 缺省参数

缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注
意：所有位置参数必须出现在默认参数前，包括函数定义和调用）。

注意：函数调用时，如果为缺省参数传值则修改默认参数值；否则使用这个默认值。

5. 不定长参数

不定长参数也叫可变参数。用于不确定调用的时候会传递多少个参数(不传参也可以)的场景。

此时，可用包裹(packing)位置参数，或者包裹关键字参数，来进行参数传递，会显得非常方便。

函数传递变量的时候，有两种方式 一种是位置参数， 一种是关键字参数， 同理不定长的参数也有两种方式

1. 包裹位置传递

def user_info(*args):
	print(args)
user_info('TOM')
user_info('TOM', 20)
user_info('TOM', 20, '男')

程序的输出：

('TOM',)
('TOM', 20)
('TOM', 20, '男')

注意：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple)，args是元组类型，这就是包裹位置传递。

2. 包裹关键字传递

def user_info(**kwargs):
    print(kwargs)
# {'name': 'TOM', 'age': 18, 'id': 110}
user_info(name='TOM')
user_info(name='TOM', age=18)
user_info(name='TOM', age=18, id=110)

程序的输出：

{
    
    'name': 'TOM'}
{
    
    'name': 'TOM', 'age': 18}
{
    
    'name': 'TOM', 'age': 18, 'id': 110}

综上：无论是包裹位置传递还是包裹关键字传递，都是一个组包的过程。

6. 拆包

1. 拆包：元组

def return_num():
	return 100, 200 #这种形式默认返回的是元组
num1, num2 = return_num()
print(num1) # 100
print(num2) # 200

2. 拆包：字典

对字典进行拆包，取出来的是字典的key

dict1 = {
    
    'name': 'TOM', 'age': 18}
a, b = dict1
# 对字典进行拆包，取出来的是字典的key
print(a) # name
print(b) # age
print(dict1[a]) # TOM
print(dict1[b]) # 18

程序的输出：

name
age
TOM
18

3. 交换变量的值

a,b = 1,2
print(a)
print(b)

a,b = b,a
print(a)
print(b)

程序输出：

1
2
2
1

7. 引用

1. 了解引用

在python中，值是靠引用来传递来的。
我们可以用 id() 来判断两个变量是否为同一个值的引用。
我们可以将id值理解为那块内存的地址标识。

# 1. int类型
a = 1
b = a
print(b) # 1
print("id(a):", id(a))
print("id(b):", id(b))

a = 2
print(b) # 1,说明int类型为不可变类型

print("id(a):", id(a))
print("id(b):", id(b))

程序的输出结果：

1
id(a): 2305065249072
id(b): 2305065249072
1
id(a): 2305065249104
id(b): 2305065249072

最开始 a和 b的地址都是一样的，也可以从打印看出来 b的值也是 1， 后来执行了 a = 2 之后，本来按照逻辑是不是 b的值也应该是 1，因为他们代表的是同一块内存区域。但是后来 从打印看 a和b 的地址并不一样。

2. 列表引用

# 2. 列列表
aa = [10, 20]
bb = aa

print(id(aa))
print(id(bb))

aa.append(30)

print(bb) # [10, 20, 30], 列列表为可变类型
print(id(aa))
print(id(bb))

程序输出：

3066822266688
3066822266688
[10, 20, 30]
3066822266688
3066822266688

8. 引用做实参

def test1(a):
    print(a)
    print("before a += a, id(a):", id(a))


    a += a
    print(a)
    print("after a += a,id(a):", id(a))

# int：计算前后id值不不同
b = 100
print('id(b):', id(b))
test1(b)

# 列列表：计算前后id值相同
c = [11, 22]
print('id(c):', id(c))
test1(c)

程序输出：

id(b): 2453566281168
100
before a += a, id(a): 2453566281168
200
after a += a,id(a): 2453566284432
id(c): 2453567835904
[11, 22]
before a += a, id(a): 2453567835904
[11, 22, 11, 22]
after a += a,id(a): 2453567835904

首先是整形变量 b = 100， b的地址是 2453566281168， 没有执行 a += a之前，a的地址是 2453566281168， 执行 完之后，a的地址变成了 2453566284432

但是 列表就没有改变地址。

9.可变和不可变类型

所谓可变类型与不可变类型是指：数据能够直接进行修改，如果能直接修改那么就是可变，否则是不可变

• 可变类型

1. 列列表
2. 字典
3. 集合

• 不可变类型

1. 整型
2. 浮点型
3. 字符串
4. 元组