python一入深似海-模块化编程-钢铁侠战甲（二）

高阶函数

##递归函数

递归函数就是定义了一个函数，然后在函数内，自己调用了自己这个函数

递归函数内必须要有结束，不然就会一只调用下去，直到调用的层数越来越多，栈溢出

递归函数是一层一层的进入，再一层一层的返回

普通战甲套反浩克战甲，套娃，

# 初步认识 递归函数  3 2 1 0
def digui(num):
    print(num) # 3 2 1 0
    # 检测当前的值是否到了零
    if num > 0:
        # 调用函数本身
        digui(num-1)
    print(num) # 0 1 2 3

digui(3)

'''
解析当前递归函数的执行过程：
digui(3) ==> 3 
    digui(3-1) ==> 2
        digui(2-1) ==> 1
            digui(1-1) ==> 0
            digui(0) ==> 0
        digui(1) ==> 1
    gidui(2) ==>2
digui(3) ==> 3
'''

回调函数

函数中的参数可以是任意类型的，那参数能不能是一个函数呢？

如果在一个函数中要求传递的参数是一个函数作为参数，并且在函数中使用了传递进来的函数，那么这个函数我们就可以称为是一个回调函数

# 定义一个函数,函数中的一个参数要求是另一个函数
# 带有回调函数参数的函数
# def func(f):
    # print(f,type(f))
    # 并且在函数中调用了传递进来的行参函数
    # f()


# 回调函数
# def love():
#     print('123')
#
# func(love)

闭包函数

既然可以把函数作为一个行参进行传递，作为回调函数，那么如果在一个函数中，返回了一个函数呢？

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

特点：

1. 在外函数中定义了局部变量，并且在内部函数中使用了这个局部变量
2. 在外函数中返回了内函数，返回的内函数就是闭包函数
3. ⚠主要在于保护了外函数中的局部变量，既可以被使用，又不会被破坏
4. 检测一个函数是否为闭包函数，可以使用 函数名.__closure__如果是闭包函数返回 cell

# 定义一个函数
def person():
    money = 0  # 函数中定义了一个局部变量
    # 工作 定义的内函数
    def work():
        nonlocal money   # 在内函数中使用了外函数的临时变量
        money += 100
        print(money)
    # 在外函数中返回了内函数，这个内函数就是闭包函数
    return work

res = person() # return work  res = work
res() # res() == work()
res()
res()
res()
# 此时 就不能够在全局中对money这个局部变量进行任何操作了，
# 闭包的作用：保护了函数中的变量不受外部的影响，但是又能够不影响使用

匿名函数 lambda 表达式

匿名函数的意思就是说可以不使用def定义，并且这个函数也有没有名字

在python中可以使用lambda表达式来定义匿名函数

注意：lambda表达式仅仅是一个表达式，不是一个代码块，所以lambda又称为一行代码的函数

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

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

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

# print(jia(2,3))

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

# 带有分支结构的lambda 表达式
#  lambda 参数列表: 真区间 if 表达式判断 else 假区间
res = lambda sex:"很man" if sex=='男' else "很nice"
print(res('女'))

迭代器

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

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

集合的第一个元素开始访问，直到集合中的所有元素被访问完毕

迭代器只能从前往后一个一个的便利，不能后退

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

iter()

功能：把可迭代的对象，转为一个迭代器对象

参数：可迭代的对象 （str，list，tuple，dict)

返回值： 迭代器对象

注意：迭代器一定是一个可以迭代的对象，但是可迭代对象不一定是迭代器

next()

next()函数可以去调用迭代器，并返回迭代器中的下一个数据

迭代器的取值方案

1. next() 调用一次获取一次，直到数据被取完
2. list() 使用list函数直接取出迭代器中的所有数据
3. for 使用for循环遍历迭代器的数据
4. 迭代器取值的特点，取出一个少一个，直到都取完，最后再获取就会报错

检测迭代器和可迭代对象的方法

from collections.abc import Iterator,Iterable                   
                                                                
varstr = '123456'                                               
res = iter(varstr)                                              
                                                                
# type() 函数返回当前数据的类型，                                           
# isinstance() 检测一个数据是不是一个指定的类型                                 
r1 = isinstance(varstr,Iterable) # True 可迭代对象                   
r2 = isinstance(varstr,Iterator) # False 不是一个迭代器                
r3 = isinstance(res,Iterable) # True 可迭代对象                      
r4 = isinstance(res,Iterator) # True 是一个迭代器                     
print(r1,r2)                                                    
print(r3,r4)         
# 迭代器一定是一个可迭代的对象，可迭代对象不一定是迭代器                                           

内置函数

内置函数就是在系统安装完python解释器时，由python解释器给提供好的函数

range() 函数

如果你确实需要遍历一个数字序列，内置函数 range() 会派上用场。它生成算术级数

range函数的使用方式

# 只写一个参数，就是从零开始到10之前，9
# res = range(11)

# 两个参数时，第一个参数是开始的值，第二个参数是结束的值（在结束值之前）
# res = range(5,10)

# 三个参数， 参数1是开始值，参数2是结束值，参数三是步进值
# res = range(1,10,3)

# 获取一个倒叙的数字序列
# res = range(10,0,-1)
# res = range(10,0,-2)

res = range(-10,-20,-1)
res = range(-20,-10)
res = range(-10,10)
print(list(res))

获取range函数返回的数字序列的方法

 res = range(10)
# 1。转为list列表数据
# print(list(res))

# 2。通过 for循环 进行遍历
# for i in res:
#     print(i)

# 3。转为迭代器，使用next函数调用
# res = iter(res)
# print(next(res))
# print(next(res))

zip() 函数

功能：zip 函数是可以接受多个可迭代的对象，然后把每个可迭代对象中的第i个元素组合在一起，形成一个新的迭代器
参数：*iterables，任意个的 可迭代对象
返回值： 返回一个元组的迭代器

var1 = '1234'
var2 = ['a','b','c']
var3 = ('A','B','C','D')
# 调用zip函数，组成新的元组迭代器
res = zip(var1,var2,var3)
# print(res,type(res))

for i in res:
    print(i)
'''
('1', 'a', 'A')
('2', 'b', 'B')
('3', 'c', 'C')
('4', 'd', 'D')
'''
# zip() 与 * 运算符相结合可以用来拆解一个列表:
x = [1, 2, 3]
y = [4, 5, 6]
zipped = zip(x, y)
print(list(zipped))

print(zip(x, y)) # 迭代器对象，
print(*zip(x, y))# 组合好的多个元组数据

其它内置函数

数据类型转换相关内置函数

• int() 将其它类型数据转为整型
• float() 转为浮点类型
• bool() 转为布尔类型
• complex() 转为复数
• str() 转为字符串类型
• list 转为列表类型
• tuple 转为元组类型
• dict 转为字典类型
• set 转为集合类型

变量相关函数

• id() 获取当前数据的ID标识
• type() 获取当前数据的类型字符串
• print() 数据的打印
• input() 获取输入的数据
• isinstance() 检测是否为指定的数据类型

数学相关函数

# 获取一个数的绝对值
# print(abs(-99.99))

# 求和 从 start 开始自左向右对 iterable 中的项求和并返回总计值
# print(sum([1,2,3]))

# 获取最大值
# print(max([1,2,3]))
# print(max(99,12,45))

# 获取最小值
# print(min([2,1,6,-9]))
# print(min(6,7,1,0,-2))

# 幂运算  返回 x 的 y 次幂
# print(pow(2,3))

# 四舍五入
# r = round(3.1415926)
# r = round(3.1415926,2) # 小数点保留几位

# r = round(4.5) # 奇进偶退  1.5 = 2 2.5=2,3.5=4,4.5=4
# print(r)

进制相关函数

# bin() 将数值类型转为二进制
# print(bin(123)) # 0b1111011

# int() 将二进制转为整型
# print(int(0b1111011)) #1 23

# oct() 转为八进制数 01234567
# print(oct(123)) # 0o173

# hex() 转为十六进制数 0123456789abcdef
# print(hex(123)) # 0x7b

高阶函数

sorted(iterable[reverse,key])排序

sorted()
运行原理：
把可迭代数据里面的元素，一个一个的取出来，放到key这个函数中进行处理，
并按照函数中return的结果进行排序，返回一个新的列表
功能： 排序
参数：
iterable 可迭代的数据 （容器类型数据，range数据序列，迭代器）
reverse 可选，是否反转，默认为False，不反转， True反转
key 可选， 函数，可以是自定义函数，也可以是内置函数
返回值： 排序后的结果

arr = [3,7,1,-9,20,10]
# 默认按照从小到大的方式进行排序
# res = sorted(arr)  # [-9, 1, 3, 7, 10, 20]

# 可以按照从大到小的方式进行排序
# res = sorted(arr,reverse=True)  # [20, 10, 7, 3, 1, -9]

# 使用abs这个函数(求绝对值）作为sorted的key关键字参数使用
res = sorted(arr,key=abs)
# print(res)

# 使用自定义函数
# def func(num):
#     print(num,num % 2)
#     return num % 2
#
# arr = [3,2,4,6,5,7,9]
#
# # 在sorted函数中使用自定义函数对数据进行处理
# res = sorted(arr,key=func)
# print(res)

## 优化版
arr = [3,2,4,6,5,7,9]
res = sorted(arr,key=lambda x:x%2)
print(res)

map(func, *iterables) 新迭代器

map(func, *iterables)
功能： 对传入的可迭代数据中的每个元素放入到函数中进行处理，返回一个新的迭代器
参数：
func 函数 自定义函数|内置函数
iterables：可迭代的数据
返回值：迭代器

(1）把一个字符串数字的列表转为 整型的数字列表
['1','2','3','4']  # ==> [1,2,3,4]
普通的处理方法
varlist = ['1','2','3','4']  # ==> [1,2,3,4]# newlist = []
for i in varlist:
     newlist.append(int(i))
print(newlist)

使用map函数进行处理
varlist = ['1','2','3','4']
res = map(int,varlist) # <map object at 0x104ea8890>
print(list(res))

(2) [1,2,3,4] ==> [1,4,9,16]
普通方法
varlist = [1,2,3,4]
newlist = []
for i in varlist:
     res = i ** 2
     newlist.append(res)
print(newlist)

使用map函数处理这个数据
varlist = [1,2,3,4]
def myfunc(x):
     return x ** 2
res = map(myfunc,varlist)
print(res,list(res))
 
优化版
res = map(lambda x:x**2,varlist)# print(res,list(res))

练习作业
(3) ['a','b','c','d'] ==> [65,66,67,68]

reduce(func,iterable)

reduce(func,iterable)
功能：
每一次从 iterable 拿出两个元素，放入到func函数中进行处理，得出一个计算结果，
然后把这个计算结果和iterable中的第三个元素，放入到func函数中继续运算，
得出的结果和之后的第四个元素，加入到func函数中进行处理，以此类推，直到最后的元素都参与了运算
参数：
func： 内置函数或自定义函数
iterable： 可迭代的数据
返回值：最终的运算处理结果
注意： 使用 reduce函数时，需要导入 from functools import reduce

from functools import reduce

(1) [5,2,1,1] ==> 5211

# 普通方法
# varlist = [5,2,1,1]
# res = ''
# for i in varlist:
#     res += str(i)
# res = int(res)
# print(res,type(res))
'''
5 2 1 1
5 * 10 + 2 == 52
52 * 10 + 1 == 521
521 * 10 + 1 == 5211
'''

# 使用 reduce完成
# def myfunc(x,y):
#     return x*10+y
# varlist = [5,2,1,1]
# # 调用函数
# res = reduce(myfunc,varlist)
# print(res,type(res))

（2） 把字符串的 '456' ==> 456
#  要求不能使用int方法进行类型的转换时，如何解决上面的问题

# 定义函数，给定一个字符串的数字，返回一个整型的数字
def myfunc(s):
    vardict = {'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9}
    return vardict[s]

# 1.先使用 map函数，把数字字符串，转为整型的数字
iter1 = map(myfunc,'456')

# 2. 把数字列表中的值，使用lambda进行二次处理
iter2 = reduce(lambda x,y:x*10+y,iter1)
print(iter2)

filter(func,iterable)过滤数据

filter(func,iterable)
功能： 过滤数据，把 iterable 中的每个元素拿到 func 函数中进行处理，
如果函数返回True则保留这个数据，返回False则丢弃这个数据
参数：
func 自定义函数
itereble： 可迭代的数据
返回值：保留下来的数据组成的 迭代器

# 要求 保留所有的偶数，丢弃所有的奇数
varlist = [1,2,3,4,5,6,7,8,9]

(1)普通方法实现
newlist = []
for i in varlist:
     if i % 2 == 0:
         newlist.append(i)
 print(newlist)

(2)使用 filter 进行处理
# 定义一个函数，判断当前这个函数是否为偶数，偶数返回True，奇数返回False
def myfunc(n):
    if n % 2 == 0:
         return True
     else:
        return False

(3) 调用 过滤器 函数进行处理
it = filter(myfunc,varlist)
print(it,list(it))

优化版
it = filter(lambda n:True if n % 2 == 0 else False,varlist)
print(it,list(it))