函数

函数

递归函数：

递归函数就是定义函数后，在函数体内调用函数本身，进入一个死循环状态

因为是死循环状态，调用的层级无线循环，所以必须在函数体内设计结束调用方法。否则会导致内存溢出

def func(num):
    # 结束条件
    print(num, end=" ")
    if num>0:
        # 递归调用
        func(num-1)
    print(num,end=" ")# 一层层进入，一层层返回
func(10)
'''
打印结果：
10 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 10 
'''

回调函数：

函数中的参数可以是任意类型，也包括参数是个函数

如果函数作为一个参数，并且在函数体中调用了这个参数，那么这个函数就叫做回调函数

def func(f):
    f()# 参数作为函数进行调用
def func1():
    print('被调用的函数func1')
func(func1)


# 回调函数，求和运算
def operation(x,y,f):
    '''
    x,y都是数值类型，f是函数类型
    将x,y两个数值通过f进行求和运算
    :param x: 
    :param y: 
    :param f: 
    :return: 
    '''
    print(f([x,y]))
operation(3,2,sum)  

闭包函数：

函数中可以返回任意类型数据，也包括返回函数

在一个函数内返回了一个内函数，并且这个返回的内函数还使用了外函数中局部变量，这个函数叫做闭包函数

闭包函数的作用是保护函数中的变量不收外部的影响，但又能够使用

def person(): # 定义外函数
    money=0 # 外函数的局部变量
    def work(): # 定义内函数
        nonlocal money # 内函数使用外函数中的局部变量
        money += 100
        print(money)
    return work() # 返回内函数
person()

匿名函数lambda表达式

匿名函数：可以不实用def定义，并且这个函数也没有函数名

python中使用lambda定义匿名函数

lambda表达式也有形参，并且不可以访问除了自己形参之外的任何数据，包括全局变量

'''
语法：
    lambda[参数列表]：返回值
'''

# 封装一个函数做加法运算
# 普通函数
def jia(x,y):
    print(x+y)
jia(1,2)

# lambda表达式封装
res=lambda x,y:x+y
print(res(4,4))

# 带有分支结构的lambda表达式
res=lambda sex:'光头' if sex=='男' else '长发'
print(res('男'))

迭代器 Iterator

迭代器是python中最具特色的功能之一，也是访问集合元素的一种方式

迭代器是一个可以记住遍历元素位置的对象

从集合的第一个元素开始访问，知道集合中所有元素被访问完毕

迭代器只能从前往后依次遍历，不能后退

能被next()函数调用，并不断返回下一个值的对象成为迭代器(Iterator)

"""
1.next()调用一次获取一次，直到取完数据为止
2.list()一次性直接取出迭代器中的所有元素
3.使用for循环遍历迭代器的数据
"""
f4=['刘德华','郭富城','黎明','宋小宝']
res=iter(f4)
r=next(res)
# r=list(res)
# print(r)
for i in res:
    print(i) 
print(r) # 列表为空，所有数据已经被取出

高阶函数

sorted() 排序

功能：排序
运行原理：把元素遍历取出，放到key函数中进行处理，并根据返回的结果进行排序后返回新列表
参数：
inalterable 可迭代数据
reverse 是否翻转，默认false(可选值)
key 函数，可以是自定义函数或者内置函数(可选值)
返回值：
排序后的结果

list=[1,4,3,6,2,3,20,-2]
arr=sorted(list) #默认从小到大排序
print(arr)
arry=sorted(list,reverse=True) #reverse=True可以从大到小排序
print(arry)

#abs()求绝对值，abs作为sorte的key关键字参数使用
arryabs=sorted(list,key=abs)
print(arryabs)

#使用自定义函数
def func(num):
    return num + 2
arrys=[1,23,2,1,2,3,4,5,3,-1]
res1=sorted(arrys,key=func)
print(res1)
# 使用lambda表达式进行优化
arr1=[1,2,3,43,2,1,3]
res2=sorted(arr1,key=lambda x:x%2)
print(res2)

map()

map(fun,*iterable)
功能：对传入的可迭代数据中的每一个元素进行处理后返回一个新的迭代器
参数：
fun 函数，可以是自定义函数或者内置函数
iterable可迭代的对象
返回值:新的迭代器

varlist=['1','2','3','4']
res=map(int,varlist)
print(list(res))
#使用map()进行幂运算
reslist=(1,2,3,4)
def mysunc(num):
    return num ** 2
reslist1=map(mysunc,reslist)
print(list(reslist1))
#优化方法
reslist2=map(lambda x:x**2,reslist)
print(list(reslist2))

reduce()

reduce(func,*iterable)
功能：
每次从iterable拿出两个元素，放到func中进行计算得到一个结果在和下一个元素进行同样的计算
参数：
func:可以是内置函数或者自定义函数
iterable:可迭代的数据
返回值:
所有元素的计算结果
注意：
使用reduce()函数时需要导入包

#将[5,2,1,1]转换成5211
arrlit=[5,2,1,1]
res=''
for i in arrlit:
    res+=str(i)
print(int(res))
# 使用reduece()完成
def func(x,y):
    return x*10+y
res=reduce(func,arrlit)
print(res)

filter()

filter() 过滤器
功能：
过滤数据，把iterable中的每个元素通过函数进行处理，如果返回True则保留数据，返回Flase则丢弃
参数：
内置函数或自定义函数
iterable：可迭代的数据
返回值：
保留数据后组成的迭代器

#普通方法
varlist=[1,2,3,4,5,6,7,8,9]
newlist=[]
for i in varlist:
    if i % 2 ==0:
        newlist.append(i)
print(list(newlist))

#使用filter()方法
def func(n):
    n % 2 == 0
filter(func,varlist)
print(list(newlist))

#简化方法
res=filter(lambda n:n%2==0,varlist)
print(list(res))