高效优化Pandas DataFrame中列表元素的存在性检查

# 假设 all_genres 是一个包含所有可能类型的字典
# genre_names 是从 all_genres 中提取的特定类型列表
# spotify_data 是一个DataFrame，其中包含 'Genre' 列

genre_names = take(1545, all_genres) # 示例函数，用于提取部分类型名称
streams_on_genre = []
for genre in genre_names:
    streams = 0
    for index, row in spotify_data.iterrows():
        if genre in row['Genre']: # 检查当前类型是否在行的'Genre'字符串中
            streams += row['Streams']
    streams_on_genre.append(streams)

import pandas as pd

# 示例DataFrame
data = {'a': [1, 2, 3], 'b': [4, 5, 6], 'c':['apple','orange','banana']}
df = pd.DataFrame(data)

print(df)
#    a  b       c
# 0  1  4   apple
# 1  2  5  orange
# 2  3  6  banana

# 检查单个元素 '5' 是否存在于 'b' 列中
print(f"5 是否存在于 df['b'] 列中: {5 in df['b'].values}")
# 输出: 5 是否存在于 df['b'] 列中: True

# 检查单个元素 'pear' 是否存在于 'c' 列中
print(f"'pear' 是否存在于 df['c'] 列中: {'pear' in df['c'].values}")
# 输出: 'pear' 是否存在于 df['c'] 列中: False

# 检查单个元素 'apple' 是否存在于 'c' 列中
print(f"'apple' 是否存在于 df['c'] 列中: {'apple' in df['c'].values}")
# 输出: 'apple' 是否存在于 df['c'] 列中: True

import pandas as pd

# 假设 spotify_data DataFrame
spotify_data = pd.DataFrame({
    'Genre': ['Pop', 'Rock, Indie', 'Hip Hop', 'Jazz', 'Rock', 'Pop, Dance'],
    'Streams': [1000, 1500, 800, 500, 1200, 2000]
})

# 假设要查找的类型列表
target_genres = ['Pop', 'Rock', 'Electronic']

# 方法一：检查 'Genre' 列中的每个元素是否完全匹配 target_genres 列表中的任一元素
# 注意：如果 'Genre' 列中是复合类型（如 'Rock, Indie'），这种方法只匹配完全相同的字符串
is_present_exact_match = spotify_data['Genre'].isin(target_genres)
print("\n精确匹配结果 (is_present_exact_match):\n", is_present_exact_match)
# 结果示例:
# 0     True  ('Pop' 在 target_genres 中)
# 1    False  ('Rock, Indie' 不完全等于 'Rock' 或其他)
# 2    False
# 3    False
# 4     True  ('Rock' 在 target_genres 中)
# 5    False

# 我们可以用这个布尔Series来过滤DataFrame
matched_data_exact = spotify_data[is_present_exact_match]
print("\n精确匹配的 DataFrame 行:\n", matched_data_exact)

# 统计匹配到的行数
print(f"\n精确匹配到的行数: {is_present_exact_match.sum()}")

# ---------------------------------------------------------------------
# 方法二：处理列中包含多个值（如 'Rock, Indie'）的情况
# 如果 'Genre' 列的每个元素可能是一个包含多个子类型的字符串，我们需要更灵活的检查
# 我们可以创建一个函数来检查目标类型是否是 'Genre' 字符串的子串

def contains_any_genre(genre_string, target_list):
    for target in target_list:
        if target in genre_string:
            return True
    return False

# 应用这个函数到 'Genre' 列
# 注意：apply 函数虽然比iterrows快，但仍然不如向量化操作高效，
# 但对于字符串子串匹配，通常是必要的步骤。
is_present_substring_match = spotify_data['Genre'].apply(
    lambda x: contains_any_genre(x, target_genres)
)
print("\n子串匹配结果 (is_present_substring_match):\n", is_present_substring_match)
# 结果示例:
# 0     True  ('Pop' 在 'Pop' 中)
# 1     True  ('Rock' 在 'Rock, Indie' 中)
# 2    False
# 3    False
# 4     True  ('Rock' 在 'Rock' 中)
# 5     True  ('Pop' 在 'Pop, Dance' 中)

matched_data_substring = spotify_data[is_present_substring_match]
print("\n子串匹配的 DataFrame 行:\n", matched_data_substring)
print(f"\n子串匹配到的行数: {is_present_substring_match.sum()}")

# 如果需要统计每个目标类型对应的总流媒体量
# 假设我们想知道 'Pop' 和 'Rock' 相关的总流媒体量
total_streams_by_genre = {}
for target_genre in target_genres:
    # 针对每个目标类型进行子串匹配
    mask = spotify_data['Genre'].apply(lambda x: target_genre in x)
    total_streams_by_genre[target_genre] = spotify_data[mask]['Streams'].sum()

print("\n按目标类型统计的总流媒体量:\n", total_streams_by_genre)

# 使用 str.contains() 进行子串匹配 (针对单个目标类型)
is_pop_genre = spotify_data['Genre'].str.contains('Pop', case=False, na=False)
print("\n是否包含 'Pop' (使用 str.contains):\n", is_pop_genre)

# 结合多个目标类型，可以使用正则表达式或循环
import re
pattern = '|'.join(target_genres) # 生成正则表达式 'Pop|Rock|Electronic'
is_any_target_genre = spotify_data['Genre'].str.contains(pattern, case=False, na=False)
print("\n是否包含任一目标类型 (使用 str.contains 和正则表达式):\n", is_any_target_genre)