1.内置类属性

内置类属性就是魔法属性
魔法属性:属性名的前后都有两个下划线
魔法方法:方法的前后都有两个下划线
类的属性
1.name:存的是类的名字，结果是个字符串
2.doc：获取类的说明文档
3.dict():将对象和类的属性及其对应的值转换成键值对存到一个字典中
4.class():获取类的类型
5.module:获取类所在的模块对应的名字
6.bases:获取当前类的父类
对象的属性:
1.class：获取对象时属于哪个类的,(返回值是一个类)
my_class =p1.class #my_class是一个类，之前类能做的事它都能做
p2 = my_class('小明',20,180)
print(p2.name)
2.dict:将对象和类的属性及其对应的值转换成键值对存到一个字典中

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 destroy_env():
        print('人类在破坏环境')
if __name__=='__main__':
    pass
    p1 =Person('张三',28,107)
    print(Person.__name__)      #存的是类的名字
    print(type(Person.__name__))#<class 'str'>
    print(type(Person))         #<class  'type'>     
    # print(p1.__name__)            #AttributeError
    print(Person.__doc__)       #获取类的说明文档
    print(datetime.datetime.__doc__)
    my_class =p1.__class__
    p2 = my_class('小明',20,180)
    print(p2.name)
    print(Person.__dict__)
    print(p2.__dict__)      #{'name': '小明', 'age': 20, 'height': 180}
    print(Person.__bases__)
    print(Person.__module__)

2.slots魔法：

通过__slots__中存的元素的属性的值来约束当前这个类的对象的属性，对象的属性只能比元组中的元素少，不能多！
注意一旦在类中给__slots__属性赋了值，那么这个类的对象的__dict__属性就不能使用了

    __slots__=('name','age','face')
class Person:
    __slots__=('name','age','face')
    def __init__(self):
        self.name='张三'
        self.age=18
        self.face=70
if __name__=='__main__':
    p1 = Person()
    print(p1.__dict__)
    print(p1.name)
    p1.sex = 'girl' #__slots__中并没有sex
    print(p1.sex)

3.私有化

python中并没有真正的私有化
a.类中的属性和方法都可以在属性名和方法名前加两个下划线，来让属性和方法变成私有的。
b.私有的属性和方法只能在当前的类中使用,在类的外面不能直接使用使用的属性
私有化的原理
私有化原理是有两个下划线的属性名和方法名前添加了'_类名'来阻止外部通过直接访问属性名来使用属性

class Dog:
    __number = 100
    def __init__(self):
        self.__color = '黄色'
        self.age = 3
        self.name = '大黄'
    def eat(self):
        print('%s在吃肉~'%self.name)
    @classmethod
    def shout(cls):
        print('汪汪汪...')
    @staticmethod
    def function():
        print('看家')
    @classmethod
    def get_number(cls):
        print(cls.__number)
    @classmethod
    def set_number(cls,number):
        cls.__number=number
if __name__=='__main__':
    Dog.get_number()
    Dog.set_number(200)
    Dog.get_number()
    dog = Dog()
    print(dog.__dict__)
    print(dog._Dog__color)
    print(Dog.__number)

4.属性的getter和setter

1.保护类型的属性：
a.就是在声明对象属性的时候在属性名前加一个下划线来代表这个属性时受保护的属性。
那么以后访问这个属性的时候就不要直接访问，要通过getter来获取属性的值和setter
来给这个属性赋值
b.如果一个属性已经声明成保护类型的属性，那么我们就需要给这个属性添加getter，也可以添加setter
2.添加getter
添加getter其实就是声明一个没有参数，有一个返回值的函数
a.格式:
@property
def 受保护的属性名没有下划线(self):
处理代码块
将属性相关的值返回
使用方式
对象.无下划线属性名
b.使用场景
场景一:如果想要获取对象的某个属性的值之前，想要再干点儿别的事情(做额外的处理)。就可以给这个属性添加getter
场景二:想要拿到某个属性被使用的时刻
3.添加setter
添加setter就是声明一个有一个参数但是没有返回值的函数.作用是个属性赋值
注意:想要给一个属性添加setter，必须先给这个属性添加getter
a.格式
@属性名.setter
def 属性名(self,参数):
处理代码块
self.属性名 = 参数
b.调用方式
对象.属性名 = '参数'

class Car:
    def __init__(self):
        self.color = '黄色'
        self.type = '自行车'
        self._price = 2000

#给_price属性添加getter

    @property
    def price(self):
        if self._price<1000:
            return self._price
        else:
            return str(self._price//1000)+'k'
    #给_price属性添加setter
    #通过setter给属性赋值
    @price.setter
    def price(self,price):
        if isinstance(price,int) or isinstance(price,float):
            self._price = price
        else:
            self._price = 0
if __name__=='__main__':
    #添加完getter后就通过getter去获取属性的值
    #price就是属性_price的getter
    c1 = Car()
    print(c1.price)#实质是在调用getter方法
    c1.price = 'x' #实质是在调用setter方法
    print(c1.price)

练习：声明一个员工类，其中有一个属性是是否已婚。存储的是bool,在获取值之前根据存的值返回'已婚'或者是'未婚'

class Staff:
    def __init__(self):
        self.name = ''
        self.age = ''
        self._marriage=False
    @property
    def marriage(self):
        if self._marriage:
            return '已婚'
        else:
            return '未婚'
    @marriage.setter
    def marriage(self,marriage):
        if marriage == '已婚':
            self._marriage=True
        elif marriage == '未婚':
            self._marriage=False
if __name__ == '__main__':
    s1 = Staff()
    s1.name = '张三'
    s1.age = 20
    s1.marriage = '已婚'
    s2 = Staff()
    s2.name = '李四'
    s2.age =18
    s2.marriage='未婚'
    print(s1._marriage,s1.marriage)
    print(s2._marriage,s2.marriage)

5.类的继承(**)

python中的类可以继承，并且支持多继承
程序中的继承，就是让子类直接拥有父类的属性和方法(继承后父类中的内容不会因为被继承而减少)
1.继承的语法
class 类名(父类):
类的名称
注意:如果声明类的时候没有写继承，那么这个类会自动继承python的基类object:相当于class 类名(object):
python中所有的类都是直接或者间接的基础自object
2.能继承哪些东西
所有的属性和方法都能继承
注意：slots的设置不会被继承,但是如果父类设置了slots，那么当前类的子类的对象的dict属性，不能获取
到父类继承下来的属性
注意:python中私有的属性其实是继承下来了的

class Person(object):
    '''人类'''
    #字段
    __slots__=('name','age')
    number = 61
    #对象属性
    def __init__(self,name='张三',age=18):
        self.name=name
        self.age=age
    #对象方法
    def show_message(self):
        print('姓名:%s，年龄:%s'%(self.name,self.age))
    @classmethod
    def show_number(cls):
        print('人类的数量%d亿'%cls.number)
    @staticmethod
    def complaint():
        print('人类殴打小动物')
class Student(Person):
    pass
if __name__ == '__main__':
    print(Student.number)
    s1 = Student()
    print(s1.name)
    s1.show_message()
    Student.show_number()
    Student.complaint()
    print(s1.__dict__)

6.方法的重写:

子类继承父类，拥有了父类的属性和方法以后，还可以添加自己的属性和方法
1.添加方法和类的字段
直接在子类中声明要添加的方法和字段就可以了
2.添加对象属性
对象的属性是通过继承父类的init方法而继承下来的
如果想要在保留父类对象的同时添加自己的对象属性，需要在子类的init方法中
通过supper()去调用父类的init方法
3.方法的重写
在子类中重新实现父类的方法就是重写
方式一：直接覆盖父类的实现
方式二：保留父类的功能再添加其他的功能
通过super()去调用父类中的方法,保留父类的功能
4.类中方法调用的过程(重点)
先在当前类中去找，没有去父类中找，找不到再去父类的父类中去找，依次类推，找到
基类为止，如果在基类中都没有找到才崩溃。在第一次找到的位置去调用。
注意:使用super的时候必须是通过super()来代替父类或者父类对象

class Animal(object):
    '''动物'''
    #字段
    number = 61
    #对象属性
    def __init__(self,name='张三',age=18,sex='雄'):
        self.name=name
        self.age=age
        self.sex=sex
    #对象方法
    def shout(self):
        print('嗷嗷叫')
    @classmethod
    def show_number(cls):
        print('动物的数量%d亿'%cls.number)
    @staticmethod
    def complaint():
        print('大动物殴打小动物')   
class Cat(Animal):
    food = '鱼'
    def __init__(self):
        self.color = '白色'
        super().__init__()  #调用父类的__init__()方法

    def shout(self):
        print(super().number)
        super().shout()
        print('喵喵')
cat = Cat()
cat.shout()

练习:写一个Person类，拥有属性，name,age，sex，要求创建Person对象的时候必须给name,age赋值
sex可赋可不赋，再写一个Staff继承自Person类，要求保留Person中的所有属性，并且添加新的属性salary.
要求创建Staff对象的时候,name必须赋值，其他的只能通过Staff对象修改值

class Person:
    def __init__(self,name,age,sex='男'):
        self.name = name
        self.age = age
        self.sex = sex
class Staff(Person):
    def __init__(self,name):
        self.salary = 1000
        super().__init__(name,0)
if __name__ == '__main__':
    s1 = Staff('张三')
    s1.age = 20
    s1.salary = 20000
    s1.sex = '女'
    print(s1.name,s1.age,s1.sex,s1.salary)

7.运算符重载：父类重载了运算符，只能也能用

重写了运算符之后，可以使用sort方法
如果希望类的对象支持相应的运算符操作(例如:+,-,*,/,>,<等)就必须实现相应的魔法方法
这个过程就叫运算符的重载

•   __add__()
  

  __gt__(self,other)  #注意：大于符号和小于符号重载一个另外一个直接可以用，另外一个自动取反

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

class Student:
    def __init__(self,name='',age=0,score=0):
        self.name = name
        self.age = age
        self.score = score
    #self:这儿的self指的是+号前面的对象，other指的是+号后面的对象
    def __add__(self,other):
        return self.score+other.score
        #self:这儿的self指的是>号前面的对象，other指的是+号后面的对象
    def __gt__(self,other):
        return self.age > other.age
    def __str__(self):
        return '<%s.%s object %s at 0x%x>'%(self.__module__,self.__class__,__name__,id(self))
        # return 'Student:%s,%s,%s'%(self.name,self.age,self.score)
if __name__ == '__main__':
    stu1 =Student()
    stu2 =Student()
    print(stu1 + stu2)
    print(stu1 > stu2)
    print(stu1)

重写str.用来定制对象的打印样式