Python-VBA函数之旅-oct函数

目录

一、oct函数的常见应用场景

二、oct函数使用注意事项

三、如何用好oct函数？

1、oct函数：

1-1、Python：

1-2、VBA：

2、推荐阅读：

个人主页：神奇夜光杯-CSDN博客 

 

一、oct函数的常见应用场景

        oct函数在 Python 中主要用于将整数转换为八进制表示形式，这在某些特定的应用场景下是非常有用的，常见的应用场景有：

1、文件权限检查：在Unix和Linux系统中，文件权限通常使用八进制表示。例如，权限 `755` 表示所有者有读、写和执行权限，组用户和其他用户只有读和执行权限，使用oct()函数可以帮助你更容易地理解或操作这些权限。

2、位操作与位掩码：在处理位级操作时(如设置、清除或检查特定的位)，八进制表示法可以提供一个简洁的方式来查看和操作位模式，虽然十六进制(使用hex()函数)在这种情况下更常见，但八进制在某些情况下可能更直观。

3、硬件编程和通信：在硬件编程和与硬件设备的通信中，八进制数经常用于表示二进制数据的分组，例如，在串行通信中，数据可能以字节为单位发送，每个字节由8位二进制数组成，可以很容易地转换为两个八进制数字。

4、调试和日志记录：在开发和调试过程中，有时需要查看和操作整数的二进制或八进制表示形式，使用oct()函数可以方便地获取这些表示形式，并将其记录到日志或输出到控制台中。

5、配置与设置：在某些应用程序或系统中，配置设置可能需要以八进制形式表示，使用oct()函数可以将用户输入的整数转换为相应的八进制表示形式，然后将其存储在配置文件中或用于配置系统参数。

6、数据验证和检查：在某些情况下，你可能需要验证一个数字是否是一个有效的八进制数，虽然oct()函数本身不会进行验证(它会尝试将任何整数转换为八进制字符串)，但你可以使用它来帮助你构建这样的验证逻辑。

7、算法和数据处理：在处理二进制数据或进行需要位操作的算法时，八进制表示法可能更易于人类理解和操作，虽然Python主要使用十六进制(hex()函数)来表示较大的二进制数，但在某些情况下，八进制可能更直观。

8、密码学与安全：虽然八进制本身在密码学和安全领域中的应用可能不如十六进制或二进制普遍，但在某些特定的上下文中，oct()函数仍然可能有用，特别是当处理与权限、访问控制或其他基于位的策略相关的安全功能时。

9、性能优化和内存管理：虽然oct()函数本身可能不是性能优化的关键部分，但在处理大量位数据或执行复杂的位操作时，将整数转换为八进制字符串以进行日志记录、调试或可视化可能会帮助你更有效地管理和优化你的代码和内存使用。

        注意，虽然oct()函数在某些特定场景下可能非常有用，但在大多数日常编程任务中，你可能更常使用十进制、二进制或十六进制数，然而，了解这些不同的数字系统和如何在Python中进行转换仍然是非常重要的。

二、oct函数使用注意事项

        在Python中使用oct()函数时，需要注意以下几点：

1、输入类型：oct()函数只接受整数类型的参数，如果你尝试将一个非整数(如浮点数、字符串等)传递给oct()函数，Python会引发一个TypeError异常。

2、输出格式：在Python 3中，oct()函数返回的字符串表示形式带有0o前缀，表示这是一个八进制数，如果你需要不带前缀的字符串，可以使用字符串切片来去除它；在Python 2中，oct()函数返回的字符串表示形式没有0o前缀。

3、大整数的表示：对于非常大的整数，oct()函数能够正确地将它们转换为八进制表示形式，而不用担心整数溢出或精度问题。

4、性能：虽然oct()函数在大多数情况下都非常快，但如果你在处理大量数据时需要频繁调用它，可能会对性能产生影响，在这种情况下，可以考虑使用其他方法来优化你的代码。

5、进制间的转换：如果你需要在八进制、二进制和十六进制之间进行转换，需要小心使用oct()、bin()和hex()函数，并理解它们返回的字符串表示形式，特别是要注意前缀(`'0o'`、`'0b'`和`'0x'`)的存在与否。

6、整数范围：oct()函数能够处理Python中的任意整数(在理论上是无限的，但在实践中受到可用内存的限制)，但是，如果你试图将超出Python整数范围的值传递给oct()函数(这在实际中是不可能发生的，因为Python整数可以扩展到任何大小)，Python将引发一个OverflowError(尽管这在实际中几乎不可能发生)。

7、国际化和编码：虽然oct()函数返回的字符串是ASCII编码的，但在处理国际化或特殊编码的文本时，需要确保你的代码能够正确处理这些字符串，这通常不是oct()函数本身的问题，而是整个应用程序或系统需要关注的问题。

三、如何用好oct函数？

        在Python中，oct()函数主要用于将整数转换为八进制字符串表示，要用好oct()函数，你最好遵循以下建议：

1、明确输入类型：确保你传递给oct()函数的参数是整数类型；如果参数是其他类型(如浮点数、字符串等)，你需要先将其转换为整数。

2、处理输出格式：Python 3中的oct()函数返回的字符串以0o开头，表示这是一个八进制数，如果你不需要这个前缀，可以使用字符串切片来去除它。

3、理解八进制表示：八进制是一种基数为8的数制系统，使用数字0-7来表示，了解八进制的基本概念可以帮助你更好地理解和使用oct()函数。

4、错误处理：当处理用户输入或不确定的数据时，应该添加适当的错误处理来捕获可能的异常。例如，你可以使用`try-except`块来捕获并处理TypeError(如果传递给oct()函数的参数不是整数)。

5、避免不必要的转换：如果你已经有一个八进制字符串(例如从文件或用户输入中读取的)，并且你只是想对其进行操作或显示，那么就没有必要使用oct()函数将其转换回整数再转换回字符串，直接操作字符串可能会更高效。

6、结合其他函数使用：你可以将oct()函数与其他Python函数结合使用，以执行更复杂的任务。例如，你可以使用字符串方法(如split()、replace()等)来进一步处理oct()函数返回的字符串。

7、文档和注释：在你的代码中使用oct()函数时，添加适当的文档和注释可以帮助其他人(或未来的你)更好地理解你的代码是如何工作的，解释为什么你选择使用八进制表示，以及你如何使用oct()函数来实现你的目标。

8、测试：编写测试用例来验证你的代码是否正确地使用了oct()函数，确保你的代码能够处理各种边界情况和异常情况。

1、oct函数：
1-1、Python：
  1. # 1.函数：oct
  2. # 2.功能：用于将整数转换为带前缀"0o"的八进制数字符串
  3. # 3.语法：oct(x)
  4. # 4.参数：x，必须参数，表示一个整数值
  5. # 5.返回值：返回一个字符串，该字符串表示参数x的八进制形式
  6. # 6.说明：
  7. # 7.示例：
  8. # 用dir()函数获取该函数内置的属性和方法
  9. print(dir(oct))
  10. # ['__call__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
  11. # '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__name__',
  12. # '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__',
  13. # '__str__', '__subclasshook__', '__text_signature__']
  14.  
  15. # 用help()函数获取该函数的文档信息
  16. help(oct)
  17.  
  18. # 应用一：文件权限检查
  19. import os
  20. import stat
  21. def get_file_permissions(file_path):
  22.     # 使用os.stat获取文件状态信息
  23.     stat_info = os.stat(file_path)
  24.     # 使用stat.S_IMODE从文件状态信息中提取权限位
  25.     permissions = stat.S_IMODE(stat_info.st_mode)
  26.     # 使用oct()将权限位转换为八进制字符串表示，并去除'0o'前缀
  27.     octal_permissions = oct(permissions)[2:]
  28.     return octal_permissions
  29. def check_file_permissions(file_path, required_permissions):
  30.     # 获取文件的八进制权限
  31.     file_perms = get_file_permissions(file_path)
  32.     # 将所需权限也转换为八进制字符串（如果它们不是已经是的话）
  33.     if not required_permissions.startswith('0') and not required_permissions.startswith('o'):
  34.         required_perms_int = int(required_permissions, 8)  # 假设required_permissions是有效的八进制字符串
  35.         required_perms = oct(required_perms_int)[2:]
  36.     # 检查文件权限是否包含所需权限
  37.     # 这里我们简单地检查required_permissions是否是file_perms的子集(即每个位都是1的地方，file_perms也必须是1)
  38.     # 这可以通过将两者转换为整数并执行位与操作来完成，然后检查结果是否等于required_permissions对应的整数
  39.     required_perms_int = int(required_permissions, 8)
  40.     file_perms_int = int(file_perms, 8)
  41.     has_required_perms = (file_perms_int & required_perms_int) == required_perms_int
  42.     return has_required_perms
  43. # 使用示例
  44. file_path = 'file.txt'  # 替换为你的文件路径
  45. print(f"File permissions for '{file_path}': {get_file_permissions(file_path)}")
  46. # 检查文件是否具有特定的权限，比如 644(读/写 对拥有者, 只读 对组和其他用户)
  47. required_permissions = '644'
  48. if check_file_permissions(file_path, required_permissions):
  49.     print(f"The file '{file_path}' has the required permissions '{required_permissions}'.")
  50. else:
  51.     print(f"The file '{file_path}' does not have the required permissions '{required_permissions}'.")
  52. # File permissions for 'file.txt': 666
  53. # The file 'file.txt' has the required permissions '644'.
  54.  
  55. # 应用二：位操作与位掩码
  56. def bitwise_operations_and_mask(num1, num2, mask):
  57.     # 位与操作
  58.     and_result = num1 & num2
  59.     print(f"num1: {oct(num1)[2:]} & num2: {oct(num2)[2:]} = {oct(and_result)[2:]}")
  60.     # 位或操作
  61.     or_result = num1 | num2
  62.     print(f"num1: {oct(num1)[2:]} | num2: {oct(num2)[2:]} = {oct(or_result)[2:]}")
  63.     # 位异或操作
  64.     xor_result = num1 ^ num2
  65.     print(f"num1: {oct(num1)[2:]} ^ num2: {oct(num2)[2:]} = {oct(xor_result)[2:]}")
  66.     # 位非操作(注意这里是对单个数进行的)
  67.     not_result = ~num1
  68.     print(f"~num1: {oct(num1)[2:]} = {oct(not_result)[2:]} (注意：位非操作的结果依赖于整数的位数)")
  69.     # 位掩码操作
  70.     masked_result = num1 & mask
  71.     print(f"num1: {oct(num1)[2:]} & mask: {oct(mask)[2:]} = {oct(masked_result)[2:]}")
  72. # 示例数值(以十进制表示，但实际上是进行二进制位操作)
  73. num1 = 0b1100  # 二进制 1100，十进制 12
  74. num2 = 0b1010  # 二进制 1010，十进制 10
  75. mask = 0b1100  # 掩码，二进制 1100，十进制 12
  76. # 执行位操作和位掩码
  77. bitwise_operations_and_mask(num1, num2, mask)
  78. # num1: 14 & num2: 12 = 10
  79. # num1: 14 | num2: 12 = 16
  80. # num1: 14 ^ num2: 12 = 6
  81. # ~num1: 14 = o15 (注意：位非操作的结果依赖于整数的位数)
  82. # num1: 14 & mask: 14 = 14
  83.  
  84. # 应用三：硬件编程和通信
  85. # 假设我们有一个硬件寄存器，它存储了一个8位的值
  86. # 我们使用整数来表示这个值，因为Python中的整数是以二进制形式存储的
  87. def read_register(address):
  88.     # 在真实情况下，这里会是一个与硬件通信的函数
  89.     # 假设我们有一个模拟的寄存器映射
  90.     registers = {
  91.         0x01: 0b11001010,  # 假设这是地址0x01的寄存器值
  92.         # ... 其他寄存器值
  93.     }
  94.     return registers.get(address, 0)  # 如果地址不存在，返回0
  95. def write_register(address, value):
  96.     # 在真实情况下，这里会是一个与硬件通信的函数
  97.     # 在这个模拟示例中，我们只是打印出写入的地址和值
  98.     print(f"Writing to register 0x{address:02X}: 0b{value:08b} (octal: 0o{oct(value)[2:]})")
  99. # 读取寄存器并显示其八进制表示
  100. register_address = 0x01
  101. register_value = read_register(register_address)
  102. print(f"Register 0x{register_address:02X} value: 0b{register_value:08b} (octal: 0o{oct(register_value)[2:]})")
  103. # 写入一个值到寄存器(模拟)
  104. new_value = 0b10101010
  105. write_register(register_address, new_value)
  106. # Register 0x01 value: 0b11001010 (octal: 0o312)
  107. # Writing to register 0x01: 0b10101010 (octal: 0o252)
  108.  
  109. # 应用四：调试和日志记录
  110. import logging
  111. # 配置一个简单的日志记录器
  112. logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
  113. def process_data(data):
  114.     # 假设我们有一些二进制数据处理函数
  115.     # 在这里，我们只是简单地将数据左移一位
  116.     processed_data = data << 1
  117.     # 使用oct()将处理后的数据转换为八进制，并记录到日志中
  118.     logging.info(f"Original data (decimal): {data}, (binary): {bin(data)[2:]}, (octal): {oct(data)[2:]}")
  119.     logging.info(
  120.         f"Processed data (decimal): {processed_data}, (binary): {bin(processed_data)[2:]}, (octal): {oct(processed_data)[2:]}")
  121.     # 返回处理后的数据（在实际应用中可能不需要返回）
  122.     return processed_data
  123. # 示例使用
  124. data = 0b1100  # 二进制数据
  125. processed_data = process_data(data)
  126. # 这里只是为了演示，实际中processed_data可能用于后续操作
  127. print(f"Processed data (decimal): {processed_data}")
  128. # Processed data (decimal): 24
  129. # 2024-05-04 22:38:25,704 - INFO - Original data (decimal): 12, (binary): 1100, (octal): 14
  130. # 2024-05-04 22:38:25,704 - INFO - Processed data (decimal): 24, (binary): 11000, (octal): 30
  131.  
  132. # 应用五：配置与设置
  133. import logging
  134. # 假设我们有一个配置字典，其中包含一些八进制表示的设置
  135. config = {
  136.     'file_permissions': 0o644,  # 八进制表示的文件权限
  137.     'device_setting': 0o377,  # 假设的硬件设置，以八进制表示
  138.     # ... 其他设置
  139. }
  140. # 配置日志记录器
  141. logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
  142. def configure_and_log_settings(config_dict):
  143.     # 遍历配置字典
  144.     for setting_name, setting_value in config_dict.items():
  145.         # 检查设置值是否为整数（这里简化为只处理整数）
  146.         if isinstance(setting_value, int):
  147.             # 使用oct()将整数转换为八进制字符串，并去除'0o'前缀
  148.             octal_str = oct(setting_value)[2:]
  149.             # 记录日志
  150.             logging.info(f'Setting {setting_name} configured to octal {octal_str} (decimal {setting_value})')
  151.         else:
  152.             # 对于非整数设置，简单记录其值
  153.             logging.info(f'Setting {setting_name} configured to {setting_value}')
  154. # 调用函数配置并记录日志
  155. configure_and_log_settings(config)
  156. # 2024-05-04 22:40:46,874 - INFO - Setting file_permissions configured to octal 644 (decimal 420)
  157. # 2024-05-04 22:40:46,874 - INFO - Setting device_setting configured to octal 377 (decimal 255)
  158.  
  159. # 应用六：算法和数据处理
  160. def add_octal_numbers(octal1, octal2):
  161.     # 将八进制字符串转换为整数
  162.     num1 = int(octal1, 8)
  163.     num2 = int(octal2, 8)
  164.     # 计算两个整数的和
  165.     sum_decimal = num1 + num2
  166.     # 将和转换回八进制字符串
  167.     sum_octal = oct(sum_decimal)[2:]  # 去掉'0o'前缀
  168.     return sum_octal
  169. # 示例用法
  170. octal1 = "123"  # 八进制数 123
  171. octal2 = "456"  # 八进制数 456
  172. # 计算和并打印结果
  173. result = add_octal_numbers(octal1, octal2)
  174. print(f"The sum of {octal1} and {octal2} in octal is: {result}")
  175. # 注意：由于八进制数的范围有限(0-7)，如果和超过了单个八进制数字可以表示的范围，
  176. # 则结果将包含多个八进制数字。例如，八进制中的 7 + 1 等于 10(在十进制中是 8)，
  177. # 但在八进制中表示为 '10' 而不是 '8'。
  178. # The sum of 123 and 456 in octal is: 601
  179.  
  180. # 应用七：密码学与安全
  181. def octal_encode(data, key):
  182.     """
  183.     简化的“编码”函数，将字符串的每个字符的ASCII码与八进制密钥进行简单的异或操作
  184.     这不是一个安全的加密方法，仅用于展示八进制在数据处理中的应用
  185.     :param data: 要编码的字符串
  186.     :param key: 八进制表示的密钥（将被转换为整数）
  187.     :return: 编码后的字符串（其ASCII码与密钥进行了异或操作）
  188.     """
  189.     # 将八进制密钥转换为整数
  190.     key_int = int(key, 8)
  191.     # 对字符串的每个字符进行异或操作
  192.     encoded_data = ''.join(chr(ord(c) ^ key_int) for c in data)
  193.     return encoded_data
  194. def octal_decode(encoded_data, key):
  195.     """
  196.     解码函数，与编码函数相反
  197.     :param encoded_data: 编码后的字符串
  198.     :param key: 八进制表示的密钥（将被转换为整数）
  199.     :return: 解码后的原始字符串
  200.     """
  201.     # 将八进制密钥转换为整数
  202.     key_int = int(key, 8)
  203.     # 对编码后的字符串的每个字符进行异或操作以恢复原始数据
  204.     decoded_data = ''.join(chr(ord(c) ^ key_int) for c in encoded_data)
  205.     return decoded_data
  206. # 示例用法
  207. original_data = "Hello, Python!"
  208. key = "1024"  # 八进制密钥，对应十进制的 83
  209. # 编码数据
  210. encoded_data = octal_encode(original_data, key)
  211. print(f"Encoded data: {encoded_data}")
  212. # 解码数据
  213. decoded_data = octal_decode(encoded_data, key)
  214. print(f"Decoded data: {decoded_data}")
  215. # 应该输出原始数据
  216. assert decoded_data == original_data
  217. # Encoded data: ɜɱɸɸɻȸȴɄɭɠɼɻɺȵ
  218. # Decoded data: Hello, Python!
  219.  
  220. # 应用八：性能优化和内存管理
  221. # 假设我们有一个整数列表，我们需要将它们转换为八进制字符串列表
  222. numbers = [10, 20, 30, 40, 50]
  223. # 使用传统的循环和append方法
  224. octal_strings_traditional = []
  225. for num in numbers:
  226.     octal_strings_traditional.append(oct(num)[2:])  # 去掉 '0o' 前缀
  227. # 使用列表推导式
  228. octal_strings_list_comp = [oct(num)[2:] for num in numbers]
  229. # 列表推导式通常更快，因为它利用了Python的内部优化
  230. # 在这个例子中，它还减否产生相同的结果  少了代码量并提高了可读性
  231. # # 输出结果以验证两种方法是
  232. print(octal_strings_traditional)
  233. print(octal_strings_list_comp)
  234. # ['12', '24', '36', '50', '62']
  235. # ['12', '24', '36', '50', '62']
1-2、VBA：
略，待后补。
2、推荐阅读：

2-1、Python-VBA函数之旅-globals()函数

Python算法之旅：Algorithm

Python函数之旅：Functions

个人主页：神奇夜光杯-CSDN博客 
文章知识点与官方知识档案匹配，可进一步学习相关知识
算法技能树首页概览61139 人正在系统学习中
遨游码海，我心飞扬
微信名片
注：本文转载自blog.csdn.net的神奇夜光杯的文章"https://myelsa1024.blog.csdn.net/article/details/138450982"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！