Python 类

1. 通过class关键字定义自己的类。

 1.1 当实例化一个类时：

       ① 先被调用的：__new__。

        ② __int__用于实例化一个类。

class CoalCrawler:
    def __init__(self, log_file, start_date, end_date, out_file):
        """

        Args:
            log_file:日志文件
            start_date:待抓取数据的开始日期
            end_date:待抓取数据的结束日期
            out_file:抓取结果的存放文件
        """
        self.__log_file = log_file
        self.__url = "http://www.cctd.com.cn/list-148-"
        self.__suffix = '.html'
        self.__start_date = datetime.strptime(start_date,  '%Y-%m-%d')
        self.__end_date = datetime.strptime(end_date,  '%Y-%m-%d')
        self.__out_file = out_file

　2. 方法：在一个类中，可能出现三种方法，实例方法、静态方法和类方法。

    实例方法

  实例方法只能通过类实例进行调用，这时候”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()

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

3. 访问控制

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