python面向对象，类

火冰狐

　　1：类和对象
　　是面向对象中的俩个重要概念，类是对事物的抽象，比如人类，球类。对象是事物的实例，比如足球，篮球。球类可以对球的特征和行为进行抽象，然后可以实例化一个真实的球体出来。
　　2：类的定义
　　类把需要的变量和函数组合成一起，这种包含称为“封装”。。classA（object）：
　　3：类的结构

　　>　　成员变量-属性              ## 类的属性是对数据的封装
　　成员函数-方法              ## 类的方法是对类的行为进行封装
　　类的创建：

　　>　　color = 'Black'          ## 类的属性-变量
　　def fun(self):           ## 类的方法中必须有参数self，这是成员函数类的方法
　　print "I am function"
#!/usr/bin/python　　class People():
　　color = 'yellow'             ## 成员变量
　　def think(self):             ## 成员函数
　　self.color = 'Black'     ## self表示类本身
　　print 'I am a %s' % self.color
　　print 'I am a thinker'
　　ren = People()                   ## 把类赋予一个变量，即实例化
　　print ren.color
　　ren.think()
　　4：类的属性
　　公有属性：在类中类外都可以使用。
　　私有属性：只能在类中使用，定义方式为__name（双下划线）
　　内置属性：由系统定义类的时候默认添加的，由前后双下划线构成。__dict__,__module__。
#!/usr/bin/python　　class People():
　　color = 'yellow'
　　__age = 20
　　def think(self):
　　self.color = 'Black'
　　print 'I am a %s' % self.color
　　print 'I am a thinker'
　　print self.__age   ## 私有函数，只能在类中使用
　　ren = People()
　　print ren.color
　　ren.think()
　　print ren._People__age     ## 仅测试使用，类外使用私有函数
　　5：类的方法相当于函数，类的属性相当于变量。
　　方法的定义跟函数一样，但是需要self作为第一个参数。
　　公有方法：跟公有属性一样，类内类外都可以使用
　　私有方法：跟私有属性一样，只能类内使用。__self
　　self：用来区分类跟方法，self本身表示类
　　类方法：被classmethod编译过的函数，能被类所调用，也能被对象调用（继承的关系）
　　静态方法：被staticmethod编译过的函数，可以被类直接调用，静态方法不需要设置self参数。
　　装饰器：
　　@classmethod：类方法
　　@staticmethod：静态方法
　　6：对象的创建
　　创建对象的过程称之为实例化：当一个对象被创建后，包含三个方面的特性：对象句柄，属性，方法。句柄用来区分对象。
　　对象的属性和方法与类中的成员变量和成员函数相对应
　　object=MyClass() ## 创建类的一个实例（对象），通过对象来调用方法和属性
#!/usr/bin/python　　# coding:utf-8
　　class MyClass1(object):                   ## 类
　　color = 'Yellow'                      ## 类的属性--变量
　　__age = 20                            ## 类的私有属性，只能在类中使用
　　@classmethod
　　def __hide(self):                     ## 类的隐藏方法，只能在类中使用
　　print "I am hidemethods!"
　　@classmethod                          ## 装饰，对象和类都可以调用
　　def fun(self):                        ## 类的方法--函数
　　print self.__age                  ## self等同类，表示调用类的私有属性
　　print 'This is function!'
　　@staticmethod                         ## 装饰，对象和类都能调用，不需要self
　　def fun1():                           ## 不需要self
　　print MyClass1.color              ## 直接使用类调用类的属性或方法
　　MyClass1.__hide()                 ## 调用类的隐藏方法
　　class InsideClass(object):            ## 类中类，内部类
　　Inside = 'Red'                    ## 内部类的属性
　　@classmethod
　　def InsideFun(self):              ## 内部类的方法
　　print self.Inside
　　object = MyClass1()                       ## 对象，实例化类
　　object.fun()                              ## 对象调用类的方法
　　MyClass1.fun()                            ## 类调用类的方法
　　MyClass1.fun1()
　　object_inside = object.InsideClass()      ## 先调用外部类，再调用内部类
　　MyClass1.InsideClass.InsideFun()          ## 调用内部类的方法
　　print object_inside.Inside                ## 调用内部类的属性
　　7：内部方法（魔术方法）
　　def __str__(self):               ## 如果直接实例化类，会返回__str__的值，而不是提示这样

　　return "This is>　　构造函数
　　def __init__(self,c='Black'):       ## 初始化对象的属性，但不会改变类的属性
　　self.color = c
　　析构函数
　　def __del__(self):                         ## 主要用于释放资源，一般执行与脚本的最后
#!/usr/bin/python　　class PeoPle(object):
　　color = 'Black'
　　def __init__(self,c):                         ## 初始化属性，c需要在实例化类的时候，跟在后面
　　self.color = c
　　print "Init runinng ......"               ## 只要把类实例化成对象，就会打印这行，
　　def fun1(self):
　　print "Color is: %s" % self.color
　　pe = PeoPle('Red')
　　print "Object print is: %s" %pe.color             ## __init__会影响对象的属性
　　print "Class print is: %s" %PeoPle.color          ## 类不会受__init__的影响
　　类的继承：
　　单类继承
#!/usr/bin/python　　class PeoPle(object):
　　color = 'Black'
　　def __init__(self,c):                   ## 初始化参数
　　self.color = c
　　print "Init runinng ......"
　　@classmethod                            ## 装饰方法，使其对象和类都可以调用
　　def fun1(self):
　　print "Color is: %s" % self.color
　　class MyClass(PeoPle):                      ## 继承父类PeoPle
　　color = 'MyClass'
　　def __init__(self):
　　PeoPle.__init__(self.'Red')         ## 表示继承父类的__init__构造函数。
　　@classmethod
　　def fun1(self):
　　print "This is MyClass the function"
　　pass
　　my=MyClass()                      ## 由于MyClass类中继承过PeoPle里的__init__参数。
　　print MyClass.color               ## 优先返回MyClass里的属性
　　my.fun1()                         ## 优先返回MyClass里的方法
　　PeoPle.fun1()                     ## 返回PeoPle里的fun1方法
　　MyClass.fun1()                    ## 返回MyClass里的fun1方法
　　pe = PeoPle('Green')              ## 由于PeoPle初始化__init__那里需要俩个参数，所以这里要加一个参数
　　print "Object print is: %s" % pe.color  ## 打印初始化后对象的属性即Green
　　print "Class print is: %s" % PeoPle.color  ## 打印类属性即Black
　　多类继承：
#!/usr/bin/python　　class PeoPle(object):
　　def __init__(self):
　　self.dwell = 'Earth'
　　self.color = 'Yellow'
　　def think(self):
　　print "I dwell am %s!" % self.dwell
　　class Chinese(object):
　　color = 'Black'
　　def __init__(self):
　　self.dwell = 'China'
　　def think(self):
　　print "I am chinese %s " % self.color
　　class MyClass(Chinese,PeoPle):       ## 默认首先继续第一个类的属性跟方法
　　def __init__(self):
　　PeoPle.__init__(self)        ## 表示使用指定类的属性
　　pass
　　my = MyClass()
　　my.think()                           ## 返回I am Chinese Yellow
　　类的属性---总结

• 　　类属性（公有属性）： 可以在类中使用，相当于变量。
  
• 　　类私有属性（私有属性）： 只能函数中使用，无法被对象调用
  
• 　　对象的公有属性： 对象可以调用
  
• 　　对象的私有属性： 只能类中调用
  
• 　　内置属性：
  
• 　　函数的局部变量： 只能在本函数中使用
  
• 　　函数的全局变量： 可以在类中所有的函数里使用
  

#!/usr/bin/python　　# coding:utf8
　　val6 = "全局变量"
　　print '*' * 50
　　class My(object):
　　val1 = "类的公有属性 val1"
　　__val2 = "类的私有属性 __val2"
　　def fun(self):
　　self.val3 = "对象的公有属性 val3"
　　self.__val4 = "对象的私有属性 __val4"
　　val5 = "函数的局部变量,只能在本函数使用"
　　global val6
　　val6 = "函数的全局变量,可以在类中所有的函数中使用"
　　def fun1(self):
　　print val6
　　my = My()
　　print my.val1
　　print my._My__val2
　　my.fun()
　　print '*' * 50
　　my.fun1()
　　类的方法总结：

• 　　公有方法：
  
• 　　私有方法：
  
• 　　类方法：
  
• 　　静态方法：
  
• 　　内置方法：
  

#!/usr/bin/python　　#-*- coding:utf8 -*_
　　class MyClass(object):
　　name = 'Warning'
　　def __init__(self):
　　self.fun1()
　　self.__fun2()
　　self.fun3()
　　self.fun4()
　　def fun1(self):
　　print "%s %s" % (self.name,'我是公有方法')
　　def __fun2(self):
　　print "%s %s" % (self.name,'我是私有方法')
　　@classmethod
　　def fun3(self):
　　print "%s %s" % (self.name,'我是类方法')
　　@staticmethod
　　def fun4():
　　print "%s %s" % (MyClass.name,'我是静态方法')
　　my = MyClass()
　　my.fun1()                           ## 调用公有方法
　　MyClass.fun3()                      ## 调用类方法
　　MyClass.fun4()                      ## 调用静态方法，注意静态方法不需要self,与类方法的区别