python学习日志10.11

昨日回顾

组合

一个对象拥有一个属性，该属性的值是另一个对象

class Foo:
    pass

class Bar():
    pass

obj=Foo()
obj1=Bar()
obj.x=obj1 # 这就是一种组合的用法
print(obj.x.z) # obj1.z

"""组合的使用场景：什么有什么的情况，满足has的情况"""
"""继承的使用场景：什么是什么的情况，满足is的情况"""

反射

通过字符串操作属性（类属性，对象属性）

res=getattr(stu, 'x') # 直接拿到结果
res=getattr(stu, 'x1', 666) # 直接拿到结果
res=getattr(stu, 'func', 666) # 直接拿到结果函数的内存地址
res()

## 补充
getattr(Student,'x')
getattr(time,'time')() # 时间戳
getattr(random, 'randint')(0,9) 
...

setattr(stu, 'x', 666) {'x':666}
hasattr(stu, 'x')
delattr(stu, 'x') 

time=__import__('time') # 通过字符串的形式可以导入一些模块
random=__import__('random') # 通过字符串的形式可以导入一些模块
import time
random.randint(0,9) # 不提示，就自己写，不错，只要你别写错

魔术方法

__init__

__str__,repr__

打印对象时自动触发，如果有返回值，类型必须是字符串，如果当两个方法同时存在，__str__的优先级更高

__del__

一般用在回收系统资源时，比如关闭文件，关闭链接

触发条件：1.使用del删除对象的时候会触发  2.当整个程序代码执行完毕的时候，也会触发执行

__doc__

查看类中的注释，这个属性不会继承类父类

__getattr__ , __setattr__, __delattr__

必须使用点语法

1.使用对象。属性获取结果的时候，会自动触发__getattr__，如果不是点语法不会触发

2.使用对象。属性 = 属性值的时候，会自动触发__setattr__

3.使用del对象。属性的时候，会自动触发__delattr__的执行

以上三个方式只是满足触发的条件，不会具体的给你获取值、设置值、删除值等操作，所以需要自己在对应的方法里做相关操作

__getitem__, __setitem__ ,__delitem__

必须使用中括号（[]）obj.x ------> obj['x']

1.使用对象点属性获取结果的时候，会自动触发__getitem__，如果不是点语法不会触发

2.使用对线。属性= 属性值的时候，会自动触发__setitem__

3.使用del对象。属性的时候，会自动触发__delitem__

以上三个方式只是满足触发的条件，不会具体的给你获取值、设置值、删除值等操作，所以需要自己在对应的方法里做相关操作

__call__

对象（）的时候会触发类中的__call__的执行

flask框架的源码----》入口就是在__call__方法里面
 

今日内容

异常

异常就是错误发生的信号，我们需要对该信号做处理，如果不处理，往后的代码就不能执行

异常的分类
    逻辑错误 ：是允许出现的，但是呢，编程的时候尽量避免逻辑错误的发生
    语法错误 ：不允许出现的

解决异常的完整语法：

try:
        被监测的代码(这块儿一般写可能会发生异常的代码)
    except 错误类型1 as e:
        print(e) # 查看到错误的原因
    except 错误类型2 as e:
        print(e) # 查看到错误的原因
   except 错误类型3 as e:
        print(e) # 查看到错误的原因
   except 错误类型4 as e:
        print(e) # 查看到错误的原因
   except Exception as e: '''万能的异常，以上所有的类型都没有被找到，就交给Exception处理'''
        print(e) # 查看到错误的原因
   else:
    	print('被监测的代码没有异常的时候会走这个分支')
    finally:
        print('不管被监测的代码有么有异常都会走')

 主动抛出异常：我们自己有时候也需要抛出一些异常信息，来阻止代码的执行
举例：
    抽象类：在父类中限制子类必须有某个方法

 import abc
    class Animal(metaclass=abc.ABCMeta):
        @abc.abstractmethod # 这么设置之后，以后所有继承Animal类的子类中都必须有speak函数
        def speak(self):pass
    
    class People(Animal):
        def speak(self):
            pass
        
    """不推荐使用这种方式"""

 常用的方式：

class Animal():
    def speak(self):
        raise Exception("请先实现speak功能")  # 这个方式是最常用，因为简单


class People(Animal):
    pass

obj=People()
obj.speak()
"""主动抛出异常的关键字是：raise"""
"""语法结构：raise 异常的类型"""
# raise IndexError('索引错误')
# raise KeyError('字典错误')
# raise Exception('字典错误')
# print(123)

 断言：

# assert 条件  # 条件必须是成立的
# l = ['kevin', 'jason', 'tank1']
# assert 'tank' in l
# print(123)

# 有什么用：单元测试(断言) 我自己写代码去测试我的写代码的bug UnitTest
"""后续的代码中必须要用tank这个元素"""

 自定义异常：

自定义异常
class MyException(BaseException):
    def __init__(self, msg):
        self.msg = msg
    def __str__(self):
        return self.msg

    def reponse(self):
        pass


raise MyException('用户名必须填写')

 

python mixins机制

class Vehicle:  # 交通工具 主类：就是具备主要的功能
    '''这里面应该有其他交通工具都具备的功能'''


# 辅类：写一些辅助的功能，辅类中得函数一般很少
class FlyMixin(): # 专门写能够支持飞的功能
    def fly(self):
        '''
        飞行功能相应的代码
        '''
        print("I am flying")

# class FlyMixin(): # 专门写能够支持飞的功能
# class Flyable(): # 专门写能够支持飞的功能
class Flyible(): # 专门写能够支持飞的功能
    def fly(self):
        '''
        飞行功能相应的代码
        '''
        print("I am flying")

# 继承的类书写顺序也有讲究
# 辅类一般写在类的左边，主类写在类的右边，主类只有一个，而辅类可以有多个

# 辅类的类名也有讲解，辅类的类名一般都是以，python 对于mixin类的命名方式一般以 Mixin, able, ible 为后缀
class CivilAircraft(FlyMixin, Flyible, Vehicle):  # 民航飞机
    pass


class Helicopter(FlyMixin, Flyible, Vehicle):  # 直升飞机
    pass


class Car(Vehicle):  # 汽车并不会飞，但按照上述继承关系，汽车也能飞了
    pass


import socketserver

# class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass
# class ThreadingTCPServer(ThreadingMixIn, TCPServer): pass

元类简介

什么是元类?
	即产生类的类
class Student():
    pass

Student()
# int # class int(object):
# str # class str(object):
# list # class list(object):
# res=int(123) # 123
# str('hello')
# list([1,2,3,4])
"""严格来说，type是查看一个对象是哪个类产生的"""

class Student():
    pass

print(type(Student)) # <class 'type'>

"""Student类就是type类产生的"""

class C1():
    pass
print(type(C1)) # <class 'type'>


class A():
    pass

print(type(A)) # <class 'type'>
"""type是所有类的类，也就是说它是所有类的元类"""

产生类的两种方式

1. class 类名():
    	pass
    
2. 由于所有的类都是有元类创建的，所以，我们可以通过type这个类造出来一个新的类
    # type(object_or_name, bases, dict)
    # type('类名', '父类', '类的名称空间')
	C1=type('C1', (), {'school':'SH'})
    obj=C1()
    print(C1.__dict__)
    print(obj.__dict__)
3. 为什么要学元类? 有什么用?
	
    # 我们学习元类，可以高度的对类做定制化
    比如：让你定义一个类，但是，类的名字首字母必须大写.
    class Student():
        pass
    class a():
        pass
    
    """
    思考：我们的定制化代码应该写在哪里?
    
    	 对象是如何产生的? 调用类然后执行类里面的__init__方法了
    	 类是如何产生的? 推导应该是，造出类的类里面的__init__方法，而这个类恰好是type元类
    	 得出结论：如果想定制化类的代码，应该写在元类的__init__方法
    	
    """
    推导：使用已知推导未知
    # 你能够直接修改元类的代码吗? 不能够直接修改元类的源码，我们是不是可以写一个子类，来继承type类，然后在子类里面的__init__方法中书写定制化代码，所以，还需要在子类里面执行父类的__init__方法

class MyTypeClass(type):
    def __init__(self, cls_name, cls_bases, cls_dict):
        print(cls_name)  # 类名C1
        print(cls_bases)  # ()父类
        print(cls_dict)  # {'__module__': '__main__', '__qualname__': 'C1'}
        if not cls_name.istitle():
            raise Exception("类名必须大写!!!")
        super().__init__(cls_name, cls_bases, cls_dict)


"""元类不能够直接被继承，需要指定metaclass=MyTypeClass"""


class C1(metaclass=MyTypeClass):
    def __init__(self):
        print('C1.__INIT__')

C1()

元类的进阶用法

元类的__call__方法

对象() 的时候会调用产生对象的类中得__call__方法

推导：类名()? 会执行产生类的类中得__call__方法，其实就是元类type中得__call__方法
class MyClass(type):
    def __call__(self, *args, **kwargs):
        print(args) # ()  ('kevin', 20)
        print(kwargs) # {'name': 'kevin', 'age': 20} {}
        if args:
            raise Exception("必须使用关键字传参")
        print('MyClass.__call__')
        super(MyClass, self).__call__(*args, **kwargs)

class C1(metaclass=MyClass):
    def __init__(self,name, age):
        self.name = name
        self.age = age
        print('C1.__init__')
"""观察C1类里的__init__方法和MyClass里的__call__方法的执行顺序?"""
"""得出结论：在执行类的__init__方法之前，其实已经执行了元类的__call__方法了,既然这样，我们就可以在实例化对象的时候，对类做一些定制化"""
# C1('kevin', 20) # 现在是位置传参，我限制让你限制不允许位置传参，只能够通过关键字传参/
C1(name='kevin', age=20) # 现在是位置传参，我限制让你限制不允许位置传参，只能够通过关键字传参/