精华内容
下载资源
问答
  • Python 面向对象三大特征

    千次阅读 2018-05-18 20:51:51
    一、 面向对象三大特征--封装面向对象的程序设计中,某个类把所需要的数据(也可以说是类的属性)和对数据的操作(也可以说是类的行为)全部都封装在类中,分别称为类的成员变量和方法(或成员函数)。这种把成员...

    一、 面向对象三大特征--封装

    面向对象的程序设计中,某个类把所需要的数据(也可以说是类的属性)和对数据的操作(也可以说是类的行为)全部都封装在类中,分别称为类的成员变量和方法(或成员函数)。这种把成员变量和成员函数封装在一起的编程特性称为封装。
    公有成员变量和私有成员变量:Python中,以两个下划线‘__’开头的变量都是私有成员变量,而其余的变量都属于公有成员变量。私有的成员变量只能在类的内部访问,而共有的公有的成员变量可以在类的外部进行访问。
    公有方法和私有方法:公有的成员方法和私有的成员方法也是通过名字来区分的,双下划线‘__’开头的方法是私有成员方法。类的私有方法只能通过对象名(在类内部也就是self)在类的内部进行访问。而公有方法可以在类的外部通过对象名进行访问。
    创建对象后,Python解释器默认调用__init__()方法。当删除一个对象时,Python解释器也会默认调用一个方法,这个方法为__del__()方法。
    def __del__(self):
    1、python解释器执行完整个代码之后会默认最后调用对象的__del__()
    2、如果有多个对象,有几个对象,python解释器执行完毕的时候就是调用几遍__del__()
    3、如果手动删除时(del)删除完成就会执行__del__(),当使用del 把内存的所有应用删除,立刻调用__del__方法
    del xxx 不会主动调用__del__方法,只有引用计数==0时,__del__()才会被执行,并且定义了__del_()的实例无法被Python的循环垃圾收集器收集,所以尽量不要自定义__del__()。一般情况下,__del__() 不会破坏垃圾处理器。

    二、面向对象三大特征--继承

    子类在继承的时候,在定义类时,小括号()中为父类的名字父类的属性、方法,会被继承给子类私有属性(私有类属性)和私有方法不被继承。
    私有的属性,不能通过对象直接访问,但是可以通过方法访问
    私有的方法,不能通过对象直接访问
    私有的属性、方法,不会被子类继承,也不能被访问
    Python中是可以多继承的父类中的方法、属性,子类会继承.
    类名.__mro__方法的作用打印多重继承的继承方法顺序

     重写父类方法

    所谓重写,就是子类中,有一个和父类相同名字的方法,在子类中的方法会覆盖掉父类中同名的方法
    1、super调用父类属性super并不是一个函数,是一个类名.。Super().方法名,可以调用父类的方法(不用传参,作用是调用父类的方法,传的是子类实例的值)supper是类名。也可以用父类的类名直接调用:类名.方法名(self)
    2、通过父类名.属性方法名调用

    三、面向对象三大特征--多态

    所谓多态:定义时的类型和运行时的类型不一样,此时就成为多态。多态指的是一类事物有多种形态,(一个抽象类有多个子类,因而多态的概念依赖于继承)。

    四  面向对象四大特征--抽象(可以不算)

    数据抽象 -->表示世界中一类事物的特征,就是对象的属性.比如鸟有翅膀,羽毛等(类的属性)
    过程抽象 -->表示世界中一类事物的行为,就是对象的行为.比如鸟会飞,会叫(类的方法)
    类属性、实例属性
    在前面的例子中我们接触到的就是实例属性(对象属性),类属性就是类对象所拥有的属性,它被所有类对象的实例对象所共有
    class Person(object):
        name = 'Tom'  #公有的类属性
        __age = 12     #私有的类属性
    如果需要在类外修改类属性,必须通过类对象去引用然后进行修改。

    类方法和静态方法

    Python中对象有两种:经典对象和新型对象。经典对象就是不继承object父类定义出来的对象。新型对象就是要继承object类定义出的对象。新型对象和经典对象最大的区别就是,新型对象中提供了对类方法和静态方法的支持。
    类方法就是被classmethod()函数处理过的函数,能够直接通过类名进行调用,也能够被对象直接调用。
    静态方法相当于类层面的全局函数,可以被类直接调用,可以被所有实例化对象共享,通过staticmethod()定义静态方法,静态方法没有self参数。

    1. 类方法:

    要用修饰器@classmethod来标识其为类方法,对于类方法,第一个参数必须是类对象,一般以cls作为第一个参数,能够通过实例对象和类对象去访问。类方法还有一个用途就是可以对类属性进行修改:
     cls 当前类的对象    类模型也是占用内存空间的   2. 类对象产生的时候还没有类模型创建的对象,所以类方法中是不能使用对象属性

    2. 静态方法

    从Python2.4后需要通过修饰器@staticmethod来进行修饰,静态方法不需要多定义参数可以不加self或者cls,当调用的方法和类对象和实例对象没有关系的时候就可以用静态方法.
    1)静态方法无需传入self参数,类成员方法需传入代表本类的cls参数;
    2)从第1条,静态方法是无法访问实例变量的,而类成员方法(类方法)也同样无法访问实例变量,但可以访问类变量;
    3)静态方法中可以使用类属性,要想使用对象属性则必须要传参,通过参数对象调用
     4. 如果静态方法的参数是self的话,与类的普通方法中的self,表示的意思是不一样的。
    而实例方法的第一个参数是实例对象self,那么通过self引用的可能是类属性、也有可能是实例属性(这个需要具体分析),不过在存在相同名称的类属性和实例属性的情况下,实例属性优先级更高。
    展开全文
  • Python 面向对象三大特征之多态

    千次阅读 2020-02-14 09:23:15
    【摘要】 面向对象三大特性多态相关知识。 多态 1、多态 多态指的是一类事物有多种形态 动物有多种形态:人,狗,猪 import abc class Animal(metaclass=abc.ABCMeta): #同一类事物:动物 @abc.abstract...

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

    多态

    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

    作者:Yuchuan

    展开全文
  • 摘要:多态从字面意思上看就是多种形态,在我们python面向对象里就是不同的对象在接收相同方法或者函数时会产生不同的行为,也就是说,每个对象可以用自己的方式去响应共同的函数,不同的方式实现不同的结果。...
    摘要:多态从字面意思上看就是多种形态,在我们python的面向对象里就是不同的对象在接收相同方法或者函数时会产生不同的行为,也就是说,每个对象可以用自己的方式去响应共同的函数,不同的方式实现不同的结果。

    多态从字面意思上看就是多种形态,比如人有黑种人,黄种人,白种人等等,这就是一类事物的不同形态,在我们python的面向对象里就是不同的对象在接收相同方法或者函数时会产生不同的行为,也就是说,每个对象可以用自己的方式去响应共同的函数,不同的方式实现不同的结果。

    多态

    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面向对象三大特征

    万次阅读 2020-07-27 18:04:46
    是指在面向对象编程的思想中,对代码进行高度的封装,封装又叫包装。封装在编程中的核心作用:整体化代码,便于携带,提高数据或算法的安全性 封装的体现 # 求出1-200之间的素数 def getnum(): s = [i for i in ...

    封装、继承、多态

    封装

    是指在面向对象编程的思想中,对代码进行高度的封装,封装又叫包装。封装在编程中的核心作用:整体化代码,便于携带,提高数据或算法的安全性
    封装的体现

    # 求出1-200之间的素数
    def getnum():
        s = [i for i in range(1, 201)]
        def fun(x):
                for i in range(2, x):
                    if x % i == 0:
                        return False
                else:
                    return True
    
        num = filter(fun, s)
        return  num
    
    print(list(getnum()))
    

    继承

    在程序中继承是指描述的是多个类之间的一个所属关系

    例如一个类A里面的所有的属性和方法可以复用,这个时候可以通过继承的方式,传递到类B里面

    这这里A类称之为父类(基类) B类称之为子类(派生类)

    在Python中子类(派生类)会继承父类(基类),那么子类就及继承了父类中的属性和方法,简化了子类的设计问题,便于后期的维护和升级

    单继承

    一个类只继承了一个父类

    如果子类继承了父类,子类就继承了父类的属性和方法

    class A(object):
    	pass
    
    class B(A)
    	pass
    
    #	B是子类,A是父类,B继承A
    
    
    class A(object):
        def __init__(self):
            self.money = 1000000
            self.blood = "A"
    
        def work(self):
            print("我是一名工程师")
    
    
    class B(A):
        pass
    
    b = B()
    print(b.money)
    print(b.blood)
    b.work()
    #输出结果
    #1000000
    #A
    #我是一名工程师
    
    

    多继承

    一个类继承了多个父类

    子类继承了多个父类,则子类就会继承父类的所有的不同名的方法

    class A(object):
    	pass
    
    class B(object)
    	pass
    
    class C(A,B):
    	pass
    
    #子类C继承了A,B两个父类
    
    
    class Tang(object):
        def __init__(self):
            self.jn1="念经"
    
        def dyj(self):
            print("我能打妖精")
    
    class Puti(object):
        def __init__(self):
            self.jn2="筋斗云"
        def sgz(self):
            print("我能耍棍子")
    
    class Sun(Tang,Puti):
        def __init__(self):
            self.jn3="七十二变"
            Tang.__init__(self)  # 调用同名父类的方法
            Puti.__init__(self)  # 调用同名父类的方法
        def zhi(self):
            print("还是弼马温")
    
    sunwukong=Sun()
    print(sunwukong.jn1,sunwukong.jn2,sunwukong.jn3)
    sunwukong.dyj()
    sunwukong.sgz()
    sunwukong.zhi()
    
    #输出结果
    #念经 筋斗云 七十二变
    #我能打妖精
    #我能耍棍子
    #还是弼马温
    
    

    多层继承

    class A(object):
    	pass
    
    class B(A)
    	pass
    
    class C(B):
    	pass
    
    #B继承A,C继承B
    
    class Puti(object):
        def __init__(self):
            self.model = "筋斗云"
    
        def kongfu(self):
            print("72般变化")
    
    
    class SunMonken(Puti):
        def __init__(self):
            self.wuqi = "金箍棒"
    
        def look(self):
            print("火眼金睛")
    
    
    class ChenXiang(SunMonken):
        def __init__(self):
            # SunMonken.__init__()
            # super函数会自动查找参数中子类的“父类”按照继承链的顺序找其后一个
            # super(子类名称,self).子类中的同名方法
            # super(ChenXiang,self).__init__()
            super().__init__()
            super(SunMonken,self).__init__()
            self.bao = "宝莲灯"
    
    print(ChenXiang.__mro__)
    
    cx = ChenXiang()
    print(cx.model)
    print(cx.wuqi)
    print(cx.bao)
    cx.kongfu()
    cx.look()
    #输出结果
    #(<class '__main__.ChenXiang'>, <class '__main__.SunMonken'>, <class '__main__.Puti'>, <class 'object'>)
    #筋斗云
    #金箍棒
    #宝莲灯
    #72般变化
    #火眼金睛
    
    

    知识点

    1. 如果多个父类的方法名不相同
      子类会全部继承
    2. 如果多个父类的方法名相同
      子类会继承第一个父类的
    3. 如果子类也有父类的同名方法,那么子类就会选择自己的这个方法,
    4. 如果子类中也有__init__方法,那么所有的父类的属性都不会被继承
    5. 通过一个类创建对象,必须要执行一次init方法
      找init方法的顺序要遵循类的继承链
    查看一个类的继承链
       类名.__mro__
    

    子类重写父类的同名方法和属性

    重写
    是指在子类中重新去写父类中已经拥 有的方法,并且在子类中保持这个方法的名字不变,只有方法体发生改变,那么调用子类对象的这个方法以后都是子类中所写的

    场景

    1. 子类继承了父类,父类不能满足子类的需求。子类重写父类的同名方法
    2. 但是子类还想在其类内部使用父类的同名方法
    class Shi(object):
        def work(self,x,y):
            return x+y
    
    class Tu(Shi):
        def work(self,x,y):
            return Shi.work(self,x,y)/2
        pass
    

    方式

           #子类中:
           父类名.父类的同名方法(self)
           #使用super
           #super函数是用来获取指定的子类在继承链中的后一个类给当前子类的self
           super(子类名,self).父类同名方法
           #一般情况下获取当前子类的直接父类的同名方法可以省略括号中的参数
           super().父类同名方法
    

    多态

    不同子类的对象调用相同的父类方法,产生不同的结果
    Python中多态是指一类事物有多种形态。比如动物有多种形态,人,狗,猫,等等。文件有多种形态:文本文件,可执行文件。

    特点

    1. 多态可以增加代码的灵活度
    2. 以继承和重写方法为前提
    3. 是调用方法的技巧,不会影响类的原本设计
    # 1.创建一个人类,这个类里面的属性:(姓名、年龄、身高等),要求人的年龄大于0小于300,如果用户填写小于0则默认为0
    class Person(object):
        def __init__(self, name,age, height):
            self.name = name
            self.__age = 0
            self.height = height
            self.set_age(age)
    
        def set_age(self, age):
            if 0 < age < 300:
                self.__age = age
            elif age < 0:
                self.__age = 0
            elif age > 300:
                self.__age = 300
    
        def get_age(self):
            return self.__age
    
    
    zs = Person("张三",500, 1.75)
    zs.set_age(-10)
    print("姓名:%s,年龄:%d岁,身高:%.2f" % (zs.name, zs.get_age(), zs.height))
    
    #输出结果
    #姓名:张三,年龄:0岁,身高:1.75
    
    展开全文
  • python面向对象三大特征

    千次阅读 2018-09-13 20:21:05
    面向对象三大特征  1.封装:根据职责将属性和方法封装到一个抽象的类中  2.继承:实现代码的重用,相同的代码不需要重复的写  3.多态:以封装和继承为前提,不同的子类对象调用相同的方法,产生不同的执行结果 一...
  • python面向对象三大特性

    千次阅读 2018-07-06 09:59:14
    封装 类里面不光有属性还有...只要对对象进行操作就可以。比如数据访问限制,既想将数据保护起来(设置私有属性:self.__属性名 self.__方法名),又想在一定程度上对数据进行操作。这里就可以用到这个特性,我们可以...
  • python面向对象

    千次阅读 多人点赞 2018-01-18 13:20:47
    如果你以前没有接触过面向对象的编程语言,那你可能需要先了解一些面向对象语言的一些基本特征,在头脑里头形成一个基本的面向对象的概念,这样有助于你更容易的学习Python面向对象编程。接下来我们先来简单的了解...
  • Python面向对象

    万次阅读 多人点赞 2020-10-11 20:59:41
    面向对象OOP2.1 类的创建与内部结构2.2 类的继承与多态2.3 OOP三大特性总结3. 模块与包 1. 关于类与对象操作的BIFs type() 返回对象类型 id(), 查看对象id dir(), 查看对象下变量及函数 issubclass(), ...
  • python 面向对象全面详解

    万次阅读 多人点赞 2019-01-12 14:25:23
    2、python面向对象的重要术语: 3、函数和面向对象编程的区别 二、封装、继承、多态 1、封装(Encapsulation) 2、继承(Inheritance) 3、多态(Polymorphism) 、面向对象的各种方法 1、静态方法 (用这个...
  • Python 面向对象

    万次阅读 2020-02-04 13:13:33
    如果你以前没有接触过面向对象的编程语言,那你可能需要先了解一些面向对象语言的一些基本特征,在头脑里头形成一个基本的面向对象的概念,这样有助于你更容易的学习Python面向对象编程。 接下来我们先来简单的...
  • 2.1 Python面向对象

    万次阅读 2019-05-21 10:15:14
    2.1 Python面向对象 2.1.1 面向对象编程概述: Python从设计之初就已经是一门面向对象的语言,正因为如此,在Python中创建一个类和对象是很容易的. 面向对象技术简介 类(Class): 用来描述具有相同的属性和...
  • Python面向对象基础

    千次阅读 2021-02-23 11:44:04
    Python面向对象基础 目标 理解面向对象 类和对象 添加和获取对象属性 魔法方法 一. 理解面向对象 面向对象就是将编程当成是一个事物,对外界来说,事物是直接使用的,不用去管他内部的情况。而编程就是设置事物...
  • Python面向对象编程

    千次阅读 2019-11-20 16:00:45
    在上一篇文章中的第十四个知识点已经对Python面向对象编程做了基本的了解 基本的知识点已经涵盖全面了: https://blog.csdn.net/hehe_soft_engineer/article/details/102904263#t5 面向对象的内容包括:类、变量...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 199,038
精华内容 79,615
关键字:

python面向对象三大特征

python 订阅