Python是面向对象语言，自然也就有面向对象的一些属性，类，继承，实例自然也就有了，具体不做了解，只需要针对其与其他语言如objective-C进行一些区别概述，找其不同点来学习。

类   ：描述具有相同的属性和方法的对象集合。定义了该集合中每个对象所共有的属性和方法。

对象  ：类的实例，通过类定义的数组结构实例化，包括两个数据成员（类变量和实例变量）和方法

变量：
    类变量     ：【与其他不同】类变量是在整个实例化的对象中公用的，定义在类中且在函数体外。类变量通常不作为实例变量使用。
    实例变量    ：定义在方法中的变量，只作用于当前实例的类。

方法  ：类中定义的函数

继承  ：继承一个基类的字段和方法

方法重写    ：【继承前提】父类中继承的方法不能满足子类的需求，可以对其进行改写，称为方法覆盖或是重写。

类创建

格式：

class Animal:
    'animal classf'

访问属性的方法：

getattr(obj,name[,default]) ：访问对象的属性

hasattr(obj,name)       ：是否存在某一属性 

setattr(obj,name,value) ：设置一个属性，如果属性不存在，会创建一个新属性 

delattr(obj,name)       ：删除属性【与其他语言区别】

例：

#!/usr/bin/python
# -*- coding:UTF-8 -*-
class Animal:
    'animal class' #__doc__ 返回值
    animalCount = 0

    def __init__(self,name):
        self.name = name
        Animal.animalCount += 1

    def count(self):
        print 'Total animal %d' % Animal.animalCount

    def display(self):
        print 'name:',self.name


#创建两个对象
dog = Animal('Dog')
cat = Animal('Cat')

#调用方法
dog.display()
cat.display()
dog.count()

#修改属性值&调用方式一
dog.name = 'Harri'   #can update attribute
dog.display()
print 'dog\'s name',dog.name

#修改属性值&调用方式二
setattr(cat,'name','Jeen')  #可自己去添加属性，类似于runtime中的属性挂载
print 'cat name :',getattr(cat,'name')


#删除name属性
delattr(dog,'name')
print 'has attr dog.name',hasattr(dog,'name')
#print dog.name #错误 提示无此属性
setattr(dog,'age','10')
print dog.age

Python内置属性

1. __dict__ :类调用，则返回类属性，对象调用则返回对象属性
#如：
>>>print '__dict__',Animal.__dict__

#输出
__dict__ {'count': <function count at 0x10b548758>, '__module__': '__main__', 'display': <function display at 0x10b548e60>, 'animalCount': 2, '__doc__': 'animal classf', '__init__': <function __init__ at 0x10b548140>}

>>>print '__dict__',dog.__dict__
#输出
__dict__ {'age': '10'}
2. __doc__      :【类或对象】文档字符串，无论类或属性均返回
#如：
print '__doc__',Animal.__doc__

#输出
__doc__ animal class
3. __name       : 【类】只能类调用，返回类名
#如：
print '__name__',Animal.__name__

#输出
__name__ Animal
4. __module__   :【类或对象】类定义所在模块，返回一致
#如：
print '__module__',Animal.__module__

#输出
__module__ __main__

注： 类的全名__main__.className,如果类位于一个导入模块module中，那么className.__module__等于module

5. __base__ :类的所有父元素构成的元组

Python的对象销毁

与OC一样，使用的是引用计数这一技术，参例：

a = 40  #创建对象
b = a   #增加40的引用
c = [b] #增加40引用

del a   #减少40引用
b = 100 #减少40引用
c[10]   #减少40引用  此时计数为0便由解释器在适当时机销毁，【不是立刻销毁】

类继承

语法：

class 派生类名（基类名）：  #基类名在括号中，基类是在类定义的时候，在元组中指明的。如果基类名比较多，则实现多继承
    ‘description’

继承特点：

1. 基类的构造方法（__init__()不会调用），它需要在其子类中主动调用
    2. 在调用基类时，需要加上基类的类名前缀，且需要带上self参数变量。【区别普通函数】
    3. 查找方法的流程：先从子类（派生类）中查找，找不到再去基类中找

例：

#!/usr/bin/python
# -*- coding:UTF-8 -*-
class Person:    #基类(父类)
    age = 0
    def __init__(self):
        print '调用父类构造方法'

    def personMethod(self):
        print '调用了父类方法'

    def setAge(self,age):
        Person.age = age

    def getAge(self):
        print '父类属性',Person.age


class Student(Person): #定义子类
    def __init__(self):     #注释掉此方法便会调用父类构造方法
        print '调用子类构造方法'
     #Person.__init__(self)     #只有这样才会调用父类构造方法，传参需要带上self


    def studentMethod(self):
        print '调用子类方法'


s = Student()
s.studentMethod()
s.personMethod()
s.getAge()
s.setAge(20)
s.getAge();

#输出：
调用子类构造方法
调用子类方法
调用了父类方法
父类属性 0
父类属性 20

判断继承关系

issubclass(sub,sup)     :判断是否为继承关系，并不只是一级继承
isinstance(obj,Class)   :判断是否为一个类或其子类的实例

方法重写：父类方法功能不够使用时

只需要在子类中定义与父类一样的方法名一样的参数即可；
如：

#!/usr/bin/python
# -*- coding:UTF-8 -*-
class Person:    #基类(父类)

    def printMethod(self):
        print '调用了父类方法'


class Student(Person): #定义子类

    def printMethod(self):
        print '调用子类方法',',展示更多信息'


s = Student()
s.printMethod()     #会直接调用子类方法

基础重载方法：
重写方法：

1. __init__(self[,args])    ：构造函数 调用时机 obj = className(args)
    2. __del__(self)        ：删除对象时 调用时机 del obj  或obj引用为0进
    3. __repr__(self)       ：转换为供解释器读取的方式   调用时机 repr(obj)
    4. __cmp__(self.x)      ：对象比较   调用时机cmp(obj,x)
    5. __add__(self.other)      ：运算符重载  调用时机 obj1 + obj2

例：

#!/usr/bin/python
# -*- coding:UTF-8 -*-
class Person:    #基类(父类)
    x = 10
    y = 20
    def printMethod(self):
        print '调用了父类方法'


class Student(Person): #定义子类

    def printMethod(self):
        print '调用子类方法',',展示更多信息'

    def __cmp__(self,other):
        return self.x - other.x

    def __add__(self,other):
        return self.x + other.x ,self.y + other.y

s = Student()
s2 = Student()
setattr(s2,'x',15)

print cmp(s,s2)     #比较
print repr(s)
print str(s2)
print s + s2    #重载运算符

可重写del方法探究

__del__     : 当对象不再被使用时，__del__方法执行

例：

#!/usr/bin/python
# -*- coding:UTF-8 -*-
class Demo:
    def __init__(self,x=0,y=0):
        self.x = x
        self.y = y

    def __del__(self):
        class_name = self.__class__.__name__
        print class_name, '销毁'

d1 = Demo()
d2 = d1
d3 = d1

print id(d1),id(d2),id(d3)
del d1
del d2
del d3

#输出
4561976640 4561976640 4561976640
Demo 销毁

补充

私有属性：
    __private_attrs     ：两个下划线开头，声明该属性为私有，不能在类外部(包括实例话对象)被使用或直接访问。在类内部调用方式：self.__private__attrs.

类方法： 在类的内部，使用def关键字可以为类定义一个方法，与一般函数定义不同，其必须包含一个参数self,且为第一个参数

私有方法：
    __private_method    ：两个下划线开头，声明方法为私有方法，不能在类外部调用，只能在内部调用 
方式： self.__private_methods()

-

注：
1. 类中声明的私有变量不能在实例化对象中使用，如需要使用，需要用obj._ClassName__attri，这样在实例对象中便可以使用，不推荐

2. 声明定义私有方法时需要添加self参数【类方法标志】，但调用时不可以传入self【只能在本类调用】

如：

#!/usr/bin/python
# -*- coding:UTF-8 -*-
class Person:    #基类(父类)
    x = 10
    y = 20

    def __sum(self,a,b):        #声明一个私有方法
        print a + b

    def printMethod(self):
        print '调用了父类方法'
        self.__sum(self.x,self.y)   #注意因为私有方法只能在本类中调用，所以第一个参数self已经被省略了【一定要注意】


class Student(Person): #定义子类

    def __init__(self,x = 20,y = 30):
        self.x = x
        self.y = y
        print '在子类中进行了初始化'

    def printMethod(self):
        print '调用了子类方法'
        Person.printMethod(self)


s = Student()
s.printMethod()

#输出
在子类中进行了初始化
调用了子类方法
调用了父类方法
50