Python для продолжающих

Программа курса:

Socket в Python

В мире компьютерных сетей, где данные перемещаются от одного устройства к другому, сокеты играют ключевую роль. Они представляют собой фундаментальный механизм, позволяющий приложениям общаться друг с другом по сети. В этой лекции мы рассмотрим, что такое сокеты, как их использовать в Python, как они работают и почему они так важны для понимания сетевых технологий.

Что такое Socket

Сокеты – это фундаментальный механизм сетевого взаимодействия, который позволяет приложениям общаться друг с другом по сети. Понимание концепции сокетов необходимо для любого разработчика, занимающегося созданием сетевых приложений. В следующих статьях мы рассмотрим различные типы сокетов, а также практические примеры их использования.

Представьте себе, что вы хотите отправить письмо своему другу. Вам нужно знать его адрес, чтобы почтальон мог доставить ваше письмо. В мире компьютерных сетей сокет можно сравнить с этим адресом, но для приложений.

Сокет (Socket) – это конечная точка сетевого соединения, которая позволяет приложениям отправлять и получать данные по сети. Он представляет собой уникальную комбинацию IP-адреса и номера порта на конкретном устройстве.

  • IP-адрес: Уникальный идентификатор устройства в сети (например, 192.168.1.100 или 2001:db8::1). Он определяет, куда нужно доставить данные.
  • Порт: Номер, идентифицирующий конкретное приложение или службу на этом устройстве (например, 80 для HTTP, 443 для HTTPS, 21 для FTP). Он определяет, какому приложению нужно доставить данные.

Таким образом, сокет можно представить как:

IP-адрес:Номер порта

Например:

192.168.1.100:80  // HTTP-сервер на устройстве с IP-адресом 192.168.1.100
2001:db8::1:443  // HTTPS-сервер на устройстве с IPv6-адресом 2001:db8::1

Чтобы лучше понять концепцию сокетов, можно провести аналогию с телефонным звонком:

  • IP-адрес – номер телефона: IP-адрес, как и номер телефона, однозначно идентифицирует устройство в сети (или абонента телефонной сети). Он позволяет нам установить связь с нужным устройством.
  • Порт – добавочный номер: Порт, как и добавочный номер, указывает на конкретное приложение или службу на этом устройстве. Если у вас есть номер телефона компании, но вы хотите связаться с конкретным отделом, вам нужен добавочный номер. Точно так же, если у вас есть IP-адрес сервера, но вы хотите связаться с конкретным приложением (например, веб-сервером), вам нужен номер порта.

Взаимодействие между приложениями по сети:

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

  1. Сервер: Приложение-сервер создает сокет и “слушает” определенный порт на своем IP-адресе. Это означает, что сервер ждет входящих соединений от клиентов.
  2. Клиент: Приложение-клиент создает сокет и пытается установить соединение с сервером, указывая IP-адрес и порт сервера.
  3. Установление соединения: Если сервер принимает соединение от клиента, между ними устанавливается сетевое соединение.
  4. Передача данных: После установления соединения приложения могут отправлять и получать данные друг от друга через сокеты. Данные обычно передаются в виде байтов.
  5. Закрытие соединения: После завершения обмена данными приложения закрывают свои сокеты, разрывая соединение.

Примеры использования:

  • Веб-серверы: Когда вы вводите URL-адрес в браузере, ваш браузер создает сокет и устанавливает соединение с веб-сервером на указанном IP-адресе и порту (обычно 80 или 443). Веб-сервер отправляет HTML-код страницы вашему браузеру через этот сокет.
  • Почтовые серверы: Когда вы отправляете электронное письмо, ваш почтовый клиент создает сокет и устанавливает соединение с почтовым сервером (например, SMTP-сервером). Почтовый клиент отправляет ваше письмо на почтовый сервер через этот сокет.
  • Онлайн-игры: Онлайн-игры используют сокеты для обмена данными между игроками и сервером игры.

В мире сокетного программирования выбор между TCP (Transmission Control Protocol) и UDP (User Datagram Protocol) - одно из ключевых решений, определяющих надежность, скорость и общую эффективность вашего сетевого приложения. Оба протокола используют сокеты для связи между приложениями, но подходят для совершенно разных сценариев. Давайте подробно рассмотрим различия между TCP и UDP и определим, когда какой протокол лучше использовать.

TCP – отличный выбор для приложений, где надежность и порядок доставки данных критически важны.

  • Передача файлов (FTP, SCP): При передаче файлов крайне важно, чтобы все данные были доставлены в целости и сохранности, и в правильном порядке. TCP гарантирует это, даже если в сети возникают проблемы.
  • Просмотр веб-страниц (HTTP, HTTPS): При просмотре веб-страниц важно, чтобы весь HTML-код, изображения и другие ресурсы были доставлены корректно, чтобы страница отображалась правильно. HTTPS также использует TCP для обеспечения безопасной передачи данных.
  • Электронная почта (SMTP, IMAP, POP3): При отправке и получении электронных писем важно, чтобы все данные были доставлены без потерь и искажений.
  • Удаленный доступ (SSH, Telnet): При удаленном доступе к компьютеру важно, чтобы все команды и ответы были переданы надежно.
  • Базы данных: Большинство баз данных используют TCP для связи между клиентом и сервером, чтобы гарантировать целостность данных.

Представьте себе, что вы скачиваете важный документ через FTP. Если в процессе скачивания часть данных будет потеряна, документ будет поврежден и бесполезен. TCP гарантирует, что все данные будут доставлены, даже если потребуется повторная отправка некоторых пакетов.

 

UDP – отличный выбор для приложений, где скорость важнее надежности, и где потеря небольшого количества данных не критична.

  • Видеостриминг: При потоковой передаче видео потеря небольшого количества кадров не сильно повлияет на качество изображения, но задержки в доставке данных могут привести к прерыванию воспроизведения. UDP позволяет передавать видео с высокой скоростью, жертвуя некоторой надежностью.
  • Онлайн-игры: В онлайн-играх важна низкая задержка, чтобы действия игрока мгновенно отображались на экране. Потеря небольшого количества пакетов данных о положении игрока или действиях не так критична, как задержка в передаче данных.
  • VoIP (Voice over IP): При передаче голоса по сети потеря небольшого количества пакетов может привести к небольшим искажениям звука, но задержки в доставке данных могут сделать разговор невозможным.
  • DNS (Domain Name System): DNS-запросы обычно отправляются по UDP, поскольку они небольшие и требуют быстрого ответа. Если DNS-ответ не получен, клиент может повторить запрос.
  • Широковещательные рассылки: UDP позволяет отправлять данные сразу нескольким получателям (широковещательная рассылка), что полезно для приложений, требующих одновременного оповещения большого количества устройств.

Представьте, что вы играете в онлайн-шутер. Важно, чтобы ваши действия (перемещение, стрельба) мгновенно отображались на экране других игроков. UDP позволяет передавать эти данные с минимальной задержкой, даже если иногда небольшое количество пакетов теряется.

Выбор между TCP и UDP зависит от конкретных требований вашего приложения. Если вам нужна надежность и гарантия порядка доставки данных, используйте TCP. Если вам важна скорость и вы готовы пожертвовать некоторой надежностью, используйте UDP.

Понимание этих различий поможет вам создавать более эффективные и надежные сетевые приложения.

 

Модуль socket в Python

Для работы с сокетами в Python используется модуль socket.

  • import socket

    Эта команда импортирует модуль socket, делая доступными все необходимые функции для работы с сокетами.

Основные функции модуля:

Модуль socket предоставляет множество функций, но мы сфокусируемся на самых важных:

  • socket.socket(): Создает новый сокет.

  • socket.bind(): Связывает сокет с определенным адресом и портом.

  • socket.listen(): Начинает прослушивание входящих соединений.

  • socket.accept(): Принимает входящее соединение.

  • socket.connect(): Устанавливает соединение с удаленным сервером.

  • socket.send(): Отправляет данные по сокету.

  • socket.recv(): Получает данные из сокета.

  • socket.close(): Закрывает сокет.

 

Создание TCP Socket в Python

Мы будем фокусироваться на TCP (Transmission Control Protocol), поскольку это наиболее распространенный протокол для надежной передачи данных.

  • s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    Эта строка создает TCP-сокет. Разберем параметры:

    • socket.AF_INET: Указывает, что мы используем IPv4 адреса.

    • socket.SOCK_STREAM: Указывает, что мы используем TCP, который обеспечивает надежную, упорядоченную и потоковую передачу данных.

Очень важно обрабатывать возможные ошибки при создании сокета. Используйте блоки try...except:

  • try:
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    print("Сокет успешно создан")
except socket.error as err:
    print("Ошибка создания сокета: %s" % (err))
    exit()

Серверная часть (TCP)

Серверная часть отвечает за прослушивание входящих соединений и обработку запросов от клиентов.

  • socket.bind((host, port)):

    host = 'localhost'  # Или '127.0.0.1'
port = 12345
s.bind((host, port))

    Привязывает сокет к определенному адресу и порту.

    • host: IP-адрес или имя хоста, на котором будет работать сервер. 'localhost'или '127.0.0.1' означает, что сервер будет доступен только на локальном компьютере. Если вы хотите, чтобы сервер был доступен извне, вам нужно указать публичный IP-адрес сервера.

    • port: Номер порта, на котором сервер будет прослушивать входящие соединения. Порты должны быть больше 1024 (порты от 0 до 1023 обычно зарезервированы для системных служб).

  • socket.listen(backlog):

    backlog = 5
s.listen(backlog)

    Начинает прослушивание входящих соединений. backlog – это максимальное количество ожидающих соединений. Если количество соединений превышает backlog, новые соединения будут отклонены.

  • socket.accept():

    conn, addr = s.accept()
print('Соединение установлено с:', addr)

    Принимает входящее соединение. Возвращает:

    • conn: Новый сокет, связанный с клиентом. Используйте этот сокет для обмена данными с клиентом.

    • addr: Адрес клиента (IP-адрес и номер порта).

  • socket.recv(buffersize):

    buffersize = 1024
data = conn.recv(buffersize)

    Получает данные от клиента. buffersize определяет максимальное количество байтов, которое можно получить за один раз.

  • socket.send(data):

    conn.sendall(data) # Отправляет все данные

    Отправляет данные клиенту. Важно использовать sendall() вместо send(), чтобы убедиться, что все данные отправлены. send() может отправить только часть данных.

  • socket.close():

    conn.close() # Закрываем соединение с клиентом
s.close() # Закрываем сокет сервера

    Закрывает сокет. Важно закрывать сокеты после завершения работы с ними, чтобы освободить ресурсы.

Клиентская часть (TCP)

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

  • socket.connect((host, port)):

    host = 'localhost'  # Или '127.0.0.1'
port = 12345
s.connect((host, port))

    Устанавливает соединение с сервером. host и port должны соответствовать адресу и порту, на котором прослушивает сервер.

  • socket.send(data):

    message = "Привет, сервер!"
s.sendall(message.encode('utf-8'))

    Отправляет данные серверу. Не забудьте закодировать данные в байты.

  • socket.recv(buffersize):

    buffersize = 1024
data = s.recv(buffersize)
print('Получено от сервера:', data.decode('utf-8'))

    Получает данные от сервера. Не забудьте декодировать данные из байтов.

  • socket.close():

    s.close()

    Закрывает сокет.

     

Примеры кода TCP Socket на Python

Простой эхо-сервер (повторяет полученные данные):

  • server.py:

    import socket

HOST = 'localhost'
PORT = 12345

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.bind((HOST, PORT))
    s.listen()
    conn, addr = s.accept()
    with conn:
        print('Соединение установлено с:', addr)
        while True:
            data = conn.recv(1024)
            if not data:
                break
            conn.sendall(data)

    client.py:

    import socket

HOST = 'localhost'
PORT = 12345

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.connect((HOST, PORT))
    message = "Привет, эхо-сервер!"
    s.sendall(message.encode('utf-8'))
    data = s.recv(1024)
    print('Получено от сервера:', data.decode('utf-8'))

Первым делом запустим сервер в терминале:

python server.py

И в новом окне терминала запустим клиента:

python client.py

И после запуска клиента мы увидим следующее сообщение:

Получено от сервера: Привет, эхо-сервер!

А в терминале сервера мы получим ответ, что соединение было установлено:

Соединение установлено с: ('127.0.0.1', 49329)

Обратите внимание на with, эта конструкция with socket.socket(...) as s:обеспечивает автоматическое закрытие сокета (s.close()) после завершения работы блока with. Это очень удобно и позволяет избежать утечек ресурсов.

Кодирование и Декодирование Данных

  • Необходимость кодирования данных в байты перед отправкой:

    message = "Привет!"
message_bytes = message.encode('utf-8')
s.sendall(message_bytes)

    Сокеты работают с байтами. Перед отправкой строки необходимо преобразовать ее в последовательность байтов с помощью метода encode().

  • Декодирование полученных данных из байтов в строку:

    data_bytes = s.recv(1024)
message = data_bytes.decode('utf-8')
print(message)

    После получения данных в виде байтов, необходимо преобразовать их обратно в строку с помощью метода decode().

  • Выбор кодировки (UTF-8 – наиболее распространенный):

    UTF-8 – наиболее распространенная кодировка для представления текста. Она поддерживает широкий спектр символов и является совместимой с большинством систем. Однако, в зависимости от требований вашего приложения, вы можете использовать другие кодировки, такие как ASCII, Latin-1 или UTF-16.

Очень важно обрабатывать ошибки, которые могут возникнуть при работе с сокетами.

  • Использование try...except блоков для обработки исключений:

    import socket

HOST = 'localhost'
PORT = 12345

try:
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
        s.bind((HOST, PORT))
        s.listen()
        conn, addr = s.accept()
        with conn:
            print('Соединение установлено с:', addr)
            while True:
                data = conn.recv(1024)
                if not data:
                    break
                conn.sendall(data)
except socket.error as e:
    print(f"Ошибка сокета: {e}")
except ConnectionRefusedError as e:
    print(f"Ошибка подключения: {e}")
except TimeoutError as e:
    print(f"Таймаут соединения: {e}")
except Exception as e:
    print(f"Непредвиденная ошибка: {e}")
finally:
    if 's' in locals():
        s.close()
    if 'conn' in locals():
        conn.close()

  • Примеры обработки различных типов ошибок:

    • socket.error: Общая ошибка сокета.

    • ConnectionRefusedError: Сервер отказался принять соединение. Это может произойти, если сервер не запущен или не прослушивает указанный порт.

    • TimeoutError: Таймаут соединения. Это может произойти, если соединение не было установлено в течение определенного времени.

    • BlockingIOError: Сокет находится в неблокирующем режиме и операция не может быть выполнена немедленно. (Чаще встречается при работе с неблокирующими сокетами, что является более продвинутой темой.)

 

Работа с UDP Сокетами в Python

В отличие от TCP, UDP является протоколом без установления соединения (connectionless). Это означает, что перед отправкой данных не требуется устанавливать специальное соединение между клиентом и сервером. Данные просто отправляются в виде независимых пакетов (датаграмм) по сети.

Преимущества UDP:

  • Быстрота: Отсутствие установления соединения и подтверждения доставки делает UDP быстрее, чем TCP.
  • Меньшая нагрузка: Меньше служебной информации (overhead) в заголовках пакетов.

Недостатки UDP:

  • Ненадежность: Данные могут быть потеряны, дублированы или доставлены в неправильном порядке. UDP не предоставляет механизмов для восстановления потерянных пакетов или упорядочивания их.
  • Отсутствие гарантии доставки: Нельзя быть уверенным, что пакет достигнет получателя.

 

Создание UDP cокетов в Python

Для работы с UDP в Python, как и с TCP, используется модуль socket.

  • socket.socket(socket.AF_INET, socket.SOCK_DGRAM):

    import socket

s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

    Эта строка создает UDP-сокет.

    • socket.AF_INET: Указывает на использование IPv4 адресов.
    • socket.SOCK_DGRAM: Указывает на использование UDP протокола. DGRAMрасшифровывается как Datagram, что отражает суть UDP.

Серверная часть (UDP)

  • socket.bind((host, port)):

    HOST = 'localhost'
PORT = 12345

s.bind((HOST, PORT))

    Привязывает сокет к определенному адресу и порту. Сервер будет прослушивать входящие UDP-пакеты на этом адресе и порту.

  • socket.recvfrom(buffersize):

    BUFFER_SIZE = 1024
data, address = s.recvfrom(BUFFER_SIZE)
print(f"Получено сообщение '{data.decode('utf-8')}' от {address}")

    Получает данные и адрес клиента, отправившего данные.

    • data: Полученные данные (в виде байтов).
    • address: Адрес клиента (IP-адрес и номер порта).
    • buffersize: Максимальный размер буфера для приема данных. Важно выбрать размер, достаточный для приема ожидаемых UDP-пакетов.

  • socket.sendto(data, address):

    message = "Эхо: " + data.decode('utf-8')
s.sendto(message.encode('utf-8'), address)

    Отправляет данные клиенту по указанному адресу. Адрес клиента был получен при вызове recvfrom().

  • socket.close():

    s.close()

    Закрывает сокет.

Клиентская часть (UDP)

  • socket.sendto(data, (host, port)):

    HOST = 'localhost'
PORT = 12345
MESSAGE = "Привет, UDP сервер!"

s.sendto(MESSAGE.encode('utf-8'), (HOST, PORT))

    Отправляет данные серверу. Указывается адрес и порт сервера. Здесь не нужно предварительно устанавливать соединение.

  • socket.recvfrom(buffersize) (опционально):

    BUFFER_SIZE = 1024
data, address = s.recvfrom(BUFFER_SIZE)
print(f"Получено сообщение '{data.decode('utf-8')}' от {address}")

    Этот вызов необязателен. Он позволяет клиенту получить ответ от сервера. Например, в нашем эхо-сервере клиент получает повторенное сообщение от сервера. Обратите внимание, что клиент не обязан получать ответ. UDP позволяет отправлять данные в одном направлении.

  • socket.close():

    s.close()

    Закрывает сокет.

Примеры кода UDP Socket на Python

Простой UDP-сервер, повторяющий полученные данные:

  • server.py:

    import socket

HOST = 'localhost'
PORT = 12345
BUFFER_SIZE = 1024

s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.bind((HOST, PORT))

print(f"UDP сервер запущен на {HOST}:{PORT}")

while True:
    data, address = s.recvfrom(BUFFER_SIZE)
    message = "Эхо: " + data.decode('utf-8')
    s.sendto(message.encode('utf-8'), address)
    print(f"Отправлено эхо-сообщение '{message}' клиенту {address}")

    client.py:

    import socket

HOST = 'localhost'
PORT = 12345
MESSAGE = "Привет, UDP сервер!"
BUFFER_SIZE = 1024

s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.sendto(MESSAGE.encode('utf-8'), (HOST, PORT))
data, address = s.recvfrom(BUFFER_SIZE) # Ждем ответа от сервера
print(f"Получено сообщение '{data.decode('utf-8')}' от {address}")
s.close()

В коде выше мы реализовали простой UDP-клиент, отправляющий сообщение на сервер. Если вам нужен клиент, который просто отправляет сообщение и не ждет ответа, уберите строки с recvfrom.


 Сценарии использования UDP

  • DNS-запросы: Быстрые, небольшие запросы. Потеря пакета менее критична, так как запрос можно повторить.
  • Видеостриминг: Допустима небольшая потеря кадров, главное - скорость передачи. Более важным является поддержание постоянного потока данных, чем гарантия доставки каждого пакета.
  • Онлайн-игры: Важна низкая задержка, даже если иногда теряются пакеты с информацией о положении игрока. Игровые приложения часто используют UDP для передачи данных о состоянии игры, положении персонажей и других динамических параметрах.

 

Итоги:

Мы рассмотрели фундаментальные концепции, начиная с основ работы с модулем socket, и разобрали примеры реализации как TCP, так и UDP соединений. Мы изучили, как создавать серверную и клиентскую части, обмениваться данными между ними, кодировать и декодировать информацию для передачи по сети, а также обрабатывать возникающие ошибки.

Резюме основных моментов:

  • socket – основной модуль для сетевого программирования в Python.
  • TCP предоставляет надежную передачу данных с установлением соединения, идеально подходящую для приложений, требующих гарантии доставки.
  • UDP, напротив, обеспечивает более быструю, но менее надежную передачу данных без установления соединения, что делает его хорошим выбором для приложений, где скорость важнее надежности (например, потоковое видео или онлайн-игры).
  • Необходимость кодирования и декодирования данных (например, с использованием UTF-8) для правильной передачи текстовой информации.
  • Важность обработки исключений для создания стабильных и отказоустойчивых сетевых приложений.

Перейти к следующему шагу

Возникли вопросы при прочтении лекции? Задайте вопрос в комментариях

Комментарии