> **Источник:** https://python-all.ru/2.7/library/socket.html
>
> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.

---

# 17.2. [`socket`](https://python-all.ru/2.7/library/socket.html#module-socket) – Низкоуровневый сетевой интерфейс

Этот модуль предоставляет доступ к интерфейсу BSD *socket*. Он доступен на всех современных системах Unix, Windows, Mac OS X, BeOS, OS/2 и, вероятно, на других платформах.

> **Примечание**
>
> Некоторые аспекты поведения могут зависеть от платформы, поскольку вызовы выполняются через API сокетов операционной системы.

Для введения в программирование сокетов (на C) см. следующие статьи: «An Introductory 4.3BSD Interprocess Communication Tutorial» (Стюарт Сечрест) и «An Advanced 4.3BSD Interprocess Communication Tutorial» (Сэмюэл Дж. Леффлер и др.), обе в UNIX Programmer’s Manual, Supplementary Documents 1 (разделы PS1:7 и PS1:8). Справочные материалы, специфичные для платформы, по различным системным вызовам сокетов также являются ценным источником информации о деталях семантики сокетов. Для Unix обратитесь к man-страницам; для Windows – к спецификации WinSock (или Winsock 2). Для API, поддерживающих IPv6, читателям рекомендуется обратиться к [**RFC 3493**](https://python-all.ru/2.7/library/socket.html) под названием «Basic Socket Interface Extensions for IPv6».

Интерфейс Python представляет собой прямую трансляцию системных вызовов Unix и библиотечного интерфейса сокетов в объектно-ориентированный стиль Python: функция [`socket()`](https://python-all.ru/2.7/library/socket.html#socket.socket) возвращает *объект сокета*, методы которого реализуют различные системные вызовы сокетов. Типы параметров несколько более высокоуровневые, чем в интерфейсе C: как и при операциях `read()` и `write()` с файлами Python, выделение буфера при операциях приёма происходит автоматически, а длина буфера неявно задаётся при отправке.

Сокетные адреса представляются следующим образом: для семейства адресов [`AF_UNIX`](https://python-all.ru/2.7/library/socket.html#socket.AF_UNIX) используется одна строка. Пара `(host, port)` используется для семейства адресов [`AF_INET`](https://python-all.ru/2.7/library/socket.html#socket.AF_INET), где *host* – это строка, представляющая либо имя хоста в доменной нотации, например `'daring.cwi.nl'`, либо IPv4-адрес, например `'100.50.200.5'`, а *port* – целое число. Для семейства адресов [`AF_INET6`](https://python-all.ru/2.7/library/socket.html#socket.AF_INET6) используется кортеж из четырёх элементов `(host, port, flowinfo, scopeid)`, где *flowinfo* и *scopeid* представляют члены `sin6_flowinfo` и `sin6_scope_id` в `struct sockaddr_in6` в C. Для методов модуля [`socket`](https://python-all.ru/2.7/library/socket.html#module-socket) *flowinfo* и *scopeid* могут быть опущены для обратной совместимости. Однако обратите внимание, что опущение *scopeid* может вызвать проблемы при работе с адресами IPv6 с областью действия. Другие семейства адресов в настоящее время не поддерживаются. Формат адреса, требуемый конкретным сокетным объектом, автоматически выбирается на основе семейства адресов, указанного при создании сокетного объекта.

Для IPv4-адресов вместо адреса хоста принимаются две специальные формы: пустая строка представляет `INADDR_ANY`, а строка `'<broadcast>'` представляет `INADDR_BROADCAST`. Это поведение недоступно для IPv6 для обратной совместимости, поэтому, если вы планируете поддерживать IPv6 в своих программах на Python, возможно, стоит избегать этих форм.

Если в части *узел* адреса сокета IPv4/v6 указано имя узла, программа может демонстрировать недетерминированное поведение, так как Python использует первый адрес, возвращённый при разрешении DNS. Адрес сокета будет разрешаться по-разному в фактический IPv4/v6-адрес в зависимости от результатов разрешения DNS и/или конфигурации узла. Для детерминированного поведения используйте числовой адрес в части *узел*.

Новое в версии 2.5: Сокеты AF\_NETLINK представляются в виде пар `pid, groups`.

Новое в версии 2.6: Поддержка только для Linux для TIPC также доступна с использованием семейства адресов `AF_TIPC`. TIPC – это открытый сетевой протокол на основе не-IP, предназначенный для использования в кластерных средах. Адреса представляются кортежем, и поля зависят от типа адреса. Общая форма кортежа: `(addr_type, v1, v2, v3 [, scope])`, где:

- *addr\_type* – одно из значений `TIPC_ADDR_NAMESEQ`, `TIPC_ADDR_NAME` или `TIPC_ADDR_ID`.
- *scope* – это одно из `TIPC_ZONE_SCOPE`, `TIPC_CLUSTER_SCOPE`, и `TIPC_NODE_SCOPE`.
- Если *addr\_type* равно `TIPC_ADDR_NAME`, то *v1* – тип сервера, *v2* – идентификатор порта, а *v3* должно быть 0.

  Если *addr\_type* равно `TIPC_ADDR_NAMESEQ`, то *v1* – тип сервера, *v2* – нижний номер порта, а *v3* – верхний номер порта.

  Если *addr\_type* равно `TIPC_ADDR_ID`, то *v1* – узел, *v2* – ссылка, а *v3* должно быть установлено в 0.

Все ошибки вызывают исключения. Могут возникать обычные исключения для недопустимых типов аргументов и нехватки памяти; ошибки, связанные с семантикой сокетов или адресов, вызывают ошибку [`socket.error`](https://python-all.ru/2.7/library/socket.html#socket.error).

Неблокирующий режим поддерживается через [`setblocking()`](https://python-all.ru/2.7/library/socket.html#socket.socket.setblocking). Его обобщение на основе тайм-аутов поддерживается через [`settimeout()`](https://python-all.ru/2.7/library/socket.html#socket.socket.settimeout).

Модуль [`socket`](https://python-all.ru/2.7/library/socket.html#module-socket) предоставляет следующие константы и функции:

#### `exception socket.error`

Это исключение возникает при ошибках, связанных с сокетами. Сопутствующее значение – это либо строка, описывающая ошибку, либо пара `(errno, string)`, представляющая ошибку, возвращённую системным вызовом, аналогично значению, сопровождающему [`os.error`](https://python-all.ru/2.7/library/os.html#os.error). Смотрите модуль [`errno`](https://python-all.ru/2.7/library/errno.html#module-errno), который содержит имена для кодов ошибок, определённых базовой операционной системой.

Изменено в версии 2.6: [`socket.error`](https://python-all.ru/2.7/library/socket.html#socket.error) теперь является дочерним классом [`IOError`](https://python-all.ru/2.7/library/exceptions.html#exceptions.IOError).

#### `exception socket.herror`

Это исключение возникает при ошибках, связанных с адресами, т.е. для функций, использующих *h\_errno* в C API, включая [`gethostbyname_ex()`](https://python-all.ru/2.7/library/socket.html#socket.gethostbyname_ex) и [`gethostbyaddr()`](https://python-all.ru/2.7/library/socket.html#socket.gethostbyaddr).

Сопутствующее значение – это пара `(h_errno, string)`, представляющая ошибку, возвращённую вызовом библиотеки. *string* представляет описание *h\_errno*, как возвращено функцией C `hstrerror()`.

#### `exception socket.gaierror`

Это исключение возникает при ошибках, связанных с адресами, для [`getaddrinfo()`](https://python-all.ru/2.7/library/socket.html#socket.getaddrinfo) и [`getnameinfo()`](https://python-all.ru/2.7/library/socket.html#socket.getnameinfo). Сопутствующее значение – это пара `(error, string)`, представляющая ошибку, возвращённую вызовом библиотеки. *string* представляет описание *error*, как возвращено функцией C `gai_strerror()`. Значение *error* будет соответствовать одной из констант `EAI_*`, определённых в этом модуле.

#### `exception socket.timeout`

Это исключение возникает при тайм-ауте на сокете, на котором тайм-ауты были включены предыдущим вызовом `settimeout()`. Сопутствующее значение – это строка, значение которой в настоящее время всегда «timed out».

Новое в версии 2.3.

#### `socket.AF_UNIX`

#### `socket.AF_INET`

#### `socket.AF_INET6`

Эти константы представляют семейства адресов (и протоколов), используемые для первого аргумента [`socket()`](https://python-all.ru/2.7/library/socket.html#socket.socket). Если константа [`AF_UNIX`](https://python-all.ru/2.7/library/socket.html#socket.AF_UNIX) не определена, то этот протокол не поддерживается.

#### `socket.SOCK_STREAM`

#### `socket.SOCK_DGRAM`

#### `socket.SOCK_RAW`

#### `socket.SOCK_RDM`

#### `socket.SOCK_SEQPACKET`

Эти константы представляют типы сокетов, используемые для второго аргумента [`socket()`](https://python-all.ru/2.7/library/socket.html#module-socket). (Обычно полезными оказываются только [`SOCK_STREAM`](https://python-all.ru/2.7/library/socket.html#socket.SOCK_STREAM) и [`SOCK_DGRAM`](https://python-all.ru/2.7/library/socket.html#socket.SOCK_DGRAM).)

#### `SO_*`

#### `socket.SOMAXCONN`

#### `MSG_*`

#### `SOL_*`

#### `IPPROTO_*`

#### `IPPORT_*`

#### `INADDR_*`

#### `IP_*`

#### `IPV6_*`

#### `EAI_*`

#### `AI_*`

#### `NI_*`

#### `TCP_*`

Многие константы этих форм, описанные в документации Unix по сокетам и/или протоколу IP, также определены в модуле socket. Они обычно используются в аргументах методов `setsockopt()` и `getsockopt()` объектов сокетов. В большинстве случаев определены только те символы, которые есть в заголовочных файлах Unix; для некоторых символов предоставлены значения по умолчанию.

#### `SIO_*`

#### `RCVALL_*`

Константы для Windows’ WSAIoctl(). Эти константы используются в качестве аргументов метода [`ioctl()`](https://python-all.ru/2.7/library/socket.html#socket.socket.ioctl) объектов сокетов.

Новое в версии 2.6.

#### `TIPC_*`

Константы, связанные с TIPC, соответствующие тем, что экспортируются C API сокетов. Дополнительную информацию см. в документации TIPC.

Новое в версии 2.6.

#### `socket.has_ipv6`

Эта константа содержит логическое значение, указывающее, поддерживается ли IPv6 на данной платформе.

Новое в версии 2.3.

#### `socket.create_connection(address[, timeout[, source_address]])`

Подключается к TCP-службе, прослушивающей *адрес* в интернете (кортеж из двух элементов `(host, port)`), и возвращает объект сокета. Это функция более высокого уровня, чем [`socket.connect()`](https://python-all.ru/2.7/library/socket.html#socket.socket.connect): если *host* – нечисловое имя узла, он будет пытаться разрешить его как для [`AF_INET`](https://python-all.ru/2.7/library/socket.html#socket.AF_INET), так и для [`AF_INET6`](https://python-all.ru/2.7/library/socket.html#socket.AF_INET6), а затем пытаться подключаться ко всем возможным адресам по очереди, пока подключение не установится. Это упрощает написание клиентов, совместимых как с IPv4, так и с IPv6.

Передача необязательного параметра *timeout* установит тайм-аут для экземпляра сокета перед попыткой подключения. Если *timeout* не указан, используется глобальная настройка тайм-аута по умолчанию, возвращаемая [`getdefaulttimeout()`](https://python-all.ru/2.7/library/socket.html#socket.getdefaulttimeout).

Если указан, *source\_address* должен быть кортежем из двух элементов `(host, port)`, к которому сокет должен привязаться как к своему исходному адресу перед подключением. Если хост или порт равны '' или 0 соответственно, будет использовано поведение ОС по умолчанию.

Новое в версии 2.6.

Изменено в версии 2.7: *source\_address* был добавлен.

#### `socket.getaddrinfo(host, port[, family[, socktype[, proto[, flags]]]])`

Преобразует аргументы *host*/*port* в последовательность кортежей из 5 элементов, содержащих все необходимые аргументы для создания сокета, подключенного к этому сервису. *host* – это доменное имя, строковое представление IPv4/v6-адреса или `None`. *port* – это строковое имя службы, такое как `'http'`, числовой номер порта или `None`. Передавая `None` в качестве значения *host* и *port*, можно передать `NULL` в базовый C API.

Аргументы *family*, *socktype* и *proto* могут быть указаны по желанию, чтобы сузить список возвращаемых адресов. По умолчанию их значение равно `0`, что означает выбор полного диапазона результатов. Аргумент *flags* может быть одной или несколькими константами `AI_*` и будет влиять на то, как вычисляются и возвращаются результаты. Его значение по умолчанию `0`. Например, `AI_NUMERICHOST` отключит разрешение доменных имён и вызовет ошибку, если *host* является доменным именем.

Функция возвращает список кортежей из 5 элементов со следующей структурой:

`(family, socktype, proto, canonname, sockaddr)`

В этих кортежах *family*, *socktype*, *proto* – целые числа и предназначены для передачи в функцию [`socket()`](https://python-all.ru/2.7/library/socket.html#socket.socket). *canonname* будет строкой, представляющей каноническое имя *хоста*, если `AI_CANONNAME` является частью аргумента *flags*; в противном случае *canonname* будет пустым. *sockaddr* – это кортеж, описывающий сокетный адрес, формат которого зависит от возвращаемого *family* (кортеж из 2 элементов `(address, port)` для [`AF_INET`](https://python-all.ru/2.7/library/socket.html#socket.AF_INET), кортеж из 4 элементов `(address, port, flow info, scope id)` для [`AF_INET6`](https://python-all.ru/2.7/library/socket.html#socket.AF_INET6)), и предназначен для передачи в метод [`socket.connect()`](https://python-all.ru/2.7/library/socket.html#socket.socket.connect).

В следующем примере получается информация об адресе для гипотетического TCP-подключения к `example.org` на порту 80 (результаты могут отличаться на вашей системе, если IPv6 не включён):

```python
>>> socket.getaddrinfo("example.org", 80, 0, 0, socket.IPPROTO_TCP)
[(10, 1, 6, '', ('2606:2800:220:1:248:1893:25c8:1946', 80, 0, 0)),
 (2, 1, 6, '', ('93.184.216.34', 80))]
```

Новое в версии 2.2.

#### `socket.getfqdn([name])`

Возвращает полностью определённое доменное имя для *name*. Если *name* опущен или пуст, он интерпретируется как локальный хост. Для поиска полного имени сначала проверяется имя хоста, возвращаемое [`gethostbyaddr()`](https://python-all.ru/2.7/library/socket.html#socket.gethostbyaddr), затем, если доступны, псевдонимы хоста. Выбирается первое имя, содержащее точку. Если полностью определённое доменное имя недоступно, возвращается имя хоста, полученное от [`gethostname()`](https://python-all.ru/2.7/library/socket.html#socket.gethostname).

Новое в версии 2.0.

#### `socket.gethostbyname(hostname)`

Преобразует имя хоста в формат IPv4-адреса. IPv4-адрес возвращается в виде строки, например `'100.50.200.5'`. Если имя хоста само является IPv4-адресом, оно возвращается без изменений. См. [`gethostbyname_ex()`](https://python-all.ru/2.7/library/socket.html#socket.gethostbyname_ex) для более полного интерфейса. [`gethostbyname()`](https://python-all.ru/2.7/library/socket.html#socket.gethostbyname) не поддерживает разрешение имён IPv6, вместо него для поддержки двойного стека IPv4/v6 следует использовать [`getaddrinfo()`](https://python-all.ru/2.7/library/socket.html#socket.getaddrinfo).

#### `socket.gethostbyname_ex(hostname)`

Преобразует имя хоста в формат IPv4-адреса (расширенный интерфейс). Возвращает тройку `(hostname, aliaslist, ipaddrlist)`, где *hostname* – основное имя хоста, отвечающее на заданный *ip\_address*; *aliaslist* – (возможно пустой) список альтернативных имён хоста для того же адреса; и *ipaddrlist* – список IPv4-адресов для того же интерфейса на том же хосте (часто, но не всегда, один адрес). [`gethostbyname_ex()`](https://python-all.ru/2.7/library/socket.html#socket.gethostbyname_ex) не поддерживает разрешение имён IPv6, а для поддержки IPv4/IPv6 двойного стека следует использовать [`getaddrinfo()`](https://python-all.ru/2.7/library/socket.html#socket.getaddrinfo).

#### `socket.gethostname()`

Возвращает строку, содержащую имя хоста машины, на которой в данный момент выполняется интерпретатор Python.

Если вы хотите узнать IP-адрес текущей машины, можно использовать `gethostbyname(gethostname())`. Эта операция предполагает, что для хоста существует допустимое отображение адреса на хост, однако это предположение не всегда выполняется.

Примечание: [`gethostname()`](https://python-all.ru/2.7/library/socket.html#socket.gethostname) не всегда возвращает полностью определённое доменное имя; используйте `getfqdn()` (см. выше).

#### `socket.gethostbyaddr(ip_address)`

Возвращает кортеж `(hostname, aliaslist, ipaddrlist)`, где *hostname* – это основное имя хоста, соответствующее заданному *ip\_address*, *aliaslist* – (возможно пустой) список альтернативных имён хоста для того же адреса, а *ipaddrlist* – список IPv4/v6-адресов для того же интерфейса на том же хосте (скорее всего, содержащий только один адрес). Чтобы найти полностью определённое доменное имя, используйте функцию [`getfqdn()`](https://python-all.ru/2.7/library/socket.html#socket.getfqdn). [`gethostbyaddr()`](https://python-all.ru/2.7/library/socket.html#socket.gethostbyaddr) поддерживает как IPv4, так и IPv6.

#### `socket.getnameinfo(sockaddr, flags)`

Преобразует адрес сокета *sockaddr* в кортеж из двух элементов `(host, port)`. В зависимости от настроек *flags* результат может содержать полное доменное имя или числовое представление адреса в *host*. Аналогично, *port* может содержать строковое имя порта или числовой номер порта.

Новое в версии 2.2.

#### `socket.getprotobyname(protocolname)`

Преобразует имя интернет-протокола (например, `'icmp'`) в константу, пригодную для передачи в качестве (необязательного) третьего аргумента функции [`socket()`](https://python-all.ru/2.7/library/socket.html#socket.socket). Обычно это требуется только для сокетов, открытых в «сыром» режиме ([`SOCK_RAW`](https://python-all.ru/2.7/library/socket.html#socket.SOCK_RAW)); для обычных режимов сокетов правильный протокол выбирается автоматически, если протокол опущен или равен нулю.

#### `socket.getservbyname(servicename[, protocolname])`

Преобразует имя интернет-службы и имя протокола в номер порта для этой службы. Необязательное имя протокола, если указано, должно быть `'tcp'` или `'udp'`, в противном случае подойдет любой протокол.

#### `socket.getservbyport(port[, protocolname])`

Преобразует номер порта интернет-службы и имя протокола в имя службы для этой службы. Необязательное имя протокола, если указано, должно быть `'tcp'` или `'udp'`, в противном случае подойдет любой протокол.

#### `socket.socket([family[, type[, proto]]])`

Создаёт новый сокет с указанным семейством адресов, типом сокета и номером протокола. Семейство адресов должно быть [`AF_INET`](https://python-all.ru/2.7/library/socket.html#socket.AF_INET) (по умолчанию), [`AF_INET6`](https://python-all.ru/2.7/library/socket.html#socket.AF_INET6) или [`AF_UNIX`](https://python-all.ru/2.7/library/socket.html#socket.AF_UNIX). Тип сокета должен быть [`SOCK_STREAM`](https://python-all.ru/2.7/library/socket.html#socket.SOCK_STREAM) (по умолчанию), [`SOCK_DGRAM`](https://python-all.ru/2.7/library/socket.html#socket.SOCK_DGRAM) или, возможно, одной из других констант `SOCK_`. Номер протокола обычно равен нулю и в этом случае может быть опущен.

#### `socket.socketpair([family[, type[, proto]]])`

Создаёт пару связанных объектов сокета, используя заданные семейство адресов, тип сокета и номер протокола. Семейство адресов, тип сокета и номер протокола такие же, как для функции [`socket()`](https://python-all.ru/2.7/library/socket.html#socket.socket) выше. Семейство по умолчанию – [`AF_UNIX`](https://python-all.ru/2.7/library/socket.html#socket.AF_UNIX), если оно определено на платформе; в противном случае по умолчанию используется [`AF_INET`](https://python-all.ru/2.7/library/socket.html#socket.AF_INET). Доступность: Unix.

Новое в версии 2.4.

#### `socket.fromfd(fd, family, type[, proto])`

Дублирует файловый дескриптор *fd* (целое число, возвращаемое методом `fileno()` файлового объекта) и создаёт из результата объект сокета. Семейство адресов, тип сокета и номер протокола такие же, как для функции [`socket()`](https://python-all.ru/2.7/library/socket.html#socket.socket) выше. Файловый дескриптор должен указывать на сокет, но это не проверяется; последующие операции с объектом могут завершиться ошибкой, если файловый дескриптор некорректен. Эта функция редко требуется, но может использоваться для получения или установки параметров сокета, переданного программе в качестве стандартного ввода или вывода (например, сервер, запущенный демоном Unix inet). Предполагается, что сокет работает в блокирующем режиме. Доступность: Unix.

#### `socket.ntohl(x)`

Преобразует 32-битные положительные целые числа из сетевого порядка байтов в порядок байтов хоста. На машинах, где порядок байтов хоста совпадает с сетевым, эта операция ничего не делает; в противном случае выполняется перестановка 4 байтов.

#### `socket.ntohs(x)`

Преобразует 16-битные положительные целые числа из сетевого порядка байтов в порядок байтов хоста. На машинах, где порядок байтов хоста совпадает с сетевым, эта функция ничего не делает; в противном случае она выполняет обмен двух байтов.

#### `socket.htonl(x)`

Преобразует 32-битные положительные целые числа из порядка байтов хоста в сетевой порядок. На машинах, где порядок байтов хоста совпадает с сетевым, эта функция ничего не делает; в противном случае она выполняет обмен четырёх байтов.

#### `socket.htons(x)`

Преобразует 16-битные положительные целые числа из порядка байтов хоста в сетевой порядок. На машинах, где порядок байтов хоста совпадает с сетевым, эта функция ничего не делает; в противном случае она выполняет обмен двух байтов.

#### `socket.inet_aton(ip_string)`

Преобразует IPv4-адрес из точечно-десятичного строкового формата (например, '123.45.67.89') в 32-битный упакованный двоичный формат в виде строки длиной четыре символа. Это полезно при взаимодействии с программой, использующей стандартную библиотеку C и требующей объекты типа `struct in_addr`, который является типом C для 32-битных упакованных двоичных данных, возвращаемых этой функцией.

[`inet_aton()`](https://python-all.ru/2.7/library/socket.html#socket.inet_aton) также принимает строки с менее чем тремя точками; подробнее см. на странице руководства Unix *inet(3)*.

Если переданная функции строка IPv4-адреса недопустима, будет возбуждено [`socket.error`](https://python-all.ru/2.7/library/socket.html#socket.error). Обратите внимание: что именно считается допустимым, зависит от нижележащей C-реализации `inet_aton()`.

[`inet_aton()`](https://python-all.ru/2.7/library/socket.html#socket.inet_aton) не поддерживает IPv6; для поддержки двойного стека IPv4/IPv6 следует использовать [`inet_pton()`](https://python-all.ru/2.7/library/socket.html#socket.inet_pton).

#### `socket.inet_ntoa(packed_ip)`

Преобразует 32-битный упакованный IPv4-адрес (строку длиной четыре символа) в его стандартное точечно-десятичное строковое представление (например, '123.45.67.89'). Это полезно при взаимодействии с программой, использующей стандартную библиотеку C и требующей объекты типа `struct in_addr`, который является типом C для 32-битных упакованных двоичных данных, принимаемых этой функцией в качестве аргумента.

Если переданная этой функции строка имеет длину не ровно 4 байта, будет вызвано исключение [`socket.error`](https://python-all.ru/2.7/library/socket.html#socket.error). Функция [`inet_ntoa()`](https://python-all.ru/2.7/library/socket.html#socket.inet_ntoa) не поддерживает IPv6, для поддержки двух стеков IPv4/v6 вместо неё следует использовать [`inet_ntop()`](https://python-all.ru/2.7/library/socket.html#socket.inet_ntop).

#### `socket.inet_pton(address_family, ip_string)`

Преобразует IP-адрес из строкового формата, зависящего от семейства, в упакованный двоичный формат. Функция [`inet_pton()`](https://python-all.ru/2.7/library/socket.html#socket.inet_pton) полезна, когда библиотека или сетевой протокол требует объект типа `struct in_addr` (аналогичного [`inet_aton()`](https://python-all.ru/2.7/library/socket.html#socket.inet_aton)) или `struct in6_addr`.

В настоящее время поддерживаемые значения для *address\_family*: [`AF_INET`](https://python-all.ru/2.7/library/socket.html#socket.AF_INET) и [`AF_INET6`](https://python-all.ru/2.7/library/socket.html#socket.AF_INET6). Если строка IP-адреса *ip\_string* недопустима, будет возбуждено [`socket.error`](https://python-all.ru/2.7/library/socket.html#socket.error). Обратите внимание: что именно считается допустимым, зависит как от значения *address\_family*, так и от нижележащей реализации `inet_pton()`.

Доступность: Unix (возможно, не на всех платформах).

Новое в версии 2.3.

#### `socket.inet_ntop(address_family, packed_ip)`

Преобразует упакованный IP-адрес (строку из некоторого количества символов) в его стандартное строковое представление, зависящее от семейства (например, `'7.10.0.5'` или `'5aef:2b::8'`). Функция [`inet_ntop()`](https://python-all.ru/2.7/library/socket.html#socket.inet_ntop) полезна, когда библиотека или сетевой протокол возвращает объект типа `struct in_addr` (аналогичного [`inet_ntoa()`](https://python-all.ru/2.7/library/socket.html#socket.inet_ntoa)) или `struct in6_addr`.

Поддерживаемые значения для параметра *address\_family* в настоящее время: [`AF_INET`](https://python-all.ru/2.7/library/socket.html#socket.AF_INET) и [`AF_INET6`](https://python-all.ru/2.7/library/socket.html#socket.AF_INET6). Если строка *packed\_ip* имеет неверную длину для указанного семейства адресов, будет вызвано исключение [`ValueError`](https://python-all.ru/2.7/library/exceptions.html#exceptions.ValueError). Исключение [`socket.error`](https://python-all.ru/2.7/library/socket.html#socket.error) вызывается при ошибках вызова [`inet_ntop()`](https://python-all.ru/2.7/library/socket.html#socket.inet_ntop).

Доступность: Unix (возможно, не на всех платформах).

Новое в версии 2.3.

#### `socket.getdefaulttimeout()`

Возвращает тайм-аут по умолчанию в секундах (число с плавающей запятой) для новых объектов сокетов. Значение `None` означает, что новые объекты сокетов не имеют тайм-аута. При первом импорте модуля socket значение по умолчанию равно `None`.

Новое в версии 2.3.

#### `socket.setdefaulttimeout(timeout)`

Устанавливает таймаут по умолчанию в секундах (число с плавающей точкой) для новых объектов сокета. Значение `None` означает, что новые объекты сокета не имеют таймаута. При первом импорте модуля socket значение по умолчанию равно `None`.

Новое в версии 2.3.

#### `socket.SocketType`

Это объект типа Python, представляющий тип объекта сокета. Он аналогичен `type(socket(...))`.

> **См. также**
>
> **Модуль [`SocketServer`](https://python-all.ru/2.7/library/socketserver.html#module-SocketServer)**
>
> Классы, упрощающие написание сетевых серверов.
>
> **Модуль [`ssl`](https://python-all.ru/2.7/library/ssl.html#module-ssl)**
>
> Обёртка TLS/SSL для объектов сокетов.

## 17.2.1. Сокетные объекты

Объекты сокета имеют следующие методы. За исключением `makefile()`, они соответствуют системным вызовам Unix, применимым к сокетам.

#### `socket.accept()`

Принимает соединение. Сокет должен быть привязан к адресу и находиться в режиме прослушивания. Возвращаемое значение – пара `(conn, address)`, где *conn* – это *новый* объект сокета, пригодный для отправки и получения данных по соединению, а *address* – адрес, привязанный к сокету на другом конце соединения.

#### `socket.bind(address)`

Привязывает сокет к *address*. Сокет не должен быть уже привязан. (Формат *address* зависит от семейства адресов – см. выше.)

> **Примечание**
>
> Исторически этот метод принимал пару параметров для адресов [`AF_INET`](https://python-all.ru/2.7/library/socket.html#socket.AF_INET) вместо одного кортежа. Это никогда не было задумано и больше не поддерживается в Python 2.0 и более поздних версиях.

#### `socket.close()`

Закрывает сокет. Все последующие операции с объектом сокета будут завершаться ошибкой. Удаленная сторона не получит больше данных (после сброса находящихся в очереди данных). Сокеты автоматически закрываются при сборке мусора.

> **Примечание**
>
> [`close()`](https://python-all.ru/2.7/library/socket.html#socket.socket.close) освобождает ресурс, связанный с соединением, но не обязательно немедленно закрывает соединение. Если требуется своевременно закрыть соединение, вызовите [`shutdown()`](https://python-all.ru/2.7/library/socket.html#socket.socket.shutdown) перед [`close()`](https://python-all.ru/2.7/library/socket.html#socket.socket.close).

#### `socket.connect(address)`

Подключается к удалённому сокету по адресу *address*. (Формат *address* зависит от семейства адресов – см. выше.)

> **Примечание**
>
> Исторически этот метод принимал пару параметров для адресов [`AF_INET`](https://python-all.ru/2.7/library/socket.html#socket.AF_INET) вместо одного кортежа. Это никогда не было задумано и больше не поддерживается в Python 2.0 и более поздних версиях.

#### `socket.connect_ex(address)`

Как и `connect(address)`, но возвращает индикатор ошибки вместо возбуждения исключения для ошибок, возвращаемых вызовом `connect()` на уровне C (другие проблемы, например «хост не найден», по-прежнему могут вызывать исключения). Индикатор ошибки равен `0`, если операция выполнена успешно, в противном случае – значению переменной `errno`. Это удобно, например, для поддержки асинхронных подключений.

> **Примечание**
>
> Исторически этот метод принимал пару параметров для адресов [`AF_INET`](https://python-all.ru/2.7/library/socket.html#socket.AF_INET) вместо одного кортежа. Это никогда не было задумано и больше не поддерживается в Python 2.0 и более поздних версиях.

#### `socket.fileno()`

Возвращает файловый дескриптор сокета (небольшое целое число). Это полезно совместно с [`select.select()`](https://python-all.ru/2.7/library/select.html#select.select).

В Windows небольшое целое число, возвращаемое этим методом, нельзя использовать там, где может быть использован файловый дескриптор (например, [`os.fdopen()`](https://python-all.ru/2.7/library/os.html#os.fdopen)). В Unix такого ограничения нет.

#### `socket.getpeername()`

Возвращает удалённый адрес, к которому подключён сокет. Это полезно, например, для определения номера порта удалённого сокета IPv4/v6. (Формат возвращаемого адреса зависит от семейства адресов – см. выше.) На некоторых системах эта функция не поддерживается.

#### `socket.getsockname()`

Возвращает собственный адрес сокета. Это полезно, например, для определения номера порта сокета IPv4/v6. (Формат возвращаемого адреса зависит от семейства адресов – см. выше.)

#### `socket.getsockopt(level, optname[, buflen])`

Возвращает значение заданной опции сокета (см. man-страницу Unix *getsockopt(2)*). Необходимые символические константы (`SO_*` и т.д.) определены в этом модуле. Если параметр *buflen* отсутствует, предполагается целочисленная опция, и функция возвращает её целое значение. Если параметр *buflen* присутствует, он задаёт максимальную длину буфера для получения опции, и этот буфер возвращается в виде строки. Разбор содержимого буфера возлагается на вызывающий код (см. опциональный встроенный модуль [`struct`](https://python-all.ru/2.7/library/struct.html#module-struct) для декодирования структур C, закодированных в виде строк).

#### `socket.ioctl(control, option)`

**Платформа**

Windows

Метод [`ioctl()`](https://python-all.ru/2.7/library/socket.html#socket.socket.ioctl) является ограниченным интерфейсом к системному интерфейсу WSAIoctl. За дополнительной информацией обратитесь к [документации Win32](https://python-all.ru/2.7/library/socket.html).

На других платформах можно использовать общие функции [`fcntl.fcntl()`](https://python-all.ru/2.7/library/fcntl.html#fcntl.fcntl) и [`fcntl.ioctl()`](https://python-all.ru/2.7/library/fcntl.html#fcntl.ioctl); они принимают объект сокета в качестве первого аргумента.

Новое в версии 2.6.

#### `socket.listen(backlog)`

Ожидает подключения к сокету. Аргумент *backlog* задаёт максимальное количество ожидающих соединений в очереди и должен быть не меньше 0; максимальное значение зависит от системы (обычно 5), минимальное принудительно устанавливается в 0.

#### `socket.makefile([mode[, bufsize]])`

Возвращает *файловый объект*, связанный с сокетом. (Файловые объекты описаны в разделе [Файловые объекты](https://python-all.ru/2.7/library/stdtypes.html#bltin-file-objects).) Файловый объект не закрывает сокет явно при вызове метода [`close()`](https://python-all.ru/2.7/library/socket.html#socket.socket.close), а лишь удаляет свою ссылку на объект сокета, так что сокет будет закрыт, если на него нет других ссылок.

Сокет должен быть в блокирующем режиме (не может иметь таймаут). Необязательные аргументы *mode* и *bufsize* интерпретируются так же, как и встроенной функцией [`file()`](https://python-all.ru/2.7/library/functions.html#file).

> **Примечание**
>
> В Windows файлоподобный объект, созданный [`makefile()`](https://python-all.ru/2.7/library/socket.html#socket.socket.makefile), нельзя использовать там, где ожидается файловый объект с дескриптором файла, например, в аргументах потока [`subprocess.Popen()`](https://python-all.ru/2.7/library/subprocess.html#subprocess.Popen).

#### `socket.recv(bufsize[, flags])`

Получает данные из сокета. Возвращаемое значение – строка, представляющая полученные данные. Максимальное количество данных, получаемых за один раз, задаётся параметром *bufsize*. См. man-страницу Unix *recv(2)* для описания необязательного аргумента *flags*; по умолчанию он равен нулю.

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

#### `socket.recvfrom(bufsize[, flags])`

Получает данные из сокета. Возвращаемое значение – пара `(string, address)`, где *string* – строка с полученными данными, а *address* – адрес сокета, отправившего данные. См. страницу руководства Unix *recv(2)* для пояснения необязательного аргумента *flags*; по умолчанию он равен нулю. (Формат *address* зависит от семейства адресов – см. выше.)

#### `socket.recvfrom_into(buffer[, nbytes[, flags]])`

Получает данные из сокета, записывая их в *buffer* вместо создания новой строки. Возвращаемое значение – пара `(nbytes, address)`, где *nbytes* – количество полученных байтов, а *address* – адрес сокета, отправившего данные. См. страницу руководства Unix *recv(2)* для пояснения необязательного аргумента *flags*; по умолчанию он равен нулю. (Формат *address* зависит от семейства адресов – см. выше.)

Новое в версии 2.5.

#### `socket.recv_into(buffer[, nbytes[, flags]])`

Получает из сокета до *nbytes* байтов, сохраняя данные в буфер, а не создавая новую строку. Если *nbytes* не указан (или равен 0), принимается столько байтов, сколько помещается в переданный буфер. Возвращает количество полученных байтов. См. страницу руководства Unix *recv(2)* для пояснения необязательного аргумента *flags*; по умолчанию он равен нулю.

Новое в версии 2.5.

#### `socket.send(string[, flags])`

Отправляет данные в сокет. Сокет должен быть подключён к удалённому сокету. Необязательный аргумент *flags* имеет то же значение, что и для [`recv()`](https://python-all.ru/2.7/library/socket.html#socket.socket.recv) выше. Возвращает количество отправленных байтов. Приложения должны проверять, что все данные отправлены; если передана только часть данных, приложению необходимо попытаться доставить оставшиеся данные. Дополнительную информацию об этой концепции см. в [Socket Programming HOWTO](https://python-all.ru/2.7/howto/sockets.html#socket-howto).

#### `socket.sendall(string[, flags])`

Отправляет данные в сокет. Сокет должен быть подключён к удалённому сокету. Необязательный аргумент *flags* имеет то же значение, что и для [`recv()`](https://python-all.ru/2.7/library/socket.html#socket.socket.recv) выше. В отличие от [`send()`](https://python-all.ru/2.7/library/socket.html#socket.socket.send), этот метод продолжает отправлять данные из *string* до тех пор, пока не будут отправлены все данные или не возникнет ошибка. В случае успеха возвращается `None`. При ошибке возникает исключение, и нет способа определить, сколько данных (если вообще какие-то) было успешно отправлено.

#### `socket.sendto(string, address)`

#### `socket.sendto(string, flags, address)`

Отправляет данные в сокет. Сокет не должен быть подключён к удалённому сокету, поскольку целевой сокет задаётся параметром *address*. Необязательный аргумент *flags* имеет тот же смысл, что и для [`recv()`](https://python-all.ru/2.7/library/socket.html#socket.socket.recv) выше. Возвращает количество отправленных байтов. (Формат *address* зависит от семейства адресов – см. выше.)

#### `socket.setblocking(flag)`

Устанавливает блокирующий или неблокирующий режим сокета: если *flag* равен 0, сокет переводится в неблокирующий режим, иначе – в блокирующий. Изначально все сокеты находятся в блокирующем режиме. В неблокирующем режиме, если вызов [`recv()`](https://python-all.ru/2.7/library/socket.html#socket.socket.recv) не находит данных, или если вызов [`send()`](https://python-all.ru/2.7/library/socket.html#socket.socket.send) не может немедленно отправить данные, возникает исключение [`error`](https://python-all.ru/2.7/library/socket.html#socket.error); в блокирующем режиме вызовы блокируются, пока не смогут продолжить. `s.setblocking(0)` эквивалентно `s.settimeout(0.0)`; `s.setblocking(1)` эквивалентно `s.settimeout(None)`.

#### `socket.settimeout(value)`

Устанавливает тайм-аут для блокирующих операций с сокетом. Аргумент *value* может быть неотрицательным числом с плавающей точкой, задающим секунды, или `None`. Если передано число с плавающей точкой, последующие операции с сокетом будут вызывать исключение [`timeout`](https://python-all.ru/2.7/library/socket.html#socket.timeout), если время тайм-аута *value* истекло до завершения операции. Установка тайм-аута в `None` отключает тайм-ауты для операций с сокетом. `s.settimeout(0.0)` эквивалентно `s.setblocking(0)`; `s.settimeout(None)` эквивалентно `s.setblocking(1)`.

Новое в версии 2.3.

#### `socket.gettimeout()`

Возвращает тайм-аут в секундах (число с плавающей точкой), связанный с операциями с сокетом, или `None`, если тайм-аут не установлен. Это значение отражает последний вызов [`setblocking()`](https://python-all.ru/2.7/library/socket.html#socket.socket.setblocking) или [`settimeout()`](https://python-all.ru/2.7/library/socket.html#socket.socket.settimeout).

Новое в версии 2.3.

Некоторые замечания о блокировке сокетов и тайм-аутах: объект сокета может находиться в одном из трёх режимов: блокирующий, неблокирующий или с тайм-аутом. Сокеты всегда создаются в блокирующем режиме. В блокирующем режиме операции блокируются до завершения или до возврата системой ошибки (например, истекло время соединения). В неблокирующем режиме операции завершаются ошибкой (к сожалению, зависящей от системы), если их невозможно выполнить немедленно. В режиме тайм-аута операции завершаются ошибкой, если их невозможно выполнить за время тайм-аута, заданное для сокета, или если система возвращает ошибку. Метод [`setblocking()`](https://python-all.ru/2.7/library/socket.html#socket.socket.setblocking) – это просто краткая форма для определённых вызовов [`settimeout()`](https://python-all.ru/2.7/library/socket.html#socket.socket.settimeout).

Режим тайм-аута внутренне переводит сокет в неблокирующий режим. Режимы блокировки и тайм-аута являются общими для файловых дескрипторов и объектов сокетов, относящихся к одной сетевой конечной точке. Следствием этого является то, что файловые объекты, возвращаемые методом [`makefile()`](https://python-all.ru/2.7/library/socket.html#socket.socket.makefile), должны использоваться только когда сокет находится в блокирующем режиме; в режиме тайм-аута или неблокирующем режиме файловые операции, которые не могут быть выполнены немедленно, завершатся ошибкой.

Обратите внимание, что операция [`connect()`](https://python-all.ru/2.7/library/socket.html#socket.socket.connect) подчиняется настройке тайм-аута, и в целом рекомендуется вызывать [`settimeout()`](https://python-all.ru/2.7/library/socket.html#socket.socket.settimeout) перед вызовом [`connect()`](https://python-all.ru/2.7/library/socket.html#socket.socket.connect) или передавать параметр тайм-аута в [`create_connection()`](https://python-all.ru/2.7/library/socket.html#socket.create_connection). Системный сетевой стек может вернуть собственную ошибку тайм-аута соединения независимо от любых настроек тайм-аута сокета Python.

#### `socket.setsockopt(level, optname, value)`

Устанавливает значение указанной опции сокета (см. страницу руководства Unix *setsockopt(2)*). Необходимые символические константы определены в модуле [`socket`](https://python-all.ru/2.7/library/socket.html#module-socket) (`SO_*` и т.д.). Значение может быть целым числом или строкой, представляющей буфер. В последнем случае вызывающий должен убедиться, что строка содержит правильные биты (см. опциональный встроенный модуль [`struct`](https://python-all.ru/2.7/library/struct.html#module-struct) для способа кодирования C-структур в строки).

#### `socket.shutdown(how)`

Завершает одну или обе половины соединения. Если *how* равно `SHUT_RD`, дальнейший приём запрещён. Если *how* равно `SHUT_WR`, дальнейшая отправка запрещена. Если *how* равно `SHUT_RDWR`, дальнейшие отправка и приём запрещены. В зависимости от платформы, завершение одной половины соединения может также закрыть противоположную половину (например, на Mac OS X `shutdown(SHUT_WR)` не позволяет дальнейшее чтение на другом конце соединения).

Обратите внимание, что методы `read()` и `write()` отсутствуют; вместо них используйте [`recv()`](https://python-all.ru/2.7/library/socket.html#socket.socket.recv) и [`send()`](https://python-all.ru/2.7/library/socket.html#socket.socket.send) без аргумента *flags*.

Объекты сокетов также имеют следующие (только для чтения) атрибуты, соответствующие значениям, переданным конструктору [`socket`](https://python-all.ru/2.7/library/socket.html#socket.socket).

#### `socket.family`

Семейство сокета.

Новое в версии 2.5.

#### `socket.type`

Тип сокета.

Новое в версии 2.5.

#### `socket.proto`

Протокол сокета.

Новое в версии 2.5.

## 17.2.2. Пример

Вот четыре минимальных примера программ, использующих протокол TCP/IP: сервер, который отправляет обратно все полученные данные (обслуживая только одного клиента), и использующий его клиент. Обратите внимание, что сервер должен выполнить последовательность [`socket()`](https://python-all.ru/2.7/library/socket.html#socket.socket), [`bind()`](https://python-all.ru/2.7/library/socket.html#socket.socket.bind), [`listen()`](https://python-all.ru/2.7/library/socket.html#socket.socket.listen), [`accept()`](https://python-all.ru/2.7/library/socket.html#socket.socket.accept) (возможно, повторяя [`accept()`](https://python-all.ru/2.7/library/socket.html#socket.socket.accept) для обслуживания более одного клиента), в то время как клиенту нужна только последовательность [`socket()`](https://python-all.ru/2.7/library/socket.html#socket.socket), [`connect()`](https://python-all.ru/2.7/library/socket.html#socket.socket.connect). Также обратите внимание, что сервер не вызывает [`sendall()`](https://python-all.ru/2.7/library/socket.html#socket.socket.sendall)/[`recv()`](https://python-all.ru/2.7/library/socket.html#socket.socket.recv) на сокете, который слушает, а на новом сокете, возвращённом [`accept()`](https://python-all.ru/2.7/library/socket.html#socket.socket.accept).

Первые два примера поддерживают только IPv4.

```python
# Программа эхо-сервера
import socket

HOST = ''                 # Символическое имя, обозначающее все доступные интерфейсы
PORT = 50007              # Произвольный непривилегированный порт
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((HOST, PORT))
s.listen(1)
conn, addr = s.accept()
print 'Connected by', addr
while 1:
    data = conn.recv(1024)
    if not data: break
    conn.sendall(data)
conn.close()
```

```python
# Программа эхо-клиента
import socket

HOST = 'daring.cwi.nl'    # Удалённый хост
PORT = 50007              # Тот же порт, что и у сервера
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))
s.sendall('Hello, world')
data = s.recv(1024)
s.close()
print 'Received', repr(data)
```

Следующие два примера идентичны двум предыдущим, но поддерживают как IPv4, так и IPv6. Серверная сторона будет прослушивать первое доступное семейство адресов (ей следовало бы прослушивать оба). На большинстве систем, готовых к IPv6, IPv6 будет иметь приоритет, и сервер может не принимать IPv4-трафик. Клиентская сторона попытается подключиться ко всем адресам, полученным в результате разрешения имен, и отправляет трафик на первый успешно подключенный.

```python
# Программа эхо-сервера
import socket
import sys

HOST = None               # Символическое имя, обозначающее все доступные интерфейсы
PORT = 50007              # Произвольный непривилегированный порт
s = None
for res in socket.getaddrinfo(HOST, PORT, socket.AF_UNSPEC,
                              socket.SOCK_STREAM, 0, socket.AI_PASSIVE):
    af, socktype, proto, canonname, sa = res
    try:
        s = socket.socket(af, socktype, proto)
    except socket.error as msg:
        s = None
        continue
    try:
        s.bind(sa)
        s.listen(1)
    except socket.error as msg:
        s.close()
        s = None
        continue
    break
if s is None:
    print 'could not open socket'
    sys.exit(1)
conn, addr = s.accept()
print 'Connected by', addr
while 1:
    data = conn.recv(1024)
    if not data: break
    conn.send(data)
conn.close()
```

```python
# Программа эхо-клиента
import socket
import sys

HOST = 'daring.cwi.nl'    # Удалённый хост
PORT = 50007              # Тот же порт, что и у сервера
s = None
for res in socket.getaddrinfo(HOST, PORT, socket.AF_UNSPEC, socket.SOCK_STREAM):
    af, socktype, proto, canonname, sa = res
    try:
        s = socket.socket(af, socktype, proto)
    except socket.error as msg:
        s = None
        continue
    try:
        s.connect(sa)
    except socket.error as msg:
        s.close()
        s = None
        continue
    break
if s is None:
    print 'could not open socket'
    sys.exit(1)
s.sendall('Hello, world')
data = s.recv(1024)
s.close()
print 'Received', repr(data)
```

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

```python
import socket

# общедоступный сетевой интерфейс
HOST = socket.gethostbyname(socket.gethostname())

# создать сырой сокет и привязать его к общедоступному интерфейсу
s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_IP)
s.bind((HOST, 0))

# Включать IP-заголовки
s.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)

# принять все пакеты
s.ioctl(socket.SIO_RCVALL, socket.RCVALL_ON)

# принять пакет
print s.recvfrom(65565)

# неразборчивый режим отключён
s.ioctl(socket.SIO_RCVALL, socket.RCVALL_OFF)
```

Запуск примера несколько раз со слишком маленькой задержкой между выполнениями может привести к этой ошибке:

```python
socket.error: [Errno 98] Address already in use
```

Это связано с тем, что предыдущее выполнение оставило сокет в состоянии `TIME_WAIT`, и его нельзя сразу использовать повторно.

Существует флаг [`socket`](https://python-all.ru/2.7/library/socket.html#module-socket), который можно установить, чтобы предотвратить это, `socket.SO_REUSEADDR`:

```python
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind((HOST, PORT))
```

Флаг `SO_REUSEADDR` указывает ядру переиспользовать локальный сокет в состоянии `TIME_WAIT`, не дожидаясь истечения его естественного тайм-аута.