python -- 面向对象

Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。

在python中，一切皆对象。在学习python的面向对象程序设计之前，先来看看面向对象的基本特征。

面向对象技术简介

• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• 类变量：类变量属于类本身，不属于任何一个实例。实例可以访问其对应类的类变量，但不能修改。
• 成员变量：成员变量定义在类的构造方法里面，在实例化对象是生成，属于某个特定对象，不属于类。
• 方法重载：子类从父类继承的方法不满足子类的需要时，可以先重载，再继承，这样来进行扩展或修改。
• 继承：子类继承自父类，这样子类就能拥有从父类继承过来的东西。通常用子类来对父类进行扩展。(父类更多的是公同拥有的，子类就是进行个性化)
• 实例化：创建一个类的实例，类的具体对象。
• 方法：类中定义的函数。
• 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

面向对象思想

　　1、面向对象特点：封装、继承、多态
　　2、面向对象程序设计思想：
　　　　先整体构想，规划多个对象，再由对象特性分别设计类
　　　　由类实例化不同的对象
　　　　由多个对象组合完成整个程序
　　3、python中的子类可以继承多个父类(一般就1-2个，python3新式类、经典类继承都是广度优先，python2中新式类采用广度优先，经典类采用深度优先)
　　4、封装，继承都是为了代码重用
　　5、多态：(一个接口，多重实现)接口重用 （注：python自身不支持多态，但可以用代码实现类似效果）

Python中的面向对象

一、类的详解

　　

例如：
class Role(object):
    ac = None    #类的变量，随着类的创建，存在与内存中
    
    def __init__(self,name,role,weapon,life_value):
        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

在这个类里面，有一个类的变量ac，可以理解为静态变量，要修改ac的值，需要通过' Role.ac = xxx '，即 类名.类变量名

类变量与成员变量区别：
     1、类变量在定义类时就存在于内存中了，而成员变量只有在实例化时才被构造方法创造
     2、定义时，成员变量前面都有self，而类变量没有。因为self时指向的不同对象，而类变量只
        能由‘类名.类变量’来修改，可以通过‘对象.类变量’来访问，但是不能修改

类不能直接调用实例变量（实例变量存储在对象中，不在类中）
     
__init__() 是构造方法，在实例化对象时自动调用，就是用来初始化对象属性等

在实例化对象时，根据构造参数传递参数

定义类时，里面属性前面都有一个self，方法的第一个参数默认是self，这个self是指向实例化的对象，不是指向的类
    

内存详解：
    在类定义时，就在系统内存里面生成了一块内存来存放类的内容，包括 类变量、类方法 等
    即：类变量存储在类里面，类里面的方法也是存储在类这块内存里面的
    
    构造函数是在实例化对象才会调用，所以构造函数里面的属性都是存在于实例化的对象的内存里面(是特定对象的属性)

对象调用类的方法：
    在实例化对象时，并没有把类里面的方法都copy到对象内存空间里面，所以对象的内存空间里面只有属性，并没有方法
  方法都是存在于类的内存中(这样就算是实例化了无数个对象，方法在内存中还是只有类空间里面这一份，节约空间)
  方法都是类的方法，实例化对象在调用方法时，都会去类空间里面找。

　　类里面有共有属性和私有属性

'''
 私有属性：只能在类里面通过类自己的方法调用，对象不能直接调用(可以通过方法)
 要把一个属性变为私有属性，只需要在属性名前面加两个下划线'__'
 
 （特例，尽量别用）从外部直接访问私有变量方法： t._Human__life

'''

class Human(object):
    __num = 10
    def __init__(self,name):
        self.name = name
        self.__life = 100
        
    def interface1(self):
        print('血量 self.__life：',self.__life)
    
    def interface2(self):
        print('__num：',self.__num)
        
        
t = Human('Tom')
print(t.name)
#print(t.__life)
'''
builtins.AttributeError: 'Human' object has no attribute '__life'
因为__life 是对象里面的私有属性，在外部不能直接调用，但可以通过方法调用
'''
t.interface1()  #血量： 100
#print(Human.__num)
'''
builtins.AttributeError: type object 'Human' has no attribute '__num'
'''
t.interface2()

print("特例访问私有变量方法 t._Human__life ：",t._Human__life) 

　　类里面不常用的特殊方法

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

class A(object):
    '''Test class'''
    num = 10
    
    #类里面的__init__()是由__new__()触发执行的
    #def __new__(self):
        #print("=======new======")
    '''
    =======new======
    None
    报错：builtins.AttributeError: 'NoneType' object has no attribute '__module__'
    说明在这里重载__new__()方法后，没有再执行__init__()
    '''
    def __init__(self,name,age):
        self.name = name
        self.age = age
        print('__init__')
    
    def __call__(self):
        print("__call__")
    
    def test(self):
        print("=====test=====")
    #重载析构函数
    def __del__(self):
        print('deleting the ...')

a = A('root',20)
print(a.__doc__)   
'''
Test class
__doc__ 获取类的说明(即：注释)
在定义类的函数时，最好在注释里面对其作用、功能、参数等做个说明
'''
'''
__module__ 表示当前操作的对象或类在那个模块

__class__     表示当前操作的对象的类是什么
'''
print(a.__module__)
'''
__main__ 在这里代表的是当前模块。如果对象a在其他模块，则会打印a所在的模块名
'''
#import test.Human
from test import Human
#from test import h
h1 = Human()
#print(h.__module__)   #test
print(h1.__module__)   #test
print(h1.__class__)   #<class 'test.Human'>

#python中，析构函数是： __del__()   析构函数会自己在程序执行结束自动调用

'''
 __call__  对象后面加括号，触发执行。
注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；
而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
'''
#执行__call__ 方法
a()  #__call__
#A()()   #__call__

'''
 __dict__    只能显示对象中的所有成员变量，不能显示类变量

我们知道：实例变量(成员变量)属于对象；类中的静态变量和方法等属于类，
'''
print(a.__dict__)
'''
{'name': 'root', 'age': 20}
'''
print(type(a))   #<class '__main__.A'>
print(a)  #<__main__.A object at 0x000001BA3967D128>

#类是由'type'创造出来的
print(type(A))    #<class 'type'>

　　类的方法

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

'''
@classmethod  类方法装饰器（不能访问实例变量）
  作用：把装饰的方法变为类方法(相似于类变量，只能通过类来访问，对象不能访问类方法)

@staticmethod  静态方法装饰器（不能访问类变量和实例变量）
  作用：类的工具箱，与类直接相互独立，要调用类的东西只有传参（一般不用）
  
@property 类属性装饰器
  作用：把装饰的方法变为一个属性（能调用，不可执行）

'''
class Animal(object):
    hobbie = "meat"
    def __init__(self,name):
        self.name = name
        self.num = None
     
    @classmethod    #类方法，不能访问实例变量
    def talk(self):
        print('%s is talking...' %self.hobbie)    #可以直接调用，但不能修改
        #print('%s is talking...' %self.name)
    '''
    builtins.AttributeError: type object 'Animal' has no 
    attribute 'name'
    '''
     
    @staticmethod
    def walk(self):
        print('%s is walking...' %self.name)
    '''
    builtins.TypeError: walk() missing 1 required positional 
    argument: 'self'
    不知道self是谁，在调用时应该把self当参数传进来
    '''   
       
    @property
    def habit(self):
        print("%s habit is xxoo" %self.name)
    '''
    builtins.TypeError: 'NoneType' object is not callable
    ''' 
    
    #property 用法补充
    #1、直接调用(此时不能传值，否则报错)
    @property
    def total_player(self):
        print("this is a property")
        return self.num
    
    #2、经过1后，total_player变成了属性，因此可以用setter
    @total_player.setter
    def total_player(self,num):
        self.num = num
        print("self.num:",self.num)
        
    #3、相对于2可以给属性传值，那么也可以用删除属性值
    @total_player.deleter
    def total_player(self):
        print("total player got deleted")
        del self.num
    
d = Animal('zhaolin')
d.talk()
d.walk(d)
d.habit
#1：
d.total_player
#2：
d.total_player = 20
#3:
del d.total_player    #用deleter时，要这样调用

'''
meat is talking...
zhaolin is walking...
zhaolin habit is xxoo

this is a property
self.num: 20
total player got deleted

'''

   

二、类的使用

　　继承：由一般(很多类都具有的共性)到特殊(不同的类有不同的特性)

  子类继承父类时，构造方法需要 【先重写，再继承】

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

'''
继承：由一般(很多类都具有的共性)到特殊(不同的类有不同的特性)

子类继承父类时，构造方法需要 【先重写，再继承】
'''

class SchoolMember(object):
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
        self.enroll()
        
    def enroll(self):
        print('[%s] was enrolled!' %self.name)
        
    def tell(self):
        print('[%s] is telling!' %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
    
    def teaching(self):
        print('Teacher [%s] is teaching [%s]' %(self.name,self.course))
        
    def get_salary(self):
        print('Teacher [%s] is saving salary [%s]' %(self.name,self.salary))
        
class Student(SchoolMember):
    student_nums = 0
    def __init__(self, name, age, sex,course,tuition):   #先重写
        super(Student,self).__init__(name,age,sex)     #再继承
        self.course = course
        self.tuition = tuition
        Student.student_nums += 1
    
    def enroll(self):            
        #super(Student,self).enroll()   #在子类里面重写enroll()，不继承    
        print('The [%s] student [%s] is enrolled!' %(self.student_nums,self.name))
        #这里可以用self.student_nums，是因为只是访问student_nums，而没有修改它
        
    def studying(self):
        print('Student [%s] is studying!' %self.name)
    
    def pay_tuition(self):
        print('The tuition of Student [%s] is [%s]' %(self.name,self.tuition))
 
#实例化对象        
t1 = Teacher('txowner', 22, 'male', 'python', 3000)
t2 = Teacher('xtsec', 24, 'male', 'php', 2500)
'''
实例化对象的过程：
    eg：t2 = Teacher('xtsec', 24, 'male', 'php', 2500)
        1、t2 = Teacher() 在内存中开辟一块内存，让t2指向该内存
        2、Teacher(t2)  把t2这块内存与类Teacher相关联(这也是为什么self是指向对象的而不是类)
        3、把各个参数传递给类的构造方法，在对象t2空间里面创建各个成员变量
        
'''

s1 = Student('root', 20, 'male', 'python', 15000)
s2 = Student('lucy', 18, 'female', 'php', 12000)

t1.teaching()
t2.teaching()
s1.studying()
s2.studying()
print('t1老师的salary：',t1.salary)
print('s2同学的tuition：',s2.tuition)

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

'''先实验老式类（经典类）的写法'''

#class A(object):   #新式类
class A:   #经典类
    def f2(self):
        print('f2 from A')

class B(A):
    def f1(self):
        print('f1 from B')
        
    def f2(self):
        print('f2 from B')
        
class C(A):
    def f2(self):
        print('f2 from C')
        
class D(B,C):
    pass

d = D()
d.f1()
d.f2()
'''
f1 from B
f2 from B

由以上结果可知：在多继承时，若多个父类都有相同方法或属性，则按照广度优先方式继承
即：继承父类的方法时，若都有相同方法名的方法，则按照继承时的顺序从左至右继承一个
'''
'''
在python2.x版本：

    深度优先：同一条线上优先，比如上面如果按照深度优先的话，D在调用f2时，先去找
父类B，如果B里
面没有f2，那么D就会去调用A里面的f2，而不会调用C里面的f2，老式类就是这样

    广度优先：同一水平层次优先，比如上面如果按照广度优先的话，D在调用f2时，先去找
父类B，如果B里面没有f2，那么D就会去调用C里面的f2，而不会调用A里面的f2，新式类就是
这样

在python3.x版本：
    不管是新式类还是经典类，在继承时，都采用广度优先
'''

　　python实现多态调用

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

'''
python没有多态。多态是java、c#、c++这类强类型语言特有的

python可以利用函数等方式来实现多态现象。

'''
class Animal(object):
    def __init__(self):
        print('Animal Class')
    
    def talk(self):
        pass

class Dog(Animal):
    def __init__(self):
        print('Dog Class')
        
    def talk(self):
        return ('woof!woof!') 
        
class Cat(Animal):
    def __init__(self):
        print('Cat Class')    
    
    def talk(self):
        return ('muaao~')
        
dog = Dog()
cat = Cat()
dog.talk()
cat.talk()

#利用函数实现统一接口
def animal_talk(obj):
    print(obj.talk())
    
animal_talk(dog)
print('=====')
animal_talk(cat)

三、反射的妙用

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

'''
反射是非常非常重要的！
反射的作用：通过一个字符串来去调用一个对象中名字跟字符串值相同的方法(属性)的内存地址
'''

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 stoped...")
    def restart(self):
        self.stop()
        self.start()
        
def test_run(ins,name):
    print("test_run",name,ins.host)
    
        
if __name__ == '__main__':
    #print(sys.argv[0],sys.argv[1])
    '''
    sys.argv是一个获取文件名后面参数的数组，sys.argv[0]是当前文件路径，
    后面依次为传递的参数
    '''
    server = WebServer('localhost', 8080)
    if hasattr(server, sys.argv[1]): 
    #if hasattr(WebServer, sys.argv[1]):   #对象或类名都可以   
        func = getattr(server,sys.argv[1])   #得到对象server中名字与传入字符串相等的函数(方法)
        func()
    else:
        print("your input incorrect!")    
     
    #server1 = WebServer('localhost1', 80)
    #setattr(server1,'run',test_run)
    #server1.run(server1,'admin')
    
    #delattr(server1,'port')
    #print(server1.port)   
    #AttributeError: 'WebServer' object has no attribute 'port'
    
    '''
    以下的obj可以是类，也可以是实例化的对象
    
    hasattr(obj,attr)  判断对象中有没有指定属性(方法)
    
    getattr(obj,attr)  获取对象中的属性(方法)的内存地址
    
    setattr(obj,attr,method)  把方法(属性)method添加到对象中，并改名为attr
        通过对象调用method：obj.attr
       
        这样把方法(属性)添加到对象中与原生方法区别：
          不会自动把self传进去，若要调用obj原生属性，只有先把obj当成参数传进去
    
    delattr(obj,attr)  把对象obj里面的attr属性(方法)删除掉
         注意：因为实例化对象的方法是存在于类中，对象只是能访问类中的方法，不能
           更改，但是对象可以更改自己的成员变量。所以这里的attr是对象自身的属性
           或方法，不是类里面的。
         
         可以通过delattr(classname,attr)来删除类的属性(方法)
    
    '''
    '''
    #方式比较low
    cmd_dict = {
        'start':server.start,
        'stop':server.stop,
        'restart':server.restart
    }
    if sys.argv[1] in cmd_dict:
        cmd_dict[sys.argv[1]]()
    else:
        print("your input incorrect!")
   
    '''