函数

一.函数

1.函数定义

# 定义一个函数:
def my_len():
    函数体

# def 关键字 -- 定义
# func 函数名 -- 和变量定义规则一样
# ()   必须要写格式 
# : 声明语句结束

2.参数

# 形参: 函数的定义中括号里是形参
# 实参: 函数的调用括号里是实参
# 位置传参时 形参和实参必须一一对应
# 传参: 将实参传递给形参的过程就是传参

1.位置参数
def fun(a,b):
    print(a,b)
fun("A","B")

2.默认参数
def fun2(a=1,b=2):
    pass
# fun2()           #不传参，默认打印1，2
# fun2(a=10,b=20)  #传参，覆盖

3.混合参数(位置参数必须在默认参数前面)
def fun3(a,b,c=1):
    print(a,b)
fun3(1,2,c=10)      

4.仅限关键字参数(必须在*args和**kwargs之间，如c)
def fun4(a,*args,b=10,c,**kwargs)
    print(a,*args,b,c,kwargs)         #1 12 10 20 {'m': 10}
fun4(1,12,b=10,c=20,m=10)       #注意实参必须是c=10

3.动态参数

#参数优先级：位置参数>动态参数>默认参数>动态关键字
'''
def fun(a,b,*args,c=1,d=2,**kwargs):
	print(a,b,args,c,d,kwargs)
fun(1,2,3,4,e=5,f=6)    #1 2 (3,4) 1 2 {e:5,f:6}
'''

1.动态位置参数
	--函数定义时星号加变量(*args)将传入的值聚合为元组赋值给变量args，在函数内部使用时星号加变量(*args)为打散
def fun(*args):
    print(args)          #打印元组, (1,2,3)
    print(*args)        #打散      1,2,3
fun(1,2,3)  

2.动态默认参数
	--函数定义时双星号加变量(**kwargs)将传入的关键参数聚合为字典赋值给变量kwargs，在函数内部使用星号加变量(*kwargs)将键打散
def fun(**kwargs):
    print(kwargs)        #{"a":1,"b":2}
    print(*kwargs)       #打散键 得到两值a b
    #print(**kwargs)     #报错
fun(a=1,b=2)

3.动态参数混合
	-优先级：位置参数>默认参数
def fun(*args,**kwargs):
    print(args,kwargs)   #(1,2) {"a":1,"b":2}
fun(1,2,a=1,b=2)

4.其他
dic = {"key":1,"key1":34}
def func(**kwargs):
    print(kwargs)
func(**dic)          #此处将dic打散成key=1,key1=34

lst = [1,2,3,4]
def fun(*args):
    print(args)
fun(*lst)            #此处将lst打散成1 2 3 4传入

4.return返回值(终止的是函数，非for循环)

1.
def fun():
    print("你好")
print(fun())       #fun()调用函数执行print("你好"),没有return，返回None   
# 打印结果：
# 你好 None

5.函数的注释

1.添加注释：在函数内部打上6个引号(''''''  or """""")回车即可。
def func(a,b):
    """
    逻辑判断...
    :param a: str
    :param b: int
    :return: bool
    """
    print(a,b)
    
2.查看注释
print(fun.__doc__)

6.global和nonlocal

1.global：golbal的两个作用1:修改全局变量。2:在局部定义全局变量。
a = 1
def fun1():
    a = 2
    def fun2():
        a = 3
        def fun3():
            global a
            a +=1
    	fun3() 
    fun2()          
fun1()  #执行结果 a=2
#由上个例子可知：无论嵌套多深，global只修改最外层全局变量的值

2.nonlocal:修改局部变量(修改最近的上一层变量，如果上一层没有找到，则继续向上找，直到第一层函数)

a = 1
def fun1():
    a =2
    def fun2():
        def fun3():
            nonlocal a
            a += 1
        fun3()
    fun()
fun1()
# fun1()中的a找上层fun2()，没有，继续向上找，fun1()中有,如果fun1()中如果没有，报错

二.函数名的第一类对象及使用

    1.1 函数名可以当做值被赋值
    1.2 函数名可以改当做元素存放在容器中
    1.3 函数名可以当做另一个函数的参数
    1.4 函数名可以当做返回值

三.名称空间

内置名称空间：我们从python官网下载的python解释器，也就是安装的python文件目录
全局名称空间：当前的py文件，我们将全局中变量和值的对应关系存储的空间，叫做全局名称空间。
局部名称空间：函数中开辟的空间

加载顺序：内置空间>全局空间>局部空间
	--名称空间加载到内存的顺序
取值顺序：局部空间>全局空间>内置空间
	--先从局部找，直到内置空间，如果内置空间找不到，则报错



#python解释器执行时，就会将内置名称空间加载到内存，程序向下运行，遇到变量和值就开辟全局名称空间，并将其加载到全局名称空间，遇到函数，将函数名和对应地址加载到内存，此时不创建局部命名空间。一旦函数执行，就创建临时空间(局部名称空间)，此时再依次将函数中的变量和值的对应关系添加到局部名称空间，函数调用完毕，就关闭局部名称空间。
---------------------------------------------------------------------------


作用域：
    全局作用域：内置空间+全局空间
    局部作用域：局部空间

四.匿名函数

1.匿名函数定义

def 用来定义有名函数; lambda 用来定义无名函数
结构：
lambda 参数:函数体    (lambda函数默认有返回值)

2.lambda函数使用原因

#我们先简单定义一个函数
def foo(x,y):
    return x**y

#下面使用lambda函数重新定义上面的函数
f = lambda x,y:x**n       #此处默认就是return x**n
print(f(2,2)) 
#打印结果 4

#ps:2
f = lambda x,y:print(x**y)
print(f(2,2))
#打印结果 4 None
#因为lambda函数有默认返回值，此处函数体中有print()，外部调用返回None

五.内置函数

引用：http://39.97.99.7/python/14 内置函数二.html

高阶函数(函数内部将可迭代对象for循环遍历)-------------------------------
# map()  func iter1                返回map对象
# filter()  func iterable            返回filter对象
# reduce()   fun iterable        返回值
# sorted()  iterable key         返回新列表
# max()     iterable key     
# min()     iterable key
--------------------------------------
# zip()   返回zip对象
#max,min,sorted,map,filter,reduce
1.max()  
	--得到下列字典中薪酬最多的人名
s1 = {"egon":3000,"alex":100000,"wupeizhi":1000,"yuanhao":200}
...调用有名函数
def fun(k):
    return s1[k]
max(s1,key=fun)

...调用匿名函数
max(s1,key=lambda x:s1[x])
#简述上方调用有名函数：
'''
max()中默认参数是一个序列，如果没有key值，就是按照s1取大小，并返回最大值；如果有key，就是按照key值来取大小，但同样返回s1中的值。此处将循环s1，将得到的值依次作为参数传递给fun()函数，max()函数就是比较key中值的大小，并返回对应的s1中的值。
'''

2.sorted()
	--按照列表中数据的平方来排序
lst = [1,4,3,-6,9,2]
print(sorted(lst,key = lambda x:x**2))
#打印结果：[1, 2, 3, 4, -6, 9]
#简述上述方法：
'''
sorted()本来返回排序好的列表序列，此处将lst遍历循环，同时将每个值作为参数传递给lambda函数中的x，比较x的平方的大小
因为1**2 < 2**2 < 3**2 < 4**2 < -6**2 <-9**2,因此返回列表[1, 2, 3, 4, -6, 9]
'''

3.map() 映射
	--将lst列表中的每个值平方
lst = [1,2,4,6]
res = map(lambda x:x**2,lst)    #将lst列表中每个值传给lambda函数，返回平方后的值
print(list(res))

	--拼接_SB,最后一个_NB
lst1 = ["小芳","大狗","王丹","黎明"]
res = map(lambda x:x+"_NB" if x == "黎明" else x+"_SB",lst1)  
print(list(res))  #["小芳_SB","大狗_SB","王丹_SB","黎明_NB"]

4.reduce 拼接
from functools import reduce
	--1到100相加
res = reduce(lambda x,y:x + y,range(1,101),0) #将0作为初始值与函数中的1相加，得到结果再与函数中的下个数相加，依次类推
	--拼接下列列表为字符串
lsts = ["my","xx","42","fg","s2"]
reduce(lambda x,y:x+y,lsts)     #将lsts中的第一二个值作为参数传递给x,y，得到的结果再与lsts中第三个数拼接，依次类推
print(reduce(lambda x,y:x+y,lsts))  #'myxx42fgs2'

5.filter()  过滤
	--过滤下面列表中大于2的数
lsts = [4,2,1,5,62,1,0]
filter(lambda x:x>2,lsts)
print(list(filter(lambda x:x>2,lsts)))  #[4,5,62]

6.reversed 反转
lst = [1,2,3,4,5]
lst1 = list(reversed(lst))
print(lst)
print(lst1)

7.zip
lst = [1,2,3,4]
lst1 = (1,2,3)
for i in zip(lst,lst1):
    print(i)
#(1,1)
#(2,2)
#(3,3)

8.format
print(format(13,">20"))  # 右对齐
print(format(13,"<20"))  # 左对齐
print(format(13,"^20"))  # 居中

#十进制转换成其他进制
print(format(13,"08b"))    # 2
print(format(13,"08d"))    # 10
print(format(13,"08o"))    # 8
print(format(12,"08x"))    # 16

六.闭包

参考:http://39.97.99.7/python/13-2 闭包.html

1.定义

在嵌套函数内，使用非全局变量（且不是本层变量）就是闭包。

2.格式

def fun():
    avg_lst = []     #自由变量
    def f2(price):                        #price是本层变量
        avg_lst.append(price)
        return avg_lst
    return f2
ret = fun()
print(ret.__closure__)         #判断是否是闭包
print(ret.__code__.co_cellvars)#判断是否有avg_lst这个自由变量
print(ret.__code__.co_varnames)#获取局部变量

3.坑

1.闭包不一定非得有return返回值
def wrapper():
    lst = []
    def inner():
        lst.append(6)
        print(lst)
    print(inner.__code__.co_freevars)
wrapper()
2.
def wrapper():
    lst = []
    def inner():
        lst.append(6)
        print(lst)
    return inner
wrapper()()   #[6]
wrapper()()   #[6]
wrapper()()   #[6]

#ret = wrapper()
#ret()       #[6]
#ret()       #[6,6]
#ret()       #[6,6,6]

4.应用

1.可以保存一些非全局变量但是不易被销毁、改变的数据
2.装饰器

a = []
def fun1():
    for i in range(10):
        a.append(i)
a.append(10)    #这样的话外部也能修改，因此将此嵌套进函数内（保证数据的安全性）

5.作用

保存局部信息不被销毁，保证数据安全性