面向对象中的属性

# 面向对象中的属性

一个类是由属性和方法组成的

Python 中定义一个类使用 class 关键字实现，其基本语法格式如下：

class 类名：
    多个（≥0）类属性...
    多个（≥0）类方法...

1
2
3

无论是类属性还是类方法，都无法像普通变量或者函数那样，在类的外部直接使用它们。我们可以将类看做一个独立的空间，则类属性其实就是在类体中定义的变量，类方法是在类体中定义的函数。

类属性又可细分为以下 3 种类型：

类体中、所有函数之外：此范围定义的变量，称为类属性或类变量；
类体中，所有函数内部：以“self.变量名”的方式定义的变量，称为实例属性或实例变量；
类体中，所有函数内部：以“变量名=变量值”的方式定义的变量，称为局部变量。
私有静态属性、私有对象属性

# 类变量（类属性）

类变量指的是在类中，但在各个类方法外定义的变量。举个例子：

class CLanguage :
    # 下面定义了2个类变量
    name = "C语言中文网"
    add = "http://c.biancheng.net"
    # 下面定义了一个say实例方法
    def say(self, content):
        print(content)

# ame 和 add 就属于类变量。

1
2
3
4
5
6
7
8
9

类变量的特点是，所有类的实例化对象都同时共享类变量，也就是说，类变量在所有实例化对象中是作为公用资源存在的。

类方法的调用方式有 2 种，

使用类名直接调用
使用类的实例化对象调用

使用类名直接调用，比如，在 CLanguage 类的外部，添加如下代码：

# 类变量调用方式
# 1、使用类名直接调用
print(CLanguage.name)
print(CLanguage.add)

c = CLanguage()
# 2、通过实例调用
c.name
print(c.name)

"""
C语言中文网
http://c.biancheng.net
C语言中文网
"""

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

通过类名不仅可以调用类变量，也可以修改它的值。

使用类的实例化对象调用，使用类对象来调用所属类中的类变量（此方式不推荐使用，原因后续会讲）。例如，在 CLanguage 类的外部，添加如下代码：

# 修改类变量的值
print("修改前，各类对象中类变量的值：")
clang1 = CLanguage()
print(clang1.name)
clang2 = CLanguage()
print(clang2.name)

print("修改后，各类对象中类变量的值：")
CLanguage.name = "Python教程"
print(clang1.name)
print(clang2.name)

"""
修改前，各类对象中类变量的值：
C语言中文网
C语言中文网
修改后，各类对象中类变量的值：
Python教程
Python教程
"""

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

注意，因为类变量为所有实例化对象共有，通过类名修改类变量的值，会影响所有的实例化对象。

值得一提的是，除了可以通过类名访问类变量之外，还可以动态地为类和对象添加类变量。例如，在 CLanguage 类的基础上，添加以下代码：

# 添加类变量
clang = CLanguage()
CLanguage.catalog = 13
print(clang.catalog)

"""
13
"""

1
2
3
4
5
6
7
8

注意，通过类对象是无法修改类变量的。通过类对象对类变量赋值，其本质将不再是修改类变量的值，而是在给该对象定义新的实例变量（在讲实例变量时会进行详细介绍）。

# 实例变量（实例属性）

实例变量指的是在任意类方法内部，以“self.变量名”的方式定义的变量，其特点是只作用于调用方法的对象。另外，实例变量只能通过对象名访问，无法通过类名访问。

class CLanguage:
    def __init__(self):
        self.name = "C语言中文网"
        self.add = "http://c.biancheng.net"

    # 下面定义了一个say实例方法
    def say(self):
        self.catalog = 13

# 其中，由于 __init__() 函数在创建类对象时会自动调用，而 say() 方法需要类对象手动调用。因此，CLanguage 类的类对象都会包含 name 和 add 实例变量，而只有调用了 say() 方法的类对象，才包含 catalog 实例变量。

clang = CLanguage()
print(clang.name)
print(clang.add)
# 由于 clang 对象未调用 say() 方法，因此其没有 catalog 变量，下面这行代码会报错
# print(clang.catalog)
"""
C语言中文网
http://c.biancheng.net
"""

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

类中，实例变量和类变量可以同名，但这种情况下使用类对象将无法调用类变量，它会首选实例变量，这也是不推荐“类变量使用对象名调用”的原因。

class CLanguage:
    name = "类变量"

    def __init__(self):
        self.name = "C语言中文网"
        self.add = "http://c.biancheng.net"

    # 下面定义了一个say实例方法
    def say(self):
        self.catalog = 13

# 其中，由于 __init__() 函数在创建类对象时会自动调用，而 say() 方法需要类对象手动调用。因此，CLanguage 类的类对象都会包含 name 和 add 实例变量，而只有调用了 say() 方法的类对象，才包含 catalog 实例变量。

clang = CLanguage()
print(clang.name)
print(clang.add)
# 由于 clang 对象未调用 say() 方法，因此其没有 catalog 变量，下面这行代码会报错
# print(clang.catalog)
"""
C语言中文网
http://c.biancheng.net
"""

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

另外，和类变量不同，通过某个对象修改实例变量的值，不会影响类的其它实例化对象，更不会影响同名的类变量。例如：

class CLanguage :
    name = "xxx"  #类变量
    add = "http://"  #类变量
    def __init__(self):
        self.name = "C语言中文网"   #实例变量
        self.add = "http://c.biancheng.net"   #实例变量
    # 下面定义了一个say实例方法
    def say(self):
        self.catalog = 13  #实例变量

# 类变量不同，通过某个对象修改实例变量的值，不会影响类的其它实例化对象，更不会影响同名的类变量
clang = CLanguage()
# 修改 clang 对象的实例变量
clang.name = "python教程"
clang.add = "http://c.biancheng.net/python"
print(clang.name)
print(clang.add)

clang2 = CLanguage()
print(clang2.name)
print(clang2.add)
# 输出类变量的值
"""
python教程
http://c.biancheng.net/python
C语言中文网
http://c.biancheng.net
"""

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

不仅如此，Python 只支持为特定的对象添加实例变量。例如，在之前代码的基础上，为 clang 对象添加 money 实例变量，实现代码为：

clang.money = 30
print(clang.money)  # 30

1
2

# 局部变量

除了实例变量，类方法中还可以定义局部变量。和前者不同，局部变量直接以“变量名=值”的方式进行定义，例如：

class CLanguage:
    # 下面定义了一个count实例方法
    def count(self, money):
        sale = 0.8 * money  # 局部变量
        print("优惠后的价格为：", sale)

clang = CLanguage()
clang.count(100)

"""
优惠后的价格为： 80.0
"""

1
2
3
4
5
6
7
8
9
10
11
12

通常情况下，定义局部变量是为了所在类方法功能的实现。需要注意的一点是，局部变量只能用于所在函数中，函数执行完成后，局部变量也会被销毁。

# 私有静态属性、私有对象属性

对于每一个类的成员而言都有两种形式：

公有成员，在任何地方都能访问
私有成员，只有在类的内部才能方法

私有成员和公有成员的访问限制不同：

静态字段(静态属性)

公有静态字段：类可以访问；类内部可以访问；派生类中可以访问
私有静态字段：仅类内部可以访问；

class C:
    __name = "私有静态字段"

    def func(self):
        print(C.__name)

class D(C):
    def show(self):
        print(C.__name)

# C.__name  # 不可在外部访问
obj = C()
# obj.__name  # 不可在外部访问
obj.func()  # 类内部可以访问
obj_son = D()
obj_son.show()  # 不可在派生类中可以访问

# 私有静态字段

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

class C:
    def __init__(self):
        self.__foo = "私有字段"
    def func(self):
        print self.foo 　#　类内部访问
class D(C):
    def show(self):
        print self.foo　＃　派生类中访问
obj = C()
obj.__foo     # 通过对象访问    ==> 错误
obj.func()  # 类内部访问        ==> 正确
obj_son = D();
obj_son.show()  # 派生类中访问  ==> 错误
私有普通字段

1
2
3
4
5
6
7
8
9
10
11
12
13
14

编辑

上次更新: 2023/05/17, 23:08:21

← 面向对象、面向过程面向对象中的方法→