01-内置类属性
内置类属性就是魔法属性
魔法属性：属性名的前面和后面都有两个下划线
魔法方法：方法的前后都有两个下划线
使用实例：
# 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(p2.name, my_class.__name__)
# 3.__dict__属性 --- 将对象属性及其对应的值转换成键值对存到一个字典中
# print(Person.__dict__)
print(p1.__dict__) # {'name': '张三', 'age': 28, 'height': 170}
# 4.__doc__属性 --- 获取类的说明文档
# 类的属性
doc = Person.__doc__
print(doc)
# 5.__module__属性 --- 获取类所在的模块对应的名字
print(Person.__module__)
print(datetime.datetime.__module__)
# 6.__bases__属性 --- 获取当前类的父类
# 类的属性
print(Person.__bases__)
2、通过
“__slots__”中存的元素的属性的值来约束当前这个类的对象的属性。对象的属性只能比元祖中的元素少，不能多！
注意：一旦在类中给__slots__属性赋了值，那么这个类的对象的__dict__属性就不能使用了.
02-属性的私有化
python中并没有真正的私有化！
python的类中默认的属性和方法都是公开
1.私有化
a.类中的属性和方法都可以通过在属性名和方法名前加两个下划线，来让属性和方法变成私有的。
b.私有的属性和方法只能在当前的类中使用
2.私有化原理
在前面有两个下划线的属性名和方法名前添加了'_类名'来阻止外部通过直接访问属性名来使用属性
class Dog:
# 字段
number = 100
__count = 200
def __init__(self):
# 对象的属性
self.color = '黄色'
self.age = 3
self.name = '大黄'
self.__sex = '公狗'
# 对象方法
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('汪汪汪~~~')
@classmethod
def __shout(cls):
print('count:', cls.__count, Dog.__count)
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) # AttributeError: type object 'Dog' has no attribute '__count'
# print(dog1.__sex) # AttributeError: 'Dog' object has no attribute '__sex'
# dog1.__eat()
# Dog.__shout()
#
print(dog1._Dog__sex)
print(dog1.__dict__)
03-属性的getter和setter
1.保护类型的属性：
a.就是在声明对象属性的时候在属性名前加一个下划线来代表这个属性是受保护的属性。
那么以后访问这个属性的时候就不要直接访问，要通过getter来获取这个属性的值，setter来给这个属性赋值.
b.如果一个属性已经声明称保护类型的属性，那么我们就需要给这个属性添加getter。也可以添加setter
2.添加getter
添加getter其实就是声明一个没有参数有一个返回值的函数。作用是获取属性的值
a.格式:
@property
def 去掉下滑线的属性名(self):
函数体
将属性相关的值返回
b.使用场景
场景一：如果想要获取对象的某个属性的值之前，想要再干点儿别的事情（做额外的处理）。就可以给这个属性添加getter
场景二：想要拿到某个属性被使用的时刻
3.添加setter
添加setter就是声明一个有一个参数但是没有返回值的函数。作用是给属性赋值
a.格式
b.使用场景
在给属性赋值前想要再干点儿别的实行，就给属性添加setter
实例：
class Car:
def __init__(self):
self.color = '黄色'
self.type = '自行车'
# _price属性是保护类型
self._price = 2000
# 给_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
# 练习：声明一个员工类，其中有一个属性是是否已婚（bool），获取值之前根据存的值返回'已婚'/'未婚'
class Staff:
def __init__(self, name, salary):
self.name = name
self.salary = salary
self._is_marry = False
@property
def is_marry(self):
if self._is_marry:
return '已婚'
return '未婚'
@is_marry.setter
def is_marry(self, marry):
self._is_marry = marry
staff1 = Staff('张三', 10000)
print(staff1.is_marry)
staff1.is_marry = True
print(staff1.is_marry)
04-继承
python中类可以继承，并且支持多继承。
程序中的继承：就是让子类直接拥有父类的属性和方法（继承后父类中的内容不会因为被继承而减少）
1.继承的语法
class 子类(父类):
类的内容
注意：如果声明类的时候没有写继承，那么这个类会自动继承python的基类，object；相当于class 类名(object):
python中所有类都是直接或者间接的继承自object
2.能继承哪些东西
a.所有的属性和方法都能继承
b.slots的值不会继承，但是会影响子类对象的dict属性。不能获取到父类继承下来的属性
05-方法的重写
子类继承父类，拥有父类的属性和方法以后，还可以再添加自己的属性和方法
1.添加方法和类的字段
直接在子类中声明相应的方法和字段
2.添加对象属性
对象的属性是通过继承父类的init方法而继承下来
如果想要在保留父类的对象的同时添加自己的对象属性，需要在子类的init方法中通过super()去调用父类的init方法
3.方法的重写
在子类中重新实现父类的方法，就是重写
方式一: 直接覆盖父类的实现
方式二: 保留父类的功能再添加其他功能
4.类中方法的调用过程（重点）
先在当前这个中的去找，没有去父类中找，找不到再去父类的父类中找，依次类推，如在基类中都没有找到才崩溃。
在第一次找到的位置，去调用
注意：使用super的时候必须是通过super()来代替父类或者是父类对象
实例：
class Animal:
"""动物类"""
number = 100
def __init__(self):
self.age = 0
self.sex = '雌'
def shout(self):
print('嗷嗷叫')
def eat(self):
print('吃东西')
class Cat(Animal):
"""猫类"""
def __init__(self):
# 调用父类的init方法
super().__init__()
self.name = '小花'
foot = '鱼'
def shout(self):
print(super())
print('喵喵~')
class Dog(Animal):
"""狗类"""
def shout(self):
# 通过super()调用父类的方法，保留父类的功能
super().shout()
print('汪汪!!')
# pass
cat1 = Cat()
print(cat1.age)
print(cat1.name)
cat1.shout()
dog1 = Dog()
dog1.shout()
06-init方法的重写
如果希望类的对象支持相应的运算符操作(例如：+, -, *, /, >, <等)，就必须实现相应的魔法方法。
这个过程就叫运算符的重载
+: __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 '<%s.%s object at 0x%x>' % (self.__module__, self.__class__.__name__, id(self))
# return 'Student: %s %d %d' % (self.name, self.age, self.score)
return str(self.__dict__)[1:-1]
class Schoolchild(Student):
def __add__(self, other):
return self.age + other.age
if __name__ == '__main__':
stu1 = Student('小明', 18, 90)
stu2 = Student('老王', 29, 84)
stu3 = Student('小花', 20, 78)
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)
print(stu3 > stu1)
# 父类重载了运算符，子类也能用
c1 = Schoolchild('小明明', 8, 70)
c2 = Schoolchild('小花花', 10, 67)
print(c1+c2)
