如何獲取騰訊元寶PC端DeepSeek滿血版（完整指南）
你可能也喜歡這些API文章!
# 創建示例字典
user = {
'name': '張三',
'age': 25,
'email': 'zhangsan@example.com'
}
# 1. 訪問元素的多種方式
# 使用方括號訪問 - 最直接的方式，但鍵不存在時會拋出KeyError
print(user['name']) # 輸出：張三
# 使用get()方法訪問 - 推薦的安全訪問方式
# 第一個參數是鍵名，第二個參數是鍵不存在時的默認值
age = user.get('age', 0) # 如果'age'鍵不存在，返回默認值0
phone = user.get('phone', '未設置') # 獲取可能不存在的鍵
# 2. 修改元素
# 直接賦值修改已存在的鍵值對
user['age'] = 26# 修改已存在的鍵的值
# 3. 添加新元素
# 使用新鍵直接賦值
user['phone'] = '13800138000'# 添加新的鍵值對
# 4. 刪除元素的多種方式
# 使用del語句 - 刪除指定鍵值對，鍵不存在會拋出KeyError
del user['email']
# 使用pop()方法 - 刪除并返回值，可以提供默認值
phone = user.pop('phone', None) # 如果鍵不存在，返回None
# 使用popitem()方法 - 刪除并返回最后一個鍵值對
last_item = user.popitem() # 返回元組(key, value)# 1. 獲取字典信息的方法
# keys() - 獲取所有鍵
# 返回一個動態視圖對象，會隨字典變化而更新
keys = user.keys() # 獲取所有鍵的視圖
key_list = list(keys) # 轉換為列表
# values() - 獲取所有值
# 同樣返回動態視圖對象
values = user.values() # 獲取所有值的視圖
value_list = list(values) # 轉換為列表
# items() - 獲取所有鍵值對
# 返回(key, value)元組的視圖對象
items = user.items() # 獲取所有鍵值對的視圖
for key, value in items: # 常用于遍歷字典
print(f"{key}: {value}")
# 2. 修改字典的方法
# update() - 批量更新字典
# 可以使用另一個字典或鍵值對序列更新
user.update({'city': '北京', 'age': 27}) # 使用字典更新
user.update(zip(['hobby', 'job'], ['讀書', '程序員'])) # 使用鍵值對序列更新
# setdefault() - 設置默認值
# 如果鍵不存在，則設置默認值并返回
# 如果鍵存在，則返回現有值
email = user.setdefault('email', 'default@example.com')
# 3. 清理字典的方法
# clear() - 清空字典
# 刪除所有鍵值對
user.clear() # 字典變為空字典 {}
# copy() - 創建字典的淺拷貝
# 創建新字典，但嵌套的可變對象仍然共享引用
user_copy = user.copy()# 復雜的嵌套字典示例
# 展示了多層嵌套的數據結構
# 適用于表示層級關系的數據
school = {
'class_1': {
'teacher': '王老師',
'students': {
'001': {
'name': '張三',
'scores': {'語文': 85, '數學': 92}
},
'002': {
'name': '李四',
'scores': {'語文': 89, '數學': 94}
}
}
}
}
# 訪問嵌套數據的方法
# 1. 使用多級鍵訪問
print(school['class_1']['students']['001']['scores']['語文']) # 輸出：85
# 2. 使用get()方法的安全訪問
# 避免鍵不存在時的異常
score = school.get('class_1', {}).get('students', {}).get('001', {}).get('scores', {}).get('語文', 0)
# 3. 修改嵌套數據
# 逐層創建或修改數據
school['class_2'] = {} # 創建新的班級
school['class_2']['teacher'] = '李老師'# 添加教師信息
school['class_2']['students'] = {} # 初始化學生字典# 1. 條件字典推導式
# 根據條件篩選鍵值對
scores = {'張三': 85, '李四': 92, '王五': 78, '趙六': 95}
# 篩選成績大于等于85分的學生
pass_students = {name: score for name, score in scores.items() if score >= 85}
# 2. 轉換值的字典推導式
# 對原字典的值進行轉換
grades = {name: 'A'if score >= 90else'B'if score >= 80else'C'
for name, score in scores.items()}
# 3. 嵌套字典推導式
# 創建復雜的嵌套字典結構
# 生成乘法表字典
matrix = {i: {j: i*j for j in range(3)} for i in range(3)}
# 結果示例：{0: {0: 0, 1: 0, 2: 0}, 1: {0: 0, 1: 1, 2: 2}, 2: {0: 0, 1: 2, 2: 4}}# 1. 使用%操作符（舊式格式化）
# 語法簡單，但功能有限
info = {'name': '張三', 'age': 25}
print('%(name)s is %(age)d years old' % info)
# 2. 使用str.format()方法
# 更靈活，支持更多格式化選項
print('{name} is {age} years old'.format(**info))
# 3. 使用f-string（推薦，Python 3.6+）
# 最簡潔、直觀的方式
# 支持直接使用表達式
print(f"{info['name']} is {info['age']} years old")# 1. 對齊和填充
data = {'name': '張三', 'score': 95.5}
# 左對齊，寬度10
# 右對齊，寬度8，保留2位小數
print(f"{data['name']:<10}|{data['score']:>8.2f}")
# 2. 使用字典進行復雜模板格式化
# 適用于生成報告、配置文件等
template = '''
學生信息：
姓名：{name}
年齡：{age}
成績：{score:.1f}
'''
student = {
'name': '張三',
'age': 18,
'score': 95.6
}
print(template.format(**student))# 1. 預分配空間
# 當知道字典大小時，使用dict.fromkeys()預分配空間
# 避免頻繁的內存重新分配
keys = range(10000)
optimized_dict = dict.fromkeys(keys) # 預分配10000個空間
# 對比：動態增長的字典
unoptimized_dict = {}
for i in range(10000):
unoptimized_dict[i] = None# 會導致多次內存重新分配
# 2. 使用字典推導式替代循環
# 字典推導式通常比循環創建字典更快
squares_comprehension = {x: x**2for x in range(1000)} # 更快
squares_loop = {}
for x in range(1000): # 更慢
squares_loop[x] = x**2# 1. 使用get()方法的最佳實踐
# 當確定鍵存在時，使用方括號訪問更快
user = {'name': '張三', 'age': 25}
# 快：確定鍵存在時使用方括號
name = user['name']
# 慢：不必要的get()調用
name = user.get('name')
# 正確使用場景：鍵可能不存在時使用get()
phone = user.get('phone', '未設置')
# 2. 避免重復訪問
# 對頻繁訪問的值進行本地緩存
def process_user_slow(user):
# 差：重復訪問字典
print(f"姓名：{user['name']}")
print(f"年齡：{user['age']}")
if user['age'] > 18:
print(f"{user['name']}是成年人")
def process_user_fast(user):
# 好：將頻繁使用的值緩存到局部變量
name = user['name']
age = user['age']
print(f"姓名：{name}")
print(f"年齡：{age}")
if age > 18:
print(f"{name}是成年人")# 1. 批量更新優化
# 使用update()方法進行批量更新，而不是多次單獨更新
user = {'name': '張三'}
# 差：多次單獨更新
user['age'] = 25
user['city'] = '北京'
user['email'] = 'zhangsan@example.com'
# 好：使用update()批量更新
user.update({
'age': 25,
'city': '北京',
'email': 'zhangsan@example.com'
})
# 2. 避免頻繁的增刪操作
# 如果需要頻繁增刪，考慮使用collections.defaultdict或set
from collections import defaultdict
# 統計單詞頻率的例子
# 使用defaultdict避免鍵檢查
word_counts = defaultdict(int)
text = "the quick brown fox jumps over the lazy dog"
for word in text.split():
word_counts[word] += 1# 無需檢查鍵是否存在# 1. 使用__slots__優化類字典
# 當類屬性固定時，使用__slots__可以顯著減少內存使用
class UserNormal:
def __init__(self, name, age):
self.name = name
self.age = age
class UserOptimized:
__slots__ = ['name', 'age'] # 顯著減少內存使用
def __init__(self, name, age):
self.name = name
self.age = age
# 2. 及時清理不需要的數據
# 使用clear()方法而不是重新賦值
large_dict = {i: i**2for i in range(10000)}
# 差：直接賦值新字典
large_dict = {} # 舊字典仍在內存中，等待垃圾回收
# 好：使用clear()清理
large_dict.clear() # 立即釋放內存
# 3. 使用弱引用字典
# 當需要緩存對象但不阻止它們被垃圾回收時
from weakref import WeakKeyDictionary
class Cache:
def __init__(self):
# 當鍵對象沒有其他引用時，自動從字典中刪除
self.data = WeakKeyDictionary()import timeit
import sys
# 1. 字典創建性能對比
def test_dict_creation():
# 測試不同創建方法的性能
setup = """size = 1000"""
test1 = """dict_comp = {x: x**2 for x in range(size)}"""
test2 = """dict_loop = {}
for x in range(size):
dict_loop[x] = x**2"""
time1 = timeit.timeit(test1, setup, number=1000)
time2 = timeit.timeit(test2, setup, number=1000)
print(f"字典推導式: {time1:.4f}秒")
print(f"循環創建: {time2:.4f}秒")
# 2. 內存使用對比
def compare_memory_usage():
# 測試普通類和使用__slots__的類的內存占用
normal_users = [UserNormal(f"user{i}", i) for i in range(1000)]
optimized_users = [UserOptimized(f"user{i}", i) for i in range(1000)]
normal_size = sys.getsizeof(normal_users[0]) * len(normal_users)
optimized_size = sys.getsizeof(optimized_users[0]) * len(optimized_users)
print(f"普通類對象占用內存: {normal_size/1024:.2f}KB")
print(f"優化類對象占用內存: {optimized_size/1024:.2f}KB")
if __name__ == '__main__':
print("性能測試結果：")
test_dict_creation()
print("\n內存使用對比：")
compare_memory_usage()
