您的位置:新葡亰496net > 电脑系统 > 面向对象,python面向对象

面向对象,python面向对象

发布时间:2019-11-16 11:28编辑:电脑系统浏览(129)

     

    1.类的性质

    创制对象的进度称之为实例化;当叁个对象被创建后,包涵四个方面包车型客车特色:对象句柄、属性和办法。
    句柄用于区分分裂的目的
    对象的属性和措施与类中的成员变量和成员函数对应
    obj = MyClass() //创制类的多个实例(对象)
    透过对象来调用方法和本性

    • 类的属性按使用节制分为公有属性和个人属性,类的性质范围决意于属性的名号。
    • 国有属性:在类中和类外都能调用的品质。
      • 个体属性:不可能在类外及被类以外的函数调用。
        概念方式:以”__”双下划线初阶的积极分子变量正是个体属性
        能够透过instance._classname__attribute情势访谈。第三个下划线只有叁个,第四个下划线是2个
    #!/usr/bin/python
    # -*- coding:utf8 -*-
    # author: chawn
    # date:
    class People(object):
        color = 'yellow'    # 公有属性
        __age = 30      # 定义私有属性
        def think(self):
            self.color = 'black'    # 调用公有属性
            print self.__age        # 调用私有属性
            print "I am a %s" % self.color
            print "I am a thinker"
    
    ren = People()
    print ren.color
    ren.think()
    print ren.__age
    
    C:UserschawnPycharmProjectspyexvenvScriptspython.exe C:/Users/chawn/PycharmProjects/pyex/180108/1.py
    yellow
    30
    I am a black
    I am a thinker
    Traceback (most recent call last):
      File "C:/Users/chawn/PycharmProjects/pyex/180108/1.py", line 17, in <module>
        print ren.__age
    AttributeError: 'People' object has no attribute '__age'
    

    个体属性在外界调用报错AttributeError: 'People' object has no attribute '__age'。
    科学写法:print ren._People__age

    • 松手属性:由系统在定义类的时候暗许增加的,由上下双下划线构成,_dict_, _module_
    #!/usr/bin/python
    # -*- coding:utf8 -*-
    # author: chawn
    # date:
    class People(object):
        color = 'yellow'    # 公有属性
        __age = 30      # 定义私有属性
        def think(self):
            self.color = 'black'    # 调用公有属性
            print self.__age        # 调用私有属性
            print "I am a %s" % self.color
            print "I am a thinker"
    
    ren = People()
    print ren.color
    ren.think()
    print ren.__dict__    #输出内置属性
    
    C:UserschawnPycharmProjectspyexvenvScriptspython.exe C:/Users/chawn/PycharmProjects/pyex/180108/1.py
    yellow
    30
    I am a black
    I am a thinker
    {'color': 'black'}  #以字典输出
    

    透过类来调用内置属性:

    #!/usr/bin/python
    # -*- coding:utf8 -*-
    # author: chawn
    # date:
    class People(object):
        color = 'yellow'    # 公有属性
        __age = 30      # 定义私有属性
        def think(self):
            self.color = 'black'    # 调用公有属性
            print self.__age        # 调用私有属性
            print "I am a %s" % self.color
            print "I am a thinker"
    
    ren = People()
    ren.color = '白色'    #给对象的属性赋值
    print ren.color
    ren.think()
    print ren.__dict__
    print '*' *30    # *重复30次
    print People.color  # 通过类调用属性color
    
    C:UserschawnPycharmProjectspyexvenvScriptspython.exe C:/Users/chawn/PycharmProjects/pyex/180108/1.py
    白色  #输出对象的属性
    30
    I am a black
    I am a thinker
    {'color': 'black'}
    ******************************
    yellow  # 类的属性输出
    {'__module__': '__main__', 'color': 'yellow', '__doc__': None, '__dict__': <attribute '__dict__' of 'People' objects>, '_People__age': 30, '__weakref__': <attribute '__weakref__' of 'People' objects>, 'think': <function think at 0x03384930>}  # 类的内置属性
    

    面向对象(object-oriented :简单称谓: OO) 现今还并未有统后生可畏的概念 我这里把它定义为: 按大家 认识客观世界的类别思虑方法,选取基于对象(实体) 的概念建模,模拟客观世界剖判、设 计、完毕软件的法门。

    Python从两全之初就曾经是一门面向对象的言语,正因为如此,在Python中开创贰个类和目的是非常轻巧的。

    1.1面向对象编制程序介绍

    在线编制程序
    在线预览:http://github.lesschina.com/python/base/oop/1.封装.html

    2.类的不二秘籍

    • 办法的概念和函数同样,可是须要self作为第三个参数。
      类情势为:

      • 国有方法
      • 个体方法
      • 类方法
      • 静态方法
    • 国有方法:在类大壮类外都能调用的法子。

    • 私家方法:无法被类的外表调用,在章程前边加上”__”双下划线正是私家方法。

    • self参数
      用来区分函数和类的方法(必得有一个self),self参数表示实施对象自作者。

    class People(object):
        color = 'yellow'  
        def think(self):    # 公有方法
            print "I am a thinker"
        def f(self):
            self.think()  # 内部调用公有方法
    ren = People()
    ren.think()  
    ren.f()  #外部调用公有方法
    
    C:UserschawnPycharmProjectspyexvenvScriptspython.exe C:/Users/chawn/PycharmProjects/pyex/180108/1.py
    I am a thinker
    I am a thinker
    

    看下私有方法:

    class People(object):
        color = 'yellow'    
        def think(self):    
            print "I am a thinker"
        def __f(self):  # 私有方法
            self.think()    #内部调用公有方法
    ren = People()
    ren.think()
    ren.__f()   #外部不可调用私有方法
    
    C:UserschawnPycharmProjectspyexvenvScriptspython.exe C:/Users/chawn/PycharmProjects/pyex/180108/1.py
    I am a thinker
    Traceback (most recent call last):
      File "C:/Users/chawn/PycharmProjects/pyex/180108/1.py", line 13, in <module>
        ren.__f()
    AttributeError: 'People' object has no attribute '__f'
    
    • 类措施:被classmethod()函数处理过的函数,能被类所调用,也能被对象所调用(是一连的关系)
    • 静态方法:相当于”全局函数”,能够被类直接调用,能够被有着实例化对象分享,通过staticmethod()定义,静态方法未有”self”参数。
      装饰器:
      • @classmethod
      • @staticmethod
    class People(object):
        color = 'yellow'
        def think(self):
            print "I am a thinker"
        def __f(self):  # 私有方法
            self.think()    #内部调用公有方法
        def test(self):
            print 'ok'
        cm = classmethod(test)  #处理一下方法
    
    ren = People()
    People.cm()  #通过类访问被处理过得方法,没被处理的不调用
    People.think()
    
    C:UserschawnPycharmProjectspyexvenvScriptspython.exe C:/Users/chawn/PycharmProjects/pyex/180108/1.py
    ok
     File "C:/Users/chawn/PycharmProjects/pyex/180108/1.py", line 17, in <module>
        People.think()
    TypeError: unbound method think() must be called with People instance as first argument (got nothing instead)
    # think方法没有被classmethod处理,所以类不能调用
    

    静态方法(卡塔尔国里为空,无法平昔被对象大概类调用,要先用staticmethod管理。何况正因为从没self参数,所以无法调用其余措施,只可以调用属性。相比之下,功能很静态。

    class People(object):
        color = 'yellow'
        def think(self):
            print "I am a thinker"
        def __f(self):  # 私有方法
            self.think()    #内部调用公有方法
        def test(): # 静态方法
            print 'ok'
    
    ren = People()
    People.cm()
    
    C:UserschawnPycharmProjectspyexvenvScriptspython.exe C:/Users/chawn/PycharmProjects/pyex/180108/1.py
    Traceback (most recent call last):
      File "C:/Users/chawn/PycharmProjects/pyex/180108/1.py", line 15, in <module>
        People.cm()
    AttributeError: type object 'People' has no attribute 'cm'
    
    class People(object):
        color = 'yellow'
        def think(self):
            print "I am a thinker"
        def __f(self):  # 私有方法
            self.think()    #内部调用公有方法
        def test(): # 静态方法
            print 'ok'
        cm = staticmethod(test)
    ren = People()
    People.cm()
    
    C:UserschawnPycharmProjectspyexvenvScriptspython.exe C:/Users/chawn/PycharmProjects/pyex/180108/1.py
    ok
    

    装饰器,有装饰器之后,类能够间接访问:

    class People(object):
        color = 'yellow'
        def think(self):
            print "I am a thinker"
        def __f(self):  # 私有方法
            self.think()    #内部调用公有方法
    
        @classmethod
        def test(self): # 动态方法
            print 'haha'
    
        @staticmethod
        def test1():    #静态方法
            print 'ok'
    
    ren = People()
    People.test()
    People.test1()
    
    C:UserschawnPycharmProjectspyexvenvScriptspython.exe C:/Users/chawn/PycharmProjects/pyex/180108/1.py
    haha
    ok
    

      面向对象编制程序(Object Oriented Programming-OOP) 是风度翩翩种缓和软件复用的设计和编制程序方法。 这种情势把软件系统中好像相近的操作逻辑和操作 应用数据、状态,以类的型式描述出来,以目的实例的花样在软件系统中复用,以达到提升软件开辟功效的功效。

    面向对象三大特色:封装、世袭、多态

    ·面向进度:依照业务逻辑从上到下写代码

    本次尽量用逸事方式来说知识,上次刚说美化,这一次好不轻巧第大器晚成篇了。步向正题:

    3. 内部类

    • 所谓内部类,就是在类的在这之中定义的类,首要目的是为了越来越好的空洞现实世界。
    • 例子:
      小车是个类,小车的礁盘,轮胎也足以抽象为类,将其定义到小车类中,则形成之中类,更加好的叙说小车类,因为底盘、轮胎是汽车的黄金时代有的。
    • 方式1:直接使用外部类调用当中类
      object_name = outclass_name.inclass_name()
    class People(object):
        color = 'yellow'
        class Chinese(object):
            name = '内部类'
        def think(self):
            print "I am a thinker"
    ren = People.Chinese()
    print ren.name
    
    C:UserschawnPycharmProjectspyexvenvScriptspython.exe C:/Users/chawn/PycharmProjects/pyex/180108/1.py
    内部类
    
    • 措施2:先对外表类进行实例化,然后再实例化内部类
      out_name = outclass_name()
      in_name = out_name.inclass_name()
      in_name.method()
    class People(object):
        color = 'yellow'
        class Chinese(object):
            name = '内部类'
        def think(self):
            print "I am a thinker"
    ren = People()  # 在People里取对象
    tom = ren.Chinese()  # 在Chinese再取一个对象
    print tom.name
    

    也可换来:

    class People(object):
        color = 'yellow'
        class Chinese(object):
            name = '内部类'
        def think(self):
            print "I am a thinker"
    # ren = People()
    # tom = ren.Chinese()
    # print tom.name
    print People.Chinese.name
    
    C:UserschawnPycharmProjectspyexvenvScriptspython.exe C:/Users/chawn/PycharmProjects/pyex/180108/1.py
    内部类
    

    魔术点子:

    • _str_(self)
    • 构造函数与析构函数
      • 构造函数:
        用来最初化类的此中意况,Python提供的构造函数是_init_();
        _init_()方法是可选的,要是不提供,Python会提交叁个暗中认可的_init_方法
      • 析构函数:
        用来释放对象占用的能源,Python提供的析构函数是_del_();
        _del_()也是可选的,若是不提供,则Python会在后台提供暗中认可析构函数
    class People(object):
        color = 'yellow'
        class Chinese(object):
            name = '内部类'
        def think(self):
            print "I am a thinker"
        def __str__(self):
            return '这是People类'  # 只能用return,不能用print
        def __init__(self):
            self.color = 'black'
        def __del__(self):
            print 'del..'
    ren = People()
    print ren
    print ren.color
    print People.color
    

    _del_(self)在程序最后试行,举例程序实践完关闭某文件。不手动关闭的话,Python也会自行回笼。

    • Python选拔垃圾回笼机制来清理不再使用的对象;python提供gc模块释放不再利用的目的。
    • Python接纳”引用计数”的算法方式来拍卖回笼,即:当有个别对象在其成效域内不再被别的对象引用的时候,python就活动撤消对象;
    • gc模块的collect()可以二次性收罗全体待管理的对象(gc.collect)

    Python 面向对象

      Python从安顿性之初就已是一门面向对象的言语,正因为这么,在Python中开创三个类和对象是非常轻巧的。本章节大家将详细介绍Python的面向对象编制程序。
      若是你在此早前从未有过接触过面向对象的编制程序语言,那你可能须要先精通一些面向对象语言的局地基本特征,在脑子里头形成贰在那之中央的面向对象的定义,那样有利于你更便于的就学Python的面向对象编制程序。接下来大家先来简单的问询上面向对象的一些基本特征。

    1.面向对象简介

    • 类(Class): 用来陈述具备同样的习性和艺术的目标的联谊。它定义了该会集中种种对象所共有的属性和办法。对象是类的实例。
    • 类变量:类变量在整整实例化的靶子中是公用的。类变量定义在类中且在函数体之外。类变量常常不作为实例变量使用。
    • 数码成员:类变量恐怕实例变量用于处理类及其实例对象的相干的数据。
    • 措施重写:设若从父类世襲的秘技不能满足子类的急需,能够对其实行改写,这些历程叫方法的掩盖(override卡塔 尔(英语:State of Qatar),也称为方法的重写。
    • 实例变量:概念在格局中的变量,只据守于当下实例的类。
    • 继承:即贰个派生类(derived class卡塔 尔(英语:State of Qatar)世袭基类(base class卡塔 尔(英语:State of Qatar)的字段和措施。世袭也同意把贰个派生类的目的作为二个基类对象相比较。比如,有像这种类型三个设计:叁个Dog类型的对象派生自Animal类,那是盲目跟风"是贰个(is-a卡塔 尔(英语:State of Qatar)"关系(例图,Dog是八个Animal卡塔 尔(阿拉伯语:قطر‎。
    • 实例化:始建三个类的实例,类的实际对象。
    • 方法:类中定义的函数。
    • 对象:因此类定义的数据结构实例。对象包蕴八个数据成员(类变量和实例变量卡塔 尔(阿拉伯语:قطر‎和办法。

    ·面向对象:将数据与函数绑定到黄金时代道,举办打包,这样能够越来越高效的支付顺序,收缩了再次代码的重写进度

    1.定义贰个类¶

    类的结合:类名、属性(没有字段卡塔 尔(阿拉伯语:قطر‎、方法

    面向对象概念

    • 类(Class): 用来陈说具备相仿的性质和办法的指标的集纳。它定义了该集合中种种对象所共有的天性和措施。对象是类的实例。
    • 类变量:类变量在一切实例化的靶子中是公用的。类变量定义在类中且在函数体之外。类变量常常不作为实例变量使用。
    • 多少成员:类变量或许实例变量用于管理类及其实例对象的相关的多寡。
    • 方法重写:如果从父类继承的艺术不可能满意子类的须求,能够对其进展改写,这一个进程叫方法的蒙蔽(override卡塔尔国,也称之为方法的重写。
    • 实例变量:概念在形式中的变量,只效劳于最近实例的类。
    • 继承:即二个派生类(derived class卡塔 尔(英语:State of Qatar)世襲基类(base class卡塔尔的字段和方法。世袭也允许把叁个派生类的指标作为多少个基类对象比较。举个例子,有如此一个两全:叁个Dog类型的对象派生自Animal类,那是仿照"是二个(is-a卡塔 尔(英语:State of Qatar)"关系(例图,Dog是叁个Animal卡塔 尔(英语:State of Qatar)。
    • 实例化:创造一个类的实例,类的现实性目的。
    • 方法:类中定义的函数。
    • 对象:因此类定义的数据结构实例。对象包涵四个数据成员(类变量和实例变量卡塔尔和艺术。

    1.1.创建类

    新葡亰496net 1

    calss ClassName:
        '这是一个经典类'
        def __init__(self):
            '这是构造方法'
             pass
      def __del__(self):
        '这是析构方法'
         pass
    
    calss ClassName(object):
        '这是一个新式类'
        def __init__(self):
            '这是构造方法'
             pass
    
     
    

    新葡亰496net 2

    类的提携消息方可经过ClassName.__doc__查看。

    class_suite 由类成员,方法,数据属性组成

    新葡亰496net 3

    注:全体成员中,只有普通字段的内容保留对象中,即:依据此类成立了多少对象,在内部存款和储蓄器中就有多少个不感觉奇字段。而别的的成员,则都是保存在类中,即:无论对象的有一些,在内部存款和储蓄器中只开创生龙活虎份

    面向进程的思绪是将数据与函数依据施行的逻辑顺序组织在一块,数据与函数分开寻思。

    1.1创设八个类¶

    In [1]:

    # 类名首字母大写
    class Student(object):
        """创建一个学生类"""
        # 没有属性定义,直接使用即可
        # 定义一个方法,方法里面必须有self(相当于C#的this)
        def show(self):
            print("name:%s age:%d"%(self.name,self.age))
    

    In [2]:

    # 实例化一个张三
    zhangsan=Student()
    # 给name,age属性赋值
    zhangsan.name="张三"
    zhangsan.age=22
    # 调用show方法
    zhangsan.show()
    

     

    name:张三 age:22
    

    In [3]:

    # 打印一下类和类的实例
    print(Student)
    print(zhangsan) #张三实例的内存地址:0x7fb6e8502d30
    

     

    <class '__main__.Student'>
    <__main__.Student object at 0x7fe961195b70>
    

     

    和静态语言分歧,Python允许对实例变量绑定任何数据 ==> 对于五个实例变量,固然如此它们都是同多个类的例外实例,但具备的变量名称可能都不比

    说的相比较空虚,举个例证就明知道:

    In [4]:

    xiaoming=Student("小明",22)
    xiaoming.mmd="mmd"
    print(xiaoming.mmd)
    
    # 小明和小潘都是Student类,但是小明有的mmd属性,小潘却没有
    xiaopan=Student("小潘",22)
    print(xiaopan.mmd)
    

     

    ---------------------------------------------------------------------------
    TypeError                                 Traceback (most recent call last)
    <ipython-input-4-500940527165> in <module>()
    ----> 1xiaoming=Student("小明",22)
          2 xiaoming.mmd="mmd"
          3 print(xiaoming.mmd)
          4 
          5 # 小明和小潘都是Student类,但是小明有的mmd属性,小潘却没有
    
    TypeError: object() takes no parameters
    

     

      类是空泛的,在运用的时候常见会找到这么些类的一个呼之欲出的存在,使用这些现实的留存。二个类能够找到八个对象。

    类(Class) 由3个部分组成

    • 类的称谓:类名
    • 类的属性:后生可畏组数据
    • 类的情势:允许对进展操作的情势 (行为)

    举例

    1卡塔尔国人类设计,只关心3样事物:

    • 东西名称(类名):人(Person)
    • 属性:身高(height)、年龄(age)
    • 方法(行为/功能):跑(run)、打架(fight)

    2卡塔尔狗类的宏图

    • 类名:狗(Dog)
    • 个性:品种 、毛色、性别、名字、 腿儿的数目
    • 方法(行为/功能):叫 、跑、咬人、吃、摇尾巴

    新葡亰496net 4

    1.2类字段

    类字段包蕴:普通字段和静态字段,他们在概念和利用上有所差别,而最实质的界别是内部存款和储蓄器中保存的任务分化

    • 常备字段归于对象
    • 静态字段归于

    新葡亰496net 5

    class Province:
    
        # 静态字段(公有属性)
        country = '中国'
    
        def __init__(self, name):
    
            # 普通字段(成员属性)
            self.name = name
    
    
    # 直接访问普通字段
    obj = Province('河北省')
    print obj.name
    
    # 直接访问静态字段
    Province.country
    
    字段的定义和使用
    

    新葡亰496net 6

    def发送邮件(内容)

    1.2使用__init__发轫化赋值¶

    创立对象后,python解释器暗中同意调用__init__措施,对供给字段进行开首化赋值

    亟待小心的是:__init__并不是C#中的构造函数,__new__ (前边会说卡塔 尔(英语:State of Qatar) __init__ 等价于构造函数

    第一个参数和类的别样措施生机勃勃致,都以self(约等于C#内部的this,表示成立的实例本人卡塔 尔(阿拉伯语:قطر‎调用的时候一向忽视它

    In [5]:

    class Student(object):
        # 初始化赋值
        def __init__(self,name,age):
            self.name=name
            self.age=age
    
        def show(self):
            print("name:%s age:%d"%(self.name,self.age))
    

    In [6]:

    # 有了__init__方法,在创建实例的时候,就不能传入空的参数了
    lisi=Student()
    

     

    ---------------------------------------------------------------------------
    TypeError                                 Traceback (most recent call last)
    <ipython-input-6-1ba88e24910b> in <module>()
          1 # 有了__init__方法,在创建实例的时候,就不能传入空的参数了
    ----> 2lisi=Student()
    
    TypeError: __init__() missing 2 required positional arguments: 'name' and 'age'
    

    In [7]:

    # 创建一个正确的实例
    xiaowang=Student("小王",22)
    xiaowang.show()
    

     

    name:小王 age:22
    

     

    类的架空

    如何把日常生活中的事物抽象成程序中的类?

    拥有大器晚成致(可能肖似)属性和表现的目的都足以抽像出二个类

    办法:通常名词都是类(名词提炼法)

    1.3方法

    方法富含:普通方法、静态方法和类措施,二种方法在内部存款和储蓄器中都归归属类,差异在于调用方式各异。

    • 习以为常方法:由对象调用;起码三个self参数;履行常常方法时,自动将调用该办法的对象赋值给self
    • 类方法:由调用; 最少三个cls参数;实践类格局时,自动将调用该方式的复制给cls
    • 静态方法:由调用;无暗中同意参数;

    新葡亰496net 7

    class Foo:
    
        def __init__(self, name):
            self.name = name
    
        def ord_func(self):
            """ 定义普通方法,至少有一个self参数 """
    
            # print self.name
            print '普通方法'
    
        @classmethod
        def class_func(cls):
            """ 定义类方法,至少有一个cls参数 """
    
            print '类方法'
    
        @staticmethod
        def static_func():
            """ 定义静态方法 ,无默认参数"""
    
            print '静态方法'
    
    
    # 调用普通方法
    f = Foo()
    f.ord_func()
    
    # 调用类方法
    Foo.class_func()
    
    # 调用静态方法
    Foo.static_func()
    

    新葡亰496net 8

    相同点:对于具备的办法来说,均归属类(非对象卡塔 尔(英语:State of Qatar)中,所以,在内部存款和储蓄器中也只保留生龙活虎份。

    不同点:艺术调用者不一致、调用方法时自动传入的参数差异

    #发送邮件提示

    1.3施用法力方法__str__¶

    在print(类名)的时候自定义输出

    以此有一些像C#类里面重写ToString,eg:

    public override string ToString()
    {
        return "Name:"   this.Name   " Age:"   this.Age;
    }
    

    In [8]:

    # Python的__str__()方法
    class Student(object):
        def __init__(self, name, age):
            self.name = name
            self.age = age
    
        # self别忘记写了,return也别忘了
        def __str__(self):
            return "姓名:%s,年龄:%s" % (self.name, self.age)
    

    In [9]:

    lisi = Student("李四", 22)
    print(lisi) #现在打印就是你DIV的输出了
    

     

    姓名:李四,年龄:22
    

     

    定义类

    利用class语句来成立多少个新类,class之后为类的名称并以冒号结尾,如下实例:

    class ClassName(object):
       '类的帮助信息'   #类文档字符串
       class_suite  #类体
    

    类的提携新闻方可由此ClassName.__doc__查看。

    class_suite 由类成员,方法,数据属性组成。

    实例:定义叁个People类

    # 定义类
    class People(object):
        """文档说明"""
        # 类属性:实例对象和类对象可以同时调用  
        sex="男" #公有的类属性
        country="中国"
        __age=18 #共有私有属性 
    
        def  __init__(self,name): # 实例方法,实例方法的第一个参数是实例对象self,那么通过self引用的可能是类属性、也有可能是实例属性
            # 实例属性是实例对象特有的,类对象不能拥有  
            self.name=name  #实例属性
    
        @classmethod  
        def getCountry(cls):  #类方法,类方法的第一个参数是类对象cls,那么通过cls引用的必定是类对象的属性和方法
            return cls.country  
        @classmethod  
        def setCountry(cls,country):  
            cls.country=country 
    
        @staticmethod  
        def getCountry():   #静态方法
            return People.country  
    
        def hi(self):  #普通方法
            return "你好%s"%self.name
    

    说明:

    • 概念类时有2种:新式类和精粹类,如Car为精华类,借使是Car(object)则为新式类
    • 类名 的命名规则依据"大驼峰"
    • 单下划线前缀:能够用来申明只供内部接纳,非强制。当使用from <模块/包名> import *,那么以“ _ ”初始的名目都不会被导入, 除非模块或包中的“__all__”列表显式地富含了它们
    • 单下划线后缀:大家习贯于用来幸免与 Python 关键字的冲突
    • 双下划线前缀:私有化,私有化而不是语法上的威吓,而是 python 隐蔽了私有字段的拜访入口,所以大家能够在新的进口中做客到个体字段:使用 **类名(对象)._类名__属性名** 来访问
    • 双下划线前后缀:保留给 Python 自用

    1.4属性

    举例你曾经理解Python类中的方法,那么属性就很简单了,因为Python中的属性其实是日常方法的变种。

    对此属性,有以下多个知识点:

    • 属性的骨干使用
    • 品质的两种概念情势

    新葡亰496net 9

    # ############### 定义 ###############
    class Foo:
    
        def func(self):
            pass
    
        # 定义属性
        @property
        def prop(self):
            pass
    # ############### 调用 ###############
    foo_obj = Foo()
    
    foo_obj.func()
    foo_obj.prop   #调用属性
    
    属性的定义和使用
    

    新葡亰496net 10

    由属性的定义和调用要细心一下几点:

    • 概念时,在日常方法的底蕴上增添 @property 装饰器;
    • 定义时,属性只有三个self参数
    • 调用时,无需括号
                 方法:foo_obj.func()
                 属性:foo_obj.prop

    潜心:属性存在乎义是:访谈属性时能够营造出和访问字段完全相似的假象

            属性由艺术变种而来,要是Python中未有品质,方法完全能够代表其功用

    属性的定义有二种形式:

    • 装饰器 即:在措施上运用装饰器
    • 静态字段 即:在类中定义值为property对象的静态字段

    连年邮箱服务器

    1.4 私有属性、方法¶

    C#、Java里面都以有访谈修饰符的,Python呢?

    Python规定,如果以双下划线__开头的质量也许措施尽管个人的

    变量名相似xxx的,也正是以双下划线开头,而且以双下划线结尾的,是例外变量。特殊变量是足以一向访谈的,不是private变量

    在说私有属性前,大家来个案例说说属性不私有的弊端,eg:

    小明同学学了点C#,然后学习了上边的学识,心想 ~ Python这么搞安全性呢?不行,小编得协会构造,于是有了上面包车型客车代码:

    In [10]:

    class Student(object):
        def __init__(self, name, age):
            self.name = name
            self.age = age
    
        def get_name(self):
            return self.name
    
        def set_name(self, name):
            self.name = name
    
        def get_age(self):
            return self.age
    
        def set_age(self, age):
            if age > 0:
                self.age = age
            else:
                print("age must > 0")
    
        def show(self):
            print("name:%s,age:%d" % (self.name, self.age))
    

     

    小明心想,想要改进age属性,你通过set_age作者就能够判明了哇,依旧本婴孩聪明

    那时候小潘过来了,淡淡的一笑,看本人怎么破了您 ~ 看代码:

    In [11]:

    zhangsan = Student("张三", -20)
    zhangsan.show()  # name:张三,age:-20
    zhangsan.age = -1  # set_age方法形同虚设,我完全可以直接访问字段了
    zhangsan.show()  # name:张三,age:-1
    

     

    name:张三,age:-20
    name:张三,age:-1
    

     

    小潘傲气的说道~大叔,给您脸吗。小编正是不去拜见你设定的主意怎么滴呢?

    小明急的哟,赶紧去找伟哥求经。不一会,傲气的贴出本人的New Code,心想着小编个人属性都用上了还怕个毛毛:

    In [12]:

    class Student(object):
        def __init__(self, name, age):
            self.__name = name
            # 一般需要用到的属性都直接放在__init__里面了
            # self.__age = age
            self.set_age(age)
    
        def get_name(self):
            return self.__name
    
        def set_name(self, name):
            self.__name = name
    
        def get_age(self):
            return self.__age
    
        def set_age(self, age):
            if age > 0:
                self.__age = age
            else:
                print("age must > 0")
    
        def show(self):
            print("name:%s,age:%s" % (self.__name, self.__age))
    

     

    小潘冷笑道~呵呵,然后使用了上次的妙计:

    In [13]:

    zhangsan = Student("张三", -20)
    zhangsan.__age = -1  # 同样的代码,只是属性前面加了下划线
    zhangsan.show()
    

     

    age must > 0
    

     

    ---------------------------------------------------------------------------
    AttributeError                            Traceback (most recent call last)
    <ipython-input-13-82c41ff46846> in <module>()
          1 zhangsan = Student("张三", -20)
          2 zhangsan.__age = -1  # 同样的代码,只是属性前面加了下划线
    ----> 3zhangsan.show()
    
    <ipython-input-12-1dec32486a19> in show(self)
         22 
         23     def show(self):
    ---> 24print("name:%s,age:%s" % (self.__name, self.__age))
    
    AttributeError: 'Student' object has no attribute '_Student__age'
    

     

    此番小潘同志傻眼了,完全不能够访谈了啊?不行,怎可以被小明岳父笑话吗?

    于是上网翻资料,国内拾壹分就国外,外文不好就翻译,终于找到三个新破解形式:

    双下划线开首的实例变量不能直接待上访问,是因为Python解释器对外把__age变量改成了_Studentage,所以,如故能够通过**_Studentage**来访问:

    In [14]:

    # 搞事情
    zhangsan._Student__age = -1
    zhangsan.show()
    

     

    name:张三,age:-1
    

     

    提出你不用那样干,不一致版本的Python解释器大概会把__age改成不相同的变量名

    有些时候,你会看出以二个下划线早先的实例变量名,比如_age这样的实例变量,外界是足以访谈的。

    但是,请把它视为私有变量,不要私下拜会(Python非常多事物全凭自觉~捂脸@_@)

    小潘终于长叹一口气,然后还不要忘嘲弄小明同学~您那属性搞的,真麻烦,总是通过艺术调用,太累了 <_> 鄙视!

    那可把小明急的呀,学习的能动都还没了,吃了碗羊肉面就去伟哥那边好好取经了~

    In [15]:

    # 私有方法一笔带过
    class Student(object):
        """私有方法"""
        def __go_home(self):
            pass
    
    
    zhangsan = Student()
    zhangsan.__go_home() # 访问不到
    

     

    ---------------------------------------------------------------------------
    AttributeError                            Traceback (most recent call last)
    <ipython-input-15-45c76191b808> in <module>()
          7 
          8 zhangsan = Student()
    ----> 9zhangsan.__go_home() # 访问不到
    
    AttributeError: 'Student' object has no attribute '__go_home'
    

     

    二个类可以包罗以下项目变量:

    • 部分变量:在情势只怕语句块中定义的变量被叫作局部变量。变量评释和带头化都以在措施中,方法甘休后,变量就能够自行销毁。
    • 分子变量:分子变量是概念在类中,方法体之外的变量。这种变量在成立对象的时候实例化(分配内部存款和储蓄器)。成员变量能够被类中的方法和特定类的讲话访问。
    • 类变量:类变量也阐明在类中,方法体之外。

    注:当类变量与成员变量重名时,在章程中开始的一段时期使用成员变量,方法中使用成员变量使用self,self代表当前类的近期指标。

    2.创建实例

    以下是三个轻松易行的Python类实例:

    新葡亰496net 11

    #!/usr/bin/python3
    # -*- coding: UTF-8 -*-
    
    class Employee:
       '所有员工的基类'
       empCount = 0
    
       def __init__(self, name, salary):
          self.name = name
          self.salary = salary
          Employee.empCount  = 1
    
       def displayCount(self):
         print "Total Employee %d" % Employee.empCount
    
       def displayEmployee(self):
          print "Name : ", self.name,  ", Salary: ", self.salary
    

    新葡亰496net 12

    • empCount变量是一个类变量(外号:公有属性,静态字段卡塔 尔(阿拉伯语:قطر‎
    • 它的值就要这里个类的具备实例之间分享。你能够在此中类或外界类应用Employee.empCount访谈。
    • 率先种艺术__init__()方法是风姿浪漫种独特的法子,被称为类的构造函数或最初化方法,当创设了这些类的实例时就能够调用该情势

    发送邮件

    1.5 装饰器,让艺术像属性这样便利¶

    Python内置的@property装饰器就是肩负把八个主意成为属性调用的,来个例子

    In [16]:

    class Student(object):
        def __init__(self, name, age):
            # 一般需要用到的属性都直接放在__init__里面了
            self.name = name
            self.age = age
    
        @property
        def name(self):
            return self.__name
    
        @name.setter
        def name(self, name):
            self.__name = name
    
        @property
        def age(self):
            return self.__age
    
        @age.setter
        def age(self, age):
            if age > 0:
                self.__age = age
            else:
                print("age must > 0")
    
        def show(self):
            print("name:%s,age:%s" % (self.name, self.age))
    

    In [17]:

    xiaoming = Student("小明", 22)
    xiaoming.name = "小潘"
    xiaoming.age = -2
    xiaoming.show()
    

     

    age must > 0
    name:小潘,age:22
    

     

    把一个getter办法成为属性,只须要增添@property就能够了

    @方法名.setter,担任把贰个setter方法产生质量赋值

    本来了,如若只想读 ==> 就只打上@property标签

    小明同学开心坏了,赶紧大吃了意气风发顿~


    static(静态)

      类的静态成员不信任类的某风流倜傥实例,可应用类名直接待上访谈

    3.创建实例对象

    要创立三个类的实例,你可以利用类的名称,并因此__init__艺术接收参数

    "创建 Employee 类的第一个对象"
    emp1 = Employee("Zara", 2000)
    "创建 Employee 类的第二个对象"
    emp2 = Employee("Manni", 5000)
    

    关门连接

    1.6 __del__ and __new__¶

    创立对象后,python解释器私下认可调用__init__() 方法

    当删除二个目的时,python解释器也会暗中同意调用__del__() 方法(有一些析构函数的含意卡塔尔国

    当有1个变量保存了对象的引用时,此指标的引用计数就能够加1

    当使用del删除变量指向的对象时,若果指标的援引计数不为1,那么历次删除计数减1,当计数为1的时候再调del就真把指标删了

    以此可以整合小编事先说过的链接来精晓:于链接文件的斟酌

    看着教授津津乐道,小明愣了楞,摸摸肚子想到,真BB,小编先搞个例证练练:

    In [1]:

    # 定义一个临时类
    class Temp(object):
        def __del__(self):
            print("你被干掉了")
    

     

    证实方面用编辑器比较确切,交互作用方式下可能不是实在的结果

    # 对象被s1和s2引用
    s1 = Temp()
    s2 = s1
    
    del s1  # 只删除s1,新创建的对象并没有被删除
    print("-" * 10)
    

    出口:(最终的被干掉是程序退出了卡塔尔

    # ----------
    # 你被干掉了
    

    假定用链接来分解正是这么的: 新葡亰496net 13

    此次三个都删掉:

    t1 = Temp()
    t2 = t1
    
    del t1
    del t2
    print("-" * 10)
    

    输出:

    # 你被干掉了
    # ----------
    

    都删了,自然就真删掉了


    那般搞相比较费心,大家引进一下赢得引用个数:getrefcount(object也会占1个引用计数卡塔 尔(英语:State of Qatar)来个案例:

    # 程序退出的时候,在他运行期间所有占用资源归还操作系统
    # 引用计数
    import sys
    t1 = Temp()
    print(sys.getrefcount(t1))  #(结果比实际引用大1)【object也会占1个引用计数】
    
    t2 = t1
    print(sys.getrefcount(t1))
    print(sys.getrefcount(t2))
    
    del t1
    print(sys.getrefcount(t2))
    # sys.getrefcount(t1)#被删掉自然没有了
    
    del t2
    print("-" * 10)
    

    运维结果:

    2
    3
    3
    2
    你被干掉了
    ----------
    

    自己再贴大器晚成种情景,你能够考虑下为何:

    t1 = Temp()
    t2 = Temp()
    
    del t1
    del t2
    print("-" * 10)
    

    输出:

    # 你被干掉了
    # 你被干掉了
    # ----------
    

     


    小潘扭过头瞅了一眼说道:“大爷,你__new__记不清写案例了”

    小圣元(Synutra卡塔尔愣神,立马反应过来讲:“作者那叫谋而后动~”

    当你实例化二个目的的时候,就能进行new 方法里面包车型地铁主意。new方法在类定义中不是必得写的,假使没概念,暗许会调用object.new去创制三个对象

    __new__措施中起码要有八个参数cls,代表要实例化的类,此参数在实例化时由Python解释器自动提供

    __new__办法中必需求有再次回到值(重返实例化出来的实例)

    小明翻阅了法定文书档案,淡定的抢占了如下标准格式的代码:

    In [3]:

    class Dog(object):
        def __init__(self, name):
            self.name = name
            print("初始化完毕")
    
        def __str__(self):
            return "Dog的名字叫:%s" % self.name
    
        def __new__(cls, name):
            # 注意参数,是cls,然后其他参数和init保持一致即可
            print("创建对象完毕")
            # 别忘记写返回值哦
            return object.__new__(cls)
    
    
    def main():
        happy = Dog("Happy")
        print(happy)
    
    
    if __name__ == '__main__':
        main()
    

     

    创建对象完毕
    初始化完毕
    Dog的名字叫:Happy
    

     


    关于__name__在模块调用的时候会详细说,你能够先那样敞亮:若是直白运维py文件就执行,别人调用那么您的main就不实行了

    正规写法:

    # 1.导入的模块
    # 2.class的定义
    # 3.其他方法定义
    
    def main():
        pass
    
    if __name__ == '__main__':
        main()
    

    此外内容前面会延续说,封装部分再说说静态方法类方法等等的就得了了(和C#只怕有超大差其余卡塔尔国


    1.类变量(静态变量卡塔 尔(阿拉伯语:قطر‎

      当类第一回被加载(任何多个指标的扬言,首先要加载类卡塔 尔(英语:State of Qatar),该类的类变量就分配独立内部存款和储蓄器,直到程序甘休被回笼。静态成员是公家的。

    比较 静态变量 成员变量
    作用域 当前类 当前类
    生命周期 类加载到程序结束 从对象产生到对象回收
    使用方法 类名.静态变量名 对象名.成员变量名

      静态变量即类变量 成员变量即实例变量,对象实例化后技术使用

    4.探望属性

    emp1.displayEmployee()
    emp2.displayEmployee()
    print("Total Employee %d" % Employee.empCount)
    

    新葡亰496net 14 完整例子

    您也得以使用以下函数的法门来访谈属性:

    • getattr(obj, name[, default]) : 访问对象的性质。
    • hasattr(obj,name) : 检查是还是不是留存二个性质。
    • setattr(obj,name,value) : 设置三个属性。借使属性不设有,会创立叁个新属性。
    • delattr(obj, name) : 删除属性。

      hasattr(emp1, 'age') # 如若存在 'age' 属性重返 True。 getattr(emp1, 'age') # 再次来到 'age' 属性的值 setattr(emp1, 'age', 8) # 增添属性 'age' 值为 8 delattr(empl, 'age') # 删除属性 'age'

    while True:

    1.7 类属性、实例属性¶

    小明问老师:“老师老师,怎么未有静态类,静态属性之类的事物呢?”

    老师笑而不语道:“小伙子原本不止是体重扩大啊,那求知欲也是大大的扩大呢 ~ 且听自身稳步道来”


    类在程序里面也是目的(你姑且能够以为具备的类都好像于C#内部的静态类卡塔 尔(阿拉伯语:قطر‎,而通过类实例化的指标,叫实例化对象

    实例属性 --> 实例对象互相之间不分享 日常我们都以在__init__中定义

    类属性(类似于C#此中的静态字段卡塔尔国 --> 归于类对象,多少个实例对象时期分享

    只顾一下:一律名称的实例属性将屏蔽掉类属性(尽量别同名卡塔 尔(英语:State of Qatar)

    类属性除了能够通过 类名.类属性 访谈外,仍然是能够直接 实例对象.类属性 (C#中抽象类和静态类是不可能被实例化的卡塔尔

    来个案例越来越直观点:

    In [1]:

    class Person(object):
        # age为类属性
        age = 1
    
        def __init__(self, name):
            # name为实例属性
            self.name = name
    
    
    def main():
        # 类名.类属性
        print(Person.age)
        xiaoming = Person("小明")
        # 对象.类属性
        print(xiaoming.age)
    
    
    if __name__ == '__main__':
        main()
    

     

    1
    1
    

     


    借使急需在类外 校正类属性,必得通过类对象去援用然后张开改变

    只要由此实例对象去援用会产生三个同名的实例属性,这种艺术改正的是实例属性,不会影响到类属性

    假设通超过实际例对象去援用该名称的脾气,实例属性会强制 屏蔽掉类属性,即引用的是实例属性,除非del了该实例属性技巧平常访问类属性

    您能够精通为,Python这么做只是为着便于你获得,该怎么改进还得怎么办。来看个案例:

    In [3]:

    class Person(object):
        # age为类属性
        age = 1
    
        def __init__(self, name):
            # name为实例属性
            self.name = name
    
    
    def main():
        # 类名.类属性
        print(Person.age)
    
        # 通过对象.类属性修改
        xiaoming = Person("小明")
        xiaoming.age = 100
        print(xiaoming.age)  # 其实,并没有修改成功,只是产生了一个同名age
        print(Person.age)  # 对吧,类属性并没有被修改
    
        # 通过类名修改
        Person.age = 22  # 如果需要在类外修改类属性,必须通过类对象去引用然后进行修改
        print(xiaoming.age)  # 刚才已经创建一个同名age,所以现在显示的是刚才的值
        print(Person.age)  # 通过类名.类属性 就可以看到值被修改了
    
        # 如果你还是不信,可以创建一个新对象看看
        xiaopan = Person("小潘")
        print(xiaopan.age)
    
        # xiaoming实例对象想访问怎么办?
        # 除非del了该实例属性才能正常访问类属性
        del xiaoming.age
        print(xiaoming.age)  # 这时候访问的就是 类属性 了
    
    
    if __name__ == '__main__':
        main()
    

     

    1
    100
    1
    100
    22
    22
    22
    

     

     静态方法

    • 做客静态方法:类名.方法名(参数列表)

    时常有局地跟类有关系的功用但在运作时又没有必要实例和类加入的情况下供给动用静态方法。 比如更正景况变量恐怕涂改别的类的性质等能用到静态方法。

      静态方法在同二个类中被调用时,类名能够总结。普通成员方法必须在目的实例化后才足以调用,

    比较 静态方法 成员方法
    调用 类名.方法名(参数) 对象名.方法名(参数)
    调用普通方法 不能直接调用 同一个类中可以调用
    调用静态方法 类名.方法名(参数) 类名.方法名(参数)
    访问静态变量 类名.静态变量名 类名.静态变量名
    访问成员变量 不能直接访问 同一类中可以直接访问
    self 不能使用 可以使用

    5.python内置类属性

    • __dict__ : 类的品质(包含八个字典,由类的多寡属性组成卡塔尔国
    • __doc__ :类的文书档案字符串
    • __name__: 类名
    • __module__: 类定义所在的模块(类的全名是'__main__.className',即使类位居二个导入模块mymod中,那么className.__module__ 等于 mymod)
    • __bases__ : 类的兼具父类构成要素(满含了四个由具备父类组成的元组卡塔 尔(阿拉伯语:قطر‎

    Python内置类属性调用实比方下:

    新葡亰496net 15

    #!/usr/bin/python3
    # -*- coding: UTF-8 -*-
    
    class Employee:
       '所有员工的基类'
       empCount = 0
    
       def __init__(self, name, salary):
          self.name = name
          self.salary = salary
          Employee.empCount  = 1
    
       def displayCount(self):
         print "Total Employee %d" % Employee.empCount
    
       def displayEmployee(self):
          print "Name : ", self.name,  ", Salary: ", self.salary
    
    print("Employee.__doc__:", Employee.__doc__)
    print("Employee.__name__:", Employee.__name__)
    print("Employee.__module__:", Employee.__module__)
    print("Employee.__bases__:", Employee.__bases__)
    print("Employee.__dict__:", Employee.__dict__)
    

    新葡亰496net 16

    举办以上代码输出结果如下:

    新葡亰496net 17

    Employee.__doc__: 所有员工的基类
    Employee.__name__: Employee
    Employee.__module__: __main__
    Employee.__bases__: ()
    Employee.__dict__: {'__module__': '__main__', 'displayCount': <function displayCount at 0x10a939c80>, 'empCount': 0, 'displayEmployee': <function displayEmployee at 0x10a93caa0>, '__doc__': 'xe6x89x80xe6x9cx89xe5x91x98xe5xb7xa5xe7x9ax84xe5x9fxbaxe7xb1xbb', '__init__': <function __init__ at 0x10a939578>}
    

    新葡亰496net 18

    6.python对象销毁(垃圾回笼)

    Python 使用了引用计数这一大概本事来追踪和回笼废品料。

    在 Python 内部记录着独具应用中的对象各有稍许援用。

     一在那之中间追踪变量,称为一个引用计数器。

    当对象被创建时, 就创办了四个援引计数, 当这么些指标不再必要时, 也正是说, 那些目的的援引计数变为0 时, 它被垃圾回收。不过回笼不是"马上"的, 由解释器在方便的时机,将废品对象占用的内部存款和储蓄器空间回笼。

    新葡亰496net 19

    a = 40      # 创建对象  <40>
    b = a       # 增加引用, <40> 的计数
    c = [b]     # 增加引用.  <40> 的计数
    
    del a       # 减少引用 <40> 的计数
    b = 100     # 减少引用 <40> 的计数
    c[0] = -1   # 减少引用 <40> 的计数
    

    新葡亰496net 20

    污源回笼机制不仅仅指向引用计数为0的对象,雷同也得以拍卖循环援引的事态。循环援引指的是,七个指标互相引用,不过尚未此外变量援引他们。这种景观下,仅使用引用计数是远远不足的。Python 的污物搜聚器实际上是三个引用流速計和一个循环垃圾采撷器。作为援引计数的补偿, 垃圾搜罗器也会专一被分配的总的数量非常的大(及未通过引用计数销毁的那二个卡塔尔国的指标。 在此种场所下, 解释器会暂停下来, 试图清理全体未援引的巡回。

    if cpu利用率> 90%:

    1.8 实例方法、类措施、静态方法¶

    先说说 实例方法,实例方法第2个概念的参数只可以是实例本身援引self,只可以通超过实际例调用(便是我们事先用的 def func_name(self,xxx):

    类方法:是类对象所享有的艺术,须要用修饰器@classmethod来标记,第一个参数必需是类对象cls,能够经过类如故实例直用

    静态方法:定义静态方法使用装饰器@staticmethod,未有暗中认可的必需参数,通过类和实例直接调用

    静态方法中无需万分定义参数,由此在静态方法中引用类属性的话,必须经过 类对象来引用(访问)

    小明目眩神摇的对教师职员和工人争辩,老师给本身看多少个案例吧:

    In [1]:

    class Dog(object):
        # 类属性
        name = "小汪"
    
        # 实例方法
        def __init__(self, age):
            # 实例属性
            self.age = age
            # 打印看看
            print("self id:%s" % id(self))
    
        # 类方法
        @classmethod
        def show_name(cls):
            # 访问类属性 cls.xxx
            print("我叫%s" % cls.name)
            # 打印看看
            print("cls id:%s" % id(cls))
    
        # 静态方法
        @staticmethod
        def say_hello():
            print("汪汪汪")
    
    
    def main():
        # 类名方式访问
        Dog.show_name()
        Dog.say_hello()  # 类名的方式可以访问静态方法
    
        # 实例对象方式访问
        dog = Dog(2)
        dog.show_name()
        dog.say_hello()
    
    
    if __name__ == '__main__':
        main()
    

     

    我叫小汪
    cls id:94310818174200
    汪汪汪
    self id:140392216464016
    我叫小汪
    cls id:94310818174200
    汪汪汪
    

     


    相同都是这么用的(供参谋卡塔 尔(英语:State of Qatar):

    实例方法:日常平常用的都是它

    类方法:类方式用在模拟C#五个构造函数(Python里面不能够有同名函数) or 你需要 对类属性、类措施操作之类的

    静态方法:一般 都以单独效能,相同于函数,只可是在面向对象里面日常这么用

     


    类方法

    • 访谈类形式:类名.方法名(参数列表)

    咱俩要写贰个只在类中运营而不在实例中运作的措施

    class A(object):
        def __init__(self, name):
            self.name = name
    
        def printd(self):
            print(self.name)
    
        @staticmethod
        def smethod(*arg):
            print('Static:', arg)
    
        @classmethod
        def cmethod(*arg):
            print('Class:', arg)
    
    
    >> > a = A(12)
    >> > a.printd()
    12
    >> > a.smethod()
    Static: ()
    >> > a.cmethod()
    Class: ( < class '__main__.A' > ,)
    >> > A.printd()
    TypeError: unbound method printd() must be called with A instance as first argument(got nothing instead)
    >> > A.smethod()
    Static: ()
    >> > A.cmethod()
    Class: ( < class '__main__.A' > ,)
    

    实例

    析构函数 __del__ ,__del__在目的销毁的时候被调用,当对象不再被使用时,__del__主意运营:

    新葡亰496net 21

    #!/usr/bin/python3
    # -*- coding: UTF-8 -*-
    
    class Point:
       def __init__( self, x=0, y=0):
          self.x = x
          self.y = y
       def __del__(self):
          class_name = self.__class__.__name__
          print class_name, "销毁"
    
    pt1 = Point()
    pt2 = pt1
    pt3 = pt1
    print id(pt1), id(pt2), id(pt3) # 打印对象的id
    del pt1
    del pt2
    del pt3
    

    新葡亰496net 22

    如上实例运维结果如下:

    3083401324 3083401324 3083401324
    Point 销毁
    

    注意:经常你需求在单身的公文中定义叁个类

    发送邮件('CPU报告急察方')

    1.9 C#包裹案例¶

    C#面向对象相比雅观,来个包裹的案例基本上就解决了:

    using System;
    
    namespace _1Encapsulation
    {
        public class Student
        {
            /// <summary>
            /// 字段
            /// </summary>
            private int _age;
            /// <summary>
            /// 属性
            /// </summary>
            public int Age
            {
                get
                {
                    return _age;
                }
    
                set
                {
                    if (value > 1)
                    {
                        _age = value;
                    }
                }
            }
    
            /// <summary>
            /// 自动化属性
            /// </summary>
            public string Name { get; set; }
    
            /// <summary>
            /// 自动属性必须要有get访问器
            /// </summary>
            public string SNum { get; }
    
            private int _gender;
            public int Gender
            {
                set
                {
                    _gender = value;
                }
            }
    
            /// <summary>
            /// 构造函数的名字必须与类名一致
            /// 构造函数没有返回值也没有viod
            /// 默认自动生成一个无参构造函数,当有一个有参构造函数的时候无参构造函数便不会自动创建
            /// </summary>
            public Student() { }
    
            /// <summary>
            /// 有参构造函数
            /// </summary>
            /// <param name="name"></param>
            /// <param name="age"></param>
            public Student(string name, int age)
            {
                this.Name = name;
                this.Age = age;
            }
    
            /// <summary>
            /// this调用当前类的某个有参构造函数
            /// </summary>
            /// <param name="name"></param>
            /// <param name="age"></param>
            /// <param name="gender"></param>
            public Student(string name, int age, int gender) : this(name, age)
            {
                this.Gender = gender;
            }
    
            /// <summary>
            /// 某个方法
            /// </summary>
            public void Show()
            {
                Console.WriteLine("Name:"   this.Name   " Age:"   this.Age   "n");
            }
    
            public override string ToString()
            {
                return "Name:"   this.Name   " Age:"   this.Age;
            }
        }
    }
    

    调用部分:

    using System;
    
    namespace _1Encapsulation
    {
        class Program
        {
            static void Main(string[] args)
            {
                Student s = new Student() { Name = "mmd", Age = 13, Gender = 1 };
                s.Show();
    
                Student s1 = new Student("dmm", 20);
                s1.Show();
    
                Console.WriteLine(s);
            }
        }
    }
    

    python的常用内置方法

    内置方法 说明
    __init__(self,...) 初始化对象,在创建新对象时调用
    __del__(self) 释放对象,在对象被删除之前调用
    __new__(cls,*args,**kwd) 实例的生成操作
    __str__(self) 在使用print语句时被调用
    __getitem__(self,key) 获取序列的索引key对应的值,等价于seq[key]
    __len__(self) 在调用内联函数len()时被调用
    __cmp__(stc,dst) 比较两个对象src和dst
    __getattr__(s,name) 获取属性的值
    __setattr__(s,name,value) 设置属性的值
    __delattr__(s,name) 删除name属性
    __getattribute__() __getattribute__()功能与__getattr__()类似
    __gt__(self,other) 判断self对象是否大于other对象
    __lt__(slef,other) 判断self对象是否小于other对象
    __ge__(slef,other) 判断self对象是否大于或者等于other对象
    __le__(slef,other) 判断self对象是否小于或者等于other对象
    __eq__(slef,other) 判断self对象是否等于other对象
    __call__(self,*args) 把实例对象作为函数调用

    __init__():
      __init__方法在类的叁个目的被确马上,立刻运转。这几个主意能够用来对您的对象做一些您期望的伊始化。注意,那些名称的开头和末段都以双下划线。

    class Person:
        def __init__(self, name):
            self.name = name
        def sayHi(self):
            print 'Hello, my name is', self.name
    

      表达:__init__ 方法定义为取叁个参数name(以至见惯司空的参数self卡塔 尔(英语:State of Qatar)。在此个__init__里,大家只是成立叁个新的域,也可以称作name。注意它们是三个例外的变量,纵然它们有相似的名字。点号使我们能够区分它们。最根本的是,大家从不特意调用__init__方法,只是在创立叁个类的新实例的时候,把参数包罗在圆括号内跟在类名前面,进而传递给__init__方法。那是这种方法的第一之处。以往,大家能够在大家的章程中运用self.name域。那在sayHi方法中获得了表明。

    __new__():
      __new__()在__init__()以前被调用,用于转移实例对象.利用这一个主意和类属性的脾性能够兑现设计方式中的单例形式.单例模式是指创造独一指标呢,单例格局设计的类只可以实例化三个对象.

    class Singleton(object):
        __instance = None                       # 定义实例
    
        def __init__(self):
            pass
    
        def __new__(cls, *args, **kwd):         # 在__init__之前调用
            if Singleton.__instance is None:    # 生成唯一实例
                Singleton.__instance = object.__new__(cls, *args, **kwd)
            return Singleton.__instance
    

    __str__():
      __str__()用于表示对象表示的意思,再次来到一个字符串.完成了__str__()方法后,能够一贯运用print语句输出对象,也得以通过函数str()触发__str__()的试行.那样就把目的和字符串关联起来,便于某个程序的得以完毕,能够用那一个字符串来代表某些类

    class Cat:
        """定义了一个Cat类"""
    
        #初始化对象
        def __init__(self, new_name, new_age):
            self.name = new_name
            self.age = new_age
    
        def __str__(self):
            return "%s的年龄是:%d"%(self.name, self.age)
    

    __del__()

      __del__称作析构方法
      析构方法,当目的在内部存款和储蓄器中被假释时,自动触发实施。
        注:此格局日常不要定义,因为在Python中,程序猿在使用时不须求关切内部存款和储蓄器的分配和刑释解教,因为此干活都是提交Python解释器来举行,所以,析构函数的调用是由解释器在进展垃圾回笼时自动触发实行的。在程序实践甘休之后,实行此办法

    class Foo:
    
        def __del__(self):
            print('run __del__')
    

    7.类的延续

    面向对象的编制程序带来的重要利润之一是代码的录用,完结这种重用的法子之一是经过三翻五次机制。世襲完全能够精晓成类之间的档期的顺序和子类型关系。

    亟需小心的地点:波澜起伏语法 class 派生类名(基类名卡塔尔国://... 基类名写作括号里,基本类是在类定义的时候,在元组之中指明的。

    在python中一而再中的一些特征

    • 1:在那起彼伏中基类的布局(__init__()方法卡塔 尔(英语:State of Qatar)不会被机关调用,它需求在其派生类的布局中亲自特地调用。
    • 2:在调用基类的议程时,需求丰裕基类的类名前缀,且需求带上self参数变量。分歧于在类中调用普通函数时并无需带上self参数
    • 3:Python总是第风流倜傥查找对应类型的点子,假如它不可能在派生类中找到相应的主意,它才早先到基类中各个查找。(先在本类中检索调用的章程,找不到才去基类中找卡塔尔国

    大器晚成旦在三番三遍元组中列了八个之上的类,那么它就被称作"多种继承"

    语法:

    派生类的证明,与她们的父类相通,世袭的基类列表跟在类名之后,如下所示:

    class SubClassName (ParentClass1[, ParentClass2, ...]):
       'Optional class documentation string'
       class_suite
    

    实例:

    新葡亰496net 23

    #!/usr/bin/python3
    # -*- coding: UTF-8 -*-
    
    class Parent:        # 定义父类
       parentAttr = 100
       def __init__(self):
          print "调用父类构造函数"
    
       def parentMethod(self):
          print '调用父类方法'
    
       def setAttr(self, attr):
          Parent.parentAttr = attr
    
       def getAttr(self):
          print "父类属性 :", Parent.parentAttr
    
    class Child(Parent): # 定义子类
       def __init__(self):
          print "调用子类构造方法"
    
       def childMethod(self):
          print '调用子类方法 child method'
    
    c = Child()          # 实例化子类
    c.childMethod()      # 调用子类的方法
    c.parentMethod()     # 调用父类方法
    c.setAttr(200)       # 再次调用父类的方法
    c.getAttr()          # 再次调用父类的方法
    

    新葡亰496net 24

    以上代码推行结果如下:

    调用子类构造方法
    调用子类方法 child method
    调用父类方法
    父类属性 : 200
    

    你能够继续四个类:

    新葡亰496net 25

    class A:        # 定义类 A
    .....
    
    class B:         # 定义类 B
    .....
    
    class C(A, B):   # 继承类 A 和 B
    .....
    

    新葡亰496net 26

    您能够动用issubclass()只怕isinstance()方法来检查评定。

    • issubclass() - 布尔函数判别二个类是另三个类的子类或许子孙类,语法:issubclass(sub,sup)
    • isinstance(obj, Class) 布尔函数假如obj是Class类的实例对象只怕是多少个Class子类的实例对象则赶回true

    if硬盘使用空间> 百分之八十:

    8.措施重写

    举例您的父类方法的效劳不能满意你的要求,你能够在子类重写你父类的法子:

    实例:

     

    新葡亰496net 27

    #!/usr/bin/python3
    # -*- coding: UTF-8 -*-
    
    class Parent:        # 定义父类
       def myMethod(self):
          print '调用父类方法'
    
    class Child(Parent): # 定义子类
       def myMethod(self):
          print '调用子类方法'
    
    c = Child()          # 子类实例
    c.myMethod()         # 子类调用重写方法
    

    新葡亰496net 28

    出殡邮件('硬盘报警')

    9.底蕴重载方法

    下表列出了部分通用的成效,你能够在自身的类重写:

    新葡亰496net 29

    if内存占用> 十分之八:

    10.类质量与办法

    发送邮件('内部存款和储蓄器报告警察方')

    类的村办属性

    __private_attrs:多少个下划线开端,申明该属性为私家,不可能在类地外界被使用或直接访问。在类内部的办法中应用时 self.__private_attrs

    面向对象编制程序(Object Oriented Programming,OOP,面向对象程序设计卡塔尔国

    类的艺术

    在类地内部,使用def关键字可认为类定义一个艺术,与经常函数定义不相同,类措施必需包涵参数self,且为第二个参数

    面向对象(object-oriented ;简单的称呼: OO)指按大家认识客观世界的系统思想方法,选拔基于对象(实体)的概念建模,模拟客观世界深入分析、设计、达成软件的方法。

    类的个体方法

    __private_method:多个下划线起头,表明该形式为个体方法,无法在类地外界调用。在类的中间调用self.__private_methods

    面向对象编制程序(Object Oriented Programming-OOP)是生机勃勃种缓慢解决软件复用的布置和编制程序方法。这种方法把软件系统中近乎相似的操作逻辑和操作使用数据、状态,以类的型式描述出来,以指标实例的款式在软件系统中复用,以高达增进软件开拓作用的功力。

    实例

    新葡亰496net 30

    #!/usr/bin/python3
    # -*- coding: UTF-8 -*-
    
    class JustCounter:
        __secretCount = 0  # 私有变量
        publicCount = 0    # 公开变量
    
        def count(self):
            self.__secretCount  = 1
            self.publicCount  = 1
            print self.__secretCount
    
    counter = JustCounter()
    counter.count()
    counter.count()
    print counter.publicCount
    print counter.__secretCount  # 报错,实例不能访问私有变量
    

    新葡亰496net 31

    面向对象的明亮:

    11.补充

     新式类与卓越类继承写法

    # ShcoolMeber.__init__(self,name,age,sex)

    super(Stu,self).__init__(name,age,sex)

    新葡亰496net 32

    新葡亰496net 33

    新葡亰496net 34

    新葡亰496net 35

    面向对象是生龙活虎种设计观念

    参照他事他说加以考察链接

    1.合乎大家的思虑习于旧贯

    2.把推行者产生指挥者

    3.简化效率,把复杂的作业简单化

    面向对象有三大特色:

    1.封装

    2.继承

    3.多态

    1.2类和指标

    对象是面向对象编制程序的着力,在应用对象的进度中,为了将全数协同特征和行事的生龙活虎组对象抽象概念,提议了其它三个新的定义——类

    类是对事情的描述,是聊以自慰的。

    目的是类的切实可行体现。

    1.2.1类

    类:

    负有相同内部景观和活动规律的实体的晤面(或统称为架空)。

    装有肖似属性和作为事物的统称

    类是虚幻的,在行使的时候平时会找到这些类的一个切实的留存,使用这一个实际的留存。二个类可以找到八个对象

    1.2.2对象

    对象:

    某多个现实事物的存在,在切实世界中得以是看得见摸得着的。

    能够是一直使用的

    1.2.3类和对象时期的关系

    类便是创造对象的沙盘

    1.2.4类的结合

    类(Class)由3个部分组成

    ·类的称谓:类名

    ·类的品质:黄金时代组数据成员变量

    ·类的点子:允许对开展操作的主意(行为)成员方法

    1.2.5类的虚幻

    持有生龙活虎致(或许形似)属性和行事的指标都足以抽像出三个类

    办法:日常名词都以类(名词提炼法)

    1.3定义类

    概念一个类,格式如下:

    class类名:

    办法列表

    demo:定义一个Car类

    #定义类

    classCar:

    #方法

    defgetCarInfo(self):

    print('车轮子个数:%d,颜色%s'%(self.wheelNum, self.color))

    defmove(self):

    print("车正在移动...")

    说明:

    ·定义类时有2种:新式类和经文类,上边的Car为杰出类,假如是Car(object)则为新式类

    ·类名的命名准则依据"大驼峰"

    1.4创制对象

    成立对象的格式为:

    对象名=类名()

    创造对象demo:

    #定义类

    classCar:

    #移动

    defmove(self):

    print('车在奔跑...')

    #鸣笛

    deftoot(self):

    print("车在鸣笛...嘟嘟..")

    #开创四个对象,并用变量BMW来保存它的援用

    BMW = Car()

    BMW.color ='黑色'

    BMW.wheelNum =4#轱辘数量

    BMW.move()

    新葡亰496net,BMW.toot()

    print(BMW.color)

    print(BMW.wheelNum)

    总结:

    ·BMW = Car(),那样就发出了二个Car的实例对象,那时也足以通超过实际例对象BMW来访谈属性恐怕措施

    ·第二次选用BMW.color

    = '白灰'表示给宝马这些目的增多属性,要是前边再一次现身BMW.color = xxx表示对质量实行校勘

    ·BMW是贰个对象,它抱有属性(数据卡塔尔和措施(函数卡塔 尔(阿拉伯语:قطر‎

    ·当创设三个对象时,正是用二个模子,来制作叁个钱物

    1.5__init__()方法

    在创制对象的时候,直接设置对象的性质。

    1.5.1使用方法

    def类名:

    #伊始化函数,用来完毕都部队分暗许的设定

    def__init__():

    pass

    1.5.2__init__()方法的调用

    #概念汽车类

    classCar:

    def__init__(self):

    self.wheelNum =4

    self.color ='蓝色'

    defmove(self):

    print('车在跑,目标:夏威夷')

    #成立对象

    BMW = Car()

    print('车的水彩为:%s'%BMW.color)

    print('车轮胎数量为:%d'%BMW.wheelNum)

    1.5.3总结1

    当创制Car对象后,在一向不调用__init__()方法的前提下,BMW就默许具有了2个属性wheelNum和color,原因是__init__()方法是在创造对象后,就及时被私下认可调用了

    调用__init__()方法时传参:

    #概念小车类

    classCar:

    def__init__(self, newWheelNum, newColor):

    self.wheelNum = newWheelNum

    self.color = newColor

    defmove(self):

    print('车在跑,目标:夏威夷')

    #成立对象

    BMW = Car(4,'green')

    print('车的颜料为:%s'%BMW.color)

    print('车轮子数量为:%d'%BMW.wheelNum)

    1.5.4总结2

    ·__init__()方法,在开创叁个目的时暗中同意被调用,没有必要手动调用

    ·__init__(self)中,暗中认可有1个参数名叫self,如若在创设对象时传递了2个实参,那么__init__(self)中出了self作为第一个形参外还供给2个形参,比如__init__(self,x,y)

    ·__init__(self)中的self参数,不须要开辟者传递,python解释器会自动把当下的对象援引传递步入

    1.6"魔法"方法

    1.6.1打印id()

    print(对象名)

    1.6.2定义__str__()方法

    classCar:

    def__init__(self, newWheelNum, newColor):

    self.wheelNum = newWheelNum

    self.color = newColor

    def__str__(self):

    msg ="嘿。。。小编的颜料是" self.color "作者有" int(self.wheelNum) "个轮胎..."

    returnmsg

    defmove(self):

    print('车在跑,目标:夏威夷')

    BMW = Car(4,"白色")

    print(BMW)

    1.6.3总结

    ·在python中方法名假诺是__xxxx__()的,那么就有独特的功力,由此称为“法力”方法

    ·当使用print输出对象的时候,只要自个儿定义了__str__(self)方法,那么就可以打字与印刷从在这里个主意中return的多寡

    ·

    1.7self

    1.7.1理解self

    示例:

    #概念一个类

    classAnimal:

    #方法

    def__init__(self, name):

    self.name = name

    defprintName(self):

    print('名字为:%s'%self.name)

    #概念叁个函数

    defmyPrint(animal):

    animal.printName()

    dog1 = Animal('西西')

    myPrint(dog1)

    dog2 = Animal('北北')

    myPrint(dog2)

    self代表是近期目的

    1.7.2总结

    ·所谓的self,能够知晓为团结

    ·能够把self当作C 中类里面包车型大巴this指针同样明亮,正是目的自己的意思

    ·有个别对象调用其方式时,python解释器会把这么些目的作为第多少个参数字传送递给self,所以开垦者只要求传递前面包车型地铁参数就可以

    1.8掩护对象的质量

    风流倜傥经有叁个指标,当需求对其进行改进属性时,有2种办法

    ·对象名.属性名=数据---->直接校正

    ·对象名.方法名() ---->直接改过

    为了越来越好的保存属性安全,即无法随意校正,平时的管理方式为

    ·将质量定义为私有总体性

    ·增多叁个方可调用的艺术,供调用

    classPeople(object):

    def__init__(self, name):

    self.__name = name

    defgetName(self):

    returnself.__name

    defsetName(self, newName):

    iflen(newName) >=5:

    self.__name = newName

    else:

    print("error:名字长度要求大于或许等于5")

    xiaoming = People("xx")

    print(xiaoming.__name)

    classPeople(object):

    def__init__(self, name):

    self.__name = name

    defgetName(self):

    returnself.__name

    defsetName(self, newName):

    iflen(newName) >=5:

    self.__name = newName

    else:

    print("error:名字长度必要大于可能等于5")

    xiaoming = People("xx")

    xiaoming.setName("yy")

    print(xiaoming.getName())

    xiaoming.setName("lisi")

    print(xiaoming.getName())

    总结

    ·Python中从不像重大字来分别公有属性和村办属性

    ·它是以属性命名格局来区分,假使在属性名前边加了2个下划线'__',则申明该属性是私有属性,不然为国有属性(方法也是均等,方法名前边加了2个下划线的话代表该办法是私有的,不然为国有的卡塔 尔(英语:State of Qatar)。

    1.9__del__()方法

    创造对象后,python解释器暗许调用__init__()方法;

    当删除三个指标时,python解释器也会默许调用一个主意,这些方式为__del__()方法

    importtime

    classAnimal(object):

    #最初化方法

    #创建完对象后会自动被调用

    def__init__(self, name):

    print('__init__办法被调用')

    self.__name = name

    #析构方法

    #当对象被删除时,会自动被调用

    def__del__(self):

    print("__del__方法被调用")

    print("%s对象及时被干掉了..."%self.__name)

    #创设对象

    dog = Animal("哈皮狗")

    #剔除对象

    deldog

    cat = Animal("波斯猫")

    cat2 = cat

    cat3 = cat

    print("---马上删除cat对象")

    delcat

    print("---立时删除cat2对象")

    delcat2

    print("---立刻删除cat3对象")

    delcat3

    print("程序2秒钟后停止")

    time.sleep(2)

    总结

    ·当有1个变量保存了指标的援用时,此目的的援用计数就可以加1

    ·当使用del删除变量指向的目的时,假如指标的引用计数不会1,比如3,那么那个时候只会让那一个援引计数减1,即变为2,当再一次调用del时,变为1,借使再调用1次del,那时候会真正把对象进行删除,__del__会被调用

    面向对象,python面向对象。1.10接续介绍以致单世襲

    干什么要持续:

    将共性的剧情放在父类中,子类只要求关爱本身特有的原委

    1.10.1接续的定义

    后续描述的是事物之间的所属关系。

    1.10.2三回九转示例

    #概念叁个父类,如下:

    classCat(object):

    def__init__(self, name, color="白色"):

    self.name = name

    self.color = color

    defrun(self):

    print("%s--在跑"%self.name)

    #概念叁个子类,世襲Cat类如下:

    classBosi(Cat):

    defsetNewName(self, newName):

    self.name = newName

    defeat(self):

    print("%s--在吃"%self.name)

    bs = Bosi("印度猫")

    print('bs的名为:%s'%bs.name)

    print('bs的颜色为:%s'%bs.color)

    bs.eat()

    bs.setNewName('波斯')

    bs.run()

    说明:

    ·即便子类未有概念__init__艺术,可是父类有,所以在子类世袭父类的时候这几个法子就被接续了,所以风姿罗曼蒂克旦成立Bosi的对象,就暗中认可试行了十三分世襲过来的__init__方法

    总结

    ·子类在继续的时候,在定义类时,小括号()中为父类的名字

    ·父类的习性、方法,会被持续给子类

    1.10.3注意点

    classAnimal(object):

    def__init__(self, name='动物', color='白色'):

    self.__name = name

    self.color = color

    def__test(self):

    print(self.__name)

    print(self.color)

    deftest(self):

    print(self.__name)

    print(self.color)

    classDog(Animal):

    defdogTest1(self):

    #print(self.__name) #无法访谈到父类的私人民居房属性

    print(self.color)

    defdogTest2(self):

    #self.__test() #无法采访父类中的私有方法

    self.test()

    A = Animal()

    #print(A.__name) #程序现身卓殊,不能够访问私有属性

    print(A.color)

    #A.__test() #程序现身分外,不能够访谈私有方法

    A.test()

    print("------分割线-----")

    D = Dog(name ="小花狗", color ="黄色")

    D.dogTest1()

    D.dogTest2()

    总结

    ·私有的习性,不可能经过对象直接访谈,然而能够透过措施访谈

    ·私有的不二等秘书诀,不能够经过对象直接采访

    ·私有的质量、方法,不会被子类世袭,也无法被访谈

    ·平日景色下,私有的质量、方法都以不对外发布的,往往用来做内部的事情,起到安全的坚决守住

    1.11多继承

    所谓多一而再,即子类有八个父类,况兼具备它们的天性

    多三番两次的格式如下:

    #概念一个父类

    classA:

    defprintA(self):

    print('----A----')

    #概念一个父类

    classB:

    defprintB(self):

    print('----B----')

    #概念三个子类,世襲自A、B

    classC(A,B):

    defprintC(self):

    print('----C----')

    obj_C = C()

    obj_C.printA()

    obj_C.printB()

    运转结果:

    ----A----

    ----B----

    说明

    ·python中是足以多一连的,在java中叫接口

    ·父类中的方法、属性,子类会世袭

    1.12重写/覆盖父类方法与调用父类方法

    1.12.1重写父类方法

    所谓重写,便是子类中,有多个和父类相通名字的秘技,在子类中的方法会覆盖掉父类中同名的章程

    #coding=utf-8

    classCat(object):

    defsayHello(self):

    print("halou-----1")

    classBosi(Cat):

    defsayHello(self):

    print("halou-----2")

    bosi = Bosi()

    bosi.sayHello()

    1.12.2调用父类的不二等秘书诀

    #coding=utf-8

    classCat(object):

    def__init__(self,name):

    self.name = name

    self.color ='yellow'

    classBosi(Cat):

    def__init__(self,name):

    #调用父类的__init__方法1(python2)

    #Cat.__init__(self,name)

    #调用父类的__init__方法2

    #super(Bosi,self).__init__(name)

    #调用父类的__init__方法3

    super().__init__(name)

    defgetName(self):

    returnself.name

    bosi =

    Bosi('xiaohua')

    print(bosi.name)

    print(bosi.color)

    1.13多态

    Python不支持多态,也不用扶助多态,python是后生可畏种多态语言,崇尚绒鸭类型。

    在前后相继设计中,钻水鸭类型(乌Crane语:duck typing卡塔 尔(英语:State of Qatar)是动态类型的后生可畏种风格。在这里种作风中,四个目的有效的语义,不是由一连自特定的类或促成特定的接口,而是由近日艺术和总体性的联谊决定。

    在硬尾鸭类型中,关注的不是目的的花色小编,而是它是什么样利用的。

    所谓多态:定义时的品类和周转时的类型分化,就成为多态

    ·Python伪代码达成Java或C#的多态

    packagedemo1;

    /*

    多态:七种形状,必需依据于继续实现的。

    场景:

    Animal

    |Dog

    |Cat

    */

    classAnimal{

    public void eat(){

    System.out.println("animaleat...");

    }

    }

    class Dogextends Animal{

    public void eat(){

    System.out.println("Dogeat...");

    }

    }

    class Catextends Animal{

    public void eat(){

    System.out.println("Cateat...");

    }

    }

    classMyTest{

    public static void tt(Animal animal){

    animal.eat();

    }

    public static void main(String[] args){

    Animal a = new Animal();

    tt(a);// animal eat...

    Animal d = new Dog();

    tt(d);// Animal animal = dDog eat...

    d = new Cat();

    tt(d);// Cat eat...

    //int num= 10;

    //tt(num);

    }

    }

    /**

    * java,c#都以强类型语言,正是说在变量定义的时候必须类型名字

    *那样,在传递参数的时候,都类型有须要

    *

    *八方在这里么的语言中,多态的表现存三种:

    *1、父类作为参数,既可以够传递父类对象,也能够传递子类对象

    *那般,在格局中,调用的是子和父皆有的艺术,

    *要是传递的是父类对象,调用的正是父类的办法

    *设若传递的是子类对象,调用的正是子类的法门

    *

    */

    ·Python “硬尾鸭类型”

    ‘’’

    python是风流倜傥种弱类型语言,未有项目节制。

    变量的品种永久是因而左侧的值判定的。

    方法中的参数,传递任何值都行。但是要思索方法内部的作业逻辑。

    多态:

    1、父类作为参数,可以传递父类和子类对象

    2、接口作为参数,只可以传递达成指标

    进而有三种掌握:

    1、python不扶助多态:

    python是弱类型,未有项目节制,不能够区分父和子,只怕说接口和促成类

    2、python随地是多态

    python是弱类型,未有项目节制,传递任何内容都行

    ‘’’

    classF1(object):

    def show(self):

    print('F1.show')

    classS1(F1):

    def show(self):

    print('S1.show')

    classS2(F1):

    def show(self):

    print('S2.show')

    deffunc(obj):

    obj.show()

    #print(type(obj))

    s1_obj =S1()

    func(s1_obj)

    s2_obj =S2()

    func(s2_obj)

    f1 = F1()

    func(f1)

    #func(10)能传递值,不过事情逻辑恐怕不相符

    1.14类性质、实例属性

    平昔在类中定义的,与艺术平齐,不在方法里的品质就是类属性

    在措施里透过self.属性都以实例属性

    类属性和实例属性:

    在眼下的事例中大家接触到的正是实例属性(对象属性卡塔尔。从名称想到所包涵的意义,类本性正是类对象所持有的习性,它被全体类对象的实例对象所共有,在内存中只存在二个别本。对于国有的类属性,在类外能够经过类对象和实例对象访谈

    1.14.1类属性

    classPeople(object):

    name ='Tom'#国有的类属性

    __age =12#个人的类属性

    p = People()

    print(p.name)#正确

    print(People.name)#正确

    print(p.__age)#不当,不可能在类外通超过实际例对象访谈私有的类属性

    print(People.__age)#荒谬,不可能在类外通过类对象访谈私有的类属性

    1.14.2实例属性(对象属性)

    classPeople(object):

    address ='山东'#类属性

    def__init__(self):

    self.name ='xiaowang'#实例属性

    self.age =20#实例属性

    p = People()

    p.age =12#实例属性

    print(p.address)#正确

    print(p.name)#正确

    print(p.age)#正确

    print(People.address)#正确

    print(People.name)#错误

    print(People.age)#错误

    1.14.3由此实例(对象)去改正类属性

    classPeople(object):

    country ='china'#类属性

    print(People.country)

    p = People()

    print(p.country)

    p.country ='japan'

    print(p.country)#实例属性会屏蔽掉同名的类属性

    print(People.country)

    delp.country#剔除实例属性

    print(p.country)

    总结

    ·就算必要在类外改良类属性,务必经过类对象去引用然后实行更正。假使由此实例对象去援引,会生出一个同名的实例属性,这种格局校正的是实例属性,不会潜移暗化到类属性,何况之后假如通过实例对象去引用该名称的天性,实例属性会强制屏蔽掉类属性,即援用的是实例属性,除非删除了该实例属性。

    ·

    1.15静态方法和类措施

    1.15.1类方法

    类对象所持有的法子,要求用修饰器@classmethod(注明、元数据卡塔尔来标识其为类措施,对于类措施,第多少个参数必需是类对象,平时以cls作为第一个参数,能够因而实例对象和类对象去拜见。

    classPeople(object):

    country ='china'

    #类措施,用classmethod来实行修饰

    @classmethod

    defgetCountry(cls):

    print(type(cls))

    print(cls)

    returncls.country

    p = People()

    p.country=1

    print(p.getCountry())#能够用超过实际例对象援用china

    printPeople.getCountry()#能够经过类对象引用china

    类措施还可能有叁个用项正是足以对类属性实行改动:

    classPeople(object):

    country ='china'

    #类措施,用classmethod来進展修饰

    @classmethod

    defgetCountry(cls):

    returncls.country

    @classmethod

    defsetCountry(cls,country):

    cls.country = country

    p = People()

    print(p.getCountry())#能够用超过实际例对象援用

    print(People.getCountry())#能够经过类对象引用

    p.setCountry('japan')

    printp.getCountry()

    printPeople.getCountry()

    1.15.2静态方法

    要求经过修饰器@staticmethod来进行修饰,静态方法不必要多定义参数

    classPeople(object):

    country ='china'

    @staticmethod

    #静态方法

    defgetCountry():

    returnPeople.country

    printPeople.getCountry()

    class People(object):

    country = 'china'

    __num = 100

    #类措施,用classmethod来实行修饰

    @classmethod

    def getCountry(cls):

    print(type(cls))

    print(cls)

    return cls.country

    @staticmethod

    def myStaticMethod():

    print('myStaticMethod...')

    print(People.__num)

    p = People()

    p.country=1

    print(p.getCountry())#能够用过实例对象征引

    print(People.getCountry())#能够因而类对象引用

    p.myStaticMethod()

    People.myStaticMethod()

    '''

    1、类措施,实例和类对象都能访问

    cls:类对象

    2、静态方法:不传参,实例和类对象都能访问

    '''

    总结

    类形式的率先个参数是类对象cls,那么通过cls引用的早晚是类对象的性质和艺术;而实例方法的率先个参数是实例对象self,那么通过self引用的大概是类属性、也会有一点都不小希望是实例属性,不过在设有近似名称的类属性和实例属性的事态下,实例属性优先级越来越高。静态方法中不必要非常定义参数,因而在静态方法中引用类属性的话,必需透过类对象来引用

    1.16设计方式

    设计情势是软件开采人士在软件开荒进度中面临的相像难题的实施方案。

    1.16.1设计格局六大原则

    1.设计格局六大口径(1卡塔尔国:单黄金年代职分标准

    即四个类只担任生龙活虎项义务

    2.设计方式六大条件(2卡塔 尔(英语:State of Qatar):里氏替换原则

    持有引用基类的地点必得能透明地运用其子类的指标

    3.设计格局六大规格(3卡塔 尔(英语:State of Qatar):信任倒置原则

    高层模块不该依靠低层模块,二者都应有依靠其抽象;抽象不该凭仗细节;细节应该依赖抽象。

    4.设计格局六大原则(4卡塔尔:接口隔开原则

    客商端不应该依靠它无需的接口;一个类对另一个类的注重应该建构在一点都不大的接口上。

    5.设计方式六大条件(5卡塔尔:迪米特别准许则

    三个对象应该对任何对象有限支撑起码的垂询。尽量缩小类与类之间的耦合。

    6.设计情势六大口径(6卡塔尔国:开闭原则

    一个软件实体如类、模块和函数应该对扩大开放,对改正关闭。

    1.16.2分类

    1.创立型格局

    重视指标:成立对象

    共四种:工厂方法格局、抽象工厂形式、单例格局、建造者情势、原型格局。

    2.结构型情势

    重大目标:对象的三结合和对象的涉嫌

    共多种:适配器格局、装饰器格局、代理方式、外观形式、桥接情势、组合方式、享元情势。

    3.行为型方式

    首要目标:对象的行为,对象能做什么

    共十风流倜傥种:计策情势、模板方法形式、观望者方式、迭代子方式、义务链方式、命令方式、备忘录情势、状态情势、访谈者方式、中介者情势、解释器情势。

    1.17工厂设计形式

    工厂函数、工厂类对现实的成形环节进展了包装,那样有支持代码的后需扩张,即把效果与利益区划的更具体。

    总结:

    在创立对象比较轻巧的时候,咱们一贯在主方法中做了,可是洋洋时候,创制对象需求有的起头化的操作,恐怕业务逻辑的处理。约等于说,不常候创立一个对象会做相比较复杂的操作,那个时候,借使全部指标的始建操作都投身主方法中,就不适当了,还行简易工厂方式

    简言之工厂方式的整合:

    1.工厂类角色:那是本情势的中央,含有一定的生意逻辑和判定逻辑,用来成立成品

    2.虚无成品剧中人物:它日常是切实付加物波澜起伏的父类或许完成的接口。

    3.具体成品剧中人物:工厂类所创办的目的就是此角色的实例。

    大致工厂的优点和缺欠

    对象创建对比复杂的时候,能够设想采纳简便工厂

    1.优点:

    在简易工厂中主函数也许顾客端不再肩负对象的创办,而是把这些权利交给工厂类,主函数也许顾客端在使用对象的时候只从工厂中调用就能够了,进而明确了生龙活虎意气风发类的职务,切合单一职分标准卡塔 尔(阿拉伯语:قطر‎

    2.缺点

    是因为那几个工厂类担当全体指标的创设,那么当子类增加时,大家就必要去修正工厂类的代码,那样吧,就违背了多个口径:开闭原则

    其偶尔候能够行使工厂方法形式

    工厂方法形式组成:

    1.虚幻工厂角色:那是工厂方法情势的为主,它与应用程序无关。是切实可行工厂剧中人物必需落成的接口也许必得延续的父类。

    2.现实工厂剧中人物:它包含和切实业务逻辑有关的代码。由应用程序调用以创办对应的切切实实付加物的目的。

    3.架空产物剧中人物:它是具体产物继续的父类恐怕是促成的接口。

    4.切实可行成品剧中人物:具体工厂剧中人物所创设的目的就是此剧中人物的实例。

    厂子方法方式的长处和破绽

    3.优点:

    解决了简易工厂形式的违反开闭原则

    4.缺点

    若果必要充实三个生气勃勃成品类剧中人物,需求增添那么些类和呼应的工厂类。代码量大。

    1.18__new__的使用

    __new__和__init__的作用

    classA(object):

    def__init__(self):

    print("这是init方法")

    def__new__(cls):

    print("这是new方法")

    returnobject.__new__(cls)

    A()

    总结

    ·__new__足足要有八个参数cls,代表要实例化的类,此参数在实例化时由Python解释器自动提供

    ·__new__务供给有重临值,重返实例化出来的实例,那点在友好达成__new__时要特别注意,可以return父类__new__出去的实例,或许直接是object的__new__出来的实例

    ·__init__有三个参数self,就是那几个__new__回到的实例,__init__在__new__的功底上得以做到部分任何早先化的动作,__init__无需重返值

    1.19单例设计情势

    1.19.1单例是怎样

    保险某二个类独有三个实例,并且自行实例化并向任何系统提供这一个实例,这几个类称为单例类,单例格局是意气风发种对象创立型方式。

    1.19.2创办单例-保险唯有1个指标

    #实例化一个单例

    classSingleton(object):

    __instance =None

    def__new__(cls, age, name):

    #假如类数字能够__instance未有可能尚未赋值

    #那正是说就创办二个对象,何况赋值为这几个指标的引用,保障后一次调用这几个办法时

    #能够通晓前边早就创建过对象了,那样就保障了独有1个对象

    ifnotcls.__instance:

    cls.__instance = object.__new__(cls)

    returncls.__instance

    a = Singleton(18,"wangcai")

    b = Singleton(8,"wangcai")

    print(id(a))

    print(id(b))

    a.age =19#给a指向的对象增多二个本性

    print(b.age)#收获b指向的对象的age属性

    1.19.3成立单例时,只进行1次__init__方法

    #实例化三个单例

    classSingleton(object):

    __instance =None

    __first_init =False

    def__new__(cls, age, name):

    ifnotcls.__instance:

    cls.__instance = object.__new__(cls)

    returncls.__instance

    def__init__(self, age, name):

    ifnotself.__first_init:

    self.age = age

    self.name = name

    Singleton.__first_init =True

    a = Singleton(18,"wangcai")

    b = Singleton(8,"xiaoqiang")

    print(id(a))

    print(id(b))

    print(a.age)

    print(b.age)

    a.age =19

    print(b.age)

    本文由新葡亰496net发布于电脑系统,转载请注明出处:面向对象,python面向对象

    关键词:

上一篇:面向对象之,底工衍生

下一篇:没有了