面向对象初级
面向对象编程是一种编程方式，此编程方式的落地需要使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用。
类就是一个模板，模板里可以包含多个函数，函数里实现一些功能
对象则是根据模板创建的实例，通过实例对象可以执行类中的函数
- 面向对象编程不是所有的情况都适用
- class是关键字，表示类
- 创建对象，类名称后加括号即可
-
class Foo: #创建类名 def bbb(self): #创建类的函数，也叫作方法 print('bbbbbbbbb') def ccc(self,name): #（self） 特殊参数 必填的 print(name) obj = Foo() # 创建对象 （创建类的实例） obj.bbb() # 调用对象 执行bbb方法 obj.ccc('kaixin')
面向对象：【创建对象】【通过对象执行方法】
函数编程：【执行函数】
场景不同那么适用编程的方式也不同
总结：函数式的应用场景 --> 各个函数之间是独立且无共用的数据
面向对象的三大特性是指：封装、继承和多态。
1，封装
封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。
所以，在使用面向对象的封装特性时，需要：
class oldoby: def fetch(self): print(self.zzzz) obj = oldoby() obj.zzzz = 'www.000000.com' #将值封装到类对象中，不需要再传参数了 obj.fetch()
将内容封装到某处：
class oldoby: def __init__(self,bk): #构造方法 self.name = '开心' self.xixi = bk print(self.name,self.xixi) obj = oldoby('zzzzzzzzz') obj1 = oldoby('xxxxxxxx')
特殊的参数：（self）self，形式参数，代指执行方法的对象。python内部传递
也就是说执行类中某一个方法，哪一个对象调用他，他就传递哪个对象！
obj = Foo()
obj.fetch('zz') ==> self:obj, backend:"zz"
obj1.fetch('xx') ==> self:obj1, backend:"xx"
类+括号 =》 自动执行类中的 __init__方法；创建了一个对象，在__init__方法中执行具体封装的操作
__init__ 有一个特殊名字：构造方法
__del__ 解释器销毁对象时候自动调用，特殊的名： 析构方法
从某处调用被封装的内容：
调用被封装的内容时，有两种情况：
- 通过对象直接调用
- 通过self间接调用
1、通过对象直接调用被封装的内容
上图展示了对象 obj1 和 obj2 在内存中保存的方式，根据保存格式可以如此调用被封装的内容：对象.属性名
class oldoby: def __init__(self,bk): self.bobo = bk foo = oldoby('xxxxxxxxx') print(foo.bobo) foo1 = oldoby('ssss') print(foo1.bobo)
class oldboy: def __init__(self,name,age): self.Name = name self.Age = age def ren(self): print(self.Name) print(self.Age) obj = oldboy('kaixin',20) obj.ren()
综上所述，对于面向对象的封装来说，其实就是使用构造方法将内容封装到 对象 中，然后通过对象直接或者self间接获取被封装的内容。
函数式编程 def jieshao(self,tian,qi,hao): print('%s,%s%s,%s,喝酒去'%(self,tian,qi,hao)) jieshao('今天','心情','好','走') 面向对象 class lianxi: def kaiche(self,name,arg,gender): print("%s,%s岁，%s ,开车去山沟" %(name,arg,gender)) obj = lianxi() obj.kaiche("老头",80,"男")
小明，18，体重 吃 加 20 减肥 减 10 喝 加 5 class Person: def __init__(self,name,age,zhong): self.Name = name self.Age = age self.Zhong = zhong def chi(self): self.Zhong = self.Zhong + 20 def jian(self): self.Zhong = self.Zhong - 10 def he(self): self.Zhong = self.Zhong + 5 doo = Person('小明',18,150) doo.chi() doo.jian() doo.jian() doo.he() print(doo.Name,doo.Age,doo.Zhong)
继承：面向对象中的继承和现实生活中的继承相同，即：子可以继承父的内容。
class Foo: def fun(self): print('xxxxxxxx') class XXX(Foo): def ccc(self): print(23212) obj = XXX() obj.fun() obj.ccc()
class Aii: def chi(self): print(self.name + '吃') class Bii(Aii): def __init__(self,name): self.name = name def chi(self): print(self.name + '叫') def jiao(self): print('爽歪歪') bb = Bii('小明真会') bb.chi() bb.jiao() 执行结果： 小明真会叫 爽歪歪 python
类可以同时继承多个类。而在（c#，Java）不可以
class Aii: def f1(self): print('Aii') class A(Aii): def f(self): print('A') class B(Aii): def f1(self): print('B') class C(A): def f1(self): print('C') class D(B): def f1(self): print('D') class E(C,D): def f(self): print('E') x = E() x.f1()
继承的执行顺序
从左到右去执行， 哪个类调用self就传值给那个类
方法从哪个调用的就执行哪个方法 class A: def bar(self): print('BAR') self.f1() class B(A): def f1(self): print('B') class C: def f1(self): print('C') class D(C,B): pass d1 = D() d1.bar()
python2.7 继承流程
当未继承object时（经典类）深度优先继承：
继承object（新式类） 顶部最后（广度优先）
class bar: #python2,7 #不继承一条道走到黑，继承新式类顶部最后 广度优先 def f1(self): print 'bar' class A(bar): def f(self): print 'a' class B(bar): def f1(self): print 'b' class C(A): def f(self): print 'c' class D(B): def f1(self): print 'd' class E(C,D): def f(self): print 'eeee' e = E() e.f1()
执行父类的构造方式：
super(当前类,self).init() 执行父类的构造方式 类后面加括号自动执行
父类.__init__(self,xxx) 数据的初始化
class A: def __init__(self): print('A构造方法') self.tu = '000动物000' class B(A): def __init__(self): print('B构造方法') self.n = '000猫000' super(B,self).__init__() super(当前类,self).init() b1 = B() b1.tu print(b1.__dict__)
三、多态 即是说多种形态
Pyhon不支持多态并且也用不到多态，多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”。
class F1: pass class S1(F1): def show(self): print ('S1.show') class S2(F1): def show(self): print( 'S2.show') # 由于在Java或C#中定义函数参数时，必须指定参数的类型 # 为了让Func函数既可以执行S1对象的show方法，又可以执行S2对象的show方法，所以，定义了一个S1和S2类的父类 # 而实际传入的参数是：S1对象和S2对象 def Func(F1 obj): """Func函数需要接收一个F1类型或者F1子类的类型""" print (obj.show()) s1_obj = S1() Func(s1_obj) # 在Func函数中传入S1类的对象 s1_obj，执行 S1 的show方法，结果：S1.show s2_obj = S2() Func(s2_obj) # 在Func函数中传入Ss类的对象 ss_obj，执行 Ss 的show方法，结果：S2.show
class F1: pass class S1(F1): def show(self): print 'S1.show' class S2(F1): def show(self): print 'S2.show' def Func(obj): print obj.show() s1_obj = S1() Func(s1_obj) s2_obj = S2() Func(s2_obj) Python “鸭子类型”
查找源码的 过程：
查找源码的方法 （self.xxx（）从底层开始找）从左到右
import socketserver #查找源码的过程 r = socketserver.ThreadingTCPServer() r.serve_forever()
