精华内容
下载资源
问答
  • python实现多态

    2019-10-10 19:10:22
    在面向对象语言,接口的多种不同的实现方式即为多态多态就是指程序定义的引用变量所指向的具体类型(类)和调用这个变量时发出的方便在编程时并不确定,只有在程序执行期间才能确定 打个比方...

    python实现多态

    多态的定义:
    多态按字面的意思就是“多种状态”。在面向对象语言中,接口的多种不同的实现方式即为多态。
    官方说:

    • 接口的多种不同的实现方式即为多态。
    • 多态性是允许你将父对象设置成为一个或更多的他的子对象相等的技术。
    • 我们在程序中定义的引用变量所指向的具体类型和通过该引用变量的方法调用在编程的时候并不确定,当处于运行期间才确定。就是这个引用变量究竟指向哪一个实例对象,在编译期间是不确定的,只有运行期才能确定,这样不用修改源码就可以把变量绑定到不同的类实例上,让程序拥有了多个运行状态,这就是多态。

    打个比方吧:
    允许将子类类型的指针赋值给父类类型的指针,把不同的子类对象都当作父类来看。比如你家有亲属结婚了,让你们家派个人来参加婚礼,邀请函写的是让你爸来,但是实际上你去了,或者你妹妹去了,这都是可以的,因为你们代表的是你爸,但是在你们去之前他们也不知道谁会去,只知道是你们家的人。可能是你爸爸,可能是你们家的其他人代表你爸参加。这就是多态。

    多态的分类:
    多态又分为 编译时多态和运行时多态。
    编译时多态:比如重载
    运行时多态:比如重写

    代码展示简单多态实现:

    class Human(object):
        def __init__(self, name):
            self.name = name
    
        def talk(self):  # 自己定义talk方法
            print('这是人')
    
        def call_talk(self):  # 多态
            self.talk()
    
    
    class Woman(Human):
        def talk(self):  # 重写talk
            print('%s很美丽' % self.name)
    
    
    class Man(Human):
        def talk(self):
            print('%s很帅气' % self.name)
    
    
    class People(Human): # 继承
        pass
    
    
    human = Human('')
    
    human.call_talk()
    
    man = Man('女人')
    
    man.call_talk()
    
    woman = Woman('男人')
    
    woman.call_talk()
    
    people = People('')
    
    people.call_talk()
    

    这是展示效果

    这是人
    女人很帅气
    男人很美丽
    这是人
    

    参考https://www.jianshu.com/p/68ddb5484ca2
    希望对大家有帮助,如果有错不吝赐教。

    展开全文
  • python中多态

    千次阅读 2017-01-09 20:54:36
    多态顾名思义 即一个接口多种实现方式,子类实力指向父类对象用法称为多态中的向上转型,多用于方法参数,类中的实例属性,以及 函数返回值,向上转型时父类对象只能调用本类所拥有实例,如果父类有和...
    python 多态:
    多态顾名思义 即一个接口的多种实现方式,子类实力指向父类对象的用法称为多态中的向上转型,多用于方法参数,类中的实例属性,以及
    函数返回值中,向上转型时父类对象只能调用本类所拥有的实例,如果父类中有和子类定义相同名称的方法,则优先调用子类实例中的方法
    并且,父类对象不能调用子类中特有的方法(子类有父类没有)
    向下转型:则指父类实例赋值给子类对象,与向上转型不同的是子类实例不仅可以调用自己的方法,而且可以调用父类中的任何方法,包括

    父类所特有的方法,当所调用的方法与父类方法一致时则仍然调用自己的方法(毕竟子类继承了父类,所以父类中的属性和方法子类中同样拥有)


    类具有继承关系,并且子类类型可以向上转型看做父类类型,如果我们从 Person 派生出 StudentTeacher ,并都写了一个 whoAmI() 方法:

    class Person(object):
        def __init__(self, name, gender):
            self.name = name
            self.gender = gender
        def whoAmI(self):
            return 'I am a Person, my name is %s' % self.name
    
    class Student(Person):
        def __init__(self, name, gender, score):
            super(Student, self).__init__(name, gender)
            self.score = score
        def whoAmI(self):
            return 'I am a Student, my name is %s' % self.name
    
    class Teacher(Person):
        def __init__(self, name, gender, course):
            super(Teacher, self).__init__(name, gender)
            self.course = course
        def whoAmI(self):
            return 'I am a Teacher, my name is %s' % self.name

    在一个函数中,如果我们接收一个变量 x,则无论该  Person、Student还是 Teacher,都可以正确打印出结果:

    def who_am_i(x):
        print x.whoAmI()
    
    p = Person('Tim', 'Male')
    s = Student('Bob', 'Male', 88)
    t = Teacher('Alice', 'Female', 'English')
    
    who_am_i(p)
    who_am_i(s)
    who_am_i(t)

    运行结果:

    I am a Person, my name is Tim
    I am a Student, my name is Bob
    I am a Teacher, my name is Alice

    这种行为称为多态。也就是说,方法调用将作用在 x 的实际类型上。s 是Student类型,它实际上拥有自己的 whoAmI()方法以及从 Person继承的 whoAmI方法,但调用 s.whoAmI()总是先查找它自身的定义,如果没有定义,则顺着继承链向上查找,直到在某个父类中找到为止。

    由于Python是动态语言,所以,传递给函数 who_am_i(x)的参数x 不一定是 Person 或 Person 的子类型。任何数据类型的实例都可以,只要它有一个whoAmI()的方法即可:

    class Book(object):
        def whoAmI(self):
            return 'I am a book'

    这是动态语言和静态语言(例如Java)最大的差别之一。动态语言调用实例方法,不检查类型,只要方法存在,参数正确,就可以调用。

    任务

    Python提供了open()函数来打开一个磁盘文件,并返回 File 对象。File对象有一个read()方法可以读取文件内容:

    例如,从文件读取内容并解析为JSON结果:

    import json
    f = open('/path/to/file.json', 'r')
    print json.load(f)

    由于Python的动态特性,json.load()并不一定要从一个File对象读取内容。任何对象,只要有read()方法,就称为File-like Object,都可以传给json.load()

    请尝试编写一个File-like Object,把一个字符串 r'["Tim", "Bob", "Alice"]'包装成 File-like Object 并由 json.load() 解析。

    ?不会了怎么办

    只要为Students类加上 read()方法,就变成了一个File-like Object

    参考代码:

    import json
    
    class Students(object):
        def read(self):
            return r'["Tim", "Bob", "Alice"]'
    
    s = Students()
    
    print json.load(s)

    展开全文
  • 子类对父类中的函数进行了重写,当父类指针(或引用)指向子类对象时,调用是子类重写后函数 那么这就引入了重写和重载概念? 重载:函数名相同,参数列表不同,重载只在类内部实现。在调用时,会...

    什么是多态呢?

      简单粗爆的理解就是:接口可以用不同的方式实现,可以写出通用的代码

      子类对父类中的函数进行了重写,当父类的指针(或引用)指向子类的对象时,调用的是子类重写后的函数

    那么这就引入了重写和重载的概念?

      重载:函数名相同,参数列表不同,重载只在类的内部实现。在调用时,会根据传参不同调用不同的函数。

      重写:也要覆盖,子类重新定义父类中有相同名称和参数的虚函数,主要在继承中体现。

    C++实现多态需要必备3大特性?

       (1)要有继承 class B: public A {}

       (2)父类的函数需是虚函数 victure,子类可以进行重写

       (3)父类的指针或引用指向子类的对象    A *a = new B()

     

    展开全文
  • Python多态的两种实现形式

    万次阅读 2020-10-27 18:25:50
    以下是Python伪代码实现Java或C的多态: class A(object): def test(self): print('A test') class B(A): def test(self): print('B test') class C(A): def test(self): print('C t

    一、Python多态

    1.对象多态

    对象多态:在继承体系中,定义时的类型和运行时的类型不一样,此时就构成多态

    以下是Python伪代码实现Java或C的多态:

    class A(object):
        def test(self):
            print('A test')
    
    
    class B(A):
        def test(self):
            print('B test')
    
    
    class C(A):
        def test(self):
            print('C test')
    
    
    def go(a):
        """
        接收A类或其子类实例
        :param a:
        :return:
        """
        a.test()
    
    
    if __name__ == '__main__':
        go(A())
        go(B())
        go(C())

    执行结果:

    由此可见,go函数接收A类或其子类对象,无论是传递A类对象、B类对象、C类对象,方法都可以正常执行, 此时便构成了对象的多态。

     

    2.类多态

    类多态:指通过@classmethod形式多态地构造对象,而不是使用Python默认的__init__构造器

    需求:实现一套MapReduce流程,用于统计目录下所有文件的总行数,代码如下:

    """
    知识要点:
        1.接口 抽象 继承
        2.生成器
        3.map reduce
        4.多线程
        5.通过@classmethod形式批量创建对象
    """
    import os
    import threading
    
    
    class GenericInputData(object):
        """
        通用输入抽象类 抽象方法由子类实现
        """
        def read(self):
            raise NotImplementedError
    
        @classmethod
        def generate_inputs(cls, config):
            raise NotImplementedError
    
    
    class FileInputData(GenericInputData):
        """
        文件输入类
        """
        def __init__(self, path):
            super().__init__()
            self.path = path
    
        def read(self):
            return open(self.path, 'r', encoding='utf-8').read()
    
        @classmethod
        def generate_inputs(cls, config):
            dir_path = config['dir_path']
            for file_name in os.listdir(dir_path):
                yield cls(os.path.join(dir_path, file_name))
    
    
    class GenericWorker(object):
        """
        通用Worker抽象类 抽象方法由子类实现
        """
        def __init__(self, input_data):
            self.input_data = input_data
            self.result = None
    
        def map(self):
            raise NotImplementedError
    
        def reduce(self, other):
            raise NotImplementedError
    
        @classmethod
        def generate_workers(cls, input_class, config):
            for input_data in input_class.generate_inputs(config):
                yield cls(input_data)
    
    
    class LineCountWorker(GenericWorker):
        """
        统计文件换行符Worker类
        """
        def map(self):
            content = self.input_data.read()
            self.result = content.count('\n')
    
        def reduce(self, other):
            self.result += other.result
    
    
    def execute(workers):
        threads = [threading.Thread(target=w.map) for w in workers]
        for thread in threads:
            thread.start()
            thread.join()
    
        first, rest = workers[0], workers[1:]
        for other in rest:
            first.reduce(other)
    
        return first.result
    
    
    def map_reduce(input_class, worker_class, config):
        gen_workers = worker_class.generate_workers(input_class, config)
        workers = list(gen_workers)
        return execute(workers)
    
    
    if __name__ == '__main__':
        result = map_reduce(FileInputData, LineCountWorker, {'dir_path': 'temp'})
        print(result)
    

    由此可见,在Python中,不仅可以通过__init__构造器创建对象,也可以通过@classmethod形式多态地构建对象。

     

    展开全文
  •  对于其他如C++语言,多态是通过在基类函数前加上virtual关键字,在派生类重写该函数,运行时将会根据对象实际类型来调用相应函数。如果对象类型是派生类,就调用派生类函数;如果对象类型是基类,就...
  • 多态指的是一类事物有多种形态,(一个抽象类有多个子类,因而多态的概念依赖于继承) 序列类型有多种形态:字符串,列表,元组 动物有多种形态:人,狗,猪 #多态:同一种事物的多种形态,动物分为人类,猪类...
  • Python 多态的实现

    2008-10-31 17:47:38
    多态是面向对象语言一个重要功能....下面演示Python语言中的一个多态 class aa: def __init__(self): pass def get(self): d=5 return d class bb(aa): def __init__(self): ...
  • Python 3.6:多态的实现

    2018-11-27 14:04:07
    多态的作用不用多说,C++用如下条件来实现多态: 要有继承 要有虚函数函数重写 要有父类指针(父类引用)指向子类对象 实际上C++使用VPTR指针来完成这个事情,其是设计模式的基础,软件分层的基石。最近看了一下...
  • 关于Python的多态问题

    2020-05-25 08:44:33
    2.继承 实现代码重用,相同代码不需要重复编写 •设计类技巧 •子类针对自己特有需求,编写特定代码 3.多态 不同 子类对象 调用相同 父类方法,产生不同执行结果 •多态 可以 增加代码灵活度 •...
  • Python-多态

    2018-09-08 09:52:22
    面向对象三大特性: 1. 封装:封装是根据职责将属性和方法封装到一个抽象类,是定义类准则,在python面向对象基础语法和面向对象封装案例详细介绍...3. 多态多态实现了不同子类对象调用相同父类方法...
  • python-多态

    2020-09-02 17:14:00
    继承实现代码重用,相同代码不需要重复编写 设计类技巧 子类针对自己特有需求,编写特定代码 多态不同子类对象调用相同父类方法,产生不同执行结果 多态可以增加代码灵活度 以继承和重写...
  • python多态

    2020-03-04 07:13:30
    实现代码重用,相同代码不需要重复编写 设计类技巧 子类针对自己特有需求,编写特定代码 多态 不同 子类对象 调用相同 父类方法,产生不同执行结果 多态 可以 增加代码灵活度 以 继承 和 ...
  • python多态

    2019-11-02 11:11:40
    2.继承 实现代码重用,相同代码不需要重复编写 设计类技巧 子类针对自己特有需求,编写特定代码 3.多态 不同 子类对象 调用相同 父类方法,产生不同执行结果 多态 可以 增加代码灵活度 以 ...
  • python中的多态

    2019-09-23 18:49:44
    面向对象有封装,继承,多态三大特性,我们在这里主要介绍python中的多态.多态(Polymorphism)按字面的意思就是“多种状态”。在面向对象语言中,接口的多种不同的实现方式即为多态。引用Charlie Calverts对多态的描述...
  • Python多态

    2020-06-14 10:58:14
    定义:堕胎是一种使用对象方式,子类重写父类方法,调用不同子类对象相同父类方法,可以产生不同结果 好处:调用灵活,有了多态,更容易编写通用代码 实现步骤: 1、定义父类,并提供公共方法
  • 53 python - 多态

    2019-08-16 15:43:08
    多态的概念是应用于Java和C#这一类强类型语言,而Python崇尚“鸭子类型”。 所谓多态:定义时的类型和运行时的类型不一样,此时就成为多态 Python伪代码实现Java或C#的多态 class F1(object): def show(self): ...
  • Python中的多态

    2021-01-14 17:23:57
    在面向对象语言,接口的多种不同的实现方式即为多态。 引用Charlie Calverts对多态的描述——多态性是允许你将父对象设置成为一个或更多的他的子对象相等的技术,赋值之后,父对象就可以根据当前赋值给它的子对象...
  • python多态

    2019-04-02 20:56:38
    封装根据职责将属性和方法封装到一个抽象 定义类准则 继承 实现代码重用 ,相同代码不需要重复编写 设计类技巧 子类针对自己特有需求,编写特定代码 多态 不同 子类对象 调用相同 ...
  • 19.python-多态

    千次阅读 2019-11-28 00:44:38
    继承实现代码重用,相同代码不需要重复编写 设计类技巧 子类针对自己特有需求,编写特定代码 多态不同子类对象调用相同父类方法,产生不同执行结果 多态可以增加代码灵活度 以继承...
  • python多态、封装

    2018-07-01 22:05:50
    多态:1、多态意思是"有多种形式"...它在类继承得以实现,在类方法调用得以体现。多态意味着变量并不知道引用对象是什么,根据引用对象不同表现不同行为方式。例1:def add(x,y): p...
  • Python有没有多态???这个问题老是被问起来,答案是有python这么强大,有什么理由没有多态? 那么我们来看看什么叫多态? 这是C#语言子类对父类重写,其实不难...但是我想说这个在C#等语言是可以实现的。这怎
  • 第十五天Python多态

    2020-07-30 23:00:45
    继承 实现代码重用, 相同代码不需要重复编写 - 设计类技巧 - 子类针对自己特有需求,编写特定代码 多态 不同 子类对象 调用相同 父类方法, 产生不同执行结果 - 多态 可以 增加代码灵活度 - 以...
  • 文章目录1、Python中的多态多态的定义多态的好处多态实现步骤2、体验多态 1、Python中的多态 多态的定义 多态是一种使用对象的方式,子类重写父类方法,不同的子类对象调用相同的父类方法,可以产生不同的执行结果。...
  • python多态深刻理解

    2019-06-30 21:27:06
    python中多态: 在很多网上的资料中将python中多态讲述的过于抽象,不利于理解这里我讲述一下什么是python的多态 python本身就是基于多态的。因此在许多网上资料说要继承父类我认为不是必要的。因为python可以任意...

空空如也

空空如也

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

python中多态的实现

python 订阅