Python中的类（上）

在Python中，可以通过class关键字定义自己的类，然后通过自定义的类对象类创建实例对象。

例如，下面创建了一个Student的类，并且实现了这个类的初始化函数"__init__":

class Student(object):     count = 0     books = []     def __init__(self, name, age):         self.name = name         self.age = age     pass

接下来就通过上面的Student类来看看Python中类的相关内容。

数据属性

在上面的Student类中，"count""books""name"和"age"都被称为类的数据属性，但是它们又分为类数据属性和实例数据属性。

类数据属性和实例数据属性

首先看一段代码，代码中分别展示了对类数据属性和实例数据属性的访问：

Student.books.extend(["python", "javascript"])   print "Student book list: %s" %Student.books     # class can add class attribute after class defination Student.hobbies = ["reading", "jogging", "swimming"] print "Student hobby list: %s" %Student.hobbies     print dir(Student)  print   wilber = Student("Wilber", 28)  print "%s is %d years old" %(wilber.name, wilber.age)    # class instance can add new attribute  # "gender" is the instance attribute only belongs to wilber wilber.gender = "male" print "%s is %s" %(wilber.name, wilber.gender)    # class instance can access class attribute print dir(wilber) wilber.books.append("C#") print wilber.books  print   will = Student("Will", 27)  print "%s is %d years old" %(will.name, will.age)    # will shares the same class attribute with wilber # will don't have the "gender" attribute that belongs to wilber print dir(will)      print will.books

通过内建函数dir()，或者访问类的字典属性__dict__，这两种方式都可以查看类有哪些属性，代码的输出为：

对于类数据属性和实例数据属性，可以总结为：

1. 类数据属性属于类本身，可以通过类名进行访问/修改
2. 类数据属性也可以被类的所有实例访问/修改
3. 在类定义之后，可以通过类名动态添加类数据属性，新增的类属性也被类和所有实例共有
4. 实例数据属性只能通过实例访问
5. 在实例生成后，还可以动态添加实例数据属性，但是这些实例数据属性只属于该实例

特殊的类属性

对于所有的类，都有一组特殊的属性：

通过这些属性，可以得到 Student类的一些信息：

class Student(object):  '''  this is a Student class  '''  count = 0  books = []  def __init__(self, name, age):   self.name = name   self.age = age  pass print Student.__name__ print Student.__doc__ print Student.__bases__ print Student.__dict__ print Student.__module__ print Student.__class 

代码输出为：

属性隐藏

从上面的介绍了解到，类数据属性属于类本身，被所有该类的实例共享；并且，通过实例可以去访问/修改类属性。但是，在通过实例中访问类属性的时候一定要谨慎，因为可能出现属性"隐藏"的情况。

继续使用上面的Student类，来看看属性隐藏：

wilber = Student("Wilber", 28)  print "Student.count is wilber.count: ", Student.count is wilber.count wilber.count = 1     print "Student.count is wilber.count: ", Student.count is wilber.count print Student.__dict__ print wilber.__dict__ del wilber.count print "Student.count is wilber.count: ", Student.count is wilber.count  print   wilber.count += 3     print "Student.count is wilber.count: ", Student.count is wilber.count print Student.__dict__ print wilber.__dict__   del wilber.count print  print "Student.books is wilber.books: ", Student.books is wilber.books wilber.books = ["C#", "Python"] print "Student.books is wilber.books: ", Student.books is wilber.books print Student.__dict__ print wilber.__dict__ del wilber.books print "Student.books is wilber.books: ", Student.books is wilber.books  print   wilber.books.append("CSS") print "Student.books is wilber.books: ", Student.books is wilber.books print Student.__dict__ print wilber.__dict__

代码的输出为：

分析一下上面代码的输出：

• 对于不可变类型的类属性Student.count，可以通过实例wilber进行访问，并且 "Student.count is wilber.count"
• 当通过实例赋值/修改count属性的时候，都将为实例wilber新建一个count实例属性，这时， "Student.count is not wilber.count"

• 当通过"del wilber.count"语句删除实例的count属性后，再次成为 "Student.count is wilber.count"

• 同样对于可变类型的类属性Student.books，可以通过实例wilber进行访问，并且 "Student. books is wilber. books"
• 当通过实例 赋值 books属性的时候，都将为实例wilber新建一个books实例属性，这时， "Student. Books is not wilber. books"
• 当通过"del wilber. books"语句删除实例的books属性后，再次成为 "Student. books is wilber. books"
• 当通过实例 修改 books属性的时候，将修改wilber.books指向的内存地址（即Student.books），此时， "Student. Books is wilber. books"

注意，虽然通过实例可以访问类属性，但是，不建议这么做，最好还是通过类名来访问类属性，从而避免属性隐藏带来的不必要麻烦。

方法

在一个类中，可能出现三种方法，实例方法、静态方法和类方法，下面来看看三种方法的不同。

实例方法

实例方法的第一个参数必须是"self"，"self"类似于C++中的"this"。

实例方法只能通过类实例进行调用，这时候"self"就代表这个类实例本身。通过"self"可以直接访问实例的属性。

class Student(object):  '''  this is a Student class  '''  count = 0  books = []  def __init__(self, name, age):   self.name = name   self.age = age  def printInstanceInfo(self):   print "%s is %d years old" %(self.name, self.age)  pass wilber = Student("Wilber", 28) wilber.printInstanceInfo() 

类方法

类方法以cls作为第一个参数，cls表示类本身，定义时使用@classmethod装饰器。通过cls可以访问类的相关属性。

class Student(object):  '''  this is a Student class  '''  count = 0  books = []  def __init__(self, name, age):   self.name = name   self.age = age  @classmethod  def printClassInfo(cls):   print cls.__name__   print dir(cls)  pass Student.printClassInfo()  wilber = Student("Wilber", 28) wilber.printClassInfo() 

代码的输出为，从这段代码可以看到，类方法可以通过类名访问，也可以通过实例访问。

静态方法

与实例方法和类方法不同，静态方法没有参数限制，既不需要实例参数，也不需要类参数，定义的时候使用@staticmethod装饰器。

同类方法一样，静态法可以通过类名访问，也可以通过实例访问。

class Student(object):  '''  this is a Student class  '''  count = 0  books = []  def __init__(self, name, age):   self.name = name   self.age = age  @staticmethod  def printClassAttr():   print Student.count   print Student.books  pass Student.printClassAttr()  wilber = Student("Wilber", 28) wilber.printClassAttr() 

这三种方法的主要区别在于参数，实例方法被绑定到一个实例，只能通过实例进行调用；但是对于静态方法和类方法，可以通过类名和实例两种方式进行调用。

访问控制

Python中没有访问控制的关键字，例如private、protected等等。但是，在Python编码中，有一些约定来进行访问控制。

单下划线"_"

在Python中，通过单下划线"_"来实现模块级别的私有化，一般约定以单下划线"_"开头的变量、函数为模块私有的，也就是说"from moduleName import *"将不会引入以单下划线"_"开头的变量、函数。

现在有一个模块lib.py，内容用如下，模块中一个变量名和一个函数名分别以"_"开头：

numA = 10 _numA = 100  def printNum():     print "numA is:", numA     print "_numA is:", _numA      def _printNum():     print "numA is:", numA print "_numA is:", _numA

当通过下面代码引入lib.py这个模块后，所有的以"_"开头的变量和函数都没有被引入，如果访问将会抛出异常：

from lib import * print numA printNum()  print _numA #print _printNum()

双下划线"__"

对于Python中的类属性，可以通过双下划线"__"来实现一定程度的私有化，因为双下划线开头的属性在运行时会被"混淆"（mangling）。

在Student类中，加入了一个"__address"属性：

class Student(object):  def __init__(self, name, age):   self.name = name   self.age = age   self.__address = "Shanghai"  pass wilber = Student("Wilber", 28) print wilber.__address 

当通过实例wilber访问这个属性的时候，就会得到一个异常，提示属性"__address"不存在。

其实，通过内建函数dir()就可以看到其中的一些原由，"__address"属性在运行时，属性名被改为了"_Student__address"（属性名前增加了单下划线和类名）

>>> wilber = Student("Wilber", 28) >>> dir(wilber) ['_Student__address', '__class__', '__delattr__', '__dict__', '__doc__', '__form at__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__r educe__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', ' __subclasshook__', '__weakref__', 'age', 'name'] >>>

所以说，即使是双下划线，也没有实现属性的私有化，因为通过下面的方式还是可以直接访问"__address"属性：

>>> wilber = Student("Wilber", 28) >>> print wilber._Student__address Shanghai >>>

双下划线的另一个重要的目地是，避免子类对父类同名属性的冲突。

看下面一个例子：

class A(object):  def __init__(self):   self.__private()   self.public()  def __private(self):   print 'A.__private()'  def public(self):   print 'A.public()' class B(A):  def __private(self):   print 'B.__private()'  def public(self):   print 'B.public()' b = B() 

当实例化B的时候，由于没有定义__init__函数，将调用父类的__init__，但是由于双下划线的"混淆"效果，"self.__private()"将变成 "self._A__private()"。

看到这里，就清楚为什么会有如下输出了：

"_"和" __"的使用 更多的是一种规范/约定，不没有真正达到限制的目的：

• "_"：以单下划线开头的表示的是protected类型的变量，即只能允许其本身与子类进行访问；同时表示弱内部变量标示，如，当使用"from moduleNmae import *"时，不会将以一个下划线开头的对象引入。
• "__"：双下划线的表示的是私有类型的变量。只能是允许这个类本身进行访问了，连子类也不可以，这类属性在运行时属性名会加上单下划线和类名。

总结

本文介绍了Python中class的一些基本点：

• 实例数据属性和类数据属性的区别，以及属性隐藏
• 实例方法，类方法和静态方法直接的区别
• Python中通过"_"和"__"实现的访问控制