小学生都能学会的python(闭包和迭代器)
小学生都能学会的python(闭包和迭代器)
1. 函数名第一类对象
函数名其实就是变量名
1). 可以像变量一样互相赋值.
2). 可以作为函数的参数,进行传递
3). 可以作为返回值返回
4). 可以作为集合的元素进行存储
# def chi():
# print("吃月饼")
# print(chi)
# fn = chi # 函数名可以进行赋值
# a = 10
# b = a
# chi()
# fn()
# 函数名可以像变量名一样进行使用
# def func1():
# print("我是一个单纯的函数")
#
# def func2(abc): # abc接收到的是一个函数的内存地址
# abc() # 执行func1, func1()
# print("我是func2", abc)
#
# # a = "苹果"
#
# func2(func1) # func1是函数的内存地址, 函数名可以像变量一样进行参数的传递
# def outer():
# def inner():
# print("我是里面")
# return inner
#
# outer()() # ()表示的是执行
# ret = outer() # outer得到的结果是inner
# ret() # 执行的是inner函数
# a = "周润发"
# b = "蓝洁瑛"
# c = "春三十娘"
# d = "简直了"
#
# lst = [a, b, c, d]
# for el in lst:
# print(el)
# def chi():
# print("吃饭")
# def he():
# print("喝饮料")
# def du():
# print("赌是不好的")
# def chou():
# print("少抽点烟")
#
# lst = [chi, he, du, chou]
# for el in lst:
# el()
# a = 10
# print(a + 20)
# 错误的
# def a():
# pass
# print(a + 10)
#
# def panpan():
# print("我是潘潘. 我喜欢毒丈夫 ")
#
# def xiaoping():
# print("我是小萍萍. 我喜欢毒丈夫 ")
#
# def xiaohua():
# print("我是小花花. 我喜欢毒丈夫 ")
#
# def daguanren():
# print("大官人喜欢xxxx")
#
# def wangpo(nv, nan): # 核心业务逻辑
# nv()
# nan()
#
# wangpo(xiaohua, daguanren) # 王婆代理了大官人和潘潘
# def chi():
# print("我是吃")
#
# a = chi
# haha = a
# hehe = haha
# bilibili= hehe
#
# bilibili()
# print(bilibili.__name__) # 函数名
def play(wanjv1, wanjv2, wanjv3):
'''
玩儿函数
:param wanjv1: 玩具1
:param wanjv2: 玩具2
:param wanjv3: 玩具3
:return: 开心
'''
print("我要玩儿荡秋千")
return "开心"
# play("独木桥", "独轮车", "独眼龙")
print(play.__doc__) # document
print(str.join.__doc__)
2. 闭包(函数的嵌套. 返回函数名)
作用:
1). 保护变量
2). 常驻内存
基本写法
def outer():
a = 10
def inner():
return a
return inner
# def func():
# a = 10
# print(a)
# func()
# print(a) # 在外面你是访问不到局部变量的, 局部变量是安全的
# 全局变量可能会被修改, 全局变量是不安全的. 可能会被其他函数所更改
# a = 10
# def func():
# global a
# a = 20
# print(a)
# func()
# print(a)
# 用闭包可以保护我们的变量
# 写法: 在外层函数中声明一个变量. 在内层函数使用或者返回这个变量.
# 这个结构叫闭包
# 1.可以保护我的变量
# 2.可以让一个变量常驻内存
# def outer():
# a = 10 # 常驻内存
# def inner():
# print(a) # 在内部使用的外面的变量
# return inner # 返回了内部函数
#
#
# # ret是inner的地址. ret就是inner
# ret = outer()
# # ret() # 这里执行inner()
# # print("哈哈")
# # print("哈哈")
# # print("哈哈")
# # ret() # inner的执行时间是不确定的
# # print("哈哈")
# # print("哈哈")
# # print("哈哈")
# # ret() # inner的执行时间是不确定的
#
# # def haha():
# # pass
# # print(ret.__closure__) # 有东西, 就是闭包. None就不是闭包
# 闭包的应用.保护变量, 常驻内存
from urllib.request import urlopen
def func():
# 闭包. content会常驻内存
content = urlopen("http://www.xiaohuar.com/").read()
def inner():
return content
return inner
print("加载中...")
g = func() # 网络请求
print("加载完毕")
print(g())
print(g())
print(g())
3. 迭代器(用)
1. Iterable: 可迭代的.里面有__iter__()
2. Iterator: 迭代器. 里面有__iter__() 还有 __next__()
特点:
1. 节省内存(欠)
2. 惰性机制(只有执行__next__()才会取值)
3. 只能向前. 不能反复
dir() 查看数据可以执行的方法
isinstance() 判断xxx对象是否是xxx类型
for循环的内部用的是迭代器
lst = [1, 2, 3]
it = lst.__iter__().__next__()
while 1:
try:
it.__next__()
except StopIteration:
break
# for c in 123:
# print(c)
# iterable 可迭代的, str, list. tuple, dict, set, open(), range()
# dir() 可以查看某数据类型中可以执行的方法
# s = "alex"
# print(dir(s)) # 在字符串中发现了__iter__. 没有__next__
# a = 123
# print(dir(a)) # 在int中没有__iter__ 没有__next__
# lst = [1, 2, 3,]
# print(dir(lst)) # 在list中也有__iter__
# 所有包含了__iter__的东西都可以使用for循环. 都可以进行迭代
# 迭代器, 在for循环内部. 调用了__iter__(), 访问__iter__()可以得到迭代器
# lst = [1, 2, 3, 4, 5, 6]
#
# it = lst.__iter__() # iterator 迭代器
# while 1:
# try:
# print(it.__next__())
# except StopIteration:
# print("结束了")
# break
# for el in lst:
# print(el)
# else:
# print("结束了")
# 迭代器给所有的数据类型提供了一种统一的遍历的方式(可迭代协议), Iterable, __iter__()
# lst = [1, 2, 3, 4, 5]
# # print("__iter__" in dir(lst))
# # print("__next__" in dir(lst))
#
# it = lst.__iter__()
# # print("__iter__" in dir(it)) # 迭代器里面是有__iter__的. 迭代器一定是可迭代的
# # print("__next__" in dir(it))
#
# for el in it: # 迭代器可以使用for循环
# print(el)
# 小总结
# Iterable: 可迭代对象. 里面包含了__iter__(),可以使用for循环
# Iterator: 迭代器. 里面包含了__iter__() 和 __next__(), 也可以使用for循环
# from collections import Iterable # 可迭代的
# from collections import Iterator # 迭代器
#
# lst = ["周润发","麻花藤","刘伟"]
# print(isinstance(lst, Iterable)) # instance 实例, 对象
# print(isinstance(lst, Iterator)) # instance 实例, 对象
#
# it = lst.__iter__()
# print(isinstance(it, Iterable)) # instance 实例, 对象
# print(isinstance(it, Iterator)) # instance 实例, 对象
# 总结
# 特点:
# 1. 节省内存
# 2. 惰性机制
# 3. 只能向前. 不能反复
lst = [1,2,3]
it = lst.__iter__()
print(it.__next__())
print(it.__next__())
print(it.__next__())
# 重新拿一个迭代器
it = lst.__iter__()
print(it.__next__())
print(it.__next__())
