Python синтаксис для анализа данных: от основ к продвинутым техникам

age = 30 # целое число
height = 1.75 # число с плавающей точкой
name = "Alice" # строка
is_analyst = True # булево значение

x = 5 + 3 # 8
y = 10 / 2 # 5.0 (деление всегда возвращает float)
z = 7 // 2 # 3 (целочисленное деление)
power = 2 ** 3 # 8 (возведение в степень)

# Этот скрипт анализирует данные о продажах
sales_growth = (current_sales – previous_sales) / previous_sales * 100 # Рост продаж в процентах

simple_text = 'Анализ данных с Python'
query = """
SELECT product, SUM(revenue) as total_revenue
FROM sales
GROUP BY product
ORDER BY total_revenue DESC
"""

# Фильтрация данных по нескольким условиям
high_value_customers = df[(df['purchase_amount'] > 1000) & (df['frequency'] > 5)]

first_char = text[0] # Первый символ
last_three = values[-3:] # Последние три элемента
every_second = measurements[::2] # Каждый второй элемент

# Классификация клиентов по объему покупок
if purchase_amount > 10000:
customer_segment = "Premium"
elif purchase_amount > 5000:
customer_segment = "Gold"
elif purchase_amount > 1000:
customer_segment = "Silver"
else:
customer_segment = "Regular"

# Расчет суммы всех значений
total = 0
for value in dataset:
total += value

# Итерация по индексам и значениям
for i, value in enumerate(dataset):
if value > threshold:
outliers.append(i)

# Итеративный алгоритм сходимости
epsilon = 0.001
difference = float('inf')
while difference > epsilon:
new_value = calculate_next_value(current_value)
difference = abs(new_value – current_value)
current_value = new_value

# Поиск первого элемента, удовлетворяющего условию
for item in dataset:
if meets_criteria(item):
result = item
break # Прекращает выполнение цикла

# Пропуск отрицательных значений
for value in measurements:
if value < 0:
continue # Переходит к следующей итерации
processed_data.append(transform(value))

# Преобразование всех значений
squared = [x**2 for x in numbers]

# Фильтрация с преобразованием
positive_squared = [x**2 for x in numbers if x > 0]

# Создание словаря
name_to_age = {person['name']: person['age'] for person in people}

# Замена пропущенных значений
clean_data = [value if value is not None else 0 for value in raw_data]

# Классификация значений
categories = ['High' if x > threshold else 'Low' for x in measurements]

try:
ratio = total_revenue / customer_count
except ZeroDivisionError:
ratio = 0 # Обработка случая отсутствия клиентов
except Exception as e:
log_error(f"Unexpected error: {e}")
ratio = None
finally:
results.append(ratio)

def calculate_growth_rate(current, previous):
"""
Рассчитывает темп роста в процентах.

Args:
current (float): Текущее значение
previous (float): Предыдущее значение

Returns:
float: Темп роста в процентах
"""
if previous == 0:
return None # Невозможно рассчитать рост от нуля
return (current – previous) / previous * 100

def outlier_detection(data, method='z-score', threshold=3):
"""
Обнаруживает выбросы в данных.

Parameters:
-----------
data : array-like
Массив значений для анализа
method : str, default='z-score'
Метод обнаружения: 'z-score', 'iqr', или 'percentile'
threshold : float, default=3
Пороговое значение для определения выбросов

Returns:
--------
outliers : array-like
Индексы выбросов в исходных данных
"""
# Реализация метода

# Функция с значениями по умолчанию
def normalize_data(data, min_val=0, max_val=1):
range_val = max(data) – min(data)
return [
(x – min(data)) / range_val * (max_val – min_val) + min_val for x in data
]

# Вызов функции с разными параметрами
norm_default = normalize_data(raw_data) # Использует значения по умолчанию
norm_custom = normalize_data(raw_data, -1, 1) # Нормализация в диапазоне [-1, 1]
norm_named = normalize_data(raw_data, max_val=10) # Именованный аргумент

# Сортировка данных по вычисляемому критерию
sorted_data = sorted(customer_data, key=lambda x: x['purchases']/x['visits'])

# Применение трансформации к каждому элементу
transformed = map(lambda x: (x – mean) / std_dev, raw_data)

def calculate_statistics(data):
"""Вычисляет базовую статистику для набора данных."""
mean_val = sum(data) / len(data)
min_val = min(data)
max_val = max(data)
return mean_val, min_val, max_val

# Распаковка возвращаемых значений
avg, minimum, maximum = calculate_statistics(measurements)

# Импорт целого модуля
import math
log_value = math.log(100)

# Импорт конкретных функций
from statistics import mean, median, mode
avg = mean(data)

# Импорт с псевдонимом
import numpy as np
array = np.array([1, 2, 3, 4, 5])

# Файл data_cleaning.py
def remove_outliers(data, method='z-score'):
# Реализация
return cleaned_data

def fill_missing_values(data, strategy='mean'):
# Реализация
return complete_data

# Использование в другом файле
from data_cleaning import remove_outliers, fill_missing_values
clean_data = remove_outliers(raw_data)
complete_data = fill_missing_values(clean_data)

# Создание списка
sales_by_quarter = [10000, 15000, 12000, 18000]

# Добавление элемента
sales_by_quarter.append(20000) # [10000, 15000, 12000, 18000, 20000]

# Вставка на определенную позицию
sales_by_quarter.insert(1, 11000) # [10000, 11000, 15000, 12000, 18000, 20000]

# Удаление элемента
sales_by_quarter.remove(11000) # [10000, 15000, 12000, 18000, 20000]

# Сортировка (изменяет исходный список)
sales_by_quarter.sort() # [10000, 12000, 15000, 18000, 20000]
sales_by_quarter.sort(reverse=True) # [20000, 18000, 15000, 12000, 10000]

# Срезы для выборки элементов
first_half = sales_by_quarter[:2] # [20000, 18000]

# Создание кортежа
point = (10, 20)
date_range = ('2023-01-01', '2023-12-31')

# Распаковка кортежа
x, y = point
start_date, end_date = date_range

# Кортеж как ключ словаря (в отличие от списка)
region_quarter_sales = {
('North', 'Q1'): 12000,
('North', 'Q2'): 15000,
('South', 'Q1'): 9000
}

# Создание словаря
customer = {
'id': 1001,
'name': 'John Smith',
'purchases': [120, 350, 290],
'active': True
}

# Доступ к значениям
customer_name = customer['name'] # 'John Smith'

# Безопасный доступ с методом get
purchase_date = customer.get('purchase_date', 'Unknown') # 'Unknown'

# Добавление или изменение элементов
customer['email'] = 'john@example.com'
customer['purchases'].append(150)

# Удаление ключа
del customer['active']

# Проверка наличия ключа
if 'email' in customer:
send_newsletter(customer['email'])

# Создание множества
products_a = {'laptop', 'phone', 'tablet', 'headphones'}
products_b = {'phone', 'smartwatch', 'headphones', 'speaker'}

# Удаление дубликатов из списка
unique_visitors = set(visitor_ids)

# Операции над множествами
common_products = products_a & products_b # {'phone', 'headphones'}
all_products = products_a | products_b # {'laptop', 'phone', 'tablet', 'headphones', 'smartwatch', 'speaker'}
unique_to_a = products_a – products_b # {'laptop', 'tablet'}

# Представление таблицы данных как списка словарей
customers = [
{'id': 1, 'name': 'Alice', 'segments': ['high_value', 'frequent']},
{'id': 2, 'name': 'Bob', 'segments': ['new_customer']},
{'id': 3, 'name': 'Charlie', 'segments': ['dormant', 'high_value']}
]

# Извлечение информации из вложенных структур
high_value_customers = [c['name'] for c in customers if 'high_value' in c['segments']]

# Словарь словарей для быстрого доступа
customers_by_id = {c['id']: c for c in customers}
bob_data = customers_by_id[2] # Быстрый доступ к данным о Bob

import numpy as np

# Создание массивов
arr1 = np.array([1, 2, 3, 4, 5])
arr2 = np.zeros((3, 4)) # Массив 3x4 из нулей
arr3 = np.random.rand(100) # 100 случайных чисел

# Векторизованные операции (без циклов)
result = arr1 * 2 + 10 # [12, 14, 16, 18, 20]

# Агрегатные функции
mean_value = np.mean(arr3)
std_dev = np.std(arr3)
percentile_90 = np.percentile(arr3, 90)

# Индексация и срезы
subset = arr2[0:2, 1:3] # Получение подмассива

# Логическая индексация
outliers = arr3[arr3 > mean_value + 2 * std_dev]

import pandas as pd

# Создание DataFrame из словаря
data = {
'name': ['Alice', 'Bob', 'Charlie', 'David'],
'age': [25, 30, 35, 40],
'salary': [50000, 60000, 75000, 90000],
'department': ['Sales', 'IT', 'Marketing', 'IT']
}
df = pd.DataFrame(data)

# Чтение данных из файла
sales_df = pd.read_csv('sales_data.csv')

# Выбор столбцов
names = df['name'] # Series
subset = df[['name', 'salary']] # DataFrame

# Фильтрация строк
high_earners = df[df['salary'] > 70000]
it_dept = df[df['department'] == 'IT']

# Условное индексирование
df.loc[df['age'] > 30, 'status'] = 'Senior'
df.loc[df['age'] <= 30, 'status'] = 'Junior'

# Групповые операции
avg_by_dept = df.groupby('department')['salary'].mean()

# Объединение датафреймов
merged = pd.merge(df, other_df, on='employee_id')

import matplotlib.pyplot as plt
import seaborn as sns

# Matplotlib — базовый график
plt.figure(figsize=(10, 6))
plt.plot(x_values, y_values, 'b-', label='Trend')
plt.scatter(outlier_x, outlier_y, color='red', label='Outliers')
plt.title('Data Analysis Results')
plt.xlabel('Time')
plt.ylabel('Value')
plt.legend()
plt.grid(True)
plt.savefig('analysis_results.png')
plt.close()

# Seaborn — статистический график с Pandas
plt.figure(figsize=(12, 8))
sns.barplot(x='department', y='salary', data=df)
plt.title('Average Salary by Department')
plt.tight_layout()
plt.show()

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error

# Подготовка данных
X = df[['feature1', 'feature2', 'feature3']]
y = df['target']

# Разделение на обучающую и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Создание и обучение модели
model = LinearRegression()
model.fit(X_train, y_train)

# Прогнозирование и оценка
predictions = model.predict(X_test)
mse = mean_squared_error(y_test, predictions)
coefficients = pd.DataFrame({
'Feature': X.columns,
'Coefficient': model.coef_
})

from scipy import stats
from scipy.optimize import minimize

# Статистические тесты
t_stat, p_value = stats.ttest_ind(group1, group2)
corr, p_corr = stats.pearsonr(x_data, y_data)

# Оптимизация функций
def objective(x):
return x[0]**2 + x[1]**2 + 5

result = minimize(objective, [1, 1], method='BFGS')
optimal_values = result.x

# Полный пайплайн анализа
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler

# 1. Загрузка и подготовка данных
df = pd.read_csv('customer_data.csv')
df.dropna(inplace=True)

# 2. Извлечение и масштабирование признаков
features = df[['annual_income', 'spending_score']]
scaler = StandardScaler()
scaled_features = scaler.fit_transform(features)

# 3. Кластеризация
kmeans = KMeans(n_clusters=5, random_state=42)
df['cluster'] = kmeans.fit_predict(scaled_features)

# 4. Анализ результатов
cluster_centers = scaler.inverse_transform(kmeans.cluster_centers_)
cluster_stats = df.groupby('cluster').agg({
'annual_income': ['mean', 'min', 'max'],
'spending_score': ['mean', 'min', 'max'],
'customer_id': 'count'
})

# 5. Визуализация
plt.figure(figsize=(10, 8))
colors = plt.cm.rainbow(np.linspace(0, 1, 5))

for cluster_id, color in enumerate(colors):
cluster_data = df[df['cluster'] == cluster_id]
plt.scatter(
cluster_data['annual_income'],
cluster_data['spending_score'],
s=50, c=[color],
label=f'Cluster {cluster_id}'
)

plt.scatter(
cluster_centers[:, 0],
cluster_centers[:, 1],
s=200, c='black', marker='X',
label='Centroids'
)

plt.title('Customer Segments')
plt.xlabel('Annual Income')
plt.ylabel('Spending Score')
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('customer_segments.png')