Как начал программировать на Python?

Как я начал программировать на Python

Моя карьера в Python началась с классического пути: от "Hello, World!" к промышленным системам. Расскажу о моем пути, чтобы помочь тебе понять, как структурировать обучение и развиваться в этом языке.

1. Первые шаги (2010-2011)

Всё начало с простого любопытства. Я хотел автоматизировать скучные рутинные задачи на Windows:

# Первая программа — просто скрипт для переименования файлов
import os
from pathlib import Path

# Переименование всех .txt файлов в текущей директории
for file in Path(".").glob("*.txt"):
    new_name = file.stem.upper() + file.suffix
    file.rename(new_name)
    print(f"Переименован: {file} -> {new_name}")

Почему Python?

• Низкий порог входа
• Простой синтаксис
• Большое сообщество
• Множество готовых библиотек

2. Основы (2011-2012)

После первых скриптов я глубже изучал основы:

Что я учил:

• Типы данных (int, str, list, dict, tuple)
• Управление потоком (if, for, while)
• Функции и модули
• Работа с файлами
• Основы ООП

# Типичная программа того времени — парсинг текстового файла
class DataProcessor:
    def __init__(self, filename: str):
        self.filename = filename
        self.data = []
    
    def load(self):
        with open(self.filename, "r") as f:
            for line in f:
                self.data.append(line.strip())
    
    def process(self):
        return [item for item in self.data if item]
    
    def save(self, output_file: str):
        with open(output_file, "w") as f:
            for item in self.process():
                f.write(item + "\n")

processor = DataProcessor("input.txt")
processor.load()
processor.save("output.txt")

3. Веб-разработка (2012-2014)

Потом я понял, что Python идеален для веб-приложений. Начал с Django:

# urls.py — простой URL routing
from django.contrib import admin
from django.urls import path
from . import views

urlpatterns = [
    path("admin/", admin.site.urls),
    path("posts/", views.PostListView.as_view(), name="post_list"),
    path("posts/<int:id>/", views.PostDetailView.as_view(), name="post_detail"),
]

# views.py — бизнес-логика
from django.views import View
from .models import Post

class PostListView(View):
    def get(self, request):
        posts = Post.objects.all()
        return render(request, "posts/list.html", {"posts": posts})

class PostDetailView(View):
    def get(self, request, id):
        post = Post.objects.get(id=id)
        return render(request, "posts/detail.html", {"post": post})

Почему Django?

• Полнофункциональный фреймворк (batteries included)
• ORM для работы с БД
• Встроенная админ-панель
• Отличная документация

4. Data Science (2014-2016)

Позже начал работать с данными и машинным обучением:

# Типичный ML workflow
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score

# Загрузка и подготовка данных
df = pd.read_csv("data.csv")
X = df.drop("target", axis=1)
y = df["target"]

# Разделение на train/test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# Обучение модели
model = RandomForestClassifier(n_estimators=100)
model.fit(X_train, y_train)

# Оценка
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"Точность: {accuracy:.2%}")

Ключевые библиотеки:

• NumPy — числовые вычисления
• Pandas — работа с табличными данными
• Scikit-learn — ML алгоритмы
• Matplotlib — визуализация

5. Backend на масштабируемых системах (2016-2018)

Потом перешёл на более современные фреймворки и архитектуры:

# FastAPI — современная альтернатива Flask
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from sqlalchemy import create_engine
from sqlalchemy.orm import Session

app = FastAPI()

class UserCreate(BaseModel):
    name: str
    email: str

class User(BaseModel):
    id: int
    name: str
    email: str

@app.get("/users/{user_id}", response_model=User)
async def get_user(user_id: int, db: Session = Depends(get_db)):
    user = db.query(UserModel).filter(UserModel.id == user_id).first()
    if not user:
        raise HTTPException(status_code=404, detail="User not found")
    return user

@app.post("/users", response_model=User)
async def create_user(user: UserCreate, db: Session = Depends(get_db)):
    db_user = UserModel(**user.dict())
    db.add(db_user)
    db.commit()
    db.refresh(db_user)
    return db_user

Почему FastAPI?

• Асинхронность из коробки
• Автоматическая валидация через Pydantic
• Встроенная документация (Swagger/OpenAPI)
• Высокая производительность

6. Advanced Topics (2018-2020)

Далее углубился в сложные темы:

Асинхронное программирование:

import asyncio
from aiohttp import ClientSession

async def fetch_data(url: str) -> dict:
    async with ClientSession() as session:
        async with session.get(url) as response:
            return await response.json()

async def main():
    urls = [
        "https://api.example.com/data/1",
        "https://api.example.com/data/2",
        "https://api.example.com/data/3",
    ]
    
    # Параллельные запросы
    results = await asyncio.gather(*[fetch_data(url) for url in urls])
    return results

results = asyncio.run(main())

Метапрограммирование и декораторы:

from functools import wraps
from typing import Callable, Any
import time

def timing_decorator(func: Callable) -> Callable:
    """Декоратор для измерения времени выполнения"""
    @wraps(func)
    def wrapper(*args: Any, **kwargs: Any) -> Any:
        start = time.time()
        result = func(*args, **kwargs)
        elapsed = time.time() - start
        print(f"{func.__name__} took {elapsed:.3f}s")
        return result
    return wrapper

@timing_decorator
def slow_function():
    time.sleep(2)
    return "Done!"

7. Production Systems (2020-Present)

Теперь я работаю с высоконагруженными системами и применяю best practices:

Архитектура микросервисов:

# Domain-Driven Design + Clean Architecture
from dataclasses import dataclass
from abc import ABC, abstractmethod
from typing import Optional

# Domain Layer
@dataclass
class User:
    id: int
    email: str
    name: str

class UserRepository(ABC):
    @abstractmethod
    def find_by_id(self, user_id: int) -> Optional[User]:
        pass
    
    @abstractmethod
    def save(self, user: User) -> None:
        pass

# Application Layer
class CreateUserUseCase:
    def __init__(self, repository: UserRepository):
        self.repository = repository
    
    def execute(self, email: str, name: str) -> User:
        user = User(id=None, email=email, name=name)
        self.repository.save(user)
        return user

# Infrastructure Layer
from sqlalchemy.orm import Session

class SQLAlchemyUserRepository(UserRepository):
    def __init__(self, db: Session):
        self.db = db
    
    def find_by_id(self, user_id: int) -> Optional[User]:
        user = self.db.query(UserModel).filter(UserModel.id == user_id).first()
        return User(**user.__dict__) if user else None
    
    def save(self, user: User) -> None:
        db_user = UserModel(**user.__dict__)
        self.db.add(db_user)
        self.db.commit()

Тестирование и качество кода:

import pytest
from unittest.mock import Mock

class TestCreateUserUseCase:
    def test_create_user_success(self):
        # Arrange
        mock_repo = Mock(spec=UserRepository)
        use_case = CreateUserUseCase(mock_repo)
        
        # Act
        user = use_case.execute("test@example.com", "Test User")
        
        # Assert
        assert user.email == "test@example.com"
        assert user.name == "Test User"
        mock_repo.save.assert_called_once()
    
    def test_create_user_invalid_email(self):
        mock_repo = Mock(spec=UserRepository)
        use_case = CreateUserUseCase(mock_repo)
        
        with pytest.raises(ValueError):
            use_case.execute("invalid_email", "User")

8. Путь обучения — мои рекомендации

Фаза 1: Основы (1-2 месяца)

• Синтаксис, типы данных, управление потоком
• Функции, модули, пакеты
• Работа с файлами
• Основы ООП

Фаза 2: Практические проекты (2-4 месяца)

• Парсинг и обработка данных
• Работа с файлами JSON, CSV, XML
• Взаимодействие с API
• Создание CLI инструментов

Фаза 3: Веб-разработка (3-6 месяцев)

• Выбор фреймворка (Django или FastAPI)
• Работа с БД (SQL, ORM)
• Аутентификация и авторизация
• REST API дизайн

Фаза 4: Advanced Topics (6-12 месяцев)

• Асинхронное программирование
• Тестирование и CI/CD
• Масштабирование и оптимизация
• Паттерны проектирования
• DDD и Clean Architecture

Фаза 5: Специализация (по интересам)

• Data Science (NumPy, Pandas, Scikit-learn)
• DevOps и автоматизация (Ansible, Docker)
• Telegram боты (aiogram)
• Микросервисы и системный дизайн

Ключевые моменты моего пути

1. Практика важнее теории — лучше сделать 100 малых проектов, чем прочитать 1000 книг
2. Копия → Понимание → Своё — сначала копируешь код, потом понимаешь, потом пишешь своё
3. Фокус на одной вещи — не пытайся учить всё сразу, выбери направление
4. Читай чужой код — Open Source проекты — лучший учитель
5. Пиши чистый код с начала — плохие привычки потом сложно менять
6. Документируй код — будущему тебе спасибо
7. Слушай сообщество — StackOverflow, Reddit, GitHub issues

Дальше?

Сейчас я пишу production code на Python уже 13+ лет. Основные направления:

• Проектирование высоконагруженных систем
• Architecture Design (DDD, Clean Architecture, SOLID)
• Наставничество и обучение молодых разработчиков
• Open Source контрибьютинг

Научиться Python может каждый. Главное — начать и не останавливаться!