[toc]
python基 础十一 函数
1.函数的作用
封装代码,大量的减少重复代码,重用性高
2.函数的定义
def 函数名():
函数体
def 是一个关键字，申明要定义一个函数
():是固定写法
函数体中写的是需要用到的重复代码
3.函数的调用
函数名()
4.函数的返回值
#函数返回值总结
函数体中不写return默认返回None,或者写了return不写值返回的也是None
return 能够返回任意数据类型(python中所有对象)
return 能够返回多个数据类型,以元组的形式接收
return 能够终止函数,return下方的代码不执行
return 将返回值返回给调用者
//return示例
def func():
a = 10
return a
a = func()
print(a)
5.函数的参数
5.1位置参数
//函数参数示例
def hehe(app): //形参数
print ("打开:",app) //注意必须用逗号隔开
hehe("微信") //实参
执行结果返回如下：
打开: 微信
//位置参数示例
def ball(web, players, age, addr): #形参
print("登陆NBA官网")
print(f"打开{web}")
print(f"找一位{players},要求年龄:{age},地区:{addr}的人")
print("看看视频")
print("学学球技")
ball("视频专区", "球员", 28, "洛杉矶") #实参 按照位置传参
登陆NBA官网
打开视频专区
找一位球员,要求年龄:28,地区:洛杉矶的人
看看视频
学学球技
5.2 默认参数
//默认参数示例
def ball(web, players, age, addr="洛杉矶"): #addr="洛杉矶"表示默认参数
print("登陆NBA官网")
print(f"打开{web}")
print(f"找一位{players},要求年龄:{age},地区:{addr}的人")
print("看看视频")
print("学学球技")
ball("视频专区", "球员", 28) #实参这里可不写形参中定义的默认值
ball("视频专区","球员",30,"波士顿") #实参写内容会覆盖形参中定义的默认参数
登陆NBA官网
打开视频专区
找一位球员,要求年龄:28,地区:洛杉矶的人
看看视频
学学球技
登陆NBA官网
打开视频专区
找一位球员,要求年龄:30,地区:波士顿的人
看看视频
学学球技
5.3 关键字传参
//关键字传参示例
def fun(a,b,c=1,d=2):
print (a,b,c,d)
fun(1,2,3,4) //结果是1 2 3 4
fun(a="呵呵",b="哈哈") //结果是呵呵 哈哈 1 2
fun(1,2,d="呵呵") //结果是1 2 1 呵呵
5.4 动态参数 *args
5.4.1 动态参数作用
1.能够接受不固定长度的参数
2.位置参数过多时可以使用动态参数
5.4.2 动态参数使用方法
def func(*c): #形参位置上的*是聚合
print(*c) #函数体中的*就是打散
func(1,2,3,4,5,6,7,8,9,0)
结果如下：
1 2 3 4 5 6 7 8 9 0
def func(a,b,*c): # *c就表示动态参数
print (a,b,*c)
func(1,2,3,4,5,6,7,8)
1 2 3 4 5 6 7 8
5.5 动态关键字参数 **kwages
5.5.1 动态关键字参数作用
只接收多余的动态位置参数 注意是只接收
5.5.2 动态关键字参数使用方法
//动态关键字使用方法示例1
def func(a,b,**kwargs):
print (kwargs)
func(a=1,b=2,c=3,d=4,e=5)
结果如下：
{'c': 3, 'd': 4, 'e': 5}
//动态关键字参数使用方法示例2
dic = {"key": 1, "key2": 2}
def func(**kwargs): #聚合
print(kwargs) #打散
func(**dic) #打散 func(key=1,key2=2)
结果如下：
{'key': 1, 'key2': 2}
5.6 函数参数面试题
#万能传参
def func(*args, **kwargs):
print(args, kwargs)
func(12, 2, 121, 12, 321, 3, a=1, b=2)
结果如下
(12, 2, 121, 12, 321, 3) {'a': 1, 'b': 2}
*xargs获取的是一个元组
**kwargs获取的是一个字典
#*args和**kwargs
def func(*args, a1=8,**kwargs): #万能传参
print(args, kwargs) #函数体中的*args是将元组打散,*kwargs是将字典的键获取到
func(12, 2, a1=1, b1=2)
结果如下：
(12, 2) {'b1': 2}
5.7 函数参数总结
#参数的总结:
1.形参
在定义函数的阶段就是形参
可以单独使用位置参数,也可以单独使用默认参数,也可以混合使用
位置传参:必须一一对应
默认参数:可以不传参,可以传参,传参就是把默认的值给覆盖
混合使用:位置参数,默认参数
2.实参
在调用函 数的阶段就是实参
可以单独使用位置参数,也可以单独使用关键字参数,也可以混合使用
位置传参:必须一一对应
关键字参数:指名道姓的方式进行传参
混合使用:位置参数,默认参数
3.参数总结
位置参数,动态位置,默认参数,动态关键字参数
*args 程序员之间约定俗称(可以更换但是不建议更换)
**kwargs 程序员之间约定俗称(可以更换但是不建议更换)
*args 获取的是一个元组
**kwargs 获取的是一个字典
*args 只接受多余的位置参数
**kwargs 只接受多余的关键字参数
4.函数参数优先级
数参数优先级: 位置参数 > 动态位置参数(可变位置参数) > 默认参数 > 动态关键字参数(可变关键字参数)
6.函数的注释
#注释方法1
def a(a,b):
"""
数字加法运算
:param a: int
:param b: int
:return: int
"""
return a + b
print (a(1,2))
#注释方法2
def func(a:int,b:int): #这里的a:int只是做到一个约束，并没有实际作用
"""
加法运算
:param a:
:param b:
:return:
"""
return a + b
print (func(1,2))
//查看函数的注释 func.__doc__
print (func.__doc__)
加法运算
:param a:
:param b:
:return:
//查看函数的名字 a.__name__
代码在编写过程中会设计到函数名赋值，例如
def func(a,b):
return a + b
a = func
print (a(1,2))
print (a.__name__)
func
7.函数的名称空间
7.1函数名称空间分类
1.内置空间 -- 存放pyhton自带一些函数
2.全局空间 -- 当前py文件顶格编写的代码开辟的空间
3.局部空间 -- 函数开辟的空间
程序加载顺序: 内置空间 > 全局空间 > 局部空间
程序取值顺序: 局部空间 > 全局空间 > 内置空间
//代码示例
a = 10 #这里的10是全局变量
def func():
a = 5 #这里的5是局部变量
print (a)
print (func())
5
None
7.2函数的作用域
1.全局作用域: 内置 + 全局 globals() #查看全局作用域
2.局部作用域: 局部 locals() #查看当前作用域(建议查看局部)
//代码示例 查看全局
a = 10
b = 20
print (globals())
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7ffe70016710>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/jetBrains/pycharm/python-works/python基础/test.py', '__cached__': None, 'a': 10, 'b': 20}
//代码示例 查看局部
def func():
a = 10
print (locals())
func()
{'a': 10}
8.函数的第一类对象
8.1总概
1.函数名可以当做值,赋值给一个变量
2.函数名可以当做另一个函数的参数来使用
3.函数名可以当做另一个函数的返回值
4.函数名可以当做元素存储在容器中
8.2 函数名可以当作值，赋值给一个变量
//代码示例
def func():
print(1)
a = func #函数名是func，然后赋值给了a，打印a与func的函数内存空间地址一样，并且执行a()相当于执行func()
print(func) #函数的内存地址 <function func at 0x7fb2b00d0e18>
print(a) #函数的内存地址 <function func at 0x7fb2b00d0e18>
a() #结果 1
8.3 函数名可以当作另一个函数的参数来使用
//代码示例
def func():
print(1)
def foo(a): #a = func <function func at 0x7fb2b00d0e18>
print(a) #func这个函数的内存地址 <function func at 0x7fb2b00d0e18>
foo(func)
func函数当作了foo函数的参数
8.4 函数名可以当作另一个函数的返回值
//代码示例
def func():
return 1 #print
def foo(a): #a = func函数的内存地址
return a #return func函数的内存地址
cc = foo(func)
print(cc) #func函数的内存地址 <function func at 0x7fe160020e18>
8.5 函数名可以当作元素存储在容器中
容器：字典、元组、列表、集合
//代码示例
def func():
print(1)
def foo():
print(2)
def f():
print(3)
lst = [func,foo,f]
⚠️将函数放在容器中的好处，可以使用for循环批量执行函数，而不是一个一个执行
for i in lst:
i()
1
2
3
//代码示例 购物平台
⚠️整体思路
1.定义5个函数，模拟购物平台注册、登陆
2.将这5个步骤的函数存入字典中
3.让用户选择要执行的操作，然后执行函数完成功能实现
def register():
print("注册")
def login():
print("登录")
def shopping():
print("浏览商品")
def add_shopping_car():
print("加入购物车")
def buy_goods():
print("购买")
msg = """
1.注册
2.登录
3.浏览商品
4.加入购物车
5.购买
请输入您要选择的序号:
"""
func_dic = {"1": register, "2": login, "3": shopping, "4": add_shopping_car, "5": buy_goods}
while True:
choose = input(msg)
if choose in func_dic:
func_dic[choose]()
else:
print("退出商城")
9.函数的嵌套
9.1 分类
1.交叉嵌套
2.嵌套
9.2 交叉嵌套
9.2.1 交叉嵌套示例1
def func(foo):
print (1)
foo()
print (3)
def a():
print (1)
func(a)
1
1
3
上述代码进一步说明
def func(foo):
print(1)
v = foo() #第一个功能是调用函数,第二个功能是接收返回值
#v = None
#print(v) #None
print(3)
1
1
None
3
9.2.2 交叉嵌套示例2
//代码示例
def func():
print(1)
print("太难")
print(2)
def foo(b):
print(3)
b()
print(4)
def f(a,b):
a(b)
f(foo,func)
最终结果
3
1
太难
2
4
9.2.3 交叉嵌套示例3
def func(a,b):
def foo(b,a):
print(b,a)
return foo(a,b)
a = func(4,7)
print(a)
结果
4 7
None
9.2.4 交叉嵌套示例4
//代码示例1
def func(a,b):
a = a + b
b = a + 10
def foo(a,d):
def f(e,f):
print(f,e)
return "呵呵"
f(d,a)
foo(b,a)
print(func(2,3))
结果
15 5
None
⚠️return "呵呵"返回给了f，f是foo函数的最后一行，默认返回None，foo又是func函数的最后一行，默认返回None
//代码示 例2
def func(a,b):
a = a + b
b = a + 10
def foo(a,d):
def f(e,f):
print(f,e)
return "呵呵"
return f(d,a)
return foo(b,a)
print(func(2,3))
结果
15 5
呵呵
10. 函数关键字global与nonlocal
10.1 global
global
1.global只修改全局空间中的变量
2.在局部空间中可以使用全局中的变量,但是不能修改,如果要强制修改需要添加global
3.当变量在全局存在时global就是申明我要修改全局的变量,并且会在局部开辟这个变量
4.当变量在全局中不存在时global就是申明要在全局创建一个变量,并且会在局部开辟这个变量
1.函数中加关键字global对全局变量进行修改
//不加global关键字
a = 10
def func():
a += 1
func()
print(a)
结果报错
UnboundLocalError: local variable 'a' referenced before assignment
当全局变量a存在时
//使用glboal关键字，global关键字申明变量a是全局变量
a = 10
def func():
global a #申明要修改全局的变量a
a += 1
func()
print(a)
结果：
11
当全局变量a不存在时
//使用global关键字申明并创建全局变量a
def func():
global a
a = 10
func()
print(a)
结果：
10
当变量在全局存在时globla就是申明我要修改全局变量，并且会在局部开辟同名变量
当变量在全局不存在时global就是申明要在全局创建一个变量
10.2 nonlocal
nonlocal
1.nonlocal只修改局部空间中的变量,最外层的一个函数
2.只修改离nonlocal最近的一层,如果这一层没有就往上一层查找,只能在局部
3.nonlocal 不能进行创建
nonlocal只修改局部空间中的变量，最外层的一个函数
只修改离nonlocal最近的一层函数，如果这一层没有就往上一层查找，只能在局部
//代码示例1
def func():
a = 10
def foo():
a = 20
def f():
nonlocal a
a += 1
print(a)
f()
foo()
func()
结果：
21
//代码示例2
a = 15
def func():
a = 10
def foo():
def f():
nonlocal a
a += 1
print(a) #11
print(a) #10
f()
foo()
print(a) #11
func()
print(a) #15
结果：
10
11
11
15
global与nonlocal结合示例
a = 10
def func():
a = 5
def foo():
a = 3
def f():
nonlocal a
a += 1
def aa():
a = 1
def bb():
global a
a += 1
print(a) #11
bb()
print(a) #1
aa()
print(a) #4
f()
print(a) #4
foo()
print(a) #5
func()
print(a) #11
结果：
11
1
4
4
5
11
