精华内容
下载资源
问答
  • python子类继承父类
    2022-04-02 10:40:35

    当父类参数较多,子类又要增加新的参数时,如果一个一个照抄一遍参数容易出错,这里可以借助*args来简便的进行父类初始化。
    利用,父类My_sprit有一大堆参数,子类UAV需要增加三个新参数scout_range、communicate_range、attack_range,可以这么写:

    class UAV(My_sprit):
        """:type
        UAV类需要实现三个范围:侦察范围、攻击范围、通信范围,这三个范围是组成杀伤链的关键
        :param float scout_range: 侦察范围
        :param float communicate_range: 通信范围
        :param float attack_range: 攻击范围
        """
        # def __init__(self,img_sprit, xy=(0, 0), speed=0.0, speed_angle=0.25 * math.pi, target=None,
        #              scout_range=None,communicate_range=None,attack_range=None):
    更多相关内容
  • 在本文里我们给大家分享一篇关于Python 子类继承父类构造函数的相关知识点内容,需要的朋友们跟着学习下。
  • Python 子类继承父类

    2022-06-27 17:05:04
    python中类的继承的基础知识

    1、一个类A继承另一个类B,就表示类A中可以直接调用类B中的内容,可以防止代码冗余

    2、继承的语法

    class DerivedClassName(modname.BaseClassName)
    

    DerivedClassName是子类名,BaseClassName是父类名称,如果父类与子类不属于同一个同一个模块时,需要在父类名前使用modname来定义父类所在模块 

    3、继承有两种类型:单继承与多继承

    3.1 单继承

    1)单继承的语法结构如下

    class DerivedClassName(BaseClassName):

            <statement-1>

            . . .

            <statement-N>

    2)如果在子类中需要父类的构造方法就需要显式地调用父类的构造方法,或者不重写父类的构造方法。

    子类不重写 __init__,实例化子类时,会自动调用父类定义的 __init__。

    #类定义
    class Father:
        #定义构造方法
        def __init__(self,n,a):
            self.name = n
            self.age = a
            print ( "name: %s" %( self.name) )
        def speak(self):
            print("%s 说: 我 %d 岁。" %(self.name,self.age))
     
    #单继承示例
    class Son(Father):
       pass
    
    if __name__=='__main__':
        son=Son('father',53)

    输出为:

    name:father

    3)如果重写了__init__ 时,实例化子类,就不会调用父类已经定义的 __init__: 

    #类定义
    class Father:
        #定义构造方法
        def __init__(self,n,a):
            self.name = n
            self.age = a
            print ( "name: %s" %( self.name) )
        def speak(self):
            print("%s 说: 我 %d 岁。" %(self.name,self.age))
     
    #单继承示例
    class Son(Father):
       def __init__(self,n):
            self.name = n
            print ( "son's name: %s" %( self.name) )
    
    if __name__=='__main__':
        son=Son('xiaoming')

    输出结果为:

    son's name:xiaoming

    4)如果重写了__init__ 时,要继承父类的构造方法,可以使用 super 关键字:

    super(子类,self).__init__(参数1,参数2,....)

    父类名称.__init__(self,参数1,参数2,...)

     

    #类定义
    class Father:
        #定义构造方法
        def __init__(self,n,a):
            self.name = n
            self.age = a
            print ( "name: %s" %( self.name) )
        def speak(self):
            print("%s 说: 我 %d 岁。" %(self.name,self.age))
     
    #单继承示例
    class Son(Father):
       def __init__(self,n):
            super(Son,self).__init__(n,20)
            self.name = n
            print ( "son's name: %s" %( self.name) )
    
    if __name__=='__main__':
        son=Son('xiaoming')
        son.speak()

    输出为:

    name:xiaoming

    son's name:xiaoming 

    xiaoming 说:我 20 岁。

    3.2 多继承

     1)多继承的语法结构如下:

    class DerivedClassName(Base1, Base2, Base3):

            <statement-1>

            . . .

            <statement-N>

     需要注意圆括号中父类的顺序,若是父类中有相同的方法名,而在子类使用时未指定,python从左至右搜索 即方法在子类中未找到时,从左到右查找父类中是否包含方法。

    #类定义
    class people:
        #定义基本属性
        name = ''
        age = 0
        #定义私有属性,私有属性在类外部无法直接进行访问
        __weight = 0
        #定义构造方法
        def __init__(self,n,a,w):
            self.name = n
            self.age = a
            self.__weight = w
        def speak(self):
            print("%s 说: 我 %d 岁。" %(self.name,self.age))
     
    #单继承示例
    class student(people):
        grade = ''
        def __init__(self,n,a,w,g):
            #调用父类的构函
            people.__init__(self,n,a,w)
            self.grade = g
        #覆写父类的方法
        def speak(self):
            print("%s 说: 我 %d 岁了,我在读 %d 年级"%(self.name,self.age,self.grade))
     
    #另一个类,多重继承之前的准备
    class speaker():
        topic = ''
        name = ''
        def __init__(self,n,t):
            self.name = n
            self.topic = t
        def speak(self):
            print("我叫 %s,我是一个演说家,我演讲的主题是 %s"%(self.name,self.topic))
     
    #多重继承
    class sample(speaker,student):
        a =''
        def __init__(self,n,a,w,g,t):
            student.__init__(self,n,a,w,g)
            speaker.__init__(self,n,t)
     
    test = sample("Tim",25,80,4,"Python")
    test.speak()   #方法名同,默认调用的是在括号中参数位置排前父类的方法

    输出结果为:

    我叫 Tim,我是一个演说家,我演讲的主题是 Python

     3.3 方法重写

    如果你的父类方法的功能不能满足你的需求,你可以在子类重写你父类的方法,实例如下:

    class Parent:        # 定义父类
       def myMethod(self):
          print ('调用父类方法')
     
    class Child(Parent): # 定义子类
       def myMethod(self):
          print ('调用子类方法')
     
    c = Child()          # 子类实例
    c.myMethod()         # 子类调用重写方法
    super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法

    输出结果:

    调用子类方法
    调用父类方法

     

    展开全文
  • 子类不需要自动调用父类的方法子类重写__init__()方法,实例化子类后,将不会自动调用父类的__init__()的方法。一子类调用父类的方法子类不重写__init__()方法,实例化子类后,会自动调用父类的__init__()的方法。...

    1、在子类中需要父类的构造方法就需要调用父类的构造方法,或者不重写父类的构造方法。

    子类不重写 init,实例化子类时,会自动调用父类定义的 init。

    class Father(object): # 所有的父类都默认继承object类,可写可不写https://blog.csdn.net/txnuli/article/details/110862361
        def __init__(self, name):
            self.name = name  # self指的是自身,这里的self就是类自身,self.name就是类里的变量,是Father所有。
            print(f"name:{self.name}")
    
        def getName(self):
            return 'Father ' + self.name
    
    
    class Son(Father):
        def getName(self):
            return 'Son ' + self.name
    
    
    if __name__ == '__main__':
        son = Son('yaya')
        print(son.getName())
    

    输出结果为:

    name:yaya
    Son yaya
    

    2、重写__init__ 时,实例化子类,就不会调用父类已经定义的 init,
    语法格式如下:

    class Father(object):
        def __init__(self, name):
            self.name = name  # self指的是自身,这里的self就是类自身,self.name就是类里的变量,是Father所有。
            print(f"name:{self.name}")
    
        def getName(self):
            return 'Father ' + self.name
    
    
    class Son(Father):
        def __init__(self, name):
            self.name = name
            print('hi')
    
        def getName(self):
            return 'Son ' + self.name
    
    
    if __name__ == '__main__':
        son = Son('yaya')
        print(son.getName())
    
    

    输出结果为:

    hi
    Son yaya
    

    3、重写__init__ 时,要继承父类的构造方法,可以使用 super 关键字:

    super(子类,self).__init__(参数1,参数2....)
    或
    父类名称.__init__(self,参数1,参数2...)
    
    class Father(object):
        def __init__(self, name):
            self.name = name  # self指的是自身,这里的self就是类自身,self.name就是类里的变量,是Father所有。
            print(f"name:{self.name}")
    
        def getName(self):
            return 'Father ' + self.name
    
    
    class Son(Father):
        def __init__(self, name):
            self.name = name
            print('hi')
            super().__init__(name)
    
        def getName(self):
            return 'Son ' + self.name
    
    
    if __name__ == '__main__':
        son = Son('yaya')
        print(son.getName())
    

    输出结果为:

    hi
    name:yaya
    Son yaya
    

    总结:
    一:子类调用父类的方法:子类不重写__init__()方法,实例化子类后,会自动调用父类的__init__()的方法。
    二:子类不需要自动调用父类的方法:子类重写__init__()方法,实例化子类后,将不会自动调用父类的__init__()的方法。
    三:子类重写__init__()方法又需要调用父类的方法:使用super关键词

    展开全文
  • 正好刚学到这里,也正好刚解答了一个网上...我可以还原一个比较常犯的错误代码案例:# 父类class Car():"""Simulate a car"""def __init__(self,make,model,year):---snip---# 子类class ElectricCar(Car):"""Simul...

    正好刚学到这里,也正好刚解答了一个网上类似的问题。

    就像其他帖子里说的,提示里已经说明了是你所传实参数目和给定形参数目不匹配造成的。

    我可以还原一个比较常犯的错误代码案例:

    # 父类

    class Car():

    """Simulate a car"""

    def __init__(self,make,model,year):

    ---snip---

    # 子类

    class ElectricCar(Car):

    """Simulate an electric car"""

    def __init__(self,make,model,year,xyz):

    super().__init__(make,model,year)

    self.xyz = 0

    如果你运行这段代码,也会提示几乎一样的错误。

    可以看出,他的初始目的应该是ElectricCar类继承Car类,并添加一个新的属性xyz,赋默认值为0。这个逻辑没有问题,但是他写的方式有问题。

    这种情况只有2种写法:

    def __init_(self,make,model,year,xyz=0):

    super().__init__(make,model,year)

    self.xyz = xyz

    def __init_(self,make,model,year):

    super().__init__(make,model,year)

    self.xyz = 0

    也就是说,如果你像通过self.xyz = 0给新增的xyz属性赋默认值0,那么括号里就不要添加形参xyz,不然会多算一个形参;而如果你想在括号里直接赋值,那么下面就写成self.xyz = xyz。

    保持括号里的和下面的始终都表示同一个形参而非两个。问题就解决了。

    感谢季同学和我的讨论,这是能快速总结出上述情形的直接原因,虽然你不玩知乎也看不到。

    展开全文
  • Python 子类继承父类构造函数说明 分类 编程技术 如果在子类中需要父类的构造方法就需要显式地调用父类的构造方法,或者不重写父类的构造方法。 子类不重写 init,实例化子类时,会自动调用父类定义的 init。 实例 ...
  • 如果在子类中需要父类的构造方法就需要***显式***地调用父类的构造方法,或者不重写父类的构造方法。子类不重写 init,实例化子类时,会自动调用父类定义的 init。 class Father(object): def __init__(self, name)...
  • 子类继承父类后,需要调用父类的方法和属性时,需要调用父类的初始化函数。 class A(object): def __init__(self): self.nameaa = 'aa' def funca(self): print('function a %s' % self.nameaa) class B(A): ...
  • 如果在子类中需要父类的构造方法就需要显式地调用父类的构造方法,或者不重写父类的构造方法。 子类不重写 init,实例化子类时,会自动调用父类定义的 init。 class Father(object): def __init__(self, name): ...
  • 继承父类后,就能调用父类方法和访问父类属性,而要完成整个集成过程,子类是需要调用的构造函数的。 子类不显式调用父类的构造方法,而父类构造函数初始化了一些属性,就会出现问题 如果子类和父类都有构造函数,...
  • python子类继承父类构造函数__init__的几种情况1. 子类不重写父类的__init__方法,那么子类继承父类的__init__2. 子类重写父类的__init__方法,就不会调用父类的__init__3. 如果子类重写了__init__,要继承父类的构造...
  • 转载于:https://www.cnblogs.com/fanweisheng/p/11232969.html
  • python子类继承父类的init方法

    千次阅读 2018-12-18 19:36:07
    父类A class A(object): def __init__(self, name): self.name=name print "name:", self.name def getName(self): ...子类不重写__init__,实例化子类时,会自动调用父类定义的...
  • Python继承、方法重写、super()类,主要包括04 Python继承、方法重写、super()类使用实例、应用技巧、基本知识点总结和需要注意事项,具有一定的参考价值,需要的朋友可以参考一下。
  • 1、显示调用父类构造方法 2、不重写父类构造方法
  • python中进行面向对象编程,当在子类的实例中调用父类的属性时,由于子类的__init__方法重写了父类的__init__方法,如果在子类中这些属性未经过初始化,使用时就会出错。 例如以下的代码: class A(object): def __...
  • 1.子类不重写__init__,实例化子类时,会自动调用父类定义的__init__ class Father(object): def __init__(self, name): self.name = name print("name: %s" % (self.name)) def getName(self): return ...
  • python子类继承父类

    2021-03-29 22:11:08
    链接 如果需要重写父类的构造方法 则有两种写法 super(子类, self).__init__(参数1, 参数2, ...): 还有一种写法 父类名称.__init__(self, 参数1, 参数2, ...):
  • 有点时候,我们需要继承父类的初始化的值。python实现为 class A: def __init__(self): self.x = 0 class B(A): def __init__(self): super().__init__() self.y = 1 super().init() ...
  • 关于Python 子类继承父类构造函数说明 1.如果在子类中需要父类的构造方法就需要显式地调用父类的构造方法,或者不重写父类的构造方法。 子类不重写__init__,实例化子类时,会自动调用父类定义的__init__。 2....
  • 子类中需要父类的构造方法就需要显式地调用父类的构造方法,或者不重写父类的构造方法。子类不重写 __init__,实例化子类时,会自动调用父类定义的 __init__。class Father(object):def __init__(self, name):self....
  • 如果在子类中需要父类的构造方法就需要显式地调用父类的构造方法,或者不重写父类的构造方法。 子类不重写 init,实例化子类时,会自动调用父类定义的 init。 class Father(object): def __init__(self, name): ...
  • 父类Aclass A(object):def __init__(self, name):self.name=nameprint "name:", self.namedef getName(self):return 'A ' + self.name子类不重写__init__,实例化子类时,会自动调用父类定义的__init__class B(A):...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 53,966
精华内容 21,586
关键字:

python子类继承父类