اکنون در دسترس! پژوهش تلگرام ۲۰۲۵ — مهمترین بینشهای سال 
Python для начинающих
رفتن به کانال در Telegram
1 240
مشترکین
+124 ساعت
+37 روز
+230 روز
آرشیو پست ها
Привет! Сегодня поговорим о том, как эффективно использовать возможности процессора в Python с помощью модуля
concurrent.futures. Если вы новичок, но хотите ускорить выполнение ресурсоёмких задач — эта статья для вас.
---
## Зачем оптимизировать CPU-ресурсы?
В современных компьютерах часто несколько ядер CPU, каждое способно выполнять свои задачи одновременно. Однако классический Python-код, особенно если он однопоточный, использует лишь одно ядро. Чтобы выйти из этого ограничения, нужно распараллелить задачи.
Модуль concurrent.futures — один из самых простых и мощных способов для параллельного выполнения кода. Он помогает быстро создавать пул потоков (ThreadPoolExecutor) или процессов (ProcessPoolExecutor), где каждый поток или процесс обрабатывает часть работы. Это особенно актуально для CPU-bound задач — тех, которые интенсивно используют процессор.
---
## Когда использовать ProcessPoolExecutor?
Важно понимать, что в Python срабатывает GIL (Global Interpreter Lock), который не даёт потокам параллельно работать с CPU. Поэтому для тяжёлых вычислений лучше использовать ProcessPoolExecutor, который создаёт несколько отдельных процессов, каждый со своим интерпретатором Python и своей памятью.
В свою очередь, ThreadPoolExecutor отлично подходит для I/O-bound задач, например, скачивания файлов или работы с сетью.
---
## Пример: ускоряем подсчёт факториала нескольких чисел
Посмотрим на пример, где нам нужно посчитать факториалы для множества больших чисел. Обычный цикл будет работать долго, а мы попробуем распараллелить процесс.
import time
from concurrent.futures import ProcessPoolExecutor
import math
def factorial(n):
return math.factorial(n)
numbers = [10**5 + i for i in range(5)] # Большие числа
start = time.time()
# Однопоточный вариант
results = []
for number in numbers:
results.append(factorial(number))
print("Single-threaded:", time.time() - start, "seconds")
start = time.time()
# Параллельный вариант
with ProcessPoolExecutor() as executor:
results = list(executor.map(factorial, numbers))
print("Multi-process:", time.time() - start, "seconds")
ProcessPoolExecutor будет значительно меньше, так как все процессы координально распараллеливают работу.
---
## Полезные советы для оптимизации
1. Выбирайте правильный executor. Для CPU-bound — ProcessPoolExecutor, для I/O-bound — ThreadPoolExecutor.
2. Настраивайте число процессов. По умолчанию ProcessPoolExecutor создаёт количество процессов равное числу CPU-ядер. Иногда можно уменьшить или увеличить это значение вручную.
3. Не передавайте большие объёмы данных между процессами. Копирование данных между процессами — дорогая операция. Лучше вычислять что-то локально в каждом процессе.
4. Используйте executor.map для удобного и эффективного запуска сразу множества задач.
---
concurrent.futures — отличный инструмент, который уже встроен в Python и позволяет без сложностей начать писать многопроцессные приложения. Он значительно улучшает производительность там, где однопоточная обработка — узкое место.
Освойте этот модуль — и ваши ресурсоёмкие задачи не будут тянуть вас назад! Удачи в кодинге!
— Иван
Привет! Я Иван, и сегодня мы отправимся в сжатый мир — поговорим о том, как уменьшать объём данных в Python с помощью модуля
gzip.
Что если у вас есть большой текстовый файл, и вы не хотите забивать диск лишними мегабайтами? Здесь на помощь приходит Gzip — классический стандарт компрессии, который легко использовать в Python, даже если вы только начинаете.
## Быстрое знакомство с gzip
Модуль gzip — это часть стандартной библиотеки Python. Он позволяет читать и записывать файлы в формате .gz без танцев с бубном.
### Как сжать файл
Сжать файл очень просто:
import gzip
with open('large_file.txt', 'rb') as f_in, gzip.open('compressed_file.txt.gz', 'wb') as f_out:
f_out.write(f_in.read())
import gzip
with gzip.open('compressed_file.txt.gz', 'rt', encoding='utf-8') as f:
for line in f:
print(line.strip())
'rt' — мы читаем текст, как если бы работали с обычным файлом.
### Сжатие строк прямо на лету
А если не хочется возиться с файлами? Можно сжимать и разжимать просто строки:
import gzip
original = b'Python is amazing! ' * 100
compressed = gzip.compress(original)
decompressed = gzip.decompress(compressed)
print('Original size:', len(original))
print('Compressed size:', len(compressed))
print('Decompressed equals original:', decompressed == original)
gzip работает только с бинарными данными.
- В Python 3.2+ поддерживается чтение/запись как текстовых файлов через параметры 'rt'/'wt' и encoding.
Вот так просто можно сберечь место и время! Экспериментируйте с разными уровнями компрессии и находите баланс между скоростью и размером файла. Python всегда рядом, чтобы сделать вашу жизнь чуточку легче — и компактнее!
Привет! Я Иван, и сегодня расскажу, как на Python с помощью модуля NLTK сделать простой генератор текстов. NLTK — мощная библиотека для работы с естественным языком, и один из классических способов использовать её, — это построить генератор на базе цепей Маркова.
Чем мы займёмся?
1. Возьмём текст — например, “Alice in Wonderland”.
2. Разделим его на слова.
3. Построим модель цепей Маркова: будем анализировать, какие слова чаще всего идут друг за другом.
4. Научим программу сочинять новые фразы — не хуже Льюиса Кэрролла!
Поехали!
### 1. Подготавливаем текст
import nltk
from nltk.corpus import gutenberg
nltk.download('gutenberg')
words = list(gutenberg.words('carroll-alice.txt'))
import random
def build_markov_chain(words):
chain = {}
for i in range(len(words) - 1):
curr_word = words[i]
next_word = words[i + 1]
if curr_word not in chain:
chain[curr_word] = []
chain[curr_word].append(next_word)
return chain
markov_chain = build_markov_chain(words)
def generate_text(chain, start_word, length=30):
curr_word = start_word
result = [curr_word]
for _ in range(length - 1):
next_words = chain.get(curr_word, None)
if not next_words:
break
curr_word = random.choice(next_words)
result.append(curr_word)
return ' '.join(result)
print(generate_text(markov_chain, 'Alice'))
Привет! С вами Иван. Сегодня мы разберём, как создавать случайные графы в Python с помощью замечательного модуля NetworkX. Представьте: вы моделируете социальные сети, исследуете транспортные маршруты или просто хотите попрактиковаться с алгоритмами на графах. Как быстро получить нужный граф? Легко, если вы знакомы с генераторами графов.
## Быстрое знакомство с NetworkX
NetworkX — один из самых популярных пакетов для работы с графами. С его помощью можно строить и анализировать любые графовые структуры — и, конечно, генерировать случайные графы для тестов или экспериментов.
## Пример 1: Случайный неориентированный граф Эрдёша-Реньи
Классика начинается с модели Эрдёша-Реньи. Здесь есть два параметра: количество вершин и вероятность появления ребра между каждой парой.
import networkx as nx
import matplotlib.pyplot as plt
n_nodes = 10
edge_prob = 0.3
G = nx.erdos_renyi_graph(n_nodes, edge_prob)
nx.draw_circular(G, with_labels=True)
plt.show()
gnp_random_graph с параметром directed=True.
n_nodes = 8
edge_prob = 0.4
DG = nx.gnp_random_graph(n_nodes, edge_prob, directed=True)
nx.draw_shell(DG, with_labels=True, arrows=True)
plt.show()
n_nodes = 15
edges_per_node = 2
BA = nx.barabasi_albert_graph(n_nodes, edges_per_node)
nx.draw_spring(BA, with_labels=True, node_color='orange')
plt.show()
Привет! Это Иван, и сегодня я хочу рассказать тебе про не совсем обычную штуку: как использовать свою библиотеку вместе с Hypothesis. Если ты когда-нибудь писал собственные функции или модули и задумался, “а как их тестировать по-настоящему?”, Hypothesis как раз даст мощный boost для твоих питонячьих тестов.
## Немного про Hypothesis
Hypothesis — это библиотека для property-based тестирования на Python. В отличие от классических юнит-тестов, она генерирует сотни разных входных данных, чтобы “поймать” неожиданные ошибки в твоем коде.
Окей, допустим, у тебя есть свой модуль — например, библиотека для работы с матрицами
mymatrix.py:
# mymatrix.py
def add_matrices(a, b):
return [[x + y for x, y in zip(row_a, row_b)]
for row_a, row_b in zip(a, b)]
pip install hypothesis
# test_mymatrix.py
from mymatrix import add_matrices
from hypothesis import given
from hypothesis.strategies import lists, integers
@given(
lists(lists(integers(), min_size=2, max_size=2), min_size=2, max_size=2),
lists(lists(integers(), min_size=2, max_size=2), min_size=2, max_size=2)
)
def test_add_matrices(matrix_a, matrix_b):
if len(matrix_a) != len(matrix_b):
return # Разные размеры не складываем
for row_a, row_b in zip(matrix_a, matrix_b):
if len(row_a) != len(row_b):
return # Разная длина строк — тоже пропускаем
result = add_matrices(matrix_a, matrix_b)
for i in range(len(matrix_a)):
for j in range(len(matrix_a[i])):
assert result[i][j] == matrix_a[i][j] + matrix_b[i][j]
return.
Это гораздо мощнее вручную написанных тестов:
- Ты не упустишь экзотические случаи, которые не пришли бы в голову!
- Если твоя функция выйдет за границы или возникнет исключение, Hypothesis все расскажет и покажет минимальный пример.
## А если своя библиотека сложная?
Ты можешь создать свои собственные стратегии генерации данных для любых сложных структур! Например, если твои объекты — это словари с обязательными и необязательными полями, Hypothesis вполне справится.
from hypothesis.strategies import composite
@composite
def custom_matrices(draw):
base = lists(integers(), min_size=3, max_size=3)
return [draw(base) for _ in range(3)]
{% block css %}
{% if request.endpoint == 'home' %}
<link rel="stylesheet" href="{{ url_for('static', filename='css/home.css') }}">
{% elif request.endpoint == 'about' %}
<link rel="stylesheet" href="{{ url_for('static', filename='css/about.css') }}">
{% endif %}
{% endblock %}macros.html:
{% macro render_nav_item(endpoint, text) %}
<li class="{% if request.endpoint == endpoint %}active{% endif %}">
<a href="{{ url_for(endpoint) }}">{{ text }}</a>
</li>
{% endmacro %}{% from "macros.html" import render_nav_item %}
<nav>
<ul>
{{ render_nav_item('home', 'Главная') }}
{{ render_nav_item('about', 'О нас') }}
</ul>
</nav>В Flask для разделения header и footer можно использовать шаблонизатор Jinja2. Вот как это организовать:
## Базовая структура проекта
myapp/
├── app.py
├── static/
│ ├── css/
│ │ ├── base.css
│ │ ├── home.css
│ │ └── about.css
│ └── js/
│ ├── base.js
│ ├── home.js
│ └── about.js
└── templates/
├── base.html
├── header.html
├── footer.html
├── home.html
└── about.html
## 1. Базовый шаблон (base.html)
<!DOCTYPE html>
<html lang="ru">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>{% block title %}Мой сайт{% endblock %}</title>
<!-- Базовые CSS -->
<link rel="stylesheet" href="{{ url_for('static', filename='css/base.css') }}">
<!-- Блок для дополнительных CSS -->
{% block css %}{% endblock %}
</head>
<body>
<!-- Подключаем header -->
{% include 'header.html' %}
<!-- Основное содержимое -->
<main>
{% block content %}{% endblock %}
</main>
<!-- Подключаем footer -->
{% include 'footer.html' %}
<!-- Базовые JS -->
<script src="{{ url_for('static', filename='js/base.js') }}"></script>
<!-- Блок для дополнительных JS -->
{% block js %}{% endblock %}
</body>
</html><header>
<nav>
<ul>
<li><a href="{{ url_for('home') }}">Главная</a></li>
<li><a href="{{ url_for('about') }}">О нас</a></li>
</ul>
</nav>
</header><footer>
<p>© 2024 Мой сайт. Все права защищены.</p>
</footer>{% extends "base.html" %}
{% block title %}Главная страница{% endblock %}
{% block css %}
<link rel="stylesheet" href="{{ url_for('static', filename='css/home.css') }}">
{% endblock %}
{% block content %}
<h1>Добро пожаловать на главную страницу!</h1>
<p>Это содержимое главной страницы.</p>
{% endblock %}
{% block js %}
<script src="{{ url_for('static', filename='js/home.js') }}"></script>
{% endblock %}{% extends "base.html" %}
{% block title %}О нас{% endblock %}
{% block css %}
<link rel="stylesheet" href="{{ url_for('static', filename='css/about.css') }}">
<!-- Можно добавить несколько CSS -->
<link rel="stylesheet" href="{{ url_for('static', filename='css/special.css') }}">
{% endblock %}
{% block content %}
<h1>О нашей компании</h1>
<p>Информация о компании...</p>
{% endblock %}
{% block js %}
<script src="{{ url_for('static', filename='js/about.js') }}"></script>
<!-- Можно добавить несколько JS -->
<script src="{{ url_for('static', filename='js/analytics.js') }}"></script>
{% endblock %}from flask import Flask, render_template
app = Flask(__name__)
@app.route('/')
def home():
return render_template('home.html')
@app.route('/about')
def about():
return render_template('about.html')
if __name__ == '__main__':
app.run(debug=True)* {
margin: 0;
padding: 0;
box-sizing: border-box;
}
body {
font-family: Arial, sans-serif;
line-height: 1.6;
}/* Стили только для главной страницы */
.hero {
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
color: white;
padding: 100px 0;
text-align: center;
}/* Стили только для страницы "О нас" */
.about-section {
padding: 50px 0;
background-color: #f8f9fa;
}@app.route('/')
def home():
return render_template('home.html',
page_title="Главная",
user="Иван")Привет! Я Иван, и сегодня мы поговорим про работу с форматом данных в Python — от знакомого CSV до YAML. Почему это важно? Почти все программы сегодня обмениваются данными, и понимание этих форматов существенно облегчает жизнь начинающему программисту.
### Парсим CSV как профи
CSV (Comma-Separated Values) встречается повсюду: от баз данных до выгрузок из «1С». Встроенный модуль
csv позволяет работать с этими файлами удобно и быстро.
import csv
with open('data.csv', mode='r', newline='') as file:
reader = csv.DictReader(file)
for row in reader:
print(row['name'], row['age'])
DictReader возвращает строки как словари: row['name'] – и все готово!
### JSON: Дружим с вебом
JSON — король обмена данными в интернете. В Python взаимодействие с ним интуитивно понятно:
import json
data = {'name': 'Ivan', 'active': True}
with open('data.json', 'w') as file:
json.dump(data, file)
with open('data.json', 'r') as file:
output = json.load(file)
print(output['name'])
json.dump и json.load.
### XML: Для любителей тегов
XML кажется устаревшим, но до сих пор встречается. Тут поможет xml.etree.ElementTree:
import xml.etree.ElementTree as ET
tree = ET.parse('data.xml')
root = tree.getroot()
for user in root.findall('user'):
print(user.find('login').text)
find и findall. Для небольших проектов чаще всего этого достаточно.
### YAML: Человечно и читаемо
YAML любят в мире DevOps и настройки сервисов за его читаемость. Для работы с YAML понадобится сторонний модуль PyYAML:
import yaml
data = {'project': 'Blog', 'contributors': ['Ivan', 'Alice']}
with open('config.yaml', 'w') as file:
yaml.dump(data, file)
with open('config.yaml') as file:
output = yaml.safe_load(file)
print(output['contributors'])
Привет, я Иван, и сегодня мы заглянем за кулисы магического модуля Python — asyncio. Представьте, что вы пишете программу, которая скачивает десятки файлов или постоянно получает сообщения с сервера. Если подходить к задаче привычно, ваш скрипт будет то и дело “замораживаться”, ведь стандартный ввод-вывод в Python синхронен — выполняется строго по очереди.
А теперь представьте: ваши задачи будто цирковые акробаты — работают параллельно, не мешая друг другу, и без лишних пауз. Вот тут на сцену и выходит asyncio!
## Немного теории: что такое asyncio и зачем он нужен
asyncio — это стандартный модуль Python, который позволяет писать асинхронный код. В отличие от потоков и процессов, асинхронность (или кооперативная многозадачность) позволяет выполнять множество ввода-вывода задач одновременно внутри одного потока. Все это управляется так называемым “циклом событий” (event loop). Каждая задача сообщает: “я жду, можешь обработать что-нибудь еще!”.
## Пример 1: Асинхронная задержка
Посмотрим на простой пример: одновременное ожидание с помощью asyncio.sleep().
import asyncio
async def print_after_delay(text, delay):
await asyncio.sleep(delay)
print(text)
async def main():
await asyncio.gather(
print_after_delay("Hello", 2),
print_after_delay("World!", 1)
)
asyncio.run(main())
aiohttp:
import asyncio
import aiohttp
async def fetch_status(url):
async with aiohttp.ClientSession() as session:
async with session.get(url) as response:
print(f"{url}: {response.status}")
async def main():
urls = [
"https://python.org",
"https://google.com",
"https://example.com"
]
tasks = [fetch_status(url) for url in urls]
await asyncio.gather(*tasks)
asyncio.run(main())
В Flask для разделения header и footer можно использовать шаблонизатор Jinja2. Вот как это организовать:
## Базовая структура проекта
myapp/
├── app.py
├── static/
│ ├── css/
│ │ ├── base.css
│ │ ├── home.css
│ │ └── about.css
│ └── js/
│ ├── base.js
│ ├── home.js
│ └── about.js
└── templates/
├── base.html
├── header.html
├── footer.html
├── home.html
└── about.html
## 1. Базовый шаблон (base.html)
<!DOCTYPE html>
<html lang="ru">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>{% block title %}Мой сайт{% endblock %}</title>
<!-- Базовые CSS -->
<link rel="stylesheet" href="{{ url_for('static', filename='css/base.css') }}">
<!-- Блок для дополнительных CSS -->
{% block css %}{% endblock %}
</head>
<body>
<!-- Подключаем header -->
{% include 'header.html' %}
<!-- Основное содержимое -->
<main>
{% block content %}{% endblock %}
</main>
<!-- Подключаем footer -->
{% include 'footer.html' %}
<!-- Базовые JS -->
<script src="{{ url_for('static', filename='js/base.js') }}"></script>
<!-- Блок для дополнительных JS -->
{% block js %}{% endblock %}
</body>
</html><header>
<nav>
<ul>
<li><a href="{{ url_for('home') }}">Главная</a></li>
<li><a href="{{ url_for('about') }}">О нас</a></li>
</ul>
</nav>
</header><footer>
<p>© 2024 Мой сайт. Все права защищены.</p>
</footer>{% extends "base.html" %}
{% block title %}Главная страница{% endblock %}
{% block css %}
<link rel="stylesheet" href="{{ url_for('static', filename='css/home.css') }}">
{% endblock %}
{% block content %}
<h1>Добро пожаловать на главную страницу!</h1>
<p>Это содержимое главной страницы.</p>
{% endblock %}
{% block js %}
<script src="{{ url_for('static', filename='js/home.js') }}"></script>
{% endblock %}{% extends "base.html" %}
{% block title %}О нас{% endblock %}
{% block css %}
<link rel="stylesheet" href="{{ url_for('static', filename='css/about.css') }}">
<!-- Можно добавить несколько CSS -->
<link rel="stylesheet" href="{{ url_for('static', filename='css/special.css') }}">
{% endblock %}
{% block content %}
<h1>О нашей компании</h1>
<p>Информация о компании...</p>
{% endblock %}
{% block js %}
<script src="{{ url_for('static', filename='js/about.js') }}"></script>
<!-- Можно добавить несколько JS -->
<script src="{{ url_for('static', filename='js/analytics.js') }}"></script>
{% endblock %}from flask import Flask, render_template
app = Flask(__name__)
@app.route('/')
def home():
return render_template('home.html')
@app.route('/about')
def about():
return render_template('about.html')
if __name__ == '__main__':
app.run(debug=True)* {
margin: 0;
padding: 0;
box-sizing: border-box;
}
body {
font-family: Arial, sans-serif;
line-height: 1.6;
}/* Стили только для главной страницы */
.hero {
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
color: white;
padding: 100px 0;
text-align: center;
}/* Стили только для страницы "О нас" */
.about-section {
padding: 50px 0;
background-color: #f8f9fa;
}@app.route('/')
def home():
return render_template('home.html',
page_title="Главная",
user="Иван")Привет, друзья! На связи Иван, и сегодня у нас настоящая находка для тех, кто хочет оживить свои Python-проекты — мы поговорим о Streamlit.
Streamlit — это библиотека, которая позволяет создавать интерактивные веб-приложения на Python буквально за считанные минуты. Не нужны ни знания фронтенда, ни написание HTML/CSS. Всё, что нужно — ваш привычный Python-код. А приложения можно запускать локально или выкладывать в интернет!
Минималистичный Hello World
Начнём с самого простого примера. Создадим страницу, которая выводит “Hello, Streamlit!”:
import streamlit as st
st.title("Hello, Streamlit!")
st.write("Это наше первое интерактивное приложение!")
app.py и запусти:
streamlit run app.pyОткроется браузер — и вуаля! У тебя уже есть полноценное приложение. Добавляем интерактивность Теперь добавим немного динамики. Представьте, что вы хотите построить график синуса — пользователь сам выбирает диапазон для оси X.
import streamlit as st
import numpy as np
import matplotlib.pyplot as plt
st.title("График синуса")
x_start = st.slider("Начало диапазона", 0, 10, 0)
x_end = st.slider("Конец диапазона", 1, 20, 10)
x = np.linspace(x_start, x_end, 100)
y = np.sin(x)
fig, ax = plt.subplots()
ax.plot(x, y)
st.pyplot(fig)
import streamlit as st
import pandas as pd
st.title("Загрузка данных")
uploaded_file = st.file_uploader("Выберите CSV-файл")
if uploaded_file is not None:
df = pd.read_csv(uploaded_file)
st.write("Первые 5 строк данных:")
st.write(df.head())
