01.内置类属性

1.内置类属性就是魔法属性
a.魔法属性：属性名的前后都有两个下划线
b.魔法方法：方法的前后都有两个下划线

class Person:
    """人类"""
    # 类的字段
    number = 99

    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 destroy():
        print('人类在破坏环境！')
p1 = Person('张三',28,170)

1.name 属性 ---类的名字（是个字符串）

name = Person.__name__
print(name,type(name),type(Person))

2.class属性 ---获取对象对应类（是一个类）
对象的属性
my_class是一个类，之前类能做到的事他都能做

my_class = p1.__class__
p2 = my_class('小明',17,999)
print(p2.name,my_class.__name__)

3.dict属性
---可以将对象或类的属性及其对应的值转换成键值对存到字典中

# print(Person.__dict__)
print(p1.__dict__)#{'name': '张三', 'age': 28, 'height': 170}
print(p2.__dict__)#{'name': '小明', 'age': 17, 'height': 999}

4.module属性 ---获取类所在的模块对应的名字

print(Person.__module__)

5.doc属性 ---获取类的说明文档

# 类的属性
doc = Person.__doc__
print(doc)

6.bases属性 ---获取当前类的父类

# 类的属性
print(Person.__bases__)

02.slots魔法

class Person:
    # 通过__slots__中存的元素的属性的值来约束当前这个类的对象的属性，
    # 对象的属性只能比元祖中的元素少，不能多！
    __slots__ = ('name','age','face')
    def __init__(self):
        self.name = '白胡子'
        self.age = 18
        self.face = 70
        # self.sex = 'boy'  #__slots__中并没有sex

p1=Person()
# p1.sex = 'girl'
# print(p1.sex)
#
# p1.neme = 'onepice'
print(p1.name)

注意：一旦在类中给slots属性赋了值，那么这个类的对象的dict属性就不能使用
1.slot属于类属性,是一个列表 , 只有列表内的变量名可以成为实例属性
2.dict属性为字典型
print(p1.dict)

03.属性的私有化：

a.python中并没有真正的私有化！！
b.python的类中默认的属性和方法都是公开的

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

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

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

    def __init__(self):
        self.color = '黑白色'
        self.age = 3
        self.name = '哈士奇'
        self.__sex = 'gong'

    # 对象方法
    def __eat(self):
        print('%s在食~'%self.name)
    def eat(self):
        # 在类中可以使用私有的属性和方法
        self.__eat()
        print('%s在食屎~'%self.name)

    @classmethod
    def shout(cls):
        print('count:',cls.__count,Dog.__count)
        print('wangwangwang~~~')

    @staticmethod
    def function():
        print('kanjjjjjjj~~~')

# python的类中默认的属性和方法都是公开的
dog1 = Dog()
print(Dog.number)
print(dog1.name,dog1.color,dog1.age)
dog1.eat()
Dog.shout()
Dog.function()

# 在类的外面不能直接使用私有的属性
#print(Dog.__count)  #AttributeError: type object 'Dog' has no attribute '__count'
print(dog1._Dog__sex)
print(dog1.__dict__)

04.属性的getter和setter

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

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

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

3.添加setter
添加setter就是声明一个有一个参数但是没有返回值的函数。作用是给属性赋值。
a.格式：@属性名.setter
b.使用场景：
在给属性赋值之前想干点别的事，就给属性添加setter

class Car:
    def __init__(self):
        self.color = '黑色'
        self.type = 'MSDS_BC'
        # _price属性是保护类型
        self._price = 2000000

    # 给_price属性添加getter
    @property
    def price(self):
        print('在使用_price属性')
        return self._price / 1000

    # 想要给一个属性添加setter，必须先给这个属性添加getter
    @price.setter
    def price(self, price):
        if isinstance(price, int) or isinstance(price, float):
            self._price = price
        else:
            self._price = 0
car1 = Car()
print(car1.color, car1._price)
# 添加完getter后就通过getter去获取属性的值
# price就是属性_price的getter

# 实质是在调用getter对应的方法
print(car1.price,'k')
print(car1.price)

# 通过setter给属性赋值。实质是在调用setter对应的方法
car1.price = 1000
print(car1.price)
car1.price = 'abc'
print(car1.price)

练习：声明一个员工类，有一个属性为是否已婚（bool）,在获取值之前，根据存的值返回'已婚'/'未婚'

class Staff:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex
        self._marrieds = ''

    @property
    def marrieds(self):
        return self._marrieds

    @marrieds.setter
    def marrieds(self, marrieds):
        if marrieds == '是':
            self._marrieds = '已婚'
        if marrieds == '否':
            self._marrieds = '未婚'


sta = Staff('ftr', '21', '男')
print(sta.name, sta.age, sta.sex)
sta.marrieds = input('是否结婚（是/否）： ')
print(sta.marrieds)

05.继承

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

1.继承的语法
class 子类(父类)：
类的内容

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

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

class Person:
# class Person（object）:
    """人类"""
    # 字段
    number = 99
    __slots__ = ('name','age')
    # 对象的属性
    def __init__(self,name='ftr',age=18):
        self.name=name
        self.age=age
        # self.__height = 50

    # 对象方法
    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类的对象
p=Person()
# p.sex='boy'

# 创建Student类的对象
stu1 = Student()
# 类的字段继承
print(Student.number)
stu1.name='cctv'
print(stu1.name)
stu1.show_message()
Student.show_number()
Student.complaint()

print(stu1.__dict__)

06.方法的重写

子类继承父类，拥有父类的属性和方法以后，还可以再添加自己的属性和方法。

1.添加方法和类的字段：
直接在子类中声明相应的方法和字段

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

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

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

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

class Animal:
    def __init__(self):
        self.age = 0
        self.sex = '雌'

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

class Cat(Animal):

    def __init__(self):
        # 调用父类的init方法
        super().__init__()
        self.name = 'xxx'

    food = '鱼'

    # @staticmethod
    # # 没用到属性和类
    # def Shout():
    #     print('mmmmm~~~')
class Dog(Animal):
    def shout(self):
        # 通过super()调用父类的方法，保留父类的功能
        super().shout()
        print('wawawa~~~')

cat1=Cat()
print(cat1.__dict__)
print(cat1.name)

5.init方法的重写

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

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

class Staff (Person):
    def __init__(self,name):
        super().__init__(name,18)
        self.name=name
        self.salary=0
per=Person('FTR',20,'boy')
per1=Person('FT',18)
sta = Staff('cctv')
print(sta.__dict__)

07.运算符的重写

如果希望类的对象支持相应的运算符操作(例如：+、-、*、/、>、<等)，就必须实现相应的魔法方法。这个过程就叫做运算符的重载。
一般情况需要对>或者<进行重载，重载后可以通过sort方法直接对对象的列表进行排序

class Student:
    def __init__(self,name='',age=18,score=0):
        self.name=name
        self.age=age
        self.score=score

    # self:+号前面的对象
    # other：+号后面的对象
    def __add__(self,other):
        return self.name + other.name

    # 重载 > 符号
    # 注意：重载>和<可以只重载一个，另外一个对应的功能自动取反
    def __gt__(self, other):
        return self.age>other.age

#     重写魔法方法__str__，用来定制对象的打印样式
    def __str__(self):
        # return ('%s %s %s '%(self.name,self.age,self.score))
        return str(self.__dict__)[1:-1][1:-1]
stu1 = Student('FTR',18,99)
stu2 = Student('FT',19,89)
stu3 = Student('F',29,79)
print(stu1)
all_students = [stu1,stu2,stu3]
all_students.sort(reverse=True)

for stu in all_students:
    print(stu.name,stu.age,stu.score)

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