面向对象
1.类的继承
a.什么是继承
父类（超类）：被继承的类
子类：去继承父类的类
继承就是然子类直接拥有父类的属性和方法（注意：继承后父类的东西不会减少）
python中所有的类都是直接或者间接的继承自object
b.怎么继承
class 类名（父类）：...
class 类名 == class 类名(object)
c. 能继承那些东西
对象属性、对象方法、类的字段、
类方法、静态方法都可以继承
注意：如果设置了 __slots__会约束当前类的对象属性个数；并且会导致当前类的对象的 __dict__属性不存在；继承后， __slots__的值不会约束到子类的对象属性，但是会导致子类对象的 __dict__只会有当前在类中添加的属性。
num = 63
def __init__(self, name = '小明', age = 18):
self.name = name
self.age = age
self.__sex = 'boy'
def eat(self, food:str):
print('%s在吃%s!'%(self.name, food))
@staticmethod
def func1():
print('静态方法')
@classmethod
def show_num(cls):
print('人类数量：%s亿' % cls.num)
class Student(Person):
def __init__(self):
super().__init__()
self.score = 100
# 创建Person对象
p1 = Person()
# p1.id = '001'
# 创建Student对象
stu1 =Student()
print(Student.num) # 63
Student.show_num() # 人类数量：63亿
Student.func1() # 静态方法
print(stu1.__dict__) # {'name': '小明', 'age': 18, '_Person__sex': 'boy', 'score': 100}
2.重写
a.添加新的方法
直接在子类中声明的新的方法，新的方法只能通过子类来使用
b.重写
1.子类继承父类的方法，在子类中去重新实现这个方法的功能 --完全重写
2.在子类方法中通过super().父类方法去保留父类对应的方法功能
c.类中函数的调用过程
类.方法，对象.方法()
先看当前类是否有这个方法，如果有就直接调用当前类中相应的方法；
如果没有就去当前类的父类中去看有没有这个方法，如果有就调用父类的方法
如果父类中也没有这个方法，就去父类的父类中找，依次类推直到找到为止。
如果找到基类object还没有找到这个方法，程序才会报异常。
class Person:
def __init__(self, name='sss'):
self.name = name
def eat(self, food):
print('%s再吃%s'%(self.name, food))
@staticmethod
def run():
print('人在跑步')
@classmethod
def get_up(cls):
print('======')
print('洗漱')
print('换衣服')
class Student(Person):
def study(self):
print("%s在学习" % self.name)
def eat(self, food):
# super():当前类的父类的对象
print('对象方法：', super())
super().eat(food)
print('喝一杯牛奶!')
@staticmethod
def run():
print('学生在跑步')
@classmethod
def get_up(cls):
# super() -->获取当前类的父类
# super() -->调用父类的get_up方法
print('类方法：', super())
super().get_up() # 保留父类get_up的功能
# cls.__bases__[0].get_up()
print('背书包')
p1 = Person()
Person.run() # 人在跑步
Person.get_up()
# ======
# 洗漱
# 换衣服
p1.eat('面条') # sss再吃面条
stu1 = Student()
stu1.study() # sss在学习
stu1.eat('蛋糕') # 对象方法： <super: <class 'Student'>, <Student object>> # sss再吃蛋糕 # 喝一杯牛奶!
Student.run() # 学生在跑步
Student.get_up()
# 类方法： <super: <class 'Student'>, <Student object>>
# ======
# 洗漱
# 换衣服
# 背书包
3.添加属性
a.添加字段
就直接在子类中声明新的字段。
b.添加对象属性
子类是通过继承父类的init方法来继承的父类的对象属性
class Car:
def __init__(self, color='黑色'):
self.color = color
self.price = 10
num = 10
class SportsCar(Car):
# 修改字段
num = 8
# 添加字段
wheel_count = 4
# 给子类添加新的对象属性
def __init__(self, color, power):
# self = sp1
# 通过super()去调用父类的init方法，用来继承父类的对象属性
super().__init__(color) # Car对象.__init__('蓝色')
self.power = power
print(Car.num) # 10
print(SportsCar.num, SportsCar.wheel_count) # 8 4
# 当子类没有中没有声明init方法，通过子类的构造方法创建对象的时候会自动调用父类的init方法
c1 = Car('红色')
print(c1.color) # 红色
sp1 = SportsCar('蓝色', 25)
print(sp1.color) # 蓝色
print(sp1.power) # 25
print(sp1.price) # 10
4.运算符的重载
通过实现类响应的魔法方法，让类的对象支持相应的运算符
import copy
import random
class Student:
def __init__(self, name, age, score):
self.name =name
self.age = age
self.score = score
# __gt__就是>对应的魔法方法
def __gt__(self, other):
# self -> 指的是大于符号前面的值，
# other -> 指的是大于符号后面的值
return self.name > other.name
def __add__(self, other):
return [self.name, other.name]
def __mul__(self, other: int):
re = []
for stu in range(other):
re.append(copy.copy(self))
return re
def __repr__(self):
return str(self.name)
# __gt__就是>对应的魔法方法
# 注意：gt和lt只需要实现一个就可以了
stu1 = Student('ss', 88, 100)
stu2 = Student('rr', 80, 148)
print(stu1 > stu2) # True
print(stu1+stu2) # ['ss', 'rr']
students = stu1 * 5
print(students)# [ss, ss, ss, ss, ss]
students[0].name = '小明'
print(students) # [小明, ss, ss, ss, ss]
class Person:
def __init__(self, name='张三', age=0):
self.name = name
self.age = age
def __mul__(self, other: int):
result = []
for _ in range(other):
result.append(copy.copy(self))
return result
def __gt__(self, other):
return self.age > other.age
# 定制打印方式
def __repr__(self):
return str(self.__dict__)[1:-1]
# 同时创建10人的对象
persons = Person()*10
# print(persons)
for p in persons:
p.age = random.randint(15, 50)
print(persons)# ['name': '张三', 'age': 15, 'name': '张三', 'age': 47, 'name': '张三', 'age': 44, 'name': '张三', 'age': 36]
# 列表的元素是类的对象，使用sort对列进行排序
persons.sort()
print(persons)
#['name': '张三', 'age': 15, 'name': '张三', 'age': 36, 'name': '张三', 'age': 44, 'name': '张三', 'age': 47]
print(max(persons)) #'name': '张三', 'age': 47
5.内存管理机制
a.
python中内存管理 --->自动管理--->垃圾回收机制
内存结构中有分栈区间和堆区间，栈区间中内存是系统自动开辟自动释放。堆区间的内存需要大量手动申请手动释放
a(栈区间) = 10(堆区间)
python中的数据都是存在堆中的，数据对应的地址都是在栈区间
python中垃圾回收机制是用来管理堆中的内存的释放
python中将值赋给变量的时候，会现在堆中开辟空间将数据存起来，然后再将数据对应的地址返回给变量，存在栈中
如果数据是数字和字符串，会在缓冲区中查看这个数据之前是否已经创建过，如果没有，就去创建空间存数据，然后将地址返回，如果之间已经创建过就直接将之前的地址返回
b.内存的释放--->垃圾回收机制
系统每隔一定的时间就会去检测当前程序中，所有的对象的引用计数是否为0，如果对象的引用计数值为0对象对应的内存就会被销毁，不是0就不销毁
c.引用计数值
每一个对象都有引用计数属性，用来存储当前对象被引用的次数。
可通过sys模块中的getrefcount获取一个对象引用的计数值
from sys import getrefcount
a =10
b = 10
c = 10
print(id(a), id(b), id(c))
aaa = [1, 2, 3]
print(getrefcount(aaa)) # 2
# 增加引用计数:增加引用（郑家保存当前对象地址的变量的个数）
a1 = ['abc']
b1 = a1
list1 = [a1, 100]
print(getrefcount(a1)) # 4
# 2.减少引用计数
del b1 # 删除存储对象地址的变量
print(getrefcount(a1)) # 3
list1[0] = 10
print(getrefcount(a1)) # 2
