Python基础

Posted 2020-09-21

?成器

1. 什么是?成器

通过列表?成式，我们可以直接创建?个列表。但是，受到内存限制，列表 容量肯定是有限的。?且，创建?个包含100万个元素的列表，不仅占?很 ?的存储空间，如果我们仅仅需要访问前??个元素，那后?绝?多数元素 占?的空间都??浪费了。所以，如果列表元素可以按照某种算法推算出 来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必 创建完整的list，从?节省?量的空间。在Python中，这种?边循环?边计算 的机制，称为?成器：generator。

2. 创建?成器?法1

要创建?个?成器，有很多种?法。第?种?法很简单，只要把?个列表? 成式的 [ ] 改成 ( )

输入：L=[ x*2 for x in range(5)]
输出：print(L)
结果：[0, 2, 4, 6, 8]


输入：G=(x *2 for x in range(5))
输出：print (G)
结果：<generator object <genexpr> at 0x03490EA0>

创建 L 和 G 的区别仅在于最外层的 [ ] 和 ( ) ， L 是?个列表，? G 是?个 ?成器。我们可以直接打印出L的每?个元素，但我们怎么打印出G的每?个 元素呢？如果要?个?个打印出来，可以通过 next() 函数获得?成器的下? 个返回值：

G=(x *2 for x in range(5))
print(next(G))
print(next(G))
print(next(G))
0
2
4

G=(x *2 for x in range(5))
for i in G:
    print(i)
0
2
4
6
8

?成器保存的是算法，每次调? next(G) ，就计算出 G 的下?个元素的值， 直到计算到最后?个元素，没有更多的元素时，抛出 StopIteration 的异常。 当然，这种不断调? next() 实在是太变态了，正确的?法是使? for 循环， 因为?成器也是可迭代对象。所以，我们创建了?个?成器后，基本上永远 不会调? next() ，?是通过 for 循环来迭代它，并且不需要关? StopIteration 异常。

总结

?成器是这样?个函数，它记住上?次返回时在函数体中的位置。对?成器 函数的第?次（或第 n 次）调?跳转?该函数中间，?上次调?的所有局部 变量都保持不变。
?成器不仅“记住”了它数据状态；?成器还“记住”了它在流控制构造（在命令 式编程中，这种构造不只是数据值）中的位置。
?成器的特点：
1. 节约内存

2. 迭代到下?次的调?时，所使?的参数都是第?次所保留下的，即是 说，在整个所有函数调?的参数都是第?次所调?时保留的，?不是新 创建的

 

迭代器

迭代是访问集合元素的?种?式。迭代器是?个可以记住遍历的位置的对 象。迭代器对象从集合的第?个元素开始访问，直到所有的元素被访问完结 束。迭代器只能往前不会后退。

1. 可迭代对象

以直接作?于 for 循环的数据类型有以下?种：
?类是集合数据类型，如 list 、 tuple 、 dict 、 set 、 str 等；
?类是 generator ，包括?成器和带 yield 的generator function。
这些可以直接作?于 for 循环的对象统称为可迭代对象： Iterable 。

 

2. 判断是否可以迭代

可以使? isinstance() 判断?个对象是否是 Iterable 对象：

 

总结

凡是可作?于 for 循环的对象都是 Iterable 类型；

凡是可作?于 next() 函数的对象都是 Iterator 类型

集合数据类型如 list 、 dict 、 str 等是 Iterable 但不是 Iterator ，不过可 以通过 iter() 函数获得?个 Iterator 对象。

 

装饰器

装饰器是程序开发中经常会?到的?个功能，?好了装饰器，开发效率如? 添翼，所以这也是Python?试中必问的问题，但对于好多初次接触这个知识 的?来讲，这个功能有点绕，?学时直接绕过去了，然后?试问到了就挂 了，因为装饰器是程序开发的基础知识，这个都不会，别跟?家说你会 Python, 看了下?的?章，保证你学会装饰器。

 

初创公司有N个业务部?，1个基础平台部?，基础平台负责提供底层的功 能，如：数据库操作、redis调?、监控API等功能。业务部?使?基础功能 时，只需调?基础平台提供的功能即可。如下：

def    f1():                
    print(‘f1‘)
def    f2():                
    print(‘f2‘)
def    f3():                
    print(‘f3‘)
def    f4():                
    print(‘f4‘)

###############    业务部?A    调?基础平台提供的功能    ###############
f1()
f2() 
f3()
f4()
###############    业务部?B    调?基础平台提供的功能    ###############
f1()
f2()
f3() 
f4()

 

?前公司有条不紊的进?着，但是，以前基础平台的开发?员在写代码时候 没有关注验证相关的问题，

即：基础平台的提供的功能可以被任何?使?。 现在需要对基础平台的所有功能进?重构，为平台提供的所有功能添加验证 机制，即：执?功能前，先进?验证。

??把?作交给 Low B，他是这么做的：

跟每个业务部?交涉，每个业务部???写代码，调?基础平台的功能 之前先验证。诶，这样?来基础平台就不需要做任何修改了。太棒了， 有充?的时间泡妹?...

当天Low B 被开除了…

??把?作交给 Low BB，他是这么做的：

############### 基础平台提供的功能如下 ###############
def f1():
    # 验证1
    # 验证2
    # 验证3
print (‘f1‘)
def f2():
    #    验证1
    # 验证2
    # 验证3
    print (‘f2‘)
def f3():
    # 验证1
    # 验证2
    # 验证3
    print (‘f3‘)
def f4():
    # 验证1
    # 验证2
    # 验证3
    print (‘f4‘)

############### 业务部?不变 ############### ### 业务部?A 调?基础平台提供的功能###

过了?周 Low BB 被开除了…

??把?作交给 Low BBB，他是这么做的：

只对基础平台的代码进?重构，其他业务部??需做任何修改
###############    基础平台提供的功能如下    ###############    
def    check_login():               
　　 #    验证1                
　　 #    验证2                
　　 #    验证3                
　　　　   pass
def f1():
    check_login()
    print(‘f1‘)
def  f2():
    check_login()
    print(‘f2‘)
def f3():
    check_login()
    print(‘f3‘)
def f4():
    check_login()
    print(‘f4‘)

 

??看了下Low BBB 的实现，嘴?漏出了?丝的欣慰的笑，语重??的跟 Low BBB聊了个天：

??说：

写代码要遵循 开放封闭 原则，虽然在这个原则是?的?向对象开发，但是也 适?于函数式编程，简单来说，它规定已经实现的功能代码不允许被修改， 但可以被扩展，即：

封闭：已实现的功能代码块

开放：对扩展开发

如果将开放封闭原则应?在上述需求中，那么就不允许在函数 f1 、f2、f3、 f4的内部进?修改代码，?板就给了Low BBB?个实现?案：

def w1(func):
    def    inner():
    # 验证1
    # 验证2
    # 验证3
    func()
    return inner

@w1
def f1():
    print (‘f1‘)
@w1
def f2():
    print (‘f2‘)
@w1
def f3():
    print (‘f3‘)
@w1
def f4():
    print (‘f4‘)

 

对于上述代码，也是仅仅对基础平台的代码进?修改，就可以实现在其他? 调?函数 f1 f2 f3 f4 之前都进?【验证】操作，并且其他业务部??需做任 何操作。
Low BBB?惊胆战的问了下，这段代码的内部执?原理是什么呢？
??正要??，突然Low BBB的?机掉到地上，恰巧屏保就是Low BBB的? 友照?，???看?紧?抖，喜笑颜开，决定和Low BBB交个好朋友。
详细的开始讲解了：
单独以f1为例：

def    w1(func):                
    def    inner():                                
        #验证1                                
        #验证2                                
        #验证3                                
    func()                
    return    inner
@w1 
def    f1():                
    print(‘f1‘)

python解释器就会从上到下解释代码，步骤如下：
1. def w1(func): ==>将w1函数加载到内存
2. @w1
没错，从表?上看解释器仅仅会解释这两句代码，因为函数在 没有被调?之 前其内部代码不会被执?。

从表?上看解释器着实会执?这两句，但是 @w1这?句代码?却有??章，@函数名是python的?种语法糖。

上例@w1内部会执??下操作：
执?w1函数 
执?w1函数，并将@w1下?的函数作为w1函数的参数，即：@w1 等价于w1(f1)所以，内部就会去执?：
def    inner():
#验证    1
# #验证    2
# #验证    3
    f1()　　　　#func是参数，此时func等于f1
    return inner  #返回的inner，inner代表的是函数，?执?函数,其实就是将原来的f1函数塞进另外?个函数中
w1的返回值
将执?完的w1函数返回值赋值给@w1下?的函数的函数名f1即将w1 的返回值再重新赋值给f1，即：
    新f1    =    def    inner():                                                    
　　#  验证    1                                                
　　# #验证    2                                                
　　# #验证    3                                                
　　原来f1()
　　return    inner
所以，以后业务部?想要执?f1函数时，就会执?新f1函数，在新f1 函数内部先执?验证，再执?原来的f1函数，然后将原来f1 函数的返回 值返回给了业务调?者。

如此?来，即执?了验证的功能，?执?了原来f1函数的内容，并将原f1函 数返回值返回给业务调?着

LowBBB 你明?了吗？要是没明?的话，我晚上去你家帮你解决吧！！！

3. 再议装饰器

#定义函数：完成包裹数据 
def    makeBold(fn):                
    def    wrapped():                                
        return    "<b>"    +    fn()    +    "</b>"                
    return    wrapped
#定义函数：完成包裹数据 
def    makeItalic(fn):                
    def    wrapped():                                
        return    "<i>"    +    fn()    +    "</i>"                
    return    wrapped
@makeBold 
def    test1():                
    return    "hello world-1"
@makeItalic 
def    test2():                
    return    "hello world-2"
@makeBold 
@makeItalic
def    test3():                
    return    "hello world-3"
print(test1())) 
print(test2())) 
print(test3()))
运?结果:
<b>hello world-1</b> 
<i>hello world-2</i> 
<b><i>hello    world-3</i></b>

4. 装饰器(decorator)功能

1. 引??志

2. 函数执?时间统计

3. 执?函数前预备处理

4. 执?函数后清理功能

5. 权限校验等场景

6. 缓存

 

5. 装饰器示例

例1:?参数的函数

from    time import ctime, sleep


def timefun(func):
    def wrappedfunc():
        print ("%s    called    at    %s" % (func.__name__, ctime ()))
        func ()

    return wrappedfunc


@timefun
def foo():
    print ("I    am    foo")


foo ()
sleep (2)
foo ()

上面代码理解装饰器执行行为可理解成
foo    =  timefun(foo)
#foo先作为参数赋值给func后,foo接收指向timefun返回的wrappedfuncfoo()
#调?foo(),即等价调?wrappedfunc() #内部函数wrappedfunc被引?，所以外部函数的func变量(?由变量)并没有释放
#func?保存的是原foo函数对象