python面向对象

class类：是对一类拥有相同属性的对象，在类中定义了这些对象的都具备的属性（variables(data)）、共同的方法

object 对象：对象是类的实例化，类实例化后可以被程序调用，一个类可以实例化多个对象，当然每个对象也可以有不同的属性。

特性：

Encapsulation封装：

在类中对数据赋值、内部调用对用户来说是透明的，用户是看不类里面的程序逻辑，类在实例化对象时是有些程序需要封装的。

Inheritance 继承：

一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承。

Polymorphism 多态：

一个接口，多种实现。基类中派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对父类的方法做了不同的实现，这就是同一种事物表现出的多种形态。

class Dog(object): #类在实例化时__init__函数中的变量在实例化后的对象指定的内存中存储，但是类中的其他方法则是在实例化对象后创建。除__init__以外的方法都是存在类定义时的内存空间中。
    dog_n=xiao   #dog_n称为类变量  ，存储在类开辟的内存空间中。
    def __init__(self,name,dog_type):  #self代表赋值对象本身
        self.name = name  #name 称为实例变量、静态属性
        self.type = dog_type       #对象跟着一个__init__函数，用来设置对象的属性，
 
    def sayhi(self): #sayhi()称为类的方法、动态属性。普通方法在任何一个对象中都是一样的，对象调用普通方法时其实是调用同一个类指定内存中的方法。
 
        print("hello,I am a dog, my name is ",self.name)

　　r1=Dog(xy,ww)   #r1称为Dog的实例。

类变量和实例变量重名时，想找实例变量，没有实例变量的再找类变量。

（1）.实例变量操作：

增加：在使用时直接对新的实例变量赋值就可以。  r1.num=5

删除：del r1.num

修改：r1.name='xiao'

查：对象中可以查类变量。

（2）类变量操作：

在一个对象中对类变量进行修改，不影响其他对象中使用类变量的值，类变量在其他对象中是不变的。

因为，在对象中修改类变量的值相当于在该对象的内存中创建了一个新的变量，和类变量是不同变量。

使用类名修改类变量，Dog.dog_n 对没有与类变量相同的对象有影响，与类变量相同的实例变量所在的对象是没有影响的。

类变量的用途：结束空间。

（3）析构函数：在实例释放、销毁的时候执行的，进行收尾工作，当对象被删除时，会自动被调用。比如：在关闭连接数据库时打开的临时文件。

     创建对象后，python解释器默认调用__init__()方法。当删除一个对象时，python解释器也会默认调用一个方法，这个方法为__del__()方法。在python中，对于开发者来说很少会直接销毁对象(如果需要，应该使用del关键字销毁)。Python的内存管理机制能够很好的胜任这份工作。也就是说,不管是手动调用del还是由python自动回收都会触发__del__方法执行:

    当一个对象赋值给多个变量时，执行删除对象操作，是在执行删除所有变量后，才将内存中的空间释放（删除变量后，最后执行__del__函数）  

import time
class Animal(object):
 
    # 初始化方法
    # 创建完对象后会自动被调用
    def __init__(self, name):
        print('__init__方法被调用')
        self.__name = name
 
 
    # 析构方法
    # 当对象被删除时，会自动被调用
    def __del__(self):
        print("__del__方法被调用")
        print("%s对象马上被干掉了..."%self.__name)
 
# 创建对象
dog = Animal("哈皮狗")
 
# 删除对象
del dog
 
 
cat = Animal("波斯猫")
cat2 = cat
cat3 = cat
 
print("---马上 删除cat对象")
del cat
print("---马上 删除cat2对象")
del cat2
print("---马上 删除cat3对象")
del cat3
 
print("程序2秒钟后结束")
time.sleep(2)

对象结束自动触发__del__方法：

import time
class Animal(object): 
    # 初始化方法
    # 创建完对象后会自动被调用
    def __init__(self, name):
        print('__init__方法被调用')
        self.__name = name 
    # 析构方法
    # 当对象被删除时，会自动被调用
    def __del__(self):
        print("__del__方法被调用")
        print("%s对象马上被干掉了..."%self.__name)
# 创建对象
dog = Animal("哈皮狗")
cat = Animal("猫")

结果为：

__init__方法被调用
__init__方法被调用
__del__方法被调用
哈皮狗对象马上被干掉了...
__del__方法被调用
猫对象马上被干掉了...

（4）在类定义中的静态变量（属性）的前面添加__将变为私有变量（隐藏该变量），在对象中无法直接使用该属性：

import time
class Animal(object): 
    def __init__(self, name,age):
        print('__init__方法被调用')
        self.__name = name 
        self.__age=age
    def syage(self):
        print 'age:%s'%self.__age
    def __del__(self):
         print("__del__方法被调用")
         print("%s对象马上被干掉了..."%self.__name)
dog = Animal("哈皮狗",'23')
cat = Animal("猫",'12')
print dog.__age


结果提示：AttributeError: 'Animal' object has no attribute '__age'

　对应私有变量需要在类中定义函数实现外面的功能，私有变量只能内部使用，不能外部使用。

import time
class Animal(object): 
    def __init__(self, name,age):
        print('__init__方法被调用')
        self.__name = name 
        self.__age=age
    def syage(self):
        print 'age:%s'%self.__age
    def __del__(self):
         print("__del__方法被调用")
         print("%s对象马上被干掉了..."%self.__name)
dog = Animal("哈皮狗",'23')
cat = Animal("猫",'12')
#print dog.__age
dog.syage()



结果：age:23

　（5）私有方法和私有变量一样需要在方法名的前面添加两个下化线__　

封装：

重构属性：

class abc:
    def __init__(self,a,b,c=5):
        self.a=a
        self.b=b
        self.c=c
    def eg(self):
        print self.a
class fgh(abc):
    def __init__(self,a,b,c,d):#在继承的子类中重构父类的属性，必须添加新增的参数
        abc.__init__(self,a,b,c=5)  #与父类中的参数一样
        self.d=10     #

继承：

py2经典类是按深度优先来继承的，新式类是按广度优先来继承的。

py3经典类和新式类都是按统一优先来继承的。

多态：

同一个接口多种形态。

多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。