目录
0 昨日复习
0.1 函数
- 定义阶段：只识别语法，不执行函数体代码
- 调用阶段：执行函数体代码
0.2 定义
def 函数名():
代码块
0.3 三种形式的函数
0.3.1 无参函数
def 函数名():
代码块
0.3.2 有参函数
def 函数名(x,y):
代码块
0.3.3 空函数
def 函数名():
pass #以后再输入
0.4 函数的返回值
返回值是通过return关键字返回的
def 函数名():
pass #默认返回none
def self_max(x,y)
if x > y:
return x
else:
return y
max_num = self_max(10,20)
print(max_num * 2) # 40
def get_list():
return [1,2,3],len([1,2,3])
get_list() #([1,2,3],3)
# 返回多个值的时候，会用元组接收多个值
return 除了返回值的作用，还有终止函数的作用，即不运行return后面的代码，也就是说一个函数可以有多个return，只要遇到第一个return就终止了
0.5 函数的调用
普通的调用：
def f1():
pass
f1()
调用后做处理：
def self_max(x,y)
if x > y:
return x
else:
return y
max_num = self_max(10,20)
print(max_num * 2) # 40
0.6 函数参数的应用
0.6.1 形参
定义阶段的参数叫形参，形参具有描述意义，不是一个具体的值
0.6.2 实参
调用阶段传入的值，是一个具体数据类型的值
0.6.3 位置形参
从左到右放入
0.6.4 位置实参
从左到右与形参一一对应
0.6.5 默认形参
def f1(y,x=1):
return x+y
z = f1(2) #y = 2,x = 1
print(z)
一般用于形参经常使用同一个值的时候，默认形参必须在位置形参的后面
0.6.6 关键字实参
def f1(x,y,z):
return x+y
a = f1(z,y = 2,x = 1) #y,z = 2,x = 1
print(a)
一般用于参数较多的时候，指定传值，可以打乱顺序传值，关键字实参必须的在位置实参的后面
0.7 可变长参数
0.7.1 *形参
def f1(*args):
print(args) # 以元组的形式输出
return args #以元组的形式返回
f1(1,2,3,4) # 此时数据个数不限
0.7.2 *实参
def f1(x,y,z,u):
print(f'x:{x},y:{y},z:{z},u:{u}')
args = (1,2,3,4) #定义一个元组，元组个数必须与形参个数相同才能在下一步用*args当实参
f1(*args)
0.7.3 **形参
def f1(**kwargs):
print(kwargs) #以字典的形势输出 ，kwargs = {'a':1,'b':2,'c':3,'d':4}
f1(a=1,b=2,c=3,d=4) #此处必须为关键字实参，个数不限
0.7.4 **实参
def f1(a,b,c):
print(f'a:{a},b:{b},c:{c}') #输出a:7,b:4,c:2
kwargs = {'b':4,'c':3}
f1(9,**kwargs)
0.7.5 最终
def f1(*args,**kwargs): #这样子定义形参，不论实参怎么输入，函数都能接收到
print(args,kwargs)
f1(1,2,3,,4,5,x=1,t=9)
1 函数对象
1.1 引用，赋值
def f1():
print(123)
a = f1 # 此时a与f1有一样的功能，是一个函数
print(id(f1)) # 输出f1的位置
print(type(f1)) #输出f1的类型，function
a() # 等价于 f1()
print(a) # 输出
1.2 当做函数的返回值
def f2():
return(f1()) #返回的是f1()运行后的结果
return(f1) #返回的是f1的内存地址
def f1():
print(147)
1.3 当作函数的参数
def f2(m):
m() #此时要求形参必须是一个函数的名称，不然会报错的吧
def f1():
print(147)
f2(f1)
1.4 作为容器元素的元素
def f1():
print(1450)
list = [1,2,f1]
list[2]() #此时list[2]即为f1
1.5 练习
def weixin():
print("微信支付成功！")
def zhifubao():
print("支付宝支付成功！")
dict = {'0':weixin,'1':zhifubao,'2':'跑单'}
dict_print = {'0':'weixin','1':'zhifubao','3':'跑单'}
while True:
print(dict_print)
choice = input("请选择你的支付方式--->").strip()
if choice == '0' or choice == '1':
dict[choice]()
elif choice == '2':
print("2b，那你还不快跑！")
else:
print('傻逼，看不懂人话？')
break
2 函数的嵌套
# # 定义阶段只检查语法，不执行代码
def f1():
def f2():
print(125)
f2()
f1()
# 通过输入指令来输出圆的周长和面积 (傻逼采用嵌套）
from math import pi
def circle(r,action):
if action == 'p':
def perimeter():
return 2*pi*r
res = perimeter()
elif action == 'a':
def area():
return pi*r**2
res = area()
else:
res = '傻逼，输错了'
return res
r_choice = int(input("请输入半径>>>").strip())
action_choice =input("选择你所需要的功能，计算面积：'p',计算周长：'a'>>>")
res=circle(r_choice,action_choice)
print(res)
3 名称空间与作用域
名称空间：存放名字的空间
3.1 内置名称空间
定义：python自带的（有点像小整数池）
生命周期：python启动的时候就活了，python关闭了就死了
'str'.strip() # 之前所学的内置方法都是一个个被封装好的函数，被封装后具有了某种功能
list = [1,2,3,4]
len(list)
# len是python的内置方法，python启动的时候，就会定义len函数，并把len丢入到内存空间中去
# 这个内存空间叫做内置名称空间 （有点像小整数池）
3.2 局部名称空间
定义：函数内部的都叫局部，也就是说函数内部定义的名字都放入了局部名称空间中
生命周期：函数运行的时候会活，运行完就死了
def f1():
def f2():
pass
f2()
3.3 全局名称空间
定义：除了内置和局部，剩下的都是全局名称空间
生命周期：程序/文件运行的时候才会活，运行完就死了
3.4 执行顺序和查找顺序
- 执行顺序：内置名称空间 ---> 全局名称空间 ---> 局部内置空间
- 查找顺序：从当前名称空间开始查找，然后逐步往上，如果当前为局部，则顺序为 局部--->全局--->内置
x = 1
def f1():
x = 2
print(2,x) # 输出2，2
x = 3
print(1,x) #输出1，3
f1()
3.5 作用域
- 全局作用域：适用于全局+内置，也就是全局可以修改内置的，内置的可以修改全局的
- 局部作用域：只适用于局部范围
- 作用域关系在函数定义阶段就已经确定了
- 函数与函数之间可能存在相同的变量名，但他们是毫无关系的，作用域不同
def f1():
x = 1
def f2():
print(1,x)
return f2
# f1() #f2
f2 = f1() #f2()
x = 10
def f3():
x = 15
print(2,x)
f2()
f3()
3.6 global and nonlocal (了解)
# global:局部修改全局
x = 100
def f1():
global x
x = 1
print(1,x) #输出 1，1
f1()
print(2,x) # 输出2，1
# nonlocal:把局部改成外部
x = 10
def f1():
x = 1
def f2():
nonlocal x #声明x是外部，嵌套函数的内部的外部,不能修改全局
x = 3
f2()
print(1,x)
print(2,x)
f1()