python面向对象编程综合运用_Python 第六篇(中)：面向对象编程中级篇

面向对象编程中级篇：

编程思想概述：

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

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

defadd(hostname,port,username,password,dbname)#连接数据库

#操作

#端口

defremove(hostname,port,username,password,dbname)#连接数据库

#操作

#端口

defcreate(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 -*-

classFoo:def __init__(self,hostname,port,username,password,dbname): #叫构造函数或构造方法

self.hostname =hostname

self.port=port

self.username=username

self.dbname=dbnamedefadd(self):#连接数据库 self.hostname,self.port

#操作

#端口

defremove(self):#连接数据库

#操作

#端口

defcreate(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 -*-

classcat(object)：defmiaomiao(self):print("喵喵叫")defeat(self):print("吃")defplay(self):print("玩")defsleep(self):print("睡觉")classdog(object)：defwangwang(self):print("汪汪叫")defeat(self):print("吃")defplay(self):print("玩")defsleep(self):print("睡觉")

cat and dog

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

动物：吃、玩、睡觉

猫：喵喵叫(猫继承动物的功能)

狗：汪汪叫(狗继承动物的功能)

如下：

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

classcat(object)：defmiaomiao(self):print("喵喵叫")defeat(self):print("吃")defplay(self):print("玩")defsleep(self):print("睡觉")classdog(object)：defwangwang(self):print("汪汪叫")defeat(self):print("吃")defplay(self):print("玩")defsleep(self):print("睡觉")class动物:defeat(self):print("吃")defplay(self):print("玩")defsleep(self):print("睡觉")#在类后面括号中写入另外一个类的名称，表示当前类继承另外一个类

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

class狗(动物)：def汪汪叫(self):print('喵喵叫')

cat and dog-->继承

代码实例：

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

classAnimal(object):defeat(self):print("%s 吃" %self.name)defploy(self):print("%s 玩" %self.name)defsleep(self):print("%s 睡觉" %self.name)class Cat(Animal): #只要继承动物的类，就有了Animal的所有功能，比如吃、玩、睡觉

def __init__(self, name):

self.name=name

self.breed= '猫'

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

def __init__(self, name):

self.name=name

self.breed= '狗'

defcry(self):print('汪汪叫')

c1= Cat('小猫')

c1.eat()

c1.ploy()

d1= Dog('二狗子')

d1.eat()

d1.sleep()

执行结果：

小猫 吃

小猫 玩

二狗子 吃

二狗子 睡觉

cat and dog-->代码实例

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

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

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

是否可以继承多个类

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

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

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

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

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

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

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

defbar(self):print("from D")classC(D):defbar(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中找

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

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

pass

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

passa=A() #A继承了B和C，B和C都继承了D，而D是新式类，所以A是新式类

a.bar()#1、执行a.bar()方法，向上找有此方法的类

执行结果：

from C

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

Pyhon不支持多态并且也用不到多态，多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”。

classF1:pass

classS1(F1):defshow(self):print 'S1.show'

classS2(F1):defshow(self):print 'S2.show'

#由于在Java或C#中定义函数参数时，必须指定参数的类型#为了让Func函数既可以执行S1对象的show方法，又可以执行S2对象的show方法，所以，定义了一个S1和S2类的父类#而实际传入的参数是：S1对象和S2对象

defFunc(F1 obj):"""Func函数需要接收一个F1类型或者F1子类的类型"""

printobj.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

复制代码

Python伪代码实现Java或C#的多态

classF1:pass

classS1(F1):defshow(self):print 'S1.show'

classS2(F1):defshow(self):print 'S2.show'

defFunc(obj):printobj.show()

s1_obj=S1()

Func(s1_obj)

s2_obj=S2()

Func(s2_obj)

Python “鸭子类型”

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

面向对象是一种编程方式，此编程方式的实现是基于对 类 和 对象 的使用

类 是一个模板，模板中包装了多个“函数”供使用

对象，根据模板创建的实例(即：对象)，实例用于调用被包装在类中的函数

面向对象三大特性：封装、继承和多态

二：类成员属性及方法：

1、成员的分类：

a.字段

普通字段

静态字段

b.方法(方法都保存在类里面)

普通方法，触发者是对象，参数是至少一个self，self=当前对象

类方法，触发者是类，参数只有一个cls，自动复制，cls=当前类

静态方法，触发者是类，参数可以是是任意参数，没有默认值

c.属性：是方法的一个变种，变成访问时跟字段相似

有两种方法定义:

一是使用装饰器@property

二是使用 Date=property(funcname)

新式类的属性：

@property

@方法名.setter

@方法名.deleter

2、代码表示：

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

classA(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#类属性，调用的时候不需要加括号

defbar1(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.bar1print(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

classFoo(object):

val= 1 #类变量，静态字段

def __init__(self,name): #构造函数

self.name = name #类属性，普通字段

defprint_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，不能加其他的参数，由类触发，执行的时候把类自身当作参数传递给类方法

classFoo(object):

val= 1

def __init__(self,name):

self.name=name

@classmethod#类方法

defprint_func(self,age):print("xxx")print(age)

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

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

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

classFoo():

name= "jack" #前面加俩下划线表示是隐藏的变量

__name1 = "tom"

def __init__(self,age):

self.age=age

@staticmethoddeffunc(name):print(name)

Foo.func("jack")

执行结果：

jack

总结：

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

普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；

类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；

静态方法：由类调用；无默认参数；

classFoo:def __init__(self, name):

self.name=namedeford_func(self):"""定义普通方法，至少有一个self参数"""

#print self.name

print('普通方法')

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

print('类方法')

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

print('静态方法')#调用普通方法

f = Foo("jack")

f.ord_func()#调用类方法

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

Foo.static_func()

方法的定义和使用

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

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

三、属性

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

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

属性的基本使用

属性的两种定义方式

1、属性的基本使用

################ 定义 ###############

classFoo:deffunc(self):pass

#定义属性

@propertydefprop(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 去数据库中请求数据

################ 定义 ###############

classPager:def __init__(self, current_page):#用户当前请求的页码(第一页、第二页...)

self.current_page =current_page#每页默认显示10条数据

self.per_items = 10@propertydefstart(self):

val= (self.current_page - 1) *self.per_itemsreturnval

@propertydefend(self):

val= self.current_page *self.per_itemsreturnval################ 调用 ###############

p= Pager(1)

p.start#就是起始值，即：m

p.end #就是结束值，即：n#复制代码

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

为什么要有属性：

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

2、属性的两种定义方式

属性的定义有两种方式：

装饰器 即：在方法上应用装饰器

静态字段 即：在类中定义值为property对象的静态字段

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

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

经典类，具有一种@property装饰器(如上一步实例)################ 定义 ###############

classGoods:

@propertydefprice(self):return "wupeiqi"

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

obj =Goods()

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

新式类，具有三种@property装饰器：################ 定义 ###############

classGoods(object):

@propertydefprice(self):print '@property'@price.setterdefprice(self, value):print '@price.setter'@price.deleterdefprice(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修饰的方法

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

classGoods(object):def __init__(self):#原价

self.original_price = 100

#折扣

self.discount = 0.8@propertydefprice(self):#实际价格 = 原价 * 折扣

new_price = self.original_price *self.discountreturnnew_price

@price.setterdefprice(self, value):

self.original_price=value

@price.deltterdefprice(self, value):delself.original_price

obj=Goods()

obj.price#获取商品价格

obj.price = 200 #修改商品原价

del obj.price #删除商品原价

获取、修改、删除

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

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

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

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

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

aaa =Foo()

aaa.func()

aaa.func1

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

公有和私有对比：

classFoo():

name= "jack" #公有变量

__name1 = "tom" #前面加俩下划线是隐藏的变量

def __init__(self,age):

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

@property#将方法变为类属性

deffunc1(self):print(self.__name1,"#将函数变为类属性并访问隐藏的变量")print(self.name,"访问公有变量")print(self.age,"访问构造函数的变量")

aaa= Foo(18)

aaa.func()

aaa.func1#类属性执行的时候不需要加括号

执行结果：

jack#通过函数访问隐藏变量

18 #通过函数访问构造函数的变量

tom #通过类直接访问公有变量

tom #将函数变为类属性并访问隐藏的变量

jack #访问公有变量

18 #访问构造函数的变量

外部访问隐藏变量：

classFoo():

name= "jack" #前面加俩下划线表示是隐藏的变量

__name1 = "tom"

def __init__(self,age):

self.age=agedeffunc(self):print(self.age)

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