Python 内置函数系列:o开头系列函数

object：所有类的"终极基类"

1. 基础特性：Python的类基础

object类是所有Python类的基类，提供了所有类实例共有的基本方法。当其构造器被调用时，它将返回一个新的基本对象。该构造器不接受任何参数。

# 创建基础对象实例
base_obj = object()
print(f"对象类型: {type(base_obj)}")  # 输出: <class 'object'>
print(f"对象标识: {id(base_obj)}")
print(f"对象哈希: {hash(base_obj)}")

oct()：八进制转换的"翻译器"

1. 基础用法：整数转八进制字符串

oct()函数将整数转换为带"0o"前缀的八进制字符串，是进制转换的重要工具。

# 基本八进制转换
print(f"8的八进制: {oct(8)}")      # 输出: '0o10'
print(f"10的八进制: {oct(10)}")    # 输出: '0o12'
print(f"16的八进制: {oct(16)}")    # 输出: '0o20'

# 负数转换
print(f"-56的八进制: {oct(-56)}")  # 输出: '-0o70'
print(f"0的八进制: {oct(0)}")      # 输出: '0o0'

# 大整数转换
large_num = 2**20
print(f"2^20的八进制: {oct(large_num)}")

# 从十六进制数转换
hex_num = 0xFF
print(f"0xFF的八进制: {oct(hex_num)}")  # 输出: '0o377'

# 使用__index__方法的对象
class IndexableNumber:
    def __index__(self):
        return 100

custom_obj = IndexableNumber()
print(f"自定义对象转换: {oct(custom_obj)}")  # 输出: '0o144'

2. 实际应用：文件权限和进制转换工具

class PermissionConverter:
    """权限转换工具类（常用于Linux文件权限）"""

    @staticmethod
    def chmod_to_octal(permission_str):
        """将chmod权限字符串转换为八进制数字"""
        if len(permission_str) != 9:
            raise ValueError("权限字符串必须是9个字符")

        # 权限映射：r=4, w=2, x=1
        perms = {'r': 4, 'w': 2, 'x': 1, '-': 0}

        # 每3位一组转换为八进制
        result = 0
        for i in range(0, 9, 3):
            group = permission_str[i:i+3]
            value = 0
            for char in group:
                if char in perms:
                    value += perms[char]
                else:
                    raise ValueError(f"无效权限字符: {char}")
            result = result * 10 + value  # 注意：这里构建的是十进制数，但每位代表八进制值

        return int(str(result), 8)  # 将字符串解析为八进制整数

    @staticmethod
    def octal_to_chmod(octal_permission):
        """将八进制权限转换为chmod字符串"""
        # 确保是有效的八进制权限（0-777）
        if not 0 <= octal_permission <= 0o777:
            raise ValueError("权限必须在0-777范围内")

        permission_str = ""
        # 转换为三位八进制字符串
        oct_str = oct(octal_permission)[2:].zfill(3)

        for digit in oct_str:
            value = int(digit, 8)
            # 转换为rwx格式
            bits = [
                'r' if value & 4 else '-',
                'w' if value & 2 else '-',
                'x' if value & 1 else '-'
            ]
            permission_str += ''.join(bits)

        return permission_str

    @staticmethod
    def format_octal_number(num, width=0, prefix=True):
        """格式化八进制输出"""
        if prefix:
            oct_str = oct(num)
        else:
            oct_str = format(num, 'o')

        if width > 0:
            # 处理前缀
            if prefix and oct_str.startswith('0o'):
                oct_str = '0o' + oct_str[2:].zfill(width)
            elif prefix and oct_str.startswith('-0o'):
                oct_str = '-0o' + oct_str[3:].zfill(width)
            elif oct_str.startswith('-'):
                oct_str = '-' + oct_str[1:].zfill(width)
            else:
                oct_str = oct_str.zfill(width)

        return oct_str

# 使用示例
converter = PermissionConverter()

# 文件权限转换
print("=== 文件权限转换示例 ===")
permission_str = "rwxr-xr--"
octal_perm = converter.chmod_to_octal(permission_str)
print(f"权限 '{permission_str}' -> 八进制: {oct(octal_perm)}")

# 反向转换
converted_back = converter.octal_to_chmod(octal_perm)
print(f"八进制 {oct(octal_perm)} -> 权限: {converted_back}")

# 常见权限示例
common_permissions = {
    "完全开放": 0o777,    # rwxrwxrwx
    "用户读写执行，组只读，其他无": 0o740,  # rwxr-----
    "用户读写，组只读，其他只读": 0o644,   # rw-r--r--
    "仅用户读写": 0o600,    # rw-------
}

for name, perm in common_permissions.items():
    perm_str = converter.octal_to_chmod(perm)
    print(f"{name}: {oct(perm)} -> {perm_str}")

# 八进制格式化
test_numbers = [8, 10, 16, 100]
for num in test_numbers:
    formatted = converter.format_octal_number(num, width=4, prefix=True)
    print(f"{num} 的八进制: {formatted}")

ord()：字符编码的"解码器"

1. 基础用法：获取字符的Unicode码位

ord()函数返回字符的Unicode码位（整数），是字符编码处理的基础。

# 基本ASCII字符
print(f"'a'的码位: {ord('a')}")      # 输出: 97
print(f"'A'的码位: {ord('A')}")      # 输出: 65
print(f"'0'的码位: {ord('0')}")      # 输出: 48
print(f"' '的码位: {ord(' ')}")      # 输出: 32（空格）

# 特殊字符
print(f"'€'的码位: {ord('€')}")      # 输出: 8364（欧元符号）
print(f"'中'的码位: {ord('中')}")    # 输出: 20013
print(f"'☆'的码位: {ord('☆')}")      # 输出: 9734

# 控制字符
print(f"'\\n'的码位: {ord('\\n')}")  # 输出: 10（换行符）
print(f"'\\t'的码位: {ord('\\t')}")  # 输出: 9（制表符）

# 字节对象（单字节）
print(f"b'a'的码位: {ord(b'a')}")    # 输出: 97
print(f"b'\\x41'的码位: {ord(b'\\x41')}")  # 输出: 65（ASCII 'A'）

# bytearray对象
ba = bytearray(b'X')
print(f"bytearray的码位: {ord(ba)}")  # 输出: 88

2. 实际应用：字符编码分析和转换

class CharacterAnalyzer:
    """字符分析工具类"""

    @staticmethod
    def analyze_string(text):
        """分析字符串中所有字符的编码信息"""
        results = []
        for i, char in enumerate(text):
            code_point = ord(char)
            results.append({
                'index': i,
                'character': char,
                'codepoint': code_point,
                'hex': hex(code_point),
                'binary': bin(code_point),
                'category': CharacterAnalyzer.get_char_category(char)
            })
        return results

    @staticmethod
    def get_char_category(char):
        """获取字符类别"""
        code = ord(char)
        if 0 <= code <= 31:
            return "控制字符"
        elif 32 <= code <= 126:
            return "ASCII可打印字符"
        elif 127 <= code <= 255:
            return "扩展ASCII"
        elif 256 <= code <= 65535:
            return "基本多文种平面(BMP)"
        else:
            return "补充平面"

    @staticmethod
    def string_to_codepoints(text, format='decimal'):
        """将字符串转换为码点序列"""
        codepoints = [ord(c) for c in text]

        if format == 'decimal':
            return codepoints
        elif format == 'hex':
            return [hex(cp) for cp in codepoints]
        elif format == 'binary':
            return [bin(cp) for cp in codepoints]
        else:
            return codepoints

    @staticmethod
    def codepoints_to_string(codepoints):
        """将码点序列转换回字符串"""
        return ''.join(chr(cp) for cp in codepoints)

    @staticmethod
    def find_special_characters(text):
        """查找文本中的特殊字符"""
        special_chars = []
        for char in text:
            cp = ord(char)
            if cp < 32 or cp > 126:  # 非标准ASCII字符
                special_chars.append({
                    'char': char,
                    'codepoint': cp,
                    'representation': repr(char)
                })
        return special_chars

# 使用示例
analyzer = CharacterAnalyzer()

# 字符串分析
print("=== 字符串编码分析 ===")
test_text = "Hello 世界! ☆"
analysis = analyzer.analyze_string(test_text)

for item in analysis:
    print(f"位置 {item['index']}: '{item['character']}' -> "
          f"码点 {item['codepoint']}, 十六进制 {item['hex']}, "
          f"类别: {item['category']}")

# 码点转换
codepoints_decimal = analyzer.string_to_codepoints("ABC", format='decimal')
codepoints_hex = analyzer.string_to_codepoints("ABC", format='hex')
print(f"字符串码点(十进制): {codepoints_decimal}")
print(f"字符串码点(十六进制): {codepoints_hex}")

# 反向转换
original = analyzer.codepoints_to_string([72, 101, 108, 108, 111])
print(f"码点转字符串: {original}")

# 查找特殊字符
text_with_special = "Hello\tWorld\n中国☆"
special = analyzer.find_special_characters(text_with_special)
print(f"\n特殊字符查找:")
for item in special:
    print(f"  字符: {item['representation']}, 码点: {item['codepoint']}")

总结

本文详细解析了Python中三个重要的内置功能：

1. 1. object - 所有类的终极基类，基类设计、内存优化、不可变对象
2. 2. oct(integer) - 八进制转换的翻译器，文件权限管理、进制转换、低级编程
3. 3. ord(character) - 字符编码的解码器，字符编码分析、文本处理、国际化支持

关键知识点总结：

• • object是所有Python类的基类，实例没有__dict__属性
• • oct()将整数转换为带"0o"前缀的八进制字符串
• • ord()返回字符的Unicode码位，支持字符串和字节对象