同学分享的一篇关于python知识点的总结（挺好，故转载）
class类的定义（Python中的类没有什么public、private、protect）
构造函数、析构函数
__init__(self)#在继承体系中，如果父类有__init__函数，子类必须在__init__函数中显式的调用父类的__init__函数来初始化
__del__(self)
类的静态变量
class Student
name="abc"
初始化类的静态变量是这样的 （DiveIntoPython中的例子）
class counter:
count = 0
def __init__(self):
self.__class__.count += 1
c = counter() #产生一个实例
print(c.count) # 1
print(counter.count) # 1
counter.count = 3; #通过类修改 3
print(c.count) # 3
print(counter.count) # 3
c.__class__.count = 4 #通过类修改
print(c.count) # 4
print(counter.count) # 4
c. count = 5 #通过实例修改
print(c.count) # 5
print(counter.count) # 4 类的静态变量无法通过实例修改
实例的成员变量
class Student
def __init__(self)
self.name = "abc"
属性定义
class Student:
def __init__(self):
self.__name="abc"
def GetName(self):
return self.__name
def SetName(self,value):
self.__name = value
def DelName(self):
del self.__name
Name = property(GetName,SetName,DelName,'Student name')
只读属性（类必须从object继承，否则就不是只读的）在python 3000中所有的类都是从object继承的，就不存在这个问题了。
class Parrot(object):
def __init__(self):
self.__voltage = 100000
@property
def voltage(self):
"""Get the current voltage."""
return self.__voltage
私有变量
class Student:
def __init__(self):
self.__name="abc"#很简单就是通过__两个下划线开头，但不是结尾的。就是私有了
私有方法
class Student:
def __Getage(self):
pass
#和私有的变量一样，你可以尝试一下直接调用，编译器会有相应的提示
强制访问私有方法、变量，"私有"事实上这只是一种规则，我们依然可以用特殊的语法来访问私有成员。上面的方法，我们就可以通过_类名来访问
aobj = Student()
aobj._Student__name
aobj._Student__Getage()
静态方法
class Class1:
@staticmethod
def test():
print "In Static method..."
方法重载
python是不支持方法重载，但是你代码了里可以写。Python会使用位置在最后的一个。我觉得这可能以Python存储这些信息通过__dict__ 有关,它就是一个Dict。key是不能相同的。所以也就没办法出现两个GoGo 方法调用。
class Student:
def GoGo(self,name):
print name
def GoGo(self):
print "default"
s = Student()
s.GoGo() #只能使用到方法最下面的一个函数
Student.GoGo('hello') #这里可以用类直接调用，但是需要加入一个参数来填 self，虽然这个参数本身不起作用
>>>
default
default
本质上，调用的时候你只能使用后面那个GoGo()方法。
一些特殊方法
__init__（self） 构造函数
__del__ （self） 析构函数
__repr__( self) repr()
__str__( self) print语句 或 str()
运算符重载
__lt__( self, other)
__le__( self, other)
__eq__( self, other)
__ne__( self, other)
__gt__( self, other)
__ge__( self, other)
这东西太多了。大家还是自己看Python自带帮助吧。
一些特殊属性，当你定义一个类和调用类的实例时可以获得的一些默认属性 。
class Student:
'''this test class'''
name = 'ss'
def __init__(self):
self.name='bb'
def Run(self):
'''people Run'''
@staticmethod
def RunStatic():
print "In Static method..."
print Student.__dict__ #类的成员信息
print Student.__doc__ #类的说明
print Student.__name__ #类的名称
print Student.__module__ #类所在的模块
print Student.__bases__ #类的继承信息
obj = Student()
print dir(obj)
print obj.__dict__ #实例的成员变量信息(不太理解Python的这个模型，为什么 Run这个函数却不再dict中)
print obj.__doc__ #实例的说明
print obj.__module__ #实例所在的模块
print obj.__class__ #实例所在的类名
单继承
具体的语法就不说了。我很关心的是它到底继承了什么单继承条件下很简单。类的静态变量、类的静态方法、实例的方法、实例的成员变量、基类的构造函数、基类的析构函数都可以从父类中继承过来。私有方法和私有变量是不能继承的。具体看测试代码：
class Student:
'''this test class'''
name = 'ss'
age = 13
def __init__(self):
self.name='bb'
self.addr="shanghai"
self.__love="man"
print "init..."
def __del__(self):
print "dead..."
def Run(self):
print 'people Run'
@staticmethod
def RunStatic():
print "In Static method..."
def __Good(self):
print "good"
class MiniStudent(Student):
pass
#类
print MiniStudent.name
print MiniStudent.age
print MiniStudent.RunStatic()
print "----================--------"
#实例
mini = MiniStudent()
print mini.name
print mini.age
print mini.Run()
print mini.addr
多继承
多继承下，情况明显比这复杂而且，而且会产生多个基类覆盖函数的问题。C++的多重继承在实际工程中使用也不多（过于复杂）。正因为这样，我感觉这种多继承应该一般不需要用，否则代码会很晦涩。下面这个例子你就可以看到。在上面的例子中，我多添加了一个StudentA的类。 具体看测试代码：
class StudentA:
def __init__(self):
print 'init-studenta'
def GoCar(self):
print "Go Car"
class Student:
'''this test class'''
name = 'ss'
age = 13
def __init__(self):
self.name='bb'
self.addr="shanghai"
self.__love="man"
print "init..."
def __del__(self):
print "dead..."
def Run(self):
print 'people Run'
@staticmethod
def RunStatic():
print "In Static method..."
def __Good(self):
print "good"
class MiniStudent(Student，StudentA):
pass
#类
mini = MiniStudent()
print mini.name
print mini.age
print mini.Run()
print mini.addr
现在这个例子是可以通过的，但如果你把class MiniStudent(Student，StudentA)修改成class MiniStudent(StudentA，Student)这个代码就通不过了。告诉你mini.addr没有定义。其实是StudentA的构造函数覆写了Student的函数，也就是说只调用了StudentA.__init__()的方法。下面就谈到继承中的覆写问题。
继承中的覆写
从上面的经验可以得到Python的多继承，但有以下几点需要注意：
1. 继承方法的调用和基类声明顺序有关（排在前面的覆写后面的方法）。
2. 基类init、del ，如果希望都使用，请显示的调用，否则很容易出错。
class StudentA:
def __init__(self):
print 'init-b'
class Student:
def __init__(self):
print 'init-a'
class MiniStudent(Student,StudentA):
def __init__(self):
StudentA.__init__(self)
Student.__init__(self)
#实例
mini = MiniStudent()
