精华内容
下载资源
问答
  • 主要介绍了Python面向对象多态实现原理及代码实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • python 面向对象 多态

    2019-02-19 18:27:00
    什么是多态 在不考虑实例类型的情况下使用实例 例子 peo=People() dog=Dog() pig=Pig() def func(obj): obj.talk() func(pig) 鸭子类型 #如果看起来像、叫声像而且走起路来像鸭子,...
    1. 什么是多态
      在不考虑实例类型的情况下使用实例
    2. 例子
      peo=People()
      dog=Dog()
      pig=Pig()
      
      def func(obj):
          obj.talk()
      
      func(pig)
    3. 鸭子类型
      #如果看起来像、叫声像而且走起路来像鸭子,那么它就是鸭子,嘿嘿
      在鸭子类型中,关注的不是对象的类型本身,而是它是如何使用的。例如,在不使用鸭子类型的语言中,我们可以编写一个函数,它接受一个类型为鸭的对象,并调用它的走和叫方法。
      优点:松耦合,每个相似类之间没有影响
      缺点:太随意,没有规范
    4. 鸭子类型例子
      #二者看起来都像文件,因而就可以当文件一样去用
      class TxtFile:
          def read(self):
              pass
      
          def write(self):
              pass
      
      class DiskFile:
          def read(self):
              pass
          def write(self):
              pass

    转载于:https://www.cnblogs.com/walthwang/p/10402814.html

    展开全文
  • 原标题:Python面向对象:封装和多态一、封装封装是隐藏对象的属性和实现细节,仅对外公开接口,控制在程序中属性的读取和修改的访问级别。封装就是将抽象得到的数据和行为(或功能)相结合,形成一个有机的整体,也...

    原标题:Python面向对象:封装和多态

    一、封装

    封装是隐藏对象的属性和实现细节,仅对外公开接口,控制在程序中属性的读取和修改的访问级别。

    封装就是将抽象得到的数据和行为(或功能)相结合,形成一个有机的整体,也就是将数据与操作数据的源代码进行有机的结合,形成“类”,其中数据和函数都是类的成员。

    1、简单理解封装

    顾名思义,封装属性就是把已有的属性封装到一个类里面去:

    class Person():

    def __init__(self, name, age, sex):

    self.name = name

    self.age = age

    self.sex = sex

    jack = Person('jack', 18, '男')

    #将jack、 18、 男 封装到jack对象(self)的name、age、sex中

    #name、age、sex又封装在了Person类中

    print(jack.__dict__)

    #{'name': 'jack', 'age': 18, 'sex': '男'}

    分析:self是一个形式参数,创建什么对象,它就代表那个对象

    2、调用封装的属性

    通过对象直接调用:

    class Person():

    def __init__(self, name, age, sex):

    self.name = name

    self.age = age

    self.sex = sex

    jack = Person('jack', 18, '男')

    print(jack.name, jack.sex, jack.age)

    #jack 男 18

    分析:在这里,我们可以用对象名随意调用到自身的属性,并进行属性修改,从安全的角度来看,这样是很不安全的,所以需要将属性隐藏起来,也就是私有化。

    私有化属性的方法:类中定义私有的,只有类内部使用,外部无法访问(比如_(杠) __(杠杠) )

    class Person():

    def __init__(self, name, age, sex):

    self.__name = name

    self.__age = age

    self.__sex = sex

    jack = Person('jack', 18, '男')

    print(jack._Person__name)#jack

    print(jack.name)

    #Error:'Person' object has no attribute 'name'

    分析:

    1、通过使用__(杠杠)的方法使得类Person属性name、age、sex成功私有化,子类无法直接调用,但是通过jack._Person__name的方式可以调用到私有化的属性,并且能对其修改,说明python在设置私有属性的时候,只是把属性的名字换成了其他的名字。

    2、类中以_或者__的属性,都是私有属性,禁止外部调用。虽然可以通过特殊的手段获取到,并且赋值,但是这么做不觉的很蛋疼么,本来就是设置私有属性,还非要去强制修改。

    私有化属性设置好了,不可能是存在那里谁都不让使用的,要不然设置私有化属性就失去了本身的意义,我们只是不想让私有化属性直接被随意的修改,而不是拒绝访问,所以还需要给私有化属性提供查找和修改的接口,我们只需要通过对接口的控制,就能有效的控制私有化属性的数据安全,比如对接口进行设置,就不会出现age被赋值为负数。

    class Person(object):

    def __init__(self, name, age, sex):

    self.__name = name

    self.__age = age

    self.__sex = sex

    def get_age(self):

    return self.__age

    def set_age(self, age):

    if age > 150 or age < 0:

    print('年龄必须大于0,小于150')

    else:

    self.__age = age

    jack = Person('jack', 18, '男')

    #访问age属性

    print(jack.get_age())#18

    #修改age属性

    jack.set_age(100)

    print(jack.get_age())#100

    #非法修改age属性

    jack.set_age(-20)#年龄必须大于0,小于150

    print(jack.get_age())#100

    分析:这样就完美了,我们既可以访问到实例化对象内部的属性,也可以在数据安全的情况下(禁止非法数据修改),修改对象的属性

    3、python自带的调用私有化数据的方法

    前面,我们用set和get的方式来调用或修改对象本身的私有化属性,达到了数据安全的目的,其实python中提供了一种直接用obj.属性名的方式调用类的私有化属性,也能保证数据安全。

    class Person(object):

    def __init__(self, name, age, sex):

    self.__name = name

    self.__age = age

    self.__sex = sex

    @property

    def age(self):

    return self.__age

    @age.setter

    def age(self, age):

    if age > 150 or age < 0:

    print('年龄必须大于0,小于150')

    else:

    self.__age = age

    jack = Person('jack', 18, '男')

    #访问age属性

    print(jack.age)#18

    #修改age属性

    jack.age = 100

    print(jack.age)#100

    #非法修改age属性

    jack.age = -20#年龄必须大于0,小于150

    print(jack.age)#100

    分析:

    1、使用 @property 装饰器时,接口名不必与属性名相同。

    2、凡是赋值语句,就会触发set方法。获取属性值,会触发get方法。

    3、我们可以使用@property装饰器来创建只读属性,@property装饰器会将方法转换为相同名称的只读属性,可以与所定义的属性配合使用,这样可以防止属性被修改。

    二、多态

    接口的多种不同的实现方式即为多态。

    多态最核心的思想就是,父类的引用可以指向子类的对象,或者接口类型的引用可以指向实现该接口的类的实例。

    多态是一种运行期的行为,不是编译期行为!在编译期间它只知道是一个引用,只有到了执行期,引用才知道指向的是谁。这就是所谓的“软绑定”。

    多态是一项让程序员“将改变的事物和未改变的事物分离开来”重要技术。

    1、多态性

    多态性是指指具有不同功能的函数可以使用相同的函数名,这样就可以用一个函数名调用不同内容的函数。

    在面向对象方法中一般是这样表述多态性:向不同的对象发送同一条消息,不同的对象在接收时会产生不同的行为。

    不同的行为就是指不同的实现,即执行不同的函数。

    class Animals(object):

    def talk(self):

    pass

    class Person(Animals):

    def talk(self):

    print('高级语言')

    class Cat(Animals):

    def talk(self):

    print('喵喵喵')

    class Dog(Animals):

    def talk(self):

    print('汪汪汪')

    per = Person()

    cat = Cat()

    dog = Dog()

    # 定义一个统一的接口来访问

    def fun(obj):

    obj.talk()

    fun(per)#高级语言

    fun(cat)#喵喵喵

    fun(dog)#汪汪汪

    分析:

    1、per对象、cat对象、dog对象是通过Animals类实现的三种不同形态,这就是多态的体现。

    2、per、cat、dog对象都是通过fun(obj)的同一种方式调用,实现了不同的效果,这就是多态性的体现,所以多态性可以说是一个接口,多种实现

    3、多态性的优点:

    3.1、增加了程序的灵活性:以不变应万变,不论对象千变万化,使用者都是同一种形式去调用,如fun(obj)

    3.2、增加了程序额可扩展性:通过继承Animal类派生新的类(Person类、Cat类、Dog类),使用者无需更改自己的代码,还是用fun(obj)去调用

    2、鸭子类型

    调用不同的子类将会产生不同的行为,而无须明确知道这个子类实际上是什么,这是多态的重要应用场景。而在python中,因为鸭子类型(duck typing)使得其多态不是那么酷,原因是python是强类型的动态脚本语言,不使用显示数据类型声明,且确定一个变量的类型是在第一次给它赋值的时候。

    鸭子类型是动态类型的一种风格。在这种风格中,一个对象有效的语义,不是由继承自特定的类或实现特定的接口,而是由"当前方法和属性的集合"决定。这个概念的名字来源于由James Whitcomb Riley提出的鸭子测试,“鸭子测试”可以这样表述:“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子,那么这只鸟就可以被称为鸭子。”

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

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

    class Duck(object):

    def walk(self):

    print('I walk like a duck')

    def swim(self):

    print('I swim like a duck')

    class Person():

    def walk(self):

    print('this one walk like a duck')

    def swim(self):

    print('this man swim like a duck')

    def fun(obj):

    obj.walk()

    obj.swim()

    fun(Duck())

    # I walk like a duck

    # I swim like a duck

    fun(Person())

    #this one walk like a duck

    #this man swim like a duck

    分析:可以看出Pseron类拥有和Duck类一样的方法,当程序调用Duck类,并利用了其中的walk和swim方法时,我们传入Person类也一样可以运行,程序并不会检查类型是不是Duck,只要他拥有 walk()和swim()方法,就能被正确地调用。

    再举例,如果一个对象实现了__getitem__方法,那python的解释器就会把它当做一个collection,就可以在这个对象上使用切片,获取子项等方法;

    如果一个对象实现了__iter__和next方法,python就会认为它是一个iterator,就可以在这个对象上通过循环来获取各个子项。

    class Foo:

    def __iter__(self):

    pass

    def __next__(self):

    pass

    from collections import Iterable

    from collections import Iterator

    print(isinstance(Foo(), Iterable)) # True

    print(isinstance(Foo(), Iterator)) # True

    因此,这就诠释了“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子,那么这只鸟就可以被称为鸭子。”这句话,那只鸟是不是鸭子不重要,重要的是它有和鸭子一样的方法,把它当鸭子调用,程序就不会报错。

    交流基地:630390733返回搜狐,查看更多

    责任编辑:

    展开全文
  • 继承与多态简介:继承可以把父类的所有功能都直接拿过来,这样就不必重零做起,子类只需要新增自己特有的方法,也可以把父类不适合的方法覆盖重写。动态语言的鸭子类型特点决定了继承不像静态语言那样是必须的。继承...

    继承与多态简介:

    继承可以把父类的所有功能都直接拿过来,这样就不必重零做起,子类只需要新增自己特有的方法,也可以把父类不适合的方法覆盖重写。

    动态语言的鸭子类型特点决定了继承不像静态语言那样是必须的。

    继承

    1387338-20180524174832591-183359890.png

    在OOP程序设计中,当我们定义一个class的时候,可以从某个现有的class继承,新的class称为子类(Subclass),而被继承的class称为基类、父类或超类(Base class、Super class)。

    如下列代码所示,继承的好处是子类获得了父类的全部功能。

    #编写一个名为Animal的class,有一个run()方法可以直接打印:

    classAnimal():defrun(self):print('Animal is running...')#当我们需要编写Dog和Cat类时,就可以直接从Animal类继承:

    classDog(Animal):pass

    classCat(Animal):pass

    #对于Dog来说,Animal就是它的父类,对于Animal来说,Dog就是它的子类。Cat和Dog类似。

    #继承有什么好处?最大的好处是子类获得了父类的全部功能。由于Animial实现了run()方法,因此,Dog和Cat作为它的子类,什么事也没干,就自动拥有了run()方法:

    dog=Dog()

    dog.run()

    cat=Cat()

    cat.run()#运行结果

    Animal isrunning...

    Animalis running...

    #继承的第二个好处需要我们对代码做一点改进。无论是Dog还是Cat,它们run()的时候,显示的都是Animal is running...,符合逻辑的做法是分别显示Dog is running...和Cat is running...,因此,对Dog和Cat类改进如下

    classDog(Animal):defrun(self):print('Dog is running...')classCat(Animal):defrun(self):print('Cat is running...')

    dog=Dog()

    dog.run()

    cat=Cat()

    cat.run()#运行结果

    Dog isrunning...

    Catisrunning...#当子类和父类都存在相同的run()方法时,我们说,子类的run()覆盖了父类的run(),在代码运行的时候,总是会调用子类的run()。这样,我们就获得了继承的另一个好处:多态。

    #也可以对子类增加一些方法,如

    classAnimal():defrun(self):print('Animal is running...')classDog(Animal):defrun(self):print('Dog is running...')classCat(Animal):defrun(self):print('Cat is running...')#再编写一个函数来理解多态,这个函数接受一个Animal类型的变量

    defrun_twice(animal):

    animal.run()

    animal.run()#再定义一个Tortoise类,也从Animal派生

    classTortoise(Animal):defrun(self):print('Tortoise is running slowly...')

    a=Animal()

    d=Dog()

    c=Cat()

    run_twice(Tortoise())print('a is Animal?', isinstance(a, Animal))print('a is Dog?', isinstance(a, Dog))print('a is Cat?', isinstance(a, Cat))print('d is Animal?', isinstance(d, Animal))print('d is Dog?', isinstance(d, Dog))print('d is Cat?', isinstance(d, Cat))

    run_twice(c)#运行结果

    Tortoise isrunning slowly...

    Tortoiseisrunning slowly...#新增一个Animal的子类,不必对run_twice()做任何修改,实际上,任何依赖Animal作为参数的函数或者方法都可以不加修改地正常运行,原因就在于多态

    aisAnimal? True

    aisDog? False

    aisCat? False

    disAnimal? True

    disDog? True

    disCat? False

    Catisrunning...

    Catis running..

    多态

    多态指的是一类事物有多种形态,(一个抽象类有多个子类,因而多态的概念依赖于继承)。

    区别多态与多态性:

    多态:同一种事物的多种形态,动物分为人类,猪类(在定义角度)

    多态性:一种调用方式,不同的执行效果(多态性)

    多态的好处就是,当我们需要传入Dog、Cat、Tortoise……时,我们只需要接收Animal类型就可以了,因为Dog、Cat、Tortoise……都是Animal类型,然后,按照Animal类型进行操作即可。由于Animal类型有run()方法,因此,传入的任意类型,只要是Animal类或者子类,就会自动调用实际类型的run()方法,这就是多态的意思:

    对于一个变量,我们只需要知道它是Animal类型,无需确切地知道它的子类型,就可以放心地调用run()方法,而具体调用的run()方法是作用在Animal、Dog、Cat还是Tortoise对象上,由运行时该对象的确切类型决定,这就是多态真正的威力:调用方只管调用,不管细节,而当我们新增一种Animal的子类时,只要确保run()方法编写正确,不用管原来的代码是如何调用的。这就是著名的“开闭”原则:

    对扩展开放:允许新增Animal子类;

    对修改封闭:不需要修改依赖Animal类型的run_twice()等函数。

    静态语言 vs 动态语言

    对于静态语言(例如Java)来说,如果需要传入Animal类型,则传入的对象必须是Animal类型或者它的子类,否则,将无法调用run()方法。

    对于Python这样的动态语言来说,则不一定需要传入Animal类型。我们只需要保证传入的对象有一个run()方法就可以了:

    classTimer(object):defrun(self):print('Start...')

    这就是动态语言的“鸭子类型”,它并不要求严格的继承体系,一个对象只要“看起来像鸭子,走起路来像鸭子”,那它就可以被看做是鸭子。

    Python的“file-like object“就是一种鸭子类型。对真正的文件对象,它有一个read()方法,返回其内容。但是,许多对象,只要有read()方法,都被视为“file-like object“。许多函数接收的参数就是“file-like object“,你不一定要传入真正的文件对象,完全可以传入任何实现了read()方法的对象。

    展开全文
  • 【摘要】 面向对象的三大特性多态相关知识。多态1、多态多态指的是一类事物有多种形态动物有多种形态:人,狗,猪import abcclass Animal(metaclass=abc.ABCMeta): #同一类事物:动物@abc.abstractmethoddef talk...

    【摘要】 面向对象的三大特性多态相关知识。

    多态

    1、多态

    多态指的是一类事物有多种形态

    动物有多种形态:人,狗,猪

    import abc

    class Animal(metaclass=abc.ABCMeta): #同一类事物:动物

    @abc.abstractmethod

    def talk(self):

    pass

    class People(Animal): #动物的形态之一:人

    def talk(self):

    print('say hello')

    class Dog(Animal): #动物的形态之二:狗

    def talk(self):

    print('say wangwang')

    class Pig(Animal): #动物的形态之三:猪

    def talk(self):

    print('say aoao')

    文件有多种形态:文本文件,可执行文件

    import abc

    class File(metaclass=abc.ABCMeta): #同一类事物:文件

    @abc.abstractmethod

    def click(self):

    pass

    class Text(File): #文件的形态之一:文本文件

    def click(self):

    print('open file')

    class ExeFile(File): #文件的形态之二:可执行文件

    def click(self):

    print('execute file')

    2、多态性

    一 什么是多态动态绑定(在继承的背景下使用时,有时也称为多态性)

    多态性是指在不考虑实例类型的情况下使用实例

    在面向对象方法中一般是这样表述多态性:

    向不同的对象发送同一条消息(!!!obj.func():是调用了obj的方法func,又称为向obj发送了一条消息func),不同的对象在接收时会产生不同的行为(即方法)。

    也就是说,每个对象可以用自己的方式去响应共同的消息。所谓消息,就是调用函数,不同的行为就是指不同的实现,即执行不同的函数。

    比如:老师.下课铃响了(),学生.下课铃响了(),老师执行的是下班操作,学生执行的是放学操作,虽然二者消息一样,但是执行的效果不同

    peo=People()

    dog=Dog()

    pig=Pig()

    #peo、dog、pig都是动物,只要是动物肯定有talk方法

    #于是我们可以不用考虑它们三者的具体是什么类型,而直接使用

    peo.talk()

    dog.talk()

    pig.talk()

    #更进一步,我们可以定义一个统一的接口来使用

    def func(obj):

    obj.talk()

    鸭子类型

    逗比时刻:

    Python崇尚鸭子类型,即‘如果看起来像、叫声像而且走起路来像鸭子,那么它就是鸭子’

    python程序员通常根据这种行为来编写程序。例如,如果想编写现有对象的自定义版本,可以继承该对象

    也可以创建一个外观和行为像,但与它无任何关系的全新对象,后者通常用于保存程序组件的松耦合度。

    例1:利用标准库中定义的各种‘与文件类似’的对象,尽管这些对象的工作方式像文件,但他们没有继承内置文件对象的方法

    例2:序列类型有多种形态:字符串,列表,元组,但他们直接没有直接的继承关系

    #二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用

    class TxtFile:

    def read(self):

    pass

    def write(self):

    pass

    class DiskFile:

    def read(self):

    pass

    def write(self):

    pass

    展开全文
  • python中的继承和多态?继承:在已有类的基础上创建新类,这其中的一种做法就是让一...如何用通俗的方式理解python函数之间的继承,多态python本来就是多态python的变量是没有类型的,只有指向的对象是有类型的,...
  • 摘要:多态从字面意思上看就是多种形态,在我们python面向对象里就是不同的对象在接收相同方法或者函数时会产生不同的行为,也就是说,每个对象可以用自己的方式去响应共同的函数,不同的方式实现不同的结果。多态...
  • 直接看代码: classDog: def __init__(self,name): self.name=name def play(self): print("%... 总结: 本文通过例子讲述了python中的多态:父类的引用指向子类的对象。 另外,像方法的重写和重载也是多态的一种体现。
  • 什么是多态? 一个类表现出的多种状态,通过继承来实现 例如Animal类表现出了Dog,Cat两种形态 class Animal:pass class Dog(Animal):pass class Cat(Animal):pass wc = Dog() def func(name,age)...
  • 创建自已对象就python非常核心的概念,事实上,python被称为面向对象语言,本章会介绍如何创建对象。以及面向对象的概念:继承、封装、多态多态: 可对不同类的对象使用同样的操作。封装:对外部世界隐藏对象的...
  • 本文实例讲述了Python面向对象多态原理与用法。分享给大家供大家参考,具体如下:目标多态面向对象三大特性封装 根据 职责 将 属性 和 方法 封装 到一个抽象的 类 中定义类的准则继承 实现代码的重用,相同的代码...
  • Python面面向向对对象象之之多多态态原原理理与与用用法法案案例例分分析析 这篇文章主要介绍了Python面向对象多态原理与用法,结合具体案例形式分析了Python多态的具体功能原理 使用 法与操作注意事项,需要的朋友...
  • Python面向对象多态

    2018-06-25 14:52:00
    Python面向对象多态  多态与多态性:  多态:  多态是指一类事物有多种形态,一个抽象类有多个子类,因而多态的概念依赖于继承。  1、序列类型有多种形态:字符串、列表、元组。  2、动物有多种形态:...
  • 面向对象的三大特征: 封装、继承、多态 一:封装 封装的内容包括两部分:封装数据和封装函数 封装数据:保护隐私(这一类数据只有这种类才能使用) 封装函数:降低复杂度,这和面向过程的编程中的作用一样。 封装的...
  • Python面向对象多态1多态 多态是指一类事物有多种形态,比如动物类,可以有猫,狗,猪等等(一个抽象类有多个子类,因而多态的概念依赖于继承)。class Animal(object): # 同一类事物:动物 def speak(self): pass...
  • 本文实例讲述了Python面向对象之继承和多态用法。分享给大家供大家参考,具体如下:Python 类的继承和多态Python 类的继承在OOP(Object Oriented Programming)程序设计中,当我们定义一个class的时候,可以从某个...
  • 本文实例讲述了Python面向对象之继承和多态用法。分享给大家供大家参考,具体如下:Python 类的继承和多态Python 类的继承在OOP(Object Oriented Programming)程序设计中,当我们定义一个class的时候,可以从某个...
  • Python3面向对象多态

    2019-02-23 13:07:45
    对象上,由运行时该对象的确切类型决定,这就是多态真正的威力:调用方只管调用,不管细节,而当我们新增一种 Animal 的子类时,只要确保 run() 方法编写正确,不用管原来的代码是如何调用的。这就是著名的“开闭”...
  • python面向对象多态

    2020-02-14 19:14:48
    python面向对象多态 多态: 同类对象的多种形态(子类化) 实现多态的步骤: 实现继承关系 重写父类方法 使用子类对象执行父类处理 class People: """人""" def dance(self): print("跳舞") def play(self): #...
  • Python面向对象——多态 目标 多态 面向对象三大特性 1.封装 根据 职责 将 属性 和 方法 封装 到一个抽象的 类 中  定义类的准则 2.继承 实现代码的重用,相同的代码不需要重复的编写  设计类的技巧  子类针对...
  • 本文实例讲述了Python面向对象多态原理与用法。分享给大家供大家参考,具体如下:目标多态面向对象三大特性封装 根据 职责 将 属性 和 方法 封装 到一个抽象的 类 中定义类的准则继承 实现代码的重用,相同的代码...
  • 多态与多态性一,多态1,多态指的是一类事物有多种形态(python里面原生多态)1.1动物有多种形态:人,狗,猪import abcclass Animal(metaclass=abc.ABCMeta): #同一类事物:动物@abc.abstractmethoddef talk(self):...
  • 继承在面向对象的程序设计中,当我们定义一个class时候,可以从现有的class继承,新的class成为子类,被继承的class称为基类,父类或超类。比如,编写一个名为Animal的class:classAnimal(object):defrun(self):...
  • 主要介绍了Python面向对象多态原理与用法,结合具体案例形式分析了Python多态的具体功能、原理、使用方法与操作注意事项,需要的朋友可以参考下

空空如也

空空如也

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

python面向对象多态

python 订阅