day10
三元运算符：
变量 = 条件成立的结果 条件判断 条件不成立的结果
补充：
# 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)
动态参数
*args ：能接收（接受任意多个）的位置参数，元组，*****在函数定义的时候叫聚合
输出的时候*args就是打散，把元组里面的东西一个个打印出来
位置参数 > 动态位置参数 > 默认参数
**kwargs ：接收的是关键字参数，字典
输出的时候*kwargs，打印出键
参数的优先级：位置参数 > 动态位置参数 > 默认参数（关键字参数） > 动态关键字参数
1、万能传参：动态位置参数 ， 动态关键字参数（最常用************）
2、位置参数，动态位置参数
3、动态位置参数，关键字参数，动态关键字参数
def func(a,b=1):
print(a,b)
func(1)
--------------------------
def func(a,b,*args): # *args是万能（接受任意多个）的位置参数，*在函数定义的时候叫聚合
print(a,b,args)
func(1,2,3,4,5,6,7,8,9)
---------------------------
def func(a,b,*args):
print(a,b,*args) # 打散
func(1,2,3,4,5,6,7,8,9)
# 位置参数 > 动态位置参数 > 默认参数
-------------------------
def func(*args , a=1, b=2):
print(a,b,args) # 元组（接收的位置参数）
func(12,15,21,11,17)
---------------------------
def func(a,b,**kwargs):
print(a,b,kwargs) # 字典（接收的关键字的参数）
func(1,2,c=1,d=2)
----------------------------
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(*args,**kwargs): # 万能传参
print(args,kwargs)
func(1,2,3,4,5,6,7,a=1,b=2,c=3)
函数释
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(funcc.__name__)
名称空间
- 内置空间：print，input，len
- 全局空间：当前py文件中定义的内容需要开辟空间存放在全局空间
- 局部空间：函数中开辟的空间就是局部空间
- 加载顺序：
内置空间 > 全局空间 > 局部空间
- 取值顺序：
局部空间 > 全局空间 > 内置空间（找不到就报错）
- 作用域：
全局作用域：内置空间+全局空间
局部作用域：局部空间
print(11)
a = 10
def func():
b = 20
print(b)
函数的嵌套
不管在什么位置，只要是函数名+()，就是在调用此函数
函数调用执行后，函数体中开辟的空间就自动销毁了
函数中套函数
def func():
print(1)
def f1():
print(2)
return f1()
func()
函数嵌套调用
def func():
a = 1
def foo():
b = 2
print(b)
print(a)
def f1():
print(b)
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)
def foo(e):
b(e)
def b(c):
print(c)
return 10
print(func(5))
global及nonlocal
global：把全局空间的变量强制放在局部空间，使局部变量可以修改全局空间里的变量
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)
print(a)
f3()
print(a)
f2()
f1()
----------------------
a = 10
def func():
global a
a += 1
def f1():
a = 10
def foo():
nonlocal a # 11 11 11 11
a += 1
print(a)
foo()
print(a)
print(a)
f1()
func()
print(a)