（七）面向对象的程序设计(类)

1、面向对象的概念

• 常用的编程方式有两种：面向过程 和 面向对象。

• 面向过程：是早期程序员所使用的方法，首先将问题分解成步骤，然后用函数逐个按次序实现，运行的时候依次调用即可。

• 面向对象：是指把构成问题的事务分解组合抽象成对象，建立对象的目的不是为了完成其中某个步骤，而是为了描述某个事务在解决整个问题中的行为，可能涉及一个步骤，但通常都会涉及多个步骤，很好地体现了软件重用的思想。Python 在涉及之初就是一门面向对象的语言。

• 看几个概念：

  • 类(class):对具有相同属性和方法的一组对象的描述或定义。
  • 对象(object):类的实例。
  • 实例(Inatance):其含义与对象基本一致。创建一个新对象的过程称为实例化(Instantiation),这个新对象称为这个类的一个实例。
  • 标识(Identity): 每个实例对象的唯一标识。
  • 实例属性(Inatance Attribute): 特定对象所具有的一组属性的集合。
  • 实例方法(Inatance Method): 对于特定对象实例的一条或多条属性的操作函数集合。
  • 类属性(Class Attribute): 属于一个类中所有对象的属性，不会只在某个实例上发生变化。
  • 类方法(Class Method):那些无须指定实例就能够工作的从属于类的函数。

2、类与实例

• 创建类和子类：类使用class关键字创建，类的属性和方法被列在一个缩进块中。如下：

   #  类
   class animals:
           pass
   # 子类
   class mammals(animals):
           pass
  

• 用函数表示类的行为特征：为类和子类创建行为特征---函数，如下：

  class animals:
       def breth(self):
           print("呼吸")
  class mammals(animals):
       def move(self):
           print("奔跑")
  class dog(mammals):
       def eat(self):
           print("吃")
  Bob = dog()
  Bob.move()
  Bob.eat()
  运行结果：
  奔跑
  吃
  

3、面向对象的特征

• Python程序是面向对象的程序，具有三个特征：封装、继承和多态。

• 封装是指将对象得到的数据和行为结合，将基本类结构的细节隐藏起来，通过方法接口实现对实例变量的所有访问。Python中允许对类的数据和方法进行封装，下面的例子封装了类中的数据，将公司名和领导人分别封装到对象objc1和objc2中的self的 companyname 和 leader属性中。

  class Company:
       def __init__(self,companyname,leader):
             self. companyname = companyname
             self. leader = leader
  if __name__ == "__main__":
       objc1 = Company("a","Nike")
       objc1 = Company("b","Jack")
  

  在调用数据时，可以使用两种方式：通过对象直接调用和通过self直接调用。例如：

  class Company:
      def __init__(self, companyname, leader):
            self.companyname = companyname
            self.leader = leader
      def show(self):
            print(self.companyname)
            print(self.leader)
  
  if __name__ == "__main__":
      objc1 = Company("a", "Nike")
      objc2 = Company("b", "Jack")
  
  # 通过对象直接调用封装的数据
  print(objc1.companyname)
  print(objc1.leader)
  运行结果为：
  a
  Nike
  
  # 通过self来间接调用，self即对象本身
  objc1.show()
  objc2.show()
  运行结果为：
  a
  Nike
  b
  Jack
  

• 继承：当已经存在一个类，需要另外再创建一个和已有类型非常相似的类时，通常不必将同一段代码重复多次，而是用继承。在类上添加关联，使得位于不同层次的类可以“继承”位于关系上层的类的属性。继承有利于代码的复用和模块化。和其他语言不同的是，Python 中的类还具有多继承的特性。即一个类可以有多个父类。

  • 继承一个父类: 下面这个例子中，Company类 只有Scale 一个父类。当调用 check()方法时，Company 本身没有定义check()方法，代码就会向上自动检测父类Scale中是否存在check()方法，结果父类中找到了该方法，次为单继承，即只有一个父类。

    class Scale:
        def check(self):
             if self.count_person > 500:
                  print("%s是个大公司." % self.name)
             else:
                  print("%s是个小公司." % self.name)
    class Company(Scale):
        def __init__(self,name,count):
             self.name = name
             self.count_person = count
    
    if __name__ == "__main__":
       my_company = Company("JK",600)
       my_company.check()
    

  • 继承多个父类:

    class Scale:
         def check(self):
              if self.count_person > 500:
                   return "%s是个大公司." % self.name
              else:
                   return "%s是个小公司." % self.name
    class Detail:
         def show(self,scale):
             print("%s,公司有%s名员工."%(scale,self.count_person))
    
    class Company(Scale,Detail):
        def __init__(self,name,count):
             self.name = name
             self.count_person = count
    
    if __name__ == "__main__":
         my_company = Company("JK",600)
         company_scale = my_company.check()
         my_company.show(company_scale)
    结果为：
    JK是个大公司.,公司有600名员工.
    

    在上面的例子中，类Company 分别继承了类Scale和类Detail,可以调用父类中的check和show方法，这种继承的方法称为多继承。

• 多态: 多态即多种姿态，是指在事先不知道对象类型的情况下，可以自动根据对象的不同类型，执行响应的操作。很多内建运算符以及函数、方法都能体现多态的性质。例如：“+”运算符，在连接数值类型变量时表示加法操作，在连接字符串时则表示拼接。例如：函数的多态性举例

  >>> def length(x):
           print(repr(x),"的长度为",len(x))
  >>> print(length('aaa'))
  'aaa' 的长度为 3
  >>> print(length([1,2,4,5,6]))
  [1, 2, 4, 5, 6] 的长度为 5
  

  函数 repr() 返回一个对象的可打印字符串，无须事先知道是什么类型，该函数也表现了Python多态特性。

4、库的安装

• 4.1、包的管理： Python 程序一般由 包(package)、模块(module)和函数(function)三部分组成。其中 包 是一系列模块组成的集合，模块是处理某类问题的函数和类的集合。一个包可以包含多个模块，每个模块可以包含多个函数与类，同时也可以有执行语句，每个包其实就是完成特定任务的工具箱。具体来说，一个.py文件可以被看做是一个独立的模块，一个模块通常就是一个文件，因为模块是按照逻辑组织代码的方法，而文件是物理层存储模块的方式。包是一个可以完整测试的、独立开发的模块组合，通常发布在Python 指定的文件夹里。当多个模块使用同一组模块时，可以将模块封装成包，发布到公共文件里，这就是包的含义。所以说模块对应的物理层结构是文件，那么包对应的物理层结构就是文件夹。包是通过目录结构组织的模块的集合，使用包的方式跟模块类似，可以通过import导入，需要注意的是，当文件夹当做包使用时，文件夹中需要包含一个_init_.py 文件，主要为了避免将包当做普通的文件夹。_init_.py的内容可以为空。

• 4.2、包管理工具： 有4种，关系如下:
  

  Python包管理
  • distutils: 是 Python 标准库的一部分，为开发者提供一种方便的打开方式，同时也为使用者提供了方便的包安装方式。
  • setuptools: 是对distutils 的增强，引入了包依赖管理。setuptools可以为Python 包创建egg文件。Python 与 egg文件的关系，类似于Java语言与 jar包的关系。setuptools提供的easy_install 脚本可以用来安装 egg 包。
  • easy_install：是由 PEAK (Python Enterprise Application Kit) 开发的setuptools包里带的一个命令，所以使用easy_install实际上是在调用 setuptools 来完成模块的工作。easy_install可以自动从 https://pypi.python.org/pypi 下载相关的包，并完成安装和升级。
  • pip：是安装管理Python 包的标准工具，是对easy_install增强和替代，但它仍有大量的功能建立在setuptools组件之上。同样可以从 PyPI网站自动下载安装包。在pip中，安装所需要的包都需要先下载，并且所有的安装包都会被跟踪，因此避免了出现安装不完整的情况。

• 4.3、包格式：用于Python 第三方库安装的包格式有以下两种

  • egg: 格式是 setuptools 引入的一种文件格式，使用.egg作为扩展名，用setuptools识别、解析和安装。
  • wheel:本质上是 ZIP的压缩格式，使用 .whl 作为扩展名。

• 4.4、安装方式： 百度自己搜

5、模块的引用
应用Python 进行编程时，通常会使用一些库(模块) 来满足开发需求。Python 中库主要分为三大类： 第一类是标准模块，第二类是第三方模块，第三类是自定义模块。无论哪个库使用之前都需要导入。这里一个库可能包含多个模块，但其含义均指 module。

• 5.1、使用 import 方式导入库
  使用 import 语句导入模块，语法如下：

  import <模块 1>
  import <模块 2>
  

  也可以在一行内导入多个模块（可读性差，不推荐）
  只要导入了某个模块，就可以引用它的所有公共函数、类或者属性。如果 import语句是在代码的顶层，则它的作用域为全局；如果import语句在某个函数中，则它的作用域仅局限于该函数。
  用import模块语句导入模块，就在当前的名称空间（NameSpace） 中建立一个指向该模块的引用，这种引用必须使用全称。也就是说，当使用被导入的模块的函数时，在调用时必须同时包含模块的名字，不能只使用函数名字，而应该使用“模块名.函数名”,例如导入 绘图模块 turtle

  >>> import turtle
  >>> t= turtle.Pen()
  

  若引入的模块名称较长，为方便使用，通常可用 as 定义一个别名。例如，导入 Matplotlib库 pyplot 模块：import Matplotlib as plt ,然后就可以直接用 plt.figure(....) 创建绘图对象，二不必使用 Matplotlib.pyplot.figure(...)。

• 5.2、from 方式

  将模块中指定的属性或名称导入当前程序命名空间，语法格式如下：

  from <模块名> import <函数名>
  

  例如，导入画图模块 turtle 中的 Pen()函数：

  >>> from  turtle import Pen
  >>> t = Pen()