标签：连接 3.3 gdi 学习 内存 原则 邮件 多重 复杂
1、什么是面向对象编程
-- 以前使用函数来实现，使用函数比较复杂的实现，现在使用面向对象，实现起来更简单。
-- 面向对象就是现在就是用类和对象来进行实现
2、什么是类？什么是对象？两者又有什么关系？
-- 类里面就是函数的集合
-- 例如：obj = 类名()，
obj就是对象，这个过程叫做实例化的过程，最后调用时使用对象名.函数()的格式进行调用，例如：obj.函数()。
-- 两者的关系是实例化与被实例化，调用与被调用的关系。
3、什么时候适用面向对象？
-- 根据一个模板创建某些东西时。
-- 当很多函数需要传多个相同参数时。
-- 当函数中又有很多重复代码时。
根据业务逻辑从上到下垒加代码（如果程序修改，对于依赖的过程都需要进行修改）
面向对象编程方式实现监控报警： #/usr/bin/env python while True: if cpu利用率 > 90 %: BR # 发送邮件提醒/BR 连接邮箱服务器 发送邮件 关闭连接 if 硬盘使用空间 > 90 %: # 发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接 if 内存占用 > 80 %: # 发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接
将某功能代码封装到函数中，如后便无需重复编写，仅仅需要代用函数即可。
面向对象
世界万物，皆可分类。
世界万物，皆为对象。
只要是对象，就肯定属于某种品类。
只要是对象，就肯定有属性（名称或功能）
对函数进行分类和封装，让开发“更快、更好、更强”
无论用什么形式来编程，我们都要明确记住以下原则：
写重复代码是非常低级的行为
你写的代码需要经常变更。
#/usr/bin/env python def 发送邮件(内容) # 发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接 while True： if cpu利用率 > 90 %: 发送邮件(‘CPU报警‘) if 硬盘使用空间 > 90 %: 发送邮件(‘硬盘报警‘) if 内存占用 > 80 %: 发送邮件(‘内存报警‘)
类有三大特性：封装、继承、多态。
封装特性：
防止数据被随意修改。
继承特性：
通过父类--->子类的fang‘shi方式以最小代码量的方式实现不同角色的共同点,和不同点的同时存在。
经典类重构写法：
SchoolMember.__init__(self,name,age,sex)
新式类重构写法(强烈推荐使用)：
super(Teacher,self).__init__(name,age,sex)
多态特性：
-- 多态是面向对象语言的一个基本特性，多态意味着变量并不知道引用的对象是什么。
-- 根据引用对象的不同表现不同的行为方式，在处理多态对象时，只需要关注它的接口即可。
-- 可以看到跟一般的静态语言相比，Python并没有在语言级别来保证接口的正确性。
-- 只能依靠文档、代码来保证。
例如： 定义： 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() 方法，动态属性。
面向对象编程是一种编程方式，此变成方式和落地需要使用“类（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")
面向对象的三大特性：封装、继承、多态
在类中对数据的赋值，内部调用对外部用户是透明的，这使类变成了类似一个容器，里面包含着类的数据和方法。
接下来我们进一步细分封装功能
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间接获取被封装的内容。
沁夫，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间接去当前对象中取值就可以了。
1、封装不需要重复传入相同的参数。
2、高内聚，低耦合（即是类里面的方法与都在一个类里面，与外界没关系。）
一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承。
开发人员：开发代码，吃，喝，拉，撒
运维人员：运维工作，吃，喝，拉，撒
#简单实现的内容
#/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()
##对于面向对象那个的继承来说，其实就是将多个类有的方法提取到父类中，子类仅需继承父类而不必--实现每个方法，避免重复造轮子。
注意：除了子类和父类的称谓，你可能看到过 派生类和基类，他们与子类和父类只是叫法不同。
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-->A
广度查找顺序：如图
深度查找顺序：如图
多态是面向对象的重要特性，简单点说:一个接口，多种实现。
#/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)
标签：连接 3.3 gdi 学习 内存 原则 邮件 多重 复杂
原文地址：http://www.cnblogs.com/cxcx/p/6111447.html
