- 动静态方法
- 面向对象之继承理论
- 继承基本操作
- 对象查找名字的顺序（非常重要）
- 继承本质
- 基于继承的派生方法（重要）
动静态方法
1.绑定给对象的方法
# 类中定义的函数有多种特性
class Student:
school_name = '清华大学'
# 1.类中直接定义函数，默认绑定给对象，类调用有几个参数传几个，对象调用第一个参数就是对象自身
def func1(self):
print('看看谁的学校最好')
obj = Student() # 类加括号生成一个对象赋值给obj
obj.func1() # obj直接调用产生自己类中的函数，直接把自己地方第一个参数传入
Student.func1(123) # 类调用自己内部函数，需要传进一个参数
2.绑定给类的方法
class Student:
school_name = '摆烂大学'
"""
被classmethod装饰的函数，默认绑定给类，类调用第一个参数就是类本身，类产生的对象也可以调用
并且自动会将产生该对象的类当做第一个参数传入
"""
@classmethod
def func2(cls):
print('猜猜这是谁',cls)
obj = Student() # 产生一个对象
Student.func2() # 类用点的方式调用内部函数，被classmethod装饰不需要传参
obj.func2() # 类产生的对象也直接点调用，会把产生对象的类，自动传入
3.静态方法
class Student:
school_name = '摆烂大学'
"""
被staticmethod修饰的就是普通的函数，无论是类还是对象调用，都必须自己手动传参
"""
@staticmethod
def func3(a):
print('猜猜这又是谁',a)
obj = Student()
obj.func3(1) # 猜猜这又是谁 1
Student.func3(2) # 猜猜这又是谁 2
面向对象之继承的概念
"""
面向对象三大特性
分装、继承、多态
1.三者中继承最为核心（实操最多，体验感最强）
2.封装和多胎略微抽象
"""
1.继承的含义
在现实生活中继承表示人与人之间资源的从属关系
eg：儿子继承父亲
在编程世界中继承表示类与类之间资源的从属关系
eg：类A继承类B
2.继承的目的
在编程世界中类A继承类B就拥有了类B中所有的数据和方法使用权限
3.继承的实操
class Son(Father):
pass
1.在定义类的时候类名后面可以加括号填写其他类名，以为着继承其他类
2.在python支持多继承，括号内填写多个类名彼此逗号隔开即可
class Son(F1,F2,F3):pass
"""
1.继承其他类的类 son
我们称之为子类、派生类
2.被继承的类 Father，F1,F2,F3
我们称之为父类，基类，超类
ps：我们最常用的就是父类和子类
"""
继承的本质
"""
对象：数据与功能的结合体
类（子类）：多个对象相同数据和功能的结合体
父类：多个类（子类）相同数据和功能结合体
ps：类与父类本质都是为了节省代码
"""
继承本质应该分为两部分
抽象：将多个类相同的东西抽出去行程一个新的类
继承：将多个类继承刚刚取出来的新的类
名字的查找顺序
1.不继承情况下名字的查找顺序
class C1:
name = 'jason'
def func(self):
print('from func')
obj = C1() # 生成一个对象
print(obj.name) # 在对象obj查找name的名字，自己局部没有去类中找jason
obj.name = 'kevin' # 在obj的名称空间创建独有的名字
print(obj.name) # 对象先在自己局部空间去找kevin
print(C1.name) # 类C1在自己局部名称空间找name jason
"""
对象查找名字的顺序：
1.先从自己的名称空间中查找
2.自己没有再去产生对象的类中查找
3.如果类中也没有，那么直接报错
对象自身>>>> 产生对象的类
"""
2.单继承情况下名字的查找顺序
class F1:
name = 'jason'
class S1(F1):
name = ' kevin'
obj = S1() # 调用类S1产生一个对象
print(obj.name)
"""
对查找名字的顺序:
对象自身>>> 产生对象的类>>>> 父类
"""
class F3:
name = 'jerry'
pass
class F2(F3):
name = 'tony'
pass
class F1(F2):
name = 'jason'
pass
class S1(F1):
name = 'kevin'
pass
obj1 = S1()
obj1.name = '嘿嘿嘿'
print(obj1.name)
class A1:
def func1(self):
print('from A1 func1')
def func2(self):
print('from A1 func2')
self.func1() # 这里seif指代的B1生成的对象obj，obj.func1（）
# 首先在自身，再找产生他的B1类里面，所以调用的是 B1的func1()
class B1(A1):
def func1(self):
print('from B1 func1')
obj = B1()
obj.func2()
"""
强调：对象名字，永远从对象自身开始一步步查找
以后在看到self.名字的时候，一定要搞清楚self指代的是哪个对象
"""
3.多继承情况下名字的查找顺序
菱形继承
广度悠闲，最后再会找到闭环的定点
class G:
name = 'from G'
pass
class A(G):
# name = 'from A'
pass
class B(G):
# name = 'from B'
pass
class C(G):
# name = 'from C'
pass
class D(A):
# name = 'from D'
pass
class E(B):
# name = 'from E'
pass
class F(C):
# name = 'from F'
pass
class S1(D, E, F):
pass
obj = S1()
print(obj.name)
"""
名字查找顺序：
对象自身 >>> 产生对象的类 >>> 父类（从左到右，最终到闭环的起点）
"""
2.非菱形继承
深度优先（从左往右每条道从完为止）
class F1:
name = 'jason'
pass
class F2:
name = 'oscar'
pass
class F3:
name = 'jerry'
pass
class S1(F1, F2, F3):
name = '嘿嘿嘿'
pass
obj = S1()
print(obj.name)
"""
名字查找顺序
对象自身 >>> 产生对象的类 >>> 父类（从左往右）
"""
mro()方法可以直接获取名字的查找顺序
经典类与新式类
"""
经典类：不继承object或者其子类的类
新式类：继承object或者其他子类的类
在python2中有经典类和新式类
在python3中只有新式类（所有默认都继承object）
"""
class Student(object):pass
这句话表示在定义类的时候，没有其他明确的父类，习惯写上object可以兼容python2
派生方法
子类基于父类某个方法做了扩展
class Person:
def __init__(self, name, age, gender):
self.name = name # 表示在类生成的对象中添加对象独有的数据
self.age = age
self.gender = gender
class Student(Person): # 子类Student，父类Person
# 想要在子类中给父类的方法添加数据
def __init__(self, name, age, gender, sid):
super().__init__(name, age, gender) # 这里表示继承父类的功能，关键字super
self.sid = sid # 表示在子类里面添加自己独有的方法
class Tercher(Person):
def __init__(self, name, age, gender, lever):
super().__init__(name, age, gender)
self.level = lever
sth1 = Student('jason', 18, 'male', 666)
print(sth1.__dict__) # {'name': 'jason', 'age': 18, 'gender': 'male', 'sid': 666}
tea1 = Tercher('tony', 28, 'female', 99)
print(tea1.__dict__) # {'name': 'tony', 'age': 28, 'gender': 'female', 'level': 99}
派生方法的实战
class My_list(list): # 父类是列表
def append(self, values): # 在子类里面定义一个append方法
if values == 'jason':
print('jason不能尾部追加')
return
super().append(values) # 继承父类中append方法
obj = My_list()
print(obj, type(obj)) # 继承了父类列表，子类生成的对象也是列表
obj.append(111)
obj.append(222)
print(obj) # [111, 222]
obj.append('jason')
print(obj) # # jason不能尾部追加