python基础之递归,闭包,迭代器(7)

递归函数

在当前函数当中调用当前函数本身的函数就是递归函数。
递归的运行特性：先进后出

def digui(num):
    print(num) # 3 , 2，1，0，====，0，1，2，3
    if num > 0:
        digui(num-1)  # 调用函数本身
    else:
        print("==========")
    print(num) # 3 2
digui(3)

#结果 3 2 1 0 ==== 0 1 2 3
先今后出,digui(0)首先被释放,再digui(1)

# 递归实现斐波那契数列
# 1,1,2,3,5,8,13,21...

def feibo(n): # n是位置
    if n == 1 or n == 2:
        return 1
    else:
        return feibo(n-1) + feibo(n-2)
res=feibo(6)

方法二:

def fib(n):
    a, b = 1, 1
    for i in range(n - 1):
        t=b
        b=a+b
        a=t
    return a
print(fib(6))


# 递归 能不用就不用
# 1.运行效率及其低，2.递归的层数不能过多（1000层）3.递归不适用计算庞大的数据量
# 写递归需要注意的事项：必须给它出口，否则会一直调用自己，直到递归层数过多，栈溢出

# 递归实现阶乘 1 * 2 * 3 * 4 * 5 * 6 * ....
def func(n):
    if n==1:
        return 1
    else:
        return func(n-1)*n
res=func(6)
print(res)

闭包

闭包的定义:

内函数使用外函数的局部变量，并且外函数将内函数返回出来的方法叫闭包,
返回的内函数叫 闭包函数.

闭包的特点:
外函数的临时变量会在将来的内部函数中用到,

• 自己调用结束后会把外函数的临时变量与内函数绑定,函数运行完成后这个闭包的临时空间不会被释放.
• 或者说函数结束后,该函数向上层引用的局部变量仍然还是存在的不会被清空.
  将来调用内函数的时候仍可使用外函数变量.

闭包的意义:
闭包可以优先使用外函数中的变量,并对闭包中的值起到了封装保护的作用.外部无法访问.

def out():
    num = 1
    def middle():
        num1 = 2
        print(num)
        def inner():
            print(num1)
        return inner
    return middle
func = out()
res = func()  # func() 相当于 middle()
res()  # res() 相当于 inner()

money = 100
def give_money():
    global money
    print(money)
    money += 100
give_money()
give_money()
money = 10000
give_money()
give_money()
give_money()
#结果为: 100 200 10000 10100 10200 受外部的全局变量10000影响

def give_money():
    money=100
    def give1_money():
        nonlocal money
        print(money)
        money+=100
    return give1_money
res=give_money()
res()
res()
money=10000
res()
res()
结果为100 200 300 400 不受外部变量影响


def out(name):
    def inner():
        print(name,"喜欢在夏天穿短裤")
    return inner
func = out("小明")  # func == inner    : func() == inner()
func()

迭代器

• 迭代器:数据量（序列里的数据）过大的情况需要用到迭代器
• 特征:迭代器会生成惰性序列,它通过计算把值依次的返回,一边循环一边计算而不是一次性得到所有数据
• 优点:需要数据的时候,一次取一个,可以大大节省内存空间.而不是一股脑的把所有数据放进内存.
  惰性序列:没有一次性的把所有数据都放在序列中,而是遍历一个放一个,这样的序列
• iter(Iterable) zip(Iterable,Iterable…)
• iter() 功能：把可迭代数据对象 转换为迭代器
• 参数： 可迭代的对象（list,str,tuple,set,dict,range()）
• 返回值： 迭代器,是可迭代的对象，但可迭代的对象不一定是迭代器

检测：

#--Iterable可迭代的  Iterator迭代器
#isinstance() 判断数据类型，返回bool值

from collections import Iterable，Iterator #迭代器,可迭代类型检测,需要先调用出来.
list1 = [1,2,3,4,5]
result = isinstance(list1,Iterator)
print(result)
result1=isinstance(list1,Iterable)
print(result)

iter(Iterable)

• 功能：使用iter可以把可迭代数据变成迭代器
• 参数：Iterable（可迭代对象）
• 返回值：迭代器

# 从迭代器里取值：三种方法
#方法一 print(next())
tuple
tuple1 = (1,2,3,4,5,6)
res = iter(tuple1)

print(next(res))
print(next(res))
print(next(res))
print(next(res))
print(next(res))
print(next(res))

#方法二 for 循环
for num in res:
    print(num)

#方法三 数据类型转换
print(list(res))

zip(Iterable,Iterable,…)

功能:从参数中的多个可迭代对象取元素组合成一个新的迭代器,迭代器的组成元素是元组.
参数:Iterable（可迭代对象）
返回值:返回一个zip对象(迭代器)，其内部元素为元组

list1 = ["大锤","二妮","小可爱"]
tuple1 = ("80","40","白给")
res = zip(list1)
print(res,type(res))
print(next(res))
print(next(res))
print(next(res))

#多个参数的zip

list1 = ["大锤","二妮","小可爱","老可爱"]
tuple1 = ("80","40","白给")
res = zip(list1,tuple1)
for name in res:
    print(name)
res1 = dict(res)
print(res1)

结果:
('大锤', '80')
('二妮', '40')
('小可爱', '白给')
{}

*zip()函数是zip()函数的逆过程，将zip对象变成原先组合前的数据。
*zip 不能作为开头直接出现，需要和zip 配合使用

list1 = ["大锤","二妮","小可爱","老可爱"]
tuple1 = ("80","40","白给")
res = zip(*zip(list1,tuple1))
for name in res:
    print(name)
    
结果:
('大锤', '二妮', '小可爱')
('80', '40', '白给')