(4)P_PY(草稿)

目录:

1、装饰器

2、列表生成式

3、生成器

4、斐波那契额

4、迭代器

5、json & pickle 模块

 

 

一、装饰器:

装饰器:
定义:本质是函数,(功能:装饰其他函数)就是为其他函数添加附加功能
原则:1、不能修改被装饰的函数的源代码
2、不能改变被装饰的函数的调用方式

实现装饰器知识储备:
1、函数即“变量
2、高阶函数
a、把一个函数名当作实参传给另外一个函数(在不修改被装饰函数源代码的情况下为其添加功能)
b、返回值中包含函数名(不修改函数的调用方式)
3、嵌套函数

高阶函数 + 嵌套函数 ==》 装饰器


test:
 def foo():
     print('in the foo')
     bar()
 foo()
cale = lambda x:x*3    #匿名函数  直接赋值给变量   没有函数名
cale(3)                # 调用

 

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

foo()                          #肯定会报错,因为在定义之前bar()函数还未定义
def bar():
    print('in the bar')
'''

 

'''
#定义一个高阶函数
import time
def bar():
    time.sleep(3)
    print('in the bar')

def test1(func):
    start_time = time.time()
    func()
    stop_time = time.time()
    print('the func run time is %s' %(stop_time - start_time))

test1(bar)         #在不改变bar的情况下 添加了新的功能,但是bar的调用方式改变了
'''

 

'''
import time
def bar():
    time.sleep(3)
    print('in the bar')

def test1(func):
    print(func)
    return func

#print(test1(bar))
bar = test1(bar)
bar()        # run bar
'''

 

'''
#嵌套函数
def foo():
    print('in the fooo')
    def bar():           #相当与定义了一个bar的局部变量,只能在函数内部调用
        print('in the bar')
    bar()   #只能在函数内部调用
foo()
'''

 

'''
#初级
#定义装饰器
import time
def timer(func):     #timer(test1)  就是func=test1   #嵌套
    def deco():
        start_time = time.time()
        func()            # 运行test1()
        stop_time = time.time()
        print('the func run time is %s' %(stop_time - start_time))
    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 = timer(test1)   #当不希望出现这个时  用上面的@timer
test1()           # ------>deco
test2()
'''

 

'''
#当调用的函数有参数时
#大部分环境使用如下方式
import time
def timer(func):     #timer(test1)  func=test1   #嵌套
    def deco(*args,**kwargs):                            #接受多个参数
        start_time = time.time()
        func(*args,**kwargs)            # 运行test1()
        stop_time = time.time()
        print('the func run time is %s' %(stop_time - start_time))
    return deco   #高阶函数


@timer      # 就相当于 test1 = timer(test1)
def test1():
    time.sleep(2)
    print('in the test1')

@timer
def test2(name,age):
    time.sleep(2)
    print('in the test2')

#test1 = timer(test1)   #当不希望出现这个时
test1()           # ------>deco
test2('laiang',18)
'''

 为多个函数添加认证功能:

import time
user,passwd = 'laiand','abc123'
def auth(func):
    def wrapper(*args,**kwargs):
        username = input("Username:").strip()   #去掉左右空格
        password = input("Password:").strip()
        if user == username and passwd == password:
            print('\033[35;1mUser has passwd authentication\033[0m')
            func(*args,**kwargs)
        else:
            exit('033[35;1mInvalid username or password\033[0m')
    return wrapper

@auth
def index():
    print('welcom to index page')

@auth
def home():
    print('welcom to index home')

@auth
def bbs():
    print('welcom to index bbs')

index()
home()
bbs()

 

二、列表生成式

现有列表a = [0,11,22,33,44,55,66,77,88,99,110],把列表里的每个值加1,如何操作:

方式一:

a = [0,11,22,33,44,55,66,77,88,99,110]
b = []             #定义一个空列表
for i in a:        #循环a 里的每一个元素
    b.append(i+1)  #把每一个元素加1扩展到b 里面
a = b print(a)

 方式二:

在原列表基础上修改

a = [0,11,22,33,44,55,66,77,88,99,110]
for index,i in enumerate(a):
    a[index] += 1
print(a)

 方式三:

a = [0,11,22,33,44,55,66,77,88,99,110]
a = map(lambda x:x+1,a)
for i in a:print(i)

 

列表生成式:   作用就是     使代码更简洁

a = [i+1 for i in range(10)]   #循环每一个数 再加一  
print(a)

 

 

三、生成器

当列表包含大量元素时,读取的时候会占用大量内存,造成空间浪费,

所以,如果列表元素可以按照某种算法推算出来,那我们是否可以在循环的过程中不断推算出后续的元素?这样就不必创建完整的list,从而节省大量的空间。

在Python中,这种一边循环一边计算的机制,称为生成器:generator

1、创建一个generator

方法一:

  把一个列表生成式的[]改成(),就创建了一个generator:

>>> a = [x*x for x in range(11)]
>>> a
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>>
>>> b = (x*x for x in range(11))
>>> b
<generator object <genexpr> at 0x7f6d80711870>
>>>

 可以直接打印出list的每一个元素

如果要打印生成器的每一个元素   通过next()函数来实现

>>> b = (x*x for x in range(11))
>>> b
<generator object <genexpr> at 0x7f6d80711870>
>>>
>>> next(b)
0
>>>
>>> next(b)
1
>>> next(b)
4
>>> next(b)
9
>>> next(b)
16
>>> next(b)
25

生成器  只是给你准备了一个生成算法  需要的时候才生成   从而节省内存,只有在调用的时候才会生成相应数据

只记录当前的位置  只有一个__next__()方法  ,在2.x里是next()

 

四、斐波拉契数列

def fib(max):
    n,a,b = 0,0,1
    while n < max:
        print(b)
        a,b = b,a + b
        n = n + 1
    return 'done'
fib(7)

只需要把print(b)改为yield b就可以,把fib函数变成generator

def fib(max):
    n,a,b = 0,0,1
    while n < max:
        #print(b)
        yield b
        a,b = b,a + b
        n = n + 1
    return 'done'
f = fib(7)
print(f)
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())
<generator object fib at 0x000001D052442BA0>
1
1
2
3

 如果一个函数定义中包含yield关键字,那么这个函数就是一个generator,每次调用next()的时候执行,遇到yield语句返回,再次执行时从上次返回的yield语句处继续执行

把函数改成generator后,基本上从来不会用next()来获取下一个返回值,而是直接使用for循环来迭代

for i in fib(9):
print(i)

但是用for循环调用generator时,发现拿不到generator的return语句的返回值。如果想要拿到返回值,必须捕获StopIteration错误,返回值包含在StopIterationvalue中:

g = fib(5)
while True:
    try:
        x=next(g)
        print('g:',x)
    except StopIteration as e:
        print('Generator return value:',e.value)
        break
g: 1
g: 1
g: 2
g: 3
g: 5
Generator return value: done

Process finished with exit code 0

 

五、迭代器

可以直接作用于for循环的数据类型有以下几种:一类是集合数据类型,如listtupledictsetstr等,一类是generator,包括生成器和带yield的generator function。

这些可以直接作用于for循环的对象统称为可迭代对象Iterable。可以使用isinstance()判断一个对象是否是Iterable对象:

 

*可以被next()函数调用并不断返回下一个值的对象称为迭代器:Iterator

 

生成器都是Iterator对象,但listdictstr虽然是Iterable,却不是Iterator

listdictstrIterable变成Iterator可以使用iter()函数:

isinstance(iter([]), Iterator)
isinstance(iter('abc'), Iterator)

小结

凡是可作用于for循环的对象都是Iterable类型;(可迭代类型)

凡是可作用于next()函数的对象都是Iterator类型,(迭代器类型)它们表示一个惰性计算的序列;

集合数据类型如listdictstr等是Iterable但不是Iterator,不过可以通过iter()函数获得一个Iterator对象。

Python的for循环本质上就是通过不断调用next()函数实现的,例如:


六、json & pickle 模块

 

posted @ 2018-03-15 16:47  莱昂嘚  阅读(217)  评论(0编辑  收藏  举报