動的パラメータ
# *args(args 可以更换，建议使用args)
# 万能参数，可以接受任意多个位置参数
# *在函数定义的时候叫聚合
# 万能参数
# 一个位置参数
# 一般位置函数
def func(a,b=1):
print(a,b)
func(1)
# 输出
# 1 1
def func(*args):
print(args)
func(1,2,3,4,5,6,7)
# 输出一个元组
# (1, 2, 3, 4, 5, 6, 7)
# 任意多个位置参数
def func(a,b,*args):
print(a,b,args)
func(1,2,3,4,5,6,7)
# 输出
# 1 2 (3, 4, 5, 6, 7)
# 去掉*，打散
def func(*args):
print(*args)
func(1,2,3,4,5,6,7)
# 输出元素
# 1 2 3 4 5 6 7
# 动态位置参数：
# 先传参*args,再传默认参数
# 元组（接受的是位置参数）
# 可以打散
# 位置参数，放在后面
def func(*args,a=1,b=2):
print(args,a,b)
func(1,2,3,4,5,6,7)
# 输出
# (1, 2, 3, 4, 5, 6, 7) 1 2
# 位置参数，放在前面，先执行默认参数
def func(a=1,b=2,*args):
print(a,b,args)
func(1,2,3,4,5,6,7)
# 输出
# 1 2 (3, 4, 5, 6, 7)
# 去掉*，可以打散
def func(*args,a=1,b=2):
print(args,a,b)
func(1,2,3,4,5,6,7)
# 输出
# 1 2 3 4 5 6 7 1 2
# 优先级
# 位置参数>动态位置参数>默认参数
def func(a,b,*args,c=1,d=3):
print(a,b,args,c,d)
func(1,2,3,4)
# 输出 1 2 (3, 4) 1 3
# 打散后是源数据类型
def func(a,b,*args,c=1,d=3):
print(a,b,*args,c,d)
func(1,2,3,4)
# 输出 1 2 3 4 1 2
# **kwargs
# 字典（接受的是关键字参数）
# 不能打散，打散后只有键
# 关键字参数
def func(a,b,**kwargs):
print(a,b,kwargs)
def func(a,b,**kwargs):
print(a,b,kwargs)
func(1,2,c=1,d=4)
# 输出 1 2 {'c': 1, 'd': 4}
# 不能打散，打散后只有键
def func(a,b,**kwargs):
print(a,b,*kwargs)
func(1,2,c=1,d=4)
# 输出1 2 c d
# *args **kwargs
# 万能传参
def func(*args,**kwargs):
print(args,kwargs)
func(1,2,3,a=1,b=3,c="78")
# 输出
# (1, 2, 3) {'a': 1, 'b': 3, 'c': '78'}
# 参数的优先级：位置参数 > 动态位置参数 > 默认参数（关键字参数） > 动态关键字参数
# 1、万能参数：动态位置参数，动态关键字参数（常用*args，**kwargs）
# 2、位置参数，动态位置参数
# 3、动态位置参数，关键字参数，动态关键字参数
# 列表用*打散成元组
lst = [12,3,45,]
def func(*args):
print(*args)
# func(lst[0],lst[1]) 之前的方法
func(*lst)
# 输出 12 3 45
# 字典用*打散成
dic = {"key":1,"key1":34}
def func(**kwargs):
print(kwargs)
func(**dic)
# 输出 {'key': 1, 'key1': 34}
名前空間
# 内置空间：python自带的方法
# eg:print input len range
# 每一次运行加载内置空间
#
#
# 全局空间：当前py文件中需要开辟的空间存放在全局空间
# 每一次运行加载全局空间
#
#
# 局部空间：函数中开辟的空间就是局部空间
#
# 加载顺序：
# 内置>全局>局部
#
# 取值顺序：
# 局部>全局>内置（找不到会报错）
#
# 作用域：
# 全局作用域：
# 泛指内容：内置空间+全局空间
#
# 局部作用域
# 只指局部空间
ネスティング
# 不管在什么位置，只要是函数名+()就是调用此函数
# 函数调用执行后,函数体在开辟的空间就自动销毁了
# 如何传参就如何退参
def func():
a = 1
def foo():
b = 2
print(b)
print(a)
def f1():
print(b)
return f1()
return foo
print(func())
# 没有调用函数foo
#输出 没有值
def func():
a = 1
def foo():
b = 2
print(b)
print(a)
def f1():
print(b)
return f1()
return foo()
print(func())
# 输出
# print(b) 2
# print(a) 1
# print(b) 2
# print(func()) None
# 函数互相引用
def func():
a = 1
foo()
print(a)
def foo():
b = 2
print(b)
func()
# 调用结果
# 2
# 1
# 输出的为内容地址,函数之间不能共用，只能取全局找，
# 全局找到的是函数名，内存地址
def a():
a =1
c()
print(c)
def b():
b =2
print(b)
def c():
c =3
print(a)
def run():
a()
run()
# 输出
# <function a at 0x10d2f81e0>
# <function c at 0x10d3bb268>
def func():
a = 1
def b():
print(a)
def foo():
b =1
def z():
print(func)
print(b)
ret = z()
func()
return ret
def run():
foo()
print(run())
# 输出
# 地址
# 1
# None
def func(a):
foo(a)
def foo(e):
b(e)
def b(c):
print(c)
return 10
print(func(5))
値を変更します。
# global 声明强制修改全局变量
# 局部不能修改全局，是出于安全考虑
a = 10
def func():
global a # 声明改变全局变量的值
a += 1
print(a) # 11
func()
print(a) # 11
# 输出11
a = 10
def f1():
a = 10
def f2():
a =15
def f3():
global a
a += 1
print(a)#11 第3个结果
print(a)#15 第2个结果
f3()
print(a)#10 第1结果
f2()
f1()
# nonlocal 在最外层的函数中修改局部空间的变量值，只修改离他最近的一层
# 找的上一层没有，继续向上找，直到找到最外层函数
a = 10
def func():
def f1():
a = 30
def foo():
nonlocal a
a += 1
print(a) # 31
foo()
print(a) # 31
f1()
func()
print(a) # 10
a = 10
def func():
def f1():
a = 30
def foo():
nonlocal a
a += 1
print(a)# 31 第1步
foo()
print(a)# 31 第2步
f1()
func()
print(a) #10 第3步
今日の要約
# 1、函数的动态参数
# *args,**kwargs 万能传参 参数名字可以换
# 能够接受动态的位置参数和动态的关键字参数
# *args - tuple
# 打散的是源数据类型
# **kwargs - dict
# 打散的是字典的键
# 定义阶段(*,**是聚合作用)
# 使用阶段(*是打散作用)
# 优先级：位置>动态位置>默认>动态关键字
#
#
# 2、函数的注释
# 每次写函数的时候都需要写注释
# """
# 函数名.__doc__
# """
#
# 3、名称空间
# 内置空间：python解释器自带的
# 全局空间：当前文件(.py文件)
# 局部空间：函数体开辟的空间
#
# 加载顺序：内置>全局>局部
# 取值顺序：局部>全局>内置
#
# 作用域：
# 全局作用域：内置+全局
# 局部作用域：局部
#
#
# 4、函数嵌套
# 函数中套函数
# 函数嵌套调用
# 函数嵌套参数的传递
# 函数嵌套返回值的传递
#
# 5、global nonlocal
# global：修改全局空间变量对应的值
# nonlocal：在外层的函数中，修改局部空间的变量值，完全步涉及全局变量
# 只修改离他近的上一层，最近的没有变量再向上找，直到找到最外层函数
#
# global于nonlocal不共用
#
# 6、三元运算符
# a = 10
# b = 20
# c = a if a >b else b
# 变量名 = 条件成立的结果 条件 不成立的结果