【Python基础】类

Myth丶恋晨 2023-10-17 08:16 62阅读 0赞

## 类的定义 ##

Python中使用**class**这个关键词来定义类：

#
    # This is an empty class.
    #
    class AClass:
        pass

这里定义了一个空的类，不过这里有一个问题，如果一个类没有定义**\_\_init\_\_**函数，会报告警，所以之类还是加上：

#
    # This is an empty class.
    #
    class AClass:
        def __init__(self):
            pass

这样就是一个比较完整的类了。

这里\_\_init\_\_就是一个构造器。

对于上述这样的空类，其实作用不大，仅仅用作命名空间（namespace），可以存放变量之类的：

#
    # This is an empty class.
    #
    class AClass:
        def __init__(self):
            pass
    
    def Sum(x, y):
        print "%d" % (x + y)
    
    if __name__ == "__main__":
        a = AClass()
        a.x = 0
        a.y = 1
        a.func = Sum
        a.func(a.x, a.y)

上面用到了类的实例化，即a = AClass()。

## 类的成员 ##

类中可以有静态的数据：

#
    # This is a class.
    #
    class AClass:
        Version = 1.0       # Static data.
        def __init__(self):
            pass
    
    if __name__ == "__main__":
        a = AClass()
        print a.Version
        print AClass.Version

类中还可以有函数，一般不叫函数叫方法：

#
    # This is a class.
    #
    class AClass:
        Version = 1.0       # Static data.
        
        def __init__(self):
            pass
        
        def printVersion(self):
            print self.Version
    
    if __name__ == "__main__":
        a = AClass()
        a.printVersion()

可以看到\_\_init\_\_其实也算是方法，两者的定义方式一致。

类中的方法需要跟类的实例绑定，它一般有一个参数self，表示实例本身；

调用方法的时候不需要特别指定这个参数。

类中有很多特定的属性：

if __name__ == "__main__":
        print dir(AClass)

使用dir来查看属性，下面是结果：

['Version', '__doc__', '__init__', '__module__', 'printVersion']

打印结果如下：

['Version', '__doc__', '__init__', '__module__', 'printVersion']
    1.0
    None
    <unbound method AClass.__init__>
    __main__
    <unbound method AClass.printVersion>

这里需要注意：

1. \_\_doc\_\_的值是None，是因为没有定义类的说明，可以通过在class定义之后的下一行加入字符串说明：

#
    # This is a class.
    #
    class AClass:
        'This is a class'
        Version = 1.0       # Static data.
        
        def __init__(self):
            pass
        
        def printVersion(self):
            print self.Version

2. 后面的unbound的原因是因为没有绑定实例，修改后：

if __name__ == "__main__":
        a = AClass()
        print dir(AClass)
        print a.Version
        print a.__doc__
        print a.__init__
        print a.__module__
        print a.printVersion

其结果如下：

['Version', '__doc__', '__init__', '__module__', 'printVersion']
    1.0
    This is a class
    <bound method AClass.__init__ of <__main__.AClass instance at 0x00000000056B4D48>>
    __main__
    <bound method AClass.printVersion of <__main__.AClass instance at 0x00000000056B4D48>>

前面提到方法与实例是绑定的，也存在两种方法虽然定义在类中，但是不需要与类绑定，它们是静态方法和类方法：

#
    # This is a class.
    #
    class AClass:
        'This is a class'
        Version = 1.0       # Static data.
        
        def __init__(self):
            pass
        
        def printVersion(self):
            print self.Version
        
        @staticmethod
        def printVersionSts():
            print "%d" % AClass.Version
        
        @classmethod
        def printVersionCls(cls):
            print "%d" % cls.Version
    
    if __name__ == "__main__":
        print AClass.printVersionSts
        print AClass.printVersionCls
        AClass.printVersionSts()
        AClass.printVersionCls()

得到的结果如下：

<function printVersionSts at 0x0000000004D52128>
    <bound method classobj.printVersionCls of <class __main__.AClass at 0x00000000047F9828>>
    1
    1

静态方法和类方法通过@staticmethod和@classmethod来修饰。

可以看到它们是直接的绑定的。

类成员一般会区分Public，Private等的，默认Python只有Public类，但是可以通过一些方法类指定Private的类。

在成员名前加双下划线来实现：

#
    # This is a class.
    #
    class AClass:
        'This is a class'
        Version = 1.0       # Static data.
        
        def __init__(self):
            pass
        
        def __printVersion(self):
            print self.Version
    
    if __name__ == "__main__":
        a = AClass()
        a.__printVersion()

这个时候PyLint会报错：

PyLint: Access to a protected member __printVersion of a client class

执行的时候会报错：

Traceback (most recent call last):
      File "D:\Code\python_tool_code\LearningPython\Class.py", line 20, in <module>
        a.__printVersion()
    AttributeError: AClass instance has no attribute '__printVersion'

## 类的继承 ##

Python中继承直接使用圆括号**()**：

#
    # Define a father class.
    #
    class Father:
        #
        # __init__ should be defined.
        #
        def __init__(self, name):
            self.name = name
        
        def introduceYourself(self):
            print "This is %s." % self.name
    #
    # Inheritance from Father.
    #
    class Children(Father):          # Use "()" for interitance.
        pass

这里就定义了一个继承类Children。

下面是一些使用代码：

#
    # Inheritance from Father.
    #
    class Children(Father):          # Use "()" for interitance.
        def introduceYourself(self):
            Father.introduceYourself(self)
            print "This is drived from Father."
    
    if __name__ == "__main__":
        p = Father("father")
        print Father.__bases__
        p.introduceYourself()
         
        s = Children("son")
        print Children.__bases__
        s.introduceYourself()

下面是运行的结果：

()
    This is father.
    (<class __main__.Father at 0x0000000004D38BE8>,)
    This is son.
    This is drived from Father.

需要说明的是：

1. 这里Father没有指定从哪里继承，实际默认就是从object继承；不过手动指定之后：

class Father(object):

得到的结果如下：

(<type 'object'>,)

2. Children从Father继承了所以可以看到**\_\_bases\_\_**有打印；

3. 子类可以Override父类的方法；

4. 子类会自动调用父类的\_\_init\_\_方法，除非子类Override了父类的\_\_init\_\_方法，此时就需要在子类的\_\_init\_\_里面指定调用父类的\_\_init\_\_（除非不需要）；

Python支持多重继承，这里先不讲。