zoukankan      html  css  js  c++  java
  • Python 面向对象

    一、Python面相对象概念

    • 面向过程:根据业务逻辑从上到下写垒代码
    • 函数式:将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可
    • 面向对象:对函数进行分类和封装,让开发“更快更好更强...”

    面向过程编程最易被初学者接受,其往往用一长段代码来实现指定功能,开发过程中最常见的操作就是粘贴复制,即:将之前实现的代码块复制到现需功能处。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    while True
        if cpu利用率 > 90%:
            #发送邮件提醒
            连接邮箱服务器
            发送邮件
            关闭连接
     
        if 硬盘使用空间 > 90%:
            #发送邮件提醒
            连接邮箱服务器
            发送邮件
            关闭连接
     
        if 内存占用 > 80%:
            #发送邮件提醒
            连接邮箱服务器
            发送邮件
            关闭连接

    随着时间的推移,开始使用了函数式编程,增强代码的重用性和可读性,就变成了这样:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    def 发送邮件(内容)
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接
     
    while True
     
        if cpu利用率 > 90%:
            发送邮件('CPU报警')
     
        if 硬盘使用空间 > 90%:
            发送邮件('硬盘报警')
     
        if 内存占用 > 80%:
            发送邮件('内存报警'

    今天我们来学习一种新的编程方式:面向对象编程(Object Oriented Programming,OOP,面向对象程序设计)
    注:Java和C#来说只支持面向对象编程,而python比较灵活即支持面向对象编程也支持函数式编程

    
    
    

      

    二、创建类和对象

    面向对象编程是一种编程方式,此编程方式的落地需要使用 “类” 和 “对象” 来实现,所以,面向对象编程其实就是对 “类” 和 “对象” 的使用。

      类就是一个模板,模板里可以包含多个函数,函数里实现一些功能

      对象则是根据模板创建的实例,通过实例对象可以执行类中的函数

    • class是关键字,表示类
    • 创建对象,类名称后加括号即可
    类是一系列对象共有的特征(变量的定义)与技能(函数的定义)的结合体
    class Foo:
        def Bar(self):
            print(123)
        def Hello(self,name):
            print(name)
    
    f = Foo()
    f.Hello('123')



    练习一:在终端输出如下信息
    
    小明,10岁,男,上山去砍柴
    小明,10岁,男,开车去东北
    小明,10岁,男,最爱大保健
    老李,90岁,男,上山去砍柴
    老李,90岁,男,开车去东北
    老李,90岁,男,最爱大保健



    class Foo:

    def __init__(self, name, age ,gender):
    self.name = name
    self.age = age
    self.gender = gender

    def kanchai(self):
    print "%s,%s岁,%s,上山去砍柴" %(self.name, self.age, self.gender)

    def qudongbei(self):
    print "%s,%s岁,%s,开车去东北" %(self.name, self.age, self.gender)

    def dabaojian(self):
    print "%s,%s岁,%s,最爱大保健" %(self.name, self.age, self.gender)


    xiaoming = Foo('小明', 10, '男')
    xiaoming.kanchai()
    xiaoming.qudongbei()
    xiaoming.dabaojian()

    laoli = Foo('老李', 90, '男')
    laoli.kanchai()
    laoli.qudongbei()
    laoli.dabaojian()

    面向对象的三大特性是指:封装、继承和多态。

    三、类和对象 

    类:从一组对象中提取相似的部分就是类,类所有对象都具有的特征和技能的结合体

    对象:在python中,用变量表示特征,用函数表示技能,因而类是变量与函数的结合体,对象是变量与方法(指向类的函数)的结合体

    class Pople:
    
        def __init__(self,name,age):
            self.name=name
            self.age=age
    
        def tail(self):
    
            print("名字:%s 年龄:%s"%(self.name,self.age))
    
    p=Pople(“hanjialong”,18)#实例化
    
    p.tail()
    
    结果:名字:hanjialong 年龄:18
    

    3.1 对象之间的交互

       camp='Demacia'
        def __init__(self,nickname,life_value=200,aggressivity=100):
            self.nickname=nickname
            self.life_value=life_value
            self.aggressivity=aggressivity
    
        def attack(self,enemy):#enemy对象
            enemy.life_value-=self.aggressivity 
    
    
    class Riven:
        camp = 'Noxus'
    
        def __init__(self, nickname, life_value=100, aggressivity=200):
            self.nickname = nickname
            self.life_value = life_value
            self.aggressivity = aggressivity
    
        def attack(self, enemy):
            enemy.life_value -= self.aggressivity
    


    3.2 练习

    1.编写一个学生类,产生一堆学生对象,要求有一个计数器(属性),统计总共实例了多少个对象
    
    class Foo:
        count=0 #Cinese.count sekf,ciybt
        def __init__(self,name):
             print(self.count)
            count+=1 #全局的count
             self.count=10 # 对象自己
            Foo.count+=1
            self.name=name

     

    四、封装

    封装,顾名思义就是将内容封装到某个地方,以后再去调用被封装在某处的内容。

    所以,在使用面向对象的封装特性时,需要:

    • 将内容封装到某处
    • 从某处调用被封装的内容
    class People:
        def __init__(self,name,age):
            self.__name=name
            self.__age=age
    
        def tell_info(self):
            print('人的名字是:%s ,人的年龄是:%s' %(
                        self.__name, #p._People__name
                        self.__age))
    
        def set_info(self,x,y):
            if not isinstance(x,str):
                raise TypeError('名字必须是字符串类型')
            if not isinstance(y,int):
                raise TypeError('年龄必须是整数类型')
    
            self.__name=x
            self.__age=y
    
    
    p=People('alex',1000)
    p.tell_info()
    #
    p.set_info('alex_SB',123)
    p.tell_info()
    

    五、继承

    5.1继承与派生

    继承:一种创建新类的方式

    查看继承

     SubClass1.__bases__ #__base__只查看从左到右继承的第一个子类,__bases__则是查看所有继承的父类

    5.2单继承

    class ParentClass1: #定义父类
        pass
    
    
    class SubClass1(ParentClass1): #单继承,基类是ParentClass1,派生类是SubClass
        pass
    
    

    5.3多继承

    class ParentClass2: #定义父类
        pass
    class SubClass2(ParentClass1,ParentClass2): #python支持多继承,用逗号分隔开多个继承的类
        pass
    

    5.4 python3与python2的区别 

    #python2中类分为:新式类与经典类
    
    # class Foo(object): #新式类
    #     pass
    #
    # class Bar: #经典类
    #     pass
    
    #python3中类全都是新式类
    
    # class Foo: #新式类
    #     pass
    #
    # print(Foo.__bases__)
    

    5.5 继承的使用

    使用继承的好处之一是可以减少代码冗余,在子类定义的新的属性,覆盖掉父类的属性,称为派生

    class Animal:
        def __init__(self, name, age, sex):
            self.name = name
            self.age = age
            self.sex = sex
    
        def eat(self):
            print('eating')
    
        def talk(self):
            print('%s 正在叫' %self.name)

    class People(Animal):#继承动物父类
    def __init__(self, name, age, sex,education):
    Animal.__init__(self,name,age,sex)继承父类的name,age,sex
    self.education=education

    def talk(self):#覆盖父类的talk
    Animal.talk(self)调用父类的talk
    print('%s say hello' %self.name)

    5.6 抽象与继承(先抽象在继承)

    抽象即抽取类似或者说比较像的部分。

    抽象分成两个层次: 

    1.将奥巴马和梅西这俩对象比较像的部分抽取成类; 

    2.将人,猪,狗这三个类比较像的部分抽取成父类。

    抽象最主要的作用是划分类别(可以隔离关注点,降低复杂度)

     

    继承:是基于抽象的结果,通过编程语言去实现它,肯定是先经历抽象这个过程,才能通过继承的方式去表达出抽象的结构。

    抽象只是分析和设计的过程中,一个动作或者说一种技巧,通过抽象可以得到类

    复制代码
    ==========================第一部分
    例如
    
      猫可以:喵喵叫、吃、喝、拉、撒
    
      狗可以:汪汪叫、吃、喝、拉、撒
    
    如果我们要分别为猫和狗创建一个类,那么就需要为 猫 和 狗 实现他们所有的功能,伪代码如下:
     
    
    #猫和狗有大量相同的内容
    class 猫:
    
        def 喵喵叫(self):
            print '喵喵叫'
    
        def 吃(self):
            # do something
    
        def 喝(self):
            # do something
    
        def 拉(self):
            # do something
    
        def 撒(self):
            # do something
    
    class 狗:
    
        def 汪汪叫(self):
            print '喵喵叫'
    
        def 吃(self):
            # do something
    
        def 喝(self):
            # do something
    
        def 拉(self):
            # do something
    
        def 撒(self):
            # do something
    
    
    
    ==========================第二部分
    上述代码不难看出,吃、喝、拉、撒是猫和狗都具有的功能,而我们却分别的猫和狗的类中编写了两次。如果使用 继承 的思想,如下实现:
    
      动物:吃、喝、拉、撒
    
         猫:喵喵叫(猫继承动物的功能)
    
         狗:汪汪叫(狗继承动物的功能)
    
    伪代码如下:
    class 动物:
    
        def 吃(self):
            # do something
    
        def 喝(self):
            # do something
    
        def 拉(self):
            # do something
    
        def 撒(self):
            # do something
    
    # 在类后面括号中写入另外一个类名,表示当前类继承另外一个类
    class 猫(动物):
    
        def 喵喵叫(self):
            print '喵喵叫'
            
    # 在类后面括号中写入另外一个类名,表示当前类继承另外一个类
    class 狗(动物):
    
        def 汪汪叫(self):
            print '喵喵叫'
    
    
    
    
    ==========================第三部分
    #继承的代码实现
    class Animal:
    
        def eat(self):
            print("%s 吃 " %self.name)
    
        def drink(self):
            print ("%s 喝 " %self.name)
    
        def shit(self):
            print ("%s 拉 " %self.name)
    
        def pee(self):
            print ("%s 撒 " %self.name)
    
    
    class Cat(Animal):
    
        def __init__(self, name):
            self.name = name
            self.breed = '猫'
    
        def cry(self):
            print('喵喵叫')
    
    class Dog(Animal):
    
        def __init__(self, name):
            self.name = name
            self.breed='狗'
    
        def cry(self):
            print('汪汪叫')
    
    
    # ######### 执行 #########
    
    c1 = Cat('小白家的小黑猫')
    c1.eat()
    
    c2 = Cat('小黑的小白猫')
    c2.drink()
    
    d1 = Dog('胖子家的小瘦狗')
    d1.eat()
    

      

    在开发程序的过程中,如果我们定义了一个类A,然后又想新建立另外一个类B,但是类B的大部分内容与类A的相同时

    我们不可能从头开始写一个类B,这就用到了类的继承的概念。

    通过继承的方式新建类B,让B继承A,B会‘遗传’A的所有属性(数据属性和函数属性),实现代码重用

    在子类中,新建的重名的函数属性,在编辑函数内功能的时候,有可能需要重用父类中重名的那个函数功能,应该是用调用普通函数的方式,即:类名.func(),此时就与调用普通函数无异了,因此即便是self参数也要为其传值

    class Riven(Hero):
        camp='Noxus'
        def __init__(self,nickname,aggressivity,life_value,skin):
            Hero.__init__(self,nickname,aggressivity,life_value) #调用父类功能
            self.skin=skin #新属性
        def attack(self,enemy): #在自己这里定义新的attack,不再使用父类的attack,且不会影响父类
            Hero.attack(self,enemy) #调用功能
            print('from riven')
        def fly(self): #在自己这里定义新的
            print('%s is flying' %self.nickname)
    
    r1=Riven('锐雯雯',57,200,'比基尼')
    r1.fly()
    print(r1.skin)
    
    '''
    运行结果
    锐雯雯 is flying
    比基尼
    
    '''
    

    5.7组合与继承  

    class Equip: #武器装备类
      def fire(self):
            print('release Fire skill')
    
    class Riven: #英雄Riven的类,一个英雄需要有装备,因而需要组合Equip类
      camp='Noxus'
        def __init__(self,nickname):
          self.nickname=nickname
           self.equip=Equip() #用Equip类产生一个装备,赋值给实例的equip属性
    
    r1=Riven('锐雯雯')
    r1.equip.fire() #可以使用组合的类产生的对象所持有的方法
    

     

    # class People:
    #     def __init__(self,name,age,sex):
    #         self.name=name
    #         self.age=age
    #         self.sex=sex
    #
    # class Teacher(People):
    #     def __init__(self,name,age,sex,salary):
    #         People.__init__(self,name,age,sex)
    #         self.salary=salary
    #
    # class Student(People):
    #     pass
    
    
    
    
    
    class Date:
        def __init__(self,year,mon,day):
            self.year=year
            self.mon=mon
            self.day=day
    
        def tell(self):
            print('%s-%s-%s' %(self.year,self.mon,self.day))
    
    class Teacher(People):
        def __init__(self,name,age,sex,salary,year,mon,day):
            self.name=name
            self.age=age
            self.sex=sex
            self.salary=salary
            self.birth=Date(year,mon,day)
    
    class Student(People):
        def __init__(self,name,age,sex,year,mon,day):
            self.name=name
            self.age=age
            self.sex=sex
            self.birth=Date(year,mon,day)
    
    # t=Teacher('egon',18,'male',3000,1995,12,31)
    # t.birth.tell()
    

    继承方式

    通过继承建立了基类与派生类的关系

    >>> class Teacher:
    ...     def __init__(self,name,gender):
    ...         self.name=name
    ...         self.gender=gender
    ...     def teach(self):
    ...         print('teaching')
    ... 
    >>> 
    >>> class Professor(Teacher):
    ...     pass
    ... 
    >>> p1=Professor('egon','male')
    >>> p1.teach()
    teaching
    

    组合方式

    用组合的方式建立了类与组合的类之间的关系 

    class BirthDate:
        def __init__(self,year,month,day):
            self.year=year
            self.month=month
            self.day=day
    
    class Couse:
        def __init__(self,name,price,period):
            self.name=name
            self.price=price
            self.period=period
    
    class Teacher:
        def __init__(self,name,gender):
            self.name=name
            self.gender=gender
        def teach(self):
            print('teaching')
    class Professor(Teacher):
        def __init__(self,name,gender,birth,course):
            Teacher.__init__(self,name,gender)
            self.birth=birth
            self.course=course
    
    p1=Professor('egon','male',
                 BirthDate('1995','1','27'),
                 Couse('python','28000','4 months'))
    
    print(p1.birth.year,p1.birth.month,p1.birth.day)
    print(p1.course.name,p1.course.price,p1.course.period)
    

    六、接口

    继承有两种用途:

    一:继承基类的方法,并且做出自己的改变或者扩展(代码重用)

    二:声明某个子类兼容于某基类,定义一个接口类Interface,接口类中定义了一些接口名(就是函数名)且并未实现接口的功能,子类继承接口类,并且实现接口中的功能

    class Interface:#定义接口Interface类来模仿接口的概念,python中压根就没有interface关键字来定义一个接口。
        def read(self): #定接口函数read
            pass
    
        def write(self): #定义接口函数write
            pass
    
    
    class Txt(Interface): #文本,具体实现read和write
        def read(self):
            print('文本数据的读取方法')
    
        def write(self):
            print('文本数据的读取方法')
    
    class Sata(Interface): #磁盘,具体实现read和write
        def read(self):
            print('硬盘数据的读取方法')
    
        def write(self):
            print('硬盘数据的读取方法')
    
    class Process(Interface):
        def read(self):
            print('进程数据的读取方法')
    
        def write(self):
            print('进程数据的读取方法')
    

     

    实践中,继承的第一种含义意义并不很大,甚至常常是有害的。因为它使得子类与基类出现强耦合。

    继承的第二种含义非常重要。它又叫“接口继承”。
    接口继承实质上是要求“做出一个良好的抽象,这个抽象规定了一个兼容接口,使得外部调用者无需关心具体细节,可一视同仁的处理实现了特定接口的所有对象”——这在程序设计上,叫做归一化。

    归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合——就好象linux的泛文件概念一样,所有东西都可以当文件处理,不必关心它是内存、磁盘、网络还是屏幕(当然,对底层设计者,当然也可以区分出“字符设备”和“块设备”,然后做出针对性的设计:细致到什么程度,视需求而定)。

    在python中根本就没有一个叫做interface的关键字,上面的代码只是看起来像接口,其实并没有起到接口的作用,子类完全可以不用去实现接口 ,如果非要去模仿接口的概念,可以借助第三方模块:

    http://pypi.python.org/pypi/zope.interface

    twisted的twistedinternetinterface.py里使用zope.interface

    文档https://zopeinterface.readthedocs.io/en/latest/

    设计模式:https://github.com/faif/python-patterns

    为什么要使用接口

    接口提取了一群类共同的函数,可以把接口当做一个函数的集合。

    然后让子类去实现接口中的函数。

    这么做的意义在于归一化,什么叫归一化,就是只要是基于同一个接口实现的类,那么所有的这些类产生的对象在使用时,从用法上来说都一样。

    归一化,让使用者无需关心对象的类是什么,只需要的知道这些对象都具备某些功能就可以了,这极大地降低了使用者的使用难度。

    比如:我们定义一个动物接口,接口里定义了有跑、吃、呼吸等接口函数,这样老鼠的类去实现了该接口,松鼠的类也去实现了该接口,由二者分别产生一只老鼠和一只松鼠送到你面前,即便是你分别不到底哪只是什么鼠你肯定知道他俩都会跑,都会吃,都能呼吸。

    再比如:我们有一个汽车接口,里面定义了汽车所有的功能,然后由本田汽车的类,奥迪汽车的类,大众汽车的类,他们都实现了汽车接口,这样就好办了,大家只需要学会了怎么开汽车,那么无论是本田,还是奥迪,还是大众我们都会开了,开的时候根本无需关心我开的是哪一类车,操作手法(函数调用)都一样

    4.抽象类

    1 什么是抽象类

        与java一样,python也有抽象类的概念但是同样需要借助模块实现,抽象类是一个特殊的类,它的特殊之处在于只能被继承,不能被实例化

    2 为什么要有抽象类

        如果说类是从一堆对象中抽取相同的内容而来的,那么抽象类是从一堆中抽取相同的内容而来的,内容包括数据属性和函数属性。

      比如我们有香蕉的类,有苹果的类,有桃子的类,从这些类抽取相同的内容就是水果这个抽象的类,你吃水果时,要么是吃一个具体的香蕉,要么是吃一个具体的桃子。。。。。。你永远无法吃到一个叫做水果的东西。

        从设计角度去看,如果类是从现实对象抽象而来的,那么抽象类就是基于类抽象而来的。

      从实现角度来看,抽象类与普通类的不同之处在于:抽象类中只能有抽象方法(没有实现功能),该类不能被实例化,只能被继承,且子类必须实现抽象方法。这一点与接口有点类似,但其实是不同的,即将揭晓答案

    #_*_coding:utf-8_*_
    __author__ = 'Linhaifeng'
    #一切皆文件
    import abc #利用abc模块实现抽象类
    
    class All_file(metaclass=abc.ABCMeta):
        all_type='file'
        @abc.abstractmethod #定义抽象方法,无需实现功能
        def read(self):
            '子类必须定义读功能'
            pass
    
        @abc.abstractmethod #定义抽象方法,无需实现功能
        def write(self):
            '子类必须定义写功能'
            pass
    
    # class Txt(All_file):
    #     pass
    #
    # t1=Txt() #报错,子类没有定义抽象方法
    
    class Txt(All_file): #子类继承抽象类,但是必须定义read和write方法
        def read(self):
            print('文本数据的读取方法')
    
        def write(self):
            print('文本数据的读取方法')
    
    class Sata(All_file): #子类继承抽象类,但是必须定义read和write方法
        def read(self):
            print('硬盘数据的读取方法')
    
        def write(self):
            print('硬盘数据的读取方法')
    
    class Process(All_file): #子类继承抽象类,但是必须定义read和write方法
        def read(self):
            print('进程数据的读取方法')
    
        def write(self):
            print('进程数据的读取方法')
    
    wenbenwenjian=Txt()
    
    yingpanwenjian=Sata()
    
    jinchengwenjian=Process()
    
    #这样大家都是被归一化了,也就是一切皆文件的思想
    wenbenwenjian.read()
    yingpanwenjian.write()
    jinchengwenjian.read()
    
    print(wenbenwenjian.all_type)
    print(yingpanwenjian.all_type)
    print(jinchengwenjian.all_type)
    复制代码
    

    3.

      

     

     

     
  • 相关阅读:
    HDU2586 How far away?(tarjan的LCA)
    You Raise Me Up
    POJ2891 Strange Way to Express Integers(中国剩余定理)
    POJ2142 The Balance(扩展欧几里得)
    HDU 1166模仿大牛写的线段树
    NetWord Dinic
    HDU 1754 线段树裸题
    hdu1394 Minimum Inversion Number
    hdu2795 Billboard
    【完全版】线段树
  • 原文地址:https://www.cnblogs.com/hanjialong/p/6959402.html
Copyright © 2011-2022 走看看