1：类和对象
是面向对象中的俩个重要概念，类是对事物的抽象，比如人类，球类。对象是事物的实例，比如足球，篮球。球类可以对球的特征和行为进行抽象，然后可以实例化一个真实的球体出来。
2：类的定义
类把需要的变量和函数组合成一起，这种包含称为“封装”。。classA（object）：
3：类的结构
class类名：
成员变量-属性 ## 类的属性是对数据的封装
成员函数-方法 ## 类的方法是对类的行为进行封装
类的创建：
class MyClass1(object): ## 类名
color = ‘Black‘ ## 类的属性-变量
def fun(self): ## 类的方法中必须有参数self，这是成员函数类的方法
print "I am function"
#!/usr/bin/pythonclass 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.colorren.think()
4：类的属性
公有属性：在类中类外都可以使用。
私有属性：只能在类中使用，定义方式为__name（双下划线）
内置属性：由系统定义类的时候默认添加的，由前后双下划线构成。__dict__,__module__。
#!/usr/bin/pythonclass 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.colorren.think()print ren._People__age ## 仅测试使用，类外使用私有函数
5：类的方法相当于函数，类的属性相当于变量。
方法的定义跟函数一样，但是需要self作为第一个参数。
公有方法：跟公有属性一样，类内类外都可以使用
私有方法：跟私有属性一样，只能类内使用。__self
self：用来区分类跟方法，self本身表示类
类方法：被classmethod编译过的函数，能被类所调用，也能被对象调用（继承的关系）
静态方法：被staticmethod编译过的函数，可以被类直接调用，静态方法不需要设置self参数。
装饰器：
@classmethod：类方法
@staticmethod：静态方法
6：对象的创建
创建对象的过程称之为实例化：当一个对象被创建后，包含三个方面的特性：对象句柄，属性，方法。句柄用来区分对象。
对象的属性和方法与类中的成员变量和成员函数相对应
object=MyClass() ## 创建类的一个实例（对象），通过对象来调用方法和属性
#!/usr/bin/python# coding:utf-8class 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.Insideobject = 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 class object!"
构造函数
def __init__(self,c=‘Black‘): ## 初始化对象的属性，但不会改变类的属性
self.color = c
析构函数
def __del__(self): ## 主要用于释放资源，一般执行与脚本的最后
#!/usr/bin/pythonclass PeoPle(object): color = ‘Black‘ def __init__(self,c): ## 初始化属性，c需要在实例化类的时候，跟在后面 self.color = c print "Init runinng ......" ## 只要把类实例化成对象，就会打印这行， def fun1(self): print "Color is: %s" % self.colorpe = PeoPle(‘Red‘)print "Object print is: %s" %pe.color ## __init__会影响对象的属性print "Class print is: %s" %PeoPle.color ## 类不会受__init__的影响
类的继承：
单类继承
#!/usr/bin/pythonclass PeoPle(object): color = ‘Black‘ def __init__(self,c): ## 初始化参数 self.color = c print "Init runinng ......" @classmethod ## 装饰方法，使其对象和类都可以调用 def fun1(self): print "Color is: %s" % self.colorclass MyClass(PeoPle): ## 继承父类PeoPle color = ‘MyClass‘ def __init__(self): PeoPle.__init__(self.‘Red‘) ## 表示继承父类的__init__构造函数。 @classmethod def fun1(self): print "This is MyClass the function" passmy=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 ## 打印初始化后对象的属性即Greenprint "Class print is: %s" % PeoPle.color ## 打印类属性即Black
多类继承：
#!/usr/bin/pythonclass PeoPle(object): def __init__(self): self.dwell = ‘Earth‘ self.color = ‘Yellow‘ def think(self): print "I dwell am %s!" % self.dwellclass Chinese(object): color = ‘Black‘ def __init__(self): self.dwell = ‘China‘ def think(self): print "I am chinese %s " % self.colorclass MyClass(Chinese,PeoPle): ## 默认首先继续第一个类的属性跟方法 def __init__(self): PeoPle.__init__(self) ## 表示使用指定类的属性 passmy = MyClass()my.think() ## 返回I am Chinese Yellow
类的属性---总结
- 类属性（公有属性）： 可以在类中使用，相当于变量。
- 类私有属性（私有属性）： 只能函数中使用，无法被对象调用
- 对象的公有属性： 对象可以调用
- 对象的私有属性： 只能类中调用
- 内置属性：
- 函数的局部变量： 只能在本函数中使用
- 函数的全局变量： 可以在类中所有的函数里使用
#!/usr/bin/python# coding:utf8val6 = "全局变量"print ‘*‘ * 50class My(object): val1 = "类的公有属性 val1" __val2 = "类的私有属性 __val2" def fun(self): self.val3 = "对象的公有属性 val3" self.__val4 = "对象的私有属性 __val4" val5 = "函数的局部变量,只能在本函数使用" global val6 val6 = "函数的全局变量,可以在类中所有的函数中使用" def fun1(self): print val6my = My()print my.val1print my._My__val2my.fun()print ‘*‘ * 50my.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,与类方法的区别