Примеры Python-кода: от основ до продвинутых техник с разбором

# Основные типы данных
name = "Алексей" # строка (str)
age = 25 # целое число (int)
height = 1.85 # число с плавающей точкой (float)
is_developer = True # логическое значение (bool)

# Проверка типа данных
print(type(name)) # <class 'str'>
print(type(age)) # <class 'int'>
print(type(height)) # <class 'float'>
print(type(is_developer)) # <class 'bool'>

# Простое условие
age = 20

if age >= 18:
print("Вы совершеннолетний")
else:
print("Вы несовершеннолетний")

# Множественные условия
score = 85

if score >= 90:
grade = "A"
elif score >= 80:
grade = "B"
elif score >= 70:
grade = "C"
else:
grade = "D"

print(f"Ваша оценка: {grade}") # Ваша оценка: B

# Цикл for с range
for i in range(5):
print(i, end=" ") # 0 1 2 3 4

print() # Перевод строки

# Цикл for с коллекцией
fruits = ["яблоко", "банан", "апельсин"]
for fruit in fruits:
print(fruit, end=" ") # яблоко банан апельсин

print()

# Цикл while
count = 0
while count < 5:
print(count, end=" ") # 0 1 2 3 4
count += 1

# Простая функция без параметров
def say_hello():
print("Привет, мир!")

say_hello() # Привет, мир!

# Функция с параметрами
def greet(name):
print(f"Привет, {name}!")

greet("Мария") # Привет, Мария!

# Функция с параметрами по умолчанию и возвратом значения
def power(base, exponent=2):
return base ** exponent

result = power(5) # 25 (5^2)
print(result)

result = power(2, 3) # 8 (2^3)
print(result)

def count_characters(string):
# Создаем пустой словарь для хранения результатов
char_count = {}

# Проходим по каждому символу строки
for char in string:
# Если символ уже есть в словаре, увеличиваем счетчик
if char in char_count:
char_count[char] += 1
# Если символа еще нет, добавляем его со значением 1
else:
char_count[char] = 1

return char_count

# Пример использования
text = "привет, мир!"
result = count_characters(text)
print(result) # {'п': 1, 'р': 2, 'и': 2, 'в': 1, 'е': 1, 'т': 1, ',': 1, ' ': 1, 'м': 1, '!': 1}

# Более элегантное решение с использованием Counter
from collections import Counter

def count_chars_elegant(string):
return Counter(string)

result_elegant = count_chars_elegant(text)
print(dict(result_elegant)) # Тот же результат, но с меньшим количеством кода

def is_palindrome(string):
# Приводим строку к нижнему регистру и удаляем все не-буквенные символы
cleaned_string = ''.join(char.lower() for char in string if char.isalnum())

# Сравниваем строку с ее обратной версией
return cleaned_string == cleaned_string[::-1]

# Примеры использования
print(is_palindrome("А роза упала на лапу Азора")) # True
print(is_palindrome("Python")) # False
print(is_palindrome("Madam, I'm Adam")) # False (из-за апострофа и пробелов)

# Улучшенная версия, игнорирующая пробелы и знаки препинания
def is_palindrome_improved(string):
# Приводим строку к нижнему регистру и удаляем все не-буквенные символы
cleaned_string = ''.join(char.lower() for char in string if char.isalnum())

# Сравниваем строку с ее обратной версией
return cleaned_string == cleaned_string[::-1]

print(is_palindrome_improved("Madam, I'm Adam")) # True

def gcd_iterative(a, b):
"""Нахождение НОД итеративным способом."""
while b:
a, b = b, a % b
return a

def gcd_recursive(a, b):
"""Нахождение НОД рекурсивным способом."""
if b == 0:
return a
return gcd_recursive(b, a % b)

# Примеры использования
print(gcd_iterative(48, 18)) # 6
print(gcd_recursive(48, 18)) # 6

# Использование встроенной функции из модуля math
import math
print(math.gcd(48, 18)) # 6

# Традиционный подход с циклом for
squares = []
for i in range(10):
squares.append(i**2)
print(squares) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# Тот же результат со списковым включением
squares_comp = [i**2 for i in range(10)]
print(squares_comp) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# Списковое включение с условием
even_squares = [i**2 for i in range(10) if i % 2 == 0]
print(even_squares) # [0, 4, 16, 36, 64]

# Вложенное списковое включение (создание матрицы)
matrix = [[i*j for j in range(5)] for i in range(5)]
print(matrix) # [[0, 0, 0, 0, 0], [0, 1, 2, 3, 4], [0, 2, 4, 6, 8], [0, 3, 6, 9, 12], [0, 4, 8, 12, 16]]

# Функция-генератор
def fibonacci_generator(n):
a, b = 0, 1
for _ in range(n):
yield a
a, b = b, a + b

# Использование генератора
for num in fibonacci_generator(10):
print(num, end=" ") # 0 1 1 2 3 5 8 13 21 34

print()

# Генераторное выражение (аналогично списковым включениям, но в круглых скобках)
gen_exp = (x**2 for x in range(10))
print(type(gen_exp)) # <class 'generator'>
print(list(gen_exp)) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# Сравнение использования памяти
import sys
list_comp = [i for i in range(1000000)]
gen_exp = (i for i in range(1000000))

print(f"Размер списка: {sys.getsizeof(list_comp)} байт") # Гораздо больше
print(f"Размер генератора: {sys.getsizeof(gen_exp)} байт") # Намного меньше

# Простой декоратор для измерения времени выполнения
import time

def timer_decorator(func):
def wrapper(*args, **kwargs):
start_time = time.time()
result = func(*args, **kwargs)
end_time = time.time()
print(f"Функция {func.__name__} выполнялась {end_time – start_time:.4f} секунд")
return result
return wrapper

# Применение декоратора
@timer_decorator
def slow_function(n):
"""Функция, имитирующая длительное выполнение."""
time.sleep(n)
return n

print(slow_function(1)) # Выведет время выполнения и вернет 1

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

@repeat(n=5)
def greet(name):
return f"Привет, {name}!"

print(greet("Анна")) # Вернет список из 5 приветствий

# Стандартное использование контекстного менеджера для файлов
with open('example.txt', 'w') as file:
file.write('Привет, мир!')
# Файл автоматически закрывается при выходе из блока with

# Создание собственного контекстного менеджера с помощью класса
class Timer:
def __enter__(self):
self.start = time.time()
return self

def __exit__(self, *args):
self.end = time.time()
print(f"Время выполнения: {self.end – self.start:.4f} секунд")

# Использование собственного контекстного менеджера
with Timer():
# Какой-то код, время выполнения которого нужно измерить
time.sleep(1)

# Создание контекстного менеджера с помощью декоратора contextlib.contextmanager
from contextlib import contextmanager

@contextmanager
def timer():
start = time.time()
try:
yield
finally:
end = time.time()
print(f"Время выполнения: {end – start:.4f} секунд")

# Использование
with timer():
time.sleep(0.5)

# Профилирование с помощью модуля cProfile
import cProfile

def slow_function():
result = []
for i in range(1000000):
result.append(i ** 2)
return result

def fast_function():
return [i ** 2 for i in range(1000000)]

# Профилируем функции
print("Профилирование slow_function:")
cProfile.run('slow_function()')

print("\nПрофилирование fast_function:")
cProfile.run('fast_function()')

# Более детальное профилирование с помощью timeit
import timeit

slow_time = timeit.timeit('slow_function()', 
globals=globals(), 
number=10)
fast_time = timeit.timeit('fast_function()', 
globals=globals(), 
number=10)

print(f"\nslow_function: {slow_time:.4f} секунд")
print(f"fast_function: {fast_time:.4f} секунд")
print(f"Ускорение: {slow_time/fast_time:.2f}x")

# Неоптимальное объединение строк
def build_string_slow(n):
result = ""
for i in range(n):
result += str(i) # Создает новую строку при каждом += операторе
return result

# Оптимизированная версия с использованием списка и join
def build_string_fast(n):
result = []
for i in range(n):
result.append(str(i))
return ''.join(result) # Создает строку только один раз

# Еще быстрее с использованием генераторного выражения
def build_string_fastest(n):
return ''.join(str(i) for i in range(n))

# Работа с большими наборами данных: генераторы vs списки
def process_large_file_with_list(filename):
with open(filename, 'r') as f:
lines = f.readlines() # Загружает весь файл в память

# Обработка каждой строки
processed = [line.strip().upper() for line in lines]
return processed

def process_large_file_with_generator(filename):
with open(filename, 'r') as f:
# Обрабатываем по одной строке за раз, не загружая весь файл
for line in f:
yield line.strip().upper()

# Рекурсивная функция для вычисления чисел Фибоначчи (неэффективная)
def fibonacci_slow(n):
if n <= 1:
return n
return fibonacci_slow(n – 1) + fibonacci_slow(n – 2)

# Применение декоратора lru_cache для кэширования результатов
from functools import lru_cache

@lru_cache(maxsize=None)
def fibonacci_fast(n):
if n <= 1:
return n
return fibonacci_fast(n – 1) + fibonacci_fast(n – 2)

# Измерение времени выполнения
import time

start = time.time()
result = fibonacci_slow(35)
end = time.time()
print(f"fibonacci_slow(35) = {result}, время: {end – start:.4f} секунд")

start = time.time()
result = fibonacci_fast(35)
end = time.time()
print(f"fibonacci_fast(35) = {result}, время: {end – start:.4f} секунд")

# Ручная реализация кэширования
def memoize(func):
cache = {}
def wrapper(*args):
if args not in cache:
cache[args] = func(*args)
return cache[args]
return wrapper

@memoize
def fibonacci_memoized(n):
if n <= 1:
return n
return fibonacci_memoized(n – 1) + fibonacci_memoized(n – 2)

# До рефакторинга: монолитная функция
def process_data_old(data):
result = []

for item in data:
# Проверка валидности
if item is None or item == '':
continue

# Обработка данных
processed_item = item.strip().lower()

# Преобразование
if processed_item.isdigit():
processed_item = int(processed_item) * 2
else:
processed_item = processed_item.upper()

# Добавление в результат
result.append(processed_item)

return result

# После рефакторинга: модульные функции
def is_valid_item(item):
return item is not None and item != ''

def process_item(item):
return item.strip().lower()

def transform_item(item):
if item.isdigit():
return int(item) * 2
return item.upper()

def process_data_new(data):
result = []

for item in data:
if not is_valid_item(item):
continue

processed_item = process_item(item)
transformed_item = transform_item(processed_item)
result.append(transformed_item)

return result

# Или еще компактнее с использованием функций высшего порядка и генераторов
def process_data_functional(data):
valid_items = filter(is_valid_item, data)
processed_items = map(process_item, valid_items)
return list(map(transform_item, processed_items))

# NumPy для эффективных вычислений с массивами
import numpy as np

# Создание массива и выполнение векторизованных операций
array = np.array([1, 2, 3, 4, 5])
print(f"Массив: {array}")
print(f"Массив в квадрате: {array ** 2}")
print(f"Среднее значение: {array.mean()}")
print(f"Стандартное отклонение: {array.std()}")

# Матричные операции
matrix_a = np.array([[1, 2], [3, 4]])
matrix_b = np.array([[5, 6], [7, 8]])
print(f"Произведение матриц:\n{np.dot(matrix_a, matrix_b)}")

# Pandas для работы с табличными данными
import pandas as pd

# Создание DataFrame из словаря
data = {
'Name': ['Анна', 'Борис', 'Виктор', 'Галина'],
'Age': [25, 32, 45, 28],
'City': ['Москва', 'Санкт-Петербург', 'Казань', 'Москва']
}
df = pd.DataFrame(data)
print("\nDataFrame из словаря:")
print(df)

# Фильтрация данных
moscow_residents = df[df['City'] == 'Москва']
print("\nЖители Москвы:")
print(moscow_residents)

# Группировка и агрегация
city_stats = df.groupby('City').agg({
'Age': ['mean', 'min', 'max'],
'Name': 'count'
})
print("\nСтатистика по городам:")
print(city_stats)

# Matplotlib – базовая библиотека для визуализации
import matplotlib.pyplot as plt
import numpy as np

# Простой линейный график
x = np.linspace(0, 10, 100)
y = np.sin(x)
plt.figure(figsize=(10, 5))
plt.plot(x, y, label='sin(x)')
plt.title('Синусоида')
plt.xlabel('x')
plt.ylabel('sin(x)')
plt.grid(True)
plt.legend()
# plt.savefig('sinusoid.png') # Сохранение графика
plt.close() # Закрываем фигуру

# Seaborn – библиотека для статистической визуализации
import seaborn as sns
import pandas as pd

# Создаем датасет
np.random.seed(0)
data = pd.DataFrame({
'group': ['A'] * 50 + ['B'] * 50,
'value': np.concatenate([np.random.normal(10, 2, 50), np.random.normal(13, 2, 50)])
})

# Строим распределение с разбивкой по группам
plt.figure(figsize=(10, 5))
sns.histplot(data=data, x='value', hue='group', kde=True, bins=15)
plt.title('Распределение значений по группам')
# plt.savefig('distribution.png')
plt.close()

# Plotly – библиотека для интерактивной визуализации
import plotly.express as px

# Создаем интерактивный график рассеяния
df = px.data.iris() # Встроенный датасет
fig = px.scatter(df, x="sepal_width", y="sepal_length", color="species",
size="petal_length", hover_data=['petal_width'])
# fig.write_html('interactive_scatter.html') # Сохранение интерактивного графика
# fig.show() # Отображение в браузере

# Scikit-learn – библиотека для традиционного машинного обучения
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report

# Загрузка данных
iris = load_iris()
X, y = iris.data, iris.target

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

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

# Оценка модели
predictions = model.predict(X_test)
accuracy = accuracy_score(y_test, predictions)
print(f"\nТочность модели: {accuracy:.4f}")
print("\nОтчет о классификации:")
print(classification_report(y_test, predictions, target_names=iris.target_names))

# Важность признаков
feature_importance = model.feature_importances_
features = iris.feature_names
importance_df = pd.DataFrame({'Feature': features, 'Importance': feature_importance})
importance_df = importance_df.sort_values('Importance', ascending=False)
print("\nВажность признаков:")
print(importance_df)

# TensorFlow – библиотека для глубокого обучения
import tensorflow as tf

# Создание простой нейронной сети для классификации цифр MNIST
mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# Нормализация данных
x_train, x_test = x_train / 255.0, x_test / 255.0

# Построение модели
model = tf.keras.models.Sequential([
tf.keras.layers.Flatten(input_shape=(28, 28)), # Преобразуем 2D-изображение в 1D-массив
tf.keras.layers.Dense(128, activation='relu'), # Полносвязный слой с 128 нейронами
tf.keras.layers.Dropout(0.2), # Слой регуляризации
tf.keras.layers.Dense(10, activation='softmax') # Выходной слой для 10 классов
])

# Компиляция модели
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])

# Обучение модели (закомментировано, так как может занять время)
# model.fit(x_train, y_train, epochs=5)

# Оценка модели (также закомментировано)
# model.evaluate(x_test, y_test)

# Flask – микрофреймворк для веб-разработки
from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/')
def home():
return "Привет, мир!"

@app.route('/api/data')
def get_data():
data = {
'name': 'Python',
'type': 'Programming Language',
'popularity': 'Very High',
'use_cases': ['Web Development', 'Data Analysis', 'AI', 'Automation']
}
return jsonify(data)

# Запуск сервера (закомментировано, так как это блокирующий вызов)
# if __name__ == '__main__':
# app.run(debug=True)

# Requests – библиотека для HTTP-запросов
import requests

def fetch_github_repo_info(username, repo):
url = f"https://api.github.com/repos/{username}/{repo}"
response = requests.get(url)

if response.status_code == 200:
data = response.json()
return {
'name': data['name'],
'stars': data['stargazers_count'],
'forks': data['forks_count'],
'language': data['language'],
'description': data['description']
}
else:
return {'error': f"Ошибка {response.status_code}: {response.reason}"}

# Пример использования
# repo_info = fetch_github_repo_info('tensorflow', 'tensorflow')
# print(repo_info)

# Beautiful Soup – библиотека для парсинга HTML и XML
from bs4 import BeautifulSoup

# Пример HTML-страницы
html = """
<!DOCTYPE html>
<html>
<head>
<title>Пример страницы</title>
</head>
<body>
<h1>Заголовок</h1>
<p class="description">Это описание</p>
<ul>
<li>Элемент 1</li>
<li>Элемент 2</li>
<li>Элемент 3</li>
</ul>
</body>
</html>
"""

# Парсинг HTML
soup = BeautifulSoup(html, 'html.parser')
print("\nРезультаты парсинга HTML:")
print(f"Заголовок: {soup.title.string}")
print(f"Первый h1: {soup.h1.string}")
print(f"Параграф с классом description: {soup.find('p', class_='description').string}")

# Извлечение списка элементов
items = soup.find_all('li')
print("Элементы списка:")
for item in items:
print(f"- {item.string}")