super方法简要说明,面向对象的编程

上边举二个例子,同样的代码应用 python2 和 python3 写的,大家在意两段程序中北京蓝加粗的一些:

@(python)

python 同一时候扶植面向对象编制程序和函数式编制程序的言语
python面向对象的主题围绕 类实例 四个大旨。
面向对象三大特色:封装继承多态

python2的类承继使用super方法:

super(type, obj)

子类中定义了同父类同名的函数后,要求体现调用父类函数时,能够透过 super,也足以向来通过父类名,提出选择super,比方在早先化函数中调用父类早先化方法,非常在多重承接的地方下
探问例子:

#!/usr/bin/env python
# coding=utf-8

class A:
    def __init__(self):
        print("Enter A")
        super(A, self).__init__()
        print("Leave A")

class B:
    def __init__(self):
        print("Enter B")
        #super(B, self).__init__()
        print("Leave B")

class CA(A):
    def __init__(self):
        print("Enter CA")
        super(CA,self).__init__()
        print("Leave CA")


class CAA(CA, A):
    def __init__(self):
        print("Enter CAA")
        super(CAA,self).__init__()
        print("Leave CAA")

class CB(B):
    def __init__(self):
        print("Enter CB")
        B.__init__(self)
        print("Leave CB")


class CBB(CB, B):
    def __init__(self):
        print("Enter CBB")
        CB.__init__(self)
        B.__init__(self)
        print("Leave CBB")


if __name__ == "__main__":
    print("- New Object CAA")
    caa = CAA()
    print("- New Object CBB")
    cbb = CBB()

上述列子中,两组类关系:
CAA->CA->A 采取 super 调用父类函数
CBB->CB->B 直接通过父类名调用其行数

对照运营结果

lcd@ubuntu:~/learn/python$ python3 supper_class.py 
- New Object CAA
Enter CAA
Enter CA
Enter A
Leave A
Leave CA
Leave CAA
- New Object CBB
Enter CBB
Enter CB
Enter B   
Leave B
Leave CB
Enter B   -->重复调用了
Leave B
Leave CBB

能够见到,使用super, python 不仅保障后续时按顺序调用父类初阶化,况兼保险每三个类不被再次调用。

概念

1.目的:类的实例。对象具有两特性状:状态与作为。
2.类:用来呈报具备同等的属性和议程的靶子的集纳,类的结合=方法 行为
3.浮泛:对具体世界难点和实业的真相表现,行为和特征建立模型,营造二个有关的子集,能够用来描述程序结构,进而达成这种模型。
4.封装:对品质和章程的载体类,只好通过其提供的接口(方法)来拜候,而把达成细节掩饰起来.python的类属性都是当面包车型客车。
5.承接:描述了子类属性从祖先类承袭那样一种方法。
6.多态:同一消息能够依附发送对象的差别而使用八种分裂的行为艺术。

 1 #-*-  coding:utf-8 -*-
 2 '''
 3 Created on 2018年8月27日
 4 
 5 @author: anyd
 6 '''
 7 import random as r
 8 
 9 class Fish(object):
10     def __init__(self):
11         self.x = r.randint(0, 10)
12         self.y = r.randint(0, 10)
13             
14     def move(self):
15         #这里主要演示类的继承机制,就不考虑检查场景边界和移动方向的问题
16         #假设所有鱼都是一路向西游
17         self.x -= 1
18         print "我的位置是:", self.x, self.y
19 
20 class Goldfish(Fish):
21     pass
22 
23 class Carp(Fish):
24     pass
25 
26 class Salmon(Fish):
27     pass
28 
29 #上边几个都是食物,食物不需要有个性,所以直接继承Fish类的全部属性和方法即可
30 #下边定义鲨鱼类,这个是吃货,除了继承Fish类的属性和方法,还要添加一个吃的方法
31 
32 class Shark(Fish):
33     def __init__(self):
34         super(Shark,self).__init__()       
35         self.hungry = True
36 
37     def eat(self):
38         if self.hungry:
39             print "吃货的梦想就是天天有的吃^_^"
40             self.hungry = False
41         else:
42             print "太撑了,吃不下了!"
43             
44 aa = Shark()
45 aa.move()

classsmethod

python 有三种情势定义类方法:
如下边例子类 A 定义的多少个方法,

  • 常规办法定义了 foo,同对象实例绑定,通过对象调用的时候,会因此隐式 self 参数字传送递类对象实例子;若是直接通过类调用,须求出示传递类实例;
  • @classmethod 格局定义了 class_foo 方法,同类绑定,能够直接通过类名能够从来调用,调用时经过 cls 隐式参数字传送递类对象。
  • @staticmethod 格局定义的法子和经常函数同样,未有绑定对象,未有传递隐式参,能够经过类实例只怕类调用。(属于类的函数,但是无需访谈类,通过一连子类覆盖,更加好地协会代码)
#!/usr/bin/env python
# coding=utf-8
# by orientlu

class A(object):
    def __init__(self):
        print("A init")
        super().__init__()

    def foo(self, x):
        '''绑定对象'''
        print("A exec foo (%s, %d)" %(self, x))

    @classmethod
    def class_foo(cls, x):
        '''绑定类'''
        print("exec class_foo (%s, %d)" %(cls, x))

    @staticmethod
    def static_foo(x):
        '''没有绑定类,对象'''
        print("exec static_foo (%d)" %(x))

class B(object):
    def foo(self, x):
        '''绑定对象'''
        print("exec foo (%s, %d)" %(self, x))

    @classmethod
    def test_class_foo(cls, x):
        '''绑定类'''
        print("exec test_class_foo -2- (%s, %d)" %(cls, x))

    def test_class_foo(self, x):
        '''后面方法覆盖前面的同名方法'''
        print("exec test_class_foo -1- (%s, %d)" %(self, x))


class AA(A):
    def __init__(self):
        print("AA Int")

    def foo(self, x):
        '''覆盖了父类函数'''
        print("AA exec foo (%s, %d)" %(self, x))


class C(AA):
    def __init__(self):
        '''子类定义了方法覆盖了父类,通过super调用到父类函数'''
        super().__init__()
        print("C init")

    def c_fun1(self):
        '''子类没有定义的函数,直接调用父类函数'''
        self.foo(1)

if __name__ == "__main__":

    print("***********************************")
    print("-------")
    a = A()
    a.foo(1)
    a.class_foo(1)
    a.static_foo(1)

    print("-------")
    A.foo(a, 1)
    A.class_foo(1)
    A.static_foo(1)

    print("***********************************")
    b = B()
    b.test_class_foo(1)
    # 以下调用出错,因为classmethod被后面的函数所覆盖了
    #B.test_class_foo(1)
    # 实际存在是后面定义的函数
    B.test_class_foo(b, 1)

    print("***********************************")
    c = C()
    c.c_fun1()

上述代码在 python3 意况下运维的输出 :

***********************************
-------
A init
A exec foo (<__main__.A object at 0x7f6af4c36ac8>, 1)
exec class_foo (<class '__main__.A'>, 1)
exec static_foo (1)
-------
A exec foo (<__main__.A object at 0x7f6af4c36ac8>, 1)
exec class_foo (<class '__main__.A'>, 1)
exec static_foo (1)
***********************************
exec test_class_foo -1- (<__main__.B object at 0x7f6af4c36b38>, 1)
exec test_class_foo -1- (<__main__.B object at 0x7f6af4c36b38>, 1)
***********************************
AA Int
C init
AA exec foo (<__main__.C object at 0x7f6af4c36b70>, 1)
创建类

python 类是应用class关键词来成立,即注重词 类名

class ClassName():
    class_suit 
  • class_suit(类实体由类成员、方法、数据属性组成)
  • 类中的函数第三个参数必得是self,
  • 类分为特出类和新式类(要是当前类可能父类承袭了object类,那么该类就是新式类,不然就是精湛类。未来逐年推荐用前卫类写)
![](https://upload-images.jianshu.io/upload_images/994436-2e4347e91097c500.png)

QQ20170709-223954@2x.png

输出如下:

类的成员、成员修饰符、类的非正规成员

图片 1

Paste_Image.png

class Province:
    country = '中国'                     # 静态字段
    def __init__(self, name):
        self.name = name                 # 普通字段

obj = Province('河北省')                 # 直接访问普通字段
print obj.name
Province.country                        # 直接访问静态字段

图片 2

Paste_Image.png

由上海教室可是:
静态字段在内部存款和储蓄器中只保留一份
日常字段在各个对象中都要封存一份
运用场景: 通过类创建对象时,假使各个对象都持有同样的字段,那么就使用静态字段

措施:普通方法、静态方法和类措施,二种方式在内存中都名下于类,不同在于调用格局分化。

class E():
    i=1
    def run(self):
         E.i  =1
         print('{0} is run ordinary method'.format(E.i))
    @staticmethod
    def eat():
        E.i  =1
        print('{0} is eat static method'.format(E.i))
    @classmethod
    def fool(cls):
        E.i  =1
        print('{0} is fool class method '.format(E.i))

e = E()
e.run()
E.eat()
E.fool()

输出

2 is run ordinary method
3 is eat static method
4 is fool class method 

质量:相当一个bean里面的情势,做相比较好的包裹一层,创设属性有第22中学艺术,一种是修饰器,一种是静态字段,装饰器情势针对卓越类和新颖类又有所差异,上边例子针对新式类(图中-今日方式开创 改为 静态格局开创)

图片 3

Paste_Image.png

我的位置是: 8 2
self

引用地址:http://m.blog.csdn.net/happyjxt/article/details/50760467

图片 4

QQ20170709-223954@2x.png

class Foo:
    def __init__(self, name, age):
        self.name = name
        self.age = age  
    def detail(self):
        print self.name
        print self.age  
obj1 = Foo('wupeiqi', 18)
obj1.detail()  # Python默认会将obj1传给self参数,即:obj1.detail(obj1),所以,此时方法内部的 self = obj1,即:self.name 是 wupeiqi ;self.age 是 18
obj2 = Foo('alex', 73)
obj2.detail()  # Python默认会将obj2传给self参数,即:obj1.detail(obj2),所以,此时方法内部的 self = obj2,即:self.name 是 alex ; self.age 是 78

  

继承

· python是支撑多一而再的言语
· python主要承袭的七个类时,找出的持续的主意重要2种,分别是:纵深优先广度优先
1、当类是卓绝类时,多三番七遍情状下,会遵照深度优先方式查找
2、当类是风靡类时,多一而再情形下,会依据广度优先格局查找

图片 5

QQ20170709-223954@2x.png

eg1、

class A():
    def __init__(self):
        print('A start')
        print('A level')
class B(A):
    def __init__(self):
        print('B start')
        print('B level')
class C(A):
    def __init__(self):
        print('C start')
        print('C level')
class D(B,C):
    def __init__(self):
        print('D start')
        print('D level')
d=D();

上述程序输入

D start
D level

假如把D类改造如下,别的没有变化:

class D(B,C):
    pass

程序输入

B start
B level

缘由:程序首先在D类寻觅init主意,程序意识并未有该办法后则寻找第3个父类的init的方法。

python3的类承接使用super方法:

经文类搜索

双重把B类改变如下,其余的未有变化

class B(A):
   pass

次第输入

A start
A  level

原因:查找顺序:D --> B --> A --> C

 1 #-*-  coding:utf-8 -*-
 2 '''
 3 Created on 2018年8月27日
 4 
 5 @author: anyd
 6 '''
 7 import random as r
 8 
 9 class Fish(object):
10     def __init__(self):
11         self.x = r.randint(0, 10)
12         self.y = r.randint(0, 10)
13             
14     def move(self):
15         #这里主要演示类的继承机制,就不考虑检查场景边界和移动方向的问题
16         #假设所有鱼都是一路向西游
17         self.x -= 1
18         print ("我的位置是:", self.x, self.y)
19 
20 class Goldfish(Fish):
21     pass
22 
23 class Carp(Fish):
24     pass
25 
26 class Salmon(Fish):
27     pass
28 
29 #上边几个都是食物,食物不需要有个性,所以直接继承Fish类的全部属性和方法即可
30 #下边定义鲨鱼类,这个是吃货,除了继承Fish类的属性和方法,还要添加一个吃的方法
31 
32 class Shark(Fish):
33     def __init__(self):
34         super().__init__()       
35         self.hungry = True
36 
37     def eat(self):
38         if self.hungry:
39             print ("吃货的梦想就是天天有的吃^_^")
40             self.hungry = False
41         else:
42             print ("太撑了,吃不下了!")
43             
44 aa = Shark()
45 aa.move()
风行类寻觅

再度把A类改换成新式类,别的未有成形

class A(object):
    def __init__(self):
        print('A start')
        print('A level')

程序输入

C start
C  level

由来:查找顺序:D --> B --> C --> A
备注:python3.0后多三番两次来说,类都以新式类,所以接二连三顺序统一是广式优先开展 

对于父类和子类重名时,又想采用父类的名字,那时能够使用首要词super-只相符用于新型类
'''
class C(B):
def meth(self, arg):
super(C, self).meth(arg)
'''
1、super只好用来最新类
2、super不是父类,而是继续顺序的下贰个类
3、 Python的多继承类是经过mro的办法来保险各种父类的函数被各个调用,并且保证各种父类函数
只调用三次(借使每一个类都使用super)

class A(object):
    def __init__(self):
        print('A start')
        print('A level')
class B(A):
    def __init__(self):
        print('B start')
        print('B level')
        super(B, self).__init__()
class C(A):
    def __init__(self):
        print('C start')
        print('C level')
        super(C, self).__init__()
class D(C,B):
    def __init__(self):
        print('D start')
        print('D level')
        super(D, self).__init__()
d=D();

输出结果

D start
D level
C start
C level
B start
B level
A start
A level

案由:新式类的检索顺序是D --> B --> C --> A,那么程序施行D类的init方法中触发super关键词,D的延续关系中的下二个类是B,那么把super.init转化为B.init推行。在进行进度中触发了super关键词,D的后续关系中B的下叁个类是C,那么super.init转化为C.init执行

出口如下:

封装

装进:你钱袋的有稍许钱
打包主要的缘由:有限支撑隐秘隔离复杂度
在python中用双下划线的方法完结遮蔽属性,还大概有用property方式

每贰个类的成员来说都有三种样式,
1、公有成员,在其他地点都能访谈,类内部能够访谈;派生类中得以访谈
2、私有成员,独有在类的在这之中本领格局
个体成员命名时,前多个字符是下划线。(特殊成员除了,比方:initcalldict等)

class C:
    def __init__(self):
        self.name = '公有字段'
        self.__foo = "私有字段"

备考:本文由局地引用。此文章只是用来学学

我的位置是: 7 4

  

super方法具体选拔注意事项能够参谋官方的点拨文书档案,里面有详细的应用例子,但个人以为这种super方法不太轻松让人看得飘飘欲仙,个人相比偏心利用未绑定的秘籍来写,那样就不管是python2 依然python3,都是尚未难题的。如下:

1 class Shark(Fish):
2     def __init__(self):
3         Fish.__init__(self)     
4         self.hungry = True

 

本文由星彩网app下载发布于计算机编程,转载请注明出处:super方法简要说明,面向对象的编程

TAG标签: 星彩网app下载
Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。