函数

一.函数

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)      

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：修改全局变量（修改最外层全局变量的值，而非上一层的）

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()中如果没有，报错

二.命名空间

内置空间：我们从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

3.lambda函数的应用场景

#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]

转载于:https://www.cnblogs.com/gaoyukun/p/11196845.html