Learn_Day15 面向对象 ==>> 进阶

1. 通过类访问：静态字段，静态方法，类方法
2. 通过类的对象访问：普通字段，类的方法
3. 字段：静态字段（每个对象都有相同的数据），普通字段（每个字段都有不同的数据）
4. 方法：静态方法（无需使用对象封装的内容，相当于函数），普通方法（使用对象中的数据），类方法
5. 属性（特性）：普通特性
6. 快速判断：有self用对象执行，无self用类执行

# 在子类中执行父类的init方法，查看类的成员<qz_day15_1>

class A:
    def __init__(self):
        print(‘A的构造方法‘)
        self.a = ‘动物‘

class B(A):
    def __init__(self):
        print(‘B的构造方法‘)
        self.b = ‘猫‘
        # 执行父类的init方法
        super(B, self).__init__()
        A.__init__(self)

# 创建类的对象
c = B()
# 类的对象.__dict__  查看类的成员
print(c.__dict__)

# 以下在qz_day15_2中导入
class C:
    def __init__(self, name):
        print(‘C的构造方法‘)
        self.n = name

a = C(‘alex‘)
b = a.n
print(b)

# 利用反射可以导入模块，去模块中找类，根据类创建对象，去对象中寻找对应的值<qz_day15_2>

m = __import__(‘qz_day15_1‘, fromlist=True)  # 执行qz_day15_1文件

a = getattr(m, ‘C‘)

b = a(‘alex‘)  # 执行qz_day15_1文件中的类C

c = getattr(b, ‘n‘)

print(c)

# 成员

class P:
    c = ‘A‘  # 静态字段

    def __init__(self, name):
        temp = ‘xxx‘
        self.n = name  # 普通字段

    def show(self):  # 类的方法（普通方法）
        print(self.n)

    @staticmethod  # 内置函数：用来装饰类中的方法，使其方法变成静态方法
    def xxx(arg1, arg2):  # 静态方法，静态方法可以无参数
        print(‘xxx‘)

    @classmethod  # 内置函数：用来装饰类中的方法，使其方法变成类方法
    def ooo(cls):  # cla为必填参数，执行时会自动将类名传入
        print(‘ooo‘)

    def star(self):  # 类的方法（普通方法）
        temp = ‘%s sb‘ % self.n
        return temp

    @property  # 内置函数：用来装饰类中的方法，使其方法伪造成字段
    def end(self):
        temp = ‘%s sb‘ % self.n
        return temp

    @end.setter  # 用于接收属性（也称特性）
    def end(self, value):
        print(value)
        self.n = value

print(P.c)  # 执行静态字段：类名.静态字段   # 自己访问自己的成员，除了类中的方法

# @staticmethod
P.xxx(1, 2)  # 执行静态方法：类名.方法
# @classmethod
P.ooo()  # 执行类方法：类名.方法

obj = P(‘alex‘)
print(obj.star())  # 执行类的方法（普通方法）

# @property
print(obj.end)  # 执行伪造成字段的方法

# @end.setter
obj.end = ‘123‘  # 设置属性（也称特性）
print(obj.end)

# 成员修饰符：用双下划线开头表示私有，仅供内部使用不能被继承

class A:
    x = ‘x‘  # 普通字段
    __o = ‘__o‘  # 私有字段

    def __init__(self):
        self.__x = ‘__x‘
    def s(self):
        print(self.__o)

class B(A):
    def c(self):
        print(self.__x)
    pass

    # a = B()

print(B.x)
# print(_A__o)  # # 报错，私有字段不能外部访问
# print(B.__o)  # 报错，私有字段不能被继承
A().s()
# print(B().__x)  # 报错，私有字段不能被继承
# B().c()  # 报错，私有字段不能被继承

# 特殊方法

class F:
    def __init__(self):
        print(‘init‘)
        self.n = ‘n‘
        xx = ‘xx‘

    def __call__(self, *args, **kwargs):  # *args, **kwargs 万能参数
        print(‘call‘)
        return args, kwargs

    def __getitem__(self, item):  # 获取 在2.7版本中是getlice
        print(item)

    def __setitem__(self, key, value):  # 赋值
        print(key, value)

    def __iter__(self):  # 执行for循环是自动执行
        yield 1
        yield 2
        yield 3

    def __delitem__(self, key):  # 删除
        print(key)

r = F()()  # 自动执行 init 与call
print(r)  # 拿到call的返回值args, kwargs
r = F()
r[‘k1‘]  # 自动执行getitem（在2.7版本中是getlice）并将k1传给item
r[‘k1‘] = [11, 123]  # 自动执行setitem并给key, value赋值，
print(1, F().__dict__)  # F()为类的对象，F().__dict__获取对象的所有成员
print(2, F.__dict__)  # 获取类的所有成员（字段）
for i in r:  # 自动执行iter
    print(‘iter‘, i)
del r[‘k1‘]  # 自动执行delitem并删除key

# 异常（错误）处理

"""
异常（错误）语法1
try:
    pass
except 异常类的名称 as 对象名:  # 对象名是为异常类创建的对象
    pass
"""

异常（错误）语法1

"""
异常（错误）语法2
try:
    pass
except Exception as e:  # 异常可以写多个，按顺序执行
    # 异常时进行的操作
    pass
else:
    # 无异常时进行的操作
    pass
finally:
    无论是否异常最后都要进行的操作
    pass
"""

异常（错误）语法2

a = input(‘请输入:‘)
try:
    if a == ‘a‘:
        print(‘123‘)
    else:
        raise Exception(‘出错了‘)  # 主动触发错误
except Exception as e:  # 封装错误信息的对象
    print(e)

#断言：不成立则把报错<多用于测试>assert 1 == 2