python装饰器，迭代，异常

装饰器的联系

DEL = 8
READ = 4
WRITE = 2
EXE = 1
userpermission = 9


def check(x, y):
    print("最外层函数被调用了")

    def handle(fn):
        print("handle函数被调用了")

        def do_ction():
            if x & y != 0:
                fn()

        return do_ction

    return handle


@check(userpermission, READ)
def read():
    print("可以读")


@check(userpermission, DEL)
def _del():
    print("可以删除")


@check(userpermission, WRITE)
def _write():
    print("可以写")


@check(userpermission, EXE)
def exe():
    print("可以运行")

read()
_del()
_write()
exe()   # 装饰器写了必须调用函数才会执行最里层的代码

高级装饰器

def can_play(clock=12):
    print("最外层函数被调用了，clock={}".format(clock))
    def handle_action(fn):
        print("handle_action被调用了")
        def do_action(x,y):
            print(x,y)
            if clock>23:
                print("太晚了，不能玩游戏了")
            else:
                fn(x,y)
                print("可以玩游戏")
        return do_action

    return handle_action


@can_play(22)
# 1.调用can_play函数，并将22传递给clock
# 2.调用handle_actio函数，把play传递给fn
# 3.最后调用play函数其实调用的是do_action
def play(name, game):
    print(name + "正在玩" + game + "游戏")


play("张三", "王者荣耀")

可迭代对象

from collections.abc import Iterable


class Person(object):
    def __init__(self, x):
        self.x = x
        self.count = 0

    def __iter__(self):
        return self  # 只要重写了__iter__方法就是一个可迭代对象

    def __next__(self):
        # 每一次for...in循环都会调用一次
        if self.count <10:
            self.count +=1
            return (self.x)
        else:
            raise StopIteration

p = Person(100)
print(isinstance(p, Iterable))

# for ...in的本质就是调用对象的__iter__方法，获取到这个方法的返回值
# 这个返回值是一个对象，然后再调用这个对象的__next__的方法
for x in p:
    print(x)

使用迭代器生成斐波那契数列

import time


class Function(object):
    def __init__(self,n):
        self.num1, self.num2 = 1, 1
        self.count = 0
        self.n = n

    def __iter__(self):
        return self

    def __next__(self):
        if self.count<self.n:
            self.count+=1
            x = self.num1
            self.num1, self.num2 = self.num2, self.num1 + self.num2
            return x
        else:
            raise StopIteration

f =Function(12)
for k in f:
    print(k)

with关键字

# with open("异常处理.py",'r',encoding='utf') as file:
#     print(file.read())  # 不需要手动关闭文件，with关键字会帮助我们关闭文件

try:
    with open('异常处理.py','r',encoding="utf8") as file:
        print(file.read())
except FileNotFoundError as e:
    print(e+"文件找不到")

# with我们称之为上下文管理器，很多需要手动关闭的连接
# 比如 文件连接，socket连接，数据库的连接，都能使用with关键字关闭连接
# with关键字后面对象，要实现__enter__和__exit__魔法方法

finally的注意事项

# 一个函数最多只有一个return语句返回
def demo(a, b):
    try:
        x = a / b
    except ZeroDivisionError as e:
        print(e)
    else:
        return x
    finally:
        return 'good'  # 如果函数里面有finally，finally里的返回值会覆盖之前的反回值


print(demo(2, 5))  # good

异常处理

# 健壮性：很多编程语言都有异常处理机制

def div(a, b):
    return a / b


try:
    x = div(5, 2)
    file = open('ddd.txt')
    print(file.read())
    file.close()
# except Exception as e 给异常起了一个变量名
# except Exception as e:  # 如果程序出错了，会立刻跳转到except语句
#     print("程序出错了")
except (FileNotFoundError,ZeroDivisionError) as e:  # 处理指定类型的异常
    print(e)
else:
    print(x)  # 只要执行了except语句，就把不会执行else语句

自定义异常

# 系统内置异常
# ZerroDivisionError:除数为0的异常
# FileNotFoundError:文件不存在异常
# FileExistError:多次创建同名的文件夹
# ValueError:int('hello')
# KeyError:如：字典里没有相应的属性，用[]获取相应的键所报的异常
class MyError(Exception):
    def __init__(self):
        print("密码长度不正确")


if __name__ == '__main__':
    password = input('请输入密码：')
    if 12 >= len(password) >= 6:
        print("密码正确")
    else:
        # 使用raise关键字可以抛出一个异常
        raise MyError

上下文管理器

# with语句后面的结果对象，需要重写__enter__和__exit__方法
# 当进入with代码块时，会自动调用__enter__方法里的代码
# 当with代码块执行完以后，会自动调用__exit__方法
class Demo(object):
    def __enter__(self):
        pass

    def __exit__(self, exc_type, exc_val, exc_tb):
        pass

def create_obj():
    x =Demo()
    return x

with create_obj() as d: # as 变量名
    # 变量d不是create_obj的返回结果
    # 它是创建的对象x调用__enter__之后的返回结果
    print(d)