python合集（8）---------高级特性，异常处理，模块与包-CSDN博客

本文链接：https://blog.csdn.net/m0_55444160/article/details/118223622

1.高级特性

1.1.生成式详解

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

普通的语法格式：[exp for iter_var in iterable]
带过滤功能语法格式: [exp for iter_var in iterable if_exp]
循环嵌套语法格式: [exp for iter_var_A in iterable_A for iter_var_B in iterable_B]

1.2. 生成器与yield的详解

生成器定义：
在Python中,一边循环一边计算的机制,称为生成器:Generator
生成器的用途
性能限制需要用到,比如读取一个10G的文件,如果一次性将10G的文件加载到内存处理的话(read方法),内存肯定会溢出;但使用生成器把读写交叉处理进行,比如使用(readline和readlines)就可以再循环读取的同时不断处理,这样就可以节省大量的内存空间.
生成器的创建

第一种方法: 列表生成式的改写。 []改成()
第二种方法: yield关键字。

打印生成器的元素
通过for循环，依次计算并生成每一个元素。如果要一个一个打印出来,可以通过next()函数获得生成器的下一个返回值。
生成器的特点

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

1.3.生成器，迭代器与可迭代对象

迭代是访问容器元素的一种方式。迭代器是一个可以记住遍历的位置的对象。
迭代器对象从集合的第一个元素开始访问,直到所有的元素被访问完结束。

可迭代对象：可以直接作用于for循环的对象
判断迭代:
一类是集合数据类型,如list， tuple，dict， set，str等;
一类是generator,包括生成器和带yield的generator function。
迭代器:
可以被next()函数调用并不断返回下一个值的对象称为迭代器:Iterator,

生成器都是Iterator对象,但list、dict、str虽然是Iterable,却不是Iterator。
把list、dict、str等Iterale变成Iterator可以使用iter()函数

1.4. 闭包

1.4.1 闭包的定义

- 闭包就是指有权访问另一个函数作用域中的变量的函数。

1.4.2 闭包的创建

最常见方式：就是在一个函数内部创建另一个函数。
常见形式：内部函数使用了外部函数的临时变量，且外部函数的返回值是内部函数的引用

1.4.3闭包的特性

闭包的一个常用场景就是装饰器
闭包也具有提高代码可复用性的作用

1.5 装饰器

定义： 装饰器本质上是一个函数，该函数用来处理其他函数，它可以让其他函数在不需要修改代码的前提下增加额外的功能，装饰器的返回值也是一个函数对象。（解释：我们已经上线了一个项目，我们需要修改某一个方法，但是我们不想修改方法的使用方法，这个时候使用装饰器）
用途： 在不改变源代码的情况下，添加额外功能(例如: 计算运行时间, 记录日志，权限判断)的工具.
而这样的用途是因为软件的维护应该遵循开放封闭原则，即软件一旦上线运行后，软件的维护对修改源代码是封闭的，对扩展功能指的是开放的。

1.5.1 装饰器的实现

遵循两大原则：
封闭: 对已经实现的功能代码块封闭。不修改被装饰对象的源代码
开放: 对扩展开发
装饰器其实就是在遵循以上两个原则的前提下为被装饰对象添加新功能。
装饰器的实现，基于闭包的

import time
def timeit(f):      # f=add
    def wrapper(x, y):
        start = time.time()
        result = f(x, y)   # f实质上是add函数
        end = time.time()
        print("函数运行的时间为: %.4f" %(end-start))
        return  result
    return wrapper
@timeit   # 1. 语法糖， add=timeit(add)
def add(x, y):
    return x + y
result = add(1, 3)
print(result)

万能装饰器的实现：

##万能装饰器模板：
def 装饰器名称(f):
    @wraps(f)  # 保留被装饰函数的属性信息和帮助文档
    def wrapper(*args, **kwargs):
        # 执行函数之前做的事情
        result = f(*args, **kwargs)
        # 执行函数之后做的事情
        return  result
    return  wrapper

含参数的装饰器

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

@timeit(args='minutes')  # timeit()  @desc===> login=desc(login)
def login():
    """login desc"""
    print('login....')

@timeit
def crawl():
    import  requests
    url = 'https://upload.wikimedia.org/wikipedia/commons/thumb/0/0a/Python.svg/1200px-Python.svg.png'
    content = requests.get(url).content
    with open('doc/python.png', 'wb') as f:
        f.write(content)
        print("下载图片成功")

# print(help(login))
# login()
crawl()
原文链接：https://blog.csdn.net/ninimino/article/details/113888288

多装饰器

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

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

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


"""
--: show_hosts()
1). wrapper1()
2). wrapper2()
3). show_hosts()
"""
show_hosts()
原文链接：https://blog.csdn.net/ninimino/article/details/113888288

1.6 内置高阶函数

函数式编程的一个特点就是,允许把函数本身作为参数传入另一个函数,还允许返回一个函数!Python对函数式编程提供部分支持。

1.6.1. map函数

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.6.2 reduce函数

reduce() 函数会对参数序列中元素进行累积

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

1.6.3 filter:

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))

1.6.4 sorted:

sorted(iterable, key=None, reverse=False)
key: 主要是用来进行比较的元素，只有一个参数，
reverse: 排序规则，True 降序 ，False 升序（默认）。

result = sorted([1, 29, 2, 3])   #顺序
print(result)
result = sorted([0, 29, 2, 0], reverse=True)  #倒序
print(result)
result = sorted([0, 8, 9, 0, 16], key=lambda x:0 if x==0 else 1) #将所有的0排在前面
print(result)

2.异常处理

2.1 异常的简单理解

Error（错误）
是系统中的错误，程序员是不能改变的和处理的，如系统崩溃，内存空间不足，方法调用栈溢等。遇到这样的错误，建议让程序终止。
Exception（异常）
表示程序可以处理的异常，可以捕获且可能恢复。遇到这类异常，应该尽可能处理异常，使程序恢复运行，而不应该随意终止异常

常见异常

IndentationError：缩进错误
KeyboardInterrupt： Ctrl+C被按下
UnboundLocalError ：有同名的全局变量
ZeroDivsionError 除0错误eg：print(10/0)
FileNotFoundError 文件不存在
除上述之外还有：AttributeError 、IOError 、ImportError 、IndexError、
SyntaxError、TypeError、ValueError、KeyError、NameErro