Python內(nèi)置函數(shù)object、oct()、ord()的實用指南
更新時間：2026年01月22日 09:09:17 作者：Python游俠
本文詳細介紹了Python中的object類、oct()函數(shù)和ord()函數(shù),分別作為所有類的基類、八進制轉(zhuǎn)換工具和字符編碼解碼器,適用于基類設計、進制轉(zhuǎn)換和字符編碼處理等場景,需要的朋友可以參考下
一、object：所有類的"終極基類"
1.1 基礎特性：Python的類基礎
object類是所有Python類的基類，提供了所有類實例共有的基本方法。
# 創(chuàng)建基礎對象實例
base_obj = object()
print(f"對象類型: {type(base_obj)}") # 輸出: <class 'object'>
print(f"對象標識: {id(base_obj)}")
print(f"對象哈希: {hash(base_obj)}")
# 驗證object實例特性
print(f"是否有__dict__: {hasattr(base_obj, '__dict__')}") # 輸出: False
print(f"是否有__slots__: {hasattr(base_obj, '__slots__')}") # 輸出: False
# 嘗試添加屬性會失敗
try:
base_obj.custom_attr = "測試值"
print("添加屬性成功")
except AttributeError as e:
print(f"添加屬性失敗: {e}") # 輸出: 'object' object has no attribute 'custom_attr'
# 基本方法演示
print(f"對象字符串表示: {str(base_obj)}")
print(f"對象正式表示: {repr(base_obj)}")
print(f"對象等于自身: {base_obj == base_obj}") # 輸出: True
1.2 實際應用：創(chuàng)建輕量級基類
class LightweightBase(object):
"""輕量級基類，使用__slots__減少內(nèi)存占用"""
__slots__ = ('x', 'y') # 明確指定可用的屬性
def __init__(self, x=0, y=0):
self.x = x
self.y = y
def __repr__(self):
return f"LightweightBase(x={self.x}, y={self.y})"
def move(self, dx, dy):
"""移動位置"""
self.x += dx
self.y += dy
return self
# 使用示例
point = LightweightBase(3, 4)
print(f"創(chuàng)建點: {point}")
print(f"點坐標: ({point.x}, {point.y})")
# 移動點
point.move(2, -1)
print(f"移動后: {point}")
# 驗證屬性限制
print(f"是否有__dict__: {hasattr(point, '__dict__')}") # 輸出: False
print(f"是否有__slots__: {hasattr(point, '__slots__')}") # 輸出: True
# 無法添加未在__slots__中定義的屬性
try:
point.z = 5
print("添加屬性成功")
except AttributeError as e:
print(f"添加屬性失敗: {e}")
# 對比普通類和輕量級類的內(nèi)存使用
class NormalClass:
def __init__(self, x, y):
self.x = x
self.y = y
import sys
normal_obj = NormalClass(1, 2)
lightweight_obj = LightweightBase(1, 2)
print(f"普通對象大小: {sys.getsizeof(normal_obj) + sys.getsizeof(normal_obj.__dict__)} 字節(jié)")
print(f"輕量對象大小: {sys.getsizeof(lightweight_obj)} 字節(jié)")
二、oct()：八進制轉(zhuǎn)換的"翻譯器"
2.1 基礎用法：整數(shù)轉(zhuǎn)八進制字符串
oct()函數(shù)將整數(shù)轉(zhuǎn)換為帶"0o"前綴的八進制字符串，是進制轉(zhuǎn)換的重要工具。
# 基本八進制轉(zhuǎn)換
print(f"8的八進制: {oct(8)}") # 輸出: '0o10'
print(f"10的八進制: {oct(10)}") # 輸出: '0o12'
print(f"16的八進制: {oct(16)}") # 輸出: '0o20'
# 負數(shù)轉(zhuǎn)換
print(f"-56的八進制: {oct(-56)}") # 輸出: '-0o70'
print(f"0的八進制: {oct(0)}") # 輸出: '0o0'
# 大整數(shù)轉(zhuǎn)換
large_num = 2**20
print(f"2^20的八進制: {oct(large_num)}")
# 從十六進制數(shù)轉(zhuǎn)換
hex_num = 0xFF
print(f"0xFF的八進制: {oct(hex_num)}") # 輸出: '0o377'
# 使用__index__方法的對象
class IndexableNumber:
def __index__(self):
return 100
custom_obj = IndexableNumber()
print(f"自定義對象轉(zhuǎn)換: {oct(custom_obj)}") # 輸出: '0o144'
2.2 實際應用：文件權限和進制轉(zhuǎn)換工具
class PermissionConverter:
"""權限轉(zhuǎn)換工具類（常用于Linux文件權限）"""
@staticmethod
def chmod_to_octal(permission_str):
"""將chmod權限字符串轉(zhuǎn)換為八進制數(shù)字"""
if len(permission_str) != 9:
raise ValueError("權限字符串必須是9個字符")
# 權限映射：r=4, w=2, x=1
perms = {'r': 4, 'w': 2, 'x': 1, '-': 0}
# 每3位一組轉(zhuǎn)換為八進制
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 # 注意：這里構建的是十進制數(shù)，但每位代表八進制值
return int(str(result), 8) # 將字符串解析為八進制整數(shù)
@staticmethod
def octal_to_chmod(octal_permission):
"""將八進制權限轉(zhuǎn)換為chmod字符串"""
# 確保是有效的八進制權限（0-777）
if not 0 <= octal_permission <= 0o777:
raise ValueError("權限必須在0-777范圍內(nèi)")
permission_str = ""
# 轉(zhuǎn)換為三位八進制字符串
oct_str = oct(octal_permission)[2:].zfill(3)
for digit in oct_str:
value = int(digit, 8)
# 轉(zhuǎn)換為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()
# 文件權限轉(zhuǎn)換
print("=== 文件權限轉(zhuǎn)換示例 ===")
permission_str = "rwxr-xr--"
octal_perm = converter.chmod_to_octal(permission_str)
print(f"權限 '{permission_str}' -> 八進制: {oct(octal_perm)}")
# 反向轉(zhuǎn)換
converted_back = converter.octal_to_chmod(octal_perm)
print(f"八進制 {oct(octal_perm)} -> 權限: {converted_back}")
# 常見權限示例
common_permissions = {
"完全開放": 0o777, # rwxrwxrwx
"用戶讀寫執(zhí)行，組只讀，其他無": 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()：字符編碼的"解碼器"
3.1 基礎用法：獲取字符的Unicode碼位
ord()函數(shù)返回字符的Unicode碼位（整數(shù)），是字符編碼處理的基礎。
# 基本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（制表符）
# 字節(jié)對象（單字節(jié)）
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
3.2 實際應用：字符編碼分析和轉(zhuǎn)換
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'):
"""將字符串轉(zhuǎn)換為碼點序列"""
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):
"""將碼點序列轉(zhuǎn)換回字符串"""
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']}")
# 碼點轉(zhuǎn)換
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}")
# 反向轉(zhuǎn)換
original = analyzer.codepoints_to_string([72, 101, 108, 108, 111])
print(f"碼點轉(zhuǎn)字符串: {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']}")
四、組合應用：編碼和權限系統(tǒng)
4.1 字符編碼轉(zhuǎn)換器
class EncodingConverter:
"""編碼轉(zhuǎn)換器"""
@staticmethod
def text_to_unicode_escape(text):
"""將文本轉(zhuǎn)換為Unicode轉(zhuǎn)義序列"""
result = []
for char in text:
cp = ord(char)
if 32 <= cp <= 126: # 可打印ASCII字符
result.append(char)
else:
# 格式: \uXXXX 或 \UXXXXXXXX
if cp <= 0xFFFF:
result.append(f"\\u{cp:04X}")
else:
result.append(f"\\U{cp:08X}")
return ''.join(result)
@staticmethod
def unicode_escape_to_text(escape_str):
"""將Unicode轉(zhuǎn)義序列轉(zhuǎn)換為文本"""
import re
def replace_match(match):
hex_str = match.group(1)
return chr(int(hex_str, 16))
# 處理\uXXXX和\UXXXXXXXX格式
pattern = r'\\[uU]([0-9a-fA-F]{4,8})'
return re.sub(pattern, replace_match, escape_str)
@staticmethod
def text_to_octal_escape(text, max_line_length=80):
"""將文本轉(zhuǎn)換為八進制轉(zhuǎn)義序列（類似C字符串）"""
result = []
line_length = 0
for char in text:
cp = ord(char)
escape_seq = f"\\{cp:03o}" # 八進制轉(zhuǎn)義
result.append(escape_seq)
line_length += len(escape_seq)
if line_length >= max_line_length:
result.append("\n")
line_length = 0
return ''.join(result)
# 使用示例
converter = EncodingConverter()
# Unicode轉(zhuǎn)義
text = "Hello 世界! ☆"
escaped = converter.text_to_unicode_escape(text)
print(f"原始文本: {text}")
print(f"Unicode轉(zhuǎn)義: {escaped}")
# 反向轉(zhuǎn)換
restored = converter.unicode_escape_to_text(escaped)
print(f"恢復文本: {restored}")
# 八進制轉(zhuǎn)義
octal_escape = converter.text_to_octal_escape("ABC\ntest")
print(f"八進制轉(zhuǎn)義: {octal_escape}")
4.2 權限管理系統(tǒng)
class PermissionSystem:
"""基于八進制的權限管理系統(tǒng)"""
def __init__(self):
self.permissions = {}
def add_user(self, username, base_permission=0o644):
"""添加用戶并設置基礎權限"""
if not 0 <= base_permission <= 0o777:
raise ValueError("權限值必須在0-777范圍內(nèi)")
self.permissions[username] = {
'permission': base_permission,
'roles': set()
}
return self.permissions[username]
def set_permission(self, username, permission):
"""設置用戶權限"""
if username not in self.permissions:
raise KeyError(f"用戶不存在: {username}")
if not 0 <= permission <= 0o777:
raise ValueError("權限值必須在0-777范圍內(nèi)")
self.permissions[username]['permission'] = permission
return permission
def check_permission(self, username, required_permission):
"""檢查用戶是否具有所需權限"""
if username not in self.permissions:
return False
user_perm = self.permissions[username]['permission']
# 將八進制權限分解為三組（用戶、組、其他）
def split_permission(perm):
perm_str = oct(perm)[2:].zfill(3)
return [int(d) for d in perm_str]
user_parts = split_permission(user_perm)
required_parts = split_permission(required_permission)
# 檢查用戶權限是否滿足要求
for u_perm, r_perm in zip(user_parts, required_parts):
# 檢查每個位：讀(4)、寫(2)、執(zhí)行(1)
if (u_perm & r_perm) != r_perm:
return False
return True
def add_role(self, username, role):
"""為用戶添加角色"""
if username not in self.permissions:
raise KeyError(f"用戶不存在: {username}")
self.permissions[username]['roles'].add(role)
return True
def has_role(self, username, role):
"""檢查用戶是否具有指定角色"""
if username in self.permissions:
return role in self.permissions[username]['roles']
return False
def display_permissions(self):
"""顯示所有用戶權限"""
print("用戶權限列表:")
print("-" * 40)
print(f"{'用戶名':<15} {'八進制':<8} {'字符串':<12} {'角色'}")
print("-" * 40)
for username, info in self.permissions.items():
perm = info['permission']
perm_str = self._permission_to_string(perm)
roles = ', '.join(info['roles']) if info['roles'] else '無'
print(f"{username:<15} {oct(perm):<8} {perm_str:<12} {roles}")
def _permission_to_string(self, permission):
"""將八進制權限轉(zhuǎn)換為字符串表示"""
converter = PermissionConverter()
return converter.octal_to_chmod(permission)
# 使用示例
print("=== 權限管理系統(tǒng)示例 ===")
system = PermissionSystem()
# 添加用戶
system.add_user("admin", 0o755) # rwxr-xr-x
system.add_user("editor", 0o644) # rw-r--r--
system.add_user("viewer", 0o444) # r--r--r--
system.add_user("tester", 0o777) # rwxrwxrwx
# 添加角色
system.add_role("admin", "administrator")
system.add_role("admin", "superuser")
system.add_role("editor", "content_manager")
system.add_role("viewer", "guest")
# 顯示權限
system.display_permissions()
# 權限檢查
print("\n權限檢查:")
test_cases = [
("admin", 0o755), # 應該通過
("admin", 0o777), # 應該失?。╝dmin沒有寫其他人的權限）
("editor", 0o644), # 應該通過
("viewer", 0o400), # 應該通過（有讀權限）
("viewer", 0o200), # 應該失?。]有寫權限）
]
for username, required_perm in test_cases:
has_perm = system.check_permission(username, required_perm)
perm_str = system._permission_to_string(required_perm)
print(f"用戶 '{username}' 有權限 {oct(required_perm)} ({perm_str}): {has_perm}")
# 角色檢查
print("\n角色檢查:")
print(f"admin 是 administrator: {system.has_role('admin', 'administrator')}")
print(f"editor 是 administrator: {system.has_role('editor', 'administrator')}")
五、高級技巧與最佳實踐
5.1 字符編碼工具
class AdvancedCharacterTools:
"""高級字符編碼工具"""
@staticmethod
def create_character_table(start=32, end=126, columns=8):
"""創(chuàng)建字符編碼表"""
print(f"字符編碼表 ({start} 到 {end}):")
print("=" * 60)
print(f"{'十進制':<8} {'十六進制':<8} {'八進制':<8} {'字符':<8} {'名稱':<20}")
print("-" * 60)
for code in range(start, end + 1):
if code % columns == 0 and code > start:
print() # 每columns個字符換行
char = chr(code)
print(f"{code:<8} {hex(code):<8} {oct(code):<8} "
f"'{char if code != 127 else 'DEL'!s:<8}' "
f"{AdvancedCharacterTools.get_char_name(code):<20}")
@staticmethod
def get_char_name(code_point):
"""獲取字符名稱（簡化版）"""
names = {
0: "NULL",
7: "BEL", # 響鈴
8: "BS", # 退格
9: "TAB", # 制表符
10: "LF", # 換行
13: "CR", # 回車
27: "ESC", # 退出
32: "SPACE",# 空格
127: "DEL", # 刪除
}
return names.get(code_point, "")
@staticmethod
def analyze_encoding_compatibility(text):
"""分析文本的編碼兼容性"""
results = {
'ascii_compatible': True,
'latin1_compatible': True,
'utf8_size': 0,
'problematic_chars': []
}
for char in text:
cp = ord(char)
# ASCII兼容性（0-127）
if cp > 127:
results['ascii_compatible'] = False
# Latin-1兼容性（0-255）
if cp > 255:
results['latin1_compatible'] = False
# UTF-8字節(jié)大小估計
if cp <= 0x7F:
results['utf8_size'] += 1
elif cp <= 0x7FF:
results['utf8_size'] += 2
elif cp <= 0xFFFF:
results['utf8_size'] += 3
else:
results['utf8_size'] += 4
# 記錄控制字符（除常見外）
if cp < 32 and cp not in [9, 10, 13]: # TAB, LF, CR
results['problematic_chars'].append({
'char': repr(char),
'codepoint': cp,
'name': AdvancedCharacterTools.get_char_name(cp)
})
return results
# 使用示例
tools = AdvancedCharacterTools()
# 創(chuàng)建字符表
tools.create_character_table(65, 90, 5) # 顯示A-Z
# 編碼兼容性分析
test_texts = [
"Hello World", # ASCII
"Café", # Latin-1
"Hello 世界", # 包含中文
"Text with\ttab\nand newline", # 控制字符
]
for text in test_texts:
print(f"\n分析文本: {repr(text)}")
analysis = tools.analyze_encoding_compatibility(text)
for key, value in analysis.items():
if key != 'problematic_chars':
print(f" {key}: {value}")
if analysis['problematic_chars']:
print(f" 有問題的字符: {analysis['problematic_chars']}")
5.2 進制轉(zhuǎn)換和優(yōu)化
class NumberSystemConverter:
"""進制系統(tǒng)轉(zhuǎn)換器"""
@staticmethod
def convert_between_bases(number, from_base, to_base):
"""在任意進制間轉(zhuǎn)換（2-36）"""
# 先轉(zhuǎn)換為十進制
if isinstance(number, str):
decimal_val = int(number, from_base)
else:
decimal_val = int(str(number), from_base)
# 從十進制轉(zhuǎn)換到目標進制
digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
if decimal_val == 0:
return "0"
result = []
is_negative = decimal_val < 0
decimal_val = abs(decimal_val)
while decimal_val > 0:
remainder = decimal_val % to_base
result.append(digits[remainder])
decimal_val //= to_base
if is_negative:
result.append('-')
return ''.join(reversed(result))
@staticmethod
def format_number_bases(number, bases=(2, 8, 10, 16)):
"""以多種進制格式化數(shù)字"""
results = {}
for base in bases:
if base == 2:
results['binary'] = bin(number)
elif base == 8:
results['octal'] = oct(number)
elif base == 10:
results['decimal'] = str(number)
elif base == 16:
results['hexadecimal'] = hex(number)
else:
results[f'base_{base}'] = NumberSystemConverter.convert_between_bases(
number, 10, base
)
return results
@staticmethod
def create_conversion_table(numbers, max_num=20):
"""創(chuàng)建進制轉(zhuǎn)換表"""
print(f"{'十進制':<8} {'二進制':<10} {'八進制':<8} {'十六進制':<8} {'字符'}")
print("-" * 45)
for num in numbers:
if 0 <= num <= max_num:
char_repr = repr(chr(num)) if 32 <= num <= 126 else '控制字符'
print(f"{num:<8} {bin(num):<10} {oct(num):<8} {hex(num):<8} {char_repr}")
# 使用示例
converter = NumberSystemConverter()
# 進制間轉(zhuǎn)換
print("進制間轉(zhuǎn)換示例:")
print(f"二進制 '1010' -> 八進制: {converter.convert_between_bases('1010', 2, 8)}")
print(f"十六進制 'FF' -> 十進制: {converter.convert_between_bases('FF', 16, 10)}")
print(f"八進制 '77' -> 二進制: {converter.convert_between_bases('77', 8, 2)}")
# 多進制格式化
num = 255
formats = converter.format_number_bases(num, [2, 8, 10, 16, 5])
print(f"\n數(shù)字 {num} 的多種進制表示:")
for base_name, value in formats.items():
print(f" {base_name}: {value}")
# 創(chuàng)建轉(zhuǎn)換表
print("\nASCII字符編碼表（部分）:")
converter.create_conversion_table(range(65, 75)) # A-J
六、總結與實用建議
通過本文的詳細解析，我們深入了解了Python中三個重要的內(nèi)置功能：
- object - 所有類的終極基類
- oct(integer) - 八進制轉(zhuǎn)換的翻譯器
- ord(character) - 字符編碼的解碼器
關鍵知識點總結：
object是所有Python類的基類，實例沒有__dict__屬性oct()將整數(shù)轉(zhuǎn)換為帶"0o"前綴的八進制字符串ord()返回字符的Unicode碼位，支持字符串和字節(jié)對象
實用場景推薦：
- object：基類設計、內(nèi)存優(yōu)化、不可變對象
- oct()：文件權限管理、進制轉(zhuǎn)換、低級編程
- ord()：字符編碼分析、文本處理、國際化支持
最佳實踐建議：
- 合理使用object：在需要內(nèi)存優(yōu)化時使用
__slots__，避免不必要的屬性 - 理解進制轉(zhuǎn)換：掌握二進制、八進制、十進制、十六進制的相互轉(zhuǎn)換
- 處理字符編碼：始終明確文本的編碼方式，使用
ord()和chr()進行編碼轉(zhuǎn)換 - 異常處理：對用戶輸入進行驗證，特別是進制轉(zhuǎn)換和編碼處理時
安全使用注意事項：
- 使用
oct()轉(zhuǎn)換用戶輸入時驗證數(shù)值范圍 - 使用
ord()處理多字節(jié)字符時注意編碼問題 - 在基類設計中合理使用屬性限制
性能優(yōu)化技巧：
- 使用
__slots__減少對象內(nèi)存占用 - 對頻繁的字符編碼操作進行緩存
- 使用生成器處理大文本的字符分析
進階學習方向：
- 深入學習Python的Unicode支持和編碼問題
- 研究
__getattribute__()和__getattr__()等特殊方法 - 了解Python的內(nèi)存管理和垃圾回收機制
- 探索struct模塊處理二進制數(shù)據(jù)
這三個功能雖然基礎，但它們是Python編程的重要基石。從面向?qū)ο笤O計到底層編碼處理，從內(nèi)存優(yōu)化到權限管理，它們?yōu)楦鞣N編程場景提供了強大的支持。熟練掌握這些功能將幫助你編寫出更加健壯、高效的Python代碼。
以上就是Python內(nèi)置函數(shù)object、oct()、ord()的實用指南的詳細內(nèi)容，更多關于Python內(nèi)置函數(shù)object、oct()、ord()的資料請關注腳本之家其它相關文章！
相關文章
django中使用POST方法獲取POST數(shù)據(jù)
這篇文章主要介紹了django中使用POST方法獲取POST數(shù)據(jù),文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2019-08-08
python中protobuf和json互相轉(zhuǎn)換應用處理方法
protobuf目前有proto2和proto3兩個版本，本文所介紹的是基于proto3，在Python 3.6.9環(huán)境下運行，本文記錄一下python中protobuf和json的相互轉(zhuǎn)換的處理方法，感興趣的朋友跟隨小編一起看看吧2022-12-12
Python結合ImageMagick實現(xiàn)多張圖片合并為一個pdf文件的方法
這篇文章主要介紹了Python結合ImageMagick實現(xiàn)多張圖片合并為一個pdf文件的方法,結合實例形式分析了Python將圖片文件轉(zhuǎn)換為pdf文件的相關操作技巧,需要的朋友可以參考下2018-04-04
使用PyInstaller打包Python腳本為可執(zhí)行文件的詳細指南
這篇文章主要為大家詳細介紹了使用PyInstaller打包Python腳本為可執(zhí)行文件的詳細步驟,文中的示例代碼講解詳細,感興趣的小伙伴可以跟隨小編一起學習一下2025-09-09
python中的iterator和"lazy?iterator"區(qū)別介紹
這篇文章主要介紹了python中的iterator和?“l(fā)azy?iterator“之間有什么區(qū)別,本文通過實例代碼給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下2023-04-04
這篇文章主要介紹了python 還原梯度下降算法實現(xiàn)一維線性回歸，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2020-10-10
想必大家都玩過貪吃蛇的游戲吧：通過操縱蛇的移動方向能夠讓蛇吃到隨機出現(xiàn)的食物，吃到的食物越多，蛇就會變得越長。本文將使用手勢識別來完成貪吃蛇這個簡單的游戲，感興趣的可以了解一下2022-04-04
這篇文章主要為大家介紹一個簡單的Python暴力破解網(wǎng)站登錄密碼腳本，文中的過程講解詳細，對我們學習Python有一定的幫助，感興趣的可以學習一下2022-01-01
這篇文章主要介紹了Python列表切片操作,結合實例形式總結分析了Python列表切片常見操作技巧與注意事項,需要的朋友可以參考下2019-02-02
今天小編就為大家分享一篇解決tensorflow由于未初始化變量而導致的錯誤問題，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2020-01-01