第一章 面向对象设计的问题
1、什么是面向对象编程
-- 以前使用函数来实现，使用函数比较复杂的实现，现在使用面向对象，实现起来更简单。
-- 面向对象就是现在就是用类和对象来进行实现
2、什么是类？什么是对象？两者又有什么关系？
-- 类里面就是函数的集合
-- 例如：obj = 类名()，
obj就是对象，这个过程叫做实例化的过程，最后调用时使用对象名.函数()的格式进行调用，例如：obj.函数()。
-- 两者的关系是实例化与被实例化，调用与被调用的关系。
3、什么时候适用面向对象？
-- 根据一个模板创建某些东西时。
-- 当很多函数需要传多个相同参数时。
第二章 面向对象基础概述
2.1 面向过程
根据业务逻辑从上到下垒加代码（如果程序修改，对于依赖的过程都需要进行修改）
2.2练习代码
面向对象编程方式实现监控报警：
#/usr/bin/env python
while True:
if cpu利用率 > 90 %:
BR # 发送邮件提醒/BR
连接邮箱服务器
发送邮件
关闭连接
if 硬盘使用空间 > 90 %:
# 发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接
if 内存占用 > 80 %:
# 发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接
2.3 函数式
将某功能代码封装到函数中，如后便无需重复编写，仅仅需要代用函数即可。
面向对象
世界万物，皆可分类。
世界万物，皆为对象。
只要是对象，就肯定属于某种品类。
只要是对象，就肯定有属性（名称或功能）
对函数进行分类和封装，让开发“更快、更好、更强”
无论用什么形式来编程，我们都要明确记住以下原则：
写重复代码是非常低级的行为
你写的代码需要经常变更。
2.4使用函数式编程来实现，增强代码的重用性和可读性
#/usr/bin/env python
def 发送邮件(内容)
# 发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接
while True：
if cpu利用率 > 90 %:
发送邮件('CPU报警')
if 硬盘使用空间 > 90 %:
发送邮件('硬盘报警')
if 内存占用 > 80 %:
发送邮件('内存报警')
第三章 面向对象简介
3.1、类的特性
类有三大特性：封装、继承、多态。
封装特性：
防止数据被随意修改。
继承特性：
通过父类--->子类的fang'shi方式以最小代码量的方式实现不同角色的共同点,和不同点的同时存在。
经典类重构写法：
SchoolMember.__init__(self,name,age,sex)
新式类重构写法(强烈推荐使用)：
super(Teacher,self).__init__(name,age,sex)
多态特性：
-- 多态是面向对象语言的一个基本特性，多态意味着变量并不知道引用的对象是什么。
-- 根据引用对象的不同表现不同的行为方式，在处理多态对象时，只需要关注它的接口即可。
-- 可以看到跟一般的静态语言相比，Python并没有在语言级别来保证接口的正确性。
-- 只能依靠文档、代码来保证。
3.2、类的定义
例如：
定义：
class Dog(object):
def __init__(self,name,age):
self.NAME=name
self.AGE=age
def sayhi(self):
print("hello, you is a dog.")
实例化：
d = Dog()
调用：
d.sayhi()
类---->实例化---->实例对象
__init__ 构造函数
self.NAME=name 属性，成员变量
def sayhi() 方法，动态属性。
3.3 使用面向对象来实现代码
面向对象编程是一种编程方式，此变成方式和落地需要使用“类（class）”和“对象（object）”来实现，所以，面向对象编程其实就是对“类”和“对象”的使用。
类就是一个模板，模板里可以包含多个函数，函数里实现具体功能（把一个类变成具体的过程叫做实例化）
对象则是根据模板创建的实例，通过实例对象可以执行类中函数。
class Dog(object):
def __init__(self,name): #构造函数，构造方法， 等于 初始化方法。所有传进来的参数先传到这里。。
self.NAME = name #其中self就是d或者d2
def sayhi(self): #类的方法
print("hello , i am a dog .my name is ",self.NAME)
def eat(self,food):
print("%s is eating %s "%(self.NAME,food))
d = Dog("Lichuang")
d2 = Dog("Chuang2")
d.sayhi()
d2.eat("baozi")
第四章 面向对象三大特征
面向对象的三大特性：封装、继承、多态
4.1 封装
在类中对数据的赋值，内部调用对外部用户是透明的，这使类变成了类似一个容器，里面包含着类的数据和方法。
接下来我们进一步细分封装功能
4.1.1 封装调用
1、通过对象直接调用
#/usr/bin/env python
class C1: #创建类
# init构造函数，在实例化时做一些类的初始化的工作
def __init__(self,name):
self.name=name
#创建一个功能方法，
def chi(self,food): #方法可以穿参数一个food
print("%s正在吃%s"%(self.name,food))
#实例化C1的类，将实例化功能的name在实例化时传进来。
obj1 = C1('陈鑫')
obj2 = C1('蜡笔小新')
#进行调用类，使用chi的方法，将方法的参数在调用时穿入进去即可
obj1.chi('汉堡')
obj2.chi('米饭') 2、通过self间接调用
执行类中的方法时，需要通过self间调用被封装的内容
class F2():
def __init__(self,name,age):
self.name = name
self.age = age
def test(self):
print(self.name)
print(self.age)
test1=F2('chenxin',22)
test1.test() ##Python默认会将test1传给self参数，self.test()即相当于test1.test(test1),所以self=tets1，因此self.name就是chenxin，self.age是22
上述内容，对于面向对象的封装来说，其实就是使用构造方法将内容封装到对象中，然后通过对象直接或者self间接获取被封装的内容。
4.1.2 练习题：在终端输出如下信息
沁夫，30岁，女，搞网恋。
沁夫，30岁，女，不学习，搞毛细。
沁夫，30岁，女，很坑爹（坑了我）。
刘强，35岁，男，每天大保健。
刘强，35岁，男，每天净扯淡。
刘强，35岁，男，常年蹲级生。函数式编程方法：
#函数式编程方法（面向过程）：
def baojian(name,age,gender):
print("%s,%s岁,%s,每天大保健。"%(name,age,gender))
def chedan(name,age,gender):
print("%s,%s岁,%s,每天净扯淡。"%(name,age,gender))
def kengdie(name,age,gender):
print("%s,%s岁,%s,很坑爹（坑了我）。\n"%(name,age,gender))
baojian('沁夫',30,'女')
chedan('沁夫',30,'女')
kengdie('沁夫',30,'女')
baojian('刘强',30,'男')
chedan('刘强',30,'男')
kengdie('刘强',30,'男')#面向对象编程方法：
#上述对比，可以看出，如果使用函数式编程，需要在每次执行函数时传入形同的参数，如果参数多的话，又需要粘贴复制了；而对面向对象值需要在创建对象的时，将所有需要的参数封装到当前对象中，之后再次使用时，通过self间接去当前对象中取值就可以了。
4.1.3总结：
1、封装不需要重复传入相同的参数。
2、高内聚，低耦合（即是类里面的方法与都在一个类里面，与外界没关系。）
4.2 继承
一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承。
4.2.1 举例说明
开发人员：开发代码，吃，喝，拉，撒
运维人员：运维工作，吃，喝，拉，撒
#/usr/bin/env python
class kaifa:
def kaifadaima(self):
print('开发代码')
def chi(self):
print('吃')
def he(self):
print('喝')
def la(self):
print('拉')
def sa(self):
print('撒')
class yunwei:
def yunweigongzuo(self):
print('运维工作')
def chi(self):
print('吃')
def he(self):
print('喝')
def la(self):
print('拉')
def sa(self):
print('撒')#使用面向对象编程中“继承”的方式实现：
class ren:
def chi(self):
print('%s 吃 '%(self.name))
def he(self):
print('%s 喝'%(self.name))
def la(self):
print('%s 拉'%(self.name))
def sa(self):
print('%s 撒'%(self.name))
class kaifa(ren):
def __init__(self,name):
self.name=name
self.renyuan="开发人员"
def cry(self):
print('%s 开发代码---->%s '%(self.name,self.renyuan))
class yunwei(ren):
def __init__(self,name):
self.name= name
self.renyuan="运维人员"
def cry(self):
print('%s 运维工作---->%s'%(self.name,self.renyuan))
kf = kaifa('沁夫')
kf.cry()
kf.chi()
kf.he()
kf.la()
kf.sa()
yw = yunwei('陈鑫')
yw.cry()
yw.chi()
yw.he()
yw.la()
yw.sa()
##对于面向对象那个的继承来说，其实就是将多个类有的方法提取到父类中，子类仅需继承父类而不必--实现每个方法，避免重复造轮子。
注意：除了子类和父类的称谓，你可能看到过 派生类和基类，他们与子类和父类只是叫法不同。2.4.2 多级继承
1、Python的类可以继承多个类，Java和C#中则只能继承一个类。
2、Python的类如果继承多个类，那么其寻找方法的方式有两种，分别是：深度查找和广度查找。
python2经典类，按深度优先来继承。
python2新式类，按广度优先来继承。
python3经典类，新式类，是按广度优先来继承。
经典类（深度优先）
当类是经典类时，多继承情况下，会按照深度优先方式查找。
#经典类写法：
class A1:
pass
class A2(A1):
pass
经典类实战:
class A:
def bar(self):
print('A.bar')
class B(A):
# pass
def bar(self):
print('B.bar')
class C(A):
# pass
def bar(self):
print('C.bar')
class D(B,C):
# pass
def bar(self):
print('D.bar')
a=D()
a.bar()
#执行bar方法时（在Python2.0中）
首先去D中查找bar方法，如果D没有，就去B中查找，如果B中没有，再去A查找，如果A没有，则去C中查找。
查找顺序：D-->B-->A-->C
#执行bar方法时（在Python3.0中）
首先在D中查找bar方法，如果D没有，就去B中查找，如果B中没有，再去C中查找，最后去A查找。
查找顺序：D-->B-->C-->A
新式类（广度优先）
当新式类时，多继承情况下，会按照广度优先方式查找。
#新式类写法：
class N1(object):
pass
class N2(N1):
pass
#新式类实战：
class A(object):
# pass
def bar(self):
print('A.bar')
class B(A):
pass
# def bar(self):
# print('B.bar')
class C(A):
pass
# def bar(self):
# print('C.bar')
class D(B,C):
pass
# def bar(self):
# print('D.bar')
a=D()
a.bar()
#执行bar方式时，（不管是Python2，还是Python3）
首先在D中查找bar方法，如果D没有，就去B中查找，如果B中没有，再去C中查找，最后去A查找。
查找顺序：D-->B-->C-->A2.4.3 广度查找和深度查找
广度查找顺序：如图
深度查找顺序：如图
2.5 多态
多态是面向对象的重要特性，简单点说:一个接口，多种实现。
#/usr/bin/env python
class F1(object):
pass
class S1(object):
def show(self):
print('S1.show')
class S2(F1):
def show(self):
print('S2.show')
def Func(obj): #在这个函数中的obj的就是实例化后的对象。
print(obj.show()) #对象在此调用两个类相同的方法，进而实现一个接口，多种实现。
s1_obj = S1() #实例化S1类
Func(s1_obj)
s2_obj = S2() #实例化S2类
Func(s2_obj)
