Python
看下面一个简单类：
>>> class MyClass(object):
... """
... this is a class with a doc string
... """
... pass
...
>>> print MyClass.__doc__ this is a class with a doc string
实例化一个类和函数调用的语法是一样的：
>>> myClass = MyClass()
类属性是类的所有对象所共享的属性，它与C++中的static属性类似：
>>> class MyClass(object):
... """
... this is a class with a doc string
... """
... str = 'this is a class attribute'
...
>>> print MyClass.str
this is a class attribute
>>> a,b = MyClass(), MyClass()
>>> id(a.str)
25889584
>>> id(b.str)
25889584
实例属性是每个对象独有的属性，每个对象的实例属性的值都可能不同：
>>> class MyClass(object):
... ClassData = 'This is a Class Attribute'
...
>>> obj1, obj2 = MyClass(), MyClass()
>>> obj1.NewData, obj2.NewData = 'New Data of obj1', 'New Data of obj2'
>>> id(obj1.NewData)
29413928
>>> id(obj2.NewData)
29413968
>>>
Python中，对象的属性是可以动态增加的。
类的所有对象，都可以读取类属性；
但类属性不能通过对象修改，在修改时，Python会自动为对象创建一个实例属性，并屏蔽掉类属性。
>>> obj1.ClassData = 'Change obj1\'s ClassDate'
>>> print obj1.ClassData
Change obj1's ClassDate
>>> print MyClass.ClassData
This is a Class Attribute
>>> print obj2.ClassData
This is a Class Attribute
>>> del obj1.ClassData
>>> print obj1.ClassData
This is a Class Attribute
类方法是通过类名就可以直接调用的方法，与C++中的static方法类型，函数的第一个参数为类本身，约定俗成将参数命名为cls：
>>> class ClassWithClassMethod(object):
... @classmethod
... def classFunc(cls):
... print 'This is a class method:',id(ClassWithClassMethod),id(cls)
...
>>> ClassWithClassMethod.classFunc()
This is a class method: 29525656 29525656
实例方法是必须通过对象调用的方法，方法的第一个参数是对象本身，约定俗成将参数命名为self：
>>> ClassWithObjMethod.objFunc()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unbound method objFunc() must be called with ClassWithObjMethod instance as first argument (got nothing instead)
>>>
>>> obj = ClassWithObjMethod()
>>> obj.objFunc()
This is a obj method: 29392080
>>> id(obj)
29392080
>>>
Python中，也可以对构造了析构的行为进行定义：
__init__会在对象构造时调用，通常会在这里进行为对象的属性赋值等初始化动作。在__init__中，必须显示的调用父类的__init__方法。
super(type, obj)返回父对象，这行代码也可以用object.__init__(self)替代。
__del__是在对象被Python垃圾回收时调用，因为垃圾回收是由Python控制，所以通常不会重写__del__方法。
>>> class CtorAndDest(object):
... def __init__(self,val):
... super(CtorAndDest, self).__init__()
... self.data = val
... print 'construct an object'
... def __del__(self):
... print 'destroy an object'
...
>>> obj = CtorAndDest(100)
construct an object
>>> obj.data
100
>>> del obj
destroy an object
封装、继承、多态是面向对象的三个基本要素，通过继承可以让我们在子类中重用父类的属性、方法。
Python支持多继承，多个父类间以逗号分隔。如果子类不重写__init__方法，在构造时会自动调用父类的__init__。
>>> class ParentClass(object):
... def __init__(self):
... self.data = 100
... print 'ParentClass constructor'
... def fonc(self):
... print 'Parent function'
...
>>> class AnotherParentClass(object):
... def func(self):
... print 'another parent function'
...
>>> class ChildClass(ParentClass, AnotherParentClass):
... pass
...
>>>
>>>
>>> obj = ChildClass()
ParentClass constructor
>>> obj.fonc()
Parent function
>>> obj.func()
another parent function
>>> obj.data
100
类或对象中的数据，通常需要有不同的作用域。面向对象开发时不建议由客户直接访问对象的数据，而是由对象提供的方法进行访问，以便对象数据在修改时不影响客户代码。
Python对没有像提供C++一样的public/protected/private关键字，不过可以通过下划线的使用达到一定的可见性控制。
不以下划线开关的普通属性，相当于C++中的public，所有对象都可以访问。双下划线__开头的属性，代表是私有属性，无法被其它对象访问。
>>> class VisibleClass(object):
... def __init__(self):
... super(VisibleClass, self).__init__()
... self.publicData = 'This is public data'
... self.__privateData = 'This is private data'
...
>>> class SubClass(VisibleClass):
... def func(self):
... print self.publicData,self.__privateData
...
>>> vobj = VisibleClass()
>>> vobj.publicData
'This is public data'
>>> vobj.__privateData
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'VisibleClass' object has no attribute '__privateData'
>>>
>>> obj = SubClass()
>>> obj.func()
This is public data
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 3, in func
AttributeError: 'SubClass' object has no attribute '_SubClass__privateData'
>>>
所谓多态，可以简单理解为子类使用与父类相同的接口，但提供不同的功能。通过在子类中重写父类中定义的方法，可以实现多态。
>>> class SortClass(object):
... def sort(self,lst):
... pass
...
>>> class SwapSortClass(SortClass):
... def sort(self,lst):
... print 'This is Swap sort'
...
>>> class QuickSortClass(SortClass):
... def sort(self,lst):
... print 'This is quick sort'
...
>>> def sort(lst, algo = SwapSortClass()):
... return algo.sort(lst)
...
>>> sort([1,3,2])
This is Swap sort
>>> sort([1,3,2], QuickSortClass())
This is quick sort
>>>
在上例中，由SortClass定义sort接口，子类中重写对应的方法提供不同的排序算法。在sort函数中，可以直接通过指定不同的参数使用不同的算法，而不需要修改sort函数的实现，代码可扩展性更强。
因为Python是弱类型的语言，所以上例中Sort类并不是必须的，实际不需要通过子类重写，只要传入的对象提供了相同的接口就可以达到相同的目的。
内置函数dir()可以查看对象/模块的属性列表，对象的__dict__则显示对象的所有属性及属性的值（等价于内置函数vars）：
通过__dict__的例子可以看到，对象的所有属性及值是以dict的形式保存在对象的__dict__属性中的，而不是像C++一样，对象的所有属性是在内存中连续分布的。带来的好处是可以为对象动态的增加和删除属性，并可以通过名字方便的访问这些属性；坏处是会占用更大的内存，不过可以通过__slots__使对象属性固定下来，并减小内存占用。
>>> obj = DictClass()
>>> import sys
>>> sys.getsizeof(obj)
32
>>> obj.a = 1
>>> sys.getsizeof(obj)
32
>>> obj.__dict__['b'] = 2
>>> obj.a
1
>>> obj.b
2
>>>
注意：不要像例子中一样通过__dict__访问对象的属性！
>>> class SlotsClass(object):
... __slots__ = ()
...
>>> import sys
>>> sys.getsizeof(SlotsClass())
getattr可以获取一个对象的某个属性的值，如果属性不存在，可以返回一个给定的默认值；
setattr用来设置对象属性的值，属性不存在时会为对象增加属性；
delattr用来删除对象的属性。
hasattr用来判断对象是否存在某个属性。
这四个方法事实上都是通过操作对象的__dict__来进行的。
Isinstance方法可以用来确定一个对象是不是一个类或它的子类的实例：
还可以使用type(obj) is Type进行判断，此方法对于obj是Type的子类的实例的情况将返回False。
Issubclass用来判断一个类是否是另一个类的子类，包括直接子类或间接子类。
>>> isinstance(0,int)
True
>>> isinstance(True,bool)
True
>>> bool.__bases__
(<type 'int'>,)
>>> obj = QuickSortClass()
>>> isinstance(obj,QuickSortClass)
True
>>> isinstance(obj,SortClass)
True
>>> type(obj) is QuickSortClass
True
>>> type(obj) is SortClass
False
>>>
>>> issubclass(bool,int)
True
>>> issubclass(type,object)
True
>>> issubclass(str,object)
True
>>> issubclass(SwapSortClass,SortClass)
True
>>> SwapSortClass.__bases__
(<class '__main__.SortClass'>,)
>>>
Python为对象提供了一系统的方法重载，以改变对象在执行某此操作时的行为。下面提供了一个简单的示例，展示了如何使对象支持+, +=, <, if判断等操作。
可以在《Python核心编程》等资料中找到Python支持的特殊方法的全集。
数据描述符：（类似于C#中的属性）
重写了__get__和__set__方法的对象被称为数据描述符。数据描述符可以用于对象属性访问的封装和控制，如下例：
>>> class DataDescripterA(object):
... def __init__(self):
... self.data = None
... def __get__(self,attr,type=None):
... return 'returned by __get__:%s'%self.data
... def __set__(self,attr,val):
... if isinstance(val,str):
... self.data = val
... else:
... assert False,'Must set to string'
...
>>> class Sample(object);
File "<stdin>", line 1
class Sample(object);
^
SyntaxError: invalid syntax
>>> class Sample(object):
... desc = DataDescripterA()
...
>>> obj = Sample()
>>> obj.desc = 10
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 10, in __set__
AssertionError: Must set to string
>>>
>>>
>>> obj.desc = 'a string'
>>> obj.desc
'returned by __get__:a string'
>>>
元类：后续单独开辟一篇来理解。