面向过程
解决问题的步骤，即按流程走，是一种机械式的思维方式。
- 优点：
- 复杂的过程流程化（分解简化）
- 缺点：
- 扩展性差
面向对象
对象指特征与技能的结合体
对象是一个数据及相关行为的集合
面向对象是功能上指向建模对象
通过数据和行为方式来描述交互对象的集合
在python中一切皆为对象。
- 优点：
- 扩展性好
- 缺点：
- 编程复杂度很高，容易出现过度设计问题
- 交互式解决问题，无法准确预测结果
类
类是一系列对象相似的特征与技能的结合体。
现实生活中:有先一个个具体的对象，才总结出类。
程序中:先定义类，再产生对象。
面向对象编程
OOP（object oriented programming）
其是一种程序设计思想。OOP把对象作为程序的一个单元，一个对象就包含了数据和操作数据的函数。
在python中，所有数据类型都可以视为对象，同时也可以定义对象。
定义的对象的数据类型就是面向对象中类（class）的概念。
Demo:
假如要处理我们的成绩。为了表示学生的成绩：
-
面向过程的方法：
stu1 = {"name":"Tom","score":99} stu1 = {"name":"Jack","score":82} -
利用函数来实现：
def find_score(stu): print(stu["name",":",stu["score"]])
面向对象设计的思想，先抽象出类，再根据类创建实例。
由于类可以起到模板的作用，因此，可以在创建实例的时候，把一些我们认为必须绑定的属性强制填写进去。通过定义一个特殊的__init__方法，在创建实例的时候，就把name，score等属性绑上去。如果实现了__init__方法，那么表示实例对象已经创建。
class Student:
i = "ZUCC"
def __init__(self,name,scores):
self.name = name
self.score = scores
def find_score(self):
print(self.name,":",self.score)
stu1 = Student("Tom",99)
stu1.find_score() #调用类的方法
print(stu1.score) #查看对象属性(注意是score不是scores)
print(stu1.i)
Tom : 99
99
ZUCC
和普通函数相比，在类中定义方法时，第一个参数必须是self。除第一个参数外，其他的和普通函数没有什么区别。
self代表的是实例，而非类。
__init__方法
- 1.为对象初始化自己独有的特征
- 2.该方法中可以有任意的代码，但是一定不可以有返回值。
数据封装
class Student(object):
def __init__(self,name,score):
self.name = name
self.score = score
def print_score(self):
print('%s:%s'%(self.name,self.score))
bart = Student('Bart Simpson',59)
bart.print_score()
我们通过__init__让stu1实例本身就拥有了相关数据，如果要访问这些数据，我们可以直接在student类的内部定义相关的函数来访问数据，以此“封装”数据。
这些封装数据的函数和student类本身是关联起来的，我们称之为类的方法。
类的两个作用：
- 属性引用
类名.属性
- 实例化
- 类名加上一个括号就是实例化，他能够自动触发
__init__函数的运行，进而为每个实例定制自己的特征。
- 类名加上一个括号就是实例化，他能够自动触发
类属性的补充：
类属性的查看：
- 1.dir(类名)
- 返回一个字典，key为属性名，value是属性值。
特殊的类属性
类名.__name__ #返回类的名字
类名.__doc__ #类的文档字符串
类名.__base__ #类的第一个父类
类名.__module__ #类定义所在的模块
类名.__class__ #实例所对应的类
类名.__dict__ #类的字典属性
总结：
class ClassName:
def __init__(self,para1,para2, ...):
self.对象属性1 = para1
self.对象属性2 = para2
def 方法名1(self):
pass
...
obj = ClassName(para1,para2)
#对象的实例化，代表具体的东西
#ClassName():调用__init__
#括号内传参，无需传入self，参数一一对应
#结果是返回对象obj
obj.对象属性1 #查看对象属性
obj.方法名1 #调用类的方法
类命名空间与对象、实例的空间
创建一个类同时会创建一个类的名称空间，用来储存我们定义的所有变量名。这些名字就是属性。
类的属性有两种：
- 静态属性
- 直接在类中定义的变量
- 动态属性
- 在类中定义的方法
查询顺序:
对象 . 属性 : 先从对象空间找,如果找不到,再从类空间找,再找不到,再从父类找…
类名 . 属性 : 先从本类空间找,如果找不到,再从父类找…
面向对象的三大特性：
- 继承
- 多态
- 封装
继承的好处：
- 1.继承了父类的全部功能
class Animal: # 定义父类
def run(self):
print("Animal is running")
class Dog(Animal): # 单继承
pass
class Cat(Animal): # 单继承
pass
dog = Dog()
cat = Cat()
dog.run()
cat.run()
Animal is running
Animal is running
- 2.在代码运行的时候，总是会调用子类的
run()。这样，我们就获得了继承的另一个好处：多态。
class Animal: # 定义父类
def run(self):
print("Animal is running")
class Dog(Animal):
def run(self):
print('Dog is running')
class Cat(Animal):
def run(self):
print('Cat is running')
dog = Dog()
cat = Cat()
dog.run()
cat.run()
# out
Dog is running
Cat is running
要理解什么是多态，我们首先要对数据类型再作一点说明。当我们定义一个class的时候，我们实际上就定义了一种数据类型。我们定义的数据类型和Python自带的数据类型，比如str、list、dict没什么两样：
a = list() # a是list类型
b = Animal() # b是Animal类型
c = Dog() # c是Dog类型
print(isinstance(a, list)) #判断前者是否属于后者
print(isinstance(b, Animal))
print(isinstance(c, Dog))
print(isinstance(c, Animal)) #c既是Dog又是Animal
True
True
True
True
多态的好处就是，当我们需要传入Dog、Cat、Tortoise……时，我们只需要接收Animal类型就可以了，因为Dog、Cat、Tortoise……都是Animal类型，然后，按照Animal类型进行操作即可。由于Animal类型有run()方法，因此，传入的任意类型，只要是Animal类或者子类，就会自动调用实际类型的run()方法，这就是多态的意思。
对于一个变量，我们只需要知道它是Animal类型，无需确切地知道它的子类型，就可以放心地调用run()方法，而具体调用的run()方法是作用在Animal、Dog、Cat还是Tortoise对象上，由运行时该对象的确切类型决定，这就是多态真正的威力：调用方只管调用，不管细节，而当我们新增一种Animal的子类时，只要确保run()方法编写正确，不用管原来的代码是如何调用的。这就是著名的“开闭”原则。
对扩展开放：允许新增Animal子类；
对修改封闭：不需要修改依赖Animal类型的run_twice()等函数。
继承还可以一级一级地继承下来，就好比从爷爷到爸爸、再到儿子这样的关系。而任何类，最终都可以追溯到根类object，这些继承关系看上去就像一颗倒着的树。比如如下的继承树。
┌───────────────┐
│ object │
└───────────────┘
│
┌────────────┴────────────┐
│ │
▼ ▼
┌─────────────┐ ┌─────────────┐
│ Animal │ │ Plant │
└─────────────┘ └─────────────┘
│ │
┌─────┴──────┐ ┌─────┴──────┐
│ │ │ │
▼ ▼ ▼ ▼
┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐
│ Dog │ │ Cat │ │ Tree │ │ Flower │
└─────────┘ └─────────┘ └─────────┘ └─────────┘
私有属性(类的访问权限)
在类的内部，可以有属性和方法，而外部代码可以通过直接调用实例变量的方法来操作数据，这样就隐藏了内部的复杂逻辑。
由下面的例子可以看出，外部代码可以自由修改一个实例的属性（name、score）：
>>> bart = Student('Bart Simpson', 59)
>>> bart.score
59
>>> bart.score = 99
>>> bart.score
99
如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线__，在Python中，实例的变量名如果以__开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问，所以，我们把Student类改一改：
class Student(object):
def __init__(self, name, score):
self.__name = name
self.__score = score
def print_score(self):
print('%s: %s' % (self.__name, self.__score))
bart = Student('Bart Simpson', 59)
print(bart.score) #不能被调用
bart.score = 99
print(bart.score)
AttributeError: ‘Student’ object has no attribute ‘score’
如果外部代码要获取name和score，可以给Student类增加get_name和get_score这样的方法：
class Student(object):
...
def get_name(self):
return self.__name
def get_score(self):
return self.__score
bart = Student('Bart Simpson', 59)
print(bart.get_name())
Bart Simpson
如果要允许外部代码修改score，可以再给Student类增加set_score方法：
class Student(object):
def __init__(self, name, score):
self.__name = name
self.__score = score
def print_score(self):
print('%s: %s' % (self.__name, self.__score))
def get_score(self):
return self.__score
def set_score(self, score):
self.__score = score
bart = Student('Bart Simpson', 59)
print(bart.get_score())
bart.set_score(69)
print(bart.get_score())
59
69
你也许会问，原先那种直接通过bart.score = 99也可以修改啊，为什么要定义一个方法大费周折？因为在方法中，可以对参数做检查，避免传入无效的参数。
封装
- A:封装概述
- 是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
- B:封装好处
- 隐藏实现细节，提供公共的访问方式
- 提高了代码的复用性
- 提高安全性。
- C:封装原则
- 将不需要对外提供的内容都隐藏起来。
- 把属性隐藏，提供公共方法对其访问。
静态语言 vs 动态语言
对于静态语言（例如Java）来说，如果需要传入Animal类型，则传入的对象必须是Animal类型或者它的子类，否则，将无法调用run()方法。
对于Python这样的动态语言来说，则不一定需要传入Animal类型。我们只需要保证传入的对象有一个run()方法就可以了：
class Timer(object):
def run(self):
print('Start...')
这就是动态语言的“鸭子类型”，它并不要求严格的继承体系，一个对象只要“看起来像鸭子，走起路来像鸭子”，那它就可以被看做是鸭子。
Python的“file-like object“就是一种鸭子类型。对真正的文件对象，它有一个read()方法，返回其内容。但是，许多对象，只要有read()方法，都被视为“file-like object“。许多函数接收的参数就是“file-like object“，你不一定要传入真正的文件对象，完全可以传入任何实现了read()方法的对象。
扫一扫
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
