Python高阶函数实现统计列表中元素的出现频率

numbers = [1, 2, 3, 4, 5]

# map 是高阶函数：它接受一个函数和一个可迭代对象
squared = list(map(lambda x: x**2, numbers))
print(squared)  # [1, 4, 9, 16, 25]

data = ['apple', 'banana', 'apple', 'cherry', 'banana', 'apple']

freq = {}
for item in data:
    freq[item] = freq.get(item, 0) + 1

print(freq)
# {'apple': 3, 'banana': 2, 'cherry': 1}

from collections import Counter

data = ['apple', 'banana', 'apple', 'cherry', 'banana', 'apple']
freq = Counter(data)

print(freq)
# Counter({'apple': 3, 'banana': 2, 'cherry': 1})

from itertools import groupby
from operator import itemgetter

data = ['apple', 'banana', 'apple', 'cherry', 'banana', 'apple']

# 先排序，因为 groupby 要求数据有序
sorted_data = sorted(data)

# 按元素分组
groups = groupby(sorted_data)

# 使用 map 计算每组数量
freq = {key: len(list(group)) for key, group in groups}

print(freq)
# {'apple': 3, 'banana': 2, 'cherry': 1}

from functools import reduce
from operator import add

def count_frequency(lst):
    # 去重并保持顺序
    unique_items = list(dict.fromkeys(lst))
    
    # 定义一个高阶函数：对每个 item，计算其在原列表中的出现次数
    def count_item(item):
        return lst.count(item)
    
    # 用 map 应用到每个唯一元素
    counts = map(count_item, unique_items)
    
    # 用 zip 将元素与计数配对
    result = dict(zip(unique_items, counts))
    
    return result

# 测试
data = ['apple', 'banana', 'apple', 'cherry', 'banana', 'apple']
freq = count_frequency(data)
print(freq)
# {'apple': 3, 'banana': 2, 'cherry': 1}

from functools import reduce

def count_with_reduce(lst):
    # 初始化空字典
    initial = {}
    
    # 定义合并函数：将一个元素及其计数加入字典
    def merge(acc, item):
        acc[item] = acc.get(item, 0) + 1
        return acc
    
    # reduce 逐个处理每个元素
    final_dict = reduce(merge, lst, initial)
    
    return final_dict

# 测试
data = ['apple', 'banana', 'apple', 'cherry', 'banana', 'apple']
freq = count_with_reduce(data)
print(freq)
# {'apple': 3, 'banana': 2, 'cherry': 1}

def frequency_by_key(lst, key_func):
    """
    根据自定义键函数统计频率。
    
    :param lst: 输入列表
    :param key_func: 键函数，如 len, lambda x: x[0], etc.
    :return: 字典，键为 key_func(x)，值为出现次数
    """
    from functools import reduce
    
    def merge(acc, item):
        key = key_func(item)
        acc[key] = acc.get(key, 0) + 1
        return acc
    
    return reduce(merge, lst, {})

# 测试：按字符串长度分组
words = ['cat', 'dog', 'elephant', 'bee', 'ant']
length_freq = frequency_by_key(words, key_func=len)
print(length_freq)
# {3: 3, 8: 1}  # 3个长度为3的词，1个长度为8的词

# 测试：按首字母分组
first_letter_freq = frequency_by_key(words, key_func=lambda x: x[0])
print(first_letter_freq)
# {'c': 1, 'd': 1, 'e': 1, 'b': 2, 'a': 1}

import time
from functools import reduce
from collections import Counter

# 生成测试数据
data = ['apple', 'banana', 'apple', 'cherry'] * 1000

def benchmark(func, data, name):
    start = time.time()
    for _ in range(1000):
        func(data)
    end = time.time()
    print(f"{name}: {(end - start)*1000:.2f} ms")

# 测试不同方法
benchmark(lambda lst: {item: lst.count(item) for item in set(lst)}, data, "Manual Count")
benchmark(lambda lst: dict.fromkeys(set(lst), 0), data, "Dict.fromkeys")
benchmark(lambda lst: Counter(lst), data, "Counter")
benchmark(lambda lst: reduce(lambda acc, x: {**acc, x: acc.get(x, 0) + 1}, lst, {}), data, "Reduce")

logs = [
    'user1', 'user2', 'user1', 'user3', 'user2', 'user1', 'user4'
]

from functools import reduce

def get_top_users(logs, top_n=3):
    # 统计频率
    freq = reduce(
        lambda acc, user: {**acc, user: acc.get(user, 0) + 1},
        logs,
        {}
    )
    
    # 排序取前 N 个
    sorted_users = sorted(freq.items(), key=lambda x: x[1], reverse=True)
    
    return sorted_users[:top_n]

# 获取前3名用户
top_users = get_top_users(logs, top_n=3)
print(top_users)
# [('user1', 3), ('user2', 2), ('user3', 1)]

# ❌ 危险！O(n²) 复杂度
freq = {item: data.count(item) for item in set(data)}

# ❌ 错误：未排序
data = ['apple', 'banana', 'apple']
groups = groupby(data)  # 不能保证分组正确

sorted_data = sorted(data)
groups = groupby(sorted_data)