Pandas DataFrame: основы, фильтрация, группировка и объединение таблиц

import pandas as pd
import numpy as np

# Создание из словаря
data = {
'имя': ['Анна', 'Борис', 'Виктория', 'Григорий'],
'возраст': [25, 30, 22, 35],
'город': ['Москва', 'Санкт-Петербург', 'Казань', 'Новосибирск'],
'зарплата': [70000, 85000, 65000, 90000]
}
df = pd.DataFrame(data)

# Создание из списка словарей
data_list = [
{'имя': 'Анна', 'возраст': 25},
{'имя': 'Борис', 'возраст': 30},
{'имя': 'Виктория', 'возраст': 22}
]
df2 = pd.DataFrame(data_list)

# Создание из массива numpy
array = np.random.randn(3, 4) # 3 строки, 4 столбца
df3 = pd.DataFrame(array, columns=['A', 'B', 'C', 'D'])

# Загрузка данных из CSV-файла
df4 = pd.read_csv('data.csv')

# Просмотр первых строк DataFrame
print(df.head())

# Информация о DataFrame
print(df.info())

# Статистика по числовым колонкам
print(df.describe())

# Размерность DataFrame
print(df.shape) # (строки, столбцы)

# Названия столбцов
print(df.columns)

# Типы данных
print(df.dtypes)

# Индексы
print(df.index)

# Создадим тестовый DataFrame
import pandas as pd

data = {
'имя': ['Анна', 'Борис', 'Виктория', 'Григорий', 'Дарья'],
'возраст': [25, 30, 22, 35, 28],
'город': ['Москва', 'Санкт-Петербург', 'Казань', 'Новосибирск', 'Москва'],
'отдел': ['Маркетинг', 'IT', 'Финансы', 'IT', 'Маркетинг'],
'зарплата': [70000, 85000, 65000, 90000, 72000]
}

df = pd.DataFrame(data)
df.set_index('имя', inplace=True) # Устанавливаем столбец 'имя' в качестве индекса

# Выбрать одну строку по метке индекса
print(df.loc['Анна'])

# Выбрать несколько строк
print(df.loc[['Анна', 'Виктория']])

# Выбрать конкретный элемент (строка, столбец)
print(df.loc['Борис', 'возраст'])

# Выбрать строки и столбцы
print(df.loc[['Анна', 'Борис'], ['возраст', 'город']])

# Выбрать диапазон строк
print(df.loc['Анна':'Виктория'])

# Выбрать первую строку
print(df.iloc[0])

# Выбрать несколько строк
print(df.iloc[[0, 2]])

# Выбрать конкретный элемент (строка, столбец)
print(df.iloc[1, 0]) # Элемент во второй строке, первом столбце

# Выбрать диапазон строк и столбцов
print(df.iloc[0:2, 1:3]) # Первые две строки, второй и третий столбцы

# Фильтрация по одному условию
print(df[df['возраст'] > 25])

# Фильтрация по нескольким условиям
print(df[(df['возраст'] > 25) & (df['город'] == 'Москва')])

# Фильтрация с использованием оператора "или"
print(df[(df['отдел'] == 'IT') | (df['зарплата'] > 75000)])

# Проверка на принадлежность множеству значений
print(df[df['город'].isin(['Москва', 'Санкт-Петербург'])])

# Фильтрация с помощью строковых методов
print(df[df['город'].str.contains('Москва')])

# Простой запрос
print(df.query('возраст > 25'))

# Запрос с несколькими условиями
print(df.query('возраст > 25 and город == "Москва"'))

# Использование переменных в запросе
min_salary = 70000
print(df.query('зарплата >= @min_salary'))

import pandas as pd
import numpy as np

# Создадим тестовый DataFrame
data = {
'имя': ['Анна', 'Борис', 'Виктория', 'Григорий'],
'возраст': [25, 30, 22, 35],
'отдел': ['Маркетинг', 'IT', 'Финансы', 'IT']
}
df = pd.DataFrame(data)

# 1. Добавление столбца с константным значением
df['активный'] = True

# 2. Добавление столбца на основе вычислений из существующих столбцов
df['возраст_через_5_лет'] = df['возраст'] + 5

# 3. Добавление столбца с использованием списка/массива
df['стаж'] = [3, 7, 1, 10]

# 4. Добавление столбца с использованием функции apply
df['категория'] = df['возраст'].apply(lambda x: 'Молодой' if x < 25 else 'Опытный')

# 5. Добавление столбца на основе условий
df['зарплатная_категория'] = np.where(df['отдел'] == 'IT', 'Высокая', 'Средняя')

# 6. Добавление нескольких столбцов одновременно
df[['бонус_1', 'бонус_2']] = pd.DataFrame([[1000, 500], [1500, 700], [800, 300], [2000, 1000]])

# 7. Переименование столбцов
df = df.rename(columns={'возраст': 'полных_лет'})

# 8. Изменение порядка столбцов
df = df[['имя', 'полных_лет', 'отдел', 'активный', 'стаж', 'категория']]

# Изменение всех значений столбца
df['активный'] = False

# Изменение только определенных значений с использованием маски
df.loc[df['полных_лет'] > 30, 'активный'] = True

# Применение функции к столбцу для трансформации всех значений
df['имя'] = df['имя'].str.upper()

# Изменение типа данных столбца
df['стаж'] = df['стаж'].astype(float)

# Замена значений
df['отдел'] = df['отдел'].replace('Маркетинг', 'Реклама')

# 1. Добавление строки с помощью метода loc
df.loc[len(df)] = ['ЕЛЕНА', 27, 'HR', True, 4, 'Опытный']

# 2. Добавление строки с помощью concat
новая_строка = pd.DataFrame([['МИХАИЛ', 40, 'Руководство', False, 15, 'Опытный']], 
columns=df.columns)
df = pd.concat([df, новая_строка], ignore_index=True)

# 3. Добавление строк из другого DataFrame
другой_df = pd.DataFrame([
['ОЛЬГА', 23, 'Финансы', True, 2, 'Молодой'],
['ПАВЕЛ', 31, 'IT', True, 8, 'Опытный']
], columns=df.columns)
df = pd.concat([df, другой_df], ignore_index=True)

# 4. Изменение существующей строки
df.iloc[0] = ['АННА (изменено)', 26, 'Реклама', False, 3.5, 'Опытный']

# 5. Изменение конкретных значений в строке
df.loc[1, ['активный', 'стаж']] = [True, 7.5]

# Удаление столбца
df = df.drop('бонус_1', axis=1) # axis=1 указывает на столбец
# Или альтернативный способ
df.drop('бонус_2', axis=1, inplace=True) # inplace=True для изменения исходного DataFrame

# Удаление нескольких столбцов
df = df.drop(['зарплатная_категория', 'возраст_через_5_лет'], axis=1)

# Удаление строки по индексу
df = df.drop(0) # Удаление первой строки
# Или с использованием inplace
df.drop(1, inplace=True) # Удаление второй строки

# Удаление строк по условию
df = df[~(df['полных_лет'] > 30)] # Удаление строк, где возраст больше 30
# или
df = df.drop(df[df['полных_лет'] > 30].index)

import pandas as pd
import numpy as np

# Создаем пример DataFrame с данными о продажах
data = {
'дата': pd.date_range(start='2023-01-01', periods=20),
'продукт': ['A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A',
'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A', 'B'],
'регион': ['Восток', 'Запад', 'Восток', 'Запад', 'Восток', 'Запад', 'Восток', 'Запад', 'Восток', 'Запад',
'Восток', 'Запад', 'Восток', 'Запад', 'Восток', 'Запад', 'Восток', 'Запад', 'Восток', 'Запад'],
'менеджер': ['Иванов', 'Петров', 'Сидоров', 'Иванов', 'Петров', 'Сидоров', 'Петров', 'Иванов', 'Сидоров', 'Петров',
'Иванов', 'Сидоров', 'Петров', 'Иванов', 'Сидоров', 'Петров', 'Иванов', 'Сидоров', 'Петров', 'Иванов'],
'продажи': [100, 150, 200, 120, 160, 210, 90, 140, 180, 110,
130, 190, 105, 155, 205, 115, 165, 215, 95, 145],
'расходы': [80, 100, 120, 85, 105, 125, 75, 95, 115, 82,
90, 110, 83, 103, 123, 87, 107, 127, 78, 98]
}

df = pd.DataFrame(data)
df['прибыль'] = df['продажи'] – df['расходы']

# Группировка по одному столбцу
by_product = df.groupby('продукт')

# Получение статистики по группам
print(by_product['продажи'].mean()) # Средние продажи по продуктам
print(by_product['продажи'].sum()) # Сумма продаж по продуктам
print(by_product.size()) # Количество записей в каждой группе

# Группировка по нескольким столбцам
by_product_region = df.groupby(['продукт', 'регион'])
print(by_product_region['продажи'].sum())

# Использование метода agg() для применения нескольких функций
agg_result = df.groupby('продукт').agg({
'продажи': ['sum', 'mean', 'max', 'min', 'count'],
'прибыль': ['sum', 'mean', 'max', 'min']
})
print(agg_result)

# Применение пользовательской функции
def profit_margin(x):
return (x['прибыль'].sum() / x['продажи'].sum()) * 100

margins = df.groupby('продукт').apply(profit_margin)
print(margins)

# Использование именованных агрегаций (pandas >= 0.25)
named_agg = df.groupby('продукт').agg(
total_sales=('продажи', 'sum'),
avg_sales=('продажи', 'mean'),
total_profit=('прибыль', 'sum'),
profit_margin=('прибыль', lambda x: (x.sum() / df.loc[x.index, 'продажи'].sum()) * 100)
)
print(named_agg)

# Фильтрация групп на основе условия
filtered = df.groupby('продукт').filter(lambda x: x['продажи'].mean() > 120)
print(filtered)

# Трансформация данных с сохранением структуры исходного DataFrame
df['продажи_нормализованные'] = df.groupby('продукт')['продажи'].transform(
lambda x: (x – x.mean()) / x.std()
)
print(df[['продукт', 'продажи', 'продажи_нормализованные']])

# Оконные функции: накопительная сумма по группам
df['накопительные_продажи'] = df.sort_values('дата').groupby('продукт')['продажи'].cumsum()
print(df[['дата', 'продукт', 'продажи', 'накопительные_продажи']])

# Сдвиг данных внутри групп (лаги)
df['предыдущие_продажи'] = df.sort_values('дата').groupby('продукт')['продажи'].shift(1)
print(df[['дата', 'продукт', 'продажи', 'предыдущие_продажи']])

# Ранжирование внутри групп
df['ранг_по_продажам'] = df.groupby('продукт')['продажи'].rank(method='dense', ascending=False)
print(df[['продукт', 'продажи', 'ранг_по_продажам']])

import pandas as pd
import numpy as np

# Создаем два DataFrame для демонстрации
df1 = pd.DataFrame({
'ID': [1, 2, 3, 4],
'Name': ['Алексей', 'Мария', 'Иван', 'Елена'],
'Department': ['IT', 'HR', 'Finance', 'Marketing']
})

df2 = pd.DataFrame({
'ID': [5, 6, 7, 8],
'Name': ['Анна', 'Сергей', 'Дмитрий', 'Ольга'],
'Department': ['IT', 'Sales', 'IT', 'HR']
})

# Вертикальное объединение (по строкам)
result_rows = pd.concat([df1, df2])
print("Вертикальное объединение:")
print(result_rows)

# Вертикальное объединение с сбросом индекса
result_reset = pd.concat([df1, df2], ignore_index=True)
print("\nВертикальное объединение с новым индексом:")
print(result_reset)

# Создаем DataFrame с разными столбцами
df3 = pd.DataFrame({
'ID': [1, 2, 3, 4],
'Name': ['Алексей', 'Мария', 'Иван', 'Елена'],
'Salary': [70000, 65000, 80000, 75000]
})

df4 = pd.DataFrame({
'ID': [1, 2, 3, 4],
'Bonus': [10000, 5000, 15000, 7000],
'Experience': [5, 3, 7, 4]
})

# Горизонтальное объединение (по столбцам)
result_cols = pd.concat([df3, df4], axis=1)
print("\nГоризонтальное объединение:")
print(result_cols)

# Объединение с обработкой дубликатов столбцов
df5 = pd.DataFrame({
'ID': [1, 2, 3, 4],
'Name': ['А', 'Б', 'В', 'Г']
})

df6 = pd.DataFrame({
'ID': [3, 4, 5, 6],
'Name': ['В2', 'Г2', 'Д', 'Е']
})

# Объединение с проверкой совпадения индексов
result_outer = pd.concat([df5, df6], join='outer') # Включает все строки (значение по умолчанию)
print("\nОбъединение outer:")
print(result_outer)

result_inner = pd.concat([df5, df6], join='inner') # Только строки, присутствующие в обоих DataFrame
print("\nОбъединение inner:")
print(result_inner)

# Создаем DataFrame с информацией о сотрудниках
employees = pd.DataFrame({
'employee_id': [1, 2, 3, 4, 5],
'name': ['Алексей', 'Мария', 'Иван', 'Елена', 'Дмитрий'],
'department_id': [101, 102, 101, 103, 102]
})

# Создаем DataFrame с информацией об отделах
departments = pd.DataFrame({
'department_id': [101, 102, 103, 104],
'department_name': ['IT', 'HR', 'Finance', 'Marketing'],
'location': ['Москва', 'Москва', 'Санкт-Петербург', 'Казань']
})

# Создаем DataFrame с зарплатами
salaries = pd.DataFrame({
'employee_id': [1, 2, 3, 5, 6],
'salary': [70000, 65000, 80000, 75000, 90000]
})

# Внутреннее объединение (inner join)
inner_merge = pd.merge(employees, departments, on='department_id')
print("Inner merge (сотрудники и отделы):")
print(inner_merge)

# Левое объединение (left join)
left_merge = pd.merge(employees, salaries, on='employee_id', how='left')
print("\nLeft merge (все сотрудники и их зарплаты, если есть):")
print(left_merge)

# Правое объединение (right join)
right_merge = pd.merge(employees, salaries, on='employee_id', how='right')
print("\nRight merge (все записи о зарплатах и сотрудники к ним):")
print(right_merge)

# Полное объединение (outer join)
outer_merge = pd.merge(employees, salaries, on='employee_id', how='outer')
print("\nOuter merge (все записи из обоих DataFrame):")
print(outer_merge)

# Объединение по разным именам столбцов
employees_alt = employees.rename(columns={'employee_id': 'emp_id'})
merge_diff_cols = pd.merge(
employees_alt, salaries,
left_on='emp_id', right_on='employee_id'
)
print("\nОбъединение по разным именам столбцов:")
print(merge_diff_cols)

# Объединение по нескольким столбцам
df7 = pd.DataFrame({
'key1': ['A', 'B', 'C', 'D'],
'key2': [1, 2, 3, 4],
'value1': [100, 200, 300, 400]
})

df8 = pd.DataFrame({
'key1': ['A', 'B', 'C', 'E'],
'key2': [1, 2, 3, 5],
'value2': [10, 20, 30, 50]
})

merge_multi_cols = pd.merge(df7, df8, on=['key1', 'key2'])
print("\nОбъединение по нескольким столбцам:")
print(merge_multi_cols)

# Создаем DataFrame с индексами
df9 = pd.DataFrame({
'A': [1, 2, 3, 4],
'B': ['a', 'b', 'c', 'd']
}, index=['I1', 'I2', 'I3', 'I4'])

df10 = pd.DataFrame({
'C': [5, 6, 7, 8],
'D': ['e', 'f', 'g', 'h']
}, index=['I1', 'I2', 'I3', 'I5'])

# Объединение по индексу
join_result = df9.join(df10)
print("Объединение по индексу (left join по умолчанию):")
print(join_result)

# Объединение с указанием типа объединения
join_inner = df9.join(df10, how='inner')
print("\nВнутреннее объединение по индексу:")
print(join_inner)

# Объединение нескольких DataFrame
df11 = pd.DataFrame({
'E': [9, 10, 11, 12],
'F': ['i', 'j', 'k', 'l']
}, index=['I1', 'I2', 'I6', 'I7'])

join_multiple = df9.join([df10, df11], how='outer')
print("\nОбъединение трех DataFrame:")
print(join_multiple)