Python 第六篇(中)：面向对象编程中级篇

面向对象编程中级篇：

编程思想概述：

面向过程：根据业务逻辑从上到下写垒代码  #最low，淘汰

函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可 #混口饭吃

def add(hostname,port,username,password,dbname)
    #连接数据库
    #操作
    #端口
    
def remove(hostname,port,username,password,dbname)
    #连接数据库
    #操作
    #端口
    
def create(hostname,port,username,password,dbname)
    #连接数据库
    #操作
    #端口

#在调用的时候每次都要传递主机信息给函数调用，比较麻烦
create("127.0.0.",3306,123456,"testdb")
remove("127.0.0.",3306,123456,"testdb")
add("127.0.0.",3306,123456,"testdb")

面向对象：对函数进行分类和封装，让开发“更快更好更强...” #最高境界

java和C#只能用面向对象写，没有函数式编程，只能用类，而python、ruby、PHP则可以选择面向对象和函数方式编程，python先有函数式编程，后有了类，

假如要写一个程序连接数据库进行增删改查，那么使用面向对象编程大概过程为：

#/usr/bin/env  python
# -*- coding:utf-8 -*-

class Foo:
    def __init__(self,hostname,port,username,password,dbname):  #叫构造函数或构造方法
        self.hostname = hostname
        self.port = port 
        self.username = username
        self.dbname = dbname
        
    def add(self):
        #连接数据库 self.hostname,self.port
        #操作
        #端口
    
    def remove(self):
        #连接数据库
        #操作
        #端口
    
    def create(self):
        #连接数据库
        #操作
        #端口

obj = Foo(hostname,port,username,password,dbname)
obj.add()

一、类的三大特性：封装、继承、多态：

 

1、三大特性之封装：将共同的类属性封装在类内部，使用的时候直接调用

类的内部详细执行过程为：

 

面向对象根据一个模板创建多个对象，将共同的变量封装起来，在使用的时候进行调用就行了

使用场景：

1，动态的创建对象，每个对象都有相同的属性，就要使用到模板，可以批量创建多个对象，传递不用的参数，简单有效。

2，多个方法共用一个字段的时候，可以将字段封装调用。

总结：

封装的作用：将一些共同的类属性封装到内存地址当中，比如封装在构造函数__init__，python解释器是从上向下执行，构造函数把所以的参数保到self里面，谁将类实例化self就是谁，

__init__: 是构造函数或构造方法

class Foo:  #定义类
    def __init__(self,name): #构造函数
        self.name = name  #类属性

    def func1(self): #类方法
        print(self.name)

obj1 = Foo("jack") #类的实例化，传递的参数会被构造函数__init__()接收
obj1.func1() #调用类方法

 

2、类的三大特性之特性之继承：

继承，面向对象中的继承和现实生活中的继承相同，即：子可以继承父的内容。

python的的类可以继承两个或以上的多个类，即python的类支持多继承，其它语言不支持多继承，

例如：创建cat和dog两个类，共有的属性为吃和叫，如果不使用继承则要创建两个类来实现各自的功能，如下所示：

#/usr/bin/env  python
# -*- coding:utf-8 -*-

class cat(object)：

    def miaomiao(self):
        print("喵喵叫")

    def eat(self):
        print("吃")
        
    def play(self):
        print("玩")
    
    def sleep(self):
        print("睡觉")

class dog(object)：

    def wangwang(self):
        print("汪汪叫")

    def eat(self):
        print("吃")
        
    def play(self):
        print("玩")
        
    def sleep(self):
        print("睡觉")

上述代码不难看出，吃、玩、睡觉是猫和狗都具有的功能，而我们却分别的猫和狗的类中编写了两次。如果使用 继承 的思想，如下实现：

　　动物：吃、玩、睡觉

　　   猫：喵喵叫（猫继承动物的功能）

　　   狗：汪汪叫（狗继承动物的功能）

如下：

#/usr/bin/env  python
# -*- coding:utf-8 -*-

class cat(object)：

    def miaomiao(self):
        print("喵喵叫")

    def eat(self):
        print("吃")

    def play(self):
        print("玩")

    def sleep(self):
        print("睡觉")

class dog(object)：

    def wangwang(self):
        print("汪汪叫")

    def eat(self):
        print("吃")

    def play(self):
        print("玩")

    def sleep(self):
        print("睡觉")
        
class 动物:

    def eat(self):
        print("吃")

    def play(self):
        print("玩")

    def sleep(self):
        print("睡觉")

# 在类后面括号中写入另外一个类的名称，表示当前类继承另外一个类
class 猫(动物)：

    def 喵喵叫(self):
        print('喵喵叫')
        
# 在类后面括号中写入另外一个类的名称，表示当前类继承另外一个类
class 狗(动物)：

    def 汪汪叫(self):
        print('喵喵叫')

代码实例：

#/usr/bin/env  python
# -*- coding:utf-8 -*-

class Animal(object):

    def eat(self):
        print("%s 吃 " %self.name)

    def ploy(self):
        print("%s 玩 " %self.name)

    def sleep(self):
        print("%s 睡觉 " %self.name)

class Cat(Animal):  #只要继承动物的类，就有了Animal的所有功能，比如吃、玩、睡觉
    def __init__(self, name):
        self.name = name
        self.breed = '猫'

    def cry(self):
        print('喵喵叫')

class Dog(Animal): #只要继承动物的类，就有了Animal的所有功能，比如吃、玩、睡觉

    def __init__(self, name):
        self.name = name
        self.breed = '狗'

    def cry(self):
        print('汪汪叫')

c1 = Cat('小猫')
c1.eat()
c1.ploy()

d1 = Dog('二狗子')
d1.eat()
d1.sleep()

执行结果：
小猫 吃 
小猫 玩 
二狗子 吃 
二狗子 睡觉 

所以，对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法。

注：除了子类和父类的称谓，你可能看到过 派生类 和 基类 ，他们与子类和父类只是叫法不同而已。

那么问题又来了，多继承呢？

• 是否可以继承多个类
• 如果继承的多个类每个类中都定了相同的函数，那么那一个会被使用呢？

1、Python的类可以继承多个类，Java和C#中则只能继承一个类

2、Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先

经典类继承的时候深度优先：

即继承的类如果有指定的方法就返回，没有继续找，如果遇到的类本身没有，但是其有继承了别的类，则也去别的类当中查找，直到别的类返回有或者没有，在决定是返回结果还是继续在别的类当找：

#/usr/bin/env  python
# -*- coding:utf-8 -*-

class D(): #4.在类D中有bar方法，所以最终的结果就是D中的bar的执行结果
    def bar(self):
        print("from D")

class C(D): 
    def bar(self):
        print("from C")

class B(D): #3.B类自己没有bar方法，但是类B还继承了类D，因此还要去类D中查找
    pass

class A(B,C): #2.A自己没有bar方法，但是类A继承于B和C，经典类会先去B中找
    pass

a = A()
a.bar() #1.执行a.bar()方法，向上找有此方法的类，a是类A的实例，因此先找到A

执行结果：
from D

新式类继承的时候 广度优先，就是那个离目标最近，就先找谁，不会优先在另外一个类的继承类中查找：

判断一个类是不是新式类，就判断此类是否继承了object类，不管此类是直接继承了object还是通过继承别的类继承object类，有点绕，就是这个类继承的别的类有object类，则这个类也是新式类：

#/usr/bin/env  python
# -*- coding:utf-8 -*-

class D(object): #
    def bar(self):
        print("from D")

class C(D): #4、从A当中找到了C，C中有bar方法，因此就是最终的结果，如果C中没有，就还去B的继承类D中找,本次D是最后一层了
    def bar(self):
        print("from C")

class B(D): #3、B类自己没有bar方法，新式类就不在往有继承的深层次找了，而是找另外的继承
    pass

class A(B,C): #2、A继承于B和C，经典类会先去B中找，B中没有找到，但是新式类不会去B继承的类中找，而去在自己继承的其他类当中找
    pass

a = A() #A继承了B和C，B和C都继承了D，而D是新式类，所以A是新式类
a.bar() #1、执行a.bar()方法，向上找有此方法的类

执行结果：
from C

 3、类的三大特性之多态：

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) 

以上就是本节对于面向对象初级知识的介绍，总结如下：

• 面向对象是一种编程方式，此编程方式的实现是基于对 类 和 对象 的使用
• 类 是一个模板，模板中包装了多个“函数”供使用
• 对象，根据模板创建的实例（即：对象），实例用于调用被包装在类中的函数
• 面向对象三大特性：封装、继承和多态

 

二：类成员属性及方法：

1、成员的分类：

a.字段
        普通字段
        静态字段
        
b.方法（方法都保存在类里面）
        普通方法，触发者是对象，参数是至少一个self，self = 当前对象
        类方法，触发者是类，参数只有一个cls，自动复制，cls = 当前类
        静态方法，触发者是类，参数可以是是任意参数，没有默认值
        
c.属性：是方法的一个变种，变成访问时跟字段相似
        有两种方法定义:
        一是使用装饰器@property
        二是使用 Date = property（funcname）
新式类的属性：
        @property
        @方法名.setter
        @方法名.deleter

2、代码表示：

#/usr/bin/env  python
# -*- coding:utf-8 -*-

class A(object):
    num = 10 #类变量，静态字段，只在类里面保存一份，所有的对象都访问同一份的数据
    def __init__(self,name):
        self.name = name #类属性，普通字段，动态字段，保存在对象里面，即在实例化的时候的对象里面，如：a=A(),则就在a里面

    def bar(self): #类方法，在调用的时候要是要括号
        print("name is %s，age is %s" %(self.name,self.num))

    @property #类属性，调用的时候不需要加括号
    def bar1(self):
        print("name is %s，age is %s" %(self.name,self.num))
a =  A("jack")
a.bar() #调用类方法
a.bar1 #调用类属性

b = A("tom")
b.bar()
b.bar1

print(id(a.num),"a.num")
print(id(b.num),"查看b,num和a.num是否同一内存地址的数据，很明显是，因为num保存在类中，内存中只有一份，什么人任何时候读取都是一样的")

print(id(a.name),"a.name")
print(id(b.name),"查看b.name和a.name是否同一个地址的数据，很明显不是，因为们是保存在对象当中，但是对象传古来的数据肯定不能是完全一样的")

访问类类属性(普通字段)的方法：实例名.类属性，如a.name

访问类变量(静态字段)的方法： 类名.变量名，如A.num

 

3、普通方法：普通方法可以有任意参数，至少有一个self形参，由对象调用

普通方法（也就是类里面的函数），self是形式参数，对象要执行类里面的普通方法的时候，首先是由对象触发的，对象执行方法的时候自动把对象自己当作参数赋值给了方法里面的self

 

class Foo(object):
    val = 1  #类变量，静态字段
    def __init__(self,name): #构造函数
        self.name = name #类属性，普通字段

    def print_func(self):
        print(self.name) #调用类属性
        print(self.val,"print_func调用")
        
if __name__ == '__main__':
    foo = Foo("jack")  #实例化类并传递参数
    print(foo.val) #通过类调用类变量
    a = Foo("jack") 
    a.print_func() #通过对象调用类方法

 4、类方法（@classmethod）：使用@classmethod装饰一个方法，就不能写self了，要写cls，

类方法只能有一个参数并且只能是cls，不能加其他的参数，由类触发，执行的时候把类自身当作参数传递给类方法

class Foo(object):
    val = 1 
    def __init__(self,name):
        self.name = name

    @classmethod #类方法
    def print_func(self,age):
        print("xxx")
        print(age)


Foo.print_func(12) #执行类方法并传递参数

5、静态方法：可以加任意参数，执行的时候直接传参数就行了，即可以连self都没有，由类调用， 不创建任何对象就可以访问，等于直接访问函数，

类方法和静态方法是特殊的方法，类方法只能有一个cls参数，静态方法可以有多个参数

class Foo():
    name = "jack"  #前面加俩下划线表示是隐藏的变量
    __name1 = "tom"
    def __init__(self,age):
        self.age = age

    @staticmethod
    def func(name):
        print(name)


Foo.func("jack")

执行结果：
jack

 

总结：

方法包括：普通方法、静态方法和类方法，三种方法在内存中都归属于类，区别在于调用方式不同。

• 普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；
• 类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；
• 静态方法：由类调用；无默认参数；

class Foo:

    def __init__(self, name):
        self.name = name

    def ord_func(self):
        """ 定义普通方法，至少有一个self参数 """

        # print self.name
        print('普通方法')

    @classmethod
    def class_func(cls):
        """ 定义类方法，至少有一个cls参数 """

        print('类方法')

    @staticmethod
    def static_func():
        """ 定义静态方法 ，无默认参数"""

        print('静态方法')


# 调用普通方法
f = Foo("jack")
f.ord_func()

# 调用类方法
Foo.class_func()

# 调用静态方法
Foo.static_func()

相同点：对于所有的方法而言，均属于类（非对象）中，所以，在内存中也只保存一份。

不同点：方法调用者不同、调用方法时自动传入的参数不同。

三、属性　　

如果已经了解Python类中的方法，那么属性就非常简单了，因为Python中的属性其实是普通方法的变种。

对于属性，有以下三个知识点：

• 属性的基本使用
• 属性的两种定义方式

1、属性的基本使用

# ############### 定义 ###############
class Foo:

    def func(self):
        pass

    # 定义属性
    @property
    def prop(self):
        pass
# ############### 调用 ###############
foo_obj = Foo()

foo_obj.func()
foo_obj.prop   #调用属性

由属性的定义和调用要注意一下几点：

• 定义时，在普通方法的基础上添加 @property 装饰器；
• 定义时，属性仅有一个self参数
• 调用时，无需括号
             方法：foo_obj.func()
             属性：foo_obj.prop

注意：属性存在意义是：访问属性时可以制造出和访问字段完全相同的假象

        属性由方法变种而来，如果Python中没有属性，方法完全可以代替其功能。

实例：对于主机列表页面，每次请求不可能把数据库中的所有内容都显示到页面上，而是通过分页的功能局部显示，所以在向数据库中请求数据时就要显示的指定获取从第m条到第n条的所有数据（即：limit m,n），这个分页的功能包括：

• 根据用户请求的当前页和总数据条数计算出 m 和 n
• 根据m 和 n 去数据库中请求数据 

# ############### 定义 ###############
class Pager:

    def __init__(self, current_page):
        # 用户当前请求的页码（第一页、第二页...）
        self.current_page = current_page
        # 每页默认显示10条数据
        self.per_items = 10


    @property
    def start(self):
        val = (self.current_page - 1) * self.per_items
        return val

    @property
    def end(self):
        val = self.current_page * self.per_items
        return val

# ############### 调用 ###############

p = Pager(1)
p.start #就是起始值，即：m
p.end   #就是结束值，即：n
#复制代码

从上述可见，Python的属性的功能是：属性内部进行一系列的逻辑计算，最终将计算结果返回

 

为什么要有属性：

1、把方法伪造成字段，从而是外界不知道这是一个函数

 

2、属性的两种定义方式

属性的定义有两种方式：

• 装饰器 即：在方法上应用装饰器
• 静态字段 即：在类中定义值为property对象的静态字段

装饰器方式：在类的普通方法上应用@property装饰器

我们知道Python中的类有经典类和新式类，新式类的属性比经典类的属性丰富。（ 如果类继object，那么该类是新式类 ）

经典类，具有一种@property装饰器（如上一步实例）

# ############### 定义 ###############    
class Goods:

    @property
    def price(self):
        return "wupeiqi"
# ############### 调用 ###############
obj = Goods()
result = obj.price  # 自动执行 @property 修饰的 price 方法，并获取方法的返回值


新式类，具有三种@property装饰器：
# ############### 定义 ###############
class Goods(object):

    @property
    def price(self):
        print '@property'

    @price.setter
    def price(self, value):
        print '@price.setter'

    @price.deleter
    def price(self):
        print '@price.deleter'

# ############### 调用 ###############
obj = Goods()

obj.price          # 自动执行 @property 修饰的 price 方法，并获取方法的返回值

obj.price = 123    # 自动执行 @price.setter 修饰的 price 方法，并将  123 赋值给方法的参数

del obj.price      # 自动执行 @price.deleter 修饰的 price 方法

注：经典类中的属性只有一种访问方式，其对应被 @property 修饰的方法
      新式类中的属性有三种访问方式，并分别对应了三个被@property、@方法名.setter、@方法名.deleter修饰的方法

由于新式类中具有三种访问方式，我们可以根据他们几个属性的访问特点，分别将三个方法定义为对同一个属性：获取、修改、删除

class Goods(object):

    def __init__(self):
        # 原价
        self.original_price = 100
        # 折扣
        self.discount = 0.8

    @property
    def price(self):
        # 实际价格 = 原价 * 折扣
        new_price = self.original_price * self.discount
        return new_price

    @price.setter
    def price(self, value):
        self.original_price = value

    @price.deltter
    def price(self, value):
        del self.original_price

obj = Goods()
obj.price         # 获取商品价格
obj.price = 200   # 修改商品原价
del obj.price     # 删除商品原价

 

公有变量和私有变量(公有字段和私有字段)：

私有：只能自己访问，其他无法访问

class Foo():
    __name = "jack"  #前面加俩下划线表示是隐藏的变量

    def func(self):
        print(self.__name) #通过函数访问隐藏变量，访问的时候同样要加双下划线

    @property
    def func1(self):
        print(self.__name) #将函数变为类属性并访问因此的变量，访问的时候同样要加上双下划线
aaa = Foo()
aaa.func()
aaa.func1

公有：即公共可以访问的变量

公有和私有对比：

class Foo():
    name = "jack"  #公有变量
    __name1 = "tom" #前面加俩下划线是隐藏的变量
    def __init__(self,age):
        self.age = age

    def func(self):
        print(self.name,"#通过函数访问隐藏变量")
        print(self.age,"通过函数访问构造函数的变量")
        print(Foo.__name1,"通过类直接访问公有变量")

    @property #将方法变为类属性
    def func1(self):
        print(self.__name1,"#将函数变为类属性并访问隐藏的变量")
        print(self.name,"访问公有变量")
        print(self.age,"访问构造函数的变量")
aaa = Foo(18)
aaa.func()
aaa.func1 #类属性执行的时候不需要加括号

执行结果：
jack #通过函数访问隐藏变量
18 #通过函数访问构造函数的变量
tom #通过类直接访问公有变量
tom #将函数变为类属性并访问隐藏的变量
jack #访问公有变量
18 #访问构造函数的变量

外部访问隐藏变量：

class Foo():
    name = "jack"  #前面加俩下划线表示是隐藏的变量
    __name1 = "tom"
    def __init__(self,age):
        self.age = age

    def func(self):
        print(self.age)

aaa = Foo(18)
print(aaa.name,"外部访问公有变量")
print(aaa._Foo__name1,"外部访问隐藏变量")