1、类装饰器：

装饰器：
闭包 + 外层函数参数是函数对象 ---装饰器

装饰器函数其实是这样一个接口约束，它必须接受一个callable对象作为参数，
然后返回一个callable对象。在Python中一般callable对象都是函数，但也有例外。
只要某个对象重写了 __call__() 方法，那么这个对象就是callable的。

# 类装饰器
class decorate:
    def __init__(self,func):
        self.func = func

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


@decorate
def girl():
    print('真是无耻.....')


girl()

类装饰器

class decorate:
    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        class inner_class:
            def __init__(self, func):
                self.func = func

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

        return inner_class(*args)


@decorate(5)
def girl():
    print('真是无耻.....')


girl()

View Code

2、元类

type() -----用来构建所有类型的类
用法：
1、type(对象) ----->返回的对象 的类型
2、type(name,bases,attrs) -----name 类名 bases：tuple保存的是所有的父类
                                                  attrs:{} 字典，所有的属性
所有的类底层都是经过type构建出来的

自定义元类：
         metaclass 元类相关知识
class xxx(type):
           def __new__(cls,name,bases,attrs):
                  do something
                   ....
           return type.__new__(cls,name,bases,attrs)
class Student(父类,metaclass=xxx):

          pass

class ListMetaclass(type):
    def __new__(cls,name,bases,attrs):
        print(name)
        print(bases)
        print(attrs)
        attrs['b'] = 'world'
        if attrs.get('test'):
            attrs.pop('test')
        return  type.__new__(cls,name,bases,attrs)


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


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

View Code

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

View Code

 4、异常处理

异常：
try:
      可能出现的异常的代码
except:
      如果存在异常执行的代码
else:
       没有遇到异常执行的代码
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:
                return 0
        # return result
    except Exception as err:
        print('错误原因：',err)
    else:
        print('正确执行')
        return result
    finally:
        print('00000000')
        return result+1

r = func('+')
print(r)

View Code

 

raise + 自定义异常

valueError
自定义异常：名字上：xxxError
格式：
class xxxError(Exception):
　　def __init__(self,*args,**args):
　　　　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)

print('----->123')

View Code

 

 

例子：宠物商店

'''
宠物商店：
   issubclass(Cat,(Pet,))   ---> issubclass(类名，(父类1，父类2，。。))
   isinstance(pet,Pet)
'''


class PetShop:
    def __init__(self, name):
        self.name = name
        self.pets = set()

    # 动作
    def save_pet(self, pet):
        # print(isinstance(pet, Pet))
        if isinstance(pet, Pet):
            self.pets.add(pet)
            print('添加成功！')
        else:
            print('不是宠物不收留！')

    def sale_pet(self, pet):
        if isinstance(pet, Pet):
            self.pets.discard(pet)
            print('宠物减少')
        else:
            print('不是宠物不收留！')

    # 查找宠物
    def search_pet(self, pname):
        for pet in self.pets:
            if pname == pet.pname:
                print('宠物在商店里')
                break
        else:
            print('不存在此宠物！')

    # 显示所有的宠物
    def all_pets(self):
        print('宠物商店所有的宠物信息如下:')
        for pet in self.pets:
            print(pet)


class Pet:
    type = '宠物'

    def __init__(self, pname, color, age):
        self.pname = pname
        self.color = color
        self.age = age

    def __str__(self):
        return '当前类型是:{},宠物名：{}'.format(self.type, self.pname)


class Dog(Pet):
    type = '狗'

    def see_house(self):
        print('特长看家...')


class Cat(Pet):
    type = '猫'

    def catch_mouse(self):
        print('特长抓老鼠....')


class Bird:
    pass


# 创建对象
shop = PetShop('爱宠')

# pet = Pet()
cat = Cat('花花', '黄色', 2)
bird = Bird()
shop.save_pet(cat)  # pet =cat
dog = Dog('大黄', '棕色', 3)
shop.save_pet(dog)

shop.all_pets()
shop.search_pet('花')

View Code