精华内容
下载资源
问答
  • python中的多态是什么 Python中的多态 (Polymorphism in Python) Polymorphism is a concept of Object Oriented Programming, which means multiple forms or more than one form. Polymorphism enables using a ...

    python中的多态是什么

    Polymorphism is a concept of Object Oriented Programming, which means multiple forms or more than one form. Polymorphism enables using a single interface with input of different datatypes, different class or may be for different number of inputs.

    多态是面向对象编程的概念,它表示多种形式或一种以上形式。 多态性使单个接口可以使用不同数据类型,不同类别或可能用于不同数量输入的输入。

    In python as everything is an object hence by default a function can take anything as an argument but the execution of the function might fail as every function has some logic that it follows.

    在python中,由于所有事物都是对象,因此默认情况下,函数可以将任何事物作为参数,但是由于每个函数都有其遵循的逻辑,因此函数的执行可能会失败。

    For example,

    例如,

    len("hello")      # returns 5 as result
    len([1,2,3,4,45,345,23,42])     # returns 8 as result

    In this case the function len is polymorphic as it is taking string as input in the first case and is taking list as input in the second case.

    在这种情况下,函数len是多态的,因为在第一种情况下函数以字符串为输入,在第二种情况下函数以list为输入。

    In python, polymorphism is a way of making a function accept objects of different classes if they behave similarly.

    在python中,多态是一种使函数接受行为不同的类的方法。

    Method overriding is a type of polymorphism in which a child class which is extending the parent class can provide different definition to any function defined in the parent class as per its own requirements.

    方法重写是一种多态性,其中扩展父类的子类可以根据其自身的要求为父类中定义的任何函数提供不同的定义。

    方法重载 (Method Overloading)

    Method overloading or function overloading is a type of polymorphism in which we can define a number of methods with the same name but with a different number of parameters as well as parameters can be of different types. These methods can perform a similar or different function.

    方法重载或函数重载是一种多态性,其中我们可以定义许多名称相同但参数数量不同的方法,并且参数可以具有不同的类型。 这些方法可以执行相似或不同的功能。

    Python doesn't support method overloading on the basis of different number of parameters in functions.

    Python不支持基于函数中不同数量参数的方法重载。

    定义多态类 (Defining Polymorphic Classes)

    Imagine a situation in which we have a different class for shapes like Square, Triangle etc which serves as a resource to calculate the area of that shape. Each shape has a different number of dimensions which are used to calculate the area of the respective shape.

    想象一下一种情况,我们对于正方形,三角形等形状有不同的类,可作为计算该形状面积的资源。 每个形状都有不同数量的尺寸,用于计算各个形状的面积。

    Now one approach is to define different functions with different names to calculate the area of the given shapes. The program depicting this approach is shown below:

    现在一种方法是用不同的名称定义不同的函数,以计算给定形状的面积。 下面显示了描述此方法的程序:

    class Square:
        side = 5     
        def calculate_area_sq(self):
            return self.side * self.side
    
    class Triangle:
        base = 5
        height = 4
        def calculate_area_tri(self):
            return 0.5 * self.base * self.height
    
    sq = Square()
    tri = Triangle()
    print("Area of square: ", sq.calculate_area_sq())
    print("Area of triangle: ", tri.calculate_area_tri())

    Area of square: 25 Area of triangle: 10.0

    正方形面积:25三角形面积:10.0

    The problem with this approach is that the developer has to remember the name of each function separately. In a much larger program, it is very difficult to memorize the name of the functions for every small operation. Here comes the role of method overloading.

    这种方法的问题在于,开发人员必须分别记住每个函数的名称。 在更大的程序中,很难记住每个小操作的功能名称。 这就是方法重载的作用。

    Now let's change the name of functions to calculate the area and give them both same name calculate_area() while keeping the function separately in both the classes with different definitions. In this case the type of object will help in resolving the call to the function. The program below shows the implementation of this type of polymorphism with class methods:

    现在,让我们更改函数的名称以计算面积,并为它们赋予相同的名称calculate_area()同时在具有不同定义的两个类中分别保留函数。 在这种情况下,对象的类型将有助于解决对该函数的调用。 下面的程序使用类方法显示了这种多态性的实现:

    class Square:
        side = 5     
        def calculate_area(self):
            return self.side * self.side
    
    class Triangle:
        base = 5
        height = 4
        def calculate_area(self):
            return 0.5 * self.base * self.height
    
    sq = Square()
    tri = Triangle()
    print("Area of square: ", sq.calculate_area())
    print("Area of triangle: ", tri.calculate_area())

    Area of square: 25 Area of triangle: 10.0

    正方形面积:25三角形面积:10.0

    As you can see in the implementation of both the classes i.e. Square as well as Triangle has the function with same name calculate_area(), but due to different objects its call get resolved correctly, that is when the function is called using the object sq then the function of class Square is called and when it is called using the object tri then the function of class Triangle is called.

    正如您在两个类(即SquareTriangle的实现中所看到的那样,该函数具有相同的名称calculate_area() ,但是由于对象不同,因此其调用可以正确解析,也就是说,使用对象sq调用该函数时,调用Square类的函数,并且使用对象tri调用该函数时,将调用Triangle类的函数。

    类方法的多态 (Polymorphism with Class Methods)

    What we saw in the example above is again obvious behaviour. Let's use a loop which iterates over a tuple of objects of various shapes and call the area function to calculate area for each shape object.

    在上面的示例中,我们再次看到了明显的行为。 让我们使用一个循环,该循环遍历各种形状的对象的元组,并调用area函数来计算每个形状对象的面积。

    sq = Square()
    tri = Triangle()
    
    for(obj in (sq, tri)):
        obj.calculate_area()

    Now this is a better example of polymorphism because now we are treating objects of different classes as an object on which same function gets called.

    现在,这是一个更好的多态示例,因为现在我们将不同类的对象视为在其上调用相同函数的对象。

    Here python doesn't care about the type of object which is calling the function hence making the class method polymorphic in nature.

    此处python不在乎调用函数的对象类型,因此实际上使类方法具有多态性。

    具有功能的多态 (Polymorphism with Functions)

    Just like we used a loop in the above example, we can also create a function which takes an object of some shape class as input and then calls the function to calculate area for it. For example,

    就像在上面的示例中使用循环一样,我们还可以创建一个函数,该函数将某个形状类的对象作为输入,然后调用该函数为其计算面积。 例如,

    find_area_of_shape(obj):
        obj.calculate_area()
    
    sq = Square()
    tri = Triangle()
    
    # calling the method with different objects
    find_area_of_shape(sq)
    find_area_of_shape(tri)

    In the example above we have used the same function find_area_of_shape to calculate area of two different shape classes. The same function takes different class objects as arguments and executes perfectly to return the result. This is polymorphism.

    在上面的示例中,我们使用了相同的函数find_area_of_shape计算两个不同形状类的面积。 相同的函数采用不同的类对象作为参数,并完美执行以返回结果。 这是多态性。

    翻译自: https://www.studytonight.com/python/python-polymorphism

    python中的多态是什么

    展开全文
  • python中的多态

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

    面向对象有封装,继承,多态三大特性,我们在这里主要介绍python中的多态.

    多态(Polymorphism)按字面的意思就是“多种状态”。在面向对象语言中,接口的多种不同的实现方式即为多态。引用Charlie Calverts对多态的描述——多态性是允许你将父对象设置成为一个或更多的他的子对象相等的技术,赋值之后,父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作(摘自“Delphi4 编程技术内幕”)。简单的说,就是一句话:允许将子类类型的指针赋值给父类类型的指针。多态性在Object Pascal和C++中都是通过虚函数实现的。

    上面所说的多态必须是在有继承的前提下,然而python中的多态却也可以继承就实现多态.

    先来看一个有继承版的多态,传入函数fun中的对象不一样便会产生不同执行效果

    class Animal(object):
        def eat(self):
            pass
    
    
    class Dog(object):
        def eat(self):
            print('eat fish')
    
    
    class Cat(object):
        def eat(self):
            print('eat bone')
    
    
    def fun(obj):
        obj.eat()
    
    
    def main():
        fun(Dog())
        fun(Cat())
    
    
    if __name__ == '__main__':
        main()

        但如果我们把Dog和Cat的父类Animal去除掉之后会发现,程序依旧是可以执行的,也就是python中的多态并非是严格意义上的多态,只要对象中存在eat()方法便可以将该对象传入fun中执行.



    转载于:https://www.cnblogs.com/fanlei5458/p/9235491.html

    展开全文
  • Python中的多态

    2018-02-26 21:40:26
    Python中的多态不同于C++、Java中的多态,没有前者要求的严格。class Dog(object): def print_self(self): print("大家好!") class Dog_2(Dog): def print_self(self): print("hello everyone!...

    Python中的多态不同于C++、Java中的多态,没有前者要求的严格。

    class Dog(object):
        def print_self(self):
            print("大家好!")
    class Dog_2(Dog):
        def print_self(self):
            print("hello everyone!")
    
    def introduce(temp):#多态的体现
        temp.print_self()#如果temp是传入的子类对象则调用子类的此方法,反之调用父类的方法。
    
    dog1 = Dog()
    dog2 = Dog_2()
    introduce(dog1)
    introduce(dog2)

    打印结果:

    #大家好!

    #hello everyone!

    Python是门动态语言,所以调用时不会检查类型,只要有这个方法,参数正确就能正常运行。

    这就是Python的多态



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

    面向对象有封装,继承,多态三大特性,我们在这里主要介绍python中的多态.

    多态(Polymorphism)按字面的意思就是“多种状态”。在面向对象语言中,接口的多种不同的实现方式即为多态。引用Charlie Calverts对多态的描述——多态性是允许你将父对象设置成为一个或更多的他的子对象相等的技术,赋值之后,父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作(摘自“Delphi4 编程技术内幕”)。简单的说,就是一句话:允许将子类类型的指针赋值给父类类型的指针。多态性在Object Pascal和C++中都是通过虚函数实现的。

    上面所说的多态必须是在有继承的前提下,然而python中的多态却也可以继承就实现多态.

    先来看一个有继承版的多态,传入函数fun中的对象不一样便会产生不同执行效果class Animal(object):

    def eat(self):

    pass

    class Dog(object):

    def eat(self):

    print('eat fish')

    class Cat(object):

    def eat(self):

    print('eat bone')

    def fun(obj):

    obj.eat()

    def main():

    fun(Dog())

    fun(Cat())

    if __name__ == '__main__':

    main()

    但如果我们把Dog和Cat的父类Animal去除掉之后会发现,程序依旧是可以执行的,也就是python中的多态并非是严格意义上的多态,只要对象中存在eat()方法便可以将该对象传入fun中执行.

    展开全文
  • Python 中的多态

    2019-07-17 22:16:47
    多态概念:不同子类对象调用了相同父类方法,产生不同结果 特点:调用方法技巧 class A(object): def __init__(self, name): self.name = name def work(self): print("我是父类A工作方法") class...
  • 再谈python中的多态

    万次阅读 2011-12-13 09:50:37
    以前写过一篇文章讲了一下python中的多态,最后得出结论python不支持多态,随着对python理解得加深,对python中得多态又有了一些看法。 首先python不支持多态,也不用支持多态,python是一种多态语言,崇尚鸭子类型...
  • python 中的多态

    2015-08-12 17:39:00
    动态语言的多态和静态语言c++等多态含义不太一样,c++中的多态就是参数数量和类型不同的方法就是不同方法,而动态语言中的多态其实值的是方法的寻找过程,即向右找到类(或者单件类),在类中找不到的话再找父类,...
  • Python部落(python.freelycode.com)组织翻译,禁止转载,欢迎转发在SmartFile,在工程生活方面我们已经习惯了使用很多非常棒技术使得开发工作更加迅速并且可控(参考开放闭合原则)。通过使用一些简单模式,我们...
  • 本文实例讲述了Python编程之多态用法。分享给大家供大家参考。具体分析如下:什么是多态?顾名思义,多态就是多种表现形态意思。它是一种机制、一种能力,而非某个关键字。它在类继承得以实现,在类方法调用...
  • Python中的多态的理解

    2020-06-04 22:22:05
    Python中的多态 类具有继承关系,子类类型可以向上转型看做是父类类型 class Animal(object): def __init__(self,name): self.name = name def speak(self): print("animal is speaking") class Dog(Animal): ...
  • 多态的概念其实不难理解,它是指对不同类型变量进行相同操作,它会根据对象(或类)类型不同而表现出不同行为。事实上,我们经常用到多态的性质,比如:>>>1 23>>>'a' 'b''ab'可以看到,...
  • 因为前面的三个特性是多态的基础,了解了前三个,了解多态就很容易啦~那么,什么是多态呢~直接看编程语言中的定义稍显枯燥,我们还是先给大家举一些生活中常见的例子。多态指的是一类事物有多种形态,比如说动物,有...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,145
精华内容 1,258
关键字:

python中的多态

python 订阅