系统管理►python实战

python类的内置方法和继承

python内部类

内部类，就是在类的内部定义的类，主要目的是为了更好的抽象现实世界。

内部类的实例化方法

  • 方法1 直接使用外部类调用内部类
    object_name = outclass_name.inclass_name() 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    #!/usr/bin/python

    class People(object):
        color = 'yellow'
        __age = 30

        class Chinese(object):
            name = "I am chinese"

    jack = People.Chinese()
    print jack.name

执行结果

1
I am chinese

访问方法可以有多种

1
2
3
4
5
6
7
8
9
10
11
#!/usr/bin/python

class People(object):
    color = 'yellow'
    __age = 30

    class Chinese(object):
        name = "I am chinese"

print People.Chinese.name
print People.Chinese().name

通过类的方法访问
People.Chinese.name
通过对象的方法访问
People.Chinese().name
对于公有属性，可以通过上述两种方式都可以。

  • 方法2
    先对外部类进行实例化，然后再实例化内部类。 
    1
    2
    3
    out_name = outclass_name()
    in_name = out_name.inclass_name()
    in_name.method()
1
2
3
4
5
6
7
8
9
10
11
12
#!/usr/bin/python

class People(object):
    color = 'yellow'
    __age = 30

    class Chinese(object):
        name = "I am chinese"

ren = People()
jack = ren.Chinese()
print jack.name

执行结果

1
I am chinese

类的内置方法(魔术方法)

__str__(self)默认在类实例化过程中就会执行，不需要调用。

1
2
3
4
5
6
7
8
9
#!/usr/bin/python

class People(object):
    color = 'yellow'
    __age = 30


ren = People()
print ren

执行结果

1
<__main__.People object at 0x7f40dfcbbd90>

当添加__str__后

1
2
3
4
5
6
7
8
9
10
11
#!/usr/bin/python

class People(object):
    color = 'yellow'
    __age = 30

    def __str__(self):
        return 'this is a people class'

ren = People()
print ren

执行结果

1
this is a people class

  • 构造函数
    __init__()
    用于初始化类的内部状态，如果不提供，python会给出一个默认的__init__方法。 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    #!/usr/bin/python

    class People(object):
        color = 'yellow'
        __age = 30

        def __init__(self,c='white'):
            self.color = c      

    ren = People()
    print ren.color
    print People.color

执行结果

1
2
white
yellow

使用类访问不会发生变化。
使用对象访问，值会根据传入的参数发生变化。

  • 析构函数
    __del__()
    用于释放对象占用的资源，如果不提供，python会在后台提供默认析构函数。
    析构函数在执行完成的最后再执行。

    垃圾回收机制

    python采用垃圾回收机制清理不再使用的对象：python提供gc模块释放不再使用的对象。
    python采用“引用计数”的算法方式来处理回收，即当某个对象在其作用域内不再被其他对象引用的时候，python就自动清除对象。
    gc模块的collect()可以一次性收集所有待处理的对象(gc.collect)。

    python类的继承

    使用继承

    继承可以重用已经存在的数据和行为，减少代码的重复编写。
    python在类名后使用一堆括号来表示继承关系，括号中的类即为父类。
    class Myclass(ParentClass)
    如果父类定义了__init__方法，子类必须显式调用父类的__init__方法(父类的init参数>=2的时候)。
    ParentClass.__init__(self,[args...])
    如果子类需要扩展父类的行为，可以添加init方法的参数。 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    #!/usr/bin/python

    class People(object):
        color = 'yellow'
        __age = 30

        def __init__(self,c):
            self.color = c      

        def think(self):
            print "I am a %s" % self.color
            print "I am a thinker"

    class Chinese(People):
        def __init__(self):
            People.__init__(self,'red')
        pass

    cn = Chinese()
    print cn.color
    cn.think()

输出结果

1
2
3
red
I am a red
I am a thinker

  • 使用super继承父类
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    #!/usr/bin/python

    class People(object):
        color = 'yellow'
        __age = 30

        def __init__(self,c):
            self.color = c      

        def think(self):
            print "I am a %s" % self.color
            print "I am a thinker"

    class Chinese(People):
        def __init__(self):
            super(Chinese, self).__init__('red')
        pass

    cn = Chinese()
    print cn.color
    cn.think()

执行结果

1
2
red
I am a red

多重继承

python支持多重继承，即一个类可以继承多个父类。
class class_name(Parent_c1,Parent_c2,...)
注意：当父类中出现多个自定义的__init__方法时，多重继承只执行第一个类的__int__方法，其他不执行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#!/usr/bin/python

class People(object):
    color = 'yellow'

    def __init__(self):
        print "init..."
        self.dwell ='Earth'       

    def think(self):
        print "I am a %s" % self.color
        print "My home is %s" % self.dwell

class Martian(object):
    color = 'red'

    def __init__(self):
        self.dwell ='Martian'       

class Chinese(Martian,People):
    pass

cn = Chinese()
cn.think()

输出结果

1
2
I am a red
My home is Martian

当继承更换顺序时

1
2
class Chinese(People,Martian):
    pass

执行结果

1
2
3
init...
I am a yellow
My home is Earth

Recommended Posts