python中的面向对象（教学式讲解）

面向对象术语简介

1、类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例
2、方法：类中定义的函数
3、类变量(属性)：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体(方法)之外。类变量通常不作为实例变量使用，类变量也称作属性
4、数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据
5、方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写
6、实例变量：定义在__init__方法中的变量，只作用于当前实例的类
7、继承：即一个派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待,以普通的类为基础建立专门的类对象
8、实例化：创建一个类的实例，类的具体对象。一个类可以实例化出无数个对象
9、对象：通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法
10、多态：对不同类的对象使用同样的操作
11、封装：对外部世界隐藏对象的工作细节

面向对象基础

类和封装

目标
理解面向对象
类和对象
添加和获取对象属性

理解面向对象

在讲面向对象之前，总结一下面向过程
1.1.面向过程和面向对象对比：
面向过程：
面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了，以过程为主导去，可以理解成一个.py文件实现所有的功能，不会涉及到任何调用等
优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、 Linux/Unix等一般采用面向过程开发，性能是最重要的因素。
缺点：没有面向对象易维护、易复用、易扩展
面向对象：
面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为
优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统 更加灵活、更加易于维护
缺点：性能比面向过程低
面向过程编程最易被初学者接受， 往往用一长段代码来实现指定功能 。
随着时间的推移，开始使用了函数式编程，增强代码的复用性和可读性，就变成了这样.
面向对象编程则是另一种解决问题的思路
“面向对象”是指在程序设计中采用封装、继承、多态等设计方法
python中“面向过程（函数式）” 和“面向对象”编程一样重要
面向对象：对整个代码逻辑（包含数据、函数、逻辑）进行包装（专业术语：封装），最大程度提升代
码复用，减少编码量
为什么我们要在这个节点学习面向对象？
因为绝大多数的python库都使用了“面向对象”的方式来编写，故而不懂”对象“。就没法真正学会python

类和对象(封装)

2.1 理解类和对象
面向对象编程语言

• 类: 一个模板, (人类)—是一个抽象的， 没有实体的
• 对象: (eg: 张三， 李四)
• 属性: (表示这类东西的特征, 眼睛， 嘴巴， 鼻子)
• 方法： (表示这类物体可以做的事情， eg: 吃饭， 睡觉，学习)
  2.1.1类
  1）类是一种抽象的概念
  2）具有相同特性（数据元素）和行为（功能）的对象的抽象就是类。
  3）类的具体化就是对象，也可以说类的实例是对象，类实际上就是一种数据类型。
  4）类具有属性，它是对象的状态的抽象，用数据结构来描述类的属性。
  5）类具有操作，它是对象的行为的抽象，用操作名和实现该操作的方法来描述
  6）类是对一系列具有相同特征和行为的事物的统称，是一个抽象的概念，不是真实存在的事物。
  特征即是属性
  行为即是方法
  类就相当于制造飞机的图纸，就是一个模板，是负责创建对象的
  
  Python的类提供了面向对象编程的所有标准特性：
  ⑴类继承机制允许多个基类，派生类可以覆盖它基类的任何方法，一个方法可以调用基类中相同名称的的方法
  ⑵对象可以包含任意数量和类型的数据
  ⑶和模块一样，类也拥有Python天然的动态特性：它们在运行时创建，可以在创建后修改
  类的定义：
  python中定义类使用class关键字，class后面紧接类名，类名通常是大写开头的单词(无类继承时类名后可以加括号也可以不加括号)
  python中类的定义语法如下：
  1:

class ClassName:
	语句1
	...
	语句n

2:

class 类名：
	执行的语句...
	零个到多个类变量...
	零个到多个方法...

1、类定义与函数定义(def语句)一样：只有在被执行才会起作用，在定义阶段只是语法检查
2、类是属性和方法的组合，所以语句1可能是内部变量(数据、属性)的定义和赋值语句，也可能是内部方法(函数)的定义语句
⑴一个对象的特征称为"属性"
⑵一个对象的行为称为"方法"
⑶属性在代码层面上来看就是变量，方法实际就是函数，通过调用这些函数来完成某些工作

3、进入类定义时，就会创建一个新的命名空间，并把它用作局部作用域因此，所有对局部变量的赋值都是在这个新命名空间内进行的。特别的，函数定义会绑定到这个局部作用域里的新函数名称

4、正常离开(从结尾出)类定义时，就会创建一个类对象
⑴它基本上是一个包围在类定义所创建的命名空间内容周围的包装器
⑵元素的(在进入类定义之前起作用的)局部作用域将重新生效，类对象将在这里被绑定到类定义头给出的类名称(在上面的例子中就是ClassName)

2.1.2对象
1）对象是一种具体的概念
2）对象是人们要进行研究的任何事物，它不仅能表示具体的事物，还能表示抽象的规则、计划或事件。
3）对象具有状态，一个对象用数据值来描述它的状态。
4）对象还有操作，用于改变对象的状态，对象及其操作就是对象的行为。
5）对象实现了数据和操作的结合，使数据和操作封装于对象的统一体中
6）对象是由类创造出来的一个具体存在的，可以直接使用的
由哪一个类创建出来的对象，就拥有在哪一个类中定义的
2.13属性
2.14方法
在程序开发中，应该先有类，再有对象（先有图纸，再有实物）
对象就相当于用图纸制造的飞机

2.2类和对象的关系

类与对象的关系就如模具和铸件的关系，类的实力化的结果就是对象，而对对象的抽象就是类，类描述了一组有相同特性（属性）和相同行为的对象。
类是模板，对象是根据类这个模板创建出来的，应该先有类，再有对象
类只有一个，而对象可以有很多个 （一个图纸可以造多个飞机，颜色，大小这些就是它的属性）
不同的对象之间属性可能会各不相同

2.3 类的设计
在使用面向对象开发前，应该首先分析需求，确定一下，程序中需要包含哪些类
在程序开发中，要设计一个类，通常要满足以下三个要素
1.类的名称： 这类事物的名字，满足大驼峰命名法 （例：ClassName）
2.类的属性： 这类事物具有什么样的特征
3.类的方法：这类事物具有什么样的行为
2.4面向对象实现方法

class 类名(): 
代码 

注意:类名要满足标识符命名规则，同时遵循大驼峰命名习惯
例：

class Plane(): 
	def fly(self): 
		print('我会飞') 

2.4.1创建对象
对象又名实例
语法

对象名 = 类名() 

例：

#创建对象 
plane1 = Plane() 
print(plane1) 
plane1.fly() 

注意：创建对象的过程叫实例化
2.4.2 self (self我会单独写一篇详细文章讲解)
self 指的是调用该函数的对象

# 1.定义一个类 
class plane(): 
	def fly(self): 
		print('我会飞') 
		print(self) 
#2 实例化两个对象 
redplane = plane() 
print(redplane) 
blueplane = plane() 
print(blueplane) 
# 3.调用实例方法 
redplane.fly() 
blueplane.fly()

注意：打印对象和self得到的结果是一致的，都是当前内存中存储的地址

2.4.3 魔法方法 （后续文章详细讲解）
在python中， xx() 的函数叫做魔法方法，指的是具有特殊功能的函数

添加和获取对象属性

属性即是特征，比如：飞机的长，宽，重量:
对象属性既可以在类外面添加和获取，也能在类里面添加和获取
3.1类外面添加对象属性
语法

对象名.属性名 = 值

例：

redplane.lenth = 400 
redplane.weight = 500

3.2 类外面获取对象属性
语法

对象名.属性名

例：

print(redplane.weight) 
print(redplane.lenth)

3.3类里面获取对象属性
语法

self.属性名 

类属性和实例属性

4.1类属性
4.1.1设置和访问类属性
类属性就是类对象所拥有的属性，它被该类的所有实例对象所共有
类属性可以使用类对象或实例对象访问

class Dog(object): 
	tooth = 10 
	
wangcai =Dog() 
xiaohei = Dog()
 
print(Dog.tooth) # 10 
print(wangcai.tooth) #10 
print(xiaohei.tooth) # 10 

类属性的优点
类的实例，记录的某项数据 始终保持一致时，则定义类属性
实例属性 要求每个对象为其单独开辟一份内存空间 来记录数据，而类属性为全类所共有，仅
占用一份内存，更加节省内存空间。
4.1.2修改类属性
类属性只能通过类对象修改，不能通过实例对象修改，如果通过实例对象修改类属性，表示的是创建了
一个实例属性

class Dog(object): 
	tooth = 10 
	
wangcai = Dog() 
xiaohei = Dog() 
#修改类属性 
Dog.tooth = 20 
print(Dog.tooth) # 20 
print(wangcai.tooth) #20 
print(xiaohei.tooth) # 20
print('*' * 10) 
wangcai.tooth = 30 
print(wangcai.tooth) #给实例对象增加一个实例属性 30 
print(Dog.tooth) # 20 
print(xiaohei.tooth) # 20

4.2 实例属性

class Dog(object): 
	def __init__(self): 
		self.age= 5 
	def info_print(self): 
		print(self.age)
		 
wangcai = Dog() 
print(wangcai.age) # print(Dog.age) #报错，实例属性不能通过类去访问 
wangcai.info_print() # 5

类方法和静态方法

python完全支持定义类方法，甚至支持定义静态方法。python的类方法和静态方法很相似，它们都推荐使用类来调用（也可以使用对象来调用）。类方法和静态方法的区别在于：python会自动绑定类方法的第一个参数，类方法的第一个参数（通常建议参数名为cls）会自动绑定到类本身，但对于静态方法则不会自动绑定。
5.1类方法
5.1.1 类方法特点
第一个形参时类对象的方法
需要用装饰器 @classmethod 来标识其为类方法,对于类方法，第一个参数必须是类对象，一般以 cls 作为第一个参数。
5.1.2 类方法使用场景
当方法中 需要使用类对象（如访问私有属性等）时，定义类方法
类方法一般和类属性配合使用

class Dog(object): 
	__tooth = 10 
	@classmethod 
	def get_tooth(cls): 
		return cls.__tooth 
		
wangcai = Dog() 
result = wangcai.get_tooth() #实例对象访问类方法 
print(result) # 10 
print(Dog.get_tooth()) # 10 类对象访问类方法

5.2 静态方法
5.2.1 静态方法特点
需要通过装饰器 @staticmethod 来进行修饰，静态方法既不需要传递类对象也不需要传递实例对 象（形参没有 self 或者 cls ）
静态方法 也能通过实例对象和类对象去访问
5.2.2静态方法使用场景
当方法中 既不需要使用实例对象（如实例对象，实例属性），也不需要使用类对象（如类属性，类方法，创建实例对象等）时，定义 静态方法
取消不需要的参数传递，有利于减少不必要的内存占用和性能消耗

class Dog(object): 
	@staticmethod 
	def info_print(): 
		print('这是一个狗类，用于创建狗的实例......') 
		
wangcai = Dog() 
#静态方法既可以使用对象访问又可以使用类访问 
wangcai.info_print() 
Dog.info_print() 

面向对象-继承

继承是面向对象的三大特征之一，也是实现软件复用的重要手段，python的继承是多继承机制，即一个子类可以同时有多个直接父类。
语法：

class SubClass(SuperClass1,SuperClass2,...):
	#类定义部分

继承实例
子类重写父类的同名属性和方法
子类调用父类的同名属性和方法
一.继承的概念
生活中的继承，一般指的是子女继承父辈的财产。
Python面向对象的继承指的是多个类之间的所属关系，即子类默认继承父类的所有属性的方法，具体如 下：

#父类A 
class A(object): 
	def __init__(self): 
		self.money = "qq密码" 
def qq_info(self): 
	print(self.money) 
	
#子类B 
class B(A): 
	pass 
son = B() 
son.info_print() 

在Python中，所有类默认继承object类，object类是顶级类或基类；其他子类叫做派生类。
案例: 每周五聚餐，张三是员工，李四是leader

class Base(object): 
	def __init__(self,company): 
		self.company= company 
	def team_work(self): 
		print('每周五聚餐') 
		
class staff(Base): 
	def work(self): 
		print('每天上班，工作') 
class leader(Base): 
	def work(self): 
		print('新员工培训，分派工作') 

面向对象-多态

对于弱类型语言来说，变量并没有声明类型，因此一个变量完全可以在不同的时间引用不同的对象，当同一个变量在调用同一个方法时，完全可能呈现出多种行为（具体呈现出哪种行为由该变量所引用的对象来决定），这就是所谓的多态。
一多态
1.1了解多态
多态：简单地说，多态就是“具有多种形态”，它指的是：即便不知道一个变量所引用的对象到底是什么 类型，仍然可以通过这个变量调用方法，在运行过程中根据变量所引用对象的类型，动态决定调用哪个对象中的方法。

1.2 体验多态

class Animal(object): 
	def eat(self): 
		print('动物要吃东西') 
class Dog(Animal): 
	def eat(self): 
		print('狗喜欢吃骨头') 
class Person(object): 
	def eat(self): 
		print('人吃五谷杂粮') 
def fun(object): 
	object.eat() 
	
fun(Animal()) 
fun(Dog()) 
fun(Person())

模块和包

4.1 模块

<1>Python中的模块
在Python中有一个概念叫做模块（module）说的通俗点：模块就好比是工具包，要想使用这个工具包中的工具(就好比函数)，就需要导入这个模块
<2>import
在Python中用关键字 import 来引入某个模块，比如要引用模块math，就可以在文件最开始的地方用import math来引入。
形如:

import module1,mudule2... 

当解释器遇到import语句，如果模块在当前的搜索路径就会被导入。
在调用math模块中的函数时，必须这样引用：

模块名.函数名 

<3>from…import
Python的from语句让你从模块中导入一个指定的部分到当前命名空间中
语法如下：

from modname import name1[, name2[, ... nameN]] 

例如

from random import choice 

<4>from … import *
把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：

from modname import * 

注意
这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。
<5> as 起别名
<6>定位模块
当你导入一个模块，Python解析器对模块位置的搜索顺序是：

1. 当前目录
2. 如果不在当前目录，Python则搜索在shell变量 PYTHONPATH 下的每个目录。
3. 如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为 /usr/local/lib/python/
4. 模块搜索路径存储在system模块的 sys.path 变量中。变量里包含当前目录， PYTHONPATH 和由安
   装过程决定的默认目录。

4.2 包

4.2.1 文件夹里面有__init__.py 文件

包a里面有如下两个模块
4.2.2 rece_msg.py

def rece_msg(): 
	print('成功接收短信') 

4.2.3 send_msg.py

def send_msg(): 
	print('发送短信，成功发送') 

在包a外面创建一个模块 run.py
代码如下

from a.rece_msg import rece_msg 
rece_msg() 

总结：

包将有联系的模块组织在一起，即放到同一个文件夹下，并且在这个文件夹创建一个名字为
init.py 文件，那么这个文件夹就称之为 包
有效避免模块名称冲突问题，让应用组织结构更加清晰