Какие знаешь ключевые особенности Python?

Ключевые особенности Python

Python — один из самых популярных языков программирования. Расскажу о его ключевых особенностях, которые делают его уникальным.

1. Динамическая типизация

Переменные могут менять тип во время выполнения:

# Динамическая типизация
x = 5
print(type(x))  # int

x = "hello"
print(type(x))  # str

x = 3.14
print(type(x))  # float

# Функция может принимать разные типы
def process(value):
    if isinstance(value, int):
        return value * 2
    elif isinstance(value, str):
        return value.upper()
    return value

print(process(5))        # 10
print(process("hello"))  # HELLO

Преимущества: гибкость, меньше кода Недостатки: ошибки видны только во время выполнения

2. GIL (Global Interpreter Lock)

В CPython только один поток может выполнять байт-код одновременно. Это важно при многопоточности.

import threading
import time

def cpu_bound_work():
    total = 0
    for i in range(100_000_000):
        total += i
    return total

# Однопоточное выполнение
start = time.time()
cpu_bound_work()
cpu_bound_work()
print(f"Однопоточно: {time.time() - start:.2f}s")  # ~5 сек

# Многопоточное выполнение (НЕ быстрее из-за GIL)
start = time.time()
threads = [
    threading.Thread(target=cpu_bound_work),
    threading.Thread(target=cpu_bound_work)
]
for t in threads:
    t.start()
for t in threads:
    t.join()
print(f"Многопоточно: {time.time() - start:.2f}s")  # ~5 сек (не быстрее!)

# Многопроцессное (Быстрее, обходит GIL)
from multiprocessing import Pool
start = time.time()
with Pool(2) as p:
    p.map(cpu_bound_work, [None, None])
print(f"Многопроцессно: {time.time() - start:.2f}s")  # ~2.5 сек

Вывод: Для I/O используй потоки, для CPU-bound используй процессы или asyncio.

3. Всё — объект

Всё в Python это объект с методами и атрибутами:

# Даже функции и классы это объекты
def my_func():
    pass

print(type(my_func))  # <class 'function'>
print(my_func.__name__)  # 'my_func'
print(dir(my_func))  # все методы и атрибуты

# Можно присваивать функции переменным
f = my_func
f()  # вызывает my_func

# Можно передавать функции как аргументы
def apply_twice(func, value):
    return func(func(value))

result = apply_twice(lambda x: x * 2, 5)  # 20

4. Интроспекция и отражение

Во время выполнения можно смотреть структуру объектов:

class User:
    def __init__(self, name):
        self.name = name
    
    def greet(self):
        return f"Hello, {self.name}"

user = User("John")

# Интроспекция
print(hasattr(user, 'name'))  # True
print(getattr(user, 'name'))  # 'John'
setattr(user, 'age', 30)
print(user.age)  # 30

# Список всех атрибутов и методов
print([attr for attr in dir(user) if not attr.startswith('_')])
# ['age', 'greet', 'name']

# Вызов методов по имени
method_name = 'greet'
method = getattr(user, method_name)
print(method())  # 'Hello, John'

# Проверка типа
print(isinstance(user, User))  # True
print(isinstance(user, object))  # True (всё наследует object)

5. Утки вместо наследования (Duck Typing)

"Если ходит как утка и крякает как утка, то это утка".

# Не нужно наследовать интерфейс
class Dog:
    def sound(self):
        return "Woof"

class Cat:
    def sound(self):
        return "Meow"

class Robot:
    def sound(self):
        return "Beep boop"

# Функция работает со всеми, потому что у них есть метод sound()
def make_sound(animal):
    print(animal.sound())

dog = Dog()
cat = Cat()
robot = Robot()

make_sound(dog)    # Woof
make_sound(cat)    # Meow
make_sound(robot)  # Beep boop

# Не нужно наследовать list, достаточно метода __iter__
class CustomList:
    def __init__(self, data):
        self.data = data
    
    def __iter__(self):
        return iter(self.data)
    
    def __len__(self):
        return len(self.data)

custom = CustomList([1, 2, 3])
for item in custom:  # работает как список
    print(item)

6. Декораторы

Мощный инструмент для модификации функций и классов:

# Простой декоратор
def timer_decorator(func):
    import time
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        elapsed = time.time() - start
        print(f"{func.__name__} took {elapsed:.4f}s")
        return result
    return wrapper

@timer_decorator
def slow_function():
    import time
    time.sleep(1)

slow_function()  # slow_function took 1.0001s

# Декоратор с параметрами
def repeat(n):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(n):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(3)
def say_hello():
    print("Hello")

say_hello()
# Hello
# Hello
# Hello

7. List comprehensions и генераторы

Компактный синтаксис для создания последовательностей:

# List comprehension
data = [1, 2, 3, 4, 5]
squares = [x**2 for x in data]  # [1, 4, 9, 16, 25]
even = [x for x in data if x % 2 == 0]  # [2, 4]

# Генератор (ленивое вычисление)
def fibonacci(n):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

for num in fibonacci(5):
    print(num)  # 0, 1, 1, 2, 3

# Generator expression (как list comprehension, но ленивая)
gen = (x**2 for x in range(1_000_000))  # не вычисляет всё сразу
first = next(gen)  # 0
second = next(gen)  # 1

# Экономия памяти
list_comp = [i**2 for i in range(1_000_000)]  # ~40 MB
gen_expr = (i**2 for i in range(1_000_000))  # ~0 KB (вычисляется по мере надобности)

8. Контекстные менеджеры (with)

Автоматическое управление ресурсами:

# Автоматическое закрытие файла
with open('data.txt') as f:
    content = f.read()
# Файл автоматически закрыт, даже если произойдёт исключение

# Собственный контекстный менеджер
class DatabaseConnection:
    def __enter__(self):
        print("Connecting to DB")
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        print("Closing DB connection")
        if exc_type:
            print(f"Exception occurred: {exc_val}")
        return False  # не подавляем исключение
    
    def execute(self, query):
        print(f"Executing: {query}")

with DatabaseConnection() as db:
    db.execute("SELECT * FROM users")
# Connecting to DB
# Executing: SELECT * FROM users
# Closing DB connection

9. Множественное наследование и MRO

Python поддерживает множественное наследование с методом разрешения порядка (MRO):

class A:
    def method(self):
        return "A"

class B(A):
    def method(self):
        return "B"

class C(A):
    def method(self):
        return "C"

class D(B, C):
    pass

obj = D()
print(obj.method())  # 'B'
print(D.mro())  # [D, B, C, A, object]

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

async/await для асинхронного кода:

import asyncio
import aiohttp

async def fetch_data(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.text()

async def main():
    urls = ['http://example.com', 'http://example2.com']
    results = await asyncio.gather(
        fetch_data(urls[0]),
        fetch_data(urls[1])
    )
    return results

results = asyncio.run(main())

11. Простота синтаксиса

Python имеет простой, читаемый синтаксис:

# Просто читается как английский язык
def calculate_average(numbers):
    if not numbers:
        return 0
    
    total = sum(numbers)
    count = len(numbers)
    return total / count

# vs Java или C++
public static double calculateAverage(int[] numbers) {
    if (numbers.length == 0) return 0;
    double sum = 0;
    for (int num : numbers) sum += num;
    return sum / numbers.length;
}

12. Огромная стандартная библиотека

"Batteries included" — в стандартной библиотеке есть почти всё:

# Работа с файлами
import os, shutil, pathlib

# Сетевые протоколы
import http, ftp, smtplib, json, urllib

# Структуры данных
from collections import deque, defaultdict, Counter

# Математика
import math, statistics, random

# Потоки и процессы
import threading, multiprocessing

# Регулярные выражения
import re

# Сжатие
import zipfile, gzip, bz2

Итого

Python привлекает разработчиков тем, что он:

• Простой для изучения
• Гибкий и мощный
• Имеет большую экосистему (NumPy, Pandas, Django, Flask)
• Используется везде: веб, науку, ML, автоматизацию, скрипты

Но помни про GIL при многопоточности и то, что динамическая типизация требует тщательного тестирования.