1.内置类属性

内置类属性就是魔法属性
魔法属性：属性名的前面和后面都有两个下划线
魔法方法：方法的前后都有两个下划线

import datetime
class Person:
    """人类"""
    # 类的字段
    number = 61
    def __init__(self,name,age,height):
        # 对象的属性
        self.name = name
        self.age = age
        self.height = height
    # 对象方法
    def run(self):
        print('%s在跑步'%self.name)
    # 类方法
    @classmethod
    def show_number(cls):
        print('人类的数量为：%d亿'%cls.number)
    #静态方法
    @staticmethod
    def destory():
        print('人类在破坏环境！')



if __name__ == '__main__':
    p1 = Person('张三',28,170)
    # 1.__name__属性  ---_类的名字(是个字符串)
    name = Person.__name__
    print(name,type(name))
    # 2.__class__属性 ---获取对象对应类（是一个类）
    # 对象的属性
    # my_class是一个类，之前类能做的事他都能做
    my_class = p1.__class__
    p2 = my_class('小明',20,180)
    print(p2.name,my_class.__class__)

    # 3.__dict__属性 ---将对象和类的属性及其对应的值转换成键值对存到一个字典中
    print(p1.__dict__)

    # 4.__doc__属性 ---获取类的说明文档
    # 类的属性
    doc = Person.__doc__
    print(doc)

    # 5.__module__属性----获取类所在的模块对应的名字
    print(Person.__module__)
    print(datetime.datetime.__module__)

    # 6.__bases__属性 ---获取当前类的父亲
    # 类的属性
    print(Person.__bases__)
输出结果：
Person <class 'str'>
小明 <class 'type'>
{'name': '张三', 'age': 28, 'height': 170}
人类
__main__
datetime
(<class 'object'>,)

2.slots魔法

class Person:
    # 通过__slots__中存的元素的属性的值来约束当前这个类的对象的属性。对象的属性只能比元组中的元素少，不能多！
    __slots__ = ('name','age','face')

    def __init__(self):
        self.name = '张三'
        self.age = 18
        self.face = 70
        # self.sex = 'male'  #__slots__中并没有sex

if __name__ == '__main__':
    p1 =  Person()
    # p1.sex = 'male'
    # print(p1.sex)
    p1.name = '小明'

    #注意：一旦在类中给__slots__属性赋了值，那么这个类的对象的__dict__属性就不能使用了
    # print(p1.__dict__)

3.属性的私有化

python中并没有真正的私有化！

1.私有化
a.类中的属性和方法都可以通过在属性名和方法名前加两个下划线，来让属性和方法变成私有的
b.私有的属性和方法只能在当前的类中使用

2.私有化原理
在前面有两个下划线的属性名和方法名前添加了'_类名'来阻止通过直接访问属性名来使用属性

class Dog:
    # 字段
    number = 100
    __count = 20

    def __init__(self):
        # 对象的属性
        self.color = 'yellow'
        self.age = 3
        self.name = '大黄'
        self.__sex = 'boy'
#     对象方法
    def eat(self):
        print('%s在吃屎~'% self.name)

#     类方法
    @classmethod
    def shout(cls):
        print('汪汪汪')
#     静态方法
    @staticmethod
    def function():
        print('看家！！')
#python的类中默认的属性和方法是公开的
dog1 = Dog()
print(Dog.number)
print(dog1.name,dog1.color,dog1.age)
dog1.eat()
Dog.shout()
Dog.function()

# 在类的外面不能直接使用私有的属性
# print(Dog.__count)
# print(dog1.__sex)
print(dog1.__dict__)
输出结果：
100
大黄 yellow 3
大黄在吃屎~
汪汪汪
看家！！
{'color': 'yellow', 'age': 3, 'name': '大黄', '_Dog__sex': 'boy'}

4.属性的getter和setter

保护类型的属性：
a.就是在声明对象属性的时候在属性名前加一个下划线来代表这个属性是受保护的属性。
那么以后访问这个属性的时候就不要直接访问，要通过getter来获取这个属性的值和setter来给这个属性赋值
b.如果一个属性已经声明成保护类型的属性，那我们需要给这个属性添加getter。也可以添加setter

2.添加getter
添加getter其实就是声明一个没有参数有一个返回值的函数
a.格式:
@property
def 去掉下划线的属性名(self):
函数体
将属性相关的值返回

b.使用场景
场景一：如果想要获取对象的某个属性的值之前，想要再干点儿别的事情（做额外的处理），就可以给这个属性添加getter
场景二：想要拿到某个属性被使用的时刻

3.添加setter
添加setter就是声明一个有一个参数但是没有返回值的函数。作用是给属性赋值
a.格式
b.使用场景

class Car:
    def __init__(self):
        self.color = '黑色'
        self.type = '劳斯莱斯'
        # _price属性是保护类型
        self._price = '2亿'

    # 给_price属性添加getter
    @property
    def price(self):
        print('在使用_print属性')
        return self._price
    # 想要给一个属性添加setter，必须先给这个属性添加getter
    @price.setter
    def price(self,price):
        if isinstance(price,int) or isinstance(price,float):
            self._price = price
        else:
            self.price = 0

# 练习：声明一个员工类，其中有一个属性是是否已婚（bool），获取值之前根据存的值返回'已婚'/'未婚'
class Staff:
    def __init__(self,name,salary):
        self.name = name
        self.salary = salary
        self._is_marry = True
    @property
    def is_marry(self):
        # return self._is_marry
        if self._is_marry:
            return '已婚'

        return '未婚'
    @is_marry.setter
    def is_marry(self,marry):
        self._is_marry = marry
    # @is_marry.setter
    # def is_marry(self,is_marry):
    #     if is_marry == True:
    #         self._is_marry = '已婚'
    #     else:
    #          self._is_marry = '未婚'
p1 = Staff('张三',1000)
print(p1.is_marry)
p1.is_marry = False
print(p1.is_marry)






if __name__ == '__main__':
    car1 = Car()
    # 添加完getter后就通过getter去获取属性的值
    # price 就是属性_price的getter
    print(car1.price)
    print(car1.color)

    car1.price = 1000
    print(car1.price)
    car1.price = 'abc'
    print(car1.price)
输出结果：
已婚
未婚
在使用_print属性
2亿
黑色
在使用_print属性
1000
在使用_print属性
0

5.继承

python 中可以继承，并且支持多继承
程序中的继承：就是让子类直接拥有父类的属性和方法（继承后父类中的内容不会因为被继承而减少）
1.继承的语法
class 子类(父类)：
类的内容

注意：如果声明的时候没有写继承，那么这个类会自动继承python的基类，object；相当于class 类名（object）：
python中所有的类都是直接或者间接的继承自object

2.能继承哪些东西
a 所有的属性和方法都能继承
b slots的值不会继承，但是会影响子类对象的dict属性，不能获取到父类继承下来的属性

class Person:
    """人类"""
    number = 61
    # __slots__ = ('name','age')

#     对象属性
    def __init__(self,name = '张三',age = 18,__height = 123):
        self.name = name
        self.age = age
        self.height = __height

#     对象方法
    def show_message(self):
        print('姓名：%s 年龄：%d'%(self.name,self.age))

#     类方法
    @classmethod
    def show_number(cls):
        print('人类的数量是：%d'%cls.number)

#     静态方法
    @staticmethod
    def complaint():
        print('人类殴打小动物')
class Student(Person):
    """学生类"""
    pass

# 创建Person类的对象

stu1 = Student()
print(Student.number)
stu1.name = '李四'
print(stu1.name)
stu1.show_message()
Student.show_number()
Student.complaint()
stu1.sex = 'boy'
print(stu1.__dict__)
输出结果：
61
李四
姓名：李四 年龄：18
人类的数量是：61
人类殴打小动物
{'name': '李四', 'age': 18, 'height': 123, 'sex': 'boy'}

6.方法的重写

子类继承父亲，拥有父亲的属性和方法以后，还可以再添加自己的属性和方法
1.添加方法
直接在子类中声明相应的方法

2.添加对象属性
对象的属性是通过继承父类的init方法而继承下来
如果想要在保留父类的对象的同时添加自己的对象属性，需要在子类的init方法中通过super()去调用父类的方法

3.方法的重写
在子类中重新实现父类的方法，就是重写
方法一：直接覆盖父类的实现
方法二：保留父类的功能再添加其他功能

4.类中方法的调用过程（重点）
现在当前这个类中去找，没有就去父类中找，找不到就再去父类的父类中找，依次类推。
如在基类中都没有找到才崩溃。在第一次找到的位置，去调用

注意：使用super的时候必须是通过super（）来代替父类或者是父类对象

class Animal:
    def __init__(self):
        self.age = 0
        self.sex = '雌'
    def shout(self):
        print('嗷嗷')
class Cat(Animal):
    def __init__(self):
        #调用父类的init方法
        super().__init__()
        self.name = '小花'


    food = '鱼'

    def shout(self):
        print('喵喵~')

class Dog(Animal):
    def shout(self):
        # 通过super（）调用父类的方法，保留父类的功能
        super().shout()
        print('汪汪~')
cat1 = Cat()
print(cat1.age)
print(cat1.name)
cat1.shout()

dog1 = Dog()
dog1.shout()
输出结果：
0
小花
喵喵~
嗷嗷
汪汪~

7.init方法的重写

练习：写一个Person类，拥有属性name，age，sex。要求创建Person对象的时候必须给name和age赋值，sex可赋可不赋,再写一个Staff类继承自Person类，要求保留Person中所有的属性，并且添加新的属性salary。要求创建Staff类中的对象的时候，只能给name赋值（必须赋）

class Person:
    def __init__(self,name,age,sex = '男'):
        self.name = name
        self.age = age
        self.sex = sex

class Staff(Person):
    def __init__(self,name):
        super().__init__(name,18)
        self.salary = 1000



p1 = Person('张三',23,'女')
p2 = Person('小红',21)

s1 = Staff('小明')

8.运算符重载

如果希望类的对象支持相应的运算符操作（例如：+，-，*，/,>,<等），就必须实现相应的魔法方法
这个过程就叫运算符的重载

+:add(self, other)

:gt(self, other)
一般情况下需要对 > 或者<进行重载，重载后可以通过sort方法直接对对象的列表进行排序

class Student:
    def __init__(self,name = '',age = 0,score = 0):
        self.name =  name
        self.age = age
        self.score = score
    # self:+号前面的对象
    # other：+号后面的对象
    def __add__(self, other):
        return self.score + other.score
    # 注意：重载>和<可以值重载换一个，另外一个对应的功能自动取反
    def __gt__(self, other):
        return self.age > other.age

    # 重写魔法方法__str__,用来定制对象的打印样式
    def __str__(self):
        # return '%s,%d,%d'%(self.name,self.age,self.score)
        return str(self.__dict__)[1:-1]
class SchoolChild(Student):
    pass

stu1 = Student('小明',32,34)
stu2 = Student('小红',23,90)
stu3 = Student('小强',34,89)
print(stu1)
all_students = [stu1,stu2,stu3]
all_students.sort()
for stu in all_students:
    print(stu.name,stu.age,stu.score)




print(stu1 + stu2)
print(stu1 > stu2)
print(stu1 < stu2)

# 运算符重载支持继承
c1 = SchoolChild('COCO',12,34)
c2 = SchoolChild('cc',23,67)
print(c1 + c2)
输出结果：
'name': '小明', 'age': 32, 'score': 34
小红 23 90
小明 32 34
小强 34 89
124
True
False
101