您的位置:新葡亰496net > 奥门新萄京娱乐场 > 新葡亰496netPython之面向对象总计,零基础分分钟

新葡亰496netPython之面向对象总计,零基础分分钟

发布时间:2019-06-16 03:47编辑:奥门新萄京娱乐场浏览(125)

    一、面向对象

    Python之面向对象总括,python面向对象

    一、面向对象

       1、面向进程

           a、优点:十分大的下跌了写程序的复杂度,只须求顺着推行的步骤,堆集代码就能够

           b、缺点:一套流水生产线或然流程正是来化解八个主题素材,代码正是牵一发而北京全身

       2、面向对象

           a、优点:化解程序的扩张性,对某二个目的单独修改,会立马反应到整个系统中

           b、缺点:可控性差,不可能向面向进度的次序设计流水生产线式的可以很精准的猜度难点的管理流程与结果,面向对象的程序一旦初叶就有指标之间的交互解决难题。

       3、 类:具备同样特征的一类东西(人、狗、老虎)

       4、对象/实例:具体的某三个东西(隔壁阿花、楼下旺财)

       5、实例化:类——>对象的历程

       6、 在python中,用变量表示特征,用函数表示能力,因此具备一样特征和才干的一类东西就是‘类’,

       7、对象是则是这一类东西中具体的二个

    class Person:   #定义一个人类
        role = 'person'  #人的角色属性都是人
        def walk(self):  #人都可以走路,也就是有一个走路方法,也叫动态属性
            print("person is walking...")
    
    class 类名:
        类属性 = None
        def __init__(self,对象属性):
            self.对象属性 = 对象属性
    
        def 方法名(self):
            pass
    
    实例 = 类名(10)
    实例.方法名()
    

        8、类的三种效应:属性引用和实例化

        9、属性引用(类名.属性)

    class Person:   #定义一个人类
        role = 'person'  #人的角色属性都是人
        def walk(self):  #人都可以走路,也就是有一个走路方法
            print("person is walking...")
    
    
    print(Person.role)  #查看人的role属性
    print(Person.walk)  #引用人的走路方法,注意,这里不是在调用
    

        10、例化:类名加括号就是实例化,会活动触发__init__函数的运作,能够用它来为各类实例定制自个儿的性状

    class Person:   #定义一个人类
        role = 'person'  #人的角色属性都是人
        def __init__(self,name):
            self.name = name  # 每一个角色都有自己的昵称;
    
        def walk(self):  #人都可以走路,也就是有一个走路方法
            print("person is walking...")
    
    
    print(Person.role)  #查看人的role属性
    print(Person.walk)  #引用人的走路方法,注意,这里不是在调用
    

        11、

    类名
        类名.类属性
       类名.方法名
    
    实例 = 类名(参数,参数)  #实例就是对象
    
    实例
        实例.方法名()
       实例.对象属性
    
    实例增加属性
    实例.新的属性名 = 1000
    print(实例.新的属性名)
    

       12、关于self

    self:在实例化时自动将对象/实例本身传给__init__的第一个参数,你也可以给他起个别的名字.
    
    对象/实例只有一种作用:属性引用
    
    class 类名:
        def __init__(self,参数1,参数2):
            self.对象的属性1 = 参数1
            self.对象的属性2 = 参数2
    
        def 方法名(self):pass
    
        def 方法名2(self):pass
    
    对象名 = 类名(1,2)  #对象就是实例,代表一个具体的东西
                      #类名() : 类名 括号就是实例化一个类,相当于调用了__init__方法
                      #括号里传参数,参数不需要传self,其他与init中的形参一一对应
                      #结果返回一个对象
    对象名.对象的属性1   #查看对象的属性,直接用 对象名.属性名 即可
    对象名.方法名()     #调用类中的方法,直接用 对象名.方法名() 即可
    
    dir(类) #返回类中的所有名字列表
    isinstance(对象,类) #判断对象是否为类的实例
    print(Person.__dict__) # 返回一个字典 key是属性名,value是属性值
    print(Person.__module__)  #person类所在的模块
    print(Person.__name__,type(Person.__name__)) #字符串数据类型的类名
    

         13、类命名空间与对象、实例的命名空间

               a、常见八个类就能够创立一个类的名称空间,用来积存类中定义的持有名字,那么些名字改成类的属性

               b、而类有二种属性:静态属性和动态属性

    •  静态属性正是直接在类中定义的变量
    • 动态属性正是概念在类中的方法

    创建叁个目的/实例就能够成立二个对象/实例的名号空间,存放对象/实例的名字,称为对象/实例的性子

    相貌对象的整合用法:

    整合指的是,在二个类中以其它贰个类的目的作为数据属性,称为类的组

    列子:

    新葡亰496net 1

    from  math  import pi
    class Circular:
        def __init__(self,radius):
            self.radius=radius
        def area(self):
            return self.radius **2 * pi
        def perimeter(self):
            return 2 * self.radius * pi
    circu=Circular(10)
    print(circu.area())
    print(circu.perimeter())
    

    圆的周长与面积

         14、面向对象的三大特色

               a、继承

    class Animal:      #父类  基类  超类
        def __init__(self,name,life_value,aggr):
            self.name = name
            self.life_value = life_value
            self.aggr = aggr
    
    
    class Person(Animal):  #子类  派生类
        pass
    
    class Dog(Animal): #子类  派生类
        pass
    
    egg = Person('egon',1000,50)
    print(egg.name)
    print(egg.aggr
    

           

    python2
    class Dad:  #经典类
    class Dag(object)  #新式类
    
    python3
    class Dad  ==  class Dag(object) #新式类
    

                  1、承袭的语法

     class 类名(父类名):
          想在子类中实现调用父类的方法
          在类内 ——super(子类名,self).方法名()
          在类外面 ——super(子类名,对象名).方法名()
          如果不指定继承的父类,默认继承object
          子类可以使用父类的所有属性和方法
          如果子类有自己的方法就执行自己的的
          如果是子类没有的方法就执行父类的
          如果子类父类都没有这个方法就报错
    
    继承、抽象、派生
    继承 是从大范围到小范围
    抽象 小范围到大范围
    派生 就是在父类的基础上又产生子类——派生类
            父类里没有的 但子类有的 ——派生方法
            派生属性
    方法的重写
        父类里有的方法,在子类里重新实现
    
     
    

                  2、承继的三种用途:                

                      b:承继基类的法子,并且做出自身的更换恐怕扩张(代码重用)***  ***

                      a:评释某些子类兼容于某基类,定义四个接口类Interface,接口类中定义

                             ** 了部分接口名(正是函数名)且尚未完结接口的效率,子类继继承口类,并且实现接口中的效用**

               b、封装

                      1、优点:

                                  a、将扭转隔开

                                  b、封装使用

                                  c、提升复用性

                                  d、进步安全性

                      2、封装原则:

                                  a、将无需对外提供的内容都掩藏起来

                                  b、把品质都隐藏起来提供公共措施对其访问

                      3、私有变量和个体方法

                                  a、在python中用双写道的初叶的的措施降属性隐藏起来(设置个人的)

    property属性

    property是一种特殊的质量,访问它时会试行一段成效(函数)然后再次回到值

      

               c、多态:”多态指的是一类东西有三种样子(举个例子:老师.下课铃响了(),学生.下课铃响了(),老师实行的是下班操作,学生实行的是放学操作,固然两个音讯一点差距也没有于,可是施行的法力差别)

                       多态指的是:一类东西有两种景观

    python自带多态:
    
      多态:同一类事物的多种状态
    
      python里处处都是多态,只是我们一般发现不了
    
      操作的时候不需要关心这个对象的数据类型,你只要用就行了
    

     

        15、反射     

            1、 反射:能够用字符串的措施去拜谒对象的属性,调用对象的艺术(可是无法去访问方法),python中全体皆对象,都能够应用反射。

            2、反射有三种方法:

                   hasattr:hasattr(object,name)推断三个指标是还是不是有name属性可能name方法。有就回去True,未有就赶回False

                  getattr:获取对象的习性或然措施,借使存在则打字与印刷出来。hasattr和getattr配套使用

                     须要小心的是,假使回去的是指标的法门,重回出来的是指标的内部存款和储蓄器地址,假设急需周转这些主意,能够在末端增加一对()

                   setattr:给指标的属性赋值,若属性不设有,先成立后赋值

                   delattr:删除该对象内定的贰本性质

              a、内置方法:isinstance和issubclass

                   isinstance(obj,cls)检查是或不是obj是或不是是类 cls 的对象

    class Foo:
        pass
    class Son(Foo):
        pass
    s=Son()
    
    print(isinstance(s,Son))
    

            b、内置方法:issubclass(sub, super)检查sub类是还是不是是 super 类的派生类 

    class Foo(object):
        pass
    
    class Bar(Foo):
        pass
    
    issubclass(Bar, Foo)
    

     

           c、python面向对象中的反射:通过字符串的样式操作对象相关的习性,python中全体事物都是指标(都能够用反射)

    检查是否含有某属性---hasattr 返回布尔值
    获取属性---getattr   没有就会报错
    设置属性---setattr
    删除属性---delattr
    

           d、内置方法:__del__

    析构方法,当对象在内部存款和储蓄器中被保释时,自动触发执行。

    注:此办法一般不要定义,因为Python是一门高端语言,技术员在采纳时无需关怀内部存款和储蓄器的分配和刑满释放解除劳教,因为此专门的学问都是提交Python解释器来举行,所以,析构函数的调用是由解释器在进展垃圾回收时自动触发实施的。

    class Foo:
        def __del__(self):
            print('fgs')
    f=Foo()
    print(123)
    print(123)
    del f
    print(123)
    print(123)
    print(123)
    

     

         e、内置方法:item系列

    新葡亰496net 2

    一,.接口类

    【反射、内置attr、包装】

       1、面向进程

    __getitem____setitem____delitem__

        __new__

    class A:
        def __init__(self):  #有一个方法在帮你创造self
            print('in init function')
            self.x=1
        def __new__(cls, *args, **kwargs):
            print('in init funct')
            return object.__new__(A,*args,**kwargs)
    a=A()
    

         f、__str__和__repr__改变目的的字符串呈现

    新葡亰496net 3

    class Foo:
     2     def __init__(self,name):
     3         self.name = name
     4     def __repr__(self):
     5         return 'obj in str'  #这里只能是return
     6     # def __str__(self):
     7     #     return '%s obj in str'%self.name
     8 f = Foo('egon')
     9 print(f)  #优先执行__str__里面的内容
    10 # 那么你是不是据地__repr__没用呢?
    11 # print('%s'%f)  #执行的是__str__里面的返回值
    12 # print('%r'%f)  #执行的是__repr__里面的返回值
    13 print('==============')
    14 print(str(f))  #当执行str(f)时,会去找__str__这个方法,如果找不到的时候,__repr__这个方法就给替补了
    15 print(repr(f))
    16 #1.当打印一个对象的时候,如果实现了__str__方法,打印__str__中的返回值
    17 # 2.当__str__没有被实现的时候,就会调用__repr__方法
    18 # 3.但是当你用字符串格式化的时候,%s和%r会分别调用__str__和__repr__方法
    19 # 4.不管是在字符串格式化的时候还是在打印对象的时候,
    20 # __repr__方法都可以作为__str__方法的替补,但反之则不行
    21 # 5.用于友好的表示对象。如果__str__和__repr__方法你只能实现一个:先实现__repr__
    

    __str__,__repr__

        15、内置方法

               a、静态方法和类情势

                   1、类措施:有个默许参数cls,并且能够一贯用类名去调用,可以与类属性交互(相当于能够利用类属性)

                   2、静态方法:让类里的格局直接被类调用,就疑似正规调用函数同样

               b、类措施和静态方法的同样点:都能够一直被类调用,不供给实例化

               c、类措施和静态方法的不一样点:

              类方法必须有一个cls参数表示那几个类,能够利用类属性

               静态方法没有要求参数

               d、绑定方法:分为一般方法和类形式

         普通方法:暗中认可有三个self对象传进来,并且不得不被对象调用-------绑定到对象

         类方法:暗中认可有贰个cls对象传进来,并且可以被类和对象(不引入)调用-----绑定到类

                e、非绑定方法:静态方法:未有设置私下认可参数,并且能够被类和对象(不推荐)调用-----非绑定

        16、接口类与抽象类

                 a、 接口类:(在抽象类的根底上)

             在python中,暗中认可是平素不接口类的           

                        接口类不能够被实例化(尽管实例化会报错)

              接口类中的方法无法被完成

    接口也就是做约束,让下面的类的方法都按照接口类中给出的方法去定义。如果接口类里面有的方法类里面没有,那么那个类就不能被实例化。(字面理解)
    
    继承的第二种含义非常重要。它又叫“接口继承”。
    接口继承实质上是要求“做出一个良好的抽象,这个抽象规定了一个兼容接口,使得外部调用者无需关心具体细节,可一视同仁的处理实现了特定接口的所有对象”——这在程序设计上,叫做归一化。
    

               b、抽象类

    在python中,默认是有的
    
        父类的方法,子类必须实现
    
        抽象类(父类)的方法可以被实现
    
    抽象类和接口类的区别:接口类不能实现方法,抽象类可以实现方法里面的内容
    
    抽象类和接口类的相同点:都是用来做约束的,都不能被实例化
    
    抽象类和接口类的使用:
    
      当几个子类的父类有相同的功能需要被实现的时候就用抽象类
    
      当几个子类有相同的功能,但是实现各不相同的时候就用接口类
    

     

    一、面向对象 1、面向过程a、优点:不小的下落了写程序的复杂度,只供给顺着试行的步调,堆放代...

    一、面向对象

      1. 承袭有两种用途  

    一、isinstance 和 issubclass

    1、isinstance(obj,cls)检查是否obj是不是是类 cls 的目的。

    • 2、issubclass(sub, super)检查sub类是或不是是 super 类的派生类
        剖断结果为布尔值:是回去True,不是回去False*

      新葡亰496net, class Bar: #定义父类

       pass
      

      class Foo(Bar): #定义子类 承袭 Bar

       pass
      

      class A: #定义类 A

       pass
      

      obj=Foo() #实例化 a = A() #实例化 #isinstance print(isinstance(obj,Foo)) #查看obj是不是是类Foo的指标 print(isinstance(obj,Bar)) #查看obj是或不是是类Bar的靶子 print(isinstance(a,A)) #查看a是或不是是类A的对象 print(isinstance(a,Foo)) #查看a是不是是类Foo的指标 #issubclass print(Foo.bases) #从前查看承继的主意 print(issubclass(Foo,Bar)) #查看类Foo 是或不是是类Bar的子类 print(issubclass(A,Bar)) #查看类A 是还是不是是类Bar的子类

      #施行结果: True True True False (main.Bar'>,) True False

    二、反射:getattr,setattr,delattr,hasattr
      1、定义:

      反射:重即使指程序能够访问、检验和修改它自身情形或作为的一种力量(自省)。

        python面向对象中的反射:通过字符串的花样,操作对象的连带的属性。python中的一切事物都是目的(都能够采纳反射)。

    2、应用:

      1) hasattr   查找
      hasattr(object,'name') 应用于类或对象,查看有未有所对应的办法。实质依然从类或对象的称号空间去追寻。判别结果重返布尔值,有为True,未有为False.

      2)getattr   获取  

      getattr(object,name,‘再次来到值’) 通过字符串获取 查看有未有那天特性,获取绑定方法。

      实为依旧从类或对象的名称空间去寻找,有的话重返为函数内部存款和储蓄器地址,加()就能够运转。

      3)setattr 设置
      setattr(x,y,v)   x=类或对象, y='字符串类型的性质名',v=value 值  实质是给类或是对象添扩充少属性。

      4)delattr 删除
      delattr(x,y)   x = 类或对象,y = '字符串类型的性质名'   删除类或是对象内的某部属性!

    #coding = utf-8
    #通过字符串的形式,为类或是对象添加属性
    class People:  #定义一个类
        country = 'China'
        def __init__(self,name):
            self.name = name
    
        def test(self):
            print('test')
    
    p = People('zh')  #实例化
    
    #hasattr
    h = hasattr(p,'name')  #查看对象p有没有name属性
    print(h)  #打印布尔值
    
    #执行结果:
    True
    
    #getattr(object,name,default=None(or'自定义的值'))
    print(p.__dict__)       #查看对象的名称空间
    print(People.__dict__)  #查看类的名称空间
    g = getattr(p,'name')   #获取对象name方法
    g1 = getattr(p,'test')  #获取对象test的绑定方法
    g2 = getattr(People,'test')  #获取类test方法
    g3 = getattr(People,'work',"没有此方法!")  #获取类work方法,没有打印value值
    print(g,g1,g2,g3)  #打印
    g1()  #执行对象对应的方法,不需要传值
    g2(p)  #执行类对应的方法,需要传值
    
    #执行结果:
    {'name': 'zh'}
    {'__module__': '__main__', 'country': 'China', '__init__': <function People.__init__ at 0x00000000028EC9D8>, 'test': <function People.test at 0x00000000028ECA60>, '__dict__': <attribute '__dict__' of 'People' objects>, '__weakref__': <attribute '__weakref__' of 'People' objects>, '__doc__': None}
    zh <bound method People.test of <__main__.People object at 0x00000000028FF208>> <function People.test at 0x00000000028ECA60> 没有此方法!
    test
    test
    
    #setattr()只能更改类或是对象内的 数据属性,函数属性没法变更。
    print(p.__dict__)   #设置前查看对象的名称空间
    setattr(p,'sex','male') #设置sex属性
    setattr(p,'age',18)     #设置age属性
    print(p.__dict__)      #设置后查看对象的名称空间
    print(p.sex,p.age)   #打印
    
    #执行结果:
    {'name': 'zh'}
    {'name': 'zh', 'sex': 'male', 'age': 18}
    male 18
    
    #delattr
    print(p.__dict__) #删除前查看对象的名称空间
    delattr(p,'age')  #删除 对象 的数据属性
    print(p.__dict__)  #删除操作完成,在对象的名称空间查看
    
    #执行结果:
    {'name': 'zh', 'sex': 'male', 'age': 18}
    {'name': 'zh', 'sex': 'male'}
    

     5)反射当前任务的模块成员。

      此处先明了多少个概念:

        脚本文件:将顺序写到三个文书中,以***.py的方法保留,使用的时候 利用python ***.py举办实施,该文件就叫做脚本文件。

        模块:import 模块名 导入的文书正是模块,文件名正是模块名。

        在现阶段地点获取当前文件中定义的函数,若是一贯将本文件以模块的款型导入文本中,程序施行直接触发递归,无法达成效益,此时在和谐职位就不可能导入本人的模块。此时就要求把本文件转成一个剧本模块,不只能够导入到别的模块或文件中用,别的该模块自身也可推行。所以就须求利用下边的方法:
    方法:import sys  #导入sys模块

    this_modules = sys.modules[__name__](有重临值)  获取二个模块,将眼下职分的文书转成二个本子模块(有切实的文当地方)

    print(__name__)

    注意:__name__的用法:  若是大家是一贯在本文件举行,那该文件中'__name__' == '__main__',不过只要从别的叁个.py文件通过import导入该文件的时候,那时__name__的值正是大家这几个py文件的名字而不是__main__。(有一种丰盛爱慕锁的以为)

    import sys  #导入sys模块
    def add():
        print('add')
    
    def change():
        print('change')
    
    def search():
        print('search')
    
    def delete():
        print('delete')
    
    this_module = sys.modules[__name__]   #利用sys模块中的modules方法,将本文件转成脚本模块
    print(this_module)  #查看
    print(__name__)  #查看__name__
    while True:
        m = input('input something:').strip()
        if not m :continue
        if hasattr(this_module,m):  #判断输入的内容在不在模块 类中
            func = getattr(this_module,m)  #获取这个方法,拿到返回值
            func()  #执行函数
        else:
            print('没有此方法!')
    
    #执行结果:
    <module '__main__' from 'F:/py_fullstack_s4/day31/__name__及反射的用途.py'>
    __main__
    input something:add
    add
    input something:work
    没有此方法!
    

    3、反射的好处:

      好处一:能够使用反射达成可插拔机制。

      能够预先定义好接口,接口唯有在被成功后才会真的实行,这贯彻了即插即用,即事先把首要的逻辑写好(只定义接口),然后前期再去落到实处接口的功用。不影响别的职员对先后的调用和花费。

    新葡亰496net 4新葡亰496net 5

    class FtpClient:
        'ftp客户端,但是还没有实现具体的功能'
        def __init__(self,addr):
            print('正在连接服务器[%s]' 
    		

    本文由新葡亰496net发布于奥门新萄京娱乐场,转载请注明出处:新葡亰496netPython之面向对象总计,零基础分分钟

    关键词: