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

    千次阅读 2019-05-29 16:40:53
    python中多态 类具有继承关系,并且子类类型可以向上转型看做父类类型,如果我们从Person派生出Student和Teacher,并都写了一个whoAmI()方法 class Person(object): def __init__(self, name, gender): self....

    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,则无论该 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() 解析。

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

    转自:廖雪峰

    展开全文
  • Python中多态

    2019-08-01 23:40:31
    这种行为称为多态。也就是说,方法调用将作用在 x 的实际类型上。 s 是Student类型,它实际上拥有自己的 whoAmI() 方法以及从 Person继承的 whoAmI方法,但调用 s.whoAmI() 总是先查找它自身的定义,如果没有...

    类具有继承关系,并且子类类型可以向上转型看做父类类型,如果我们从 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,则无论该 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'
        
    def who_am_i(x):
        print(x.whoAmI())
    
    b = Book()
    who_am_i(b)
    

    结果为:

    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))
    

    结果为:

    [‘Tim’, ‘Bob’, ‘Alice’]


    大家加油!
    学习链接: https://www.imooc.com/code/6247

    展开全文
  • classPerson(object):def__init__(self,name,gender):self.name=nameself.gender=genderdefwhoAmI(self):return'IamaPerson,mynameis%s'%self.nameclassStudent(Person):def__init__(self,name...

    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)

    展开全文
  • 本篇文章给大家带来的内容是关于python中多态的实例解析(详细),有一定的参考价值,有需要的朋友可以参考一下,希望对你有所帮助。class Human(object): # 父类 :创建“人”类def __init__(self):print('Ill pound ...

    本篇文章给大家带来的内容是关于python中多态的实例解析(详细),有一定的参考价值,有需要的朋友可以参考一下,希望对你有所帮助。class Human(object): # 父类 :创建“人”类

    def __init__(self):

    print('Ill pound the code and buy you a bag') # 我会敲打码,给你买包包

    class Man(Human): # 1)子类1 创建“男人”类

    def __init__(self):

    print('In hs, we should have the knowledge to drink wine.The President up, the kitchen down') # 在衡水,要文武双全,有知识,会喝酒;上的总裁,下的厨房

    class Woman(Human):# 2)子类2 创建“女人”类

    def __init__(self):

    print('If a man loves me, I dont care if he has a house or a car.Woman?Do you believe a') # 如果男人爱我,我不会在意他有没有房子车子。呵呵女人啊?你信了那只能说明你太天真了。

    print('human:')

    h = Human()

    print('man:')

    m = Man()

    print('woman:')

    w = Woman() # 分别对 人类、男人类、女人类创建一个变量h、m、w

    print(isinstance(h,Human))#isinstance举例

    print(isinstance(m,Man))

    print(isinstance(m,Human)) # 分别判断h是人类吗、m是男人类吗、m是人类吗,输出结果全部为是。

    #输出结果是:

    # human:

    # Ill pound the code and buy you a bag

    # man:

    # In hs, we should have the knowledge to drink wine.The President up, the kitchen down

    # woman:

    # If a man loves me, I dont care if he has a house or a

    car.Woman?Do you believe a

    # True

    # True

    # True

    这就是变量的多态;另外当m调用__init__方法时输出的内容和Human的__init__是不一样的,这就是多态之函数的多态。

    鸭子类型:

    参考鸭子类型,鸭子类型(英语:duck typing)是动态类型的一种风格。在这种风格中,一个对象有效的语义,不是由继承自特定的类或实现特定的接口,而是由"当前方法和属性的集合"决定。这个概念的名字来源于由James Whitcomb Riley提出的鸭子测试,“鸭子测试”可以这样表述:

    “当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子,那么这只鸟就可以被称为鸭子。”

    在鸭子类型中,关注的不是对象的类型本身,而是它是如何使用的。例如,在不使用鸭子类型的语言中,我们可以编写一个函数,它接受一个类型为"鸭子"的对象,并调用它的"走"和"叫"方法。在使用鸭子类型的语言中,这样的一个函数可以接受一个任意类型的对象,并调用它的"走"和"叫"方法。如果这些需要被调用的方法不存在,那么将引发一个运行时错误。任何拥有这样的正确的"走"和"叫"方法的对象都可被函数接受的这种行为引出了以上表述,这种决定类型的方式因此得名。

    鸭子类型通常得益于"不"测试方法和函数中参数的类型,而是依赖文档、清晰的代码和测试来确保正确使用。

    综上:鸭子类型,就是使用了貌似不属于自己的方法(其他函数的方法),自己这个 函数,实例化后会改变本质

    展开全文
  • 89. Python中 多态的理解
  • python中多态与java中多态

    千次阅读 2014-02-17 14:32:37
    python中多态  A function that can operate on more than one type. If all the operations in a function can be applied to a type, then the function can be applied to a type. 一个函数可以使用在不同...
  • Python不支持多态,也不用支持多态python是一种多态语言,崇尚鸭子类型。一个对象有效的语义,不是由继承自特定的类或实现特定的接口,而是由当前方法和属性的集合决定。多态是允许将父对象设置成为和一个或多个它...
  • 多态的概念其实不难理解,它是指对不同类型的变量进行相同的操作,它会根据对象(或类)类型的不同而表现出不同的行为。事实上,我们经常用到多态的性质,比如:>>>1+23>>>'a'+'b''ab'可以看到,...
  • 对于其他如C++的语言,多态是通过在基类的函数前加上virtual关键字,在派生类重写该函数,运行时将会根据对象的实际类型来调用相应的函数。如果对象类型是派生类,就调用派生类的函数;如果对象类型是基类,就调用...
  • 3、python中多态 1、什么是多态 要理解什么是多态,我们首先要对数据类型再作一点说明。当我们定义一个class的时候,我们实际上就定义了一种数据类型。我们定义的数据类型和Python自带的数据类型,比如str、...
  • 文章目录1、什么是多态“开闭”原则2、静态语言 vs 动态语言小结3、python中多态 1、什么是多态 要理解什么是多态,我们首先要对数据类型再作一点说明。当我们定义一个class的时候,我们实际上就定义了一种数据类型...
  • 多态是指不同的子类在继承父类后分别都重写覆盖了父类的方法,即父类同一个方法,在继承的子类表现出不同的形式。多态成立的另一个条件是在创建子类时候必须使用父类new子类的方式。Fuf1=newZi1();Fuf2=newZi2();...
  • Python是一种纯粹的面向对象语言。面向对象编程的四大特征分别是:抽象、封装、继承和多态多态根据上下文,对象可以采用...Python本身就是一种多态语言:上述程序,参数a和b可以接收不同的数据类型。当a和b同...
  • 文章目录1、什么是多态“开闭”原则2、静态语言 vs 动态语言小结3、python中多态1、什么是多态要理解什么是多态,我们首先要对数据类型再作一点说明。当我们定义一个class的时候,我们实际上就定义了一种数据类型。...
  • 一、多态多态是指一类事物有多种形态,比如动物类,可以有猫,狗,猪等等。(一个抽象类有多个子类,因而多态的概念依赖于继承)import abcclass Animal(metaclass=abc.ABCMeta):#同一类事物:动物@abc....
  • 学习到多态的时候,不确定自己是否完全理解了python多态,于是Google观看了众多资料和文献,发现很多编程大佬讲得过于抽象,不便于新手理解,这违背了python的初衷:简单。 所以我在此用通俗一点的方式作了一个...
  • 多态多态指的是一类事物有多种形态,(一个抽象类有多个子类,因而多态的概念依赖于继承)序列类型有多种形态:字符串,列表,元组动物有多种形态:人,狗,猪#多态:同一种事物的多种形态,动物分为人类,猪类...
  • python中多态简单介绍

    2018-10-25 14:49:56
    多态是指相同的信息发给不同的对象会引发不同的动作 """ class A: def __init__(self,name=""): self.name=name def show(self): print("A show ", self.name) class A1(A...
  • 1. python多态,但是不是一个严谨的多态,因为Python是一个动态语言,没有强制类型 封装 一个函数一个功能,一个类是多个相关函数的集合 继承 子类相同的方法会放到父类,减少代码重复性 mro 及多...
  • Python中多态不是语法,而是一种设计思想,多态的设计就是要完成对不同类型对象使用相同方法调用能得到各自期望的结果。 # 多态:同一种事物的多种形态,动物分为人、猪、狗等等 class Animal: def run(self): ...
  • python面向对象有三特征:继承、封装、多态 多态怎么理解? 一类事物,有多种形态,比如动物类,可以有猫、狗、鸡。一个抽象类有许多子类 # 作者:小白jiang class Animal(object): def talk(self): pass class ...
  • 多态多态指的是一类事物有多种形态,(一个抽象类有多个子类,因而多态的概念依赖于继承) 序列类型有多种形态:字符串,列表,元组 动物有多种形态:人,狗,猪 #多态:同一种事物的多种形态,动物...

空空如也

空空如也

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

python中多态

python 订阅