1,装饰器:decorator(又叫语法糖)
本质是函数，功能是用来装饰的，装饰其他函数：就是为其他函数添加附加功能。
原则：a，不能修改被装饰的函数的源代码
b，函数的调用方式也不能修改
说明：尽管加了装饰函数，对原函数没有任何影响，原函数感觉不到装饰器的存在，原函数该怎么运行还怎么运行。
2、基本常识：
a,函数即“变量”:函数就是变量。
b,高阶函数：满足两个条件之一就是，
之一：把一个函数名当做实参传给另外一个函数 （在不修改被装饰函数的源代码的情况下为其添加装饰功能）
例子：
def bar():
print(‘111111111‘)
def test1（func）:
print(func)
test1(bar)
------------>
运行后打印出来的是时内存地址：
<function bar at 0x0000000000000D521453> 这个内存地址里存的就是对应变量的内容
之二：返回值中包含函数名，返回值也可以字符串，数字，列表，函数名，函数执行。
c,嵌套函数（在一个函数的内容主体内又定义了一个新的函数）
def bar():
def foo():
print(‘In the foo‘)
return ‘aa‘
print(‘In the bar‘)
return foo()
bar()
运行结果如下：
In the bar
In the foo
d,匿名函数：没有名称的函数（注意，此时的内存回收机制）,他在内存中保存机制：此时的门牌号
如：calc = lambda x:x*3
calc（3）
e,高阶函数+嵌套函数=装饰器
实例1：函数的调用，不是装饰器
def bar(): -------------------- 存到内存里的一个名称，相当于门牌号，只用通过这个门牌号才能里面具体的内容
print(‘in the bar‘) ------- 存到内存里的对应门牌号的具体的内容，实实在在的存下来。python的内存机制，当门牌号没有时才会回收里面的具体的内容，才是释放内存，有多个门牌号时，所有的门牌都回收才会释放该内存
def foo():
print(‘in the foo‘)
bar()
foo()
实例2：python的内存回收机制
x = 1 直到python的程序结束，才会回收x =1这个内存，要么在程序中定义del来结束这个变量，否则就是直到程序结束才回收。del清除的就是1这个具体的内容的门牌号，内核里里有个内存清除器，当它到点启动时，发现这个1没有
人引用了，此时才会清空1的这个内容。这就是内存回收机制
实例3：def bar():
pass ---------------------> pass :当代码运行到这一行的时候。跳过。相当于执行了一个空值。
bar
---->
<function bar at 0X000000000000D50158> 此时就是内存地址
bar（） 此时就是基于内存地址在调用,即调用该函数（变量）的具体内容
实例4：高阶函数之将一个函数作为另外一个函数的实参传进去：
def bar（）：
pass
def test1(func):
print(func) --------> 打印出来的是内存地址
func() ----------> 调用基于func内存地址的具体内容。
test1（bar）
实例5：高阶函数之将一个函数作为另外一个函数的实参传进去：：
import time
def bar():
print(555555)
def test1(func): ----------------> 此处的func就是形参的参数名，会被后面的实参的bar代替
start_time=time.time()
func() ----------------> 运行bar函数
stop_time=time.time()
print("the func run time is %s" %(stop_time-start_time))
test1(bar)
实例6：高阶函数之将一个函数作为另外一个函数的返回值传进去：：
import time
def bar（）：
time.sleep(3)
print(‘in the bar‘)
def test2(func):
print(func) ------------> 打印出来内存地址
return func -----------> 将func这个参数作为返回值
print(test2（bar)) -----------> 打印一个运行后的函数就是打印他的返回值（即return后的内容）!!!!!!!
----------->
解说：test2（bar） 相当于将bar的内存地址传给test2了
test2（bar())相当于将bar的变量内容传给test2了
import time
def bar（）：
time.sleep(3)
print(‘in the bar‘)
def test2(func):
print(func) -----------> 打印出来内存地址
return func -----------> 将bar的内存地址返回回来
t=test2（bar) -----------> 将test2(bar)运行后的返回值再赋值给t这个变量!!!!!!
print(t)
----->
<function bar at 0X000000000000D50158>
<function bar at 0X000000000000D50158>
注意：这里的bar函数并没有运行。只是调用了bar这个函数的名称而已。所以只有上面的内存地址显示出来。
---------------------------------------------------------------------------------------------------------------------
import time
def bar（）：
time.sleep(3)
print(‘in the bar‘)
def test2(func):
print(func) -----------> 打印出来内存地址
return func -----------> 将bar的内存地址返回回来
t=test2（bar) ----------->这一步的运行结果就是打印了bar()函数的内存地址，并将该内存地址赋值给了t
t() ---- 运行bar，注意bar只是门牌号，运行t这个内存地址的主体内容，就是运行bar()这个实体。
----->
<function bar at 0X000000000000D50158>
in the bar
-----------------------------------------------------------------------------------------------------------------------
import time
def bar（）：
time.sleep(3)
print(‘in the bar‘)
def test2(func):
print(func) ------------ 打印出来内存地址
return func ----------- 将bar的内存地址作为返回值
bar=test2（bar) ---------- 重新给bar赋值
bar() ------------------ 再次运行bar
总结：返回值中包含函数名(不修改函数的调用方式)
------->
<function bar at 0x00000000004C3E18>
In the bar.
总结：该例中两次给bar赋值，一次是定义成一个函数，第二次是定义成了内存地址赋值。但是该内存地址的主体内容仍然没变。故仍然可以运行。
-----------------------------------------------------------------------------------------------------------------------
实例7，嵌套函数：在一个函数体内，用def去申明一个新的变量
def foo():
print(‘00000000000‘)
def bar(): -------------> 在一个函数体内定义一个新的函数，其作用域也就在这个函数范围内，这就是嵌套函数。出来外面这个函数就失效。
print(‘11111111111‘)
bar()
foo()
注意：与函数调用不同：下例为函数的调用
def test1():
print(‘2222222222‘)
def test2():
print("3333333333")
test1() --------------- 函数的调用,不是嵌套函数。
print(test2) ---------------- 仅仅打印test2的内存地址
print(test2()) ---------------- 分两步运行：1，运行的结果就是先运行test2()函数；2，最后打印test2()的返回值
-------------------》
<function test2 at 0x00000000021DF730>
222222222222222222233333
2222222222
None -------------> 因为函数中没有定义返回值，所以返回值为None.
补充说明：
def test1():
print(2222222222)
return ‘xxxxxx‘
print(test1()) --------------------------> 分两步执行：1，test1()函数执行，2，打印该函数的执行结果
------->
2222222222
xxxxxx
-----------------------------------------------------------------------------------------------------------------------------
实例8，@timer 的作用：
实例9，
import time
def timer(func): ---------------------------- timer(test1) ,将test1的内存地址传给func了，
def deco(): ----------------> 嵌套函数
start_time=time.time()
func() ------------------------- 运行test1（）
stop_time=time.time()
print("the func run time is %s" %(stop_time-start_time)) -------- 打印出test1 的运行时间
return deco ------------------------------------------------- 高阶函数，返回这个函数（或者叫变量）的内存地址
def test1():
time.sleep(3)
print(‘in the test1‘)
test1=timer（test1）
test1() ------------- 此时实际执行的就是deco的函数
-------> 等3秒后出现以下结果
in the test1
the func time is 3.00001785546222
装饰器的用法：@,给哪个函数加，就在哪个函数的上头将上@
实例10,
import time
def timer(func): ---------------------------- timer(test1) ,将test1的内存地址传给func了，
def deco(): ------------------嵌套函数
start_time=time.time()
func() ------------------------- 运行test1（）
stop_time=time.time()
print("the func run time is %s" %(stop_time-start_time)) -------- 打印出test1 的运行时间
return deco ------------------------------------------------- 高阶函数，返回这个函数（或者叫变量）的内存地址
@timer ------------- 作用相当于：test1=timer(test1)
def test1():
time.sleep(3)
print(‘in the test1‘)
@timer
def test2():
time.sleep(3)
print(‘in the test2‘)
test1()
test2()
实例11：装饰器：可以满足日常90%的需求：针对任意的传入的参数
import time
def timer(func):
def deco(*args,**args):
start_time=time.time()
func(*args,**args)
stop_time=time.time()
print("the func run time is %s" %(stop_time-start_time))
return deco
@timer
def test1():
time.sleep(3)
print(‘in the test1‘)
@timer
def test2():
time.sleep(3)
print(‘in the test2‘)
test1()
test2()
实例12：模拟网站，一个页面就是一个函数
import time
user,passwd =‘alex‘,‘abac123‘
def auth(func):
def wrapper(*args,**kwargs):
username = input("Username:").strip()
password = input("Password:").strip()
if user == username and passwd == password:
print("user has passed authz")
func(*args,**args)
else:
exit
return wrapper
def index():
print("welcome to index page")
@auth
def home():
print("welcome to home page")
return "from home"
@auth
def bbs():
print("welcome to bbs page")
index()
home()
bbs()
3、迭代器&生成器
3.1、 列表生成式(在cmd的python命令行里执行)，使代码更简洁。
[i*2 for i in range(10)]
等同于：
a = []
for i in range(10):
a.append(i*2)
print(a)
3.2、 通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的
空间都白白浪费了。所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。
生成器特点：1，生成器只有在调用时候才会生成相应的数据。并且生成器省内存的方法就是只保留一个值
2, 只记录当前位置
3，只有一个next方法：__next__() 双下划线
在Python中，这种一边循环一边计算的机制，称为生成器：generator。
在cmd的python命令下运行：
生成1个1百万的列表:
>>>[i*2 fro i in range(1000000)] 此时就会打印
...
赋值的形式：
>>>a = [i*2 fro i in range(1000000)] 后面的数字越大，则这一步的时间越长。
>>>len(a) 可以查看
调用方式：
>>>a[1000]
>>>c = ( i*2 for i in range(100000000)) ----马上出来，因为它不生成具体的每一个数字，只生成一个内存地址，此时，只有你访问这个地址，它才会生成。不访问的话，它都不会存在。和列表的区别，只有在调用的时候才会生成。
不调用的时候不会生成。
>>>print（c）
<generator object <genexpr> at 0x000000000000D4E308>
访问的范式：不能通过列表的下标去取值
生成器取值只能是一个一个的去取
>>> c._ _next_ _() --------------- 实际中next用得并不多，实际中用循环去调取数据。
5122
>>> c._ _next_ _()
5124
3.3、利用函数来做生成器
generator非常强大，如果用推算的算法比较复杂，用类型表达式的for循环无法实现的时候，还可用函数来实现
斐波拉契数列（Fibonacci），除第一个和第二个数外，任意一个数都可由前两个数相加得到：
1, 1, 2, 3, 5, 8, 13, 21, 34, ...
斐波拉契数列用列表生成式写不出来，但是，用函数把它打印出来却很容易：
def fib(max):
n, a, b = 0, 0, 1
while n < max:
print(b)
a, b = b, a + b
n = n + 1
return ‘done‘
注意，赋值语句：
a, b = b, a + b
相当于：
t = (b, a + b) # t是一个tuple
a = t[0]
b = t[1]
>>> fib(10) 调用：意思是生成10个这个序列
1
1
2
3
5
8
13
21
34
55
done
要把fib函数变成generator，只需要把print(b)改为yield b就可以了：
def fib(max):
n,a,b = 0,0,1
while n < max:
#print(b)
yield b
a,b = b,a+b ==========》 注意这个书写方式，是两个等式同时赋值的意思。即 a=b,b=a+b 同时进行赋值！！！。
n += 1
return ‘done‘
print（fib(100)）
运行后：
<generator object fib at 0x000000000000D4E308>
这就是定义generator的另一种方法。如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator：
>>> f = fib(6)
>>> f
<generator object fib at 0x104feaaa0>
pytharm里面是这样的：
<generator object f at 0x0000000001DC68E0>
这里，最难理解的就是generator和函数的执行流程不一样。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield
语句处继续执行。
作用：上面的f函数是可以在程序外来随时中断的，又可以随时的恢复启用，中间可以夹杂别的程序。
当f程序是个很大的很慢的程序时，就可以在这中间夹杂别的程序了
data = fib(10)
print(data)
print(data.__next__())
print(data.__next__())
print("干点别的事") ------------可以跳出程序外做别的任务。然后又可以随时进入在生成器程序。
print(data.__next__())
print(data.__next__())
print(data.__next__())
print(data.__next__())
print(data.__next__())
#输出
<generator object fib at 0x101be02b0>
1
1
干点别的事
2
3
5
8
13
复制代码
在上面fib的例子，我们在循环过程中不断调用yield，就会不断中断。当然要给循环设置一个条件来退出循环，不然就会产生一个无限数列出来。
同样的，把函数改成generator后，我们基本上从来不会用next()来获取下一个返回值，而是直接使用for循环来迭代：
def f(max):
n,a,b=0,0,1
while n<max:
yield b
a,b = b,a+b
n = n+1
return "done"
for n in f(10):
print(n)
1
1
2
3
5
8
但是用for循环调用generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def f(max):
n,a,b=0,0,1
while n<max:
yield b
a,b = b,a+b
n = n+1
return "done"
for n in f(10):
print(n)
g = fib(6)
while True:
try:
x = next(g)
print(‘g:‘, x)
except StopIteration as e:
print(‘Generator return value:‘, e.value)
break
意思是：while True :一直循环下去
try：一直抓值，
except ... 直到抓取到特定的StopIteration这个错误的时候才执行其下面的语句：print和break操作。e代表上文代码里定义的返回值："done",
g: 1
g: 1
g: 2
g: 3
g: 5
g: 8
Generator return value: done
关于如何捕获错误，后面的错误处理还会详细讲解
例2：
def f(max):
n,a,b =0,0,1
while n<max:
yield b
a,b = b,a+b
n =n+1
return "done"
g = f(10)
print("========== start loop ==========")
for i in g:
print(i)
def f(max):
n,a,b =0,0,1
while n<max:
yield b
a,b = b,a+b
n =n+1
return "done"
g = f(10)
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
运行：
报错一个"done"的异常错误。因为取值超过了定义的10次，已经取不到值了
改进方法：引进try：
def f(max):
n,a,b =0,0,1
while n<max:
yield b
a,b = b,a+b
n =n+1
return "done" -----------就是超值范围后的报错信息，异常的时候打印的消息。
g = f(10)
while True: ----------> 死循环
try: ---------------> s是一种不断的抓的方法
x = next(g)
print("g:",x)
except StopIteration as e:
print("Generator return value:",e.value)
break
意思是try下面的代码一旦出这个错：StopIteration （出来别的任何错都不处理）
就执行：print("Generator return value:",e.value) 和break 跳出循环
总结：代码带有yield的就不叫函数了。就是一个生成器了。
yield作用：使得函数保存当前位置，并退出该函数，下次任何再调用函数的时候再回来
应用：通过yield实现在单线程的情况下实现并发运算的效果
实例1：
def con(name):
print("%s prepare to eat box."%name)
while True:
baozi = yield
print("box %s coming,and eated by %s"%(baozi,name))
c =con("chen")
c.__next__()
c.__next__()
运行：
chen prepare to eat box.
box None coming,and eated by chen
例2：
def con(name):
print("%s prepare to eat box."%name)
while True:
baozi = yield
print("box %s coming,and eated by %s"%(baozi,name))
c =con("chen")
c.__next__()
b1 = "韭菜的"
c.send(b1)
--->
chen prepare to eat box.
box 韭菜的 coming,and eated by chen
解释：send 可以给yield传值同时调用该值
next仅仅是调用yield的值。
例3：
def con(name):
print("%s prepare to eat box."%name)
while True:
baozi = yield
print("box %s coming,and eated by %s"%(baozi,name))
c =con("chen")
c.__next__()
b1 = "韭菜的"
c.send(b1)
c.__next__()
---->
chen prepare to eat box.
box 韭菜的 coming,and eated by chen
box None coming,and eated by chen
迭代器&生成器
1，列表生产式：
a = [1,3,2]
--->
[ i*2 for i in range(10) ]
先用i循环产生的值 *2 ，生成的值就是列表的新元素
以前的实现方法(python软件里实现)：
a = []
for i in range(10):
a.append(i*2)
作用：简化代码
扩展：传递变量i，也可以传递一个函数进去
[ func(i) for i in range(10)]
2,生成器generator：仅生成需要使用的元素，列表里用不到的元素就不生成，节省内存空间
实例：
（ i*2 for i in range(10)）
b = （ i*2 for i in range(10)）
for i in b:
print(i)
0
2
4
6
8
10
12
14
16
18
作用：快速生成
[ i*2 for i in range(100000000) ] ----》 1分钟的时间生成，生成式写好后立即生成。
（补充：a = xxx \n len(a) 查看a生成到哪里了,取值a[10]）
b = （ i*2 for i in range(1000000)） -----》瞬间完成，压根就不生成任何元素。调用的时候再生成
生成具体的元素：
for i in b:
print(i)
...
...
...
取值方法：
b._ _next_ _()
和列表的区别：调用的时候才生成
生成器取值的方法：1，只有用这一个next方法取值，取下一个值: b._ _next_ _()，实际中用next取值应用得比较少。
2，只记住当前的位置，只记住当前位置的这个元素。从而达到节省内存的目的
3，利用函数来做生成器
3.1肺波拉起数列：除第一个第二个数外，任意一个数都可以由前两个数相加得到
此时用列表无法实现。可以用函数定义出：
def f(max):
n,a,b =0,0,1
while n<max:
print(b) ------------》改成 yield b 就成立生成器
a,b = b,a+b
n =n+1
f(10) -----》生成10个该数列：1，1，2，3，5，8，13，21，34，55
def f(max):
n,a,b =0,0,1
while n<max:
yield b
a,b = b,a+b
n =n+1
print(f(100)) ----> <generator object fib at 0x0000000000006CJSIF5645>
使用方法：
def f(max):
n,a,b =0,0,1
while n<max:
yield b
a,b = b,a+b
n =n+1
g = f(100)
print(g.__next__())
print(g.__next__())
...
--->
1
1
...
作用：上面的f函数是可以在程序外来随时中断的，又可以随时的恢复启用，中间可以夹杂别的程序。
当f程序是个很大的很慢的程序时，就可以在这中间夹杂别的程序了
如：
def f(max):
n,a,b =0,0,1
while n<max:
yield b
a,b = b,a+b
n =n+1
g = f(100)
print(g.__next__()) ---->1
print(g.__next__()) ---->1
print("do some other things")
print(g.__next__()) ----->2
print("do some other things")
print("do some other things")
print(g.__next__()) ----->3
print(g.__next__()) ----->5
例2：
def f(max):
n,a,b =0,0,1
while n<max:
yield b
a,b = b,a+b
n =n+1
return "done"
g = f(10)
print("========== start loop ==========")
for i in g:
print(i)
def f(max):
n,a,b =0,0,1
while n<max:
yield b
a,b = b,a+b
n =n+1
return "done"
g = f(10)
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
运行：
报错一个"done"的异常错误。因为取值超过了定义的10次，已经取不到值了
改进方法：引进try：
def f(max):
n,a,b =0,0,1
while n<max:
yield b
a,b = b,a+b
n =n+1
return "done" -----------就是超值范围后的报错信息，异常的时候打印的消息。
g = f(10)
while True: ----------> 死循环
try: ----------> 是一种不断的抓的方法
x = next(g)
print("g:",x)
except StopIteration as e:
print("Generator return value:",e.value)
break
意思是try下面的代码一旦出这个错：StopIteration （出来别的任何错都不处理）
就执行：print("Generator return value:",e.value) 和break 跳出循环
总结：代码带有yield的就不叫函数了。就是一个生成器了。
例：
import time
def consumer(name):
print("%s 准备吃包子啦!" %name)
while True:
baozi = yield
print("包子[%s]来了,被[%s]吃了!" %(baozi,name))
def producer(name):
c = consumer(‘A‘)
c2 = consumer(‘B‘)
c.__next__() ---------------------> 打印“print("%s 准备吃包子啦!" %name)”这句代码
c2.__next__()
print("老子开始准备做包子啦!")
for i in range(10):
time.sleep(1)
print("做了2个包子!")
c.send(i)
c2.send(i)
producer("alex")
迭代器：
迭代器是访问集合元素的一种方式。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退，不过这也没什么，因为人们很少在迭代途中往后退。另外，迭代器的一大优点是不要求事先准备好
整个迭代过程中所有的元素。迭代器仅仅在迭代到某个元素时才计算该元素，而在这之前或之后，元素可以不存在或者被销毁。这个特点使得它特别适合用于遍历一些巨大的或是无限的集合，比如几个G的文件
特点：
1.访问者不需要关心迭代器内部的结构，仅需通过next()方法不断去取下一个内容
2.不能随机访问集合中的某个值 ，只能从头到尾依次访问
3.访问到一半时不能往回退
4.便于循环比较大的数据集合，节省内存
>>> a = iter([1,2,3,4,5])
>>> a
<list_iterator object at 0x101402630>
>>> a.__next__()
1
>>> a.__next__()
2
>>> a.__next__()
3
>>> a.__next__()
4
>>> a.__next__()
5
>>> a.__next__()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
可以直接作用于for循环的数据类型有以下几种：
一类是集合数据类型，如list、tuple、dict、set、str等；
一类是generator，包括生成器和带yield的generator function。
这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。
可以使用isinstance()判断一个对象是否是Iterable对象：
>>> from collections import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance(‘abc‘, Iterable)
True
>>> isinstance((x for x in range(10)), Iterable)
True
>>> isinstance(100, Iterable)
False
而生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后抛出StopIteration错误表示无法继续返回下一个值了。
*可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。
判断：一个函数里有next的方法的就叫迭代器（反之，没有这个方法的就不叫迭代器）
>>> a =[1,2,3]
>>> dir(a) ---------> 查看有无next方法
生成器肯定就是迭代器（因为生成器有next方法）：
>>> from collection import Iterator
>>> isinstance((x for x in range(5)).Iterator)
True
但迭代器不一定就是生成器
可以使用isinstance()判断一个对象是否是Iterator对象：
>>> from collections import Iterator
>>> isinstance((x for x in range(10)), Iterator)
True
>>> isinstance([], Iterator) ------》判断列表是否是
False
>>> isinstance({}, Iterator) —————》 字典
False
>>> isinstance(‘abc‘, Iterator) --------》字符串
False
生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。
>>>a=[1,2,3]
>>>iter(a)
>>>b=iter(a) ---------> 此时的b就是一个迭代器了，可以通过next的方法取值了。
>>>b.__next__()
>>>b.__next__()
>>>b.__next__()
把list、dict、str等Iterable变成Iterator可以使用iter()函数：
>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter(‘abc‘), Iterator)
True
你可能会问，为什么list、dict、str等数据类型不是Iterator？
这是因为Python的Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只
能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。
Iterator甚至可以表示一个无限大的数据流，例如全体自然数。而使用list是永远不可能存储全体自然数的。
小结
凡是可作用于for循环的对象都是Iterable类型；
凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；
集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。
Python的for循环本质上就是通过不断调用next()函数实现的，例如：
for x in [1, 2, 3, 4, 5]:
pass
实际上完全等价于：
# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
try:
# 获得下一个值:
x = next(it)
except StopIteration:
# 遇到StopIteration就退出循环
break
例：range(10) 在python3.0里就是一个迭代器
>>> range(10) -------> python3.0
range(1.10)
>>> range(10) --------> python2.0 变成跌代器：xrange(10)
[0,1,2...9]
本质：3.0里面的for循环就是通过next的方法去取值的。
for line in f.readlines():
xxx
这个也是使用迭代的方法。一次读一行。
以后通过socket传文件的额时候可以用这个，因为底层很多的都是迭代器封装的。
内置方法（内置参数）pycharm里演示：
abs():取绝对值
all():
Return True if all elements of the iterable are true (or if the iterable is empty). Equivalent to:
def all(iterable):
for element in iterable:
if not element:
return False
return True
实例：
print(all[0,12,-45345]) ----> 因为0为非真，故返回假
print(all[12210,12,-45345])
any() 如果可迭代对象的任意的一个数据为真，就返回真，（有一个数据为真就返回真）。列表为空就返回假
def any(iterable):
for element in iterable:
if element:
return True
return False
实例：
print(any[0,12,-45345])
print(all[])
print(all[0])
ascii(): 没用:将一个内存对象变成一个可打印的字符串
实例：print（ascii([1,3,"是否发生李开复"]）)
a=[1,3,"是否发生李开复"]
print(a,type(a))
--------------------------------------------------------------------------------------
bin() 将一个整数转换成二进制(1进制转二进制)
>>>bin(1)
>>>bin(234432143)
--------------------------------------------------------------------------------------
bool() 布尔判断。0就是FALSE，1就是true
>>>bool(1)
>>>bool(0)
--------------------------------------------------------------------------------------
bytearray() 字节数组,将二进制变成列表的形式可以修改了。用不上，知道有这个东西就行了
a=bytes("abcde",encoding="utf-8")
print(a)
print(a.capitalize(),a)
理解：字符串不可以修改，列表可以修改。
b=bytearray("abcde",encoding="utf-8")
b[0]
print(b[0]) ---------> 97 ascii码里a这个字符对应的就是97
print(b[1]) ---------> 98 ascii码里b这个字符对应的就是98
b[1] = 100
print(b)
b[1] = 50
print(b) -----> bytearary(b"xxxxxx")
---------------------------------------------------------------------------------------
callable(object) 判断对象是否可以调用：在这个对象后面可以加（）的就是属于可以调用
比如：
print(callable（[1,2,3]）） ----> false
def a():pass
print(callable(a)) -----> true
--------------------------------------------------------------------------------
chr() ---> 反映数字！！对应的ASCII码的字符
chr（97）
---------------------------------------------------------------------------------
ord() ----->反映字符在ascii码里对应的数字
ord(a)
---------------------------------------------------------------------------------
classmothod()类方法
---------------------------------------------------------------------------------
compile() 底层的，将代码用于编译的。用不上
---------------------------------------------------------------------------------
complex() 复数，用不上
---------------------------------------------------------------------------------
delattr( ) 面向对象
-----------------------------------------------------------------------------------
dir（）：查看某个对象的所有方法：
a= {1,2,212}
dir（a） ------->结果里面有两个下划线的除了next都是内置方法，我们不能用，其他的方法可以用
-----------------------------------------------------------------------------------
divmod() 相除并返回商和余数
divmod(5,3)
-->
(1,2)
-----------------------------------------------------------------------------------------
filter（function，iterable）:对传入的值按照function的方法过滤下在处理，从一组数据里面过滤出你想要的。
例：
a=filter(lambda n:n>5,range(10))
for i in a:
print(a)
----------------------------------------------------------------------------------------
map(function，iterable) 对传入的值都安装function的方法来处理
a=map(lambda n:n**n,range(10)) == a=[lambda i:i*2 for i in range(10)]
for i in a:
print(i)
-----------------------------------------------------------------------------------------
reduce():是一个标注库里的模块了,逐渐相加
import functools
a = functools.reduce(lambda x,y:x+y,range(10))
print(a)
___>45
0+1+2+3+4+5+6+7+8+9==45
---------------------------------------------------
frozenset([iterable]) 不可变的
a= [1,2,3,4323,4,24,234,234,,124,13,21,3]
a=frozenset([1,2,3,4323,4,24,234,234,,124,13,21,3])
此时的a就不可变了。没有了改，增，删的方法了
----------------------------------------------------
globals() 返回当前程序所有变量的key.value的格式
print(globals()) 用得少
-----------------------------------------------------
解释：哈希算法：固定映射关系：
张三 =“xxx” --------》 python自动给"张飞" 映射成 1，
李四 = “xxx” --------》 ..........................2,
下次寻址：寻张三，就安装对应表找1，等于就是寻找：1,2,3,4,5,6...等
而找1000000里面的值的方法：
假如找5000，在100万里打半，50万 》5千
再判断：25万 》 5千
再打半判断：12.5万 > 5千
........... 6.75万 ....
3.875 ....
............1.9875 ...
............ 1万 > 5千
。。。。。。5 qian = 5qian 找到了。等于在100万里找个数通过7次就找到了
例：
hash(10) ----》打印出16进制
hash（“Jack”）
----------------------------------------------------------------------------
locals() -----> 用不上
----------------------------------------------------------------------------
max() 返回列表里的最大值
min() 返回列表里的最小值
-----------------------------------------------------------------------------
oct() 转8进制,没什么用
oct(1)
--->0o1
oct(9)
--->
0o11
-----------------------------------------------------------------------------
pow(x,y), x的y次方
pow（2,3）
--》8
----------------------------------------------------------------------------------
round(1.2342342342) --- 保留2位小数点
--->
1.33
----------------------------------------------------------------------------------
setattr() 非常重要的！！
----------------------------------------------------------------------------------
slice() 切片 ---- 没用
例：
d = range(20)
d[slice（2,5）]
语法等于：
d[2,5]
-----------------------------------------------------------------------------
sorted（）
例：
a = {
6:2,
8:0,
1:4,
9:11
}
print(a)
因为字典本身即是无序的，通过sort()可以排序,默认安装key来排序
print(sorted(a.iteams())
安装value来排序:
print(sorted(a.items(),key=lambda x:x[1])) x代表：字典里的元素 key:value
-----------------------------------------------------------------------------
zip() 拉链，
a=[1,2,3,4]
b=[‘a‘,‘b‘,‘c‘,‘d‘]
zip(a,b)
print(zip(a,b))
for i in zip(a,b):
print(i)
当a,b 的元素个数不一样的时候，按照最少的那个来组合
----------------------------------------------------------------------------------
json 和pickle
用于序列化的两个模块
json，用于字符串 和 python数据类型间进行转换
pickle，用于python特有的类型 和 python的数据类型间进行转换
Json模块提供了四个功能：dumps、dump、loads、load
pickle模块提供了四个功能：dumps、dump、loads、load
序列化：将内存的对象变成字符串
例：将字典存成字符串：
info = {
name="alex",
age=22,
}
f= open(‘text‘,‘w‘)
f.write(str(info))
f.close
反序列化：
d = f.read()
f.close()
print(d)
--》
d = eval(f.read())
f.close()
print(d[‘age‘]) ----->22
----------------------------
info = {
name="alex",
age=22,
}
序列化dumps： 将硬盘的数据对象存到内存上了
f = open(‘text‘,‘w‘)
print(json.dumps(info))
----------------------------
反序列化loads：将内存的数据对象存到硬盘上了
import json
f= open("text",‘r‘)
d = json.loads(f.read())
print(d["age"])
右键运行：反序列化：
22
例：
import json
def sayhi(name):
print("hello",name)
info = {
‘name‘:"alex",
"age":22,
"func":sayhi
}
f = open("text","w")
f.write(json.dumps(info))
f.close()
报错：该内存地址不是一个json的可序列化的数据，json只能处理简单的数据，比如：字典，列表，字符串等
因为json是所有的语言里都通用的。作用在于在不同语言之间进行交互。
处理复杂的可序列化的数据：用pikle:
import json
def sayhi(name):
print("hello",name)
info = {
‘name‘:"alex",
"age":22,
"func":sayhi
}
f = open("text","wb")
print()
f.write(pickle.dumps(info))
f.close()
反序列化：
d = pickle.loads(f.read)
print(d[‘age‘])
f=open(‘text‘,"wb")
pickle.dump(info,f) == f.write(pickle.dumps(info))
f.close()
d = pickle.load(f) == d = pickle.loads(f.read())
print(d[‘func‘]("alex"))
要点：json的序列化，反序列化
pickle的序列化，反序列化
引申：dump两次、三次
------------------------------------------------------------------------------------------------
软件目录开发规范：
为什么要设计好目录结构
"设计项目目录结构"，就和"代码编码风格"一样，属于个人风格问题。对于这种风格上的规范，一直都存在两种态度:
一类同学认为，这种个人风格问题"无关紧要"。理由是能让程序work就好，风格问题根本不是问题。
另一类同学认为，规范化能更好的控制程序结构，让程序具有更高的可读性。
我是比较偏向于后者的，因为我是前一类同学思想行为下的直接受害者。我曾经维护过一个非常不好读的项目，其实现的逻辑并不复杂，但是却耗费了我非常长的时间去理解它想表达的意思。从此我个人对于提高项目可读性、可维护性的
要求就很高了。"项目目录结构"其实也是属于"可读性和可维护性"的范畴，我们设计一个层次清晰的目录结构，就是为了达到以下两点:
可读性高: 不熟悉这个项目的代码的人，一眼就能看懂目录结构，知道程序启动脚本是哪个，测试目录在哪儿，配置文件在哪儿等等。从而非常快速的了解这个项目。
可维护性高: 定义好组织规则后，维护者就能很明确地知道，新增的哪个文件和代码应该放在什么目录之下。这个好处是，随着时间的推移，代码/配置的规模增加，项目结构不会混乱，仍然能够组织良好。
所以，我认为，保持一个层次清晰的目录结构是有必要的。更何况组织一个良好的工程目录，其实是一件很简单的事儿。
目录组织方式
关于如何组织一个较好的Python工程目录结构，已经有一些得到了共识的目录结构。在Stackoverflow的这个问题上，能看到大家对Python目录结构的讨论。
这里面说的已经很好了，我也不打算重新造轮子列举各种不同的方式，这里面我说一下我的理解和体会。
假设你的项目名为foo, 我比较建议的最方便快捷目录结构这样就足够了:
Foo/
|-- bin/
| |-- foo ----------》 执行这里的文件，去调用下面的main.py的主程序，从而实现整个python程序运行。
|-- conf/
|
|-- foo/
| |-- tests/ ------------------>测试的
| | |-- __init__.py
| | |-- test_main.py
| |
| |-- __init__.py
| |-- main.py ---------------> 正式的
|
|-- docs/ --------------> 文档
| |-- conf.py
| |-- abc.rst
|
|-- setup.py -----------> 安装程序
|-- requirements.txt --------> 依赖哪些别的软件
|-- README
简要解释一下:
bin/: 存放项目的一些可执行文件，当然你可以起名script/之类的也行。
foo/: 存放项目的所有源代码。(1) 源代码中的所有模块、包都应该放在此目录。不要置于顶层目录。(2) 其子目录tests/存放单元测试代码； (3) 程序的入口最好命名为main.py。
docs/: 存放一些文档。
setup.py: 安装、部署、打包的脚本。
requirements.txt: 存放软件依赖的外部Python包列表。
README: 项目说明文件。
除此之外，有一些方案给出了更加多的内容。比如LICENSE.txt,ChangeLog.txt文件等，我没有列在这里，因为这些东西主要是项目开源的时候需要用到。如果你想写一个开源软件，目录该如何组织，可以参考这篇文章。
下面，再简单讲一下我对这些目录的理解和个人要求吧。
关于README的内容
这个我觉得是每个项目都应该有的一个文件，目的是能简要描述该项目的信息，让读者快速了解这个项目。
它需要说明以下几个事项:
1、软件定位，软件的基本功能。
2、运行代码的方法: 安装环境、启动命令等。
3、简要的使用说明。
4、代码目录结构说明，更详细点可以说明软件的基本原理。
5、常见问题说明。
我觉得有以上几点是比较好的一个README。在软件开发初期，由于开发过程中以上内容可能不明确或者发生变化，并不是一定要在一开始就将所有信息都补全。但是在项目完结的时候，是需要撰写这样的一个文档的。
可以参考Redis源码中Readme的写法，这里面简洁但是清晰的描述了Redis功能和源码结构。
关于requirements.txt和setup.py
setup.py
一般来说，用setup.py来管理代码的打包、安装、部署问题。业界标准的写法是用Python流行的打包工具setuptools来管理这些事情。这种方式普遍应用于开源项目中。不过这里的核心思想不是用标准化的工具来解决这些问题，而是说，
一个项目一定要有一个安装部署工具，能快速便捷的在一台新机器上将环境装好、代码部署好和将程序运行起来。
这个我是踩过坑的。
我刚开始接触Python写项目的时候，安装环境、部署代码、运行程序这个过程全是手动完成，遇到过以下问题:
安装环境时经常忘了最近又添加了一个新的Python包，结果一到线上运行，程序就出错了。
Python包的版本依赖问题，有时候我们程序中使用的是一个版本的Python包，但是官方的已经是最新的包了，通过手动安装就可能装错了。
如果依赖的包很多的话，一个一个安装这些依赖是很费时的事情。
新同学开始写项目的时候，将程序跑起来非常麻烦，因为可能经常忘了要怎么安装各种依赖。
setup.py可以将这些事情自动化起来，提高效率、减少出错的概率。"复杂的东西自动化，能自动化的东西一定要自动化。"是一个非常好的习惯。
setuptools的文档比较庞大，刚接触的话，可能不太好找到切入点。学习技术的方式就是看他人是怎么用的，可以参考一下Python的一个Web框架，flask是如何写的: setup.py
当然，简单点自己写个安装脚本（deploy.sh）替代setup.py也未尝不可。
requirements.txt
这个文件存在的目的是:
方便开发者维护软件的包依赖。将开发过程中新增的包添加进这个列表中，避免在setup.py安装依赖时漏掉软件包。
方便读者明确项目使用了哪些Python包。
这个文件的格式是每一行包含一个包依赖的说明，通常是flask>=0.10这种格式，要求是这个格式能被pip识别，这样就可以简单的通过 pip install -r requirements.txt来把所有Python包依赖都装好了。具体格式说明： 点这里。
关于配置文件的使用方法
注意，在上面的目录结构中，没有将conf.py放在源码目录下，而是放在docs/目录下。
很多项目对配置文件的使用做法是:
配置文件写在一个或多个python文件中，比如此处的conf.py。
项目中哪个模块用到这个配置文件就直接通过import conf这种形式来在代码中使用配置。
这种做法我不太赞同:
这让单元测试变得困难（因为模块内部依赖了外部配置）
另一方面配置文件作为用户控制程序的接口，应当可以由用户自由指定该文件的路径。
程序组件可复用性太差，因为这种贯穿所有模块的代码硬编码方式，使得大部分模块都依赖conf.py这个文件。
所以，我认为配置的使用，更好的方式是，
模块的配置都是可以灵活配置的，不受外部配置文件的影响。
程序的配置也是可以灵活控制的。
能够佐证这个思想的是，用过nginx和mysql的同学都知道，nginx、mysql这些程序都可以自由的指定用户配置。
所以，不应当在代码中直接import conf来使用配置文件。上面目录结构中的conf.py，是给出的一个配置样例，不是在写死在程序中直接引用的配置文件。可以通过给main.py启动参数指定配置路径的方式来让程序读取配置内容。当然，这
里的conf.py你可以换个类似的名字，比如settings.py。或者你也可以使用其他格式的内容来编写配置文件，比如settings.yaml之类的。
跨目录调用文件:atm.py 调用settings.py和main.py
atm
|-bin
| |- __init__.py
| |- atm.py
|-conf
| |- __init__.py
| |- settings.py
|-core
|- __init__.py
|- main.py
def login():
print("welcome to my atm")
print(__file__) ----------------> 当前文件的相对路径
import os
#print(os.path.abspath(__file__)) ---> 当前文件的绝对路径
#通过dir命令：返回路径名，不要文件名
#print（os.path.dirname(os.path.abspath(__file__))） -----> 可以找到父一级的目录：bin目录
#再向上一级，到atm的总目录
import sys
BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_DIR)
import conf,core
from conf import settings -----------> 这样就可以调用 conf 目录下的文件了
from core import main -----------> 这样就可以调用core目录下的文件了
main.login()
程序结构:
day4-atm/
├── README
├── atm #ATM主程目录
│ ├── __init__.py
│ ├── bin #ATM 执行文件 目录
│ │ ├── __init__.py
│ │ ├── atm.py #ATM 执行程序
│ │ └── manage.py #ATM 管理端,未实现
│ ├── conf #配置文件
│ │ ├── __init__.py
│ │ └── settings.py
│ ├── core #主要程序逻辑都 在这个目录 里
│ │ ├── __init__.py
│ │ ├── accounts.py #用于从文件里加载和存储账户数据
│ │ ├── auth.py #用户认证模块
│ │ ├── db_handler.py #数据库连接引擎
│ │ ├── logger.py #日志记录模块
│ │ ├── main.py #主逻辑交互程序
│ │ └── transaction.py #记账\还钱\取钱等所有的与账户金额相关的操作都 在这
│ ├── db #用户数据存储的地方
│ │ ├── __init__.py
│ │ ├── account_sample.py #生成一个初始的账户数据 ,把这个数据 存成一个 以这个账户id为文件名的文件,放在accounts目录 就行了,程序自己去会这里找
│ │ └── accounts #存各个用户的账户数据 ,一个用户一个文件
│ │ └── 1234.json #一个用户账户示例文件
│ └── log #日志目录
│ ├── __init__.py
│ ├── access.log #用户访问和操作的相关日志
│ └── transactions.log #所有的交易日志
└── shopping_mall #电子商城程序,需单独实现
└── __init__.py