当前位置：首页 > news >正文

练习题：20

news 来源：原创 2025/7/2 19:11:47

Python题目

题目

设计一个整数类MyInteger，它有一个整数变量，并有一个Value属性，可以通过为Value存取该变量的值，还有一个转二进制字符串的成员函数toBin及转十六进制字符串的成员函数toHex。

题目分析

1. 类与变量、属性设计分析

类的作用与抽象概念：
在 Python 中，定义 MyInteger 类旨在对整数这一数据类型进行更具功能性的封装与抽象。通过创建这个类的对象，可以将整数以一种更符合特定需求的方式进行管理和操作，使其不仅仅是一个简单的数值，而是具备了额外的属性和行为。
整数变量与 Value 属性：
类中需要有一个整数变量来实际存储整数值，它是这个类所代表整数的核心数据。而 Value 属性的作用是提供一种对外的接口，方便对这个内部的整数变量进行值的获取和设置操作。从外部来看，通过访问 Value 属性，就能如同操作普通变量一样获取或修改类中所封装的整数值，这样的设计增强了数据的封装性和访问控制，使得类的内部实现细节（即实际存储整数值的那个整数变量）可以相对独立，同时对外提供统一、规范的访问方式。

2. `Value` 属性的实现分析

属性访问与修改逻辑：
对于 Value 属性，在 Python 中可以通过使用 @property 装饰器和对应的 @Value.setter 装饰器来实现其既能获取值又能设置值的功能。
- 获取值（@property 装饰器部分）：在定义获取值的方法时，只需简单地返回内部存储整数变量的值即可。例如，如果内部整数变量名为 _num，那么获取 Value 属性值的方法可以写成类似 @property 装饰的 def Value(self): return self._num 的形式，这样当在外部通过对象访问 Value 属性（如 obj.Value，obj 为 MyInteger 类的对象）时，就能够获取到内部存储的整数值。
- 设置值（@Value.setter 装饰器部分）：定义设置值的方法时，接收一个参数作为要设置的新值，并将这个新值赋给内部的整数变量。例如，@Value.setter 装饰的 def Value(self, new_value): self._num = new_value，这样当在外部通过对象对 Value 属性进行赋值操作（如 obj.Value = 5）时，就能将新的整数值传递到类内部，更新存储的整数值。

3. 转换函数分析

toBin 函数功能与实现思路：
toBin 函数的目标是将类中存储的整数转换为二进制字符串形式。在 Python 中，可以利用内置的函数来实现这个功能，比如 bin() 函数，它接受一个整数作为参数，并返回对应的二进制表示形式的字符串（以 0b 开头），不过通常我们希望去掉开头的 0b 标识，使其更符合常规的二进制字符串表示习惯。所以在 toBin 函数内部，可以先调用 bin() 函数获取二进制字符串，然后通过字符串切片等操作（如 [2:]）去掉开头的 0b，将处理后的二进制字符串作为函数的返回值，这样调用 toBin 函数时就能得到一个干净的、代表该整数的二进制字符串表示。
toHex 函数功能与实现思路：
toHex 函数用于把整数转换为十六进制字符串形式。类似地，Python 提供了 hex() 内置函数来实现这个转换，它会返回以 0x 开头的十六进制表示形式的字符串。同样为了得到更符合常规使用习惯的十六进制字符串，在 toHex 函数内部，可以在调用 hex() 函数后，通过合适的字符串处理方法（如切片操作去掉 0x 开头部分）对返回的字符串进行调整，最终返回处理后的十六进制字符串，使得调用 toHex 函数能够获取到代表该整数的十六进制字符串表示。

4. 整体代码结构与编程规范考虑

代码布局与缩进规则：
整个代码按照 Python 的类定义语法规范编写，MyInteger 类的定义放在一个代码块中，Value 属性的获取和设置方法以及 toBin、toHex 函数作为类的方法依次定义在类内部，并且严格遵循 Python 的代码缩进规则（通常采用 4 个空格缩进表示代码块的层次关系），以此保证代码结构清晰，符合 Python 编程的语法和风格要求。
命名规范与可读性：
在为类名、函数名以及内部变量名命名时，尽量选择有意义且符合 Python 命名规范的名称。例如，类名采用大驼峰命名法（像 MyInteger），函数名采用小写字母加下划线的方式（如 toBin、toHex 等），对于内部的整数变量，可以采用下划线开头的命名方式（如 _num）来表示它是类的内部实现细节，这样的命名有助于提高代码的可读性和可维护性，方便自己以及其他阅读代码的人快速理解代码的意图和各个部分的功能。

代码实现

class MyInteger:def __init__(self, num):"""构造函数，用于初始化MyInteger类对象，接收一个整数参数并赋值给内部变量:param num: 整数，用于初始化对象内部存储的数值"""self._num = num@propertydef Value(self):"""Value属性的获取方法，用于获取内部存储的整数值:return: 返回内部的整数值"""return self._num@Value.setterdef Value(self, new_value):"""Value属性的设置方法，用于设置内部存储的整数值:param new_value: 要设置的新整数值"""self._num = new_valuedef toBin(self):"""将内部存储的整数转换为二进制字符串的成员函数:return: 去掉前缀'0b'后的二进制字符串表示"""return bin(self._num)[2:]def toHex(self):"""将内部存储的整数转换为十六进制字符串的成员函数:return: 去掉前缀'0x'后的十六进制字符串表示"""return hex(self._num)[2:].lower()# 创建MyInteger类的对象并进行相关操作测试
num_obj = MyInteger(10)
print("初始Value属性值:", num_obj.Value)
num_obj.Value = 15
print("修改后Value属性值:", num_obj.Value)
print("转换为二进制字符串:", num_obj.toBin())
print("转换为十六进制字符串:", num_obj.toHex())

代码解释

1. 类定义部分

class MyInteger:def __init__(self, num):"""构造函数，用于初始化MyInteger类对象，接收一个整数参数并赋值给内部变量:param num: 整数，用于初始化对象内部存储的数值"""self._num = num@propertydef Value(self):"""Value属性的获取方法，用于获取内部存储的整数值:return: 返回内部的整数值"""return self._num@Value.setterdef Value(self, new_value):"""Value属性的设置方法，用于设置内部存储的整数值:param new_value: 要设置的新整数值"""self._num = new_valuedef toBin(self):"""将内部存储的整数转换为二进制字符串的成员函数:return: 去掉前缀'0b'后的二进制字符串表示"""return bin(self._num)[2:]def toHex(self):"""将内部存储的整数转换为十六进制字符串的成员函数:return: 去掉前缀'0x'后的十六进制字符串表示"""return hex(self._num)[2:].lower()

构造函数 __init__：
- 它接收一个参数 num，这个参数就是要存储在对象内部的整数值。在函数内部，通过 self._num = num 将传入的参数值赋给对象的私有属性（以单下划线开头表示是类内部使用的属性，虽然 Python 并没有真正的私有属性限制，但这是一种约定俗成的表示方式）self._num，完成对象的初始化，使得每个 MyInteger 类的对象都有自己对应的初始整数值。
Value 属性相关方法：
- 获取方法（使用 @property 装饰器）：定义了 @property 装饰的 def Value(self) 方法，其内部只有简单的 return self._num 语句，这意味着当在外部通过对象访问 Value 属性（例如 obj.Value，obj 为 MyInteger 类的对象）时，Python 解释器会自动调用这个方法，返回对象内部存储的整数值，实现了获取值的功能。
- 设置方法（使用 @Value.setter 装饰器）：@Value.setter 装饰的 def Value(self, new_value) 方法用于设置 Value 属性的值。它接收一个参数 new_value，代表要设置的新整数值，通过 self._num = new_value 语句将这个新值赋给对象内部的 self._num 属性，这样当在外部通过对象对 Value 属性进行赋值操作（如 obj.Value = 5）时，就能更新对象内部存储的整数值，实现了属性值的修改功能。
toBin 函数：
- 这个函数的目的是将对象内部存储的整数转换为二进制字符串形式。在函数内部，先调用 bin(self._num) 语句，利用 Python 内置的 bin() 函数将 self._num（即对象内部存储的整数）转换为二进制表示形式的字符串（该字符串默认以 0b 开头），然后通过字符串切片操作 [2:] 去掉开头的 0b 标识，最后返回处理后的二进制字符串，使得调用该函数能够获取到符合常规习惯的二进制字符串表示。
toHex 函数：
- 用于把对象内部存储的整数转换为十六进制字符串形式。函数内部先执行 hex(self._num) 语句，调用 Python 内置的 hex() 函数将整数转换为十六进制表示形式的字符串（该字符串以 0x 开头），接着通过 [2:] 切片操作去掉开头的 0x 部分，再调用 lower() 方法将字符串中的字母转换为小写形式（使十六进制字符串更规范统一），最后返回处理后的十六进制字符串，这样调用 toHex 函数就能得到合适的十六进制字符串表示。

2. 对象创建与功能测试部分

# 创建MyInteger类的对象并进行相关操作测试
num_obj = MyInteger(10)
print("初始Value属性值:", num_obj.Value)
num_obj.Value = 15
print("修改后Value属性值:", num_obj.Value)
print("转换为二进制字符串:", num_obj.toBin())
print("转换为十六进制字符串:", num_obj.toHex())

对象创建：
首先使用 num_obj = MyInteger(10) 语句创建一个 MyInteger 类的对象 num_obj，在创建过程中，Python 解释器会自动调用 MyInteger 类的构造函数 __init__，将实参 10 传递给 num 参数，进而通过 self._num = num 语句将 10 赋给对象内部的 self._num 属性，完成对象的初始化，使得 num_obj 对象初始存储的整数值为 10。
属性值获取与修改测试：
- 通过 print("初始Value属性值:", num_obj.Value) 语句，调用 num_obj 对象的 Value 属性的获取方法（通过 @property 装饰器定义的方法），获取并打印出对象内部存储的初始整数值 10。
- 接着执行 num_obj.Value = 15 语句，调用 num_obj 对象的 Value 属性的设置方法（通过 @Value.setter 装饰器定义的方法），将对象内部存储的整数值更新为 15。然后通过 print("修改后Value属性值:", num_obj.Value) 语句再次获取并打印 Value 属性值，验证值已经被成功修改为 15。
转换函数测试：
- 通过 print("转换为二进制字符串:", num_obj.toBin()) 语句，调用 num_obj 对象的 toBin 函数，将对象内部存储的整数（此时为 15）转换为二进制字符串并打印出来，输出结果为对应的二进制字符串表示（例如 1111）。
- 最后通过 print("转换为十六进制字符串:", num_obj.toHex()) 语句，调用 num_obj 对象的 toHex 函数，将整数转换为十六进制字符串并打印，输出结果为对应的十六进制字符串表示（例如 f），以此完成对 MyInteger 类各个功能的测试验证。

运行思路

1. 类定义阶段

当 Python 解释器开始执行包含 MyInteger 类定义的代码时：

class MyInteger:def __init__(self, num):"""构造函数，用于初始化MyInteger类对象，接收一个整数参数并赋值给内部变量:param num: 整数，用于初始化对象内部存储的数值"""self._num = num@propertydef Value(self):"""Value属性的获取方法，用于获取内部存储的整数值:return: 返回内部的整数值"""return self._num@Value.setterdef Value(self, new_value):"""Value属性的设置方法，用于设置内部存储的整数值:param new_value: 要设置的新整数值"""self._num = new_valuedef toBin(self):"""将内部存储的整数转换为二进制字符串的成员函数:return: 去掉前缀'0b'后的二进制字符串表示"""return bin(self._num)[2:]def toHex(self):"""将内部存储的整数转换为十六进制字符串的成员函数:return: 去掉前缀'0x'后的十六进制字符串表示"""return hex(self._num)[2:].lower()

首先遇到 class MyInteger: 语句，Python 解释器会识别这是在定义一个名为 MyInteger 的类，并为这个类分配相应的内存空间，用于存储类的相关信息，比如后续要定义的方法、属性等内容。
接着定义构造函数 __init__，解释器会记录这个特殊方法是用于创建 MyInteger 类对象时进行初始化操作的。在函数内部，执行 self._num = num 语句时，它明白这是将传入的参数值赋给对象的特定属性（这里 self 代表即将创建的对象实例自身，_num 是类内部用来存储整数值的变量），不过此时只是定义好了构造函数的逻辑，还没有实际对象创建，所以这部分代码处于等待被调用执行的状态。
然后定义 Value 属性相关的获取和设置方法：
- 对于 @property 装饰的 Value 获取方法，解释器会识别这是定义了一个属性的获取行为，当通过对象访问该属性时会执行此方法返回对应的值，这里就是返回 self._num 的值，此时只是记录下这个逻辑，等待后续对象实例化后的调用。
- 对于 @Value.setter 装饰的设置方法，解释器知道这是用于处理对 Value 属性进行赋值操作的逻辑，它接收一个参数 new_value 并将其赋给 self._num，同样也是先记录下此逻辑，暂未实际执行。
再定义 toBin 和 toHex 函数时，解释器会记录这两个方法属于 MyInteger 类，分别用于将对象内部存储的整数转换为二进制和十六进制字符串形式，其内部的代码逻辑（如调用内置函数及字符串处理操作等）也只是先记录下来，等待对象调用这些函数时再执行。

2. 对象创建阶段

num_obj = MyInteger(10)

执行到这行代码时，Python 解释器会着手创建 MyInteger 类的一个对象实例。
首先，会为这个新的对象实例分配内存空间，用来存储对象的属性值（也就是 _num 这个变量的值）以及其他和对象相关的元数据。
之后，自动调用 MyInteger 类中定义的 __init__ 构造函数，将实参 10 传递给构造函数中的 num 参数。
在构造函数内部，通过 self._num = num 语句，把传入的整数 10 赋给新创建对象的 self._num 属性，从而完成对象 num_obj 的初始化工作，使得 num_obj 对象在内存中保存了初始整数值为 10。

3. 获取 `Value` 属性值阶段（`print("初始Value属性值:", num_obj.Value)` 语句）

执行这行代码时，Python 解释器看到 num_obj.Value 的访问形式，会根据对象 num_obj 找到它所属的 MyInteger 类，然后识别出这是在访问 Value 属性。
由于 Value 属性通过 @property 装饰器进行了定义，解释器会自动调用对应的 Value 获取方法（即 def Value(self): return self._num 这个方法）。
在该方法内部，通过 return self._num 语句返回 num_obj 对象的 self._num 属性值，此时该值为 10，这个 10 就会作为表达式 num_obj.Value 的结果传递给 print 函数，最终在控制台输出 初始Value属性值: 10。

4. 设置 `Value` 属性值阶段（`num_obj.Value = 15` 语句）

执行这行代码时，Python 解释器看到对 num_obj 对象的 Value 属性进行赋值的操作，会根据对象找到所属的 MyInteger 类，并识别出这是要调用 Value 属性的设置方法（通过 @Value.setter 装饰器定义的方法）。
然后将赋值语句右边的值 15 作为参数传递给 Value 设置方法中的 new_value 参数。
在 Value 设置方法内部，通过 self._num = new_value 语句，把传入的 15 赋给 num_obj 对象的 self._num 属性，从而更新了对象内部存储的整数值，完成了属性值的修改操作。

5. 调用 `toBin` 函数阶段（`print("转换为二进制字符串:", num_obj.toBin())` 语句）

执行到这行代码时，Python 解释器会根据对象 num_obj 找到 MyInteger 类中定义的 toBin 函数，并开始执行其内部的代码逻辑。
首先，在 toBin 函数内部执行 bin(self._num) 语句，此时 self._num 为对象 num_obj 中存储的整数值 15（经过前面属性值修改后的值），bin() 函数会将 15 转换为二进制表示形式的字符串，默认得到的字符串是 0b1111。
接着执行 [2:] 字符串切片操作，去掉字符串开头的 0b 标识，得到 1111，然后将这个处理后的二进制字符串作为函数的返回值返回。
最后这个返回的二进制字符串 1111 会作为表达式 num_obj.toBin() 的结果传递给 print 函数，在控制台输出 转换为二进制字符串: 1111。

6. 调用 `toHex` 函数阶段（`print("转换为十六进制字符串:", num_obj.toHex())` 语句）

执行这行代码时，Python 解释器依据对象 num_obj 找到 MyInteger 类中的 toHex 函数，并开始执行其内部代码逻辑。
首先在 toHex 函数内部执行 hex(self._num) 语句，self._num 此时为 15，hex() 函数会将 15 转换为十六进制表示形式的字符串，得到 0xf。
然后执行 [2:] 切片操作去掉开头的 0x 部分，得到 f，再调用 lower() 方法将字符串中的字母转换为小写形式（虽然这里本身就是小写，但如果是其他十六进制数包含大写字母会统一转换为小写），最终得到处理后的十六进制字符串 f。
这个 f 作为 num_obj.toHex() 函数的返回值传递给 print 函数，在控制台输出 转换为十六进制字符串: f。

结束语

希望通过以上对代码运行思路细致入微的剖析，能让你对 Python 中类的属性定义、方法实现以及对象相关操作有更为透彻深入的理解呀。在 Python 编程的学习过程中，明晰代码背后的运行逻辑有助于我们更扎实地掌握各类编程技巧，更灵活地运用它们去解决实际项目里遇到的问题呢。要是后续你在 Python 编程方面还有别的疑问或者想要探讨的有趣话题，欢迎随时跟我交流哦，祝愿你在编程之路上不断取得进步，收获满满的知识与成就，期待下次再一起聊聊编程那些事儿啦！

目录