Python 类的私有属性和私有方法

桃扇骨 2024-03-27 09:10 98阅读 0赞

在 Python 的面向对象编程中，私有属性是只能在类的实例方法中访问的属性，不允许在外界访问私有属性。

### 1. 私有属性的定义 ###

#### 1.1 定义 ####

在属性名称前加上前缀 \_\_，表示该属性为私有属性，示例代码如下：

class Object:
        def method(self):
            self.__private_attribute = 123

在第 3 行，创建一个私有属性 `__private_attribute`。

#### 1.2 在类外读取私有属性 ####

只能在类的实例方法中访问私有属性，不允许在类的外部访问私有属性，示例代码如下：

class Person:
        def __init__(self, name):
            self.__name = name
     
    tom = Person('tom')
    print(tom.__name)

*  在第 1 行，定义了类 Person
 *  在第 3 行，创建私有属性 \_\_name
 *  在第 5 行，创建一个实例 tom
 *  在第 6 行，直接访问实例的属性 \_\_name

程序运行输出如下：

Traceback (most recent call last):
      File "attr-get.py", line 6, in <module>
        print(tom.__name)
    AttributeError: 'Person' object has no attribute '__name'

程序运行报错：‘Person’ object has no attribute ‘\_\_name’，表示无法找到属性 \_\_name’。因此，**在类 Person 的外部无法直接读取实例的私有属性**。

#### 1.3 在类外修改私有属性 ####

1.2 小节的例子，在类外读取私有属性；本节的例子，在类外修改私有属性。示例代码如下：

class Person:
        def __init__(self, name):
            self.__name = name
     
        def get_name(self):
            return self.__name
    
    tom = Person('tom')
    tom.__name = 'jerry'
    print(tom.get_name())

*  在第 1 行，定义了类 Person
    
     *  在第 3 行，创建私有属性 \_\_name
     *  在第 6 行，在类的实例方法 get\_name 中，访问私有属性 \_\_name
 *  在第 8 行，创建一个实例 tom
    
     *  在第 9 行，将实例的属性 \_\_name 修改为 ‘jerry’
     *  在第 10 行，通过实例方法 get\_name 读取私有属性 \_\_name

*  在第 3 行，创建私有属性 \_\_name
 *  在第 6 行，在类的实例方法 get\_name 中，访问私有属性 \_\_name

*  在第 9 行，将实例的属性 \_\_name 修改为 ‘jerry’
 *  在第 10 行，通过实例方法 get\_name 读取私有属性 \_\_name

程序运行输出如下：

tom

程序在第 9 行，将实例的私有属性 \_\_name 修改为 ‘jerry’，但是程序输出表明：在类的内部，私有属性 \_\_name 没有发生变化。因此，**在类 Person 的外部无法直接修改实例的私有属性**。

#### 1.4 通过 set/get 方法访问私有属性 ####

本节在类的外部访问私有属性的方法，代码如下：

class Person:
        def __init__(self, name):
            self.__name = name
     
        def get_name(self):
            return self.__name
     
        def set_name(self, name):
            self.__name = name
    
    tom = Person('tom')
    tom.set_name('jerry')
    print(tom.get_name())

*  在第 1 行，定义了类 Person
    
     *  在第 3 行，创建私有属性 \_\_name
     *  在第 5 行，创建方法 get\_name，它读取私有属性 \_\_name
     *  在第 8 行，创建方法 set\_name，它修改私有属性 \_\_name
 *  在第 11 行，创建一个实例 tom
    
     *  在第 12 行，通过实例方法 get\_name 读取私有属性 \_\_name
     *  在第 13 行，通过实例方法 set\_name 修改私有属性 \_\_name

*  在第 3 行，创建私有属性 \_\_name
 *  在第 5 行，创建方法 get\_name，它读取私有属性 \_\_name
 *  在第 8 行，创建方法 set\_name，它修改私有属性 \_\_name

*  在第 12 行，通过实例方法 get\_name 读取私有属性 \_\_name
 *  在第 13 行，通过实例方法 set\_name 修改私有属性 \_\_name

程序输出结果如下：

jerry

程序输出表明，通过方法 tom.set\_name(‘jerry’) 成功的将私有属性 \_\_name 设置为 jerry。因此，**在类的外部通过 get/set 方法访问私有属性**。

### 2. 私有属性的应用 ###

#### 2.1 概述 ####

数学中的线段拥有 3 个属性：

*  start，表示开始位置
 *  end，表示结束位置
 *  length，表示线段的长度，等于 end - start

当修改属性 start 时，属性 length 会发生变化；当修改属性 end 时，属性 length 也会发生变化；如果修改属性 start 或者 end 时，忘记修改属性 length 的话，则会造成逻辑错误，示例代码如下：

class Segment:
        def __init__(self, start, end):
            self.start = start
            self.end = end
            self.length = self.end - self.start
    
        def show(self):
            print('start = %d, end = %d, length = %d' % (self.start, self.end, self.length))
    
    segment = Segment(10, 100)
    segment.start = 20
    segment.show()

*  在第 2 行，定义构造方法
    
     *  在第 5 行，使用属性 start 和 end 计算属性 length
 *  在第 7 行，定义方法 show，打印属性 start、end、length
 *  在第 10 行，创建线段 segment，设置 start = 10，end = 100
 *  在第 11 行，将 start 修改为 20
 *  在第 12 行，调用方法 show 打印属性 start、end、length

*  在第 5 行，使用属性 start 和 end 计算属性 length

程序运行输出结果如下：

start = 20, end = 100, length = 90

start 修改为 20 后，length 应该等于 80，但是程序输出表明 length 等于 90。**由于 start 修改后，忘记修改 length，造成了这样的逻辑错误**。

#### 2.2 使用私有属性解决问题 ####

为了解决上个小节中的问题，将属性 start、end、length 设置为私有属性：

*  禁止在外界直接访问这 3 个属性
 *  只能通过对应的 get/set 方法访问这 3 个属性

class Segment:
        def __init__(self, start, end):
            self.__start = start
            self.__end = end
            self.__length = self.__end - self.__start
    
        def get_start(self):
            return self.__start
    
        def set_start(self, start):
            self.__start = start
            self.__length = self.__end - self.__start
    
        def get_end(self):
            return self.__end
    
        def set_end(self, end):
            self.__end = end
            self.__length = self.__end - self.__start
    
        def get_length(self):
            return self.__start
    
        def set_length(self, length):
            self.__length = length
    
        def show(self):
            print('start = %d, end = %d, length = %d' % (self.__start, self.__end, self.__length))
    
    segment = Segment(10, 100)
    segment.set_start(20)
    segment.show()

类 Segment，包含 3 个私有属性，读写这些属性的方法如下：

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>get_start</td> 
   <td>读取属性 start</td> 
  </tr> 
  <tr> 
   <td>set_start</td> 
   <td>设置属性 start</td> 
  </tr> 
  <tr> 
   <td>get_end</td> 
   <td>读取属性 end</td> 
  </tr> 
  <tr> 
   <td>set_end</td> 
   <td>设置属性 end</td> 
  </tr> 
  <tr> 
   <td>get_length</td> 
   <td>读取属性 length</td> 
  </tr> 
  <tr> 
   <td>set_length</td> 
   <td>设置属性 length</td> 
  </tr> 
 </tbody> 
</table>

*  在第 12 行，在 set\_start 方法中，修改属性 start 时，同时重新计算属性 length
 *  在第 19 行，在 set\_end 方法中，修改属性 end 时，同时重新计算属性 length
 *  **在 set 方法中，修改 start 和 end 属性时，同时修改 length 属性，从而保证了一致性，不会出现上个小节中的逻辑错误。**

程序运行输出结果如下：

start = 20, end = 100, length = 80

输出表明，当属性 start 修改为 20 后，属性 length 被修改为 80，避免了上个小节中的错误。

### 3. 私有方法的定义 ###

#### 3.1 定义 ####

在Python 的面向对象编程中, 私有方法是只能在类的实例方法中访问的方法，不允许在外界访问私有方法。在方法名称前加上前缀 \_\_，表示该方法为私有方法，示例代码如下：

class Object:
        def __private_method(self):
            pass

在第 3 行，定义了一个私有方法 \_\_private\_method。

#### 3.2 在类外访问私有方法 ####

私有方法只能在类的内部被调用，不允许在类的外部访问。示例代码如下：

class Object:
        def __private_method(self):
            pass
    
    object = Object()        
    object.__private_method()

*  在第 2 行，定义了一个私有方法 \_\_private\_method
 *  在第 5 行，创建一个实例 object
 *  在第 6 行，调用实例的私有方法 \_\_private\_method

程序运行输出如下：

Traceback (most recent call last):
      File "method-error.py", line 6, in <module>
        object.__private_method()
    AttributeError: 'Object' object has no attribute '__private_method'

程序运行报错：‘Object’ object has no attribute ‘\_\_private\_method’，表示无法找到方法 \_\_private\_method’。因此，**在类 Person 的外部无法调用实例的私有方法**。

### 4. 私有方法的应用 ###

#### 4.1 概述 ####

本节完成一个分析文本的程序，文本由多个单词构成，单词之间使用空格隔开，单词的类型如下：

*  数字，例如 123
 *  字母，例如 abc
 *  操作符，例如 =、+、- 等符号

程序对文本分析后，输出单词的类型和值，假设输入文本为 a = 123，则输出如下：

alpha    a
    operator =
    digit    123

程序的思路如下：

1.  定义方法 parse\_string，它将文本分割为多个单词
2.  定义方法 parse\_word，它判断并打印单词的类型
3.  在方法 parse\_string 中调用 parse\_word 处理每个单词

方法 parse\_word 用于辅助实现方法 parse\_string，不需要被外界访问，因此将其设定为私有方法。

#### 4.2 使用私有方法解决问题 ####

class Parser:
        def __parse_word(self, word):
            if word.isdigit():
                print('digit    %s' % word)
            elif word.isalpha():
                print('alpha    %s' % word)
            elif word == '=' or word == '+' or word == '-':
                print('operator %s' % word)
    
        def parse_string(self, string):
            words = string.split(' ')
            for word in words:
                self.__parse_word(word)
    
    parser = Parser()
    parser.parse_string('sum = sum + 100')

*  在第 2 行，定义私有方法 \_\_parse\_word，判断单词的类型
    
     *  在第 3 行，通过方法 isdigit 判断是否为数字
     *  在第 5 行， 通过方法 isalpha 判断是否为字母
 *  在第 10 行，定义公开方法 parse\_string
    
     *  在第 11 行，使用 split 将文本分割为多个单词
     *  在第 13 行，循环调用私有方法 \_\_parse\_word 处理每个单词
 *  在第 16 行，在类 Parser 的外部，调用公开方法 parse\_string

*  在第 3 行，通过方法 isdigit 判断是否为数字
 *  在第 5 行， 通过方法 isalpha 判断是否为字母

*  在第 11 行，使用 split 将文本分割为多个单词
 *  在第 13 行，循环调用私有方法 \_\_parse\_word 处理每个单词

实现方法 parse\_string 是类 Parser 的接口，外界通过这个方法实现分析文本的功能；**而方法 \_\_parse\_word 是一个辅助方法，它用于实现方法 parse\_string，不需要公开给外界调用，因此将它设定为私有方法**。

程序运行输出如下：

alpha    sum
    operator =
    alpha    sum
    operator +
    digit    100