python的高级特性

生成式

列表生成式

列表生成式就是一个用来生成列表的特定语法形式的表达式。是Python提供的一种生成列表的简洁形式, 可快速生成一个新的list。

题目：生成100个验证码，需要字母组成

import string
import random
codes = []
for count in range(100):
    code = "".join(random.sample(string.ascii_letters,4))
    codes.append(code)
print(codes)

用列表生成式方式为：

codes = ["".join(random.sample(string.ascii_letters,4)) for i in range(100)]
print(codes)

结果和上面方式一样

找到1-100之间可以被3整除的数字

nums = []
for num in range(1,101):
    if num % 3 ==0:
        nums.append(num)
print(nums)

用列表生成式方式为：

nums = [num for num in range(1,101) if num %3 == 0]
print(nums)

结果和上述方式一样

字典生成式

result = {i: i**2 for i in range(10)}
print(result)

{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

生成器详解

在Python中,一边循环一边计算的机制,称为生成器: Generator。

什么时候需要使用生成器

性能限制需要用到,比如读取一个10G的文件,如果一次性将10G的文件加载到内存处理的话(read方法),内存肯定会溢出;
使用生成器把读写交叉处理进行,比如使用(readline和readlines)就可以再循环读取的同时不断处理,这样就可以节省大量的内存空间！！

那么怎么创建生成器呢

1，列表生成式的改写：

将[]改为（）

nums = (i**2 for i in range(10))
for num in nums:
    print(num)

2.yield关键字

那么怎么将生成器的元素打印出来呢：

可以for循环输出元素。
如果要一个一个打印出来,可以通过next()函数获得生成器的下一个返回值。

def login():
    print('step 1')
    yield 1
    print('step 2')
    yield 2
    print('step 3')
    yield 3
g = login()
print(next(g))
print(next(g))
print(next(g))

结果如下：

step 1
1
step 2
2
step 3
3

生成式的特点

减少内存占用. 随时生产, 即时消费, 不用堆积在内存当中;
可不终止调用. 写上循环, 即可循环接收数据, 对在循环之前定义的变量, 可重复使用;
生成器的循环, 在 yield 处中断, 没那么占 cpu.

闭包

闭包就是指有权访问另一个函数作用域中的变量的函数。
创建闭包最常见方式，就是在一个函数内部创建另一个函数。

常见形式: 内部函数使用了外部函数的临时变量，且外部函数的返回值是内部函数的引用。
闭包的一个常用场景就是装饰器。

下面的代码充分使用了下面三条原理：仔细分析

函数里面嵌套函数
外部函数的返回值是内部函数的引用
内部函数可以使用外部函数的变量

def timeit(name):
    def wrapper():
        print('wrapper ' + name)
    return wrapper
in_fun = timeit(name='westos') 
in_fun()

wrapper westos

装饰器

指的是工具，而程序中的函数就是具备某一功能的工具，所以装饰器指的是为被装饰器对象添加额外功能的工具/函数。

什么情况下使用装饰器，为什么使用呢？
当我们修改某个项目的一个方法，但不想修改使用方式，此时就可以用装饰器，因为软件的维护应该遵循开放封闭原则，即软件一旦上线运行后，软件的维护对修改源代码是封闭的，对扩展功能指的是开放的。
所以装饰器需要遵循的两大原则 ：
封闭: 对已经实现的功能代码块封闭。 不修改被装饰对象的源代码
开放: 对扩展开发
##装饰器就是在遵循以上原则的前提下为装饰对象添加新功能！！

import time
def timeit(f):   
    def wrapper(x, y):
        start = time.time()
        result = f(x, y)  
        end = time.time()
        print("函数运行的时间: %.8f" %(end-start))
        return  result
    return wrapper

@timeit   #  语法糖， add=timeit(add)
def add(x, y):
    return x + y

result = add(2, 3)
print(result)

结果如下：

函数运行的时间: 0.00000000
5

万能装饰器

装饰器本质上是一个函数，该函数用来处理其他函数，它可以让其他函数在不需要修改代码的前提下增加额外的功能，装饰器的返回值也是一个函数对象。
先在终端安装

pip install requests

import  time
from functools import  wraps
def timeit(f):
    """计时器的装饰器"""
    @wraps(f)  # 保留被装饰函数的属性信息和帮助文档
    def wrapper(*args, **kwargs):
        """wrapper内部函数"""
        start = time.time()
        result = f(*args, **kwargs)
        end = time.time()
        print(f"函数{f.__name__}运行时间为{end-start}秒")
        return  result
    return  wrapper

@timeit
def login():
    """login desc"""
    print('login....')

@timeit
def crawl():
    import  requests
    url = 'https://img-blog.csdnimg.cn/20210624154133103.png'
    content = requests.get(url).content
    with open('/home/kiosk/PycharmProjects/pythonProject/7/Screenshot from 2021-06-24 15-41-04.png', 'wb') as f:
        f.write(content)
        print("下载图片成功")

# print(help(login))
# login()
crawl()

带参数的装饰器

套三层的装饰器;在装饰器外层嵌套一层

多个装饰器

from functools import  wraps
def is_login(f):
    @wraps(f)
    def wrapper(*args, **kwargs):
        print('is_login, 用户是否登录')
        result = f(*args, **kwargs)
        return  result
    return  wrapper

def is_permission(f):
    @wraps(f)
    def wrapper(*args, **kwargs):
        print('is_permission, 用户是否有权限')
        result = f(*args, **kwargs)
        return  result
    return  wrapper

# 规则: 执行装饰器内容是从上到下。 被装饰的顺序是从下到上。
@is_login
@is_permission
def show_hosts():
    print("显示所有的云主机")


show_hosts()

内置高阶函数

1.map函数

result = map(lambda x: x ** 2, [1, 2, 4, 5])
print(list(result))
result = map(lambda x, y: x + y, [1, 2, 3], [4, 5, 6])
print(list(result))

结果为

[1, 4, 16, 25]
[5, 7, 9]

2.reduce函数

from functools import reduce

result = reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])
print(result)

结果为15

3.filter

筛选出所有的偶数，奇数！

result = filter(lambda x: x % 2 == 0, [1, 2, 4, 5, 8])
print(list(result))

result = filter(lambda x: x % 2 != 0, [1, 2, 4, 5, 8])
print(list(result))

4.sorted

result = sorted([1, 29, 2, 3])
print(result)
result = sorted([1, 29, 2, 3], reverse=True)
print(result)
result = sorted([0, 8, 9, 0, 16], key=lambda x:0 if x==0 else 1)
print(result)

结果如下：

[1, 2, 3, 29]
[29, 3, 2, 1]
[0, 0, 8, 9, 16]

这里# reverse: 排序规则，True 降序 ，False 升序（默认）

我们发现这里用到的排序是sorted，之前用的是sort
区别：

1.排序对象不同: sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
2.返回值不同:
(1)list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值
(2)内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作