装饰器迭代器生成器内置函数

Posted 2020-11-02 信、达、雅

、装饰器

1、装饰器：在原有函数的前后增加功能，且不改变原函数的调用方式

例子1（不带参数的装饰器）：计算func1函数的执行时间（计算一个函数的运行时间）

import time
def timer(f):
    def inner():
        starttime=time.time()
        ret=f()
        endtime=time.time()
        print(\'函数耗时：%s\'% (endtime-starttime))
        return ret
    return inner

def func1():
    print(\'begin....\')
    time.sleep(0.1)
    print(\'end....\')
    return 666

func1=timer(func1)
func1()


执行结果：

begin....
end....
函数耗时：0.1000056266784668

 

以上不是写成@timer那种形式，可以改写成：

import time
def timer(f):
    def inner():
        starttime=time.time()
        ret=f()
        endtime=time.time()
        print(\'函数耗时：%s\'% (endtime-starttime))
        return ret
    return inner
@timer
def func1():
    print(\'begin....\')
    time.sleep(0.1)
    print(\'end....\')
    return 666

result=func1()
print(result)
执行结果：

begin....
end....
函数耗时：0.1000056266784668
666

 

例子2（带参数的装饰器）

import time
def timer(f):
    def inner(*args,**kwargs):
        starttime=time.time()
        ret=f(*args,**kwargs)
        endtime=time.time()
        print(\'函数耗时：%s\'% (endtime-starttime))
        return ret
    return inner
@timer
def func1(a,b):
    print(\'begin....\',a)
    time.sleep(0.1)
    print(\'end....\',b)
    return True

result=func1(100,101)
print(result)

执行结果：

begin.... 100
end.... 101
函数耗时：0.1000056266784668
True

 

总结：装饰器的结构如下 

简单来讲，这个就是个外层函数，定义个inner内层函数，return inner函数

# def timmer(f):
#     def inner(*args,**kwargs):
#　　　　　调用函数之前可以加的功能
#         ret = f(*args,**kwargs)
#　　　　　调用函数之后可以加的功能
#         return ret
#     return inner

 

复习装饰器：

装饰器的进阶
    给装饰器加上一个开关  - 从外部传了一个参数到装饰器内
    多个装饰器装饰同一个函数 - 套娃
        每个装饰器都完成一个独立的功能
        功能与功能之间互相分离
        同一个函数需要两个或以上额外的功能
def wrapper1(func):
    def inner(*args,**kwargs):
        \'\'\'执行a代码\'\'\'
        ret = func(*args,**kwargs)
        \'\'\'执行b代码\'\'\'
        return ret
    return inner

def wrapper2(func):
    def inner(*args,**kwargs):
        \'\'\'执行c代码\'\'\'
        ret = func(*args,**kwargs)
        \'\'\'执行d代码\'\'\'
        return ret
    return inner

@wrapper1
@wrapper2
def func():pass

# 执行顺序：a代码 c代码 func d代码 b代码
备注：哪个离函数最近，谁里面的func就是真正的被装饰的函数

2、装饰器的进阶的需求

第一种情况，500个函数，你可以设计你的装饰器 来确认是否生效（考虑给装饰器传参）

举例1：

import time

def outetr(flag):
    def timmer(f):
        def inner(*args,**kwargs):
            if flag==True:
                start_time = time.time()
                ret = f(*args,**kwargs)
                end_time = time.time()
                print(end_time - start_time)
            else:
                ret = f(*args, **kwargs)
            return ret
        return inner
    return timmer

@outetr(True)   # func = timmer(func) 这样话outetr(True)，这个只执行了outetr这个函数，其余的没有执行，返回timmer。就相当于outetr(True)=timmer，这样@timmer再去执行后面的

def func(a,b):
    print(\'begin func\',a)
    time.sleep(0.1)
    print(\'end func\',b)
    return True

ret = func(1,2)   #--> inner()

执行结果：

begin func 1
end func 2
0.10100579261779785

 

如果给装饰器传参是false

import time
def outetr(flag):
    def timmer(f):
        def inner(*args,**kwargs):
            if flag==True:  ##内部函数使用外部函数的变量
                start_time = time.time()
                ret = f(*args,**kwargs)
                end_time = time.time()
                print(end_time - start_time)
            else:
                ret = f(*args, **kwargs)
            return ret
        return inner
    return timmer

@outetr(False)   # func = timmer(func)
def func(a,b):
    print(\'begin func\',a)
    time.sleep(0.1)
    print(\'end func\',b)
    return True

ret = func(1,2)   #--> inner()

执行结果：

begin func 1
end func 2

 

以上可以再改造成：

import time
FLAG = True  ##全部变量，假如有500个函数，底下的都看这个定义的
def outer(flag):
    def timmer(f):
        def inner(*args,**kwargs):
            if flag == True:
                start_time = time.time()
                ret = f(*args,**kwargs)
                end_time = time.time()
                print(end_time - start_time)
            else:
                ret = f(*args, **kwargs)
            return ret
        return inner
    return timmer

@outer(FLAG)   # func = timmer(func)
def func(a,b):
    print(\'begin func\',a)
    time.sleep(0.1)
    print(\'end func\',b)
    return True

func(1,2)

执行结果：

begin func 1
end func 2
0.1000056266784668    #如果FLAG=False的话，就没有这一行的这个结果，其余的还有

第二种情况：两个函数同时装饰同一个函数

def wrapper1(func):  #f传进来了
    def inner1():
        print(\'wrapper1 ,before func\')
        func()  #f
        print(\'wrapper1 ,after func\')
    return inner1

def wrapper2(func):   #innner1传进来了
    def inner2():
        print(\'wrapper2 ,before func\')
        func()  #inner1
        print(\'wrapper2 ,after func\')
    return inner2

@wrapper2   #f=warpper2(f)  此时的f是inner1   f=wrapper2(inner1)=inner2
@wrapper1  #f=wrapper1(f) =inner1
def f():
    print(\'in f\')

f() #这句等于inner2()

执行结果：

wrapper2 ,before func
wrapper1 ,before func
in f
wrapper1 ,after func
wrapper2 ,after func

 执行顺序如下：

 

 例子：（上周day03作业可以用类似方法去做）

# 装饰器 登录 记录日志
import time
login_info = {\'alex\':False}
def login(func):   # manager
    def inner(name):
        if login_info[name] != True:
            user = input(\'user ：\')
            pwd = input(\'pwd ：\')
            if user == \'alex\' and pwd == \'alex3714\':
                login_info[name] = True
        if login_info[name] == True:
            ret = func(name)     # timmer中的inner
            return ret
    return inner

def timmer(f):
    def inner(*args,**kwargs):
        start_time = time.time()
        ret = f(*args,**kwargs)     # 调用被装饰的方法
        end_time = time.time()      #
        print(end_time - start_time)
        return ret
    return inner

@login
@timmer
def index(name):
    print(\'欢迎%s来到博客园首页~\'%name)

@login
@timmer    # manager = login(manager)   #这块应该是先登录再计算时间再计算时间，所以登录写上面，timmer写下面
def manager(name):
    print(\'欢迎%s来到博客园管理页~\'%name)

index(\'alex\')
index(\'alex\')
manager(\'alex\')
manager(\'alex\')

# 计算index 和 manager的执行时间

执行结果：

user ：alex
pwd ：alex3714
欢迎alex来到博客园首页~
0.0
欢迎alex来到博客园首页~
0.0
欢迎alex来到博客园管理页~
0.0
欢迎alex来到博客园管理页~
0.0

 总结：整体是先执行login中的inner，再执行timmer中的inner，只要登录之后就不再登录，想去哪儿去哪儿，看执行结果也可以看出

二、迭代器

# 迭代器
# 如何从列表、字典中取值的
    # index索引 ，key
    # for循环
# 凡是可以使用for循环取值的都是可迭代的

# 可迭代协议 ：内部含有__iter__方法的都是可迭代的
# 迭代器协议 ：内部含有__iter__方法和__next__方法的都是迭代器

举例1：

print(dir([1,2,3]))
lst_iter = [1,2,3].__iter__()   #lst_iter这个是迭代器，迭代器只记得当前值和下一个值

print(lst_iter.__next__())
print(lst_iter.__next__())
print(lst_iter.__next__())

执行结果：

[\'__add__\', \'__class__\', \'__contains__\', \'__delattr__\', \'__delitem__\', \'__dir__\', \'__doc__\', \'__eq__\', \'__format__\', \'__ge__\', \'__getattribute__\', \'__getitem__\', \'__gt__\', \'__hash__\', \'__iadd__\', \'__imul__\', \'__init__\', \'__init_subclass__\', \'__iter__\', \'__le__\', \'__len__\', \'__lt__\', \'__mul__\', \'__ne__\', \'__new__\', \'__reduce__\', \'__reduce_ex__\', \'__repr__\', \'__reversed__\', \'__rmul__\', \'__setattr__\', \'__setitem__\', \'__sizeof__\', \'__str__\', \'__subclasshook__\', \'append\', \'clear\', \'copy\', \'count\', \'extend\', \'index\', \'insert\', \'pop\', \'remove\', \'reverse\', \'sort\']
1
2
3

调用完iter方法之后，是迭代器

print(dir([1,2,3].__iter__()))  有next方法和iter方法，所以说被iter之后的这个是迭代器

[\'__class__\', \'__delattr__\', \'__dir__\', \'__doc__\', \'__eq__\', \'__format__\', \'__ge__\', \'__getattribute__\', \'__gt__\', \'__hash__\', \'__init__\', \'__init_subclass__\', \'__iter__\', \'__le__\', \'__length_hint__\', \'__lt__\', \'__ne__\', \'__new__\', \'__next__\', \'__reduce__\', \'__reduce_ex__\', \'__repr__\', \'__setattr__\', \'__setstate__\', \'__sizeof__\', \'__str__\', \'__subclasshook__\']

 举例2：

for i in [1,2,3]:   #  [1,2,3].__iter__()   [1,2,3]这个本身不是迭代器，只是可迭代的，但是for循环之后，会在内部调用[1,2,3].__iter__()，调用iter方法之后，转变成迭代器，然后
　　

　　print(i)　　　　　　　　　　　　　　　　　　　　　　每一次循环就像是调用next方法赋值给i，然后再输出

举例3：

l = [1,2,3]
lst_iter = iter(l)   # l.__iter__()
while True:
    try:
        print(next(lst_iter)) # lst_iter.__next__()
    except StopIteration:
        break

执行结果：
1
2
3

总结：

# 什么是可迭代的
# 什么是迭代器     迭代器 = iter(可迭代的)，自带一个__next__方法
# 可迭代 最大的优势 节省内存

from collections import Iterable,Iterator
print(range(100000000))
print(isinstance(range(100000000),Iterable))  #判断是不是可迭代的
print(isinstance(range(100000000),Iterator))　#判断是不是迭代器

执行结果：

range(0, 100000000)
True
False

 

# py2 range 不管range多少 会生成一个列表 这个列表将用来存储所有的值
# py3 range 不管range多少 都不会实际的生成任何一个值
# 迭代器的优势:
#     节省内存
#     取一个值就能进行接下来的计算 ，而不需要等到所有的值都计算出来才开始接下来的运算 —— 快
# 迭代器的特性:惰性运算（你找迭代器要值的时候才会生成值）

以下都是可迭代的：

# f = open()
# for line in f:

# 列表 字典 元组 字符串 集合 range 文件句柄 enumerate(给元素加序号)

三、生成器

# 生成器  Generator
# 自己写的迭代器 就是一个生成器
# 两种自己写生成器(迭代器)的机制：生成器函数 生成器表达式
举例1：

def func1():
    print(\'***\')
    yield 1
    print(\'%%%\')
    yield 2

m=func1()
print(\'--\',next(m))

执行结果：

***
-- 1

举例2：

def func1():
    print(\'***\')
    yield 1
    print(\'%%%\')
    yield 2

m=func1()  #这块调用生成器函数，不会触发代码的执行，返回一个生成器
print(\'--\',next(m))
print(\'--\',next(m))

执行结果：

***
-- 1
%%%
-- 2

# 生成器函数的调用不会触发代码的执行，而是会返回一个生成器(迭代器)
# 想要生成器函数执行，需要用next

举例3：

def cloth_g(num):
    for i in range(num):
        yield \'cloth%s\'%i


g = cloth_g(1000)
print(next(g))
print(next(g))
print(next(g))

执行结果：

cloth0
cloth1
cloth2

举例4：

# 使用生成器监听文件输入的例子
import time
def listen_file():
    with open(\'userinfo\') as f:
        while True:
            line = f.readline()
            if line.strip():
                yield line.strip()
            time.sleep(0.1)

g = listen_file()
for line in g:
    print(line)

执行结果：

ahjskhfklsjdahf
asjkhfdjlhflk
ajskhjkldfh
2387497
wlhql jewo91804
sssdkajlhgd

 执行顺序：

 

总结：这个可以实现边往文件里写，写完保存，会自动输出到控制台中

 

# send关键字
def func():
    print(11111)
    ret1 = yield 1  #这块是接收参数，可以直接写yield 1，这样就是不接收参数，不影响send发送参数
    print(22222,\'ret1 :\',ret1)
    ret2 = yield 2
    print(33333,\'ret2 :\',ret2)
    yield 3

g = func()
ret = next(g)
print(ret)
print(g.send(\'alex\'))  # 在执行next的过程中 传递一个参数 给生成器函数的内部  send相当于调用了个next方法
print(g.send(\'金老板\'))

# 向生成器中传递值 有一个激活的过程 第一次必须要用next触发这个生成器（也就是第一次next的时候不能用send）
 执行结果：

11111
1
22222 ret1 : alex
2
33333 ret2 : 金老板
3

执行顺序：

 

 send举例1：

# 例子
# 计算移动平均值
# 12 13 15 18
# 月度 的 天平均收入
def average():
    sum_money = 0
    day = 0
    avg = 0
    while True:
        money = yield avg
        sum_money += money
        day += 1
        avg = sum_money/day

g = average()
next(g)
print(g.send(200))   
print(g.send(300))
print(g.send(600))
执行结果：

200.0
250.0
366.666666666666

执行顺序：

 

#预激生成器

# 预激生成器
def init(func):
    def inner(*args,**kwargs):
        ret = func(*args,**kwargs)
        next(ret)  # 预激活
        return ret
    return inner

@init
def average():
    sum_money = 0
    day = 0
    avg = 0
    while True:
        money = yield avg
        sum_money += money
        day += 1
        avg = sum_money/day

g = average()
print(g.send(200))
print(g.send(300))
print(g.send(600))

执行结果：

200.0
250.0
366.6666666666667

 

# yield from
def generator_func():
    yield from range(5)   #相当于for循环
    yield from \'hello\'
    # for i in range(5):
    #     yield i
    # for j in \'hello\':
    #     yield j

g = generator_func()
for i in generator_func():
    print(i)

执行结果：

0
1
2
3
4
h
e
l
l
o

 

总结：
# 如何从生成器中取值
# 第一种 ：next  随时都可以停止 最后一次会报错
# print(next(g))
# print(next(g))
结果是：
0
1
# 第二种 ：for循环 从头到尾遍历一次 不遇到break、return不会停止
# for i in g:
#     print(i)
结果是g中每个元素输出出来了，一竖列
# 第三种 ：使用list tuple 数据类型的强转  会把所有的数据都加载到内存里 非常的浪费内存
# print(g)
# print(list(g))  相当于强制把g中的每个元素取出来生成一个列表

执行结果：

<generator object generator_func at 0x01E654E0>
[0, 1, 2, 3, 4, \'h\', \'e\', \'l\', \'l\', \'o\']

# 生成器函数 是我们python程序员实现迭代器的一种手段
# 主要特征是 在函数中 含有yield
# 调用一个生成器函数 不会执行这个函数中的代码 只是会获得一个生成器（迭代器）
# 只有从生成器中取值的时候，才会执行函数内部的代码，且每获取一个数据才执行得到这个数据的代码
# 获取数据的方式包括 next send 循环 数据类型的强制转化
# yield返回值的简便方法，如果本身就是循环一个可迭代的，且要把可迭代数据中的每一个元素都返回 可以用yield from
# 使用send的时候，在生成器创造出来之后需要进行预激，这一步可以使用装饰器完成
# 生成器的特点 ： 节省内存 惰性运算
# 生成器用来解决 内存问题 和程序功能之间的解耦

# 列表推倒式

举例1：
new_lst = []
for i in range(10):
    new_lst.append(i**2)
print(new_lst)
执行结果：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
上面的可以用一句话写：

print([i**2 for i in range(10)]) #这个就是列表推导式
执行结果：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

举例2：求0到9对2取余

print([i%2 for i in range(10)])
执行结果：[0, 1, 0, 1, 0, 1, 0, 1, 0, 1]

举例3：求l列表中的所有奇数

l = [1,2,3,-5,6,20,-7]
print([num for num in l if num%2 == 1])
执行结果：[1, 3, -5, -7]

举例4：

# 30以内所有能被3整除的数
print([num for num in range(30) if num %3 ==0])

执行结果：[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

举例5：

# 30以内所有能被3整除的数的平方
print([num**2 for num in range(30) if num %3 ==0])
执行结果：[0, 9, 36, 81, 144, 225, 324, 441, 576, 729]

举例6：

# 找到嵌套列表中名字含有两个‘e’的所有名字
names = [[\'Tom\', \'Billy\', \'Jefferson\', \'Andrew\', \'Wesley\', \'Steven\', \'Joe\'],
         [\'Alice\', \'Jill\', \'Ana\', \'Wendy\', \'Jennifer\', \'Sherry\', \'Eva\']]

print([name for name_lst in names for name in name_lst if name.count(\'e\') == 2])

执行结果：[\'Jefferson\', \'Wesley\', \'Steven\', \'Jennifer\']

# 生成器表达式
l = [i for i in range(30) if i%3 ==0]   # 列表推倒式 排序的时候
g = (i for i in range(30) if i%3 ==0)   # 生成器表达式 庞大数据量的时候 使用生成器表达式
print(l)
print(g)
for i in g:print(i)
执行结果：

[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]
<generator object <genexpr> at 0x01E55420>
0
3
6
9
12
15
18
21
24
27

 

举例1：

def demo():
    for i in range(4):
        yield i

g=demo()

g1=(i for i in g)  #g1这个是生成器表达式，也没有取值，只是拿到个生成器的内存地址
g2=(i for i in g1)  #这块也没有取值

print(list(g1))   #list强转  真正干活取值的是在这步开始的
print(list(g2))　 #强转

执行结果：

[0, 1, 2, 3]
[]

执行顺序：

 

举例2：这个比较难理解

def add(n,i):
    return n+i
#
def test():
    for i in range(4):
        yield i

g=test()
for n in [1,3,10]:
    g=(add(n,i) for i in g)

print(list(g))

执行结果：[30, 31, 32, 33]

总结：

# 一个生成器 只能取一次
# 生成器在不找它要值的时候始终不执行
# 当他执行的时候，要以执行时候的所有变量值为准

四、内置函数（min max sorted filter map 面试明星知识点）

# print
# len
# max min
# dir

举例：

def func():
    a = 1
    b = 2
    print(locals())
    print(globals())

# 全局命名空间中的名字
func()

执行结果：

{\'b\': 2, \'a\': 1}
{\'__name__\': \'__main__\', \'__doc__\': None, \'__package__\': None, \'__loader__\': <_frozen_importlib_external.SourceFileLoader object at 0x0052C410>, \'__spec__\': None, \'__annotations__\': {}, \'__builtins__\': <module \'builtins\' (built-in)>, \'__file__\': \'H:/MyProject/ke删除.py\', \'__cached__\': None, \'func\': <function func at 0x003FB660>}

 

print(locals())   # 本地的命名空间
print(globals())  # 全局的命名空间

执行结果：

{\'__name__\': \'__main__\', \'__doc__\': None, \'__package__\': None, \'__loader__\': <_frozen_importlib_external.SourceFileLoader object at 0x0041C410>, \'__spec__\': None, \'__annotations__\': {}, \'__builtins__\': <module \'builtins\' (built-in)>, \'__file__\': \'H:/MyProject/ke删除.py\', \'__cached__\': None, \'func\': <function func at 0x003DB660>}
{\'__name__\': \'__main__\', \'__doc__\': None, \'__package__\': None, \'__loader__\': <_frozen_importlib_external.SourceFileLoader object at 0x0041C410>, \'__spec__\': None, \'__annotations__\': {}, \'__builtins__\': <module \'builtins\' (built-in)>, \'__file__\': \'H:/MyProject/ke删除.py\', \'__cached__\': None, \'func\': <function func at 0x003DB660>}

举例2:99乘法表

# 99乘法表
for i in range(1,10):
    for j in  range(1,i+1):
        print(\'%s * %s = %2s\'%(i,j,i*j),end=\' \')
    print()

举例3：

print(1,2,3,4,5,sep=\';\',end=\'  \')
print(1,2,3,4,5,sep=\';\',end=\'\')
执行结果：
1;2;3;4;5  1;2;3;4;5

#举例3：打印进度条（\\r 默认表示将输出的内容返回到第一个指针，这样的话，后面的内容会覆盖前面的内容）

import time
for i in range(0,101,2):  #0,2,4,6,8
     time.sleep(0.1)
     char_num = i//2      #打印多少个\'*\'     4
     if i == 100:
         per_str = \'\\r%s%% : %s\\n\' % (i, \'*\' * char_num)
     else:
        per_str =  \'\\r%s%% : %s\'%(i,\'*\'*char_num)
     print(per_str,end=\'\',flush=True)   # 0.01  flush表示即时的意思

print()    #写文件

执行结果：
100% : **************************************************

# python 能直接操作文件 —————— 需要发起系统调用 才能操作文件

举例4：hash

print(hash(\'1291748917\'))

#对可hash的数据类型进行hash之后会得到一个数字
# 在一次程序的执行过程中 对相同的可哈希变量 哈希之后的结果永远相同的
# 在一次程序的执行过程中 对不相同的可哈希变量 哈希之后的结果几乎总是不相同的
# hash 字典底层的存储 和set 集合的去重机制

举例5：# callable 可调用

def func():pass
a = 1
print(callable(func))
print(callable(a))
执行结果：

True
False

举例6：查看一个变量所拥有的所有名字

print(dir(\'1\')) # 查看一个变量所拥有的所有名字
执行结果：
[\'__add__\', \'__class__\', \'__contains__\', \'__delattr__\', \'__dir__\', \'__doc__\', \'__eq__\', \'__format__\', \'__ge__\', \'__getattribute__\', \'__getitem__\', \'__getnewargs__\', \'__gt__\', \'__hash__\', \'__init__\', \'__init_subclass__\', \'__iter__\', \'__le__\', \'__len__\', \'__lt__\', \'__mod__\', \'__mul__\', \'__ne__\', \'__new__\', \'__reduce__\', \'__reduce_ex__\', \'__repr__\', \'__rmod__\', \'__rmul__\', \'__setattr__\', \'__sizeof__\', \'__str__\', \'__subclasshook__\', \'capitalize\', \'casefold\', \'center\', \'count\', \'encode\', \'endswith\', \'expandtabs\', \'find\', \'format\', \'format_map\', \'index\', \'isalnum\', \'isalpha\', \'isdecimal\', \'isdigit\', \'isidentifier\', \'islower\', \'isnumeric\', \'isprintable\', \'isspace\', \'istitle\', \'isupper\', \'join\', \'ljust\', \'lower\', \'lstrip\', \'maketrans\', \'partition\', \'replace\', \'rfind\', \'rindex\', \'rjust\', \'rpartition\', \'rsplit\', \'rstrip\', \'split\', \'splitlines\', \'startswith\', \'strip\', \'swapcase\', \'title\', \'translate\', \'upper\', \'zfill\']

举例7：

print(bin(10))
print(oct(10))
print(hex(10))  # 0123456789abcdef
执行结果：

0b1010
0o12
0xa

 

举例8：取绝对值

print(abs(4))
print(abs(-4))
执行结果：

4
4

举例9：商余函数，返回一个元组

print(divmod(10,2))  # 商余函数
print(divmod(7,3))  # 商余函数
print(divmod(9,7))  # 商余函数
执行结果：

(5, 0)
(2, 1)
(1, 2)

举例10、round()

print(round(3.1415926,4)) # 默认取整，小数精确 会四舍五入
执行结果：3.1416

举例11、

print(pow(2,3,5))  # 相当于(2**3)%5
print(pow(3,2,2))
执行结果：
3
1
举例12、sum

print(sum([1,2,3,4,5]))
print(sum([1,2,3,4,5],0))   #0代表起始值
print(sum([1,2,3,4,5],20))  #20代表起始值
print(sum(range(1,6)))

执行结果：

15
15
35
15

举例13、min

print(min([1,2,3,4,5]))
print(min(1,2,3,4))
print(min(1,-2,3,-4))
print(min(1,-2,3,-4,key=abs))
执行结果：

1
1
-4
1

 

def func(num):
    return num%2   #对2区域之后，是0,1,0，那么最小的0对应的就是-2
print(min(-2,3,-4,key=func))
执行结果：-2

举例14、reverse和reversed

ret = [1,2,3,4,5]
ret.reverse()
print(ret)
执行结果：[5, 4, 3, 2, 1]

ret = [1,2,3,4,5]

# ret.reverse()  直接改变原来的值
# print(ret)

ret1 = reversed(ret)
ret2 = reversed((1,2,3,4,5))
print(ret)
print(list(ret1))  #没改变原来的值，只是赋值给了新的
print(list(ret2))  #没改变原来的值，只是赋值给了新的

执行结果：

[1, 2, 3, 4, 5]
[5, 4, 3, 2, 1]
[5, 4, 3, 2, 1]

举例15、format

print(format(\'test\', \'<20\'))
print(format(\'test\', \'>20\'))
print(format(\'test\', \'^20\'))
执行结果：

test
　　　　　　  test
　　　　test

 

举例16、

print(ord(\'a\'))    # 小写的a-z 97+26  A-Z 65+26
print(chr(97))
执行结果：
97
a

举例17、

print(1)
print(\'1\')
print(repr(1))
print(repr(\'1\'))
执行结果：

1
1
1
\'1\'

举例18、enumerate

l = [\'苹果\',\'香蕉\']
ret = enumerate(l,1)   # 枚举  接收两个参数：一个容器类型，一个序号起始值   返回值：可迭代的
print(ret)
for num,item in enumerate(l,1):
    print(num,item)

执行结果：

<enumerate object at 0x006C8418>
1 苹果
2 香蕉

举例19、all  （0为False、空字符串为false，None为false，all的话有一个为false为false）

print(all([1,2,3,4,5]))
print(all([0,1,2,3,4,5]))
print(all([\'a\',1,2,3,4,5]))
print(all([\'\',1,2,3,4,5]))
print(any([0,None,False]))

print(all([None]))

print(any([0,None,True]))  #任何一个为true为true

执行结果：

True
False
True
False
False

False

True

举例20、拉链方法（以最少的为准）

ret = zip([1,2,3,4,5],(\'a\',\'b\',\'c\',\'d\'),(4,5))   #拉链方法
print(ret)
for i in ret:
    print(i)
执行结果：

<zip object at 0x007684B8>
(1, \'a\', 4)
(2, \'b\', 5)

 

举例21：filter(过滤)

lst =  [1, 4, 6, 7, 9, 12, 17]
def func(num):
    if num % 2 == 0:return True
filter(func,lst)
for i in filter(func,lst):
    print(i)

执行结果：

4
6
12

# g = (i for i in lst if i%2 == 0)  上面的相当于这句
for i in g:
　　print(i)


找到list中非空的字符串

l = [\'test\', None, \'\', \'str\', \'  \', \'END\']
def func(item):
    if item and item.strip():return True
for i in filter(func,l):
    print(i)

执行结果：

test
str
END

举例22：map

#[i**2 for i in range(10)]
def func(num):
    return num ** 2
for i in map(func,range(10)):print(i)
执行结果：

0
1
4
9
16
25
36
49
64
81

举例23：排序功能sort（改变原来的）、sorted（不改变原来的，生成新的）

# 排序功能
l = [1,-4,-2,3,-5,6,5]
l.sort(key=abs)  
print(l)
l = [1,-4,-2,3,-5,6,5]
new_l = sorted(l,key=abs,reverse=True)
print(new_l)

执行结果：

[1, -2, 3, -4, -5, 5, 6]
[6, -5, 5, -4, 3, -2, 1]

 

l = [[1,2],[3,4,5,6],(7,),\'123\']
print(sorted(l,key=len))
执行结果：[(7,), [1, 2], \'123\', [3, 4, 5, 6]]

举例24：# eval()
文档里面给出来的功能解释是：将字符串string对象转化为有效的表达式参与求值运算返回计算结果

eval(\'print(123)\')
exec(\'print(123)\')
print(eval(\'1+2-3*20/(2+3)\'))
print(exec(\'1+2-3*20/(2+3)\'))
执行结果：

123
123
-9.0
None

总结：

# 内置函数
# 标红的如果不会
# 标黄的 是能够节省你的代码 面试会用
# min max sorted filter map 面试明星知识点
# 你经常不见 且没被点名说重点的 就不用特别了解了

五、匿名函数
1、lambda表达式

# def add(a,b):
#     return a+b
add=lambda a,b : a+b   这个就相当于上面的def的函数，这个就是匿名函数
print(add(1,2))
执行结果：3

2、求10以内的数的平方的几种方法：

方法一、列表推导式
result=[i**2 for i in range(10)]

print(result)
执行结果：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

方法二：生成器表达式

result=(i**2 for i in range(10))
for i in result:
    print(i)
执行结果：

0
1
4
9
16
25
36
49
64
81

 

方法三、map内置函数

def func(num):
    return num ** 2
for i in map(func,range(10)):print(i)
执行结果同方法二样式

方法四、map函数

for i in map(lambda num:num**2,range(10)):print(i)

3、

def func(num):
    return num%2
print(min(-2,3,-4,key=func))
执行结果：-2

上面的可以写成：
print(min(-2,3,-4,key=lambda  num: num%2))

执行结果：-2

4、lamdba表达式

d = lambda p:p*2
t = lambda p:p*3
x = 2
x = d(x)   # x = 4
x = t(x)   # x = 12
x = d(x)
print(x)
执行结果：24
4、练习题：（练习1&练习2）

# 练习1：现有两元组((\'a\'),(\'b\')),((\'c\'),(\'d\')),请使用python中匿名函数生成列表[{\'a\':\'c\'},{\'b\':\'d\'}]
方法一、

def func(t):
    return {t[0]:t[1]}
ret = map(func,zip(((\'a\'),(\'b\')),((\'c\'),(\'d\'))))
print(list(ret))
执行结果：[{\'a\': \'c\'}, {\'b\': \'d\'}]

方法二：

ret = map(lambda t:{t[0]:t[1]},zip(((\'a\'),(\'b\')),((\'c\'),(\'d\'))))
print(list(ret))
执行结果：[{\'a\': \'c\'}, {\'b\': \'d\'}]

#练习2：

# 3.以下代码的输出是什么？请给出答案并解释。

def multipliers():
    return [lambda x:i*x for i in range(4)]
print([m(2) for m in multipliers()])
执行结果：

[6, 6, 6, 6]

# def multipliers():
#     lst = []
#     i = 0
#     lst.append(lambda x:i*x)
#     i = 1
#     lst.append(lambda x:i*x)
#     i = 2
#     lst.append(lambda x:i*x)
#     i = 3
#     lst.append(lambda x:i*x)
#     # lst = [lambda x:3*2,lambda x:i*x,lambda x:i*x,lambda x:i*x]
#     return lst
# print([m(2) for m in multipliers()])


改造后：

def multipliers():
    return (lambda x:i*x for i in range(4))
g = (lambda x:i*x for i in range(4))
print([m(2) for m in g])
执行结果：[0, 2, 4, 6]

# 请修改multipliers的定义来产生期望的结果。
六、递归（递归最大深度是997或者998）

# def func():
#     print(1)
#     func()
#
# func()    # 997 /998

# import sys
# def foo(n):
#     print(n)
#     n += 1
#     foo(n)
# foo(1)

# 6!
# print(6*5*4*3*2*1)  #720
def fn(n):
    if n == 1:return 1
    return n*fn(n-1)
print(fn(6))

执行结果：720



# 递归 就是自己调用自己
# 递归需要有一个停止的条件
# def fn(6):
#     if 6 == 1:return 1
#     return 6*fn(5)
# print(fn(6))
#
# def fn(5):
#     return 5*fn(4)
#
# def fn(4):
#     return 4*fn(3)
#
# def fn(3):
#     return 3*fn(2)
#
# def fn(2):
#     return 2*fn(1)
#
# def fn(1):
#     return 1

复习：

一、生成器和迭代器
迭代器 : iter next
可以被for循环 节省内存空间 它没有所谓的索引取值的概念 当前的值和下一个值- 公式
生成器和迭代器本质上是一样的
    yield函数
        执行生成器函数 会得到一个生成器 不会执行这个函数中的代码
        有几个yield,就能从中取出多少个值
    生成器表达式
        生成器表达式也会返回一个生成器 也不会直接被执行
        for循环里有几个符合条件的值生成器就返回多少值
    每一个生成器都会从头开始取值,当取到最后的时候,生成器中就没有值了
        一个生成器只能用一次

def fff():
    for i in range(10):
        yield i
g2 = (i**i for i in range(20))
g = fff()
print(next(g))
print(next(g))
print(next(g))

执行结果：

0
1
2

 

def fff():
    for i in range(10):
        yield i
g2 = (i**i for i in range(20))
g = fff()
# print(next(g))
# print(next(g))
# print(next(g))

print(next(fff()))
print(next(fff()))
print(next(fff()))
执行结果：
0
0
0

def fff():
    for i in range(10):
        yield i
g2 = (i**i for i in range(20))
g = fff()
# print(next(g))
# print(next(g))
# print(next(g))

# print(next(fff()))
# print(next(fff()))
# print(next(fff()))
for i in fff():
    print(i)

执行结果：

0
1
2
3
4
5
6
7
8
9

# 内置函数和匿名函数
# map filter sorted max min zip（重点）
def func(n):
    if n%2 == 0:
        return True
ret = filter(func,range(20))
# ret = filter(lambda n: True if n%2 == 0 else False ,range(20))
# ret = filter(lambda n: n%2 == 0 ,range(20))
print(list(ret))
执行结果：[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

def func(n):
    if n%2 == 0:
        return True
# ret = filter(func,range(20))
ret = filter(lambda n: True if n%2 == 0 else False ,range(20))
# ret = filter(lambda n: n%2 == 0 ,range(20))
print(list(ret))
执行结果：[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

def func(n):
    if n%2 == 0:
        return True
# ret = filter(func,range(20))
# ret = filter(lambda n: True if n%2 == 0 else False ,range(20))
ret = filter(lambda n: n%2 == 0 ,range(20))
print(list(ret))
执行结果：[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]