一、面向对象简介
1、面向过程编程
面向过程”(Procedure Oriented)是一种以过程为中心的编程思想。这些都是以什么正在发生为目标进行编程，不同于面向对象的是谁在受影响。与面向对象明显的不同就是封装、继承、类。
特性：模块化 流程化
优点：性能比面向对象高, 因为类调用时需要实例化，开销比较大，比较消耗资源;
单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发，性能是最重要的因素。
缺点：没有面向对象易维护、易复用、易扩展
2、函数式编程
数式编程是种编程方式，它将电脑运算视为函数的计算。函数编程语言最重要的基础是λ演算（lambda calculus），而且λ演算的函数可以接受函数当作输入（参数）和输出（返回值）。
主要思想: 把运算过程尽量写成一系列嵌套的函数调用。
3、面向对象编程
面向对象是按人们认识客观世界的系统思维方式，采用基于对象（实体）的概念建立模型，模拟客观世界分析、设计、实现软件的办法。通过面向对象的理念使计算机软件系统能与现实世界中的系统一一对应。
特性：抽象 封装 继承 多态
优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，
可以设计出低耦合 的系统，使系统更加灵活、更加易于维护
缺点：性能比面向过程低
二、面向对象
对象和类
类(Class)是现实或思维世界中的实体在计算机中的反映，它将数据以及这些数据上的操作封装在一起。
对象(Object)是具有类类型的变量。类和对象是面向对象编程技术中的最基本的概念。
- 如何定义类? class 类(): pass
- 如何将类转换成对象?
实例化是指在面向对象的编程中，把用类创建对象的过程称为实例化。是将一个抽象的概念类，具体到该类实物的过程。实例化过程中一般由类名 对象名 = 类名（参数1，参数2…参数n）构成。
类（Class）是是创建实例的模板
对象(Object)是一个一个具体的实例
如下边代码所示：
class Student:
# 构造方法： 当创建对象时会自动调用并执行;
# self实质上是实例化出来的对象
def __init__(self, name, age, gender):
# 将创建对象的属性(name, age, gender)封装到self(就是实例化的对象)变量里面;
# 在类里面定义的变量: 属性
self.name = name
self.age = age
self.gender = gender
# 在类里面定义的函数： 方法
def study(self):
print('%s,%s,%s eating......' %(self.name,self.age,self.gender))
def sleep(self):
# 获取对象self封装的属性(name, age, gender)
print('%s,%s,%s sleep.......' %(self.name,self.age,self.gender))
student1=Student("小明",18,"男")
student1.study() ## 调用学生类的study方法。
构造方法__init__与其他普通方法不同的地方在于，当一个对象被创建后，会立即调用构造方法。自动执行构造方法里面的内容。
封装
顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。所以，在使用面向对象的封装特性时，需要：
1). 将内容封装到某处
2). 从某处调用被封装的内容
1). 通过对象直接调用被封装的内容： 对象.属性名
2). 通过self间接调用被封装的内容： self.属性名
3). 通过self间接调用被封装的内容: self.方法名()
对于面向对象的封装来说，其实就是使用构造方法将内容封装到 对象 中，然后通过对象直接或者self间接获取被封装的内容。我们上边的代码里就用到了封装。
继承特性
面向对象的三大特性是指：封装、继承和多态
- 继承
- 多继承
- 私有属性与私有方法
继承描述的是事物之间的所属关系,当我们定义一个class的时候,可以从某个现有的class继承,新的class称为子类、扩展类(Subclass),而被继承的class称为基类、父类或超类(Baseclass、Superclass)。
问题一: 如何让实现继承?
子类在继承的时候,在定义类时,小括号()中为父类的名字
问题二: 继承的工作机制是什么?
父类的属性、方法,会被继承给子类。 举例如下: 如果子类没有定义__init__方法,父类有,那么在子类继承父类的时候这个方法就被继承了,所以只要创建对象,就默认执行了那个继承过来的__init__方法。
# 定义类的过程
# Father: 父类/基类
class Father:
goal = "今天很帅！"
# 如果类里面的方法以双下划线开头/结尾, 魔术方法;
def __init__(self, name, age, money):
# 封装
self.name = name
self.age = age
self.money = money
def eat(self):
print("%s正在吃大餐" %(self.name))
# Son: 子类/扩展类
# 代表Son类的父类为Father;
class Son(Father):
# Son没有构造方法, 因为父类Father有， 自动调用父类的构造方法;
goal = "先挣它10个亿"
def eat(self):
# 调用父类的方法一:
Father.eat(self)
# 调用父类的方法二(建议): 获取Son对应的父类，， 并执行该父类的eat方法
super(Son, self).eat()
print("%s正在吃xxxxxx" %(self.name))
# 实例化的过程: 通过类创建对象的过程
wsc = Son("王思聪", 35, 10000000000)
wsc.eat()
print(wsc.goal)
多继承,即子类有多个父类,并且具有它们的特征
新式类： 广度优先
经典类: 深度优先
在Python 3.x之后的版本，因为所有的类都派生自内置类型object(即使没有显示的继承object类型)，即所有的类都是“新式类”。
class D:
a = 'd'
class B(D):
pass
class C(D):
a = 'c'
class A(B, C):
pass
obj = A()
print(obj.a)
多态特性
多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。通俗来说： 同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。
多态的好处就是，当我们需要传入更多的子类，只需要继承父类就可以了，而方法既可以直接不重写（即使用父类的），也可以重写一个特有的。
调用方只管调用，不管细节，而当我们新增一种的子类时，只要确保新方法编写正确，而不用管原来的代码。这就是著名的“开闭”原则：
对扩展开放（Open for extension）：允许子类重写方法函数
对修改封闭（Closed for modification）：不重写，直接继承父类方法函数
面向对象案例
队列的封装
队列是限制在一端进行插入操作和另一端删除操作的线性表，允许进行插入操作的一端称为“队尾”，
允许进行删除操作的一端称为“队头”，，当队列中没有元素时称为“空队”。特点 ：先进先出（FIFO）。
class Queue(object):
"""
根据列表的数据结构封装队列的数据结构
"""
# 构造方法
def __init__(self):
# 定义一个空队列， 用来存储队列的元素
self.__queue = []
# len(Q)自动会调用该方法
def __len__(self):
return len(self.__queue)
def enqueue(self, item):
self.__queue.append(item)
print("元素[%s]进队成功" % (item))
def dequeue(self):
"""出栈, 判断队是否为空"""
if not self.is_empty():
# 获取出队的元素
item = self.__queue.pop(0)
print("元素[%s]出队成功" % (item))
else:
raise Exception("队列为空")
def first(self):
"""获取队头元素"""
if not self.is_empty():
# 获取出队的元素
item = self.__queue[0]
print("队头元素为: [%s] " % (item))
else:
raise Exception("队为空")
def length(self):
"""获取队列的元素个数"""
return len(self.__queue)
def is_empty(self):
"""判断队列是否为空"""
return len(self.__queue) == 0
Q = Queue()
Q.enqueue(6)
Q.enqueue(3)
Q.enqueue(2)
Q.enqueue(1)
Q.first()
Q.dequeue()
print(len(Q))
356
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
