迭代器,闭包,可迭代对象,函数名的使用

时间:2021-11-24 22:44:18

迭代器:

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. 面试题 查询数据