#1函数名
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():
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迭代器
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__())
print(it.__next__())
