Сообщить об ошибке.

Объект Socket модуля socket в Python.

Атрибуты и методы, определяемые объектом Socket.

Все методы объекта Socket, за исключением метода Socket.makefile(), соответствуют системным вызовам Unix, применимым к сокетам.
Объекты Socket ​​поддерживают протокол диспетчера контекста. Выход из диспетчера контекста эквивалентен вызову функции socket.close().

Содержание:


Socket.accept():

Метод Socket.accept() принимает соединение.
Сокет должен быть привязан к адресу и прослушивать соединения. Возвращаемое значение - это пара (conn, address), где
  • conn - это новый объект сокета, который можно использовать для отправки и получения данных в соединении,
  • address - это адрес, привязанный к сокету на другом конце соединения.
Вновь созданный сокет не наследуется.

Socket.bind(address):

Метод Socket.bind() привязывает сокет к адресу address. Сокет еще не должен быть привязан.
Формат адреса зависит от семейства адресов.
Вызывает событие аудита socket.bind с аргументами self, address.

Socket.close():

Метод Socket.close() закрывает сокет.
Базовый системный ресурс (например, файловый дескриптор) также закрывается, когда закрываются все файловые объекты из Socket.makefile(). Как только это произойдет, все будущие операции с объектом сокета завершатся ошибкой.
После того, как данные из очереди будут сброшены, удаленный сокет не будет получать больше данных.
Сокеты автоматически закрываются, когда они собираются сборщиком мусора, но рекомендуется явно закрыть их Socket.close() или использовать для них оператор with.
Изменено в Python 3.6: Если возникает ошибка при выполнении базового вызова Socket.close(), то возникает исключение OSError.
Обратите внимание, что Socket.close() освобождает ресурс, связанный с соединением, но не обязательно немедленно закрывает соединение. Если необходимо своевременно закрыть соединение, то перед закрытием сокета Socket.close() вызовите метод Socket.shutdown().

Socket.connect(address):

Метод Socket.connect() подключается к удаленному сокету по адресу address. Формат адреса address зависит от семейства адресов.
Если соединение прерывается сигналом, а обработчик сигнала не вызывает исключение и сокет блокируется или имеет тайм-аут, то метод ожидает завершения соединения или вызывает исключение Socket.timeout.
Для неблокирующих сокетов, если соединение прерывается сигналом или исключением, созданным обработчиком сигнала, то метод вызывает исключение InterruptedError, .
Вызывает событие аудита socket.connect с аргументами self, address.
Изменено в Python 3.5: теперь метод ожидает завершения соединения вместо вызова исключения InterruptedError, если соединение прерывается сигналом, а обработчик сигнала не вызывает исключения и сокет блокируется или имеет тайм-аут.

Socket.connect_ex(address):

Метод Socket.connect_ex() работает подобно методу Socket.connect(address), но вместо вызова исключения (возвращаемых вызовом connect() языка C) возвращает индикатор ошибки (Исключение может возникнуть, если не найден хост - "host not found").
Индикатор ошибки равен 0, если операция прошла успешно, в противном случае, индикатор ошибки равен значению переменной errno. Метод Socket.connect_ex() полезен для поддержки, например, асинхронных подключений.
Вызывает событие аудита socket.connect с аргументами self, address.

Socket.detach():

Метод Socket.detach() переводит объект сокета в закрытое состояние, не закрывая дескриптор файла.
Возвращает дескриптор файла, который может быть повторно использован для других целей.

Socket.dup():

Метод Socket.dup() дублирует объект сокета Socket. Вновь созданный сокет не наследуется.

Socket.fileno():

Метод Socket.fileno() возвращает файловый дескриптор сокета (небольшое целое число) или -1 в случае ошибки.
Метод Socket.fileno() полезен с системным вызовом Unix select.select().
В Windows возвращаемое этим методом малое целое число, нельзя использовать там, где можно использовать дескриптор файла, например os.fdopen(). Unix не имеет этого ограничения.

Socket.get_inheritable():

Метод Socket.get_inheritable() получает наследуемый флаг дескриптора файла или дескриптора сокета.
Метод возвращает True, если сокет может быть унаследован в дочерних процессах, False, если нет.

Socket.getpeername():

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

Socket.getsockname():

Метод Socket.getsockname() возвращает собственный адрес и порт сокета.
Метод полезен, например, для определения номера порта сокета IPv4/v6. Формат возвращаемого адреса зависит от семейства адресов.
import socket
s = socket.socket()
s.bind(('localhost', 12345))
# распаковать кортеж
host, port = s.getsockname()
>>> host
# '127.0.0.1'
>>> port
# 12345
Если компьютер имеет маршрут, подключенный к Интернету с белым IP-адресом, то код ниже вернет этот IP-адрес, Если компьютер подключен к интернету при помощи серого IP-адреса, то в результате выполнения кода получим адрес подсети провайдера:
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(("8.8.8.8", 80))
host, port = s.getsockname()
>>> host
# '10.10.10.13'
Можно использовать эту функцию для определения адреса компьютера в подсети провайдера, для которой не требуется маршрутизируемый доступ в Интернет.
import socket

def extract_ip():
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    try:       
        s.connect(('10.255.255.255', 1))
        ip = st.getsockname()[0]
    except Exception:
        ip = '127.0.0.1'
    finally:
        st.close()
    return ip


>>> extract_ip()
# '10.10.10.13'

Socket.getsockopt(level, optname[, buflen]):

Метод Socket.getsockopt() возвращает значение заданной опции сокета (смотрите man-страницу Unix командой $ man getsockopt).
Необходимые символьные константы socket.SO_* и т. д. определены в модуле socket.
  • Если аргумент buflen отсутствует, то предполагается целочисленный параметр, и метод возвращает его целое значение.
  • Если аргумент buflen присутствует, то он указывает максимальную длину буфера, используемого для приема опции, и этот буфер возвращается как байтовый объект.
Вызывающий объект должен декодировать содержимое возвращаемого буфера. Чтобы узнать, как декодировать структуры языка С, закодированные как байтовые строки смотрите встроенный модуль struct.

Socket.getblocking():

Метод Socket.getblocking() возвращает True, если сокет находится в режиме блокировки, False, если в неблокирующем режиме.
Вызов метода эквивалентен проверке Socket.gettimeout() == 0.
Новое в Python 3.7.

Socket.gettimeout():

Метод Socket.gettimeout() возвращает значение тайм-аут float в секундах или None, если тайм-аут не установлен.
Метод отражает последний вызов Socket.setblocking() или Socket.settimeout().

Socket.ioctl(control, option):

Только для операционной системы Windows.
Метод Socket.ioctl() - это ограниченный интерфейс для системного интерфейса WSAIoctl. Для получения дополнительной информации, обратитесь к документации Win32.
На других платформах могут использоваться общие функции |fcntl.fcntl()| и |fcntl.ioctl()|. Они принимают объект сокета в качестве своего первого аргумента.
В настоящее время поддерживаются только следующие управляющие коды: socket.SIO_RCVALL, socket.SIO_KEEPALIVE_VALS и socket.SIO_LOOPBACK_FAST_PATH.
Изменено в Python 3.6: добавлен socket.SIO_LOOPBACK_FAST_PATH.

Socket.listen([backlog]):

Метод Socket.listen() переводит сервер для приема подключений.
Если задан необязательный аргумент backlog, то он должен быть не менее 0 (если меньше, то это равно 0).
Аргумент backlog указывает количество подключений, которые система поставит в очередь, перед отказом от новых подключений. Если не указано, то выбирается разумное значение по умолчанию.

Socket.makefile(mode='r', buffering=None, *, encoding=None, errors=None, newline=None):

Метод Socket.makefile() возвращает объект файла, связанный с сокетом. Точный возвращаемый тип зависит от аргументов, переданных в метод Socket.makefile(). Эти аргументы интерпретируются так же, как и встроенной функцией функции open(), за исключением того, что поддерживаются только значения mode 'r' (по умолчанию), 'w' и 'b'.
Сокет должен находиться в режиме блокировки. У него может быть установлен тайм-аут, но при этом, внутренний буфер файлового объекта может оказаться в несогласованном состоянии, если произойдет этот тайм-аут.
Закрытие файлового объекта, Socket.makefile(), не приведет к закрытию исходного сокета, если все остальные файловые объекты не были закрыты и Socket.close() не был вызван для объекта сокета.
Примечание. В Windows файловый объект, созданный методом Socket.makefile(), нельзя использовать там, где ожидается файловый объект с файловым дескриптором, например как потоковые аргументы функции subprocess.Popen().

Socket.recv(bufsize[, flags]):

Метод Socket.recv() получает данные из сокета. Возвращаемое значение - байтовый объект, представляющий полученные данные.
  • Максимальный объем данных, которые должны быть получены за один раз, указывается в bufsize.
  • Информацию о значении необязательного аргумента flags (по умолчанию он равен нулю) смотрите на справочной странице по recv(2) Unix, командой $ man recv.
Примечание. Для наилучшего соответствия с аппаратными и сетевыми реалиями значение bufsize должно быть относительно небольшим, например 4096.

Socket.recvfrom(bufsize[, flags]):

Метод Socket.recvfrom() получает данные из сокета. Возвращаемое значение - это парный кортеж (bytes, address), где bytes - это байтовый объект, представляющий полученные данные, а address - это адрес сокета, отправляющего данные. Формат адреса address зависит от семейства адресов.
Информацию о значении необязательного аргумента flags (по умолчанию он равен нулю) смотрите на справочной странице по recv(2) Unix, командой $ man recv.
Изменено в Python 3.7: для адреса IPv6, первый элемент адреса больше не содержит части %scope_id. Чтобы получить полный IPv6-адрес, используйте функцию socket.getnameinfo().

Socket.recvmsg(bufsize[, ancbufsize[, flags]]):

Метод Socket.recvmsg() получает обычные данные до bufsize байтов и вспомогательные данные из сокета.
Аргумент ancbufsize устанавливает размер в байтах внутреннего буфера, используемого для приема вспомогательных данных. По умолчанию он равен 0, это означает, что дополнительные данные не будут получены. Соответствующие размеры буфера для вспомогательных данных можно вычислить с помощью socket.CMSG_SPACE() или socket.CMSG_LEN(), а элементы, которые не помещаются в буфер, могут быть усечены или отброшены.
Информацию о значении необязательного аргумента flags (по умолчанию он равен нулю) смотрите на справочной странице по recv(2) Unix, командой $ man recv.
Возвращаемое значение метода Socket.recvmsg() - это 4-кортеж: (data, ancdata, msg_flags, address).
  • Элемент данных data - это байтовый объект, содержащий полученные основные данные.
  • Элемент ancdata представляет собой список из нуля или более кортежей (cmsg_level, cmsg_type, cmsg_data), представляющих полученные вспомогательные данные (управляющие сообщения):
    • cmsg_level и cmsg_type - это целые числа, определяющие уровень протокола и специфичный для протокола тип соответственно,
    • cmsg_data - это байтовый объект, содержащий связанные данные.
  • Элемент msg_flags - это побитовое ИЛИ различных флагов, указывающих условия в полученном сообщении. подробности смотрите в документации к вашей системы.
  • Если принимающий сокет не подключен, то address является адресом отправляющего сокета, если он доступен, в противном случае его значение не указано.
В некоторых системах методы Socket.sendmsg() и Socket.recvmsg() могут использоваться для передачи файловых дескрипторов между процессами через сокет socket.AF_UNIX. Когда это средство используется (оно часто ограничивается сокетами socket.SOCK_STREAM), то метод Socket.recvmsg() будет возвращать в своих вспомогательных данных элементы формы (socket.SOL_SOCKET, socket.SCM_RIGHTS, fds), где fds - байтовый объект, представляющий новые файловые дескрипторы как двоичный массив собственного типа языка C int. Если метод Socket.sendmsg() вызывает исключение после возврата из системного вызова, то он сначала попытается закрыть все файловые дескрипторы, полученные через этот механизм.
Некоторые системы не указывают усеченную длину элементов вспомогательных данных, которые были получены только частично. Если кажется, что элемент выходит за пределы конца буфера, то Socket.recvmsg() выдаст RuntimeWarning и вернет его часть, которая находится внутри буфера, при условии, что элемент не был усечен до начала связанных с ним данных.
В системах, поддерживающих механизм socket.SCM_RIGHTS, функция recv_fds() (смотрите ниже) будет получать дескрипторы файлов maxfds, возвращая данные сообщения и список, содержащий дескрипторы при игнорировании неожиданных условий, таких как получение несвязанных управляющих сообщений. Смотрите также метод объекта сокета Socket.sendmsg().
import socket, array

def recv_fds(sock, msglen, maxfds):
    fds = array.array("i")   # Array of ints
    msg, ancdata, flags, addr = sock.recvmsg(msglen, Socket.CMSG_LEN(maxfds * fds.itemsize))
    for cmsg_level, cmsg_type, cmsg_data in ancdata:
        if cmsg_level == Socket.SOL_SOCKET and cmsg_type == Socket.SCM_RIGHTS:
            # Append data, ignoring any truncated integers at the end.
            fds.frombytes(cmsg_data[:len(cmsg_data) - (len(cmsg_data) % fds.itemsize)])
    return msg, list(fds)
Доступность: большинство платформ Unix, возможно, и другие.

Socket.recvmsg_into(buffers[, ancbufsize[, flags]]):

Метод Socket.recvmsg_into() получает нормальные и вспомогательные данные из сокета, ведя себя как метод Socket.recvmsg(), но разбрасывает нормальные данные в ряд буферов вместо того, чтобы возвращать новый байтовый объект.
Аргумент buffers должен быть итерацией объектов, экспортирующих записываемые буферы, например объекты bytearray). Они будут заполняться последовательными фрагментами нормальных данных до тех пор, пока все они не будут записаны или пока buffers больше не останется. Операционная система может установить ограничение (os.sysconf() со значением SC_IOV_MAX) на количество буферов, которые могут быть использованы.
Аргументы ancbufsize имеет то же значение, что и для метода Socket.recvmsg().
Информацию о значении необязательного аргумента flags (по умолчанию он равен нулю) смотрите на справочной странице по recv(2) Unix, командой $ man recv.
Возвращаемое значение Socket.recvmsg_into() представляет собой 4-кортеж: (nbytes, ancdata, msg_flags, address), где
  • nbytes - это общее количество байтов нормальных данных, записанных в буферы,
  • ancdata, msg_flags и address такие же, как для Socket.recvmsg().
Пример:
>>> import socket
>>> s1, s2 = Socket.socketpair()
>>> b1 = bytearray(b'----')
>>> b2 = bytearray(b'0123456789')
>>> b3 = bytearray(b'--------------')
>>> s1.send(b'Mary had a little lamb')
# 22
>>> s2.recvmsg_into([b1, memoryview(b2)[2:9], b3])
# (22, [], 0, None)
>>> [b1, b2, b3]
# [bytearray(b'Mary'), bytearray(b'01 had a 9'), bytearray(b'little lamb---')]
Доступность: большинство платформ Unix, возможно, и другие.

Socket.recvfrom_into(buffer[, nbytes[, flags]]):

Метод Socket.recvfrom_into() получает данные из сокета, записывая их в буфер вместо создания новой строки байтов.
Возвращаемое значение - это парный кортеж (nbytes, address), где
  • nbytes - это количество полученных байтов,
  • address - адрес сокета, отправляющего данные. Формат адреса address зависит от семейства адресов.
Информацию о значении необязательного аргумента flags (по умолчанию он равен нулю) смотрите на справочной странице по recv(2) Unix, командой $ man recv.

Socket.recv_into(buffer[, nbytes[, flags]]):

Метод Socket.recv_into() получает от сокета до nbytes байтов, сохраняя данные в буфере buffer, а не создавая новую строку байтов.
Если nbytes не указан или равен 0, то получает до размера, доступного в данном буфере. Возвращает количество полученных байтов.
Информацию о значении необязательного аргумента flags (по умолчанию он равен нулю) смотрите на справочной странице по recv(2) Unix, командой $ man recv.

Socket.send(bytes[, flags]):

Метод Socket.send() отправляет данные в сокет. Отправляющий сокет должен быть подключен к удаленному сокету.
Необязательный аргумент flags имеет то же значение, что и для метода Socket.recv() выше.
Возвращает количество отправленных байтов. Приложения несут ответственность за проверку того, что все данные были отправлены. Если была передана только часть данных, то приложению необходимо попытаться доставить оставшиеся данные.
Для получения дополнительной информации по этой теме обратитесь к разделу "Рекомендации по программированию сокетов".

Socket.sendall(bytes[, flags]):

Метод Socket.sendall() отправляет данные в сокет. Отправляющий сокет должен быть подключен к удаленному сокету.
Необязательный аргумент flags имеет то же значение, что и для метода Socket.recv() выше.
В отличие от метода Socket.send(), этот метод продолжает отправлять байтовые данные до тех пор, пока не будут отправлены все данные или не возникнет ошибка. В случае успеха ничего не возвращается. При ошибке возникает исключение и невозможно определить, сколько данных было успешно отправлено.

Socket.sendto(bytes, address)
Socket.sendto(bytes, flags, address):

Метод Socket.sendto() отправляет данные в сокет. Отправляющий сокет не должен быть подключен к удаленному сокету, поскольку сокет назначения указан в аргументе address. Формат адреса address зависит от семейства адресов.
Необязательный аргумент flags имеет то же значение, что и для метода Socket.recv() выше.
Метод Socket.sendto() возвращает количество отправленных байтов. Вызывает событие аудита socket.sendto с аргументами self, address.

Socket.sendmsg(buffers[, ancdata[, flags[, address]]]):

Метод Socket.sendmsg() отправляет обычные и вспомогательные данные в сокет, собирая обычные данные из ряда буферов и объединяя их в одно сообщение.
Аргумент buffers определяет обычные данные как итерацию байтоподобных объектов (например, объектов bytes); Операционная система может установить ограничение (os.sysconf() со значением SC_IOV_MAX) на количество buffers, которые могут использоваться.
Аргумент ancdata указывает вспомогательные данные (управляющие сообщения) как итерацию из нуля или более кортежей (cmsg_level, cmsg_type, cmsg_data), где
  • cmsg_level и cmsg_type - целые числа, определяющие уровень протокола и тип, специфичный для протокола соответственно,
  • cmsg_data - это байтоподобный объект, содержащий связанные данные.
Обратите внимание, что некоторые системы (в частности, системы без socket.CMSG_SPACE()) могут поддерживать отправку только одного управляющего сообщения за вызов.
Необязательный аргумент flags имеет то же значение, что и для метода Socket.recv() выше.
Если аргумент address не равен None, то он устанавливает адрес назначения для сообщения.
Метод Socket.sendmsg() возвращает количество отправленных байтов обычных данных.
В примере ниже функция send_fds() отправляет список файловых дескрипторов fds через сокет socket.AF_UNIX в системах, поддерживающих механизм socket.SCM_RIGHTS. Смотрите также метод Socket.recvmsg().
import socket, array

def send_fds(sock, msg, fds):
    return sock.sendmsg([msg], [(Socket.SOL_SOCKET, Socket.SCM_RIGHTS, array.array("i", fds))])
Доступность: большинство платформ Unix, возможно, другие.
Вызывает событие аудита socket.sendmsg с аргументами self, address.

Socket.sendmsg_afalg([msg, ]*, op[, iv[, assoclen[, flags]]]):

Метод Socket.sendmsg_afalg() это специализированная версия Socket.sendmsg() для сокета socket.AF_ALG.
Устанавливает режим, IV, AEAD, связанную длину данных и флаги для сокета socket.AF_ALG.
Доступность: Linux >= 2.6.38.
Новое в Python 3.6.

Socket.send_fds(sock, buffers, fds[, flags[, address]]):

Метод Socket.send_fds() отправляет список файловых дескрипторов fds через сокет socket.AF_UNIX.
Параметр fds представляет собой последовательность файловых дескрипторов.
Значение и поведение остальных аргументов метода смотрите в Socket.sendmsg().
Доступность: Unix поддерживает механизм Socket.sendmsg() и SCM_RIGHTS.
Новое в Python 3.9.

Socket.recv_fds(sock, bufsize, maxfds[, flags]):

Метод Socket.recv_fds() получает до maxfds файловых дескрипторов. Возвращает (msg, list(fds), flags, addr).
Значение и поведение аргументов метода смотрите в Socket.recvmsg().
Доступность: Unix поддерживает механизм Socket.recvmsg() и SCM_RIGHTS.
Новое в Python 3.9.
Обратите внимание на любые усеченные целые числа в конце списка файловых дескрипторов.

Socket.sendfile(file, offset=0, count=None):

Метод Socket.sendfile() отправляет файл до тех пор, пока не будет достигнут EOF с помощью высокопроизводительной системной функции os.sendfile и возвращает общее количество отправленных байтов.
Аргумент file должен быть обычным файловым объектом, открытым в двоичном режиме mode='rb'.
Если системная функция os.sendfile недоступна (например, Windows) или файл не является обычным файлом, вместо него будет использоваться метод Socket.send().
Аргумент offset указывает, откуда начать чтение файла.
Аргумент count, если указан, то это общее количество байтов для передачи в отличие от отправки файла до достижения EOF. Положение файла обновляется при возврате или также в случае ошибки, в этом случае file.tell() можно использовать для определения количества отправленных байтов.
Сокет должен быть типа socket.SOCK_STREAM. Неблокирующие сокеты не поддерживаются.

Socket.set_inheritable(inheritable):

Метод Socket.set_inheritable() устанавливает наследуемый флаг inheritable файлового дескриптора сокета или дескриптора сокета.

Socket.setblocking(flag):

Метод Socket.setblocking() устанавливает блокирующий или неблокирующий режим сокета: если флаг False, то сокет установлен в неблокирующий режим, в противном случае - в режим блокировки.
Этот метод является сокращением для некоторых вызовов Socket.settimeout():
  • Socket.setblocking(True) эквивалентен Socket.settimeout(None);
  • Socket.setblocking(False) эквивалентен Socket.settimeout(0.0).
Изменено в Python 3.7: метод больше не применяет флаг socket.SOCK_NONBLOCK к Socket.type.

Socket.settimeout(value):

Метод Socket.settimeout() устанавливает тайм-аут для блокировки операций сокета.
Аргумент value может быть неотрицательным числом float, выражающим секунды, или None.
  • Если аргументу value задано ненулевое значение, то последующие операции сокета вызовут исключение socket.timeout, если значение периода тайм-аута истекло до завершения операции.
  • Если value=0, то сокет переводится в неблокирующий режим.
  • Если value=None, то сокет переводится в режим блокировки.
Для получения дополнительной информации смотрите "Примечания о тайм-аутах сокетов".
Изменено в Python 3.7: метод больше не переключает флаг socket.SOCK_NONBLOCK на Socket.type.

Socket.setsockopt(level, optname, value: int)
Socket.setsockopt(level, optname, value: buffer)
Socket.setsockopt(level, optname, None, optlen: int):

Метод Socket.setsockopt() устанавливает значение value данной опции optname сокета (см. Страницу руководства Unix setsockopt (2)).
Необходимые символьные константы socket.SO_* и т. д. определены в модуле socket. Значение value может быть целым числом, None или байтовым объектом, представляющим буфер. В последнем случае вызывающая сторона должна убедиться, что строка байтов содержит правильные биты (как кодировать структуры языка С в байтовые строки, смотрите встроенный модуль struct). Если установлено значение None, то требуется аргумент optlen. Это эквивалентно вызову функции C setsockopt() с optval=NULL иoptlen=optlen`.
Изменено Python 3.6: добавлена ​​форма Socket.setsockopt(level, optname, None, optlen: int).

Socket.shutdown(how):

Метод Socket.shutdown() отключает одну или обе половины соединения.
  • Если how=socket.SHUT_RD, то дальнейшее получение запрещено.
  • Если how=socket.SHUT_WR, то дальнейшая отправка запрещена.
  • Если how=socket.SHUT_RDWR, то дальнейшая отправка и получение запрещены.

Socket.share(process_id):

Метод Socket.share() копирует сокет и подготавливает его для совместного использования с целевым процессом.
Целевой процесс должен быть предоставлен с идентификатором процесса process_id. Результирующий объект bytes затем может быть передан целевому процессу с использованием некоторой формы межпроцессного взаимодействия и сокет может быть воссоздан там с помощью функции socket.fromshare().
После вызова этого метода можно безопасно закрыть сокет, поскольку операционная система уже продублировала его для целевого процесса.
Обратите внимание, что нет методов read() или write(), вместо них используйте методы Socket.recv() и Socket.send() без аргумента flags.
Доступность: Windows.

Socket.family:

Атрибут Socket.family возвращает семейство сокетов (только для чтения).

Socket.type:

Атрибут Socket.type возвращает тип сокета (только для чтения).

Socket.proto:

Атрибут Socket.proto возвращает протокол на котором работает сокет (только для чтения).

Примечания о тайм-аутах сокетов.

Объект сокета может находиться в одном из трех режимов: блокирующий, неблокирующий или тайм-аут. По умолчанию сокеты всегда создаются в режиме блокировки, но это можно изменить, вызвав функцию socket.setdefaulttimeout().
  • В режиме блокировки, операции блокируются до тех пор, пока не будут завершены или система не возвратит ошибку (например, истекло время ожидания соединения).
  • В неблокирующем режиме операции завершаются неудачно (с ошибкой, которая, к сожалению, зависит от системы), если они не могут быть выполнены немедленно: можно использовать функции из модуля select для определения того, когда и доступен ли сокет для чтения или записи.
  • В режиме тайм-аута операции завершаются ошибкой, если они не могут быть завершены в течение тайм-аута, указанного для сокета (они вызывают исключение socket.timeout) или если система возвращает ошибку.
Примечание. На уровне операционной системы сокеты в режиме тайм-аута внутренне устанавливаются в неблокирующий режим. Кроме того, режимы блокировки и тайм-аута используются совместно дескрипторами файлов и объектами сокетов, которые относятся к одной и той же конечной точке сети. Эта деталь реализации может иметь видимые последствия, если, например, вы решили использовать метод сокета Socket.fileno().

Тайм-ауты и метод подключения.

Операция соединения Socket.connect() также зависит от установки тайм-аута, и в целом рекомендуется вызвать Socket.settimeout() перед вызовом Socket.connect() или передать параметр timeout в функцию socket.create_connection().
Однако системный сетевой стек может также возвращать собственную ошибку тайм-аута соединения независимо от любого параметра тайм-аута сокета Python.

Тайм-ауты и метод Socket.accept().

Если результат функции socket.getdefaulttimeout() не равен None, то сокеты, возвращаемые методом Socket.accept(), наследуют этот тайм-аут. В противном случае поведение зависит от настроек прослушивающего сокета:
  • если прослушивающий сокет находится в режиме блокировки или в режиме тайм-аута, то сокет, возвращаемый функцией Socket.accept(), находится в режиме блокировки;
  • если прослушивающий сокет находится в неблокирующем режиме, то состояние сокета, возвращаемый методом Socket.accept(), полностью зависит от операционной системы. Если необходимо обеспечить кросс-платформенное поведение, то рекомендуется вручную переопределить этот параметр.