python 装饰器

装饰器

# 函数装饰器

    def decorator(func):
        def wrapper(*args, **kwargs):
            func()
            print('涂点粉...')
            print('涂点口红')
            print('变成小萝莉')
    
        return wrapper

类装饰器

   class decorator:
        def __init__(self, func):
            self.func = func
    
        def __call__(self, *args, **kwargs):
            self.func(*args, **kwargs)
            print('涂点粉...')
            print('涂点口红')
            print('变成小萝莉')

    @decorator  # d = decorator(girl)     girl = d
    def girl():
        print('俺是大妈....')
    girl()

元类

元类被称为 Python 中的“深奥的巫术”。尽管你需要用到它的地方极少（除非你基于 zope 编程），可事实上它的基础理论其实令人惊讶地易懂。

一切皆对象
一切都有类型
 “class”和“type”之间本质上并无不同
类也是对象
它们的类型是 type

class ListMetaclass(type):
    def __new__(cls, name, bases, attrs):
        print(name)
        print(bases)
        print(attrs)
        attrs['b'] = 'world'
        if attrs.get('test'):#当用到text的时候他被移除所有不会renturn（下两行）到，不会创立空间地址
            attrs.pop('test')
        return type.__new__(cls, name, bases, attrs)

class MyList(object, metaclass=ListMetaclass):
    a = 'hello'

    def test(self):
        print('---->test')

l = MyList()
print(l)
print(l.a)
# print(l.b)
l.test()

 type()  ----> 用来构建所有类型的类
 用法：
 1.type(对象)   ----》 返回的是对象的类型
 2.type(name,bases,attrs)  ----> name 类名   bases： tuple保存的是所有的父类  attrs：{} 字典   类中的所有的属性   

 所有的类底层都是经过type构建出来的。

 自定义元类：
 class xxx(type):
    def __new__(cls,name,bases,attrs):
        do something
        ....
        return type.__new__(cls,name,bases,attrs)

 class Student(父类,metaclass=xxx):
     pass

元类它只做了三件事：

    拦截类的创建
    
    修改类
    
    返回修改之后的类

异常处理

1. 基础：
 try.....except
 
 try:
    可能出现异常的代码
 except:
    如果存在异常执行的代码
    
 扩展：
 try:
    可能出现异常的代码
 except 异常类型1:
    如果存在异常执行的代码
 except 异常类型2:
    如果存在异常执行的代码
 
 Exception是所有异常类型父类，Exception通常是要放在最后的用来接收未知的类型
 如果想获取错误xxxError的报错信息，需要使用格式：
 except 异常类型 as 名字:
    ......
    do something 
    

 try:
    可能出现异常的代码
 except:
    如果存在异常执行的代码
 else:
    没有遇到异常执行的代码

def chu(a, b):
    try:
        a = int(a)
        b = int(b)  # t = TypeError('错误的提示信息')  raise t
        return a / b

    except TypeError as err:  # isinstance(obj,TypeError)    err = t
        print('类型错误', err)  # err 就是错误对象
    except ZeroDivisionError as err:
        print('除数为零', err)
    except Exception as err:
        print('---->出错啦', err)


r = chu(1, 0)
print(r)
print('=========>AAAAAA')

r = chu(10, 'G')
print(r)
print('=========>BBBBBB')

finally:
    无论是否存在异常都会执行的代码部分

  如果代码有返回值+finally，则肯定会执行finally里面代码部分

  在开发的时候，数据库连接，网络的连接,使用finally在最后的时候释放资源

def func(opr):
    result = 0
    try:
        n1 = int(input('输入第一个数:'))
        n2 = int(input('输入第二个数:'))

        if opr == '+':
            print('正在进行加法运算..')
            result = n1 + n2
        elif opr == '-':
            print('正在进行减法运算..')
            result = n1 - n2
        elif opr == '*':
            print('正在进行乘法运算..')
            result = n1 * n2
        elif opr == '/':
            print('正在进行除法运算..')
            if n2 != 0:
                result = n1 / n2
            else:
                result = 0
        return result
    except Exception as err:
        print('出错啦!', err)
    # else:
    #     print('正确执行！')
    #     return result
    finally:
        print('00000000')
        return result + 1
        # conn.close()

r = func('+')
print(r)
当出现异常的时候也会运行 finally里面的 不会因为上面有renturn而结束函数，但是当finally里面也有return的时候会执行finally 里面的return，外面的不会执行

异常的传递

```python
 def get_random():
        try:
            list1 = []
            for i in range(5):
                ran = random.randint(1, 10)
                list1.append(ran)
            list1.append('9')
            func(list1)
        except Exception as err:  #err自己起的名字 用来接收产生的错误
            print('+++++++++++++++++>', err)
    
    
    try:
        get_random()
    except Exception as err:
        print(err)

  raise + 自定义异常
    ValueError
    自定义异常，名字上：xxxError
    格式:
       class xxxError(Exception):
          def __init__(self, *args, **kwargs):
               pass
     使用：
     ######## raise xxxError('消息')####
    
      处理异常：
       try:
          有可能有异常代码
       except 类型:
          处理异常

两大部分：
  1. 处理异常： try...except
                try...except...else
                try...except...else...finally
  2. 自定义异常 + raise

自定义异常

class UserNameError(Exception):
    def __init__(self, *args, **kwargs):
        pass


class PasswordError(Exception):
    def __init__(self, *args, **kwargs):
        pass


def register():
    username = input('输入用户名:')
    # 名字长度>=6,不能数字开头  '2'
    if len(username) < 6 or username[0].isdigit():
        # 用户名定义出错
        raise UserNameError('用户名格式错误')
    else:
        print('用户名合法')
        password = input('输入密码:')
        if 10 >= len(password) >= 6:
            print('注册成功')
        else:
            raise PasswordError('密码格式错误')

# 调用函数
try:
    register()
except Exception as err:
    print(err)

单例类：单例模式

1.单例是一种 设计模式 ，应用该模式的类只会生成一个实例
2.单例模式保证了在程序的不同位置都 可以且仅可以取到同一个对象实例 
3.使用单例模式可以减少产生冲突，也不会浪费资源

class Person:
    __instance = None

    def __new__(cls, *args, **kwargs):
        if cls.__instance is None:
            cls.__instance = object.__new__(cls, *args, **kwargs)
        return cls.__instance

    def __init__(self):
        print('---->init')


 p1 = Person()
 p2 = Person()
#p3 = Person()
#
 print(id(p1))
 print(id(p2))
print(id(p3))

装饰器器实现单例

   class cls_decorator:
        def __init__(self, f):
            self.f = f
            self.__instance = {}
    
        def __call__(self, *args, **kwargs):
            if self.f not in self.__instance:
                self.__instance[self.f] = self.f()  # self.f = Singleton   Singleton()
            return self.__instance[self.f]  # {'Singleton':<Singleton object at 0x00000000022205F8>}

函数装饰器实现

def func_decorator(cls):
    _instance = {}

    def wrapper(*args, **kwargs):
   

     if cls not in _instance:
                _instance[cls] = cls()
            return _instance[cls]
    return wrapper


@func_decorator  # 1.cls = cls_decorator()  2. Singleton = cls
class Singleton:
    def __init__(self):
        print('---->Singleton init')


print(Singleton)
s1 = Singleton()  # cls()
s2 = Singleton()

print(s1 is s2)