import pandas as pd
from io import StringIO

# Створимо тестові дані для демонстрації
csv_data = StringIO("""date,product,category,price,quantity
2024-11-15,Телефон Samsung Galaxy,Електроніка,12000,5
2024-12-01,Ноутбук Dell,Електроніка,28000,2
2024-12-05,Футболка Nike,Одяг,850,10
2024-11-20,iPhone 15,Електроніка,45000,3
2024-12-10,Навушники Sony,Електроніка,3500,8
2024-11-25,Джинси Levi's,Одяг,2200,4
2024-12-15,Телефон Samsung Galaxy,Електроніка,12000,7""")

df = pd.read_csv(csv_data, parse_dates=["date"])

# Завдання 1: середня ціна в "Електроніці"
average = df[df["category"] == "Електроніка"]["price"].mean()

# Завдання 2: найпопулярніший товар
best_product = df.groupby("product")["quantity"].sum().idxmax()

# Завдання 3: продажі у грудні за допомогою дат
december_sales = (df["date"].dt.month == 12).sum()

print(f"Середня ціна в Електроніці: {average:.2f} грн")
print(f"Лідер продажів: {best_product}")
print(f"Продажів у грудні: {december_sales}")

import numpy as np

# 1. З Python-списку
arr1 = np.array([1, 2, 3, 4, 5])
print("З списку:", arr1)
print("Тип:", type(arr1))

# 2. Масив нулів
zeros = np.zeros(5)
print("Нулів:", zeros)

# 3. Масив одиниць
ones = np.ones(5)
print("Одиниць:", ones)

# 4. Послідовність (аналог range)
seq = np.arange(0, 10, 2)
print("Послідовність:", seq)

# 5. Рівномірно розподілені
lin = np.linspace(0, 1, 5)
print("Лінійні:", lin)

import numpy as np

arr = np.array([[1, 2, 3],
                [4, 5, 6]], dtype=np.int64)

print(f"shape (форма):       {arr.shape}")
print(f"ndim (вимірність):   {arr.ndim}")
print(f"size (елементів):    {arr.size}")
print(f"dtype (тип даних):   {arr.dtype}")
print(f"itemsize (байт/ел):  {arr.itemsize}")
print(f"strides (кроки Б):   {arr.strides}")

import numpy as np

arr = np.array([1, 2, 3, 4, 5])

# Операції зі скалярами — застосовуються до КОЖНОГО елемента
print("arr + 10:", arr + 10)
print("arr * 2: ", arr * 2)
print("arr ** 2:", arr ** 2)
print("arr > 3: ", arr > 3)

# Поелементні операції (добуток Адамара)
a = np.array([1, 2, 3])
b = np.array([10, 20, 30])
print("a + b (поелементно):", a + b)
print("a * b (поелементно):", a * b)

# Матричне множення (Dot Product / Matrix Multiplication)
A = np.array([[1, 2],
              [3, 4]])
B = np.array([[5, 6],
              [7, 8]])

# Оператор @ або np.matmul (рядки на стовпці)
print("\nМатричне множення A @ B:\n", A @ B)

import time
import numpy as np

# Зі списком Python
python_list = list(range(1_000_000))
start = time.time()
python_result = [x * 2 for x in python_list]
python_time = time.time() - start

print(f"Python list: {python_time:.3f}с")

# З NumPy масивом
numpy_arr = np.arange(1_000_000)
start = time.time()
numpy_result = numpy_arr * 2
numpy_time = time.time() - start

print(f"NumPy array: {numpy_time:.3f}с")

# Висновок
print(f"🚀 NumPy швидше у {python_time/numpy_time:.0f} разів!")

import numpy as np

arr = np.array([10, 20, 30, 40, 50])

print("Перший елемент:", arr[0])
print("Останній:", arr[-1])
print("Зріз [1:4]:", arr[1:4])
print("Кожен другий:", arr[::2])

# 2D масив (матриця)
matrix = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9]])

print("Елемент [1, 2]:", matrix[1, 2])
print("Весь стовпець 1:", matrix[:, 1])
print("Весь рядок 0:", matrix[0, :])
print("Підматриця [1:, 1:]:\n", matrix[1:, 1:])

import numpy as np

original = np.array([10, 20, 30, 40, 50])

# Зріз створює VIEW
view_slice = original[1:4]
print("До зміни view_slice:", view_slice)

# Змінюємо перший елемент зрізу
view_slice[0] = 999

# Оригінальний масив теж змінився!
print("Після зміни original:", original)
print("view_slice ділить пам'ять з original?", np.shares_memory(original, view_slice))
print("view_slice.base is original?", view_slice.base is original)

# Щоб захистити оригінальні дані — створюйте явну копію .copy()
safe_copy = original[1:4].copy()
safe_copy[0] = 777

print("Після зміни safe_copy original не змінився:", original)
print("safe_copy ділить пам'ять з original?", np.shares_memory(original, safe_copy))

import numpy as np

scores = np.array([85, 42, 91, 67, 78, 55, 96, 33])

# Створюємо булеву маску
mask = scores > 70
print("Маска:", mask)

# Застосовуємо маску для фільтрації
good_scores = scores[scores > 70]
print("Хороші оцінки:", good_scores)

# Декілька умов: ОБОВ'ЯЗКОВО в круглих дужках з операторами &, |
middle_scores = scores[(scores >= 50) & (scores <= 85)]
print("Оцінки від 50 до 85:", middle_scores)

# Статистика відфільтрованих даних
print(f"Хороших оцінок: {len(good_scores)}")
print(f"Середня серед хороших: {good_scores.mean():.1f}")

import numpy as np

# Матриця ознак 4 зразки x 3 характеристики
X = np.array([[10.0, 200.0, 1.5],
              [12.0, 210.0, 1.8],
              [14.0, 190.0, 1.4],
              [16.0, 240.0, 2.1]])

# Обчислюємо середнє для кожного стовпця (форма: (3,))
mean_vector = X.mean(axis=0)
print("Форма X:           ", X.shape)
print("Форма mean_vector: ", mean_vector.shape)
print("Середні стовпців:  ", mean_vector)

# Віднімання завдяки Broadcasting: (4, 3) - (3,) -> (4, 3)
X_centered = X - mean_vector
print("\nЦентровані ознаки:\n", X_centered.round(2))

import numpy as np

data = np.array([23, 45, 12, 67, 89, 34, 56, 78, 90, 11])

print(f"Сума:             {data.sum()}")
print(f"Середнє:          {data.mean():.1f}")
print(f"Мінімум:          {data.min()}")
print(f"Максимум:         {data.max()}")
print(f"Стд. відхилення:  {data.std():.1f}")
print(f"Індекс мінімуму:  {data.argmin()}")
print(f"Індекс максимуму: {data.argmax()}")

import numpy as np

matrix = np.array([[1, 2, 3],
                   [4, 5, 6]])

print("Сума всіх елементів:", matrix.sum())
print("Сума по стовпцях (axis=0):", matrix.sum(axis=0))
print("Сума по рядках (axis=1):", matrix.sum(axis=1))

import numpy as np

arr = np.arange(12)
print("Одновимірний:", arr)

# reshape створює нове view з іншими strides, якщо пам'ять неперервна
matrix = arr.reshape(3, 4)
print("\nМатриця 3×4:\n", matrix)

flat = matrix.flatten()
print("\nЗнову 1D (копія):", flat)

import numpy as np

# Створюємо генератор із фіксованим seed
rng = np.random.default_rng(seed=42)

# Рівномірний розподіл [0.0, 1.0)
random_floats = rng.random(5)
print("Випадкові [0, 1):", random_floats.round(3))

# Випадкові цілі числа від 1 до 100
random_ints = rng.integers(1, 100, size=5)
print("Випадкові цілі:", random_ints)

# Стандартний нормальний розподіл (μ=0, σ=1)
normal_dist = rng.standard_normal(5)
print("Нормальний розподіл:", normal_dist.round(3))

# Вибірка з повторенням і без
items = np.array(["CPU", "GPU", "RAM", "SSD"])
choice_sample = rng.choice(items, size=3, replace=False)
print("Вибір без повернення:", choice_sample)

import pandas as pd

# Найпростіший Series: зі списку Python
temperatures = pd.Series([22, 25, 19, 27, 23])
temperatures

import pandas as pd

# Series з іменованим індексом
grades = pd.Series(
    [85, 92, 78, 96, 71],
    index=["Іван", "Олена", "Петро", "Марія", "Андрій"]
)

grades

import pandas as pd

grades = pd.Series(
    [85, 92, 78, 96, 71],
    index=["Іван", "Олена", "Петро", "Марія", "Андрій"]
)

print("Оцінка Олени:", grades["Олена"])
print("За позицією 1:", grades.iloc[1])
print("Перші три:\n", grades.iloc[0:3])

import pandas as pd

grades = pd.Series(
    [85, 92, 78, 96, 71],
    index=["Іван", "Олена", "Петро", "Марія", "Андрій"]
)

# Додати 5 балів всім
print("Додати 5 балів всім:")
print(grades + 5)

# Відбір за умовою
print("Хто має оцінку > 80:")
excellent = grades[grades > 80]
print(excellent)

# Агрегатні функції
print(f"Середня оцінка: {grades.mean():.1f}")
print(f"Найвища: {grades.max()}")
print(f"Найнижча: {grades.min()}")

import pandas as pd

# Словник автоматично перетворюється на Series
city_populations = pd.Series({
    "Київ":    2952301,
    "Харків":  1421125,
    "Одеса":   1015826,
    "Дніпро":   980775
})

city_populations.sort_values(ascending=False)

import pandas as pd

data = {
    "Ім'я":        ["Іван",  "Олена", "Петро", "Марія"],
    "Вік":         [20,      22,      21,      23],
    "Математика":  [85,      92,      78,      96],
    "Фізика":      [78,      88,      82,      91],
    "Python":      [91,      95,      73,      89]
}

df = pd.DataFrame(data)
df

# Перевіримо структуру
print(f"Розмір: {df.shape} (рядків × стовпців)")
print(f"Стовпці: {list(df.columns)}")
print(f"Типи даних:\n{df.dtypes}")

import pandas as pd

data = {
    "Ім'я": ["Іван", "Олена", "Петро", "Марія"],
    "Вік": [20, 22, 21, 23],
    "Математика": [85, 92, 78, 96]
}
df = pd.DataFrame(data)

# Один стовпець → Series
ages = df["Вік"]
print("Тип:", type(ages))
print(ages)

import pandas as pd

data = {
    "Ім'я": ["Іван", "Олена", "Петро", "Марія"],
    "Вік": [20, 22, 21, 23],
    "Математика": [85, 92, 78, 96]
}
df = pd.DataFrame(data)

# iloc = integer location (позиція, як у списку)
first_row = df.iloc[0]
print("Перший рядок:\n", first_row)

print("\nКонкретна комірка [1, 2]:", df.iloc[1, 2])

import pandas as pd

data = {
    "Ім'я": ["Іван", "Олена", "Петро", "Марія"],
    "Вік": [20, 22, 21, 23],
    "Математика": [85, 92, 78, 96],
    "Python": [82, 95, 88, 91]
}
df = pd.DataFrame(data)

# 1. iloc: перші 2 рядки (0, 1) та перші 3 стовпці (0, 1, 2)
print("--- df.iloc[0:2, 0:3] (права межа виключається) ---")
print(df.iloc[0:2, 0:3])

# 2. loc: рядки від 0 до 2 (0, 1, 2!) та вибрані назви стовпців
print("\n--- df.loc[0:2, ['Ім\\'я', 'Python']] (обидві межі включаються) ---")
print(df.loc[0:2, ["Ім'я", "Python"]])

import pandas as pd

data = {
    "Ім'я": ["Іван", "Олена", "Петро", "Марія"],
    "Вік": [20, 22, 21, 23],
    "Математика": [85, 92, 78, 96],
    "Python": [82, 95, 88, 91]
}
df = pd.DataFrame(data)

# Студенти, яким більше 21 року
older = df[df["Вік"] > 21]
print("Старші за 21:\n", older[["Ім'я", "Вік"]])

# Кілька умов: обов'язково (& = AND, | = OR) у круглих дужках
top_students = df[(df["Математика"] > 85) & (df["Python"] > 85)]
print("Топ-студенти:\n", top_students[["Ім'я", "Математика", "Python"]])

import pandas as pd

data = {
    "Ім'я": ["Іван", "Олена", "Петро", "Марія"],
    "Математика": [85, 92, 78, 96],
    "Фізика": [80, 88, 75, 90],
    "Python": [89, 95, 80, 90]
}
df = pd.DataFrame(data)

# Обчислити середню оцінку кожного студента
df["Середня"] = df[["Математика", "Фізика", "Python"]].mean(axis=1)

df[["Ім'я", "Середня"]]

import pandas as pd

data = {
    "Ім'я": ["Іван", "Олена", "Петро", "Марія"],
    "Математика": [85, 92, 78, 96],
    "Фізика": [80, 88, 75, 90],
    "Python": [89, 95, 80, 90]
}
df = pd.DataFrame(data)
df["Середня"] = df[["Математика", "Фізика", "Python"]].mean(axis=1)

# Відсортувати за середньою оцінкою (від найвищої)
df_sorted = df.sort_values("Середня", ascending=False)

df_sorted[["Ім'я", "Середня"]]

import pandas as pd

# Таблиця 1: Замовлення
orders = pd.DataFrame({
    "order_id": [101, 102, 103, 104],
    "user_id":  [1, 2, 1, 5],
    "amount":   [1200, 3400, 450, 890]
})

# Таблиця 2: Користувачі
users = pd.DataFrame({
    "user_id": [1, 2, 3],
    "name":    ["Іван", "Олена", "Петро"],
    "city":    ["Київ", "Львів", "Одеса"]
})

# Внутрішнє об'єднання (INNER JOIN) — лише ті, хто є в обох таблицях
merged_inner = pd.merge(orders, users, on="user_id", how="inner")
print("--- INNER JOIN ---")
print(merged_inner)

# Ліве об'єднання (LEFT JOIN) — зберігає ВСІ замовлення
merged_left = pd.merge(orders, users, on="user_id", how="left")
print("\n--- LEFT JOIN (зверніть увагу на NaN для user_id=5) ---")
print(merged_left)

import pandas as pd

q1_sales = pd.DataFrame({"місяць": ["Січень", "Лютий"], "виторг": [100000, 120000]})
q2_sales = pd.DataFrame({"місяць": ["Березень", "Квітень"], "виторг": [115000, 140000]})

# Склеюємо по вертикалі з оновленням індексів (ignore_index=True)
half_year = pd.concat([q1_sales, q2_sales], ignore_index=True)
print("Піврічний звіт:\n", half_year)

import pandas as pd

df = pd.read_csv("sales_data.csv")
df.info()

import pandas as pd

df = pd.read_csv("sales_data.csv")
df.describe()

# Для текстових стовпців окремо
print("Статистика категорій:")
print(df["category"].value_counts().head(3))

import pandas as pd
import numpy as np

# Створимо тестовий DataFrame з пропусками
data = {
    "order_id": range(1, 11),
    "date": pd.date_range("2024-01-01", periods=10),
    "product": ["Товар" + str(i) for i in range(1, 11)],
    "category": ["Електроніка", "Одяг", None, "Електроніка", None, "Одяг", "Електроніка", None, "Одяг", "Електроніка"],
    "price": [1000 + i*100 for i in range(10)],
    "quantity": [5, None, 3, 4, None, 2, 6, 1, None, 4]
}
df = pd.DataFrame(data)

# Кількість пропусків у кожному стовпці
print("Пропуски:")
print(df.isnull().sum())

print("\nВідсоток пропусків:")
print((df.isnull().sum() / len(df) * 100).round(2))

import pandas as pd

# Створимо тестові дані продажів
data = {
    "product": ["Телефон", "Ноутбук", "Футболка", "Телефон", "Книга", "Ноутбук", "Футболка", "Телефон"],
    "category": ["Електроніка", "Електроніка", "Одяг", "Електроніка", "Книги", "Електроніка", "Одяг", "Електроніка"]
}
df = pd.DataFrame(data)

# Підрахунок частоти категорій
df["category"].value_counts()

import pandas as pd

# Створимо датасет продажів
data = {
    "city": ["Київ", "Харків", "Київ", "Харків", "Одеса", "Київ", "Одеса", "Львів"],
    "product": ["Телефон", "Ноутбук", "Футболка", "Телефон", "Ноутбук", "Книга", "Телефон", "Футболка"],
    "price": [12000, 28000, 450, 11500, 27000, 320, 12500, 480]
}
df = pd.DataFrame(data)

# Середня ціна товарів у кожному місті
df.groupby("city")["price"].mean()

import pandas as pd

# Датасет студентів
students = pd.DataFrame({
    "Ім'я": ["Іван", "Олена", "Петро", "Марія", "Андрій", "Софія"],
    "Курс": [2, 3, 2, 4, 3, 2],
    "Оцінка": [85, 92, 78, 96, 88, 91]
})

students

# Середня оцінка по курсах
avg_by_course = students.groupby("Курс")["Оцінка"].mean()
avg_by_course

# Кількість студентів на кожному курсі
print("Студентів на курсі:")
print(students.groupby("Курс").size())

print("\n📊 Висновок: найкраща середня оцінка на 4 курсі!")

import pandas as pd

data = {
    "city": ["Київ", "Харків", "Київ", "Харків", "Одеса"],
    "price": [12000, 28000, 450, 11500, 27000]
}
df = pd.DataFrame(data)

# Спосіб 1: as_index=False прямо в groupby
df_res1 = df.groupby("city", as_index=False)["price"].mean()
print("--- Спосіб 1 (as_index=False) ---")
print(df_res1)

# Спосіб 2: Іменована агрегація (Named Aggregation) з кастомними назвами колонок
df_res2 = df.groupby("city", as_index=False).agg(
    середня_ціна=("price", "mean"),
    кількість_замовлень=("price", "count")
)
print("\n--- Спосіб 2 (Іменована агрегація) ---")
print(df_res2)

import pandas as pd

data = {
    "city": ["Київ", "Харків", "Київ", "Одеса", "Київ", "Харків", "Львів"],
    "price": [1200, 1500, 1100, 1300, 1250, 1450, 1350]
}
df = pd.DataFrame(data)

# Унікальні міста
print("Унікальні міста:")
print(df["city"].unique())

# Кількість унікальних міст
print(f"\nКількість унікальних міст: {df['city'].nunique()}")