Преобразование словарей Python в DataFrame Pandas: полное руководство

# Создание словаря
data_dict = {
'имя': ['Иван', 'Мария', 'Александр'],
'возраст': [25, 30, 35],
'город': ['Москва', 'Санкт-Петербург', 'Казань']
}

import pandas as pd

# Создание DataFrame
df = pd.DataFrame({
'имя': ['Иван', 'Мария', 'Александр'],
'возраст': [25, 30, 35],
'город': ['Москва', 'Санкт-Петербург', 'Казань']
})

import pandas as pd

data_dict = {
'name': ['Alice', 'Bob', 'Charlie'],
'age': [25, 30, 35],
'city': ['New York', 'Boston', 'Chicago']
}

df = pd.DataFrame(data_dict)
print(df)

# Словарь с ключами как именами столбцов (orient='columns', по умолчанию)
dict_columns = {'A': [1, 2, 3], 'B': [4, 5, 6]}
df1 = pd.DataFrame.from_dict(dict_columns)

# Словарь с ключами как индексами строк (orient='index')
dict_index = {
'row1': {'A': 1, 'B': 2},
'row2': {'A': 3, 'B': 4}
}
df2 = pd.DataFrame.from_dict(dict_index, orient='index')

print("orient='columns':\n", df1)
print("\norient='index':\n", df2)

# Список словарей, где каждый словарь — отдельная строка
list_of_dicts = [
{'name': 'Alice', 'age': 25, 'city': 'New York'},
{'name': 'Bob', 'age': 30, 'city': 'Boston'},
{'name': 'Charlie', 'age': 35, 'city': 'Chicago'}
]

df = pd.DataFrame(list_of_dicts)
print(df)

complex_dict = {
'user1': {
'personal': {
'name': 'Alex',
'age': 28
},
'preferences': ['sports', 'music'],
'purchases': [
{'item': 'laptop', 'price': 1200},
{'item': 'phone', 'price': 800}
]
},
'user2': {
'personal': {
'name': 'Emma',
'age': 24
},
'preferences': ['reading', 'travel', 'cooking'],
'purchases': [
{'item': 'camera', 'price': 700},
{'item': 'book', 'price': 20}
]
}
}

def flatten_dict(nested_dict, prefix=''):
flattened = {}
for key, value in nested_dict.items():
if isinstance(value, dict):
flattened.update(flatten_dict(value, f"{prefix}{key}_"))
else:
flattened[f"{prefix}{key}"] = value
return flattened

# Применение к каждому пользователю
flattened_users = {
user_id: flatten_dict(user_data)
for user_id, user_data in complex_dict.items()
}

# Создание DataFrame
user_df = pd.DataFrame.from_dict(flattened_users, orient='index')
print(user_df)

from pandas import json_normalize

# Извлечение данных о покупках всех пользователей
all_purchases = []
for user_id, user_data in complex_dict.items():
for purchase in user_data['purchases']:
purchase['user_id'] = user_id
all_purchases.append(purchase)

# Создание DataFrame из списка покупок
purchases_df = json_normalize(all_purchases)
print(purchases_df)

# Вариант 1: Преобразование списков в строки
preferences_as_string = {
user_id: ', '.join(user_data['preferences'])
for user_id, user_data in complex_dict.items()
}

# Вариант 2: Создание бинарных индикаторов (one-hot encoding)
all_preferences = set()
for user_data in complex_dict.values():
all_preferences.update(user_data['preferences'])

preference_indicators = {}
for user_id, user_data in complex_dict.items():
user_prefs = user_data['preferences']
preference_indicators[user_id] = {
pref: pref in user_prefs for pref in all_preferences
}

preferences_df = pd.DataFrame.from_dict(preference_indicators, orient='index')
print(preferences_df)

# Преобразование многоуровневой структуры
normalized_df = json_normalize(
data=[{'id': k, **v} for k, v in complex_dict.items()],
record_path=['purchases'],
meta=[
'id', 
['personal', 'name'], 
['personal', 'age']
],
meta_prefix='user_'
)
print(normalized_df)

# Явное указание типов данных при создании DataFrame
typed_df = pd.DataFrame({
'id': pd.Series(data=[1, 2, 3], dtype='int32'),
'name': pd.Series(data=['A', 'B', 'C'], dtype='category'),
'value': pd.Series(data=[1\.1, 2.2, 3.3], dtype='float32')
})

# Альтернативно, можно изменить типы уже созданного DataFrame
df = pd.DataFrame({'id': [1, 2, 3], 'name': ['A', 'B', 'C'], 'value': [1\.1, 2.2, 3.3]})
df['id'] = df['id'].astype('int32')
df['name'] = df['name'].astype('category')
df['value'] = df['value'].astype('float32')

print(f"Размер в памяти: {df.memory_usage(deep=True).sum()} байт")

# Оптимизация использования памяти
def optimize_dataframe(df):
start_mem = df.memory_usage(deep=True).sum() / 1024**2
print(f"Исходное использование памяти: {start_mem:.2f} MB")

for col in df.columns:
# Оптимизация целочисленных типов
if df[col].dtype == 'int64':
min_val, max_val = df[col].min(), df[col].max()
if min_val >= -128 and max_val <= 127:
df[col] = df[col].astype('int8')
elif min_val >= -32768 and max_val <= 32767:
df[col] = df[col].astype('int16')
elif min_val >= -2147483648 and max_val <= 2147483647:
df[col] = df[col].astype('int32')

# Оптимизация чисел с плавающей точкой
elif df[col].dtype == 'float64':
df[col] = df[col].astype('float32')

# Оптимизация строковых типов
elif df[col].dtype == 'object':
if df[col].nunique() / len(df[col]) < 0.5: # Если менее 50% уникальных значений
df[col] = df[col].astype('category')

end_mem = df.memory_usage(deep=True).sum() / 1024**2
print(f"Оптимизированное использование памяти: {end_mem:.2f} MB")
print(f"Уменьшение: {100 * (start_mem – end_mem) / start_mem:.2f}%")

return df

optimized_df = optimize_dataframe(df)

# Установка эффективного индекса
# Используйте колонку, по которой часто выполняется поиск
df.set_index('id', inplace=True)

# Поиск по индексу гораздо быстрее, чем по колонкам
result = df.loc[2] # Быстрая выборка по индексу

# Для иерархических данных используйте составные индексы
multi_index_df = pd.DataFrame({
'date': ['2022-01-01', '2022-01-01', '2022-01-02', '2022-01-02'],
'category': ['A', 'B', 'A', 'B'],
'value': [100, 200, 300, 400]
})
multi_index_df.set_index(['date', 'category'], inplace=True)

# Эффективный поиск по составному индексу
result = multi_index_df.loc[('2022-01-01', 'A')]

# Плохо: использование циклов
def slow_calculation(df):
results = []
for i, row in df.iterrows():
results.append(row['value'] * 2)
df['doubled'] = results
return df

# Хорошо: векторизованные операции
def fast_calculation(df):
df['doubled'] = df['value'] * 2
return df

# Измерение производительности
import time

start_time = time.time()
slow_result = slow_calculation(df.copy())
slow_time = time.time() – start_time

start_time = time.time()
fast_result = fast_calculation(df.copy())
fast_time = time.time() – start_time

print(f"Время выполнения циклом: {slow_time:.6f} с")
print(f"Время выполнения векторизации: {fast_time:.6f} с")
print(f"Ускорение: {slow_time/fast_time:.1f}x")

# Обработка большого CSV-файла чанками
chunks = []
for chunk in pd.read_csv('large_file.csv', chunksize=10000):
# Выполняем операции над каждым чанком
processed_chunk = process_function(chunk)
chunks.append(processed_chunk)

# Объединяем результаты
result_df = pd.concat(chunks, ignore_index=True)

sales_data = {
'store1': {
'jan': {'electronics': 10000, 'clothing': 5000, 'food': 7000},
'feb': {'electronics': 11000, 'clothing': 4500, 'food': 7200},
'mar': {'electronics': 9500, 'clothing': 5500, 'food': 6800}
},
'store2': {
'jan': {'electronics': 8000, 'clothing': 6000, 'food': 9000},
'feb': {'electronics': 8500, 'clothing': 5800, 'food': 9200},
'mar': {'electronics': 9000, 'clothing': 6200, 'food': 9500}
}
}

# Решение: преобразование данных в плоскую структуру
flat_data = []
for store, months in sales_data.items():
for month, categories in months.items():
for category, sales in categories.items():
flat_data.append({
'store': store,
'month': month,
'category': category,
'sales': sales
})

sales_df = pd.DataFrame(flat_data)
print(sales_df)

# Анализ: общие продажи по магазинам
total_by_store = sales_df.groupby('store')['sales'].sum()
print("\nОбщие продажи по магазинам:")
print(total_by_store)

# Анализ: тренды по категориям
pivot_table = sales_df.pivot_table(
index='month', 
columns='category', 
values='sales', 
aggfunc='sum'
)
print("\nТренды продаж по категориям:")
print(pivot_table)

survey_data = {
'resp1': {
'age': 25,
'income': 50000,
'satisfaction': 4,
'comments': "Good service"
},
'resp2': {
'age': 30,
'satisfaction': 5,
'recommend': True
},
'resp3': {
'age': 45,
'income': 70000,
'satisfaction': 3,
'recommend': False,
'comments': "Too expensive"
}
}

# Решение: создание DataFrame с обработкой отсутствующих значений
survey_df = pd.DataFrame.from_dict(survey_data, orient='index')
print(survey_df)

# Заполнение отсутствующих данных
survey_df['recommend'] = survey_df['recommend'].fillna(False)
survey_df['income'] = survey_df['income'].fillna(survey_df['income'].mean())
print("\nПосле обработки отсутствующих данных:")
print(survey_df)

# Анализ: корреляция между уровнем дохода и удовлетворенностью
correlation = survey_df['income'].corr(survey_df['satisfaction'])
print(f"\nКорреляция между доходом и удовлетворенностью: {correlation:.2f}")

import datetime

events_log = [
{'timestamp': '2023-01-01 10:15:30', 'type': 'login', 'user_id': 1, 'status': 'success'},
{'timestamp': '2023-01-01 10:17:20', 'type': 'purchase', 'user_id': 1, 'amount': 150, 'status': 'completed'},
{'timestamp': '2023-01-01 10:45:00', 'type': 'login', 'user_id': 2, 'status': 'failed'},
{'timestamp': '2023-01-01 10:46:30', 'type': 'login', 'user_id': 2, 'status': 'success'},
{'timestamp': '2023-01-01 11:05:15', 'type': 'purchase', 'user_id': 2, 'amount': 75, 'status': 'completed'},
{'timestamp': '2023-01-01 12:30:45', 'type': 'login', 'user_id': 3, 'status': 'success'},
{'timestamp': '2023-01-01 12:37:10', 'type': 'purchase', 'user_id': 3, 'amount': 200, 'status': 'failed'},
{'timestamp': '2023-01-01 12:40:30', 'type': 'purchase', 'user_id': 3, 'amount': 200, 'status': 'completed'}
]

# Решение: преобразование и анализ временных данных
events_df = pd.DataFrame(events_log)

# Преобразование строк в datetime
events_df['timestamp'] = pd.to_datetime(events_df['timestamp'])

# Установка временной метки в качестве индекса
events_df.set_index('timestamp', inplace=True)

# Анализ: количество событий по часам
hourly_events = events_df.resample('H').size()
print("Количество событий по часам:")
print(hourly_events)

# Анализ: статистика покупок
purchases = events_df[events_df['type'] == 'purchase']
successful_purchases = purchases[purchases['status'] == 'completed']

print("\nСтатистика успешных покупок:")
print(f"Общая сумма: {successful_purchases['amount'].sum()}")
print(f"Средняя сумма: {successful_purchases['amount'].mean():.2f}")
print(f"Максимальная сумма: {successful_purchases['amount'].max()}")

product_data = {
'product1': {
'name': 'Smartphone X',
'price': 999,
'category': {
'main': 'Electronics',
'sub': 'Smartphones'
},
'attributes': ['5G', 'Water Resistant', '128GB']
},
'product2': {
'name': 'Laptop Pro',
'price': 1599,
'category': {
'main': 'Electronics',
'sub': 'Computers',
'specific': 'Laptops'
},
'attributes': ['16GB RAM', 'SSD', 'Touch Screen']
},
'product3': {
'name': 'Cotton T-shirt',
'price': 25,
'category': {
'main': 'Clothing',
'sub': 'T-shirts'
},
'attributes': ['Cotton', 'White', 'Medium']
}
}

# Решение: обработка вложенных структур и списков атрибутов
products_list = []

for product_id, data in product_data.items():
product_info = {'id': product_id, 'name': data['name'], 'price': data['price']}

# Обработка вложенной категории
for cat_level, cat_value in data['category'].items():
product_info[f'category_{cat_level}'] = cat_value

# Преобразование списка атрибутов в строку
product_info['attributes'] = ', '.join(data['attributes'])

products_list.append(product_info)

products_df = pd.DataFrame(products_list)
print(products_df)

# Создание бинарных индикаторов для атрибутов
all_attributes = set()
for attrs in product_data.values():
all_attributes.update(attrs['attributes'])

for attr in all_attributes:
products_df[f'has_{attr.replace(" ", "_")}'] = products_df['attributes'].str.contains(attr)

print("\nDataFrame с индикаторами атрибутов:")
print(products_df[['name'] + [col for col in products_df.columns if 'has_' in col]])