Python для новичков

Вы когда-нибудь оказались в ситуации, когда нужно сгенерировать отчет с сотнями строк данных, а затем каждую неделю обновлять его вручную? Excel зависает, числа в глазах двоятся, а дедлайны дышат в затылок. В такой момент Python становится супергероем офисной автоматизации. Сегодня я покажу, как автоматизировать создание и обновление отчетов с помощью Python — быстро, просто и без боли. На помощь приходят проверенные бойцы: pandas, openpyxl и matplotlib. Они помогут работать с данными, редактировать Excel-файлы и даже строить графики. Начнем с простого отчета: есть CSV-файл с продажами по регионам, нам нужно собрать сумму продаж, построить график и сохранить всё это в Excel-отчет. Пример исходных данных в sales.csv: region,date,sales North,2024-05-01,1200 South,2024-05-01,950 North,2024-05-02,1340 ... и так далее. Сначала читаем и обрабатываем данные:

    
        import pandas as pd

data = pd.read_csv("sales.csv", parse_dates=["date"])
summary = data.groupby("region")["sales"].sum().reset_index()
{}
    

Хотим добавить график, чтобы отчет был не только полезный, но и красивый? Без проблем:

    
        import matplotlib.pyplot as plt

plt.figure(figsize=(6, 4))
plt.bar(summary["region"], summary["sales"], color="skyblue")
plt.title("Sales by Region")
plt.xlabel("Region")
plt.ylabel("Total Sales")
plt.tight_layout()
plt.savefig("sales_chart.png")
plt.close()
{}
    

Теперь создаем Excel-файл с таблицей и вставляем туда наш график:

    
        from openpyxl import Workbook
from openpyxl.drawing.image import Image
from openpyxl.utils.dataframe import dataframe_to_rows

wb = Workbook()
ws = wb.active
ws.title = "Sales Report"

# Вставляем таблицу
for row in dataframe_to_rows(summary, index=False, header=True):
    ws.append(row)

# Вставляем картинку с графиком
img = Image("sales_chart.png")
img.anchor = "E2"  # координаты вставки
ws.add_image(img)

wb.save("sales_report.xlsx")
{}
    

Что получилось: из CSV-файла мы автоматически получили сводную таблицу по регионам, построили визуализацию и сохранили все это в виде Excel-файла. Всё генерируется буквально за секунды. Можно запускать этот скрипт каждый день или неделю через планировщик задач — и больше не мучиться с отчетами вручную. Если добавить немножко логики — например, проверку за какую дату данные, или отправку итогового файла по email через smtplib — автоматизация выходит на новый уровень. Python не просто сокращает время, он освобождает его. Отчеты, которые раньше отнимали часы, можно теперь генерировать в одно касание. И вместо унылого копирования цифр — больше времени на анализ, развитие и создание чего-то действительно важного.

Хотите,чтобы ваши цели исполнялись, а жизнь шла по выбранному вами пути? Подписывайтесь: https://t.me/consciousreal

Привет, друзья! Сегодня нырнем в мир асинхронности и узнаем, как Python-тюлень превращается в сетевую торпеду благодаря библиотеке asyncio. Если вы когда-либо писали сетевые приложения и сталкивались с болью от блокирующего кода — добро пожаловать в будущее, где одна корутина может сделать больше, чем десять потоков на слабом ноутбуке. Что же такое asyncio? Это современный подход к асинхронному программированию в Python. Он позволяет запускать несколько задач одновременно без реального многопоточия — за счёт кооперативной многозадачности. Это идеальный выбор для I/O-зависимых задач: работы с сетью, файлами, сокетами и базами данных. Рассмотрим пример простого TCP-сервера, который обрабатывает клиентские соединения асинхронно: import asyncio async def handleclient(reader, writer): addr = writer.getextrainfo('peername') print(f"Connected: {addr}") while True: data = await reader.readline() if not data: break message = data.decode().strip() print(f"Received from {addr}: {message}") response = f"Echo: {message}\n" writer.write(response.encode()) await writer.drain() print(f"Disconnected: {addr}") writer.close() await writer.waitclosed() async def main(): server = await asyncio.startserver(handleclient, '127.0.0.1', 8888) addr = server.sockets0.getsockname() print(f"Serving on {addr}") async with server: await server.serveforever() asyncio.run(main()) Этот код запускает асинхронный TCP-сервер на порту 8888. При подключении клиента создается новая корутина handleclient. Вместо блокирующих операций чтения/записи мы используем await reader.readline() и await writer.drain(), позволяя другим задачам выполняться между ожиданиями. Чем это лучше, скажете вы? Ну, во-первых — экономия ресурсов. Вместо того чтобы спаунить потоки и платить за переключение контекста (и риск словить GIL), asyncio даёт нам лёгкие задачи внутри одного потока. Во-вторых — читаемость. Вместо колбэков и адской вложенности в стиле JavaScript времён динозавров, у нас есть async/await — лаконично и выразительно. Допустим, вы хотите написать клиент, который периодически шлёт сообщения серверу: async def tcpechoclient(): reader, writer = await asyncio.openconnection('127.0.0.1', 8888) for i in range(5): message = f"Hello {i}\n" writer.write(message.encode()) await writer.drain() response = await reader.readline() print(f"Received: {response.decode().strip()}") await asyncio.sleep(1) writer.close() await writer.waitclosed() asyncio.run(tcpechoclient()) Это уже мини-болталка: клиент отправляет сообщения, сервер эхо-отвечает. Всё асинхронно и без блокировок! А если подключатся десятки клиентов? Никаких проблем — asyncio справится, пока вы не начнете жарить процессор тяжёлыми вычислениями. Тут уже стоит подумать об asyncio + multiprocessing или выносить нагрузку в отдельные сервисы. А как быть с тайм-аутами, отменой задач и очередями? Тут тоже всё продумано: asyncio предоставляет объекты Future, Task и Queue, которые позволяют строить настоящие архитектуры. И, да, в реальных проектах часто используются такие фреймворки, как aiohttp (асинхронный HTTP-сервер и клиент) или websockets — они расширяют возможности asyncio, сохраняя модели async/await. asyncio — это мощный инструмент, который делает написание сетевых приложений в Python одновременно простым, эффективным и масштабируемым. Если вы до сих пор пишете blocking-сокеты — самое время пересесть на асинхронный экспресс. До встречи в следующих постах, где мы разберём, как с помощью aiohttp строить REST API, не теряя скорости даже под нагрузкой.

На этой неделе я решил затронуть тему, которая волнует многих начинающих разработчиков: создание собственной системы управления контентом (CMS) на Django. Часто при изучении фреймворка мы учимся делать блоги, страницы и формы. Но что, если попробовать сделать нечто большее — свою CMS? Управляемый контент, возможность редактирования без кода, гибкое расширение — звучит вдохновляюще? Тогда поехали. С чего начать? Django уже практически готов для построения CMS. У него есть админка, модели, формы, авторизация, шаблоны — всё, что нужно новичку для уверенного старта. Создадим базу: установим Django и создадим проект.

    
        django-admin startproject cms_project
cd cms_project
python manage.py startapp core
{}
    

В core создаём первую модель — ContentPage:

    
        from django.db import models

class ContentPage(models.Model):
    title = models.CharField(max_length=200)
    slug = models.SlugField(unique=True)
    body = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.title
{}
    

Подключим её в админку:

    
        from django.contrib import admin
from .models import ContentPage

admin.site.register(ContentPage)
{}
    

Теперь, зайдя в admin-панель, можно добавлять страницы с уникальным slug и текстом. Но наша цель — чтобы эти страницы отдавались по соответствующему URL, не создавая вручную views под каждую. Создаём "умный" view:

    
        from django.shortcuts import get_object_or_404, render
from .models import ContentPage

def content_page_view(request, slug):
    page = get_object_or_404(ContentPage, slug=slug)
    return render(request, 'core/page.html', {'page': page})
{}
    

И URL-шаблон:

    
        from django.urls import path
from .views import content_page_view

urlpatterns = [
    path('<slug:slug>/', content_page_view, name='content_page'),
]
{}
    

Всё. Теперь любой контент с определённым slug — например, "about" — будет доступен по адресу /about/. Но что, если хотим, чтобы администратор мог задавать не только текст, но и типы блоков? Представим блок "цитата", "изображение + текст", "галерея". Решение: отдельные модели блоков.

    
        class PageBlock(models.Model):
    page = models.ForeignKey(ContentPage, related_name='blocks', on_delete=models.CASCADE)
    block_type = models.CharField(max_length=50, choices=[
        ('text', 'Text'),
        ('quote', 'Quote'),
        ('image', 'Image'),
    ])
    content = models.TextField()
    order = models.PositiveIntegerField(default=0)

    class Meta:
        ordering = ['order']
{}
    

Теперь страницы можно собирать как конструктор: добавлять разнообразные блоки, управлять их порядком. Через админку пользователь собирает страницу сам, без кода. В шаблоне просто итерируем blocks и отображаем нужный HTML под каждый тип:

    
        {% for block in page.blocks.all %}
  {% if block.block_type == 'text' %}
    <p>{{ block.content }}</p>
  {% elif block.block_type == 'quote' %}
    <blockquote>{{ block.content }}</blockquote>
  {% elif block.block_type == 'image' %}
    <img src="{{ block.content }}" alt="Image block">
  {% endif %}
{% endfor %}
{}
    

Хочется вложений страниц, как у real CMS? Добавим parent-связь в ContentPage и дорисуем древовидную структуру — можно с помощью django-mptt. Хотим редактор, вместо plain TextField? Подключаем django-ckeditor и получаем визуальную обработку контента. В этой архитектуре вся мощь CMS оказывается в руках администратора: он создаёт новые страницы, меняет их, комбинирует блоки — без программирования. Мы же, как разработчики, создаём каркас и логику. Таким образом, используя стандартный инструментарий Django, мы получаем лёгкую, настраиваемую и расширяемую CMS. Не надо ждать "идеальную" CMS от третьих лиц — можно построить свою. Понятную, минималистичную и под конкретные задачи. И это, по моему личному опыту, куда ценнее универсальных монстров.

Как написать игру змейка на Python

🚀 Друзья, если вы только начинаете осваивать Python или уже перешли к фреймворкам и сложным бибилотекам, вам помогут авторские материалы многолетнего разработчика и преподавателя Python Дмитрия Читалова. Уже размещены: ✅Основы Python ✅Алгоритмы и структуры данных ✅Паттерны проектирования на Python ❗️Сейчас еженедельно выкладываются новые материалы, разбираются вопросы с собеседований Подписаться можно здесь.

Как разрабатывать VPN-приложения на основе Python VPN — это не просто модный термин из мира информационной безопасности. Это реальный рабочий механизм, который позволяет шифровать трафик, обходить блокировки и защищать соединение в публичных сетях. Интересно, что с помощью Python можно построить простое VPN-приложение буквально с нуля — и это совсем не магия, а знание и немного кода. Основная идея VPN — создание защищённого туннеля между клиентом и сервером, внутри которого весь сетевой трафик проходит в зашифрованном виде. В Python мы можем реализовать подобную функциональность, используя стандартные библиотеки socket и ssl, а также сторонние — такие как pycryptodome для дополнительного шифрования. Начнем с основы — создадим шифрованное TCP-соединение. Допустим, у нас есть клиент и сервер, которые общаются по TLS: Пример серверной части:

    
        import socket
import ssl

context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
context.load_cert_chain(certfile='cert.pem', keyfile='key.pem')

bind_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
bind_socket.bind(('0.0.0.0', 9000))
bind_socket.listen(5)

while True:
    new_socket, addr = bind_socket.accept()
    conn = context.wrap_socket(new_socket, server_side=True)
    data = conn.recv(1024)
    print(f"Received: {data}")
    conn.sendall(b'Encrypted Hello from VPN Server!')
    conn.close()
{}
    

Пример клиента:

    
        import socket
import ssl

context = ssl.create_default_context()
conn = context.wrap_socket(socket.socket(socket.AF_INET), server_hostname='localhost')
conn.connect(('localhost', 9000))
conn.sendall(b'Hello from Client')
print(f"Server says: {conn.recv(1024)}")
conn.close()
{}
    

Это уже зашифрованное соединение! На более высоком уровне мы можем добавить маршрут через этот туннель, используя iptables на Linux или прокси-настройки на других системах. Но стоит заметить: этот способ безопасен только внутри локального проекта, для полноценного VPN нужны туннелирование на уровне IP (например, средствами TUN/TAP). Для работы с такими интерфейсами в Python можно использовать модуль pyroute2 (работает под Linux). Вот пример настройки туннеля:

    
        from pyroute2 import IPRoute
ip = IPRoute()
idx = ip.link_create(ifname='tun0', kind='tun')
ip.addr('add', index=idx, address='10.0.0.1', prefixlen=24)
ip.link('set', index=idx, state='up')
{}
    

Создав интерфейс, можно направлять трафик через него и обрабатывать поступающие IP-пакеты с помощью raw-сокетов. Например, чтобы захватить пакеты и переслать через защищённый TCP, мы можем использовать socket.socket с типом socket.SOCK_RAW. Дополнительно, для шифрования полезной нагрузки можно подключить AES:

    
        from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes

key = get_random_bytes(16)
cipher = AES.new(key, AES.MODE_EAX)

data = b'Secret payload'
ciphertext, tag = cipher.encrypt_and_digest(data)
print(ciphertext)
{}
    

Таким образом, VPN-приложение на Python может включать в себя: - шифрованный TCP-туннель (через ssl); - работу с сетевыми интерфейсами (через pyroute2); - обработку и маршрутизацию IP-пакетов (через raw-сокеты и TUN); - шифрование всех данных (через pycryptodome). Конечно, это всё требует продуманной архитектуры, обработки ошибок и аутентификации. Настоящий VPN — больше, чем просто код: это защита всего маршрута данных. Но начать проще, чем кажется. Python даёт достаточный инструментарий, чтобы понимать, как всё устроено на самом деле. Звучит как вызов? Отлично. Потому что любой хороший девелопер любит разбираться в инфраструктуре, не только писать логику веб-приложений. VPN на Python — это именно тот случай, когда ты понимаешь, как работает интернет изнутри.

Python — язык, который поощряет чистоту, читаемость и элегантность. И одно из самых мощных проявлений этих качеств — конструкции контекстного менеджмента. Возможно, ты уже встречал волшебное слово with, но не совсем понимал, что именно происходит под капотом. Давай разберёмся. Представим себе файл. Мы его открываем, читаем, а потом… забываем закрыть. Вроде бы ничего страшного — но если таких забытых файлов десятки, появляются утечки ресурсов. Контекстные менеджеры помогают гарантировать, что нужные действия будут выполнены автоматически, даже если в процессе произойдёт ошибка. Базовый пример: with open('data.txt', 'r') as file: content = file.read() После выхода из блока with Python сам вызовет file.close(). Удобно и безопасно. Но фокус в том, что можно писать свои контекстные менеджеры! Чтобы понять, как это работает, вспомним о двух магических методах: - enter() - exit() Создадим простой таймер: import time class Timer: def enter(self): self.start = time.time() return self def exit(self, exctype, excval, exctb): self.end = time.time() print(f'Time elapsed: {self.end - self.start:.4f} seconds') Теперь используем: with Timer(): total = sum(i**2 for i in range(1000000)) Контекст открылся, засеклось время. После выхода — замер завершился, результат выведен. Но писать собственные классы с enter и exit — не всегда удобно. Тут приходит модуль contextlib. Он предлагает простой способ создавать менеджеры контекста из функций. Пример с contextlib.contextmanager: from contextlib import contextmanager @contextmanager def changedirectory(path): import os prevdir = os.getcwd() os.chdir(path) try: yield finally: os.chdir(prevdir) Вот такой элегантный способ временно сменить директорию: with changedirectory('/tmp'): print('We are here:', os.getcwd()) После выхода — возвращаемся туда, откуда пришли. Даже если внутри блока произойдёт исключение. А теперь чуть более продвинутый трюк: подавление ошибок. Модуль contextlib помогает снова: from contextlib import suppress with suppress(ZeroDivisionError): print(1 / 0) # Ошибка будет проигнорирована Очень полезно, когда есть неважные операции, которые могут не сработать, и их не хочется оборачивать в try/except. И наконец: если ты работаешь с ресурсами — файлами, соединениями, блокировками — знай, что многие библиотеки уже поддерживают контекстные менеджеры. Например, threading.Lock: import threading lock = threading.Lock() with lock: # безопасный доступ к ресурсу dosomething() Безопасность, лаконичность, надёжность — вот за что мы любим with. Он делает код чище и устойчивее к ошибкам. А знание, как писать свои менеджеры контекста, открывает путь к по-настоящему выразительному Python-коду.

Дорога до вуза, задания, встречи с друзьями...Где найти энергию на все? 🤯 Lamoda поможет не тратить силы на лишнее — работай удаленно или в гибридном формате на новой оплачиваемой стажировке! 😎 Подавай заявку до 16 мая, чтобы воспользоваться и другими комфортными условиями: 👇 — зарплатой 90 000 или 65 000 рублей в зависимости от направления — гибким графиком: работай от 30 часов в неделю — полезными бенефитами: ДМС для экстренных случаев, корпоративными скидками, обучением и другим — карьерными перспективами: ты сможешь остаться в штате Lamoda Переходи на сайт — там ты найдешь еще больше крутых преимуществ работы в Lamoda! https://vk.cc/cLCw1y?erid=2W5zFHmxvrU