week5_notebooke1

Posted 2020-11-10 安东尼漂流记

01 装饰器进阶
02 函数的有效信息
03 可迭代对象、迭代器
04 生成器
列表生成式 生成器表达式
05 内置函数
06 二分查找

01 装饰器进阶
多个装饰器装饰同一个函数：
1、装饰顺序从近到远
先decorate2装饰func，此时decorate2中的f为func函数，返回inner2
然后decorate1装饰func，但是此时的func等于inner2，返回inner1
最后func等于inner1
2、执行顺序由远到近
按照执行顺序，先执行inner1
打印inner1 before
执行inner2，打印inner2 before
执行func，打印execute
执行inner2 after
执行inner1 after
3、前期可以在f()后加注释，以方便理清装饰顺序，然后按照函数嵌套的执行顺序，判断执行顺序
- 示例一：
def func1(f): # f = wraper2
def wraper1():
print(‘before wrapper1‘)
f() # f = wraper2
print(‘after wrapper1‘)

                return wraper1


            def func2(f):  # f = wraper3
                def wraper2():
                    print(‘before wrapper2‘)
                    f() # wraper3
                    print(‘after wrapper2‘)

                return wraper2

            def func3(f): # f = index()
                def wraper3():
                    print(‘before wrapper3‘)
                    f() # index()
                    print(‘after wrapper3‘)
                return wraper3


            # before wrapper1
            # before wrapper2
            # before wrapper3
            # in anthony
            # after wrapper3
            # after wrapper2
            # after wrapper1



            @func1  # func1 = func1(index)
            @func2  # func2 = func2(index)
            @func3  # func3 = func3(index)
            def index():
                print(‘in anthony‘)

            index()

    带参数的装饰器：
        示例一：
            def timeout(flag):
                def func1(f):
                    def wraper1(*args,**kwargs):
                        if flag:
                            f(*args,**kwargs)
                            print(‘in anthony‘)
                        else:
                            f(*args, **kwargs)
                            print(‘out anthony‘)
                    return wraper1
                return func1


            flag =False

            @timeout(flag)

            def index():
                print(‘登录中...‘)
            index()

02 函数的有效信息
- 函数注释：
doc #获取函数有效信息
name #得到参数名
from functools import wraps
wraps(f)
- 开放封闭原则：
- 对扩展开放
- 对修改原内容封闭

03 可迭代对象、迭代器

可迭代对象：str,list,tuple,dict,set,range,文件句柄
    - 该对象中含有__iter__方法的就是可迭代对象，遵循可迭代协议。
判断是否是可迭代对象:
    -- ‘__iter__‘ in dir(对象)
    --  from collections import Iterable
        print(isinstance(‘abc‘,Iterable))

迭代器：
    含义：内部含有__iter__且含有__next__方法的对象就是迭代器，遵循迭代器协议。

    判断是否是迭代器:
    -- from collections import Iterator
        print(isinstance(‘abc‘,Iterator))
    -- ‘__iter__‘ in dir(对象)

    好处：
        - 节省内存
        - 惰性机制
        - 单向执行，不可逆

04 生成器
- 含义：生成器本质就是迭代器，即自定义的迭代器(自定制的迭代器)
- 构成方式：
- 以函数的方式构建
- 生成器表达式
凡是函数中见到yield,即生成器

    示例：
        def func1():
            print(111)
            yield 666
            print(222)
            yield ‘anthony‘
        g_obj = func1() #生成器对象
        print(g_obj.__next__())

- 对应规则：__netxt__和yield必须一一对应
- 关于send和next的区别
      send和next都是对生成器取值
      send会给上一个yield发送一个值
      send不能用在第一次取值
      最后一个yield，不能得到值

05列表生成式 生成器表达式
列表推导式格式：简单、一行搞定
# 遍历模式：[变量(加工后的变量) for 变量 in iterable]
示例：l = [‘python%s期‘ % i for i in range(1,11)]
print(l)
# 筛选模式：
示例：l = [i for i in range(1,31) if i%3==0 ]
print(l)
列表推导式优缺点：
缺点：
- 特别复杂数据无法实现,只能用代码实现
- 不能排除错误

生成器表达式：
        l_obj = ([i for i in range(1,31) if i%3==0 ])
        for i in l_obj:
            print(i)

生成器表达式和列表推导式区别：
    - 列推直观能看出，但是占内存
    - 生成器表达式不易看出，但是节省内存

06 内置函数：python自带内置函数
其他相关：(重点)
- eval：执行字符串类型的代码，并返回最终结果
- exec:执行字符串类型的代码。
- 分割：print(1,2,3,sep=‘*‘)
- end:换行
print(111,end=‘‘)
print(222)

    input:函数接受一个标准输入数据，返回为 string 类型。
    print:打印输出。
    - print:
        with open(‘练习‘,encoding=‘utf-8‘,‘w‘) as f1:
            print(‘wohisshui‘,file=f1)


    - hash:获取一个对象（可哈希对象：int，str，Bool，tuple）的哈希值。
        print(hash(‘anthony‘))
        print(hash(99))
        print(hash(True))
    - id:用于获取对象内存地址
    - help：查看函数或模块详细信息
    - callable：函数用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。
    - dir：检查对象中的所有方法和属性
    - int：print(int())  # 默认为0
           print(int(3.6)) # 取值为3，取整
    float：函数用于将整数和字符串转换为浮点数

数学相关：
    abs：函数返回数字的绝对值。

　　　　divmod：计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。
　　　　round：保留浮点数的小数位数，默认保留整数。
　　　　pow：求xy次幂。（三个参数为xy的结果对z取余）

相关内置函数：

　　　　reversed：将一个序列翻转，并返回此翻转序列的迭代器。
　　　　slice：构造一个切片对象，用于列表的切片。

bytes：用于不同编码之间的转化。将Unicode装换位bytes
ord:输入字符找该字符编码的位置

　　chr:输入位置数字找出其对应的字符
　　ascii:是ascii码中的返回该值，不是就返回/u...

repr:返回一个对象的string形式（原形毕露）。
    # %r  原封不动的写出来
    # name = ‘taibai‘
    # print(‘我叫%r‘%name)

    # repr 原形毕露
    print(repr(‘{"name":"alex"}‘))
    print(‘{"name":"alex"}‘)

sorted：对所有可迭代的对象进行排序操作。
    示例：
        def func(x):return x[1]
        L = [(‘a‘,3),(‘d‘,4),(‘c‘,1),(‘e‘,2)]
        print(sorted(L,key=func))

        L = [(‘a‘, 1), (‘c‘, 3), (‘d‘, 4),(‘b‘, 2), ]
        sorted(L, key=lambda x:x[1])               # 利用key
        [(‘a‘, 1), (‘b‘, 2), (‘c‘, 3), (‘d‘, 4)]
         
         
        students = [(‘john‘, ‘A‘, 15), (‘jane‘, ‘B‘, 12), (‘dave‘, ‘B‘, 10)]
        sorted(students, key=lambda s: s[2])            # 按年龄排序
        [(‘dave‘, ‘B‘, 10), (‘jane‘, ‘B‘, 12), (‘john‘, ‘A‘, 15)]
         
        sorted(students, key=lambda s: s[2], reverse=True)    # 按降序
        [(‘john‘, ‘A‘, 15), (‘jane‘, ‘B‘, 12), (‘dave‘, ‘B‘, 10)]


重要：
    zip：函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。
        示例：
        l1 = [1,2,3,]
        l2 = [‘a‘,‘b‘,‘c‘,5]
        l3 = (‘*‘,‘**‘,(1,2,3))
        for i in zip(l1,l2,l3):
            print(i)
    map:会根据提供的函数对指定序列做映射。
        >>>def square(x) :            # 计算平方数
        ...     return x ** 2
        ... 
        >>> map(square, [1,2,3,4,5])   # 计算列表各个元素的平方
        [1, 4, 9, 16, 25]
        >>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
        [1, 4, 9, 16, 25]

07 匿名函数
示例：
func1 = lambda x,y:x+y
print(func1())

06 二分查找