Какой у тебя уровень владения Python?

# Уровень владения Python

Самооценка: Advanced (70-80% от профессионального разработчика)

Я не full-stack разработчик, но для аналитики и data science я использую Python на уровне выше среднего.

Что я могу делать

1. Data Manipulation (Expert level)

pandas:

• Чтение из разных источников (CSV, JSON, SQL, Excel, Parquet)
• Трансформация данных (pivot, melt, groupby, merge, concat)
• Работа с временными рядами (resample, rolling windows)
• Оптимизация памяти (правильные dtype, chunking для больших файлов)

numpy:

• Операции с массивами
• Векторизованные вычисления вместо циклов
• Линейная алгебра (matrix operations)

polars:

• Более быстрая альтернатива pandas для больших данных
• Lazy evaluation и оптимизация запросов

# Пример: сложный анализ в pandas
import pandas as pd
import numpy as np

# ETL процесс
df = pd.read_csv('sales.csv')

# Чистка данных
df['date'] = pd.to_datetime(df['date'])
df = df[df['amount'] > 0]  # Удаляем некорректные значения

# Feature engineering
df['revenue'] = df['quantity'] * df['price']
df['year_month'] = df['date'].dt.to_period('M')
df['days_since_signup'] = (df['date'] - df['signup_date']).dt.days

# Агрегирование с иерархией
summary = df.groupby(['user_id', 'year_month']).agg({
    'revenue': 'sum',
    'quantity': 'count',
    'amount': ['min', 'max', 'mean']
}).reset_index()

# Расчёт когортных метрик
summary['cum_revenue'] = summary.groupby('user_id')['revenue'].cumsum()
summary['revenue_pct_of_total'] = (
    summary.groupby('user_id')['revenue'].transform('sum')
)
summary['pct'] = summary['revenue'] / summary['revenue_pct_of_total']

print(summary)

Это не просто работа с данными — это продуманная архитектура трансформаций.

2. Статистика и анализ (Advanced level)

scipy.stats:

from scipy.stats import ttest_ind, mannwhitneyu, chi2_contingency
from scipy.stats import pearsonr, spearmanr

# T-test для сравнения двух групп
t_stat, p_value = ttest_ind(group_a, group_b)

# Mann-Whitney U test (non-parametric)
statistic, p_value = mannwhitneyu(group_a, group_b)

# Chi-square для категориальных данных
contingency_table = pd.crosstab(df['category'], df['outcome'])
chi2, p_value, dof, expected = chi2_contingency(contingency_table)

# Корреляция
pearson_r, p_value = pearsonr(df['x'], df['y'])
spearman_r, p_value = spearmanr(df['x'], df['y'])

statsmodels:

import statsmodels.api as sm
from statsmodels.formula.api import ols

# Линейная регрессия с интерпретируемыми коэффициентами
model = ols('revenue ~ C(country) + log(user_days) + is_premium', data=df).fit()
print(model.summary())
# Выведет R-squared, p-values для каждого коэффициента, доверительные интервалы

# Интерпретация результатов
print(model.params)  # Коэффициенты
print(model.pvalues)  # P-values
print(model.conf_int())  # Доверительные интервалы

Доверительные интервалы:

from scipy import stats

def calculate_confidence_interval(data, confidence=0.95):
    n = len(data)
    mean = data.mean()
    se = stats.sem(data)  # standard error
    t_critical = stats.t.ppf((1 + confidence) / 2, n - 1)
    
    ci_lower = mean - t_critical * se
    ci_upper = mean + t_critical * se
    
    return ci_lower, mean, ci_upper

ci_lower, mean, ci_upper = calculate_confidence_interval(revenue_data)
print(f"Revenue: ${mean:.2f} [95% CI: ${ci_lower:.2f}, ${ci_upper:.2f}]")

3. Machine Learning (Intermediate level)

Я не специалист ML, но могу:

Классификация и регрессия:

from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.ensemble import RandomForestClassifier, GradientBoostingRegressor
from sklearn.metrics import roc_auc_score, precision_recall_curve, f1_score

# Подготовка данных
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y
)

# Классификация
model = RandomForestClassifier(n_estimators=100, max_depth=10, random_state=42)
model.fit(X_train, y_train)

# Оценка
y_pred_proba = model.predict_proba(X_test)[:, 1]
auc = roc_auc_score(y_test, y_pred_proba)
print(f"AUC: {auc:.3f}")

# Feature importance
feature_importance = pd.DataFrame({
    'feature': X.columns,
    'importance': model.feature_importances_
}).sort_values('importance', ascending=False)

Кластеризация:

from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler

# Нормализация
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# K-means
kmeans = KMeans(n_clusters=3, random_state=42)
clusters = kmeans.fit_predict(X_scaled)

df['cluster'] = clusters

Временные ряды:

from statsmodels.tsa.seasonal import seasonal_decompose
from statsmodels.tsa.statespace.sarimax import SARIMAX

# Разложение на компоненты
decomposition = seasonal_decompose(ts_data, model='additive', period=12)
trend = decomposition.trend
seasonal = decomposition.seasonal
residual = decomposition.resid

# ARIMA модель
model = SARIMAX(ts_data, order=(1, 1, 1), seasonal_order=(1, 1, 1, 12))
results = model.fit()
forecast = results.get_forecast(steps=12)

4. Работа с базами данных (Advanced level)

SQLAlchemy:

from sqlalchemy import create_engine, text
import pandas as pd

# Подключение
engine = create_engine('postgresql://user:password@host/db')

# Чтение из БД
query = """
SELECT user_id, date, revenue
FROM sales
WHERE date >= '2023-01-01'
"""
df = pd.read_sql(query, engine)

# Запись в БД
df.to_sql('staging_sales', engine, if_exists='append', index=False)

# С параметрами
query = text("""
SELECT * FROM sales WHERE date >= :start_date AND region = :region
""")
df = pd.read_sql(query, engine, params={'start_date': '2023-01-01', 'region': 'US'})

psycopg2 (прямое подключение):

import psycopg2
from psycopg2.extras import execute_values

conn = psycopg2.connect("dbname=analytics user=analyst password=secret")
cur = conn.cursor()

# Bulk insert
data = [(1, 'John', 100), (2, 'Jane', 200)]
execute_values(cur, "INSERT INTO users (id, name, value) VALUES %s", data)
conn.commit()
cur.close()
conn.close()

5. Визуализация (Intermediate level)

import matplotlib.pyplot as plt
import seaborn as sns
import plotly.express as px
import plotly.graph_objects as go

# Matplotlib (базовое)
plt.figure(figsize=(12, 6))
plt.plot(df['date'], df['revenue'], label='Revenue')
plt.xlabel('Date')
plt.ylabel('Revenue ($)')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

# Seaborn (статистические визуализации)
sns.set_style('whitegrid')
plt.figure(figsize=(10, 6))
sns.boxplot(data=df, x='region', y='revenue', hue='product')
sns.despine()
plt.show()

# Plotly (интерактивные графики)
fig = px.line(df, x='date', y='revenue', color='region', 
              title='Revenue by Region', hover_data=['amount'])
fig.show()

# Plotly объекты
fig = go.Figure()
fig.add_trace(go.Scatter(x=df['date'], y=df['revenue'], name='Revenue'))
fig.update_layout(title='Analytics Dashboard', xaxis_title='Date', yaxis_title='$')
fig.write_html('dashboard.html')

6. Автоматизация и скрипты (Advanced level)

import os
import logging
from datetime import datetime, timedelta
import schedule
import time

# Логирование
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('analytics.log'),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger(__name__)

# Обработка ошибок
try:
    df = pd.read_sql(query, engine)
except Exception as e:
    logger.error(f"Error reading from DB: {e}", exc_info=True)
    raise

# Планирование задач
def daily_report():
    logger.info("Starting daily report")
    # Код отчёта
    logger.info("Daily report completed")

schedule.every().day.at("02:00").do(daily_report)

while True:
    schedule.run_pending()
    time.sleep(60)

7. API интеграции (Intermediate level)

import requests
import json
from typing import Dict, List

class APIClient:
    def __init__(self, base_url: str, api_key: str):
        self.base_url = base_url
        self.headers = {'Authorization': f'Bearer {api_key}'}
    
    def get_data(self, endpoint: str, params: Dict = None) -> List[Dict]:
        url = f"{self.base_url}/{endpoint}"
        try:
            response = requests.get(url, headers=self.headers, params=params)
            response.raise_for_status()
            return response.json()
        except requests.RequestException as e:
            logger.error(f"API Error: {e}")
            raise
    
    def post_data(self, endpoint: str, data: Dict) -> Dict:
        url = f"{self.base_url}/{endpoint}"
        response = requests.post(url, headers=self.headers, json=data)
        response.raise_for_status()
        return response.json()

# Использование
client = APIClient('https://api.example.com', 'your-api-key')
data = client.get_data('users', params={'limit': 100})

Что я НЕ умею (или не часто использую)

• Frontend разработка: HTML, CSS, JavaScript (могу читать, но не пишу)
• Backend (FastAPI, Django): Понимаю логику, но не разработчик
• ООП и design patterns: Знаю основы, но не архитектор системы
• Асинхронное программирование: asyncio, разобраться могу, но не эксперт
• DevOps: Docker, Kubernetes — только поверхностно

Как я совершенствую свои навыки

1. Практика: Постоянно пишу код в реальных проектах
2. Чтение: Stack Overflow, документация, блоги
3. Конкурсы: Kaggle для практики ML
4. Курсы: DataCamp, курсы на Udemy по мере необходимости
5. Code review: Смотрю чужой код в GitHub, учу лучшие практики

Стандарты кода

# Соблюдаю PEP 8
# Используемые инструменты: black, flake8, mypy (type hints)

from typing import List, Dict, Optional

def calculate_metrics(
    data: pd.DataFrame, 
    group_by: List[str],
    metric: str = 'revenue'
) -> Dict[str, float]:
    """Calculate metrics grouped by columns.
    
    Args:
        data: Input DataFrame
        group_by: Columns to group by
        metric: Metric to calculate (default: revenue)
    
    Returns:
        Dictionary with metrics by group
    """
    result = data.groupby(group_by)[metric].agg(['sum', 'mean', 'count'])
    return result.to_dict()

Итоговая оценка

Для должности Data Analyst: Мой уровень Python достаточен для:

• ✅ ETL-процессов и автоматизации
• ✅ Статистического анализа
• ✅ Работы с API
• ✅ Базового ML (прогностические модели, кластеризация)
• ✅ Написания production-ready кода

Не достаточен для: Full-stack разработки, высоконагруженных систем, сложных архитектурных решений (но и не требуется для аналитики).

Мой Python — это инструмент для аналитики, а не основная профессия.