函数
函数是对功能的封装
语法:
def 函数名(形参列表):
函数体(代码块,return)
调用
函数名(实参列表)
返回值
1.return:在函数执行的时候,如果遇到return.直接返回
2.如果函数什么都不写,不写return.得到的是None.
3.在函数中写return 值.返回一个值.
4.在函数中可以返回多个返回值,return 值1, 值2, 值3......, 接收的是元组.
参数
函数执行的时候给函数传递消息.
*形参:函数声明的位置的变量
*实参:函数调用的时候给的具体的值
传参:把实参交给形参的过程
#单行注释
'''多行注释'''
# 函数注释
def func(a, b):
"""
这个函数是用来计算a和b的和
:param a: 第一个数据
:param b: 第二个数据
:return: 返回的是两个数的和
"""
return a + b
print(func.__doc__) # document文档
1.实参:
1.位置参数,按照形参的参数位置,给形参传值
2.关键字参数,按照形参的名字给形参传值
3.混合参数.即用位置参数,也用关键参数
2.形参:
1.位置参数,按照形参的参数位置,给形参传值
2.默认值参数 先位置后默认值
3.动态传参
1).*args 位置参数动态传参
def chi(*li):
print(li)
chi('米饭', '面条', '粥')
chi('馒头', '盖浇饭')
chi('馒头') #返回的是一个元组
输出结果:
('米饭', '面条', '粥')
('馒头', '盖浇饭')
('馒头',)
2).**kwargs 关键字参数动态传参
def chi1(**food):
print(food)
chi1(good_food = '米饭', drink = '可乐') #返回的是一个字典
输出结果:
{'good_food': '米饭', 'drink': '可乐'}
位置参数动态传参和关键字参数动态传参一起使用的顺序:
顺序: 位置, *args, 默认值, **kwargs
def fun(a, *args, c="哈哈", **kwargs):
print(a, args, c, kwargs)
fun(1, 2, 3, 4,5, 6)
输出结果:
1 (2, 3, 4, 5, 6) 哈哈 {}
def func(*args, **kwargs): #无敌传参
pass
聚合:形参的位置*,**:聚合 聚合:把接收到的参数组合成一个元组
打散: 实参的位置*,**: 打散 打散:把序列按顺序打散
字典的打散和聚合需要两个**
def fun(*args):
print(args)
lst = [1, 4, 7]
fun(lst) #直接输入列表,列表整体作为一个参数传入函数
fun(lst[0], lst[1], lst[2]) #输入列表的每一个元素,需要索引输入
fun(*lst) # 可以使用*把一个列表按顺序打散
s = "臣妾做不到"
fun(*s) # 字符串串也可以打散, (可迭代对象)
输出结果:
([1, 4, 7],)
(1, 4, 7)
(1, 4, 7)
('臣', '妾', '做', '不', '到')
def fun(*args, **kwargs): #聚合
print(args)
print(kwargs)
list1 = [1, 2, 3, 4]
tuple1 = (1, 2, 3, 4)
list2 = ['alex', 'wusir', 1]
dic = {'name': 'alex', 'age': 18}
fun(*list1, *tuple1, *list2, **dic) #打散
输出结果:
(1, 2, 3, 4, 1, 2, 3, 4, 'alex', 'wusir', 1)
{'name': 'alex', 'age': 18}
命名空间:
1.内置名称空间
2.全局名称空间
3.局部名称空间
作用域:
1.全局作用域:内置名称空间+全局名称空间
2.局部作用域: 局部(函数被调用)
globals() 查看全局中的内容
locals() 查看当前作用域中的内容
a = 110 # 全局
def fn(): #全局
b = 20 # 局部
def gn(): # 局部
print(globals()) # 可以查看全局作用域中的内容
print(locals()) # 查看当前作用域中的内容
gn()
fn()
输出结果:
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0327DF50>,
'__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>,
'__file__': 'C:/Users/Desktop/python.py', '__cached__': None, 'a': 110, 'fn': <function fn at 0x032507C8>}
{}
函数嵌套:函数可以互相嵌套
global :在局部访问全局中的内容
def func():
global a # 1. 可以把全局中的内容引入到函数内部 , 2. 如果全局中没有这个内容,就在全局创建一个变量
a = 20 #将20赋值给a,这个a是全局中的a,此时全局中的a为20
a += 10 # a = a+10 此时a=30
print(a) #a=30
func()
print(a)
输出结果:
30
30
nonlocal:在局部寻找外层函数中离它最近的那个变量
a = 10
def outer():
a = 1
def inner(): # 在inner中改变a的值
nonlocal a # 寻找外层函数中离他最近的那个变量
print(a) #在outer()函数中找到a,此时a=1
a = 20 #将20赋值给a
print(a) #此时a=20
inner()
outer()
输出结果:
1
20
a = 1
def fun_1():
a = 2
def fun_2():
nonlocal a
a = 3
def fun_3():
a = 4
print(a)
print(a)
fun_3()
print(a)
print(a)
fun_2()
print(a)
print(a)
fun_1()
print(a)
输出结果:
1
2
3
4
3
3
1