1. 类的属性

1.1 内置类属性

创建类的时候，系统默认为我们添加的类的属性

• name 字段
  类.name 获取类的名字
• doc 字段
  类.doc 获取类的说明文档
• class 对象属性
  对象.class 获取对象对应的类(你这个对象是哪个类的对象)
• dict 字段/对象属性
  对象.dict 获取对象中所有的属性和对应的值，以字典的形式返回
• module 字段
  类.module 获取指定的类声明在哪个模块中，返回模块名(获取类所在的模块的name属性的值)
• bases 字段
  类.bases 返回当前类的所有父类

class Person:
    """说明文档:人类"""
    #类的字段
    number = 61

    #对象属性
    def __init__(self, name, age=0, gender='女'):
        self.name = name
        self.age = age
        self.gender = gender

    #======方法=========
    def object_func(self):
        print('对象方法:'+self.name)

    @classmethod
    def class_func(cls):
        print('类方法：', cls.number)

    @staticmethod
    def static_func():
        print('静态方法')

静态方法是系统自带的魔法，可以定制当前类的对象的打印内容，实现这个函数的时候要求有一个字符串类型的返回值
影响单独打印对象的效果
静态方法的内部实现如下：

    def __str__(self):
        return str(self.__dict__)[1::-1]
    对象作为元素的时候的打印效果
    def __repr__(self):
        return '<'+str(self.__dict__)[1:-1]+'>'

    def __repr__(self):
        return '<%s.%s object at %s>' % (self.__class__.__moduld__, self.__class__.__name__, hex(id(self)))

p1 = Person('小明', 18, '男')
print(Person.__name__, type(Person.__name__)) #Person <class 'str'>
print(Person.__doc__)   #说明文档:人类
print(p1.__class__)     #<class '__main__.Person'>
print(Person.__dict__)  #{'__module__': '__main__', '__doc__': '说明文档:人类', 'number': 61, '__init__': <function Person.__init__ at 0x011AB9C0>, 'object_func': <function Person.object_func at 0x011AB978>, 'class_func': <classmethod object at 0x009F72D0>, 'static_func': <staticmethod object at 0x011A9650>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>}
print(p1.__dict__)      #{'name': '小明', 'age': 18, 'gender': '男'}
print(Person.__module__)#__main__
print(Person.__bases__) #(<class 'object'>,)

class A(Person, int):
    pass


print(A.__bases__)  #(<class '__main__.Person'>, <class 'int'>)

print('p1：', p1)    #p1： <__main__.Person object at 0x011A9890>

persons = [p1, Person('小花', 20)]
print(persons)      #[ object at 0x011A9890>, <__main__.Person object at 0x011A9950>]<__main__.Person

2.slots魔法

可以通过给slots字段赋值来约束当前类有哪些对象属性;
当在类中给slots赋值后，当前类的对象的dict属性无效

class Dog:
    __slots__ = ('name', 'age', 'gender', 'name1')

    def __init__(self, name, age=0):
        self.name = name
        self.age = age
        self.gender = '公'


dog = Dog('大黄')


print(dog.__dict__)

2. 属性的私有化和保护

2.1 高级语言

在很多的高级面向对象语言中，会将属性和方法分为公开的(在类的外部可以使用)、
私有的(只能在类的内部使用,不能被继承)、受保护(只能在类的内部使用,可以被继承)的三类

2.2 python

python中类的内容本质上全部都是公开的。私有和公开都只是约定

• 私有化
  a.内容只能在类的内部使用，不能在外面使用。（效果）
  b.在类中的方法名或者属性名前加'',那么对应的属性和方法就会变成私有的。 (怎么私有化)
  c.当声明类的时候在名字前加'',内部会在这个基础前面再加'_类名'。 (私有化的本质)

• 属性保护
  可通过在对象属性名前加'',把这个属性标记成受保护类型；为了告诉别人这个属性在使用的时候，不要直接用，而是通过getter和setter来使用
  a.getter
  获取对象的属性值之前想要干点儿别的事情，那么就给这个属性添加getter
  第一步: 在对应的属性名前加''
  第二步: 在@property后面声明一个函数，这个函数没有参数，有一个返回值，并且函数名是属性名去掉''
  第三步: 获取属性值的时候，通过'对象.属性名去掉下划线'去获取属性的值
  b.setter
  给属性赋值前干别的事情，就给这个属性添加setter。（想要添加setter必须先有getter）
  第一步: 在对应的属性名前加''
  第二步: 在@getter名.setter后面声明一个函数，这个函数需要一个参数，没有返回值，并且函数名是属性名去掉'_'
  第三步: 给属性赋值的时候，通过'对象.属性名去掉下划线=值'的方式赋值

2.3 抛出异常:

a.语法:
raise 异常类型

b.说明:
raise - 关键字
异常类型 - 可以是系统提供的异常类型，也可以自定义异常类型(必须继承Exception)

2.4 自定义异常类型：写一个类继承Exception，然后重写str方法来自定义错误信息。

class WeekValueError(Exception):
    def __str__(self):
        return '星期的值只能是1-7的整数！'


# raise WeekValueError


# ===============保护==============
class AgeError(Exception):
    def __str__(self):
        return '年龄要求是整数，并且范围在0~150!'


class Person1:
    def __init__(self):
        self._age = 0   #定义受保护属性age
        self._week = 6  #定义受保护属性week

    @property      #定义受保护的属性对应的方法
    def age(self):
        if self._age < 18:
            return self._age, '未成年'
        elif self._age < 30:
            return self._age, '成年'
        elif self._age < 50:
            return self._age, '中年'
        else:
            return self._age, '老年'

    @age.setter     #设置受保护的属性
    def age(self, x):
        if not isinstance(x, int):
            raise AgeError
        elif not 0 < x <= 150:
            raise AgeError
        self._age = x

    @property   #定义受保护的属性week对应的方法
    def week(self):
        weeks = ['周1', '周2', '周3', '周4', '周5', '周6', '周日']
        return weeks[self._week - 1]

    @week.setter    #设置week方法
    def week(self, x):
        if not isinstance(x, int):
            raise ValueError
        elif not 1 <= x <= 7:
            raise ValueError
        self._week = x


p1 = Person1()


p1.week = 1          # 本质是在调用setter对应的方法
print(p1.week)       # 本质是在调用getter对应的方法

p1.age = 100
age, jieduan = p1.age
print(age, jieduan)

练习: 给age属性添加getter和setter,获取年龄的时候拿到年龄值，和这个年龄对应的阶段;给age赋值的时候，必须是整数，并且范围在0-150。如果不满足要求报错：AgeError

class Person:
    __number = 61    #定义一个私有字段number

    def __init__(self, name, age=18):
        self.name = name
        self.__age = age    #定义私有属性age

    def message(self):
        print(self.__age)

    def __func1(self):      #定义私有方法func1
        print(self.name)


p = Person('小明')
print(p.name)
# print(p._Person__age)
p.message()

# print(Person.__number)
# p.__func1()
print(p.__dict__)

3. 类的继承

3.1 什么继承: 让子类直接拥有父类所有的属性和方法

父类 - 被继承者, 子类 - 继承者
python中所有的类都是直接或者间接的继承object

3.2 怎么继承

class 子类名(父类1,父类2,...):
类的内容

3.3 子类中添加内容

1)添加字段和方法，直接添加

class Person(object):
    number = 61

    def __init__(self, name, age=0, gender='男'):
        # name = '小花'
        self.name = name
        self.age = age
        self.gender = gender
        self.__num = '0001'     #设置私有属性num，默认值是'0001'

    def fun1(self):
        print('Person对象方法:', self.name)

    @classmethod
    def func2(cls):
        print(cls.number)

    @staticmethod
    def func3():
        print('func3')


class Student(Person):
    flag = '学生！'

    def __init__(self, name):
        # name = '小花'
        # 在子类的方法中去调用父类的方法
        super().__init__(name)     #  super().__init__('小花')
        self.study_id = 'stu001'

    def fun1(self):
        super().fun1()
        print('子类的,func1')

    def study(self):
        print('%s在学习' % self.name)


stu = Student('小花')
print(stu.__dict__)   #{'name': '小花', 'age': 0, 'gender': '男', '_Person__num': '0001', 'study_id': 'stu001'}
# 使用父类继承下来的属性和方法
print(Student.number) #61
print(stu.name)       #小花
stu.fun1()            #Person对象方法: 小花
Student.func2()       #
Student.func3()


# 使用自己的属性和方法
print(Student.flag)
stu.study()


print(Person.__bases__)