类的属性
变量在类中称为类的属性，函数在类中称为类的方法，类的属性分为以下几种：
(1) 公有属性：在类中和类外都能调用的属性，定义的时候与变量的定义一致，如 color = 'yellow'
(2) 私有属性：不能在类外及被类以外的函数调用，定义的时候以双下划线开头，如__color = 'yellow'
(3) 内置属性： 由系统在定义类的时候默认添加的，定义的时候以前后双下划线构成，如 dict
#!/usr/bin/env python
class People(object):
color = 'yellow' # 定义类的公有属性
__age = 30 # 定义类的私有属性
def think(self):
print self.__age # 只能在类里面调用私有属性
ren = People()
print ren.color # 可以在类外面调用公有属性
ren.think()
print ren.__dict__ # 系统已经定义好了内置属性，可以直接调用类的方法
变量在类中称为类的属性，函数在类中称为类的方法，类的方法分为以下几种：
(1) 公有方法：在类中和类外都能调用的方法
(2) 私有方法：只能在类里面被调用，不能被类的外部调用，定义的时候要在前面加上双下划线，如 def __think()
备注：定义方法的时候后面都有一个self，如：def think(self)；就是区别类方法和函数（不需要self），里面有self是作为函数的第一个参数
(3) 类方法：能被类直接调用的方法称为类方法，但要通过 classmethod() 函数处理后才能被类直接调用
(4) 静态方法：静态方法相当于全局函数，可以被类直接调用，但要通过 staticmethod() 处理后才能被直接调用，注意静态方法没有 self 参数br/>区别：@classmethod与@staticmethod
<="" a="" style="margin: 0px; padding: 0px; max-width: 100%;"> 前者是类方法，后者是静态方法，共同点是都可以使用类的名字来调用这个方法。
不同点是两种方法的定义不同，前者必须有个self参数，后者可以没有参数，类方法也叫做动态方法，在调用类方法的时候，其他方法不会被加载到内存，调用静态方法是，其他方法也会一起被加载到内存。
self就表示类的本身。
类方法里必须使用self作为参数，这样才能被类识别为是自己的一个方法。
没有self就是一个函数，这时类是不能调用它的，除非使用@staticmethod这个装饰器，类才能调用它。
实例：
#!/usr/bin/env python
class People(object):
color = 'yellow'
__age = 30
def __talk(self): # 定义私有方法，需要在前面添加双下划线
print "I am talking with Tom"
def test(self): # 定义公有方法，方法的定义和函数一样，但是需要 self 作为第一个参数，表示执行对象本身
self.__talk() # 在类的内部调用私有方法
jack = People()
jack.test()#!/usr/bin/env python
class People(object):
color = 'yellow'
__age = 30
def test(self): # 定义公有方法
print "Testing......"
cm = classmethod(test) # 通过 classmethod 函数转换成类方法
jack = People()
People.cm() # 公有方法是不可以通过类直接调用的，只能通过对象来调用，但转换成类方法之后，就可以通过类直接调用#!/usr/bin/env python
class People(object):
color = 'yellow'
__age = 30
def test(): # 在类中定义方法如果没有加 self 参数只能称其为函数
print "Testing......"
sm = staticmethod(test) # 通过 staticmethod 函数转换成静态方法
jack = People()
People.sm() # 静态方法可以通过类直接调用可以参考以下代码：
class People(object):
color='yellow' #类的属性
__age=30 #私有属性
def A(self): #公有方法
self.color='black'
print 'I am a %s' %self.color
def test(self):
self.A() #类里面调用
print self.__age #调用私有属性
def __think(self):
print 'this is private mathod'
def call(self): #调用私有方法
self.__think()
@classmethod #只对下面的一个函数起作用
def classMethod(self):
print 'This is classMethod'
@classmethod
def call_class(self): #动态函数调用类的属性
print self.color
def B(self): #通过动态方法对这个方法B不起作用，只能用实例化的类调用
print 'B'
@staticmethod #只对下面的一个函数起作用
def staticMetod():
print 'This is staticMethod'
pe=People()
pe.A()
pe.test()
pe.call()
People.classMethod()
People. call_class()
People.staticMetod()
pe.B()结果：
I am a black
I am a black
30
this is private mathod
This is classMethod
yellow
This is staticMethod
B类的内置方法
所谓内部类，就是在类的内部定义的类，主要的目的是为了更好的抽象现实世界
class People(object):
color='yellow'
class Chinese(object):
print 'I am a chinese'
name='test'
#第一种方法：
pe=People()
jack=pe.Chinese()
print jack.name
#第二种方法调用属性name1：
print People.Chinese.name结果：
I am a chinese
test
test实例：
class People(object):
color='yellow'
def __str__(self): #通过这个函数可以知道pe是做什么的，只能用return，不能用print
return 'pe is People class'
def __init__(self): #将类的属性更改，调用的结果就是green,但是使用类调用属性则不变
self.color='green'
print 'this is init' #初始化方法可以不用调用，最开始的时候直接就执行了
class Chinese(object):
print 'I am a chinese'
name='test'
pe=People()
print pe
print pe.color
print People.color结果：
I am a chinese
this is init
pe is People class
green
yellow实例2：可以设置初始化的默认参数
结果：
初始化函数时可以调用方法：
del 用于释放对象所占用的资源，注意 del 是在脚本要退出之前执行的
class People(object):
color = 'yellow'
def __init__(self):
self.fd = open('/etc/passwd') # 我打开了一个文件
def __del__(self):
self.fd.close() # 可以在__del__中关掉这个文件ren = People()
