面向对象编程中级篇：
| 编程思想概述： |
面向过程：根据业务逻辑从上到下写垒代码 #最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("睡觉")
cat and 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("睡觉") class 动物: def eat(self):
print("吃") def play(self):
print("玩") def sleep(self):
print("睡觉") # 在类后面括号中写入另外一个类的名称，表示当前类继承另外一个类
class 猫(动物)： def 喵喵叫(self):
print('喵喵叫') # 在类后面括号中写入另外一个类的名称，表示当前类继承另外一个类
class 狗(动物)： def 汪汪叫(self):
print('喵喵叫')
cat and dog-->继承
代码实例：
#/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() 执行结果：
小猫 吃
小猫 玩
二狗子 吃
二狗子 睡觉
cat and dog-->代码实例
所以，对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法。
注：除了子类和父类的称谓，你可能看到过 派生类 和 基类 ，他们与子类和父类只是叫法不同而已。
那么问题又来了，多继承呢？
- 是否可以继承多个类
- 如果继承的多个类每个类中都定了相同的函数，那么那一个会被使用呢？
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
复制代码
Python伪代码实现Java或C#的多态
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 “鸭子类型”
以上就是本节对于面向对象初级知识的介绍，总结如下：
- 面向对象是一种编程方式，此编程方式的实现是基于对 类 和 对象 的使用
- 类 是一个模板，模板中包装了多个“函数”供使用
- 对象，根据模板创建的实例（即：对象），实例用于调用被包装在类中的函数
- 面向对象三大特性：封装、继承和多态
二：类成员属性及方法：
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,"外部访问隐藏变量")