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

面向：过程、函数、对象：

面向过程：根据业务逻辑从上到下写垒代码！

面向过程的编程弊：每次调用的时候都的重写，代码特别长，代码重用性没有，每次增加新功能所有的代码都的修改！那有什么办法解决上面出现的弊端呢？函数就出现了。

面向函数：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可！

函数解释：
函数可以理解为一个一个的功能块，你把一个大的功能拆分成一块一块的，用某项功能的时候就去调用某个功能块即可！
函数可以理解为：乐高积木，给你一块一块的，你可以用这些积木块组成你想要的任何，功能！
函数可以调用函数！主函数的作用就是把函数进行串联、调用！函数本身是不能自己执行的如果你不调用就永不执行！

面向对象：更简单的重用代码！

什么是面向对象编程呢？就是所有的代码都是通过类和对象来实现的就是面向对象编程！

创建类和对象：

面向对象编程（Object Oriented Programming，OOP，面向对象程序设计）

Java和C#来说只支持面向对象编程，而python比较灵活即支持面向对象编程也支持函数式编程

所有语言的特性都是：封装、继承、多态（多态在python中体现的不是很好）

面向对象编程是一种编程方式：通过“类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用。

通过两个例子来看下：

例子一：

##方式一
#函数
def Bar():  #定义函数
    print("Bar") #函数要执行的动作
def Hello(name):
        print('i am %s' %name)

Bar() #调用函数
Hello("tom") #调用函数时传递参数,参数的数量要和函数定义的时候的数量一致

#方式二
# 创建类
class Foo: #创建经典类
    def Bar(self): #类里的函数
        print("Bar")
    def Hello(self, name):
        print('I am %s' %name)
a = Foo() #实例化类
a.Bar() #调用类的函数
a.Hello("jack") #调用类函数时传递参数

那个简单？肯定是第一个简单为什么？不是说类的会更简单点吗？因为咱们类的东西还没有使用到！

在没学会，封装和继承的时候，方式一是简单的！

例子二：

以数据库为例：

数据库的常用操作有：增、删、改、查

增、删、改、查是不是可以用函数写成四个方法：

def fetch():

def modify():

def remove():

def create()

#我假设要添加一个值create函数里是不是的有：
#连接数据库 hostname,prot,username,password,dbname
#我是不是的保存这么多东西进行连接啊！连接之后是不是的打开数据库
#连接数据库 hostname,prot,username,password,dbname
#打开
#操作
#关闭

那添加需吗？修改需要吗？查找需要吗？都需要那么看下实际的函数式编程的效果：

def fetch(hostname,prot,username,password,dbname ,arg ):
    #连接数据库 hostname,prot,username,password,dbname
    #打开
    #操作
    #关闭
def modify(hostname,prot,username,password,dbname ,arg ):
    #连接数据库 hostname,prot,username,password,dbname
    #打开
    #操作
    #关闭
def remove(hostname,prot,username,password,dbname ,arg ):
    #连接数据库 hostname,prot,username,password,dbname
    #打开
    #操作
    #关闭
def create(hostname,prot,username,password,dbname ,arg)
    #连接数据库 hostname,prot,username,password,dbname
    #打开
    #操作
    #关闭

每一个函数里都包含了一些字段！你都给他参数化，这些是不是都的加到参数里边，你执行的时候都的给他传参数进去！
fetch (hostname,prot,username,password,dbname ,[11,22,33,44])
modify (hostname,prot,username,password,dbname ,[11,22,33,44])
creremove ate(hostname,prot,username,password,dbname ,[11,22,33,44])
crcreate eate(hostname,prot,username,password,dbname ,[11,22,33,44])

每次操作的时候是不是都的给他写一遍！

上面的方法是通过函数来实现的，那么看下，下面的例子通过面向对象来实现：

class Db_contrl(object):
    def __init__(self,hostname,port,username,password,dbname): #__init__ 是构造方法，在实例化的时候执行，调用的时候传递给类Db_cotrl的实参会传递给__init__调用
        self.hostname = hostname
        self.port = port
        self.username = username
        self.password = password
        self.dbname = dbname

    def fetch(self):
        #连接数据库self.hostname,self.port,self.username,self.password,self.dbname
        #打开
        #操作
        #关闭
    def modify(self):
        #连接数据库self.hostname,self.port,self.username,self.password,self.dbname
        #打开
        #操作
        #关闭
    def create(self):
        #连接数据库self.hostname,self.port,self.username,self.password,self.dbname
        #打开
        #操作
        #关闭
    def remove(self):
        #连接数据库self.hostname,self.port,self.username,self.password,self.dbname
        #打开
        #操作
        #关闭
obj1 = Db_contrl('1,1,1,1',80,'jack','123456','testdb') #实例化类，并传递参数

obj1.fetch() #通过类调用函数，执行不同的类函数即类的方法，
obj1.modify()
obj1.create()
obj1.remove()

我现在在去调用的类里的方法的时候还需要去传参数吗？已经不需要了，因为python面向对象的最主要的就是封装！

那么这些参数封装在那里呢？

obj1 = Db_contrl('1,1,1,1',80,'jack','123456','testdb') 在实例化的时候我就把这些参数传给类了，他封装到了self中

如下图：

比如：boj1在调用一个create方法的时候，在obj1的这个对象里面不仅存储这个对象的参数，还有一个隐藏的参数叫做“类对象指针”，

他的作用就是告诉对象，去那里找方法！想想一下如果没有这个类对象指针，对象知道是那个模板创建的他吗？不知道的！

并且对象里是没有方法的方法是存储在类中的！如上图方法里每个都有：self   意思就是：obj1调用就是等于 def create(obj1) !!!

相比函数式编程，我是是不是每次调用的时候就没必要传一大堆参数了？

看完上面的例子就的想到：如果在一些方法里共同使用了一组变量，如果这时候使用函数式编程，每次调用方法的时候都的传这些参数！

这时候就要想到使用面向对象：把这些变量封装到对象中，每次调用的时候直接传这个对象即可！

例子三：

如果有有一个游戏，我要创建角色用函数怎么创建？是不是的写很多函数来实现很麻烦看下我的代码！

#!/usr/bin/env python
#coding:utf-8
#author Zhang Shijie

class Game_pmodel(object):
    def __init__(self,name,profession,attack=0,blood=0,speed=0): #__init__构造函数，名字和职业等信息
        self.name = name   #定义普通字段
        self.profession = profession #定义普通字段
        self.attack = attack
        self.blood = blood
        self.speed = speed

    def supershuai(self):
        self.blood = int(self.blood) + 1000
        self.attack = int(self.attack) + 1000
        self.speed = int(self.speed) + 1000
        print("\033[32;1m呼叫及时当前血量：%s 当前攻击为：%s，当前速度为：%s" % (self.blood,self.attack,self.speed))
    def add_attack(self):
        self.attack = int(self.attack) +300
        print("\033[32;1m您当前的攻击力为%s\033[0m" % self.attack)
    def aspirine(self):
        self.blood = int(self.blood) + 300
        print("\033[32;1m您当前的血量为%s\033[0m" % self.blood)
    def detail(self):
        """注释：当前对象的详细情况"""
        temp = "角色:%s ; 职业:%s ; 战斗力:%s ; 血量:%s ; 速度:%s"  % (self.name, self.profession, self.attack, self.blood,self.speed)
        print(temp)
user1 = Game_pmodel("jack","法师","","","")  #将类实例化并传递参数
user1.detail() #调用类方法
user1.supershuai()
user1.add_attack()
user1.aspirine()

我在创建一个角色的时候：= obj1 = Game_pmodel('角色名称','职业',攻击,'血量','速度')

那么现在看下！现在创建了一个实实在在的角色，他有自己的名字、职业、攻击、血量、速度、。如果要用函数写，好麻烦吧！

总结：动态的创建一个东西，创建的时候的要依据某一个模板，当你在动态的创建某一类东西的时候，就的用面向对象！

继承：

继承非常简单，举个例子来说，现在写了一个类，有一些角色的模板了，我可以根据这个角色的模板创建不通的角色，现在我有个需求，我要单独在写一个战士的模板，在上面写的那个类里的东西，很多重复的可以使用的，我是不是可以使用呢？难道我还需要重新写一遍吗？python这里提供了一个简单的方法“继承”！之前说过python的面向对象，就是让你更好的去重用你的代码！

class Game_pmodel(object):
    def __init__(self,name,profession,attack=0,blood=0,speed=0): #__init__构造函数，名字和职业等信息
        self.name = name   #定义普通字段
        self.profession = profession #定义普通字段
        self.attack = attack
        self.blood = blood
        self.speed = speed

    def supershuai(self):
        self.blood = int(self.blood) + 1000
        self.attack = int(self.attack) + 1000
        self.speed = int(self.speed) + 1000
        print("\033[32;1m呼叫及时当前血量：%s 当前攻击为：%s，当前速度为：%s" % (self.blood,self.attack,self.speed))
    def add_attack(self):
        self.attack = int(self.attack) +300
        print("\033[32;1m您当前的攻击力为%s\033[0m" % self.attack)
    def aspirine(self):
        self.blood = int(self.blood) + 300
        print("\033[32;1m%s当前的血量为%s\033[0m" % (self.name,self.blood))
    def detail(self):
        """注释：当前对象的详细情况"""
        temp = "角色:%s ; 职业:%s ; 战斗力:%s ; 血量:%s ; 速度:%s"  % (self.name, self.profession, self.attack, self.blood,self.speed)
        print(temp)

class Game_pmodel2(Game_pmodel):
    def weapon(self):
        self.attack = int(self.attack) + 1000
        print("\033[32;1m%s拿起武器攻击力+1000,您现在的攻击力是:%s \033[0m"  % (self.name,self.attack))

user1 = Game_pmodel("jack","法师","","","")
user1.aspirine()

user2 = Game_pmodel2("tom","法师","","","")
user2.weapon()

在第二个类里面：Warrior，我并没有设置attack字段，那是那里来呢！class Warrior(Game_pmodel):  在这里继承了基类的字段和，方法如下:

我通过战士的这个类，实例化了一个角色，但是我并在这里并没有add_attack() 那里来的呢？就是继承来的，so 这个就是继承！

在这里有个点需要提下，“经典类”、“新式类” ，还有他的多继承！（Python的类可以继承多个类，Java和C#中则只能继承一个类） 

上面的截图！有（object）就是新式类，有什么区别！新式类，有些修改和新增了一些功能，以后建议使用“新式类”，因为新式类以后可能会增加一些功能。

这里需要提的一点是在多继承的时候的问题：

不管是直接、或间接的继承新式类，那么你的类也是新式类！

当类是经典类时，多继承情况下，会按照深度优先方式查找
当类是新式类时，多继承情况下，会按照广度优先方式查找

#经典类:广度优先,python 2是深度优先，python是广度优先：

import  time
class A:  #经典类
    n = "A"
    def f2(self):
        print("f2 from A")
class B(A):
    n = "B"
    def f1(self):
        print("from B")
    #def f2(self):
    #    print("f2 from B")
class C(A):
    n = "C"
    def f2(self):
        print("from C")
class D(B,C):
    pass
d = D()
d.f2()
d.f2()
time.sleep(1)

python2执行结果：

f2 from A
f2 from A

python 3执行结果：

from C
from C

#新式类:深度优先,python 3全部是广度优先

import  time

class A(object):
    n = "A"
    def f2(self):
        print("f2 from A")
class B(A):
    n = "B"
    def f1(self):
        print("from B")
    #def f2(self):
    #    print("f2 from B")

class C(A):
    n = "C"
    def f2(self):
        print("from C")
class D(B,C):
    pass

d = D()
d.f2()
d.f2()
time.sleep(1)

python2执行结果：

from C
from C

python3执行结果：

from C
from C

总结：

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

类 是一个模板，模板中包装了多个“函数”供使用
对象，根据模板创建的实例（即：对象），实例用于调用被包装在类中的函数
面向对象三大特性：封装、继承和多态（多态在python体现的不是很好）

函数式编程 和 面向对象 如何选择？分别在什么情况下使用？

对于 C# 和 Java 程序员来说不存在这个问题，因为该两门语言只支持面向对象编程（不支持函数式编程）。而对于 Python 和 PHP 等语言却同时支持两种编程方式，且函数式编程能完成的操作，面向对象都可以实现；而面向对象的能完成的操作，函数式编程不行（函数式编程无法实现面向对象 的封装功能）。

所以，一般在Python开发中，全部使用面向对象 或 面向对象和函数式混合使用

 

1、isinstance:判断某个实例释放由某个类创建的(或理解为对象是否类的实例，类可是创建对象的类，也可以是创建对象的类的基类)，程序依赖于程序的输入，将用户输入的类型做分门别类的操作，返回True或False：

 

class ClassA(object):
    pass
    C = 'xxx'
A = ClassA()
B = "a"
C = "syring"
print(isinstance(A, ClassA),"判断A是否ClassA类创建的类型,返回True")
print(isinstance(B, ClassA),"判断B是否ClassA类创建的类型,返回False")
print(isinstance(B, list),"判断B是否由list类创建的类型")
print(isinstance(C, str),"判断C是否有str类创建的类型")
print(isinstance(C, (int, str, list)),"判断C是否有int，str和list创建的类型")

执行结果：
True 判断A是否ClassA类创建的类型,返回True
False 判断B是否ClassA类创建的类型,返回False
False 判断B是否由list类创建的类型
True 判断C是否有str类创建的类型
True 判断C是否有int，str和list创建的类型

2.判断某一个类是否另一个类的派生类(即子类):

class Class1(object): #Class1是Class2的基类
    pass
class Class2(Class1,object): #Class2是Class1的派生类
    pass
class Class3(object):
    pass
print(issubclass(Class2,Class1),"Class2是Class1的派生(字)类")
print(issubclass(Class3,Class1),"Class3不是Class1的派生(字)类")

执行结果：
True Class2是Class1的派生(字)类
False Class3不是Class1的派生(字)类