Python的类和实例

类是一种数据结构，可用于创建实例。

Python类是一个可调用对象，即类对象。

class  class_name    内存中生成一个这个类名引用的类对象，但是类中的代码不会执行。

实例初始化：

      通过调用类来创建实例

      instance = ClassName(args...)

      类在实例化时，可使用__init__   和 __del__两个特殊方法。

 

使用class关键字创建类

class ClassName(bases):

'class cocumentation string'

class_suite

 

In [227]: class TestClass():
.....: pass
.....:

In [228]: type(TestClass)
Out[228]: classobj

 

In [228]: type(TestClass)
Out[228]: classobj

In [229]: obj1 = TestClass()

In [230]: type(obj1)
Out[230]: instance

定义类名是单词首字母大写。  函数名第一个单词首字母小写，其他大写。

 

超类是一个或多个用于继承的父类的集合。

类体可以包含：声明语句，类成员定义、数据属性、方法

   如果不存在继承关系，ClassName后面的（bases）  可以不提供，类文档为可选。

class语句一般形式

class ClassName(bases):

    data = value       //类成员--类属性（从属于类，能被各个实例使用）

    def method(self,..):         //方法成员，首个参数为”self“

        self.member = value    //实例属性（只能被实例自己使用）

 

In [231]: class FirstClass():
.....: data = "hello class"
.....: def printdata(self):
.....: print self.data
.....:

In [232]: ins1 = FirstClass()

In [233]: ins1.
ins1.data ins1.printdata

In [233]: ins1.data
Out[233]: 'hello class'

In [234]: ins1.printdata
Out[234]: <bound method FirstClass.printdata of <__main__.FirstClass instance at 0x1778488>>

In [235]: ins1.printdata()
hello class

 

In [236]: class ThirdClass():
.....:     data = "hello ThirdClass"
.....:     def setdata(self,x):
.....:         self.str1 = x
.....:     def printdata(self):
.....:         print self.str1
.....:

In [243]: ins5 = ThirdClass()

In [244]: ins5.setdata('aaa')

In [245]: ins5.printdata()
aaa

In [246]: ins6 = ThirdClass()

In [247]: ins6.data
Out[247]: 'hello ThirdClass'

 

类属性是供所有实例共享的。但是实例自己的属性的自己使用的。

object.method()

 

ins5.setdata('asdf') = ThirdClass(ins5,'adsf')

因此类中每个方法必须具有self参数，它隐含当前实例之意。

在方法内对self属性做赋值运算会产生每个实例自己的属性。

Python规定，没有实例，方法不允许被调用，此即为”绑定“。

 

     创建实例时，Python会自动调用类中的__init__方法，以隐形地为实例提供属性。__init__方法被称为构造器。如果类中没有定义__init__ 方法，实例创建之初仅是一个简单的名称空间。

__varname__（）：会被Python解释器自动调用。

In [249]: class MyClass():
.....:     data = 'hello myclass'
.....:     def __init__(self,x):
.....:         self.str1 = x
.....:

In [250]: i1 = MyClass('adsf')

In [251]: i1.
i1.data i1.str1

In [251]: i1.str1
Out[251]: 'adsf'

In [254]: i2 = MyClass('xyz')

In [255]: i2.data
Out[255]: 'hello myclass'

In [256]: i2.str1
Out[256]: 'xyz'

 

__del__   析构器

 

类的特殊属性

     __dict__ 字典属性：保存了类自己的所有可用属性和方法。

In [257]: MyClass.__dict__
Out[257]:
{'__doc__': None,
'__init__': <function __main__.__init__>,
'__module__': '__main__',
'data': 'hello myclass'}

C.__name__   类C的名字（字符串）

C.__doc__   类C的文档字符串

C.__bases__    类C的所有父类构成的元组

C.__dict__      类C的属性

C.__module__    类C定义所在的模块

C.__class__      实例C对应的类（仅新式类）

Python内置的dir()函数获取类的属性。

 

实例仅拥有数据属性。通过构造器为实例提供属性。这些数据属性独立于其他实例或类，实例释放时，其属性也被清除。

    实例的特殊属性

      I.__class__       实例I 的类

      I.__dict__         I 的属性

In [258]: i1.__dict__
Out[258]: {'str1': 'adsf'}

In [259]: i1.__class__
Out[259]: <class __main__.MyClass at 0x17d97a0>

 

 

Python类方法中可用的变量

1、实例变量：指定变量名称及实例自身进行引用     self.变量名

2、局部变量：方法内部创建的变量

3、类变量：静态变量

4、全局变量

 

In [260]: class c1():
.....:     d1 = 'hello c1'
.....:     def __init__(self,x):
.....:        self.insdata = x
.....:

In [261]: i1 = c1(50)

In [262]: i1.
i1.d1 i1.insdata

In [262]: i1.d1
Out[262]: 'hello c1'

In [263]: i1.insdata
Out[263]: 50

In [264]: i2 = c1(100)

In [265]: i2.d1
Out[265]: 'hello c1'

In [266]: i2.insdata
Out[266]: 100

In [267]: i1.d1 = 'new value'

In [268]: i1.d1
Out[268]: 'new value'

In [269]: i2.d1
Out[269]: 'hello c1'

In [270]: c1.d1
Out[270]: 'hello c1'

In [271]: c1.d1 = 'c1 new value'

In [272]: i1.d1
Out[272]: 'new value'

In [273]: i2.
i2.d1 i2.insdata

In [273]: i2.d1
Out[273]: 'c1 new value'

 

继承

继承描述了基类的属性如何“遗传”给派生类

子类可以继承它的基类的任何属性，包括数据属性和方法。

一个未指定基类的类，其默认有一个名为object的基类

Python允许多重继承

 

In [274]: class PClass(object):
.....: gender = 'Male'
.....: def __init__(self,who):
.....: self.name = who
.....:

In [275]: class CClass(PClass):
.....: def displayInfo(self):
.....: print self.gender,self.name
.....:

In [276]: x = CClass('Tom')

In [277]: x.
x.displayInfo x.gender x.name

In [277]: x.name
Out[277]: 'Tom'

In [278]: x.gender
Out[278]: 'Male'

In [279]: x.
x.displayInfo x.gender x.name

In [279]: x.displayInfo()
Male Tom

In [280]: dir(x)
Out[280]:
['__class__',
'__delattr__',
'__dict__',
'__doc__',
'__format__',
'__getattribute__',
'__hash__',
'__init__',
'__module__',
'__new__',
'__reduce__',
'__reduce_ex__',
'__repr__',
'__setattr__',
'__sizeof__',
'__str__',
'__subclasshook__',
'__weakref__',
'displayInfo',
'gender',
'name']

 

Python中几乎所有属性的获取都可以使用“object.attribute"的格式。不过此表达式会在Python中启动搜索---搜索连续的树。

 

类连接其超类的方式

     将超类列在类头部的括号内，其从左至右的顺序会决定树中的次序，由下至上，（同一级--由左至右。

      

 

继承方法专用化

继承会先在子类寻找变量名，然后才查找超类，因此，子类可以对超类的属性重新定义来取代继承而来的行为。

   子类可完全取代从超类继承而来的属性；也可通过已覆盖的方法回调超类来扩展超类的方法。

 

 

类、实例和其他对象的内建函数：

issubclass()    判断一个类是否由另一类派生    issubclass(sub,sup)

isinstance()     判断对象是否是给定类的实例    isinstance(obj1,class_obj2)

hasattr()      判断一个对象是否拥有指定的属性    hasattr(obj,'attr')

                    getattr()/setattr()/delattr()

super()

在子类中找出其父类以便于调用其属性。

一般情况下仅能采用非绑定方式调用祖先类方法、

super() 可用于传入实例或类型对象    super（type[,obj])