面向对象编程

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

一、编程类型

面向过程编程：根据业务逻辑从上到下写垒代码，分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。

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

面向对象编程：对函数进行分类和封装，把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。

二、类和对象

面向对象编程需要使用 “类” 和 “对象” 来实现

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

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

class role(object):  #创建一个类，类名role，（object）新式类的写法
    ac = None
    def __init__(self,name,role,weapon,life_value=100):  #初始化函数，在生成一个角色时要初始化的一些属性就填写在这里
        self.name = name
        self.role = role
        self.weapon = weapon
        self.life_value = life_value
    def buy_weapon(self,weapon):
        print("%s is buying [%s]" %(self.name,weapon))
        self.weapon = weapon

p1 = role("nima",'police',"B11",90)  #创建对象，自动把参数传给Role下面的__init__(...)方法
t1 = role("nimei",'terrorist',"B10",100)  #生成一个角色，相当于 t1, role(t1,'nimei','terrorist','B10',100)
p1.buy_weapon("AK47")  #python 会自动帮你转成 role.buy_weapon(p1,”B21")
t1.buy_weapon("B51")

p1.ac = "china brand"
role.ac = "us brand"
print("p1:",p1.life_value,p1.ac)
print("t1:",t1.weapon,t1.ac)

__init__()叫做初始化方法(或构造方法)， 在类被调用时，这个方法(虽然它是函数形式，但在类中就不叫函数了,叫方法)会自动执行，进行一些初始化的动作，所以我们这里写的__init__(self,name,role,weapon,life_value=100)就是要在创建一个角色时给它设置这些属性

三、面向对象三大特性

1.封装

封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

将内容封装到某处

class foo:
    def __init__(self,name,age):
        self.name = name
        self.age = age

obj = foo('haha',22)  #将haha和22分别封装到obj的name和age属性中

调用被封装的内容

class foo:
    def __init__(self,name,age):
        self.name = name
        self.age = age

obj = foo('haha',22) 
print(obj.name)  #通过“对象.属性名”调用被封装的内容

class foo:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def detail(self):
        print(self.name)   #通过“self.name”调用被封装的内容
        print(self.age)

obj = foo('haha',22) 
obj.detail()

2.继承

继承可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

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

通过继承创建的新类称为“子类”或“派生类”，被继承的类称为“基类”、“父类”或“超类”，继承的过程，就是从一般到特殊的过程。

一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。

class SchoolMember(object):  #父类
    member_nums = 0
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
        self.enroll()

    def enroll(self):
        SchoolMember.member_nums +=1
        print("the [%s] SchoolMember [%s] is enrolled!" %(self.member_nums,self.name))

    def tell(self):
        print("hello my name is %s" %self.name)

class Teacher(SchoolMember):  #子类，继承父类
    def __init__(self,name,age,sex,course,salary):
        super(Teacher,self).__init__(name,age,sex)
        self.course = course
        self.salary = salary
        #SchoolMember.__init__(self,name,age,sex)  旧的写法
    def teaching(self):
        print("Teacher [%s] is teaching [%s]" %(self.name,self.course))

class Student(SchoolMember):
    def __init__(self,name,age,sex,course,tuition):
        super(Student,self).__init__(name,age,sex)  #继承
        self.course = course
        self.tuition = tuition
    def pay_tution(self):
        print("cao,student [%s] paying tution [%s]" %(self.name,self.tuition))

t1 = Teacher("haha",50,"男","PY",250)
t2 = Teacher("hehe",60,"女","PY",741)

s1 = Student("nima",24,"男","python",1000)
s2 = Student("nimei",23,"女","python",1200)
t1.tell()
t2.teaching()
s1.tell()
s2.pay_tution()

#输出结果
#the [1] SchoolMember [haha] is enrolled!
#the [2] SchoolMember [hehe] is enrolled!
#the [3] SchoolMember [nima] is enrolled!
#the [4] SchoolMember [nimei] is enrolled!
#hello my name is haha
#Teacher [hehe] is teaching [PY]
#hello my name is nima
#cao,student [nimei] paying tution [1200]

继承多个类

继承多个类，寻找方法的方式，深度优先和广度优先，Python3.0不管新式类还是经典类都是广度优先

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

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

class A:
    n = 'A'
    def f2(self):
        print("f2 from A")
class B(A): #继承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):  #多继承,先找B,C,A 广度优先
    '''test class'''
    def __del__(self):
        print("deleteing the...")

#经典类，深度优先，Python3.0不管新式类还是经典类都是广度优先

d = D()
d.f1()
d.f2()
print(d.__doc__) #打印类的介绍

from multi_inheritance import D

a = D()
print(a.__module__)  #打印从哪个文件导入

3.多态

多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。多态是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。

Pyhon不支持多态并且也用不到多态，多态的概念是应用于Java和C#这一类强类型语言中

class Animal:
    def __init__(self, name):    # Constructor of the class
        self.name = name
    def talk(self):              # Abstract method, defined by convention only
        raise NotImplementedError("Subclass must implement abstract method")

class Cat(Animal):
    def talk(self):
        return 'Meow!'

class Dog(Animal):
    def talk(self):
        return 'Woof! Woof!'

def animal_talk(obj):  #python不需要指定类型，所以没有多态
    print(obj.talk())  
#==========================================
c = Cat("nima")
d = Dog("nimei")
animal_talk(c)
animal_talk(d)

其他类型的语言

def animal_talk(万能类型,obj): #必须指定类型Dog或者Cat，使用万能类型为多态，接口重用
    print(obj.talk())
#==========================================
c = Cat("nima")
d = Dog("nimei")
animal_talk(c)
animal_talk(d)

四、类的方法与属性

1.类方法

class Animal:
    def __init__(self,name):
        self.name = name
    hobbie = "meat"

    @classmethod #类方法，不能访问实例变量
    def talk(self):
        print("%s is talking..." % self.name)  #不能访问实例变量name
        print("%s is talking..." % self.hobbie)  #类变量可以访问

d = Animal("yoyo")
d.talk() 

2.静态方法

class Animal:
    def __init__(self,name):
        self.name = name
    hobbie = "meat"

    @staticmethod  #静态方法，不能访问类变量及实例变量
    def walk(self):
        print(" %s is talking..." % self.hobbie)  #不可以

    def walk():
        print(" is talking..." )  #正确方法

d = Animal("yoyo")
d.walk()

 

3.属性

    @property  #把方法变成属性
    def habit(self):
        print("%s habit is football" %self.name)
d.habit  #调用

私有属性，属性的修改和删除

class Animal:
    def __init__(self,name):
        self.name = name
        self.__num = None  #私有属性    

    @property
    def total_players(self):
        return self.__num  #私有属性，只能在里面自己用，对外面隐藏

    @total_players.setter  #修改属性
    def total_players(self,num):
        self.__num = num
        print("total players:",self.__num)
    @total_players.deleter  #删除属性
    def total_players(self):
        print("total players got deleted.")
        del self.__num

d = Animal("yoyo")
print(d.total_players)  #None
d.total_players = 3  #赋值
print(d.__num) #无法访问私有属性
d.__num = 9  #外部修改为9，内部还是3
print(d.__num)
print("OUT:",d._Animal__num) #特例访问私有变量
print(d.total_players) #结果为3
del d.total_players  #删除属性

4.类的特殊成员

 

 (1)__doc__:显示类的描述信息

class Foo:
    """ test class """  #类的介绍
    def func(self):
        pass
print(d.__doc__) #打印类的介绍

(2)__module__:表示当前操作的对象在那个模块

from multi_inheritance import D

a = D()
print(a.__module__)  #打印从哪个文件导入

(3)__init__:构造方法，通过类创建对象时，自动触发执行

class Foo:

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

a = Foo("wu",22)

(4)__del__:析构方法，当对象在内存中被释放时，自动触发执行

    def __del__(self): 
        print("deleteing the...") 

(5)__call__:对象后面加括号，触发执行

class Foo:

    def __init__(self):
        pass
    
    def __call__(self, *args, **kwargs):

        print '__call__'


obj = Foo() # 执行 __init__
obj()       # 执行 __call__

(6)__dict__:获取类或对象中的所有成员

 class Foo:
     def __init__(self):
         print('__init__')
         self.n =4
print(obj.__dict__)  #以字典的形式显示，可以查看所有变量


MyShinyClass = type('MyShinyClass',(),{"test":123}) #一句话定义一个类
print(type(MyShinyClass))  #类是由type创建
a = MyShinyClass()
print(MyShinyClass.test)

五、反射

#反射.py
import sys
class WebServer(object):
    def __init__(self,host,port):
        self.host = host
        self.port = port

    def start(self):
        print("Server is starting...")
    def stop(self):
        print("Server is stopping...")
    def restart(self):
        self.stop()
        self.start()

if __name__ == "__main__":
    server = WebServer('localhost',333)

#传统解决方法
    cmd_dic = {
        'start':server.start,
        'stop':server.stop
    }

    if sys.argv[1] in cmd_dic:
        cmd_dic[sys.argv[1]]()

#输入python 反射.py restart
#输出Server is stopping...
#      Server is starting...

利用反射

import sys
class WebServer(object):
    def __init__(self,host,port):
        self.host = host
        self.port = port

    def start(self):
        print("Server is starting...")
    def stop(self):
        print("Server is stopping...")
    def restart(self):
        self.stop()
        self.start()

def test_run(name):
    print("running...",name)

if __name__ == "__main__":
    server = WebServer('localhost',333)
    #print(sys.argv[1])
    if hasattr(server,sys.argv[1]):  #判断
        func = getattr(server,sys.argv[1])  #获取server.start 内存地址
        func()  #server.start()

    setattr(server,'run',test_run)  #设置，把test_run添加到实例
    server.run("alex")

    delattr(server,'host')  #删除host
    delattr(WebServer,'start')  #删除start
    print(server.host)
    print(server.restart())