1 内置类属性
-
内置类属性就是魔法属性
魔法属性：属性名的前面和后面都有两个下划线。
魔法方法：方法的前后都有两个下划线。
声明一个人的类：
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("人类在破坏环境")
实例化一个对象：
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('小明', 20, 180)
print(Person.__class__)
print(p2.name, my_class.__name__)
# 3.__dict__属性 ---> 将对象和类的属性及其对应的值转换成键值对存到一个字典中
print(Person.__dict__) # 字典形式获取类中的所有内容
print(p1.__dict__)
# 4. __doc__属性 ---> 获取类的说明文档
doc = Person.__doc__
print(doc)
# 5.__module__属性 ---> 获取类所在的模块对应的名字
print(Person.__module__)
print(datetime.datetime.__module__)
# 6.__bass__属性 ---> 获取当前类的父类
# 类的属性
print(Person.__bases__)
2 slots魔法
通过slots中存的元组的属性的值，来约束当前这个类的对象的属性。对象的属性只能比元组中的元素少，不能多！
class Person:
"""人类"""
__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) # AttributeError: 'Person' object has no attribute 'sex'
注意： 一旦在类中给—__slots__属性赋了值，那么这个类的对象__dict__属性就不能使用了
3 属性的私有化
首先注意：
python中并没有真正的私有化！
python的类中默认的属性和方法都是公开的。1.私有化
a.类中的属性和方法都可以通过在属性名和方法名前加两个下划线，来让属性和方法变成私有的。
b.私有的属性和方法只能在当前的类中使用2.私有化原理
在前面有两个下划线的属性名和方法名前添加了'_类名'来阻止外部通过直接访问属性名来使用属性。
例如，声明一个狗类：
class Dog:
"""狗类"""
# 字段
number = 100
__count = 200 # 这里的count就是私有化属性
def __init__(self):
# 对象的属性
self.color = '黄色'
self.age = 3
self.name = '大黄'
self.__sex = '公狗' # 私有化sex属性
# 对象方法
def eat(self):
print('%s在吃狗粮~' % self.name)
# 类方法
@classmethod
def shout(cls):
print('count：', cls.__count, Dog.__count) # 在class内部可以通过类名和cls调用
print('汪汪汪~')
# 静态方法
@staticmethod
def function():
print('看家！！')
实例化一个狗对象：
d1 = Dog()
# 在类的外面不能直接使用私有的属性
# print(Dog.__count)
# print(d1.__sex)
print(d1.__dict__)
print(d1._Dog__sex)
输出结果为：
{'color': '黄色', 'age': 3, 'name': '大黄', '_Dog__sex': '公狗'}
公狗
4 属性的getter和setter
1.保护类型的属性：
a.就只在声明对象属性的时候，在属性名前加一个下划线，来代表这个属性是受保护的属性。
那么以后访问这个属性的时候就不要直接访问，要通过getter来获取属性的值和setter来给这个属性赋值。
b.如果一个属性已经声明成保护类型的属性，那么我们就需要给这个属性添加getter。也可以添加setter2.添加getter
添加getter其实就是声明一个没有参数，有一个返回值的函数。作用是获取属性的值
a.格式：
@property
def 去掉下划线的属性名（self）：
函数体
返回值
将属性相关的值返回
b.使用场景
场景一：如果想要获取对象的某个属性的值前，想要干点别的事情，就可以给这个属性添加getter
场景二：想要拿到某个属性被使用的时刻3.添加setter
添加setter就是声明一个有一个参数但是没有返回值的函数。作用是给属性赋值
具体使用方法如下代码所示：
class Car:
"""车类"""
def __init__(self):
self.color = '黄色'
self.type = '自行车'
# _price属性是保护类型
self._price = 10000
# 给_price属性添加getter
@property
def price(self):
print('在使用_price属性')
return self._price
# 想要给一个属性添加setter，必须先给这个属性添加getter
@price.setter
def price(self, price1):
if isinstance(price1, int) or isinstance(price1, float):
self._price = str(price1) + 'K'
else:
self._price = 0
实例化一个类：
c1 = Car()
# print(c1.color, c1.type, c1._price)
#添加完getter后就通过getter去获取属性的值
# price就是属性_price的getter
print(c1.price)
c1.price = 1000
print(c1.price)
c1.price = 'abc'
print(c1.price)
输出结果为：
在使用_price属性
10000
在使用_price属性
1000K
在使用_price属性
0
5 类的继承
python中的类可以继承，并且支持多继承。
程序中的继承：就是让子类直接拥有父类的属性和方法（继承后父类中的内容不会因为被继承而减少）
-
1.继承的语法
class 子类（父类）：
类的内容
注意：如果声明类的时候没有写继承，那么这么类会自动继承python的基类，object。
相当于：class 类名（object）
python中的类都是直接或间接的继承自object -
2.能继承哪些东西
a.所有的属性和方法都能继承
b.__slots__的值不会继承，但是会影响子类对象__dict__属性。不能获取到父类继承下来的属性
具体示例如下所示，创建一个人的类作为父类：
class Person(object):
"""人类"""
# 字段
number = 16
# __slots__ = ('name', 'age')
# 对象属性
def __init__(self, name1='张三', age1=18):
self.name = name1
self.age = age1
self.__heiget = 180
# 对象方法
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类
p1 = Person()
# 创建学生类
stu1 = Student()
# 类的字段能继承
print(Student.number)
# 对象的属性能继承
print(stu1.name)
stu1.name = '李四' # 能修改
print(stu1.name)
# 对象的方法能继承
stu1.show_message()
# 类的方法能继承
stu1.show_number()
# 静态方法能继承
stu1.complaint()
stu1.sex = 'girl'
print(stu1.__dict__)
输出结果为：
16
张三
李四
姓名：李四，年龄：18
人类的数量：16
人类殴打小动物！
{'name': '李四', 'age': 18, '_Person__heiget': 180, 'sex': 'girl'}
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):
# 通过super调用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 运算符的重载
如果希望类的对象支持相应的运算符操作（例如：+、-、*、/、>、<等），就必须实现相应的魔法方法。
这个过程就叫运算符的重载。
+：__add__
>：__gt__
一般情况需要对>或者<进行重载，重载后可以通过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 'Student: %s %d %d' % (self.name, self.age, self.score)
实例化人类：
stu1 = Student('小明', 18, 90)
stu2 = Student('小红', 19, 99)
print(stu1 + stu2)
print(stu1 > stu2)
print(stu1)
输出结果为：
189
False
Student: 小明 18 90
