迭代器:
1.函数名的使用
2.闭包
3.迭代器
3.1 可迭代对象
3.2 迭代器
难**********
4.递归
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
全局里存放会有污染和不安全的现象
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__())
迭代器特性:
惰性机制
不能从下向上走
一次性的,用完就没了
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.这是扩展知识,能理解多少理解多少
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.将内部函数名当做返回值返回,在全局调用
# 怎么去查看闭包??
# 函数名.__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. 面试题 查询数据