Python之面向对象编程

类和实例

 类比于java中的类与实例，类是一个抽象的模板，而实例是根据类创建出来的一个个具体的对象。

下面是一个最简单的类的定义：

class Student(object):  #类名通常大写 （）内之所继承的父类
    count = 0;
    books = [];
    def __init__(self,name,age):  #相当于java类的构造器，self为必须存在的一个参数，相当与this
        self.age = age
        self.name = name
    pass
    

__init__ 方法的第一个参数永远是self，代表创建的实例本身，因此__init__方法内部就可以把各种属性绑定到实例上，在创建实例时需要传入对应的参数，但self无需传入。与普通函数相比，在类中定义的函数第一个参数永远是self。

aa = Studeng('lpw',21)

类的数据属性

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

count，books为类数据属性，name和age为实例属性；类属性属于类本身，可以通过类名进行访问/修改，类属性也可以被类的所有实例访问和修改，类定义后可以通过类名动态的添加数据属性。而实例属性只能通过实例访问，实例生成后还可以动态添加实例数据属性。Note:类属性与实例属性取相同名字时，实例属性将屏蔽类属性，可以通过del  lpw.account删除实例的某种属性

下面一段代码演对类数据属性和实例数据属性的访问：

class Student(object):
    count = 0;
    books = [];
    def __init__(self,name,age): #相当于java类的构造器，self为必须存在的一个参数，相当与this
        self.age = age
        self.name = name
    pass

Student.books.extend(['Python','java'])  #list的extend函数是在list后面添加新的列表
print('Student\'s books:%s' %Student.books)
#类能在定义后拓展类属性
Student.hobbies = ['read','run','love']
print (dir(Student))  #可通过dir函数查看类有哪些属性

print

lpw = Student('lpw',21)
print ("%s is %d years old" %(lpw.name, lpw.age))
#下面给实例新增属性gender
lpw.gender = 'male'  #gender属性仅属于实例lpw而非所有实例
print(lpw.hobbies)   #实例lpw可以访问新增的类属性hobbies

特殊的类属性

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

类属性	含义
__name__	类的名字（字符串）
__doc__	类的文档字符串
__bases__	类的所有父类组成的元组
__dict__	类的属性组成的字典
__module__	类所属的模块
__class__	类对象的类型

类的方法：

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

• 实例方法：实例方法的第一个参数必须是self，实例方法只能通过实例进行调用

class Student(object):
    count = 0;
    books = [];
    def __init__(self,name,age): #相当于java类的构造器，self为必须存在的一个参数，相当与this
        self.age = age
        self.name = name
    
    def printInfo(self):  #实例方法
        print ("%s is %d years old" %(self.name, self.age))
    pass
    
lpw = Student('lpw',28)
lpw.printInfo()

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

class Student(object):
    count = 0;
    books = [];
    def __init__(self,name,age): #相当于java类的构造器，self为必须存在的一个参数，相当与this
        self.age = age
        self.name = name
   
    @classmethod
    def printClassMed(cls):
        print(cls.__name__)
    pass
    
Student.printClassMed()
lpw = Student('lpw',21)
lpw.printClassMed()

• 静态方法：静态方法没有参数限制，既不需要实例参数，也不需要类参数，定义的时候使用@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中，通过单下划线”_”来实现模块级别的私有化，一般约定以单下划线”_”开头的变量、函数为模块私有的，也就是说”from moduleName import *”将不会引入以单下划线”_”开头的变量、函数。

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

Python

1 2 3 4 5 6 7 8 9 10

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这个模块后，所有的以”_”开头的变量和函数都没有被引入

双下划线”__”

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

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

Python

1 2 3 4 5 6 7 8 9 10

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”不存在。

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

Python

1 2 3 4

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

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

看下面一个例子：

Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

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 *”时，不会将以一个下划线开头的对象引入。
“__”：双下划线的表示的是私有类型的变量。只能是允许这个类本身进行访问了，连子类也不可以，这类属性在运行时属性名会加上单下划线和类名。