动静态方法与继承

本文主要是介绍动静态方法与继承，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

对象独有的功能

class Student:
    school = '霍格沃兹魔法学院'

    def __init__(self, name):
        self.name = name  # 对象的独有的数据

    def est(self):  # 对象调用时会将对象当做第一个参数传入
        print('%s正在看魁地奇比赛' % self.name)


res1 = Student('harry')
res1.est()
# harry正在看魁地奇比赛
res2 = Student('hermione')
res2.est()
# hermione正在看魁地奇比赛
'''
对对象独有的方法，无法实现，在全局中不是独有的，在类中则是公共的
python解释器有一个特性，定义在类中的函数是绑定给对象的，相当于对象的独有方法
'''

动静态方法

'''
在类体代码中编程的函数
1.要绑定给对象的方法，就直接在类体代码中编程，对象调用时会自动将对象当第一个参数传入，类调用时有几个形参就传几个实参
2.静态方法就只是普通的函数
'''
class Student:
    school = '霍格沃兹魔法学院'

    def __init__(self):  # self用于接收对象
        print('开始喽', self)

    @classmethod  # 绑定给类的方法
    def est(cls):  # cls用于接收对象
        print('正在看魁地奇比赛', cls)

    @staticmethod  # 静态方法
    def run(a, b):  # 调用时必须按照函数的传参要求
        print('溜了溜了')


res1 = Student()
# 开始喽 <__main__.Student object at 0x000002399E2EF190>
Student.est()
# 正在看魁地奇比赛 <class '__main__.Student'>
res1.est()
# 正在看魁地奇比赛 <class '__main__.Student'>
Student.run(1, 2)
# 溜了溜了
res1.run(1, 2)
# 溜了溜了

面向对象三特性之继承

'面向对象三大特性分别是：继承、封装、多态'
1.继承的含义
在编程的数据里继承是用来描述类与类之间数据的关系，如a继承了b，则a拥有了b的所有数据和功能
2.继承的目的
在编程的数据里继承可以帮我们节省代码的编写，且一个类可以继承多个类
3.继承的操作
class 子类名(父类名):
    pass
'''
1.定义类名时在类名后面加括号，括号内填写需要继承的类名，如果要继承多个类名，可以用逗号隔开
2.类的称呼
被继承的类称为：父类或基类或超类
继承的类称为：子类或派生类
'''

继承的本质

1.抽象：将多个类共同的数据或功能抽取出来形参一个父类
2.继承：一层一层的获取父类里的资源
'''
对象:数据和功能的结合体
类:多个对象相同的数据和功能的结合体
父类:多个类相同的数据和功能的结合体
'''

名字的查找顺序

1.不继承的情况下查找名字的顺序
class Student:
    school = '霍格沃兹魔法学院'

    def est(self):  # cls用于接收对象
        print('正在看魁地奇比赛')


res = Student()
print(res.school)
# 霍格沃兹魔法学院
res.school = '德姆斯特朗魔法学院'  # 对象点名字是在自身的名称空间中产生了新的school
print(res.school)
# 德姆斯特朗魔法学院
print(Student.school)
# 霍格沃兹魔法学院
'先在对象自身查找，若没有，再去产生该对象的类中查找'

2.单继承情况下名字的查找顺序
class A:
    name = 'from A'
	 pass

class B(A):
    name = 'from B'
	 pass

class C(B):
    name = 'from C'
	 pass

odj = C()
# odj.name = 'from odj'
print(odj.name)
# 查找顺序:from odj>>>from C>>>from B>>>from A
'先在对象自身查找，若没有，再去产生该对象的类中查找,若还是没有，则去类的父类中查找...'

3.多继承的情况下名字的查找顺序
3.1非菱形继承
class A:
    name = 'from A'
    pass

class B:
    name = 'from B'
    pass

class C(B):
    name = 'from C'
    pass

class D(A):
    name = 'from D'
    pass

class E(D, C):
    name = 'from E'
    pass

odj = E()
# odj.name = 'from odj'
print(odj.name)
# 查找顺序:from odj>>>from E>>>from D>>>from A>>>from C>>>from B
'非菱形继承是深度优先，它是将类的每个分支走到底，在换下一分支'

3.2菱形继承
class F:
    name = 'from F'
    pass

class A(F):
    name = 'from A'
    pass

class B(F):
    name = 'from B'
    pass

class C(B):
    name = 'from C'
    pass

class D(A):
    name = 'from D'
    pass

class E(D, C):
    name = 'from E'
    pass

odj = E()
# odj.name = 'from odj'
print(odj.name)
# 查找顺序:from odj>>>from E>>>from D>>>from A>>>from C>>>from B>>>from F
'菱形继承是广度优先，它是走完全部分支在走最后一个父类'

经典类与新式类

经典类：不继承object或其子类的类
新式类：继承了object或其子类的类
'''
在python3.X中所有的类都是默认继承object，所以python3.X里只有新式类
在python2.X中有经典类和新式类

为了兼容python2.X，在定义的时候，如果没有要继承的父类，可以写成：
class 子类名(object):
    pass

写代码时对object无需关心，知道它是什么就可以了
'''

派生方法

'''
调用父类可以获得父类的功能和数据，但子类要扩展新的数据和功能，就需要用到派生方法
'''

class School:
    def __init__(self, name, age):
        self.name = name
        self.age = age


class Student(School):
    def __init__(self, name, age, location):
        # School.__init__(self, name, age)  # 子类调用父类的方法
        super().__init__(name, age)  # super是专门用与子类调用父类的方法
        self.location = location  # 调用后在加上这个身份特有的数据


class Teacher(School):
    def __init__(self, name, age, course):
        # School.__init__(self, name, age)
        super().__init__(name, age)
        self.course = course


res1 = Student('harry', 18, '找球手')
print(res1.name)  # harry
print(res1.age)  # 18
print(res1.location)  # 找球手
res2 = Teacher('snape', 38, '魔药学')
print(res2.name)  # snape
print(res2.age)  # 38
print(res2.course)  # 魔药学

'派生方法可以让我们在用父类时通过super()增加功能'
class MYClasss(list):
    def append(self, age):
        if age == 'harry':
            print('harry不能加入列表')  # harry不能加入列表
            return
        super().append(age)


obj = MYClasss()
obj.append(110)
obj.append(120)
obj.append('harry')
obj.append(119)
print(obj)  # [110, 120, 119]

这篇关于动静态方法与继承的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！