Python – простой, гибкий и невероятно популярный язык, который используется практически во всех областях современной разработки. С его помощью можно создавать веб-приложения, писать игры, заниматься анализом данных, автоматизировать задачи системного администрирования и многое другое. “Погружение в Python” читают разработчики, применяющие Python в проектах, которыми ежедневно пользуются миллионы людей. Курс покрывает все необходимые для ежедневной работы программиста темы, а также рассказывает про многие особенности языка, которые часто опускают при его изучении. В ходе курса вы изучите конструкции языка, типы и структуры данных, функции, научитесь применять объектно-ориентированное и функциональное программирование, узнаете про особенности реализации Python, научитесь писать асинхронный и многопоточный код. Помимо теории вас ждут практические задания, которые помогут проверить полученные знания и отточить навыки программирования на Python. После успешного окончания курса вы сможете использовать полученный опыт для разработки проектов различной сложности.
Сокеты, клиент-сервер
Loading...
From the course by Moscow Institute of Physics and Technology
Погружение в Python
602 ratings
Moscow Institute of Physics and Technology
602 ratings
Course 1 of 4 in the Specialization Программирование на Python
From the lesson
Многопоточное и асинхронное программирование.
Пятая неделя посвящена одной из самых актуальных тем современного мира разработки — асинхронному и многопоточному программированию. Вы узнаете про процессы и потоки, а также научитесь писать асинхронный код с помощью asyncio.
Meet the Instructors
Александр ЕмелинMail.Ru Group, преподаватель МГТУ им. Н. Э. Баумана
Александр ЖебракТехнический директор Insilico Medicine
Дмитрий ШвеенковMail.Ru Group, руководитель команды разработки
В предыдущих видеоуроках мы рассмотрели то,
как устроены процессы и потоки в Python.
В следующих видеолекциях мы будем изучать то,
как устроены сокеты и как работают сетевые программы,
и те знания, которые мы приобрели в предыдущих видеоуроках,
понадобятся нам для организации взаимодействия по сети.
Итак, давайте разберем, что такое сокеты, как они устроены
и попробуем написать свою первую программу клиент-сервер,
которая будет обмениваться данными между собой.
Сокеты — это, прежде всего, кросс-платформенный механизм
для обмена данными между отдельными процессами.
Эти процессы могут работать на разных серверах,
они могут быть написаны на разных языках, и, прежде всего,
программа на Python, которая использует механизм сокетов,
она осуществляет системные вызовы
и взаимодействие с ядром операционной системы.
Как правило, для организации сетевого взаимодействия
нужен сервер, который изначально создает некое соединение
и начинает «слушать» все запросы, которые поступают в него
и программа-клиент, которая присоединяется к серверу
и отправляет ему нужные данные.
Давайте рассмотрим пример серверной программы.
Для того чтобы создать сокет,
мы должны импортировать модуль socket.
Далее мы должны создать объект типа socket из модуля socket.
В него необходимо передать некоторые параметры.
В данном случае это некоторое семейство
— мы используем address family,
мы используем конкретную константу AF_INET, а также тип сокета.
В данном примере мы используем потоковый сокет.
Полную информацию по типам сокетов, по типам address family
можно посмотреть в документации на Python,
либо в документации про то,
как устроена сеть в операционной системе Linux.
Итак, мы создали объект socket — это потоковый сокет.
Далее мы должны вызвать метод bind.
В метод bind мы должны передать некую адресную пару — это host,
в данном случае мы передаем 127.0.0.1,
и порт 127.0.0.1 будет означать, что наш сервер будет слушать
все входящие соединения только локально на одной машине.
Если мы укажем пустую строчку, либо адрес 0.0.0.0,
то наш сервер будет слушать входящие соединения со всех интерфейсов.
Порт — это некая целочисленная константа,
существуют некоторые зарезервированные порты,
например, 80-й порт, обычно на нем работает HTTP-сервер,
43-й порт, 443-й порт.
Как правило, порты с номерами до 2,000 являются системными,
и мы должны использовать адреса больше значений 2,000,
но максимальное значение для порта — это 65,535.
Итак, системный вызов bind зарегистрировал
нашу адресную пару в операционной системе.
Двигаемся дальше.
Далее, для того чтобы начать принимать соединения,
мы должны вызвать метод listen.
У метода listen есть необязательный параметр
— это так называемый backlog, или размер очереди входящих соединений,
которые еще не обработаны, для которых не был вызван метод accept.
Если наш сервер будет не успевать принимать входящие соединения,
то все эти соединения будут копиться в этой очереди,
и если она превысит это максимальное значение,
то операционная система выдаст ошибку
ConnectionRefused для клиентской программы.
Двигаемся дальше.
Мы создали сокет, зарегистрировали адресную пару, вызвали метод listen.
Далее мы должны вызвать метод accept,
для того чтобы начать принимать входящее клиентское соединение.
Системный вызов accept по умолчанию заблокируется,
до тех пор, пока не появится клиентское соединение.
Итак, если клиент вызовет метод connect, то наш метод accept
вернет нам объект, который будет являться полнодуплексным каналом.
У этого объекта будут доступны
методы записи в этот канал и методы чтения.
В нашем примере мы в бесконечном цикле
будем вызывать чтение из нашего полнодуплексного канала.
Если мы ничего не прочитали, это будет означать,
что клиент закрыл соединение и нам необходимо тоже прекратить работу.
В качестве обработки наших данных, которые мы прочитали с канала,
мы просто выводим эти данные в консоль.
После того как мы закончили работу с нашим клиентом,
мы вызываем метод close для нашего объекта,
который представляет собой полнодуплексный канал,
и также закрываем сокет,
который слушает новые соединения со стороны клиента.
Давайте рассмотрим код на стороне клиента.
Для того чтобы установить соединение с сервером,
мы должны создать объект типа socket.socket.
По умолчанию создается потоковый сокет
с семейством address family AF_INET.
После этого мы должны вызвать метод connect.
Connect заблокируется до тех пор,
пока сервер со своей стороны не вызовет метод accept.
После того как системный вызов connect отработал,
наш сокет готов к работе, и для него можно вызывать
методы send, sendall или recv,
для того чтобы получать данные с сервера.
То есть, по сути, мы получили такой же полнодуплексный канал,
с которым можно работать, отправлять и получать данные.
После того как мы завершили работу с нашим клиентским сокетом,
необходимо вызвать метод close.
В Python существует более короткая запись
для создания клиентского сокета — это вызов метода модуля
socket create_connection.
В create_connection мы передаем адресную пару,
необязательный timeout.
Про timeout мы еще с вами будем говорить в следующих видео.
Этот вызов возвращает нам проключенное соединение,
готовое для того, чтобы делать отправку или прием данных.
Давайте попробуем запустить наш код и посмотрим,
как он работает на самом деле.
Нам потребуется код нашего сервера.
Давайте запустим его при помощи команды python3.
Итак, наш сервер создал сокет
и готов принимать новые соединения.
Давайте попробуем присоединиться к нашему серверу.
Импортируем модуль socket, создаем новое соединение
при помощи socket.create_connection.
Передаем адресную пару
в виде хоста и порт — 10001.
Итак, наш сокет готов со стороны клиента,
для того чтобы отправлять и принимать данные.
Давайте попробуем отправить данные.
Хочу обратить ваше внимание, что при работе с данными по сети
мы вынуждены отправлять именно байты, а не строки.
Поэтому мы передаем байты.
Пусть это будет строка ping.
Давайте посмотрим на сервер — сервер получил эти данные
и вывел нашу переданную строчку ping.
Давайте попробуем закрыть соединение со стороны клиента.
Для этого нам нужно вызвать метод close.
Итак, мы закрыли соединение со стороны клиента.
Наш сервер прекратил
цикл while и закрыл соединение,
и наша программа со стороны сервера завершила свою работу.
Как я уже говорил, socket — это кроссплатформенный механизм
и необязательно программа-клиент и сервер
должны быть написаны на одном и том же языке.
Давайте посмотрим, как наш пример будет работать,
если мы воспользуемся вместо клиента программой telnet.
Точно так же укажем адрес и порт,
куда мы собираемся отправлять наши данные.
Итак, telnet выполнил подключение, написал нам, что он приконнектился.
Давайте попробуем отправить данные.
Опять на стороне сервера мы видим, что данные получены
Давайте попробуем закрыть соединение.
Итак, мы видим, что наша серверная программа
завершила свою работу.
Ещё раз хочу обратить ваше внимание,
что сокет — это кроссплатформенный механизм,
который можно использовать на различных языках,
в том числе и на Python.
Хочется ещё обратить и остановить ваше внимание
на некоторых ключевых моментах
в нашей серверной и клиентской программе.
В частности, это вызовы методов close для наших объектов,
для соединения, на котором мы акцептим новые соединения клиентов,
а также для объекта connection,
который является полнодуплексным каналом.
Наш код носит обучающий характер, и в нём нет обработки ошибок.
Как правило, сетевые программы настоящие,
они выглядят более сложно, в них, естественно обрабатываются ошибки,
и одним из требований к сетевым программам
является то, что необходимо правильно и грамотно
завершать работу с созданными connect'ами
и со всеми открытыми сокетами, тем самым контролируя
ресурсы процесса, в котором всё это работает.
В Python существует более удобный механизм
для работы с сокетами в виде контекстных менеджеров.
Давайте рассмотрим пример, в котором мы выполняем
те же самые задачи, но используем контекстный менеджер.
Итак, мы используем на стороне сервера
конструкцию with socket.socket,
создаём наш объект типа socket,
вызываем методы bind, listen.
Затем в бесконечном цикле вызываем accept
и получаем новые соединения от клиентов.
Для полученного объекта мы опять используем контекстный менеджер
и мы не заботимся о вызовах метода close.
После того как контекстный менеджер завершит свою работу,
он автоматически вызовет метод close для нужных нам объектов.
Это очень удобно, и это позволяет допускать вам
меньшее количество ошибок при работе с сокетами.
На стороне клиента мы используем снова контекстный менеджер
для вызова socket.create.connection
и опять не заботимся о вызове метода close.
Предпочтительнее работать с контекстными менеджерами
при написании клиент-серверных программ на языке Python.
Итак, в этом видео мы обсудили, что такое сокеты,
как они устроены, мы попробовали написать
свою первую сетевую программу типа клиент-сервер,
попробовали поотправлять данные с клиента на сервер,
и мы обсудили роль контекстных менеджеров
в языке Python для написания сетевых программ.
В следующем видео мы продолжим с вами знакомство
с сетевыми программами и углубимся в детали их работы.
Explore our Catalog
Join for free and get personalized recommendations, updates and offers.
Coursera provides universal access to the world’s best education,
partnering with top universities and organizations to offer courses online.
© 2018 Coursera Inc. All rights reserved.
