话不多说，直接进入正文：
编程思想：
我个人所了解的有2种，还有个函数式编程的概念模模糊糊（大概是把常用的代码封装成一个函数，重复调用即可，先认为就是这样吧）
1 面向对象：面向对象是把所有的事务物当作独立的对象（建立对象对的目的不是为完成一个步骤，而是为了描述这个些对象在整个解决问题的步骤中的行为），处理问题过程中所思考的是各个对象之间的关系（JAVA,python）。
2 面向过程：根据事务的逻辑分析出解决问题所需要步骤，再用函数一步一步的去实现这些步骤，使用的时候一个个依次调用就行了。（C语言是典型的代表）
无论用什么形式来编程，我们都要明确记住以下原则：
- 写重复代码是非常不好的低级行为
- 你写的代码需要经常变更
面向对象和面向过程的资料参考： 猛戳这里
用代码去了解
简单了解了什么是面向对象和面向过程的编程思想后，那么就开始用代码去了解。
简单的业务内容：
对CPU，内存，磁盘使用率监控，使用率超过90%报警。
当我们刚接触python这门语言的时候，作为小白，根据这个业务逻辑肯定是挨个挨个的去判断（面向过程的思想），然后去发送报警信息，那么就有了下面的代码：
while True:
if cpu.usage > 90:
mail(CPU报警) #（假设mail这里是一个发送邮件的功能，我们直接在括号内输入要发送的内容就行了）
if mem.usage > 90:
mail(内存报警)
if disk.usage > 90:
mail(磁盘报警)
但是随着知识的增长，此时我们学习了函数，了解到了函数式编程，那么可以把代码精简如下：
def judge_usage(name,content): #把判断功能和发送功能做成一个函数，直接传参就行了
if name > 90:
mail(content)
judge_usage(cpu.usage,cpu报警) #那么我们调用的时候直接传入内存，CPU，磁盘的使用率就行了。
好了到此为止我们觉得这个代码就行了，最起码把代码精简了，省去了重复的代码。
那么今天我们就来学习下 --> 面向对象的编程
说道面向对象，那么不得不提类和对象，那么在python里面什么类，什么是对象。
类：一堆方法的集合，但是这些方法之间又有联系。
对象：类实例化后的结果就是对象
咱们也得知道，通过实例化后的对象可以执行类里面的一些方法。
代码例子：
#面对对象的编程 OOP
class Role(object): #通过class这个关键字来创建一个类,Role表示这是类的名字,（object）是新式类的写法 必 须这么写（以后再说原因），表示继承object类，3.0以上的版本最好都写上。
def __init__(self,name,role,gun,life_value): #__init__用函数的话说这里就是Role类的初始化函数，使用类的专业名词就是说构造方法，在类 实例化的时候会默认执行。，这里的self表示为对象本身，而对象又是在实例化的时候创建的
self.name=name #把name赋值给self.name
self.role=role
self.gun=gun
self.life_val=life_value
def buy_gun(self,gun_name): #定义了一个buy_gun的方法
print("%s buy %s"%(self.name,gun_name))
self.gun=gun_name
我们这样使用这个类：
p1=Role('lisi','police','AK47',100)
print('P1 ',p1.buy_gun('xxx'))
#其实上面那语句 " p1=Role('lisi','police','AK47',100) " 等价于这句 Role(p1,'lisi','police','AK47',100),p1的所在的位置就对应的是self。这么做的目的就在于把'lisi','police','AK47',100和p1关联起来
说清楚点就是：实际上我们执行上面实例化的语句时做了两件事情
1 在内存开辟空间，指向p1这个变量名。
2 开始实例化了，调用了Role这个类，并且执行了__init__这个构造方法，相当于Role.__init__(p1,'lisi','police','AK47',100),注意看，p1占用了self的位置，为啥会这样，其实这么做的目的就在于把'lisi','police','AK47',100和刚才开辟的变量名p1关联起来，也许你就会问了，为啥要关联起来，如果不关联起来，那么这4个参数就没有跟谁了，解释器就会报错了。
3 所以说，p1=Role('lisi','police','AK47',100)这样一运行后，self.name = name ,self.role = role ...... 就把'lisi','police','AK47',100 这4个值放入了p1这个内存空间里面。
到此你也许会问为啥在第二个方法里面buy_gun还有个self呢？那么现在就解答你的问题。
虽然我们在实例化的时候把传入了那几个参数和p1关联起来了，但是我们在调用这个bug_gun方法的时候，需要告诉buy_gun，从谁那里获取信息，怎么去获取，于是把p1传给self，这样buy_gun才能够去访问p1的信息，所以能够打印出self.name（p1.name）来，其实最简单的回答就是调用方法的时候，这个方法得知道who are you。do you understand?? i think you will answer i do!!
好了，说了那么多，我们总结下出以下2点：
- 上面的这个p1=Role('lisi','police','AK47',100)动作，叫做类的“实例化”， 就是把一个虚拟的抽象的类，通过这个动作，变成了一个具体的对象了， 这个对象就叫做实例
- 刚才定义的这个类体现了面向对象的第一个基本特性，封装，其实就是使用构造方法将内容封装到某个具体对象中，然后通过对象直接或者self间接获取被封装的内容
类的变量和实例的变量
class aa(object):
x=0
def __init__(self,name):
self.name=name
def buy_some(self,goods_name):
print("%s buying %s"%(self.name,goods_name))
bb=aa('bb')
cc=aa('cc')
aa.name='AK47'
print('aa.weapon -->',aa.name)
dd=aa('lisi')
aa.x="AA's thing"
aa.c='ccccccccc'
aa.name='AA'
bb.x='first'
bb.c='xxxxxxx'
bb.buy_some('lumia1020')
print('bb.c-->',bb.c)
#print('bb name--',bb.name)
cc.buy_some('Nokia N1')
print('cc c -->',cc.c)
从上面的代码中可以观察到1 在类里面的初始化方法__init__()，只有在调用的时候才才会创建self.name这个变量，倘若没有调用，那么直接运行aa.name是会报错的， 因为self.name是属于实例的变量(也叫成员属性，实例的属性)，存在实例的内存中，不属于类的变量2 在类里面的变量x，在类没有被调用的也是存在的，存在类的内存里，所以aa.x是可以的3 aa这个类里面的buy_some方法，他是在aa这个类的内存里面的，不是在实例的内存里面的，所以实例每次调用这个buy_some方法的时候，都得 去类里面调用，并且告诉这个方法调用者的信息（其实就是实例的变量，buy_some第一个参数就是self,就是用来接受调用者信息的）。那会有人问了，为什么 不在每个实例化的过程中把buy_some方法都添加到实例内存中的，这样的话buy_some方法就在实例内存中，就不用在调用buy_some这个方法的告诉这个方法调 用者的信息，显然这个想法是错误的，为啥，因为函数对于外面是封闭的，所以调用buy_some的时候还得告诉调用者的信息，并且这样在每个实例中添加相同的 方法，那样只会占据更多的内存。那又有人会问了，我们可以把全局变量在buy_some这个方法中写死，如刚才实例化成的bb,cc，但是这里有个问题是，写死的 前提必须这个全局变量存在，但是没有实例化之前这个变量又是不存在的，所以这里是一个非常矛盾的问题。说了这么多就是想说明这点，类里面的方法除了构 造方法之外，都在类的内存里面，调用类里面的方法的时候必须告诉这个方法 调用者的信息
把上面3句话说精简点就是：
1 类的变量可以随时访问，实例的变量只有在实例化之后才能访问
2 类里面的方法除了构造方法之外，都在类的内存里面，调用类里面的方法的时候必须告诉这个方法 调用者的信息
3 倘若在类变量xx=None, 那么实例化之后，实例.xx='something'相当于把xx='something'放入了实例的内存里，如果直接实例.xx，就等于直接取类的变量。
类的继承
继承也是类的一大特性，它可以使用现有类的所有功能，并无需重新编写原来的类的情况下对这些功能进行扩展。
在这里我们要了解两个概念 ：
-------------------------------------------
父类（也有人称超类，基类）：被继承的类。
子类（也有人称派生类）：通过继承创建的类。
-------------------------------------------
继承的过程，也就是从一般到特殊的过程。要实现继承，可以通过“继承”（Inheritance）和“组合”(Compostion）来实现。
继承是从一般到特殊的过程：父类是定义一般的方法，而子类是有特殊的方法，所以这就是从一般到继承的过程。
一般情况下一个子类只有一个基类，要实现多重继承，可以通过多级继承来实现。
我们看如下代码：
class animal(object):
def __init__(self,name):
self.name=name
def eat(self):
print("%s eating!!"%self.name)
def drink(self):
print("%s drink!!"%self.name)
def sleep(self):
print("%s sleep!!"%self.name)
def discharge(self):
print("%s discharge!!"%self.name)
class people(animal): #这里开始继承animal类
def __init__(self,name,hair,thought):
super(people,self).__init__(name) #super 是用来解决多重继承问题的,咱们后面会讲到
self.hair=hair
self.thought=thought
def whether_thought(self):
print("He's name is %s ,and he can thought(%s) as people!!"%(self.name,self.thought))
class monkey(animal):
def __init__(self,name,hair,climb):
super(monkey,self).__init__(name)
self.climb = climb
def whether_climb(self):
print("he is monkey and he's name is %s,he can climb(%s)"%(self.name,self.climb))
p1=people('ljf','black','yes')
p1.whether_thought() #p1可以调用属于自己的方法，但是无法调用monkey的whether_climb的方法
print(p1.hair)
p1.eat() #p1可以调用父类eat的方法
m1=monkey('wukong','yellow','can climb')
m1.whether_climb()
m1.drink() #m1可以调用父类的drink方法