必威-必威-欢迎您

必威,必威官网企业自成立以来,以策略先行,经营致胜,管理为本的商,业推广理念,一步一个脚印发展成为同类企业中经营范围最广,在行业内颇具影响力的企业。

python 必威同时支持面向对象编程和函数式编程的

2019-11-08 16:41 来源:未知

  

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 不仅保证持续时按顺序调用父类起始化,何况保障每叁个类不被另行调用。

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

  以上是python中类的有些简易注意事项,做为面向对象的一大首要,类这一定义还大概有好些个值得深究的东西。比方参数类型等等,这几个都必要和谐去渐渐探求。

 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中用双下划线的点子实现掩盖属性,还会有用property方式

每贰个类的分子而言都有三种样式,
1、公有成员,在任何处方都能访问,类内部能够访问;派生类中得以访谈
2、私有成员,独有在类的里边技艺方式
个体成员命名时,前四个字符是下划线。(特殊成员除了,比如:initcalldict等)

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

备注:本文由一些援引。此小说只是用来上学

class A(object):#代码都差不多。。这个也不解释了。。
    def __init__(self):
        print("A")
        super(A,self).__init__()
class B(object):
    def __init__(self):
        print("B")
        super(B, self).__init__()
class C(A):
    def __init__(self):
        print("C")
        super(C, self).__init__()
class D(A):
    def __init__(self):
        print("D")
        super(D, self).__init__()
class E(B,C):
    def __init__(self):
        print("E")
        super(E, self).__init__()
class F(D,E):
    def __init__(self):
        print("F")
        super(F, self).__init__()
a = E()
print("---------")
b = F()
######看一下输出记录,为了省地儿,我合成了两行行########
# 初始化E类得到的输出结果 E B C A
#---------
# 初始化F类得到的输出结果 F D E B C A

输出如下:

@(python)

概念

1.目的:类的实例。对象具有三个特色:状态与表现。
2.类:用来描述具备同等的个性和方法的对象的集结,类的结缘=方法+行为
3.大而无当:对现实世界难点和实体的庐山真面目目展现,行为和天性建模,创建多少个辅车相依的子集,能够用来描述程序结构,进而达成这种模型。
4.封装:对质量和办法的载体类,只可以通过其提供的接口(方法)来寻访,而把落到实处细节掩饰起来.python的类属性都以公开的。
5.世襲:描述了子类属性从祖先类继承那样后生可畏种方法。
6.多态:同风流倜傥音信能够凭借发送对象的差别而使用七种不相同的行为艺术。

  

python2的类继承使用super方法:

继承

· python是永葆多一而再连续的语言
· python首要世襲的多个类时,搜索的继续的方法首要2种,分别是:深度优先广度优先
1、当类是精华类时,多三回九转境况下,会根据深度优先格局查找
2、当类是风尚类时,多三番四遍情形下,会根据广度优先情势查找

必威 1

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艺术,程序意识未有该措施后则寻觅第叁个父类的init的方法。

class test(object):#定义一个类。。不要管名字了
    name = "test"#类变量
    def __init__(self,age):#初始方法,传个参数
        self.age = age#定义一个实例变量,把传进来的参数直接赋值给它
    def say(self):# 未加装饰器的普通方法,输出个test,ps:只能实例化之后通过实例调用
        print("test")
    @staticmethod#加装饰器@staticmethod之后的方法,
   #即静态方法 不无需实例化调用 ,无法传参数。当一个类只有静态方法的时候,从意义上讲就单纯是一个类的工具包
    def say2():
        print("say hi 2") 
    @classmethod
   # 类方法 ,不需要实例化即可调用,可以使用类参数,无法使用实例参数,这里没有传个参数做例子。。抱歉
    def say3(self):
        print("say hi 3")。
    @property #加@property的方法
   #可以返回数据,使用意义上来讲,就是把经过类方法处理后的数据传递出去
    def say4(self):
         # print("this is 4")
         return  "test"
TAG标签:
版权声明:本文由必威发布于必威-编程,转载请注明出处:python 必威同时支持面向对象编程和函数式编程的