三元运算符:
# 变量 = 条件成立的结果 条件判断 条件不成立的结果
a = 30
b = 20
c = a if a > b else b
print(c)
1.函数的动态参数
*args,**kwargs (能够接受动态的位置参数和动态的关键字参数)
定义阶段(*args,**kwargs) 聚合
*args - tuple
**kwargs -- dict
使用阶段*args,*kwargs 打散
*args - 源数据类型
*kwargs - 打散是字典的键
优先级: 位置 > 动态位置> 默认 > 动态关键字
lst = [12,23,3,4,5,6]
def func(*args):
print(*args)
func(lst[0],lst[1]) # 笨的办法
func(*lst)
dic = {"key":1,"key1":34}
def func(**kwargs):
print(kwargs)
func(**dic)
2.函数的注释
"""
每次写函数的时候需要写注释
函数名.__doc__
"""
3.名称空间
内置空间: Python解释器自带的
全局空间: 当前文件(.py文件)
局部空间: 函数体开辟的空间
加载顺序: 内置 > 全局 > 局部
取值顺序: 局部 > 全局 > 内置
作用域:
全局作用域: 内置 + 全局
局部作用域: 局部
4.函数嵌套
函数中套函数
函数嵌套调用
函数嵌套参数的传递
函数嵌套返回值的传递
5.global nonlocal
global 秀爱全局空间的变量对应的值
nonlocal 在外层的函数中,修改局部空间的变量值,完全不干涉全局变量
# 只修改离它最近的一层,醉的一层没有变量继续向上找,直到找到找到最外层函数
6.三元运算符
a = 10
b = 20
c = a if a > b else b
1.函数的动态参数
def func(a, b=1):
print(a, b)
func(1)
*args
def func(a, b, *args): # *args 是万能(接受任意多个)的未知参数 *在函数定义的时候叫做聚合
print(a, b, args)
func(1, 2, 3, 4, 5, 6)
def func(a, b, *args): # *args 是万能(接受任意多个)的未知参数 *在函数定义的时候叫做聚合
print(a, b, *args)
func(1, 2, 3, 4, 5, 6)
未知参数 > 动态位置参数 > 默认参数
def func(*args, a=1, b=2):
print(a, b, args) # 元组(接受的位置参数)
func(12, 23, 43, 54, 654)
*kwargs
def func(a, b, **kwargs):
print(a, b, kwargs) # 字典(接受的关键字的参数)
func(12, 21, f=3)
def func(a, b, *args, c=1, d=2):
print(a, b, *args, c, d)
func(1, 2, 3, 4)
def func(a, b, *args, c=1, d=2, **kwargs):
print(a, b, *args, c, d, kwargs) # *kwargs -- 获取到的字典的键
func(1, 2, 3, 4, c=8, d=10, e="alex", f="wusir")
综合
def func(*agrs, **kwargs): # 万能传参
print(agrs, kwargs)
func(1, 2, 3, 4, 5, 6, 7, 8, a=1, b=2, c=3)
总结
# 参数的优先级: 位置参数 > 动态位置参数 > 默认参数(关键字参数) > 动态关键字参数
# 1.万能参数; 动态位置参数,关键字参数(最常用***********)
# 2.未知参数,动态位置参数
# 3.动态位置参数,关键字参数,动态关键字参数
2.函数的注释
def func(a,b):
"""
逻辑判断...
:param a: str
:param b: int
:return: bool
"""
print(a,b)
def func1(user,password):
"""
密码加密
:param user: 用户名 str
:param password: 密码 str
:return: 加密的密码 MD5
"""
print(user,password)
print(func.__doc__)
print(func1.__doc__)
print(func.__name__)
3.名称空间
print(11)
a=10
def func():
b = 20
print(b)
内置空间: print input len
全局空间: 当前.py文件需要开辟的空间存放在全局空间
局部空间: 函数中开辟的空间就是局部空间
加载顺序:
内置空间 > 全局空间 > 局部空间
取值顺序:
局部空间 > 全局空间 > 内置空间(找不到就报错了!)
作用域:
全局作用域: 内置空间 + 全局空间
局部作用域: 局部空间
4.函数的嵌套
def func():
print(1)
def f1():
print(2)
return f1()
func()
不管在什么位置,只要是函数名+() 就是在跳用此函数
函数调用执行后,函数重新开辟的空间就自动销毁
def func():
a = 1
def foo():
b = 2
print(b) # 2
print(a) # 1
def f1():
print(b) # 2
return f1()
return foo()
print(func())
函数的调用
def func():
a = 1
foo()
print(a)
def foo():
b = 2
print(b)
func()
def a():
a1 = 1
c()
print(c)
def b():
b1 = 2
print(b1)
def c():
c1 = 3
print(a)
def run():
a()
run()
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())
def func(a):
foo(a) #10
def foo(e):
b(e) # return 10
def b(c):
print(c)
return 10
print(func(5))
5.gloabal,nonlocal
def func():
global a # 声明修改全局变量的值
a += 1
print(a)
func()
print(a)
a = 10
def f1():
a = 10
def f2():
a = 15
def f3():
global a
a += 1
print(a) # 11
print(a) # 15
f3()
print(a) # 10
f2()
f1()
a = 10
def func():
def f1():
global a
a += 1
def foo():
nonlocal a
a += 1
print(a) # 31
foo()
print(a) # 31
f1()
func()
print(a) # 10
总结
global : 修改全局空间的变量对应的值
nonlocal :在外层的函数中,修改局部空间的变量值.完全不涉及全局变量,
只修改离它最近的一层,最近的一层没有变量继续向上找,直到找到最外层函数