from collections import defaultdict
# 使用普通字典統(tǒng)計(jì)單詞出現(xiàn)次數(shù)
word_counts = {}
words = ['apple', 'banana', 'apple', 'orange', 'banana', 'apple']
for word in words:
    if word in word_counts:
        word_counts[word] += 1
    else:
        word_counts[word] = 1
print("普通字典統(tǒng)計(jì)結(jié)果：", word_counts)
# 輸出: {'apple': 3, 'banana': 2, 'orange': 1}
# 使用defaultdict簡(jiǎn)化代碼
word_counts_dd = defaultdict(int)
for word in words:
    word_counts_dd[word] += 1  # 不需要檢查鍵是否存在
print("defaultdict統(tǒng)計(jì)結(jié)果：", word_counts_dd)
# 輸出: defaultdict(<class 'int'>, {'apple': 3, 'banana': 2, 'orange': 1})

from collections import defaultdict
employees = [
    {'name': 'Alice', 'department': 'Engineering'},
    {'name': 'Bob', 'department': 'HR'},
    {'name': 'Charlie', 'department': 'Engineering'},
    {'name': 'David', 'department': 'Marketing'},
    {'name': 'Eve', 'department': 'HR'}
]
# 使用defaultdict進(jìn)行分組
dept_groups = defaultdict(list)
for employee in employees:
    dept = employee['department']
    dept_groups[dept].append(employee['name'])
print("按部門分組結(jié)果：", dept_groups)
# 輸出: defaultdict(<class 'list'>, {'Engineering': ['Alice', 'Charlie'], 'HR': ['Bob', 'Eve'], 'Marketing': ['David']})

from collections import defaultdict
# 創(chuàng)建一個(gè)兩級(jí)defaultdict
sales_data = defaultdict(lambda: defaultdict(int))
# 模擬一些銷售記錄
records = [
    {'year': 2023, 'month': 1, 'amount': 1500},
    {'year': 2023, 'month': 2, 'amount': 2000},
    {'year': 2023, 'month': 1, 'amount': 1800},
    {'year': 2024, 'month': 1, 'amount': 2200},
    {'year': 2024, 'month': 3, 'amount': 1700},
]
for record in records:
    year = record['year']
    month = record['month']
    amount = record['amount']
    sales_data[year][month] += amount
print("多級(jí)字典銷售數(shù)據(jù)：")
for year, months in sales_data.items():
    for month, total in months.items():
        print(f"Year {year}, Month {month}: {total}")

from collections import defaultdict
# 創(chuàng)建一個(gè)三級(jí)defaultdict
def recursive_defaultdict():
    return defaultdict(recursive_defaultdict)
nested_dict = defaultdict(recursive_defaultdict)
# 添加數(shù)據(jù)
nested_dict['level1']['level2']['level3'] = 'deep_value'
print("三級(jí)嵌套字典：", nested_dict)
# 輸出: defaultdict(<function recursive_defaultdict at 0x...>, {'level1': defaultdict(<function recursive_defaultdict at 0x...>, {'level2': defaultdict(<function recursive_defaultdict at 0x...>, {'level3': 'deep_value'})})})

import time
from collections import defaultdict
# 生成一個(gè)包含大量單詞的列表
words = ['word{}'.format(i) for i in range(100000)] + ['common'] * 100000
# 使用普通字典
start_time = time.time()
word_counts = {}
for word in words:
    if word in word_counts:
        word_counts[word] += 1
    else:
        word_counts[word] = 1
end_time = time.time()
print("普通字典計(jì)數(shù)時(shí)間：{:.4f}秒".format(end_time - start_time))
# 使用defaultdict
start_time = time.time()
word_counts_dd = defaultdict(int)
for word in words:
    word_counts_dd[word] += 1
end_time = time.time()
print("defaultdict計(jì)數(shù)時(shí)間：{:.4f}秒".format(end_time - start_time))

from collections import Counter
# 統(tǒng)計(jì)單詞出現(xiàn)次數(shù)
words = ['apple', 'banana', 'apple', 'orange', 'banana', 'apple']
word_counts = Counter(words)
print("Counter統(tǒng)計(jì)結(jié)果：", word_counts)
# 輸出: Counter({'apple': 3, 'banana': 2, 'orange': 1})
# 獲取出現(xiàn)次數(shù)最多的兩個(gè)單詞
most_common_two = word_counts.most_common(2)
print("出現(xiàn)次數(shù)最多的兩個(gè)單詞：", most_common_two)
# 輸出: [('apple', 3), ('banana', 2)]

from collections import Counter
import matplotlib.pyplot as plt
from wordcloud import WordCloud
text = """
Python is a high-level, interpreted, general-purpose programming language.
Its design philosophy emphasizes code readability with the use of significant indentation.
"""
# 分詞
words = text.lower().split()
# 統(tǒng)計(jì)單詞頻率
word_counts = Counter(words)
# 生成詞云
wordcloud = WordCloud(width=800, height=400, background_color='white').generate_from_frequencies(word_counts)
# 顯示詞云
plt.figure(figsize=(10, 5))
plt.imshow(wordcloud, interpolation='bilinear')
plt.axis('off')
plt.show()

from collections import Counter
# 模擬數(shù)據(jù)列表
data = ['A', 'B', 'C', 'A', 'B', 'A', 'D', 'E', 'F', 'A', 'B', 'C', 'D']
# 統(tǒng)計(jì)每個(gè)元素的頻率
data_counts = Counter(data)
# 找出出現(xiàn)次數(shù)少于2次的元素
rare_elements = [element for element, count in data_counts.items() if count < 2]
print("出現(xiàn)次數(shù)少于2次的元素：", rare_elements)
# 輸出: ['E', 'F']

from collections import Counter
words = ['apple', 'banana', 'apple', 'orange', 'banana', 'apple', 'grape', 'banana', 'grape', 'grape']
word_counts = Counter(words)
# 獲取出現(xiàn)次數(shù)最多的兩個(gè)單詞
top_two = word_counts.most_common(2)
print("出現(xiàn)次數(shù)最多的兩個(gè)單詞：", top_two)
# 輸出: [('apple', 3), ('banana', 3)]
# 獲取所有元素按頻率排序
sorted_words = word_counts.most_common()
print("所有元素按頻率排序：", sorted_words)
# 輸出: [('apple', 3), ('banana', 3), ('grape', 3), ('orange', 1)]

from collections import Counter
word_counts = Counter({'apple': 3, 'banana': 2, 'orange': 1})
# 獲取還原的元素列表
elements = list(word_counts.elements())
print("還原的元素列表：", elements)
# 輸出: ['apple', 'apple', 'apple', 'banana', 'banana', 'orange']

from collections import Counter
c1 = Counter({'apple': 4, 'banana': 2, 'orange': 1})
c2 = Counter({'apple': 1, 'banana': 1, 'grape': 2})
c1.subtract(c2)
print("減法后的計(jì)數(shù)器：", c1)
# 輸出: Counter({'apple': 3, 'banana': 1, 'orange': 1, 'grape': -2})

from collections import Counter
c1 = Counter({'apple': 3, 'banana': 1, 'orange': 2})
c2 = Counter({'apple': 1, 'banana': 2, 'grape': 1})
# 加法
c_sum = c1 + c2
print("加法結(jié)果：", c_sum)
# 輸出: Counter({'apple': 4, 'banana': 3, 'orange': 2, 'grape': 1})
# 交集
c_intersection = c1 & c2
print("交集結(jié)果：", c_intersection)
# 輸出: Counter({'apple': 1, 'banana': 1})
# 并集
c_union = c1 | c2
print("并集結(jié)果：", c_union)
# 輸出: Counter({'apple': 3, 'banana': 2, 'orange': 2, 'grape': 1})

from collections import defaultdict
# 使用set作為默認(rèn)值，避免重復(fù)添加元素
dept_employees = defaultdict(set)
employees = [
    {'name': 'Alice', 'department': 'Engineering'},
    {'name': 'Bob', 'department': 'HR'},
    {'name': 'Charlie', 'department': 'Engineering'},
    {'name': 'Alice', 'department': 'Engineering'},
    {'name': 'Eve', 'department': 'HR'}
]
for employee in employees:
    dept = employee['department']
    name = employee['name']
    dept_employees[dept].add(name)
print("按部門唯一員工分組：", dept_employees)
# 輸出: defaultdict(<class 'set'>, {'Engineering': {'Alice', 'Charlie'}, 'HR': {'Bob', 'Eve'}})

from collections import Counter
# 模擬多個(gè)計(jì)數(shù)器
c1 = Counter({'apple': 2, 'banana': 1})
c2 = Counter({'apple': 1, 'orange': 3})
c3 = Counter({'banana': 2, 'grape': 1})
# 合并所有計(jì)數(shù)器
total_counts = c1 + c2 + c3
print("合并后的計(jì)數(shù)器：", total_counts)
# 輸出: Counter({'apple': 3, 'orange': 3, 'banana': 3, 'grape': 1})

from collections import Counter
# 使用生成器表達(dá)式代替列表
words_generator = (word for word in open('large_text_file.txt', 'r'))
# 初始化Counter
word_counts = Counter(words_generator)
print("最常見的五個(gè)單詞：", word_counts.most_common(5))

from collections import defaultdict, Counter
# 模擬項(xiàng)目分配數(shù)據(jù)
project_assignments = [
    {'department': 'Engineering', 'employee': 'Alice', 'project': 'Project X'},
    {'department': 'Engineering', 'employee': 'Bob', 'project': 'Project Y'},
    {'department': 'HR', 'employee': 'Charlie', 'project': 'Project Z'},
    {'department': 'Engineering', 'employee': 'Alice', 'project': 'Project Y'},
    {'department': 'HR', 'employee': 'Charlie', 'project': 'Project X'},
    {'department': 'Engineering', 'employee': 'Bob', 'project': 'Project X'},
]
# 使用defaultdict嵌套Counter
dept_employee_projects = defaultdict(Counter)
for assignment in project_assignments:
    dept = assignment['department']
    employee = assignment['employee']
    project = assignment['project']
    dept_employee_projects[dept][employee] += 1
print("每個(gè)部門中每個(gè)員工的項(xiàng)目數(shù)量：")
for dept, counter in dept_employee_projects.items():
    print(f"部門: {dept}")
    for employee, count in counter.items():
        print(f"  員工: {employee}, 項(xiàng)目數(shù)量: {count}")

from collections import Counter
c1 = Counter({'apple': 3, 'banana': 1, 'orange': 2})
c2 = Counter({'apple': 1, 'banana': 2, 'grape': 1})
# 計(jì)算交集
c_intersection = c1 & c2
print("交集計(jì)數(shù)器：", c_intersection)
# 輸出: Counter({'apple': 1, 'banana': 1})

from collections import defaultdict
def default_value_factory():
    return "default_"  # 自定義默認(rèn)值
# 創(chuàng)建defaultdict，使用自定義工廠函數(shù)
custom_dd = defaultdict(default_value_factory)
# 訪問不存在的鍵
print("訪問不存在的鍵 'key1'：", custom_dd['key1'])
# 輸出: default_
# 再次訪問相同鍵，已存在
print("再次訪問鍵 'key1'：", custom_dd['key1'])
# 輸出: default_

from collections import defaultdict
def dynamic_default_factory(key):
    return f"default_for_{key}"
# 自定義defaultdict類，傳遞鍵給工廠函數(shù)
class DynamicDefaultDict(defaultdict):
    def __missing__(self, key):
        self[key] = dynamic_default_factory(key)
        return self[key]
# 創(chuàng)建DynamicDefaultDict實(shí)例
dynamic_dd = DynamicDefaultDict()
# 訪問不存在的鍵
print("訪問不存在的鍵 'alpha'：", dynamic_dd['alpha'])
# 輸出: default_for_alpha
print("訪問不存在的鍵 'beta'：", dynamic_dd['beta'])
# 輸出: default_for_beta

from collections import Counter
# 假設(shè)有一個(gè)非常大的文本文件
def word_generator(file_path):
    with open(file_path, 'r') as file:
        for line in file:
            for word in line.lower().split():
                yield word
# 使用生成器初始化Counter
word_counts = Counter(word_generator('large_text_file.txt'))

from collections import Counter
# 處理二進(jìn)制數(shù)據(jù)
data = b"apple banana apple orange banana apple"
# 使用Counter直接統(tǒng)計(jì)字節(jié)
byte_counts = Counter(data.split())
print(byte_counts)
# 輸出: Counter({b'apple': 3, b'banana': 2, b'orange': 1})

from collections import Counter
words = ['apple', 'banana', 'Apple', 'orange', 'banana', 'apple', 'APPLE']
# 只統(tǒng)計(jì)小寫的單詞
word_counts = Counter(word.lower() for word in words if word.islower())
print("小寫單詞計(jì)數(shù)：", word_counts)
# 輸出: Counter({'apple': 3, 'banana': 2, 'orange': 1})

from collections import defaultdict
# 定義遞歸defaultdict
def tree():
    return defaultdict(tree)
# 創(chuàng)建樹狀結(jié)構(gòu)
family_tree = tree()
# 添加成員
family_tree['grandparent']['parent']['child'] = 'Alice'
family_tree['grandparent']['parent']['child2'] = 'Bob'
print("家族樹：", family_tree)
# 輸出: defaultdict(<function tree at 0x...>, {'grandparent': defaultdict(<function tree at 0x...>, {'parent': defaultdict(<function tree at 0x...>, {'child': 'Alice', 'child2': 'Bob'})})})

from collections import Counter
def compute_probability_distribution(data):
    counts = Counter(data)
    total = sum(counts.values())
    probability = {element: count / total for element, count in counts.items()}
    return probability
# 示例數(shù)據(jù)
data = ['A', 'B', 'A', 'C', 'B', 'A', 'D']
prob_dist = compute_probability_distribution(data)
print("概率分布：", prob_dist)
# 輸出: {'A': 0.42857142857142855, 'B': 0.2857142857142857, 'C': 0.14285714285714285, 'D': 0.14285714285714285}

from collections import Counter
import math
def compute_entropy(data):
    counts = Counter(data)
    total = sum(counts.values())
    entropy = -sum((count / total) * math.log(count / total, 2) for count in counts.values())
    return entropy
# 示例數(shù)據(jù)
data = ['A', 'B', 'A', 'C', 'B', 'A', 'D']
entropy = compute_entropy(data)
print("信息熵：", entropy)
# 輸出: 信息熵： 1.8464393446710154

from collections import defaultdict
def matrix_frequency(matrix):
    freq = defaultdict(int)
    for row in matrix:
        for element in row:
            freq[element] += 1
    return freq
# 示例矩陣
matrix = [
    [1, 2, 3],
    [4, 2, 1],
    [1, 3, 4],
    [2, 2, 2]
]
freq = matrix_frequency(matrix)
print("矩陣元素頻率：", freq)
# 輸出: defaultdict(<class 'int'>, {1: 3, 2: 5, 3: 2, 4: 2})

logs = [
    {'user_id': 'U1', 'product_id': 'P1'},
    {'user_id': 'U2', 'product_id': 'P2'},
    {'user_id': 'U1', 'product_id': 'P3'},
    {'user_id': 'U3', 'product_id': 'P1'},
    {'user_id': 'U2', 'product_id': 'P1'},
    {'user_id': 'U1', 'product_id': 'P2'},
    {'user_id': 'U3', 'product_id': 'P3'},
    {'user_id': 'U2', 'product_id': 'P3'},
    {'user_id': 'U1', 'product_id': 'P1'},
    {'user_id': 'U3', 'product_id': 'P2'},
]

from collections import defaultdict
# 使用defaultdict記錄每個(gè)用戶購(gòu)買的商品
user_purchases = defaultdict(list)
for log in logs:
    user = log['user_id']
    product = log['product_id']
    user_purchases[user].append(product)
print("每個(gè)用戶的購(gòu)買記錄：", user_purchases)
# 輸出: defaultdict(<class 'list'>, {'U1': ['P1', 'P3', 'P2', 'P1'], 'U2': ['P2', 'P1', 'P3'], 'U3': ['P1', 'P3', 'P2']})

from collections import Counter
# 提取所有購(gòu)買的商品
all_products = [log['product_id'] for log in logs]
# 使用Counter統(tǒng)計(jì)商品購(gòu)買次數(shù)
product_counts = Counter(all_products)
print("每個(gè)商品的購(gòu)買次數(shù)：", product_counts)
# 輸出: Counter({'P1': 4, 'P2': 3, 'P3': 3})

from collections import defaultdict, Counter
import math
# 使用defaultdict記錄每個(gè)用戶購(gòu)買的商品
user_purchases = defaultdict(list)
for log in logs:
    user = log['user_id']
    product = log['product_id']
    user_purchases[user].append(product)
# 使用Counter統(tǒng)計(jì)每個(gè)商品的購(gòu)買次數(shù)
product_counts = Counter([log['product_id'] for log in logs])
# 計(jì)算每個(gè)用戶的購(gòu)買頻率（信息熵）
def compute_user_entropy(purchases):
    count = Counter(purchases)
    total = sum(count.values())
    entropy = -sum((c / total) * math.log(c / total, 2) for c in count.values())
    return entropy
user_entropy = {user: compute_user_entropy(products) for user, products in user_purchases.items()}
print("每個(gè)用戶的購(gòu)買信息熵：", user_entropy)
# 輸出: {'U1': 1.5, 'U2': 1.584962500721156, 'U3': 1.5}
# 推薦高頻商品給用戶（未購(gòu)買過(guò)的高頻商品）
def recommend_products(user_purchases, product_counts, top_n=2):
    recommendations = {}
    for user, products in user_purchases.items():
        purchased = set(products)
        # 選擇購(gòu)買次數(shù)最多且用戶未購(gòu)買過(guò)的商品
        recommended = [prod for prod, count in product_counts.most_common() if prod not in purchased]
        recommendations[user] = recommended[:top_n]
    return recommendations
recommendations = recommend_products(user_purchases, product_counts)
print("為每個(gè)用戶推薦的商品：", recommendations)
# 輸出: {'U1': [], 'U2': [], 'U3': []}