精华内容
下载资源
问答
  • python 子类重写父类方法

    千次阅读 2019-09-03 20:51:57
    子类拓展了父类,子类是一种特殊的父类,大部分时候,子类总是以父类为基础,额外增加新的方法,但有一种情况例外,子类需要重写父类方法,见代码: class Animal: def eat(self): print('kkkkkk') class ...

    子类拓展了父类,子类是一种特殊的父类,大部分时候,子类总是以父类为基础,额外增加新的方法,但有一种情况例外,子类需要重写父类的方法,见代码:

    class Animal:
        def eat(self):
            print('kkkkkk')
    
    class Person(Animal):
        def eat(self):
            print('hhhhhhhh')
            return '这是子类的方法'
    
    p = Person()
    print(p.eat())    #   hhhhhhhh
                        #这是子类的方法
    

    这种子类与父类同名的方法的现象被称为方法重写,也被称为方法覆盖,可以说子类重写了父类的方法,也可以说子类覆盖了父类的方法。

    使用未绑定方法调用被重写方法

    在通过类名调用实例方法时,python不会为实例方法的第一个参数self自动绑定参数值,而是需要程序显式绑定第一个参数self,这种机制被称为未绑定方法。

    class Base(object):
        def foo(self):
            print('父类中定义的foo方法')
    class Sub(Base):
        def foo(self):
            print('子类重写父类中的foo 方法')
        def bar(self):
            print('执行bar方法')
            self.foo()   # 直接执行foo方法,将会调用子类重写之后的foo()方法
            Base.foo(self)    #使用类名调用实例方法(未绑定方法)调用父类被重写的方法
    b = Sub()
    b.bar()
    

    python的子类会继承得到父类的构造方法,如果子类有多个父类,那么排在前面的父类的构造方法优先被调用,那么其对应的实例变量(构造方法中参数的个数)可能就会发生改变

    使用super()函数

    class super(object):
        """
        super() -> same as super(__class__, <first argument>)
        super(type) -> unbound super object
        super(type, obj) -> bound super object; requires isinstance(obj, type)
        super(type, type2) -> bound super object; requires issubclass(type2, type)
        Typical use to call a cooperative superclass method:
        class C(B):
            def meth(self, arg):
                super().meth(arg)
        This works for class methods too:
        class C(B):
            @classmethod
            def cmeth(cls, arg):
                super().cmeth(arg)
        """
    

    super其实就是一个类,因此调用super的本质就是super类的构造方法来创建super对象,使用super函数最常用的做法就是不传入任何参数,然后通过super对象的方法既可以调用父类的实例方法,也可以父类的类方法,在调用父类的实例方法时,程序会完成第一个参数self的自动绑定,在调用类方法时,程序会完成第一个参数cls的自动绑定

    class Base(object):
        def foo(self):
            print('父类中定义的foo方法',end=' ')
    class Sub(Base):
        def foo(self):
            super().foo()
            print('子类重写父类中的foo 方法')
    b = Sub()
    b.foo()     #   打印  父类中定义的foo方法 子类重写父类中的foo 方法
    

    无论采用未绑定方法还是super()函数调用方法,父类中的方发优先被执行,然后执行子类中重写的方法

    构造函数的重写仍然遵从这两个方法,代码如下:

    class Person(object):
        def __init__(self, name, age):
            self.name = name
            self.age = age
            self.money = 1000
    
        def test(self):
            print(self.name + ' say hello')
    
    
    class Student(Person):
        def __init__(self, name, age, school):
            # 子类在父类的基础上又扩展了自己的功能
            # 父类名.函数名(参数)
            # Person.__init__(self, name, age)
    
            # super().函数名()
            super().__init__(name, age)
            self.school = school
    
        def study(self):
            print('学生正在学习')
    
        def test(self):
            # Person.test(self)
            super().test()
            print('hehe')
    
    
    s = Student('zhangsan', 18, '春田花花幼稚园')
    print(s.money)
    s.test()
    # s.study()
    
    
    展开全文
  • key, value): # print(111) # # # redis_cache = RedisCache() # redis_cache.set("key", "value") # 如果子类没有重写父类的抽象方法,在初始化的时候就报错 import abc class CacheBase(metaclass=abc.ABCMeta): ...
    # 如何去模拟一个抽象基类
    # class CacheBase():
    #     def get(self, key):
    #         raise NotImplementedError
    #
    #     def set(self, key, value):
    #         raise NotImplementedError
    #
    #
    # class RedisCache(CacheBase):
    #     def set(self, key, value):
    #         print(111)
    #
    #
    # redis_cache = RedisCache()
    # redis_cache.set("key", "value")
    
    # 如果子类没有重写父类的抽象方法,在初始化的时候就报错
    import abc
    class CacheBase(metaclass=abc.ABCMeta):
        @abc.abstractmethod
        def get(self, key):
            pass
    
        @abc.abstractmethod
        def set(self, key, value):
            pass
    
    
    # class RedisCache(CacheBase):  # TypeError: Can't instantiate abstract class RedisCache with abstract methods get, set
    #     pass
    
    class RedisCache(CacheBase):  # TypeError: Can't instantiate abstract class RedisCache with abstract methods get, set
        def set(self, key, value):
            pass
            print(111)
        def get(self, key):
            pass
    
    
    redis_cache = RedisCache()
    redis_cache.set("key", "value")
    
    展开全文
  • 1. 重写父类方法 所谓重写,就是子类中,有一个和父类相同名字的方法,在子类中的方法会覆盖掉父类中同名的方法 #coding=utf-8 class Cat(object): def sayHello(self): print("halou-----1") class Bosi(Cat): ...

    1. 重写父类方法

    所谓重写,就是子类中,有一个和父类相同名字的方法,在子类中的方法会覆盖掉父类中同名的方法

    #coding=utf-8
    class Cat(object):
        def sayHello(self):
            print("halou-----1")
    
    
    class Bosi(Cat):
    
        def sayHello(self):
            print("halou-----2")
    
    bosi = Bosi()
    
    bosi.sayHello()
    

    在这里插入图片描述

    2. 调用父类的方法

    #coding=utf-8
    class Cat(object):
        def __init__(self,name):
            self.name = name
            self.color = 'yellow'
    
    
    class Bosi(Cat):
    
        def __init__(self,name):
            # 调用父类的__init__方法1(python2)
            #Cat.__init__(self,name)
            # 调用父类的__init__方法2
            #super(Bosi,self).__init__(name)
            # 调用父类的__init__方法3
            super().__init__(name)
    
        def getName(self):
            return self.name
    
    bosi = Bosi('xiaohua')
    
    print(bosi.name)
    print(bosi.color)
    
    

    在这里插入图片描述

    展开全文
  • 重写父类的__init__方法方法1:调用父类的__init__(python2) 父类名.__init__(self,重写的属性) 方法2:调用父类的__init__ super(子类名,self).__init__(重写的属性) 方法3: 调用父类的__init__ super...

    所谓重写,就是子类中,有一个和父类相同名字的方法,在子类中的方法会覆盖掉父类中同名的方法

    重写父类的__init__方法:

    方法1:调用父类的__init__(python2)

    父类名.__init__(self,重写的属性)

    方法2:调用父类的__init__

    super(子类名,self).__init__(重写的属性)

    方法3: 调用父类的__init__

    super().__init__(重写的属性)

    展开全文
  • Python 子类调用父类方法

    千次阅读 2014-12-08 17:09:12
    Python在继承时,如果子类重写了init()函数,则父类的init()不会被调用,这时如果子类只是想要对父类的init()函数进行简单的扩展的话,是很不方便的。那么有没有比较方便的方法来从子类调用父类呢?  第一种是...
  • 1.类中前置双下划线__表示私有的,内部不允许访问,意思是只有类对象自己能访问,连子类对象也不能访问。 ...前置下划线的变量和方法代表这个变量和方法最好是只在类内部使用。意思就是,“虽然..
  • 如果在子类中需要父类的构造方法就需要显式地调用父类的构造方法,或者不重写父类的构造方法子类不重写 init,实例化子类时,会自动调用父类定义的 init。 情况一:子类需要自动调用父类的方法子类不重写init...
  • 1、显示调用父类构造方法 2、不重写父类构造方法
  • 情况一: 子类需要自动调用父类方法子类重写__init__()方法,实例化子类后,会自动调用父类的__init__()的方法。 class Father(object): def __init__(self, name): self.name=name print ( "name: %s" %( ...
  • 重写父类方法 所谓重写,就是子类中,有一个和父类相同名字的方法,在子类中的方法会覆盖掉父类中同名的方法 class Cat(object): def sayHello(self): print("halou-----1") class Bosi(Cat): def sayHello...
  • 如果在子类中需要父类的构造方法就需要显式地调用父类的构造方法,或者不重写父类的构造方法子类不重写 __init__,实例化子类时,会自动调用父类定义的 __init__。 class Father(object): def __init__(self, ...
  • 一、父类定义方法read_tokens class DataReader(object): def read_tokens(self, path): """ Reads the given file line by line and yields the list of tokens present in each ...
  • 1.如果在子类中需要父类的构造方法就需要显式地调用父类的构造方法,或者不重写父类的构造方法子类不重写__init__,实例化子类时,会自动调用父类定义的__init__。 2.如果重写了__init__时,实例化子类,就...
  • python子类继承父类

    2021-03-29 22:11:08
    链接 如果需要重写父类的构造方法 则有两种写法 super(子类, self).__init__(参数1, 参数2, ...): 还有一种写法 父类名称.__init__(self, 参数1, 参数2, ...):
  • 1. 子类中访问父类中的私有属性和私有方法 如果想使用父类中的私有属性和私有方法,那么就需要在父类中,为这些私有的属性和方法,提供相应的公有的接口方法来间接访问 2. 如何为父类中的属性进行初始化 在子类中...
  • 1、在子类中需要父类的构造方法就需要调用父类的构造方法,或者不重写父类的构造方法子类不重写 init,实例化子类时,会自动调用父类定义的 init。 class Father(object): def __init__(self, name): self.name...
  • 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__,实例化子类时,会自动调用父类定义的...
  • 如果在子类中需要父类的构造方法就需要显式地调用父类的构造方法,或者不重写父类的构造方法子类不重写 init,实例化子类时,会自动调用父类定义的 init。 class Father(object): def __init__(self, name): ...
  • 当一个类被子类继承且子类重写了构造方法后,若子类还想使用父类的构造方法,如果直接通过创建的子类对象调用父类方法会报错。解决办法有两个:一个是调用超类方法的未绑定版本,一个是使用super函数 见下面的例子...
  • python 重写父类方法(override)

    千次阅读 2019-02-09 20:29:20
    重写父类方法(override) 当父类方法不满足子类需求时,我们可以重写父类的方法, 如果重写的方法里面还需要调用父类里的方法时,我们可以 通过在重写的方法里面用super()再次调用父类的方法就可以了。 调用...
  • 如果在子类中需要父类的构造方法就需要显式地调用父类的构造方法,或者不重写父类的构造方法子类不重写 init,实例化子类时,会自动调用父类定义的 init。 class Father(object): def __init__(self, name): ...
  • Python 重写父类方法

    2019-12-19 15:55:25
    父类方法不能满足子类的需要,那么子类就可以重写或者完善父类方法。 例如: ''' 遇到问题没人解答?小编创建了一个Python学习交流QQ群:579817333 寻找有志同道合的小伙伴,互帮互助,群里还有不错的视频学习...
  • 如果在子类中需要父类的构造方法就需要***显式***地调用父类的构造方法,或者不重写父类的构造方法子类不重写 init,实例化子类时,会自动调用父类定义的 init。 class Father(object): def __init__(self, name)...
  • 2019独角兽企业重金招聘Python工程师标准>>> ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 935
精华内容 374
关键字:

python子类重写父类方法

python 订阅