面向对象初级

面向对象编程是一种编程方式，此编程方式的落地需要使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用。

　　类就是一个模板，模板里可以包含多个函数，函数里实现一些功能

　　对象则是根据模板创建的实例，通过实例对象可以执行类中的函数

• 面向对象编程不是所有的情况都适用 
• 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()