1.生成器的两种定义方式

1
2
3
4
5
1.  (x*2 for x in range(10))

2.def foo():
    yield 1
c=foo()

列表生成器

1
2
3
4
5
6
7
a=[x for x in range(10)]   
print(a)   #[1,2,3,4,5,6,7,8,9]

def f(n):
   return n**3
s=[f(c) for c in range(3)]
print(s) #[0,1,8]

生成器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def foo():
    print('ok1')
    yield 1  #yield 关键字
    print('0k2')
    yield 2
c=foo()  
#一个生成器类型地址<generator object foo at 0x0000029A42661570>

def foo():
    print('ok1')
    yield 1  #yield 关键字
    print('0k2')
    yield 2
#c=foo()  
#一个生成器类型地址<generator object foo at 0x0000029A42661570>
#不加c=foo()时  
#foo()相当于一个函数  yiled相当于return

2.生成器的两种方法：

next调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def foo():
    print('ok1')
    yield 1  #yield 关键字
    print('0k2')
    yield 2
c=foo()  
#一个生成器类型地址<generator object foo at 0x0000029A42661570>
a=next(c)  
b=next(c)  # ok1 ok2 1 2

注：def foo():
    print('ok1')
    yield 1  #执行到该步return 
    print('0k2')
    yield 2
a=next(foo())  
b=next(foo())  
print(a,b)  # ok1 ok2 1 2

send调用

1
2
3
4
5
6
7
8
9
10
11
12
13
def foo():
    print('ok1')
    a=yield 1   ①
    print(a)
    print('0k2')
    b=yield 2
    print(b)
    c=yield 3
    print(c)
c=foo()
c.send(None) #相当于next(b) 执行到yield 1
c.send('abc')  # 给a赋值 ‘abc’ 执行到yield 2
c.send('cba')  # 给b赋值 ‘cba’ 执行到yield 3

注：生成器在定义时值的数量是固定的，调用超出会StopIteration

yield 实现伪并发

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import time
def cons(name):
    print("%s准备吃包子了" % name)
    while True:
        baozi = yield
        print("包子%d来了  %s开始吃包子了" % (baozi,name))
def do(name):
    print("准备做包子了")
    a=cons('a')  #调用con()使得a为生成器
    b=cons('b')  #调用con()使得b为生成器
    a.__next__()  #初次使用生成器 为send赋值做准备
    b.__next__()
    print('开始做包子了')
    for i in range (1,5):
        time.sleep(2)
        print('做了2个包子')
        a.send(i)  #赋值i给包子
        b.send(i)
do('chen')

3.可迭代类型 iterable

3.可迭代类型 iterable

  • 列表 list
  • 元组 tuple
  • 集合 set
  • 字典 dict
1
2
3
4
5
6
7
8
a=[1,2,3]
b=(1,2,3)
c={1,2,3}
d={'name':''}
print(type(a))   #<class 'list'>
print(type(b))   #<class 'tuple'>
print(type(c))   #<class 'set'>
print(type(d))   #<class 'dict'>

4.迭代器 iterator ——遵循迭代器协议

（1.）next方法

（2.）iter()方法

1
2
3
4
5
6
7
8
a=[1,2,3]
b=(1,2,3)
c={1,2,3}
d={'name':''}  
print(iter(a))   #<list_iterator object at 0x0000014B220BDCC0>
print(iter(b))   #<tuple_iterator object at 0x0000014B220BDCC0>
print(iter(c))   #<set_iterator object at 0x0000014B22070DC8>
print(iter(d))   #<dict_keyiterator object at 0x0000014B21DDA548>

4.for循环作用

1
2
3
4
5
for i in iterable
   print i
#1.使用iter方法装换成迭代器
#2.调用next方法输出
#3.检查容错  StopIteration

5.python装饰器

装饰器的实现条件：

1.函数的定义域

2.高阶函数的使用

闭包：

1
2
3
4
5
6
def outer():
    x = 10
    def inner():  #inner 是内部函数
        print(x)   #x是inner函数外的变量
    return inner   #inner就是一个闭包
outer()()  #10

装饰器

1
2
3
4
5
6
7
8
9
10
11
import time
def  show_time(f):   
#f函数名是一个外部形参变量，show_time就是一个装饰器
    def inner():  #inner是一个闭包函数，可调用f
        start=time.time()
        f()
        end=time.time()
        print("time=%d",(end-start))
    return inner
def foo():
    print("foo....")

第一种调用方式：

1
2
foo=show_time(foo)
foo()

第二种调用方式：

1
2
@show_time #foo=show_time(foo)
foo()

装饰器函数的参数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import time
def logger(flag=''):
    def show_time(f):
        def inner(*x,**y):
            start=time.time()
            f(*x,**y)
            end=time.time()
            print("time=%d",(end-start))
            if (flag=='ture'):
                print("日志记录")
        return inner
    return show_time
@logger('')   #调用装饰器函数传入参数 判断是否打印日志文件
def foo():
    print("foo0......")
    time.sleep(3)
foo()
@logger('ture')
def add(*a,**b): #a为函数add的不定长参数 可传入多值
    sum=0
    for i in a:
        sum+=i
    print(sum)
    time.sleep(1)
add(1,2,3,4,5,7,8) #传入多值

简单实现登录系统功能：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
sername,password='chen','123'  #使用‘jd’方式登录的账号密码验证库
wxname,wxpasswd='wang','567'   #使用‘wx’
option = False        #判断是否登录的标志位
def choseup(a=''):  #登录方式选择  装饰器参数
    def up(f):  #装饰器函数  
        def inner():
            if option == False :
                if a=='jd':
                    user1=input("username=\n")
                    passwd1=input("password=\n")
                    if user1==username and passwd1==password :
                        print("登录成功")
                        f()
                        option == True
                    else:
                        print("账号密码错误请重新登录")
                        inner()
                elif a=='wx':
                    user2=input("username=\n")
                    passwd2=input("password=\n")
                    if user2==wxname and passwd2==wxpasswd:
                        print("登录成功")
                        f()
                        option == True
                    else:
                        print("账号密码错误请重新登录")
                        inner()
            else: pass
        return inner
    return up

 
@choseup('jd')    #传输参数‘jd’，选择登录方式为jd
def sort_page1():  
    print("welcome to home")
@choseup('wx')  #传输参数‘wx’，选择登录方式为wx
def sort_page2():
    print("welcome to finale")
@choseup('jd')
def sort_page3():
    print("welcome to book")


def a():
    x = input("1.home\n2.finale\n3.book\n")  
#x返回字符串类型"1"  "2"  "3"  不是 1 2 3   
#此点导致调了一下午 切记
    print('您的选择为：',x)
    if (x == '1'):   #
        sort_page1()
    elif (x == '2'):
        sort_page2()
    elif (x == '3'):
        sort_page3()
a()