Python super初始化理解过程

Python中子类调用父类的方法有两种方法能够实现:调用父类构造方法,或者使用super函数(两者不要混用)。

使用“super”时经常会出现代码“super(FooChild,self).__init__(xxx,xxx)”。那super().__init__()到底要怎么用呢?

为了方便理解,我写了如下例子验证用法:

#-*- coding:utf-8 -*-class A(object):
    def __init__(self,xing,gender):         #!#1
        self.namea="aaa"                    #!#2
        self.xing = xing                    #!#3
        self.gender = gender                #!#4

    def funca(self):
        print "function a : %s"%self.namea

class B(A):
    def __init__(self,xing,age):            #!#5
        super(B,self).__init__(xing,age)    #!#6(age处应为gender)
        self.nameb="bbb"                    #!#7
        ##self.namea="ccc"                  #!#8
        ##self.xing = xing.upper()          #!#9
        self.age = age                      #!#10

    def funcb(self):
        print "function b : %s"%self.nameb

b=B("lin",22)                               #!#11
print b.nameb
print b.namea
print b.xing                                #!#12
print b.age                                 #!#13
b.funcb()
b.funca()

通过更改代码中标记#!#几行的输入参数来验证super的用法,并得出以下结论:

1.B类继承A类,在B类自己的基础上可以调用A类所以的方法,代码最后两行b.funcb()\b.funca()可以正常运行。

2.A、B同时拥有__init__,B会改写A中的__init__方法,A类的方法失效,通过注释(#)掉#!#6行代码、恢复#89行代码,运行后可得。

3.super函数可以调用A父类中的属性,如namea、xing,B类中有同名属性时,覆盖A类中的同名属性。

4.B类__init__(#5)参数需大于或等于A父类的__init__方法,因为super初始化了,参数量为父类参数量。

5.super函数原理:super().__init__(xxx,xxx)中的xxx参数为类B(#5)中输入的参数,但与类A中参数名相对应。如上面那段代码#6中输入的是age参数,虽然运行结果并没错(因为没有运行.gender),但是其实这个age参数是赋值到A类的gender参数上的(本文末的第二段代码有相关例子,代码加#####处)

6.使用super函数时,可将B子类中(#5)与A类相同的参数依次写入__init__(xxx)的xxx参数中(注意self参数已在super()中传入,在__init__()中将隐式传递,不需要写出,也不能写),之后可再次重写xxx中参数属性,#5中多余参数可自定义属性

class A(object):
    def __init__(self,xing,gender):
        self.namea="aaa"
        self.xing = xing
        self.gender = gender

    def funca(self):
        print "function a : %s"%self.namea

class B(A):
    def __init__(self,xing,gender,age):
        super(B,self).__init__(xing,age)
        self.nameb="bbb"
        ##self.namea="ccc"
        self.xing = xing.upper()
        self.age = age + 1
        #self.gender = gender.upper()

    def funcb(self):
        print "function b : %s"%self.nameb

b=B("lin","nan",22)
print b.nameb
print b.namea
print b.xing
print b.age
b.funcb()
b.funca()
print b.gender   #####

输出结果:  

bbb
aaa
LIN
23
function b : bbb
function a : aaa
22   #####

时间: 2024-11-16 11:51:50

Python super初始化理解过程的相关文章

【Python】使用super初始化超类

初始化超类的传统方式,在子类的实例中调用超类的__init__()方法. 但是传统的方法有两个问题,比如: 问题1: 1 class MyBaseClass: 2 def __init__(self, value): 3 self.value = value 4 5 6 class TimesTwo: 7 def __init__(self): 8 self.value *= 2 9 10 11 class PlusFive: 12 def __init__(self): 13 self.val

理解python super()类

首先我们通过网友在stackoverflow关于python super类的一个疑问来作为本篇的开始,问题大致是这样的: >>> class A(object): ... def __init__(self): ... print "A init" ... super(A,self).__init__() ... >>> >>> a = A() A init >>> class B(object): ... def

python super()

一.问题的发现与提出 在Python类的方法(method)中,要调用父类的某个方法,在Python 2.2以前,通常的写法如代码段1: 代码段1: class A: def __init__(self): print "enter A" print "leave A" class B(A): def __init__(self): print "enter B" A.__init__(self) print "leave B"

Java 类的实例变量初始化的过程 静态块、非静态块、构造函数的加载顺序

Java 类的实例变量初始化的过程 静态块.非静态块.构造函数的加载顺序 先看一道Java面试题: 1 public class Baset { 2 private String baseName = "base"; 3 // 构造方法 4 public Baset() { 5 callName(); 6 } 7 // 成员方法 8 public void callName() { 9 // TODO Auto-generated method stub 10 System.out.p

Dubbo中消费者初始化的过程解析

首先还是Spring碰到dubbo的标签之后,会使用parseCustomElement解析dubbo标签,使用的解析器是dubbo的DubboBeanDefinitionParser,解析完成之后返回BeanDefinition给Spring管理. 服务消费者端对应的是ReferenceBean,实现了ApplicationContextAware接口,Spring会在Bean的实例化那一步回调setApplicationContext方法.也实现了InitializingBean接口,接着会

《python源码剖析》笔记 python环境初始化

本文为senlie原创,转载请保留此地址:http://blog.csdn.net/zhengsenlie 1.线程环境初始化 Py_InitializeEx,Python会首先调用 PyInterpreterState_New创建一个崭新的PyInterpreterState对象. 创建了PyInterpreterState(进程状态)对象之后,Python会调用PyThreadState_New创建PyThreadState(线程状态)对象 全局变量_PyThreadState_Curren

说说Python程序的执行过程

1. Python是一门解释型语言? 我初学Python时,听到的关于Python的第一句话就是,Python是一门解释性语言,我就这样一直相信下去,直到发现了*.pyc文件的存在.如果是解释型语言,那么生成的*.pyc文件是什么呢?c应该是compiled的缩写才对啊! 为了防止其他学习Python的人也被这句话误解,那么我们就在文中来澄清下这个问题,并且把一些基础概念给理清.   2. 解释型语言和编译型语言   计算机是不能够识别高级语言的,所以当我们运行一个高级语言程序的时候,就需要一个

Python——五分钟理解元类(metaclasses)

“元类的魔幻变化比 99% 的用户所担心的更多,当你搞不懂是否真的需要用它的时候,就是不需要.” —Tim Peters 本文源于在 PyCon UK 2008 上的一个快速演讲. 元类被称为 Python 中的“深奥的巫术”.尽管你需要用到它的地方极少(除非你基于zope 编程),可事实上它的基础理论其实令人惊讶地易懂. 一切皆对象 一切皆对象 一切都有类型 “class”和“type”之间本质上并无不同 类也是对象 它们的类型是 type 以前,术语 type 用于内置类型,而术语 clas

python之总体理解

作为脚本,python具备了弱类型语言的灵活性,便捷性.这在日常的开发使用中能够大幅度的减轻开发人员的编码负担,开发者也能够将精力集中在程序的逻辑管理和总体构架设计上.一般而言,随着经验的积累,开发人员都能使用python写出漂亮的代码,简洁而美观. python也是严谨的,从对各类预定义错误的设定我们就可以发现python具备着编译语言具备的严密的逻辑结构.可以这么讲,随着对python的深入理解,就越能感受到python在提供各类便捷操作的同时依然保持了编译语言具有的严密逻辑,只是很多"隐藏