2019-03-15-day011-递归生成器

函数的进阶:

动态参数:

两种: 动态位置参数 > 动态默认参数

打散(聚合):

• 实参处打散
• 形参处聚合
• 不在函数中第一次使用*打散,第二次是聚合
• 在数据库中快速写入数据的时候,**dic

名称(命名)空间:

加载顺序:

1. 内置
2. 全局
3. 局部

取值顺序:

1. 局部
2. 全局
3. 内置

命名空间作用域:

1. 全局 全局 + 内置
2. 局部 局部

函数的注释:

函数注释的作用: 清晰描述函数的功能及参数和返回值

好处,在不知道这个函数是什么的情况下,省去看代码的时间

函数名.__doc__ # 查看函数的注释

函数名.__name__ 函数的名字 反射

global,nonlocal

global: 在局部空格直接修改全局变量,如果没有就创建一个

 a = 6
 def func():
     global a
     a = 6
     # a+=1 # a = a + 1
     # print(a)
 func()

 def func():
     b = 10
     def aa():
         global b
         b = 3
         print(b)
     aa()
     print(b)
 func()
 print(b)

nonlocal:在局部空间内,

修改离自己最近的上一层变量,如果没有继续向上一层查找,

直到局部顶层没有就报错.

函数的嵌套:

def 函数1:
    def 函数2:

def func():
    func1()

def func1():
    print(2)
    func2()

def func2():
    print(1)
func()

什么是嵌套作用域?

 def func():
     a = 3
     def a1():
         b = 1
         print(b)

解构

*c,a,b,d,e = [1,2,3,4]
print(c)

函数名的使用

def func():
    pass

print(func)  # 函数的内存地址

def func():
    print(1)
a = func

a()
func()   # 函数名可以当做值赋值给变量

def func():
    print(1)

def func2():
    print(2)

li = [func,func2]
print(li)  # 函数名可以当做元素放到容器里

def func():
    def aa():
        print(2)
        return None
    return aa()  # return None
func() # func() == None

def f():
    def a():
        def b():
            def c():
                return '哈撒给!'
            return c()
        return b()
    return a()
print(f())

for i in range(3):
    def func(x):
        print(x*i)
    func(2)  # 0 2 4

li = [] # [func,func,func]
for i in range(3):
    def func(x):
        print(x*i)
    li.append(func)

for func in li: # [func,func,func]
    func(2) # 0 2 4  0 2 4  0 2 4
    # 0 2 4
    # 0 0 0 2 2 2 4 4 4

li = []
for i in range(3):
    def func(x,i):
        print(x*i)
    li.append(func)

for func in li:
    func(2)

li = []
for i in range(3):
    def func(x,y=i):
        print(x*y)
    li.append(func)

for func in li:
    func(2)

def s():
    print(1)

def func(s11):
    s11()

func(s)

闭包

1. 一个嵌套函数
2. 在嵌套函数的内部函数使用外部(非全局的变量)

满足以上两条就是闭包

def wrapper():
    a = 10
    def inner():
       print(a)
    # print(inner.__closure__) # 不是None 就是闭包
    inner()
wrapper()

def wrapper():
    a = 10
    def inner():
       print(a)
    return inner
inner = wrapper()
inner()

def wrapper():
    a = 10
    def inner():
       print(a)
    return inner
wrapper()()

money = 10
全局里存放会有污染和不安全的现象

def wrapper():
    money = 10
    def inner(num):
        nonlocal money
        money += num
        print(money)
    return inner
wrapper()(100)

python中闭包,会进行内存驻留, 普通函数执行完后就销毁了

全局里存放会有污染和不安全的现象

面试必问,装饰器 -- 装饰器的本质就是闭包

闭包有个弊端:会出现内存泄漏

迭代器

可迭代对象:

• 可以被for的就是可迭代对象
• Python 协议
• 具有.__iter__方法的就是可迭代对象
• a = 对象.__iter__ # 创建一个迭代器
• 具有__iter__和__next__就是一个迭代器

for i in [1,2,3]:
    print(i)

li = [1,2,3]
a = li.__iter__()
a.__iter__()
a.__next__()

li = [1,2,3]
a = li.__iter__()
print(a.__next__())
print(a.__next__())  #一个一个取
print(a.__next__())

b = li.__iter__()
print(b.__next__())
print(b.__next__())
print(b.__next__())

迭代器特性:

• 惰性机制
• 不能从下向上走
• 一次性的,用完就没了
  python
for i in [1,2,4,3]:
print(i)


for的机制:

li = [1,2,3,4,6,7,87,8,9,90,0,0,0,0,8,7,7,67,]
em = li.__iter__()
while 1:
    try:
        print(em.__next__())

    except StopIteration:
        break

for i in range(10):
    print(i)

扩展

dic = {'1':1}  # 8679250325822402967 = 1
print(hash('1'))

递归

1. 自己玩自己 (自己调用自己本身)
2. 玩的有限制 (有明确结束条件)

import sys
sys.setrecursionlimit(10)
count = 0
def func():
    global count
    count += 1
    print(count)
    if count == 500:
        return
    func()
func()

def func(n):
    n+=1
    print(n)
    if n == 100:
        return
    func(n)
func(0)

1,1,2,3,5,8,13,21,34,55

超出了递归的最大层次

递归默认层次,官方说明 1000,实际测试 998/997

def func(age):
    age = age + 1
    print(age)
    if age == 5:
        return
    func(age)
func(2)

def func(age):
    print(age)

def func1(age):
    print(age)
    func(age+1)

def func2(age):
    print(age)
    func1(age+1)
func2(2)

今日总结

1.函数名的使用:

• a = 函数名
• a()
• 返回值 函数名
• 返回函数名的时候不能加括号
• 函数名: 可以容器的元素
• 函数名可以当做参数被传递

2.闭包:

1. 首先有一个嵌套函数
2. 嵌套函数内部函数调用非全局的变量
3. 将内部函数名当做返回值返回,在全局调用
4. 怎么去查看闭包??
5. 函数名.__closure__ 返回None 就不是闭包

3.迭代器:

• 可迭代对象: 具有__iter__方法就是可迭代对象
• 迭代器: 具有__iter__方法,__next__就是迭代器
• for循环的机制 就是迭代器,

4.递归:

def func(n):
    n+=1
    print(n)
    if n == 5:
        return
    func(n)
func(2)

• 递归的效率比较低,尾递归的用时 和 for的用时 是一样的,比for慢
• 递归的应用场景:
• 在不明确要循环的次数时候,可以用递归
• 递归操作文件目录

5. 面试题 查询数据