系统管理►python实战

python面向对象及类的属性和方法

python面向对象

面向过程：函数式编程，C程序。
面向对象：C++,Java,Python等。

1
2
3
4
str.+TAB键    查看字符串的方法
list. +TAB键    查看列表的方法
tuple. +TAB键    查看元组的方法
dict. +TAB键    查看字典的方法

类和对象

类：对事物的抽象，比如：人类，球类。
对象：类的一个实例，比如：篮球，足球。
实例的说明：
球类可以对球的特征和行为进行抽象，然后可以实例化一个真实的球实体出来。
面向对象的思想：封装、继承、多态。

类的定义

类把需要的变量和函数组合在一起，这种包含称为封装。

1
class A(object):

命名：1个单词首字母大写，多个单词首字母都大写。
创建对象的过程称之为实例化；当一个对象被创建之后，包含3方面的特性：对象句柄、属性和方法。
句柄用于区分不同的对象。
对象的属性和方法与类中的成员变量和成员函数对应。

1
obj = MyClass()  //创建类的一个实例(对象)，通过对象调用方法和属性

类的结构

1
2
3
class 类名:
	成员变量 – 属性
	成员函数 – 方法

类的创建

1
2
3
class MyClass(object):
    def fun(self):
        print “I am function”

类的方法至少有一个参数self。

实例

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

class People(object):
    color = 'yellow'

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

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

输出结果

1
2
3
yellow
I am a black
I am a thinker

类的属性

定义

按使用范围：私有属性和公有属性。
公有属性：在类中和类外都能调用的属性。
私有属性：不能再类外及被类以外的函数调用。
定义方式：以””双下划线开始的成员变量就是私有属性，可以通过instance._classname_attribute方式访问(不建议使用，仅用于测试)。
内置属性：由系统在定义类的时候默认添加的，由前后双下划线构成，`dict、module__`。
支持中文的写法

1
2
3
#coding:utf8
#encoding:utf8
#coding:utf-8

实例

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
#coding:utf8

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

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

ren = People()
ren.color = '白色人'
print ren.color
ren.think()
#print ren.__age
print ren._People__age
print ren.__dict__
print '#' * 30
print People.color
print '#' *30
print People.__dict__

输出结果

1
2
3
4
5
6
7
8
9
10
白色人
I am a black
I am a thinker
30
30
{'color': 'black'}
##############################
yellow
##############################
{'__module__': '__main__', 'color': 'yellow', '__doc__': None, '__dict__': <attribute '__dict__' of 'People' objects>, '_People__age': 30, '__weakref__': <attribute '__weakref__' of 'People' objects>, 'think': <function think at 0x7f95deb1bc08>}

类的方法

方法的定义和函数一样，但是需要self作为第一个参数。

分类

公有方法：在类中和类外都可以调用的。
私有方法：不能被类的外部调用，在方法前面加上”__”双下划线。
self参数：用于分区函数和类方法(必须有一个self)，self参数表示执行对象本身。
类方法：被classmethod()函数处理过的函数，能被类所调用，也能被对象所调用(是继承的关系)。
静态方法：相当于全局函数，可以被类直接调用，可以被所有实例化对象共享，通过staticmethod()定义，静态方法没有self参数。

实例

  • 公有方法调用
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    #!/usr/bin/python
    #coding:utf8

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

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

    jack = People()
    jack.test()

输出结果

1
2
3
I am a yellow
I am a thinker
30

  • 私有方法
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    #!/usr/bin/python
    #coding:utf8

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

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

        def __talk(self):
            print "I am talking with Tom"

        def test(self):
            self.__talk()

    jack = People()
    jack.test()
    jack.__talk()

输出结果

1
2
3
4
5
I am talking with Tom
Traceback (most recent call last):
  File "1_9_4.py", line 21, in <module>
    jack.__talk()
AttributeError: 'People' object has no attribute '__talk'

  • 类方法
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    #!/usr/bin/python
    #coding:utf8

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

        def test(self):
            print "Testing..."

        cm = classmethod(test)

    jack = People()
    People.cm()
    People.test()

输出结果(类方法必须经过classmethod方法处理，否则会报错如下)

1
2
3
4
5
Testing...
Traceback (most recent call last):
  File "1_9_4_1.py", line 15, in <module>
    People.test()
TypeError: unbound method test() must be called with People instance as first argument (got nothing instead)

  • 静态方法
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    #!/usr/bin/python
    #coding:utf8

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

        def test():
            print "this is a func"

        sm = staticmethod(test)

    jack = People()
    People.sm()

输出结果

1
this is a func

  • 装饰器(仅对相邻的第一个函数起作用,类方法和静态方法的简化)
    @classmethod
    @statucmethod
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    #!/usr/bin/python
    #coding:utf8

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

        @classmethod
        def test(self):
            print "this is a class method"

        @staticmethod
        def test1():
            print "this is a static method"

    jack = People()
    People.test()
    People.test1()

输出结果

1
2
this is a class method
this is a static method

说明
静态方法：将类的所有属性和方法提前加载到内存。
动态方法：只加载调用的属性和方法至内存，未调用的不加载。

Recommended Posts