e.g 接受两个数字参数,将大的返回给调用者
def f(a,b)
c=a if a>b else b # 如果a>b将a的值赋给c,否则将b 的值赋给c
return c
f(10,20)
动态参数----形参
动态参数:def f( * food ) 中 *food 可以接收任意个位置参数
e.g def f(*food):
print("我要吃")
f("盖浇饭","辣条","面条")=======> 我要吃("盖浇饭","辣条","面条")
接受的结果是 tuple形式的 一个元组
动态接收位置参数: 位置混合动态 * food , 默认值 只能放后边 ,若要改变默认值参数,在形参中添加一个关键字参数即可
def f(a,b,*food) # 其中位置参数必须再前, 动态参数在后边,接受 除了前两个位置之外的所有参数
e.g
def fn( a,b,c, *arg ,d=5 )
print( a,b,c,d,arg )
fn( 1, 2,3, 7,9,8,0 )======> 1,2,3,5 (7,9,8,0) # 前边位置按照位置给a,b,c赋值 d是默认值就是5, 剩余的都被arg 接收
fn(1, 2,3, 7,9,8,0,d=88) ======>1,2,3,88 (7,9,8,0) # 位置参数复制后,d 虽然上边给了默认值,但是实参中又给参数,
就按照实参给的值赋值, 其他的还是被 arg 全部接受
fn(1, 2,3, 7,9,8,0,d=" 马大哈 ")====> 1,2,3, 马大哈 (7,9,8,0)
动态接收关键字参数 **food 两个*号
def fn(**food)
print(food)
fn( good_food=" 盖浇饭 " ,bed_good=" 辣条 ")=====> {"good_food" = " 盖浇饭 " ," bed_good"= " 辣条 " }
动态接受关键字参数 ===> 结果是返回给调用方一个 字典dict 形式
形参中====>动态参数 顺序
位置参数 ------ *参数(位置) ----- 默认值参数 ---- ** 参数(关键字)
*参数 接收的参数 以元组的形式返回 *(lst,str,tuple...) 打散这些类型,将其中参数传给函数 元组形式(迭代产生)
**参数 接收的 以字典 形式 返回 **dic 只能打散字典 以字典形式 传给函数(迭代产生的)
def f(*arg ,**kwarg):
print(*arg)
print(**kwarg)
f(1,2,3,sex="男",age=18)=====>(1,2,3)
{"age"="18", " sex "="男 "}
lst=["麻花藤","大阳哥""杰哥"] 将列表中的元素传递到函数中
fn(*lst)------>("麻花藤","大阳哥""杰哥") # *lst 是将列表打散,然后再将其聚合到 元组 中
fn("hujie")===> ( "h","u","j","i","e" ) # 将字符串中内容打散,再聚合到元组中
dic={ "name": 大白,"性能": 超人 }
fn(name=dic["name"],性能=dic["性能"])====>{ "name": 大白,"性能": 超人 }
fn(**dic)=====>{ "name": 大白,"性能": 超人 } # 将字典打散,以key-value 形式进行传参
函数的注释形式
def f(a,b):
'''
计算a+b的和 , 返回一个数
:param a: 第一个数
:param b :第二个数
:return: 返回计算后的和
'''
return a+b
f(2,3)
命名空间和作用域
命名空间:
1. 内置命名空间: python 解释内部运行时的变量函数 例如: type...list ...
2. 全局命名空间: 在py文件中,我们在函数外声明的变量,都属于全局命名空间
3. 局部命名空间: 在我们函数声明的变量,都是在局部命名空间中 函数中的
作用域:
1. 全局作用域: 全局命名空间+内置命名空间
2.局部作用域:局部命名空间
通过global s () 函数 来获取查看 全局作用域的内容 和global 不一样
locals() 函数 查看当前作用域中的所有名字
e.g
a=123 # 全局
b=12 #全局
def f(): #全局
c=麻花藤 # 局部
def fn(): #局部
pass
找值顺序 就近原则
a=10
def fn():
a=20
print(a) # 就近原则,先找同层的 当a=20 不存在时, print(a)=10
d但是, a=20,存在, print(a)=20
fn()
print(a)====> 和它同级的a=10, 因此0
e.g a=10
def f():
global a # 将全局变量a 引进来,a=a+10, 将全局变量赋
a=a+10 值为 20, 这时 全局变量 a=20 整个都变了
print(a)#### 找值,本层中没有a, 因此会报错 原来的全局变量已经不存在了
只有将全局变量引进了,在a=a+10
上边加个 global a
f()
print()
global a 是将全局变量 a 引入局部中 ,外边的全局变量 就不存在了
这时 a 不再是局部变量 变为了 全局变量 ,若将其重新赋值,整个函数的全局变量 a 也会改变
nonlocal a 是在局部作用域中,将离他最近层的 a 拿过来, 不会找全局 ,如它父级没有 a 则会报错, 若有的话拿过来后做改变,原位置a 也会改变, 但是还在
e.g
a = 1 #1
def fun_1(): #4
a = 2 #5
def fun_2(): #8
nonlocal a #9 调用父级的 a=2
a = 3 #10 将父级的a=2 全新赋值 为 a=3
def fun_3(): #13
a = 4 #14
print(a) #15 四打印 同级的 a=4
print(a) #11 三打印 同级赋过值的 a=3
fun_3() #12
print(a) #16 五打印 同级的 a=3
print(a) #6 二打印 同级的 a=2
fun_2() #7
print(a) # 17 打印同级的a, 但是a 被 第十步, 引入到子级中 被重新赋值为3, 所以六打印a=3
print(a) # 2 一打印 同级的a=1
fun_1() #3
print(a) # 七打印 同级 a=1
结果====> 1 2 3 4 3 3 1
函数的嵌套
1. 只要遇到 f( )就是函数的调用 , 若没有f() 就不执行
2. 函数的执行顺序: 一层一层的, 看到定义的函数,只有看到 f( ) 调用了才去执行
def f1(): #2 定义
print("赵") #3
def f2(): #6
print("钱") #7
def f3():#10
print("孙") #11 =======> 赵周钱李孙
print("李") #8
f3() #9
print("周") #4
f2() #5
f1() #1