Программирование сетевых взаимодействий с помощью сокетов в Python

Как передавать данные без установки соединения с помощью UDP?

UDP не требует установки соединения, данные отправляются датаграммами. Это быстрее, но ненадёжно.

import socket

server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
server.bind(('localhost', 8889))
print('UDP сервер запущен')

data, addr = server.recvfrom(1024)
print(f'Получено от {addr}: {data}')
server.sendto(b'Echo: ' + data, addr)

Python ipaddress ip network (модуль ipaddress в python)

import socket

client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
client.sendto(b'Hello UDP', ('localhost', 8889))
data, _ = client.recvfrom(1024)
print(f'Ответ: {data.decode()}')

Python сети (сетевые возможности python)

Особенности: recvfrom возвращает данные и адрес отправителя. sendto требует указания адреса назначения. Проблемы: потеря пакетов, дублирование, порядок не гарантируется.

Как не блокировать выполнение программы при ожидании данных с помощью неблокирующих сокетов?

Установка сокета в неблокирующий режим позволяет выполнять другие действия во время ожидания.

import socket

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.settimeout(0.0)  # или setblocking(False)
server.bind(('localhost', 8890))
server.listen(1)
server.setblocking(False)

while True:
    try:
        client, addr = server.accept()
        print(f'Подключение {addr}')
    except BlockingIOError:
        pass  # нет подключений
    # другие действия

Python network programming (сетевое программирование на python)

Неблокирующий режим выбрасывает исключение BlockingIOError, если операция не может быть выполнена сразу. Цель: интеграция в цикл событий, например, в графических приложениях.

Как обрабатывать несколько клиентов одновременно с помощью модуля selectors?

Модуль selectors предоставляет мультиплексирование ввода-вывода, позволяя одному потоку обслуживать множество сокетов.

import selectors
import socket

sel = selectors.DefaultSelector()

def accept(sock):
    conn, addr = sock.accept()
    conn.setblocking(False)
    sel.register(conn, selectors.EVENT_READ, read)

def read(conn):
    data = conn.recv(1024)
    if data:
        conn.sendall(data)
    else:
        sel.unregister(conn)
        conn.close()

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server.bind(('localhost', 8891))
server.listen(5)
server.setblocking(False)
sel.register(server, selectors.EVENT_READ, accept)

while True:
    events = sel.select()
    for key, mask in events:
        callback = key.data
        callback(key.fileobj)

Ip network python (работа с ip-сетями в python)

Код регистрирует серверный сокет на чтение. При подключении регистрируется новый клиент. Функции обратного вызова обрабатывают события. Цель: масштабирование на сотни клиентов в одном потоке.

Как использовать современные асинхронные возможности Python для сокетов с asyncio?

Модуль asyncio предоставляет высокоуровневый API для асинхронного ввода-вывода.

import asyncio

async def handle_client(reader, writer):
    data = await reader.read(1024)
    writer.write(data)
    await writer.drain()
    writer.close()

async def main():
    server = await asyncio.start_server(
        handle_client, 'localhost', 8892)
    async with server:
        await server.serve_forever()

asyncio.run(main())

import asyncio

async def tcp_client():
    reader, writer = await asyncio.open_connection('localhost', 8892)
    writer.write(b'Hello asyncio')
    await writer.drain()
    data = await reader.read(1024)
    print(f'Ответ: {data.decode()}')
    writer.close()

asyncio.run(tcp_client())

Пояснение: asyncio.start_server создаёт сервер, который автоматически обрабатывает множество подключений. Внутри корутины handle_client используется ожидание для неблокирующих операций. Цель: написание эффективных сетевых приложений с минимальной сложностью.

Как защитить передачу данных с помощью SSL/TLS сокетов?

Модуль ssl оборачивает обычный сокет в защищённый.

import socket
import ssl

# Сервер (требуется сертификат и ключ)
context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
context.load_cert_chain('cert.pem', 'key.pem')

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
    sock.bind(('localhost', 8443))
    sock.listen(5)
    with context.wrap_socket(sock, server_side=True) as ssock:
        conn, addr = ssock.accept()
        data = conn.recv(1024)
        conn.sendall(data)

import socket
import ssl

context = ssl.create_default_context()
context.check_hostname = False
context.verify_mode = ssl.CERT_NONE

with socket.create_connection(('localhost', 8443)) as sock:
    with context.wrap_socket(sock, server_hostname='localhost') as ssock:
        ssock.sendall(b'Hello SSL')
        print(ssock.recv(1024))

Важно: сервер должен иметь сертификат. Для теста можно сгенерировать самоподписанный. Клиент отключает проверку хоста. Цель: шифрование трафика.

Как организовать межпроцессное взаимодействие в одной системе с помощью Unix domain sockets?

Unix domain sockets (AF_UNIX) работают быстрее, так как не используют сетевой стек.

import socket
import os

socket_path = '/tmp/mysocket'
try:
    os.unlink(socket_path)
except FileNotFoundError:
    pass

server = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
server.bind(socket_path)
server.listen(1)

conn, _ = server.accept()
data = conn.recv(1024)
print(f'Получено: {data.decode()}')
conn.sendall(b'Hello from Unix socket')
conn.close()

import socket

client = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
client.connect('/tmp/mysocket')
client.sendall(b'Hi Unix')
print(client.recv(1024).decode())

Адрес - путь к файлу сокета. После завершения файл нужно удалить. Цель: быстрый обмен данными между процессами на одной машине.

Как обслуживать много клиентов с помощью многопоточного сервера?

Каждое подключение обрабатывается в отдельном потоке.

import socket
import threading

def handle_client(conn, addr):
    print(f'Поток запущен для {addr}')
    with conn:
        data = conn.recv(1024)
        conn.sendall(data)

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server.bind(('localhost', 8893))
server.listen(5)

while True:
    conn, addr = server.accept()
    thread = threading.Thread(target=handle_client, args=(conn, addr))
    thread.start()

Цель: простота реализации параллельной обработки. Проблемы: накладные расходы на потоки, GIL ограничивает вычислительные задачи, но для ввода-вывода потоки подходят.