标签：name 继承 self 面向对象 print 父类 class
面向对象之动静态方法
@classmethod
@staticmethod
在类中的动态方法：
class 类名:
name = '倚天屠龙记'
def func1(self):
print('屠龙刀牛逼')
#在类中直接定义函数，默认绑定给对象自身，self就是本身的意思，当对象调用这个函数时，默认的第一个参数就是对象自身
@classmethod
def func2(cls):
print('倚天一出谁与争锋')
#被 @classmethod 修饰的函数，默认的参数就是这个类，类调用这个函数是，就会把类本身当作第一个参数传入
在类中的静态方法：
@staticmethod
def func3(a):
print('张无忌牛逼')
# 被@staticmethod 修饰的函数，就是默认的函数不会自动获取任何参数，不管是类还是对象调用，都必须手动传参
obj = 类名() #创建一个对象
obj.func1() #不需要传参 也可以执行，因为默认传参self 就是对象本身
类名.func1(123) # 必须传参，因为默认传参self 是对象本身 类调用还是要传参的
ojb = Dragon()
Dragon.func2()
# func2 默认传参为类本身 所以不需要传参也可以调用
ojb.func2()
# func2 默认传参为类本身 对象中也包括类 所以把产生对象的类也传进去了
ojb.func3()
Dragon.func3()
# 不管是对象还是类 调用func3 都需要传参，因为没有默认参数
面向对象之继承的概念
'''
面向对象的三大特性 ：封装 继承 多态
三者中 继承 最为核心，因为实际工作中运用次数最多，体验感也是最强
封装和多态略微抽象
'''
1.继承的含义
在现实生活中继承表示人与人之间资源的从属关系
eg:儿子继承父亲
在编程世界中继承表示类与类之间资源的从属关系
eg:类A继承类B
2.继承的目的
在现实生活中儿子继承父亲就拥有了父亲所有资源的支配权限
在编程世界中类A继承类B就拥有了类B中所有的数据和方法使用权限
3.继承的实操
class Son(Father):
pass
#这样 类 son 就可以用到 father 类中的所有方法和数据
#也支持多继承，定义类的时候 class a(b,c,d,e,f)使用逗号隔开即可
class a(b,c,d,e,f):
pass
'''
1,继承其他类的类 叫做 子类 或者 派生类
一般都叫子类 子类可以拥有父类的所有公共数据和方法
2.被继承的类叫做 父类 或者 超类
一般都叫父类
'''
继承的本质
"""
对象:数据与功能的结合体
类(子类):多个对象相同数据和功能的结合体
父类:多个类(子类)相同数据和功能结合体
ps:类与父类本质都是为了节省代码
"""
继承本质应该分为两部分
抽象:将多个类相同的东西抽出去形成一个新的类
继承:将多个类继承刚刚抽取出来的新的类
重点记忆 抽象 和 继承 的概念
变量名的查找顺序
无继承和单继承
1.在没有继承的情况下
class A1:
name = '张无忌'
def func(self):
print('来自张无忌')
obj = A1()
obj.name = '赵敏'
print(A1.name) #'张无忌' 同样的名字，类中自己拥有则优先用自己的
print(obj.name) #'赵敏' 同样的名字，对象中自己拥有则优先用自己的
"""
对象查找名字的顺序
1.先从自己的名称空间中查找，谁调用的先找谁里面有没有
2.自己没有再去产生该对象的类中查找
3.如果类中也没有 那么直接报错
对象自身 >>> 产生对象的类
"""
2. 在单继承的情况下
class A：
name = '张翠山'
class A1(A):
pass
obj = A1()
obj.name = '赵敏'
print(A1.name) # '张翠山' 类里面没有 子类没有就找父类
print(obj.name) # 自己有就用自己的 ，没有就找自己的类，
''' 对象自身 >>>> 产生对象的类 >>> 类的父类 >>> 父类的父类
从内而外 层层寻找 优先找自身
'''
class A1:
def func1(self):
print('from A1 func1')
def func2(self):
print('from A1 func2')
self.func1()
class B1(A1):
def func1(self):
print('from B1 func1')
obj = B1() #B1类产生了的对象
obj.func2() #对象本身没有 然后找产生的类B1 B1里面没有就找它的父类A1， A1里面有 就执行， print('from A1 func2')，和 self.func1()
# self = 对象本身， 那就又回到了obj, boj没有找B1 B1有就执行print('from B1 func1')
'''
使用 对象.名字的方法，永远都是从对象自身开始一步步查找的
self指代的就是一个对象，一定要搞清楚 self指代的是哪个对象
'''
多继承查找顺序
class G:
name = 'from G'
pass
class A:
# name = 'from A'
pass
class B:
# name = 'from B'
pass
class C:
# 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)
# print(S1.mro())
# 找名字顺序 ojb >>> S1 >>> D >>> A >>> E >>> B >>> F >>> C
对象自身 >>> 产生对象的类 >>> 父类(从左往右)
3.多继承情况下名字的查找顺序
'''
菱形继承
广度优先(最后才会找闭环的定点)
非菱形继承
深度优先(从左往右每条道走完为止)
ps:mro()方法可以直接获取名字的查找顺序
'''
经典类与新式类
经典类：不继承object或者其子类的类
新式类:继承object或者其子类的类
在python2中有经典类和新式类
在python3中只有新式类(所有类默认都继承object)
现在基本都是python3了
这也是python2与python3的区别
python3中 所有的类都默认带有 object
Python2中 需要手动加上 object
class A1(object):
pass
派生方法
派生方法就是子类基于父类某个方法做的扩展
关键词 super()
class Person:
def __init__(self,name,age)
self.name = name
self.age = age
class Student(Person):
def __init__(self,name,age,gender)
super().__init__(name,age)
self.sid = sid
# 如果在子类中需要调用父类的方法 需要用到关键词 super().的方式把父类方法先复制过来，然后在加入新的参数
class Teacher(Person):
def __init__(self,name,age,level)
super().__init__(name,age)
self.level = level
#super(). 可以调用父级方法
标签：name,
继承,
self,
面向对象,
print,
父类,
class
From： https://www.cnblogs.com/moongodnnn/p/16855564.html