Python 迭代器&生成器

1.内置参数

		Built-in Functions
abs()	dict()	help()	min()	setattr()
all()	dir()	hex()	next()	slice()
any()	divmod()	id()	object()	sorted()
ascii()	enumerate()	input()	oct()	staticmethod()
bin()	eval()	int()	open()	str()
bool()	exec()	isinstance()	ord()	sum()
bytrarray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()	__import__()
complex()	hasattr()	max()	round()
delattr()	hash()	memoryview()	set()

内置参数详解 https://docs.python.org/3/library/functions.html?highlight=built#ascii

2.迭代器&生成器

列表生成式，是Python内置的一种极其强大的生成list的表达式。

如果要生成一个list [1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9] 可以用 range(1 , 10)：

1 2	#print(list(range(1,10))) [1, 2, 3, 4, 5, 6, 7, 8, 9]

如果要生成[1x1, 2x2, 3x3, ..., 10x10]怎么做？

1 2 3 4 5 6

l = [] for i in range(1,10):     l.append(i*i) print(l) ####打印输出#### #[1, 4, 9, 16, 25, 36, 49, 64, 81]

而列表生成式则可以用一行语句代替循环生成上面的list：

1 2	>>> print([x*x for x in range(1,10)]) [1, 4, 9, 16, 25, 36, 49, 64, 81]

for循环后面还可以加上if判断，这样我们就可以筛选出仅偶数的平方：

1 2	>>> print([x*x for x in range(1,10) if x %2 ==0]) [4, 16, 36, 64]

>>>[ i*2 for i in range(10)]
[0,1,4,6,8,10,12,14,16,18]
等于
>>>a=[]
>>>for i in range(10)：
.  .  .    a.append(i*2)
>>>a
[0,1,4,6,8,10,12,14,16,18]

小程序

str1 = ""
for i in iter(input,""):    # 循环接收 input输入的内容
    str1 += i

print(str1)

生成器

通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。

要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：

>>>l = [x*x for x in range(10)]
>>>l
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>>g = (x*x for x in range(10))
>>>g
<generator object <genexpr> at 0x1022ef630>

创建L和g的区别仅在于最外层的[]和()，L是一个list，而g是一个generator。

我们可以直接打印出list的每一个元素，但我们怎么打印出generator的每一个元素呢？

如果要一个一个打印出来，可以通过next()函数获得generator的下一个返回值：

>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
9
>>> next(g)
16
>>> next(g)
25
>>> next(g)
36
>>> next(g)
49
>>> next(g)
64
>>> next(g)
81
>>> next(g)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

所以，我们创建了一个generator后，基本上永远不会调用next()，而是通过for循环来迭代它，并且不需要关心StopIteration的错误。

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'

上面的函数可以输出斐波那契数列的前N个数：

>>>fib(10)
1
1
2
3
5
8
13
21
34
55
done

生成器的特点：

1）生成器只有在调用时才会生成相应的数据；

2）只记录当前位置；

3）只有一个__next__()方法；

还可通过yield实现在单线程的情况下实现并发运算的效果：

import time
def consumer(name):
    print("%s 准备吃包子！" %name)
    while True:
        baozi = yield
        print("包子[%s]来了，被[%s]吃了！" %(baozi,name))
c = consumer("ChenRonghua")
c.__next__()

def produceer(name):
    c = consumer("a")
    c2 = consumer("b")
    c.__next__()
    c2.__next__()
    print("老子开始准备做包子啦！")
    for i in range(10):
        time.sleep(1)
        print("做了1个包子，分两半！")
        c.send(i)
        c2.send(i)
produceer("alex")

　　迭代器

我们已经知道，可以直接作用于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循环的对象都是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

　　

3.Json&pickle数据序列化

用于序列化的两个模块

• json，用于字符串 和 python数据类型间进行转换
• pickle，用于python特有的类型 和 python的数据类型间进行转换

Json模块提供了四个功能：dumps、dump、loads、load

pickle模块提供了四个功能：dumps、dump、loads、load

info = {
    "name":"alex",
    "age":22
}
f = open("test.txt","w")
f.write(info)
f.close()

json序列化

 f = open("test.txt","r")

 data = eval(f.read())
 f.close()
 print(data['age'])

json反序列化

json能处理简单的数据类型，字典，列表，字符串。

json是所有语言通用的，json的作用是不同语言之间进行数据交互。

 #json序列化
 import json
 info = {
     "name":"alex",
     "age":22
 }
 f = open("test.txt","w")
 #print(json.dumps(info))
 f.write(json.dumps(info))
 f.close()
 #json反序列化
 import json
 f = open("test.txt","r")

 data = json.loads(f.read())
 f.close()
 print(data['age'])

json序列化，反序列化

 import pickle
 def sayhi(name):
     print("hello,",name)
 info = {
     "name":"alex",
     "age":22,
     "func":sayhi
 }
 f = open("test.txt","wb")

 f.write(pickle.dumps(info))
 f.close()

pickle序列化

import pickle
def sayhi(name):
    print("hello,",name)
f = open("test.txt","rb")
data = pickle.loads(f.read())

print(data['func']("Alex"))

pickle反序列化

4.装饰器

定义：

本质上是个函数，功能是装饰其他函数—就是为其他函数添加附加功能

装饰器原则：

1）  不能修改被装饰函数的源代码；

2）  不能修改被装饰函数的调用方式；

实现装饰器知识储备：

函数即“变量”

定义一个函数相当于把函数体赋值给了函数名

1.函数调用顺序：其他高级语言类似，python不允许在函数未声明之前，对其进行引用或者调用

错误示范：

 def foo():
     print('in the foo')
     bar()
 foo()

 报错：
 in the foo
 Traceback (most recent call last):
   File "<pyshell#13>", line 1, in <module>
     foo()
   File "<pyshell#12>", line 3, in foo
     bar()
 NameError: global name 'bar' is not defined

 def foo():
     print('foo')
     bar()
 foo()
 def bar()
     print('bar')
 报错：NameError: global name 'bar' is not defined

正确示范:(注意，python为解释执行，函数foo在调用前已经声明了bar和foo，所以bar和foo无顺序之分)

def foo()
    print('in the foo')
    bar()
def bar():
    print('in the bar')
foo()

def bar():
    print('in the bar')
def foo():
    print('in the foo')
    bar()
foo()

2.高阶函数

满足下列条件之一就可成函数为高阶函数

　　1.某一函数当做参数传入另一个函数中

　　2.函数的返回值包含n个函数，n>0

高阶函数示范：

def bar():
    print('in the bar')
def foo(func):
    res=func()
    return res
foo(bar)

高阶函数的牛逼之处：

def foo(func):
    return func
print('function body is %s' %(foo(bar)))
print('function name is %s' %(foo(bar).func_name))
foo(bar)()
#foo(bar)() 等同于bar=foo(bar)然后bar()
bar = foo(bar)
bar()

3.内嵌函数和变量作用域

定义：在一个函数体内创建另一个函数，这种函数就叫内嵌函数

嵌套函数：

def foo():
    def bar():
        print('in the bar')
    bar()
foo()

局部作用域和全局做用域的访问顺序

x = 0
def grandpa():
    def dad():
        x = 2
        def son():
            x=3
            print(x)
        son()
    dad()
grandpa()

4.高阶函数+内嵌函数=》装饰器

函数参数固定

def decorartor(func):
    def wrapper(n):
        print('starting')
        func(n)
        print('stopping')
    return wrapper

def test(n):
    print('in the test arg is %s' %n)
decorartor(test)('alex')

函数参数不固定

def decorartor(func):
    def wrapper(*args,**kwargs):
        print('starting')
        func(*args,**kwargs)
        print('stopping')
    return wrapper

def test(n,x=1):
    print('in the test arg is %s' %n)
decorartor(test)('alex',x=2222)

1.无参装饰器

import time
def decorator(func):
    def wrapper(*args,**kwargs):
        start_time=time.time()
        func(*args,**kwargs)
        stop_time=time.time()
        print("%s" %(stop_time-start_time))
    return wrapper

@decorator
def test(list_test):
    for i in list_test:
        time.sleep(0.1)
        print('-'*20,i)

#decorator(test)(range(10))
test(range(10))

2.有参装饰器

import time
def timer(timeout=0):
    def decorator(func):
        def wrapper(*args,**kwargs):
            start=time.time()
            func(*args,**kwargs)
            stop=time.time()
            print('run time is %s ' %(stop-start))
            print(timeout)
        return wrapper
    return decorator
@timer(2)
def test(list_test):
    for i in list_test:
        time.sleep(0.1)
        print ('-'*20,i)

#timer(timeout=10)(test)(range(10))
test(range(10))

3.终极装饰器

user,passwd = 'alex','abc123'
def auth(auth_type):
    print('auth func:',auth_type)
    def outer_wrapper(func):
        def wrapper(*args,**kwargs):
            print("wrapper func args:",*args,**kwargs)
            if auth_type=="local":
                username = input("Username:").strip()
                password = input("Password:").strip()
                if user == username and passwd == password:
                    res = func(*args,**kwargs)
                    print("---after authentication")
                    return res
                else:
                    exit("\033[31;1mInvalid username or password\033[0m")
            elif auth_type == "ldap":
                print('搞毛线ldap,不会......')

        return wrapper
    return outer_wrapper

def index():
    print("welcome to index page")
@auth(auth_type="local")    #home = wrapper()
def home():
    print("welcome to home page")
    return "from home"
@auth(auth_type="ldap")
def bbs():
    print("welcome to bbs page")

index()
print(home())#wrapper()
bbs()