Поиск локальных IP-адресов с помощью Python stdlib

import socket
socket.gethostbyname(socket.gethostname())

Это не будет работать всегда (возвращает 127.0.0.1 на машинах, имеющих имя хоста в /etc/hosts как 127.0.0.1), gimel показывает, что лучше использовать socket.getfqdn(). Конечно, вашей машине нужно разрешаемое имя хоста.

Боюсь, что нет хороших независимых от платформы способов сделать это, кроме подключения к другому компьютеру и отправки ему вашего IP-адреса. Например: findmyipaddress. Обратите внимание, что это не сработает, если вам нужен IP-адрес, который находится за NAT, если только компьютер, к которому вы подключаетесь, также не находится за NAT.

Вот одно из решений, которое работает в Linux: получить IP-адрес, связанный с сетевым интерфейсом.

Я только что нашел это, но это кажется немного хакерским, однако они говорят, что попробовал это на * nix, а я сделал это на Windows, и это сработало.

import socket
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(("8.8.8.8", 80))
print(s.getsockname()[0])
s.close()

Предполагается, что у вас есть доступ в Интернет и нет локального прокси.

Вы можете использовать модуль netifaces. Просто введите:

pip install netifaces

в вашей командной оболочке, и он установится при установке Python по умолчанию.

Тогда вы можете использовать это так:

from netifaces import interfaces, ifaddresses, AF_INET
for ifaceName in interfaces():
    addresses = [i['addr'] for i in ifaddresses(ifaceName).setdefault(AF_INET, [{'addr':'No IP addr'}] )]
    print '%s: %s' % (ifaceName, ', '.join(addresses))

На моем компьютере было напечатано:

{45639BDC-1050-46E0-9BE9-075C30DE1FBC}: 192.168.0.100
{D43A468B-F3AE-4BF9-9391-4863A4500583}: 10.5.9.207

Автор этого модуля утверждает, что он должен работать в Windows, UNIX и Mac OS X.

Если вы не хотите использовать внешние пакеты и не хотите полагаться на внешние серверы Интернета, это может помочь. Это образец кода, который я нашел на Google Code Search и модифицировал для возврата необходимой информации:

def getIPAddresses():
    from ctypes import Structure, windll, sizeof
    from ctypes import POINTER, byref
    from ctypes import c_ulong, c_uint, c_ubyte, c_char
    MAX_ADAPTER_DESCRIPTION_LENGTH = 128
    MAX_ADAPTER_NAME_LENGTH = 256
    MAX_ADAPTER_ADDRESS_LENGTH = 8
    class IP_ADDR_STRING(Structure):
        pass
    LP_IP_ADDR_STRING = POINTER(IP_ADDR_STRING)
    IP_ADDR_STRING._fields_ = [
        ("next", LP_IP_ADDR_STRING),
        ("ipAddress", c_char * 16),
        ("ipMask", c_char * 16),
        ("context", c_ulong)]
    class IP_ADAPTER_INFO (Structure):
        pass
    LP_IP_ADAPTER_INFO = POINTER(IP_ADAPTER_INFO)
    IP_ADAPTER_INFO._fields_ = [
        ("next", LP_IP_ADAPTER_INFO),
        ("comboIndex", c_ulong),
        ("adapterName", c_char * (MAX_ADAPTER_NAME_LENGTH + 4)),
        ("description", c_char * (MAX_ADAPTER_DESCRIPTION_LENGTH + 4)),
        ("addressLength", c_uint),
        ("address", c_ubyte * MAX_ADAPTER_ADDRESS_LENGTH),
        ("index", c_ulong),
        ("type", c_uint),
        ("dhcpEnabled", c_uint),
        ("currentIpAddress", LP_IP_ADDR_STRING),
        ("ipAddressList", IP_ADDR_STRING),
        ("gatewayList", IP_ADDR_STRING),
        ("dhcpServer", IP_ADDR_STRING),
        ("haveWins", c_uint),
        ("primaryWinsServer", IP_ADDR_STRING),
        ("secondaryWinsServer", IP_ADDR_STRING),
        ("leaseObtained", c_ulong),
        ("leaseExpires", c_ulong)]
    GetAdaptersInfo = windll.iphlpapi.GetAdaptersInfo
    GetAdaptersInfo.restype = c_ulong
    GetAdaptersInfo.argtypes = [LP_IP_ADAPTER_INFO, POINTER(c_ulong)]
    adapterList = (IP_ADAPTER_INFO * 10)()
    buflen = c_ulong(sizeof(adapterList))
    rc = GetAdaptersInfo(byref(adapterList[0]), byref(buflen))
    if rc == 0:
        for a in adapterList:
            adNode = a.ipAddressList
            while True:
                ipAddr = adNode.ipAddress
                if ipAddr:
                    yield ipAddr
                adNode = adNode.next
                if not adNode:
                    break

Использование:

>>> for addr in getIPAddresses():
>>>    print addr
192.168.0.100
10.5.9.207

Поскольку он полагается на windll, это будет работать только в Windows.

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

alias myip = "python -c 'import socket; print([l for l in ([ip for ip in socket.gethostbyname_ex(socket.gethostname())[2] if not ip.startswith(\"127.\")][:1], [[(s.connect((\"8.8.8.8\", 53)), s.getsockname()[0], s.close()) for s in [socket.socket(socket.AF_INET, socket.SOCK_DGRAM)]][0][1]]) if l][0][0])'"

• Правильно работает с Python 2.x, Python 3.x, современными и старыми дистрибутивами Linux, OSX / macOS и Windows для поиска текущего IPv4-адреса.
• Не вернет правильный результат для машин с несколькими IP-адресами, IPv6, без настроенного IP-адреса или без доступа в Интернет.

ПРИМЕЧАНИЕ: Если вы собираетесь использовать что-то подобное в программе Python, правильным способом является использование модуля Python с поддержкой IPv6.

То же, что и выше, но только код Python:

import socket
print([l for l in ([ip for ip in socket.gethostbyname_ex(socket.gethostname())[2] if not ip.startswith("127.")][:1], [[(s.connect(('8.8.8.8', 53)), s.getsockname()[0], s.close()) for s in [socket.socket(socket.AF_INET, socket.SOCK_DGRAM)]][0][1]]) if l][0][0])

• Это вызовет исключение, если IP-адрес не настроен.

Версия, которая также будет работать в локальных сетях без подключения к Интернету:

import socket
print((([ip for ip in socket.gethostbyname_ex(socket.gethostname())[2] if not ip.startswith("127.")] or [[(s.connect(("8.8.8.8", 53)), s.getsockname()[0], s.close()) for s in [socket.socket(socket.AF_INET, socket.SOCK_DGRAM)]][0][1]]) + ["no IP found"])[0])

(спасибо @ccpizza)

Фон:

Использование socket.gethostbyname(socket.gethostname()) здесь не сработало, потому что на одном из компьютеров, на котором я был, был /etc/hosts с повторяющимися записями и ссылками на себя. socket.gethostbyname() возвращает только последнюю запись в /etc/hosts.

Это была моя первая попытка отсеять все адреса, начинающиеся с "127.":

import socket
print([ip for ip in socket.gethostbyname_ex(socket.gethostname())[2] if not ip.startswith("127.")][:1])

Это работает с Python 2 и 3, в Linux и Windows, но не работает с несколькими сетевыми устройствами или IPv6. Однако он перестал работать в последних дистрибутивах Linux, поэтому вместо этого я попробовал эту альтернативную технику. Он пытается подключиться к DNS-серверу Google на 8.8.8.8 через порт 53:

import socket
print([(s.connect(('8.8.8.8', 53)), s.getsockname()[0], s.close()) for s in [socket.socket(socket.AF_INET, socket.SOCK_DGRAM)]][0][1])

Затем я объединил два вышеуказанных метода в однострочник, который должен работать везде, и создал псевдоним myip и фрагмент кода Python в верхней части этого ответа.

С ростом популярности IPv6 и для серверов с несколькими сетевыми интерфейсами использование стороннего модуля Python для поиска IP-адреса, вероятно, является более надежным и надежным, чем любой из перечисленных здесь методов.

Я использую следующий модуль:

#!/usr/bin/python
# module for getting the lan ip address of the computer

import os
import socket

if os.name != "nt":
    import fcntl
    import struct
    def get_interface_ip(ifname):
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        return socket.inet_ntoa(fcntl.ioctl(
                s.fileno(),
                0x8915,  # SIOCGIFADDR
                struct.pack('256s', bytes(ifname[:15], 'utf-8'))
                # Python 2.7: remove the second argument for the bytes call
            )[20:24])

def get_lan_ip():
    ip = socket.gethostbyname(socket.gethostname())
    if ip.startswith("127.") and os.name != "nt":
        interfaces = ["eth0","eth1","eth2","wlan0","wlan1","wifi0","ath0","ath1","ppp0"]
        for ifname in interfaces:
            try:
                ip = get_interface_ip(ifname)
                break;
            except IOError:
                pass
    return ip

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

Фиксированный список имен интерфейсов не работает для последних версий Linux, которые приняли изменение systemd v197 в отношении предсказуемых имен интерфейсов, как указано Александр. В таких случаях вам необходимо вручную заменить список именами интерфейсов в вашей системе или использовать другое решение, например netifaces.

К вашему сведению, я могу проверить, что метод:

import socket
addr = socket.gethostbyname(socket.gethostname())

Работает в OS X (10.6,10.5), Windows XP и на хорошо управляемом сервере отдела RHEL. Это не сработало на очень минимальной виртуальной машине CentOS, над которой я просто взламываю ядро. Поэтому для этого случая вы можете просто проверить адрес 127.0.0.1 и в этом случае сделать следующее:

if addr == "127.0.0.1":
     import commands
     output = commands.getoutput("/sbin/ifconfig")
     addr = parseaddress(output)

А затем проанализируйте IP-адрес из вывода. Следует отметить, что ifconfig по умолчанию не входит в PATH обычного пользователя, и поэтому я указываю полный путь в команде. Надеюсь, это поможет.

Я использую это на своих машинах с Ubuntu:

import commands
commands.getoutput("/sbin/ifconfig").split("\n")[1].split()[1][5:]

Это не работает.

Чтобы получить список IP-адресов в системах * nix,

import subprocess
co = subprocess.Popen(['ifconfig'], stdout = subprocess.PIPE)
ifconfig = co.stdout.read()
ip_regex = re.compile('((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-4]|2[0-5][0-9]|[01]?[0-9][0-9]?))')
[match[0] for match in ip_regex.findall(ifconfig, re.MULTILINE)]

Хотя это немного поздно для этого ответа, я подумал, что кому-то это может пригодиться :-)

PS: Он также вернет широковещательные адреса и сетевую маску.

Один простой способ произвести "чистый" вывод с помощью утилит командной строки:

import commands
ips = commands.getoutput("/sbin/ifconfig | grep -i \"inet\" | grep -iv \"inet6\" | " +
                         "awk {'print '} | sed -ne 's/addr\:/ /p'")
print ips

Он покажет все IPv4-адреса в системе.

У машины может быть несколько сетевых интерфейсов (включая локальный шлейф 127.0.0.1), о котором вы упомянули. Что касается ОС, то это еще и «настоящий IP-адрес».

Если вы хотите отслеживать все интерфейсы, взгляните на следующий пакет Puthon: http://alastairs-place.net/netifaces/

Я думаю, вы можете избежать того, чтобы gethostbyname возвращал 127.0.0.1, если вы опустите запись обратной связи из файла hosts. (подлежит проверке).

127.0.1.1является ваш реальный IP-адрес. В более общем смысле компьютер может иметь любое количество IP-адресов. Вы можете отфильтровать их для частных сетей - 127.0.0.0/8, 10.0.0.0/8, 172.16.0.0/12 и 192.168.0.0/16.

Однако не существует кроссплатформенного способа получить все IP-адреса. В Linux вы можете использовать SIOCGIFCONF ioctl.

Метод Socket API

см. https://stackoverflow.com/a/28950776/711085

Минусы:

• Не кроссплатформенный.
• Требуется дополнительный резервный код, связанный с наличием определенных адресов в Интернете.
• Это также не сработает, если вы находитесь за NAT.
• Вероятно, создает UDP-соединение, не независимо от доступности DNS (обычно ISP) (см. Другие ответы на такие идеи, как использование 8.8.8.8: сервер Google (по совпадению также DNS))
• Убедитесь, что вы сделали адрес назначения НЕДОСТУПНЫМ, как числовой IP-адрес, неиспользование которого гарантированно гарантировано. НЕ используйте какой-либо домен, например fakesubdomain.google.com или somefakewebsite.com; вы по-прежнему будете рассылать спам этой стороне (сейчас или в будущем), а также спамить свои собственные сетевые ящики в процессе.

Рефлекторный метод

(Обратите внимание, что это не отвечает на вопрос OP о локальном IP-адресе, например 192.168 ...; он дает вам ваш общедоступный IP-адрес, который может быть более желательным в зависимости от варианта использования.)

Вы можете запросить какой-либо сайт, например whatismyip.com (но с API), например:

from urllib.request import urlopen
import re
def getPublicIp():
    data = str(urlopen('http://checkip.dyndns.com/').read())
    # data = '<html><head><title>Current IP Check</title></head><body>Current IP Address: 65.96.168.198</body></html>\r\n'

    return re.compile(r'Address: (\d+\.\d+\.\d+\.\d+)').search(data).group(1)

или при использовании python2:

from urllib import urlopen
import re
def getPublicIp():
    data = str(urlopen('http://checkip.dyndns.com/').read())
    # data = '<html><head><title>Current IP Check</title></head><body>Current IP Address: 65.96.168.198</body></html>\r\n'

    return re.compile(r'Address: (\d+\.\d+\.\d+\.\d+)').search(data).group(1)

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

• Одним из преимуществ этого метода является кроссплатформенность.
• Он работает из-за уродливых NAT (например, вашего домашнего маршрутизатора).

Недостатки (и обходные пути):

• Требуется, чтобы этот веб-сайт был в рабочем состоянии, формат не менялся (почти наверняка не изменится) и чтобы ваши DNS-серверы работали. Можно смягчить эту проблему, также запросив другие сторонние отражатели IP-адресов в случае сбоя.
• Возможный вектор атаки, если вы не запрашиваете несколько отражателей (чтобы скомпрометированный отражатель не сообщал вам, что ваш адрес не является адресом) или если вы не используете HTTPS (чтобы предотвратить атаку типа `` злоумышленник посередине ''). быть сервером)

редактировать: Хотя изначально я думал, что эти методы действительно плохие (если вы не используете много резервных вариантов, код может быть неактуальным через много лет), все же возникает вопрос «что такое Интернет?». Компьютер может иметь множество интерфейсов, указывающих на множество различных сетей. Более подробное описание темы погуглите по gateways and routes. Компьютер может иметь доступ к внутренней сети через внутренний шлюз или к всемирной паутине через шлюз, например, на маршрутизаторе (обычно так). Локальный IP-адрес, о котором спрашивает OP, четко определен только для одного канального уровня, поэтому вы должны указать это («это сетевая карта или кабель Ethernet, о котором мы говорим?») . На поставленный вопрос может быть несколько неуникальных ответов. Однако глобальный IP-адрес во всемирной паутине, вероятно, четко определен (при отсутствии массивной фрагментации сети): вероятно, обратный путь через шлюз, который может получить доступ к TLD.

В Linux:

>>> import socket, struct, fcntl
>>> sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
>>> sockfd = sock.fileno()
>>> SIOCGIFADDR = 0x8915
>>>
>>> def get_ip(iface = 'eth0'):
...     ifreq = struct.pack('16sH14s', iface, socket.AF_INET, '\x00'*14)
...     try:
...         res = fcntl.ioctl(sockfd, SIOCGIFADDR, ifreq)
...     except:
...         return None
...     ip = struct.unpack('16sH2x4s8x', res)[2]
...     return socket.inet_ntoa(ip)
... 
>>> get_ip('eth0')
'10.80.40.234'
>>> 

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

Import WMI

def getlocalip():
    local = wmi.WMI()
    for interface in local.Win32_NetworkAdapterConfiguration(IPEnabled=1):
        for ip_address in interface.IPAddress:
            if ip_address != '0.0.0.0':
                localip = ip_address
    return localip







>>>getlocalip()
u'xxx.xxx.xxx.xxx'
>>>

Между прочим, WMI очень мощный ... если вы занимаетесь удаленным администрированием оконных машин, вам обязательно нужно проверить, что он может.

Мне пришлось решить задачу «Выяснить, является ли IP-адрес локальным или нет», и моей первой мыслью было составить список локальных IP-адресов, а затем сопоставить его. Вот что привело меня к этому вопросу. Однако позже я понял, что есть более простой способ сделать это: попробовать привязать этот IP-адрес и посмотреть, работает ли он.

_local_ip_cache = []
_nonlocal_ip_cache = []
def ip_islocal(ip):
    if ip in _local_ip_cache:
        return True
    if ip in _nonlocal_ip_cache:
        return False
    s = socket.socket()
    try:
        try:
            s.bind((ip, 0))
        except socket.error, e:
            if e.args[0] == errno.EADDRNOTAVAIL:
                _nonlocal_ip_cache.append(ip)
                return False
            else:
                raise
    finally:
        s.close()
    _local_ip_cache.append(ip)
    return True

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

Это будет работать на большинстве ящиков Linux:

import socket, subprocess, re
def get_ipv4_address():
    """
    Returns IP address(es) of current machine.
    :return:
    """
    p = subprocess.Popen(["ifconfig"], stdout=subprocess.PIPE)
    ifc_resp = p.communicate()
    patt = re.compile(r'inet\s*\w*\S*:\s*(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})')
    resp = patt.findall(ifc_resp[0])
    print resp

get_ipv4_address()

Небольшое уточнение версии команд, которая использует команду IP и возвращает адреса IPv4 и IPv6:

import commands,re,socket

#A generator that returns stripped lines of output from "ip address show"
iplines=(line.strip() for line in commands.getoutput("ip address show").split('\n'))

#Turn that into a list of IPv4 and IPv6 address/mask strings
addresses1=reduce(lambda a,v:a+v,(re.findall(r"inet ([\d.]+/\d+)",line)+re.findall(r"inet6 ([\:\da-f]+/\d+)",line) for line in iplines))
#addresses1 now looks like ['127.0.0.1/8', '::1/128', '10.160.114.60/23', 'fe80::1031:3fff:fe00:6dce/64']

#Get a list of IPv4 addresses as (IPstring,subnetsize) tuples
ipv4s=[(ip,int(subnet)) for ip,subnet in (addr.split('/') for addr in addresses1 if '.' in addr)]
#ipv4s now looks like [('127.0.0.1', 8), ('10.160.114.60', 23)]

#Get IPv6 addresses
ipv6s=[(ip,int(subnet)) for ip,subnet in (addr.split('/') for addr in addresses1 if ':' in addr)]

import socket
socket.gethostbyname(socket.getfqdn())

Этот ответ - моя личная попытка решить проблему получения IP-адреса LAN, поскольку socket.gethostbyname(socket.gethostname()) также вернул 127.0.0.1. Этот метод не требует подключения к Интернету, только подключение к локальной сети. Код предназначен для Python 3.x, но может быть легко преобразован для 2.x. Использование UDP-трансляции:

import select
import socket
import threading
from queue import Queue, Empty

def get_local_ip():
        def udp_listening_server():
            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
            s.bind(('<broadcast>', 8888))
            s.setblocking(0)
            while True:
                result = select.select([s],[],[])
                msg, address = result[0][0].recvfrom(1024)
                msg = str(msg, 'UTF-8')
                if msg == 'What is my LAN IP address?':
                    break
            queue.put(address)

        queue = Queue()
        thread = threading.Thread(target=udp_listening_server)
        thread.queue = queue
        thread.start()
        s2 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s2.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
        waiting = True
        while waiting:
            s2.sendto(bytes('What is my LAN IP address?', 'UTF-8'), ('<broadcast>', 8888))
            try:
                address = queue.get(False)
            except Empty:
                pass
            else:
                waiting = False
        return address[0]

if __name__ == '__main__':
    print(get_local_ip())

import socket
[i[4][0] for i in socket.getaddrinfo(socket.gethostname(), None)]

Примечание: это не использование стандартной библиотеки, но довольно простое.

$ pip install pif

from pif import get_public_ip
get_public_ip()

Что ж, вы можете использовать команду «ip route» в GNU / Linux, чтобы узнать свой текущий IP-адрес.

Это показывает IP, присвоенный интерфейсу DHCP-сервером, работающим на маршрутизаторе / модеме. Обычно «192.168.1.1/24» - это IP-адрес локальной сети, где «24» означает диапазон возможных IP-адресов, предоставленных DHCP-сервером в пределах диапазона маски.

Вот пример: обратите внимание, что PyNotify - это просто дополнение, чтобы ясно понять мою точку зрения, и он вообще не требуется

#! /usr/bin/env python

import sys , pynotify

if sys.version_info[1] != 7:
   raise RuntimeError('Python 2.7 And Above Only')       

from subprocess import check_output # Available on Python 2.7+ | N/A 

IP = check_output(['ip', 'route'])
Split_Result = IP.split()

# print Split_Result[2] # Remove "#" to enable

pynotify.init("image")
notify = pynotify.Notification("Ip", "Server Running At:" + Split_Result[2] , "/home/User/wireless.png")    
notify.show()    

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

Вы можете установить PyNotify с помощью easy_install или даже Pip:

easy_install py-notify

или же

pip install py-notify

или в скрипте / интерпретаторе python

from pip import main

main(['install', 'py-notify'])

Просто, но мило!

def getip():

    import socket
    hostname= socket.gethostname()
    ip=socket.gethostbyname(hostname)

    return(ip)

Это вариант ответа UnkwnTech - он предоставляет функцию get_local_addr(), которая возвращает основной IP-адрес локальной сети хоста. Я публикую его, потому что это добавляет ряд вещей: поддержку ipv6, обработку ошибок, игнорирование адресов localhost / linklocal и использование TESTNET addr (rfc5737) для подключения.

# imports
import errno
import socket
import logging

# localhost prefixes
_local_networks = ("127.", "0:0:0:0:0:0:0:1")

# ignore these prefixes -- localhost, unspecified, and link-local
_ignored_networks = _local_networks + ("0.", "0:0:0:0:0:0:0:0", "169.254.", "fe80:")

def detect_family(addr):
    if "." in addr:
        assert ":" not in addr
        return socket.AF_INET
    elif ":" in addr:
        return socket.AF_INET6
    else:
        raise ValueError("invalid ipv4/6 address: %r" % addr)

def expand_addr(addr):
    """convert address into canonical expanded form --
    no leading zeroes in groups, and for ipv6: lowercase hex, no collapsed groups.
    """
    family = detect_family(addr)
    addr = socket.inet_ntop(family, socket.inet_pton(family, addr))
    if "::" in addr:
        count = 8-addr.count(":")
        addr = addr.replace("::", (":0" * count) + ":")
        if addr.startswith(":"):
            addr = "0" + addr
    return addr

def _get_local_addr(family, remote):
    try:
        s = socket.socket(family, socket.SOCK_DGRAM)
        try:
            s.connect((remote, 9))
            return s.getsockname()[0]
        finally:
            s.close()
    except socket.error:
        # log.info("trapped error connecting to %r via %r", remote, family, exc_info=True)
        return None

def get_local_addr(remote=None, ipv6=True):
    """get LAN address of host

    :param remote:
        return  LAN address that host would use to access that specific remote address.
        by default, returns address it would use to access the public internet.

    :param ipv6:
        by default, attempts to find an ipv6 address first.
        if set to False, only checks ipv4.

    :returns:
        primary LAN address for host, or ``None`` if couldn't be determined.
    """
    if remote:
        family = detect_family(remote)
        local = _get_local_addr(family, remote)
        if not local:
            return None
        if family == socket.AF_INET6:
            # expand zero groups so the startswith() test works.
            local = expand_addr(local)
        if local.startswith(_local_networks):
            # border case where remote addr belongs to host
            return local
    else:
        # NOTE: the two addresses used here are TESTNET addresses,
        #       which should never exist in the real world.
        if ipv6:
            local = _get_local_addr(socket.AF_INET6, "2001:db8::1234")
            # expand zero groups so the startswith() test works.
            if local:
                local = expand_addr(local)
        else:
            local = None
        if not local:
            local = _get_local_addr(socket.AF_INET, "192.0.2.123")
            if not local:
                return None
    if local.startswith(_ignored_networks):
        return None
    return local

Вариант ответа ниндзягеко. Это должно работать в любой локальной сети, которая разрешает широковещательную передачу UDP и не требует доступа к адресу в локальной сети или в Интернете.

import socket
def getNetworkIp():
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
    s.connect(('<broadcast>', 0))
    return s.getsockname()[0]

print (getNetworkIp())

netifaces доступен через pip и easy_install. (Я знаю, его нет в базе, но, возможно, стоит установить.)

У netifaces есть некоторые странности на разных платформах:

• Интерфейс localhost / loop-back не всегда может быть включен (Cygwin).
• Адреса перечислены для каждого протокола (например, IPv4, IPv6), а протоколы перечислены для каждого интерфейса. В некоторых системах (Linux) каждая пара протокол-интерфейс имеет свой собственный связанный интерфейс (с использованием нотации имя_интерфейса: n), в то время как в других системах (Windows) один интерфейс будет иметь список адресов для каждого протокола. В обоих случаях есть список протоколов, но он может содержать только один элемент.

Вот код для netifaces, с которым можно поиграть:

import netifaces

PROTO = netifaces.AF_INET   # We want only IPv4, for now at least

# Get list of network interfaces
# Note: Can't filter for 'lo' here because Windows lacks it.
ifaces = netifaces.interfaces()

# Get all addresses (of all kinds) for each interface
if_addrs = [netifaces.ifaddresses(iface) for iface in ifaces]

# Filter for the desired address type
if_inet_addrs = [addr[PROTO] for addr in if_addrs if PROTO in addr]

iface_addrs = [s['addr'] for a in if_inet_addrs for s in a if 'addr' in s]
# Can filter for '127.0.0.1' here.

Приведенный выше код не отображает адрес обратно в имя интерфейса (полезно для генерации правил ebtables / iptables на лету). Итак, вот версия, которая хранит вышеуказанную информацию с именем интерфейса в кортеже:

import netifaces

PROTO = netifaces.AF_INET   # We want only IPv4, for now at least

# Get list of network interfaces
ifaces = netifaces.interfaces()

# Get addresses for each interface
if_addrs = [(netifaces.ifaddresses(iface), iface) for iface in ifaces]

# Filter for only IPv4 addresses
if_inet_addrs = [(tup[0][PROTO], tup[1]) for tup in if_addrs if PROTO in tup[0]]

iface_addrs = [(s['addr'], tup[1]) for tup in if_inet_addrs for s in tup[0] if 'addr' in s]

И нет, я не люблю понимание списков. В наши дни так работает мой мозг.

Следующий фрагмент распечатает все это:

from __future__ import print_function  # For 2.x folks
from pprint import pprint as pp

print('\nifaces = ', end='')
pp(ifaces)

print('\nif_addrs = ', end='')
pp(if_addrs)

print('\nif_inet_addrs = ', end='')
pp(if_inet_addrs)

print('\niface_addrs = ', end='')
pp(iface_addrs)

Наслаждаться!

На Debian (проверено), и я подозреваю, что большинство Linux ..

import commands

RetMyIP = commands.getoutput("hostname -I")

На MS Windows (проверено)

import socket

socket.gethostbyname(socket.gethostname())

Если у компьютера есть маршрут к Интернету, всегда будет работать для получения предпочтительного локального IP-адреса, даже если / etc / hosts установлен неправильно.

import socket

s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(('8.8.8.8', 1))  # connect() for UDP doesn't send packets
local_ip_address = s.getsockname()[0]

Версия, которая, как мне кажется, еще не была опубликована. Я тестировал python 2.7 на Ubuntu 12.04.

Нашел это решение по адресу: http://code.activestate.com/recipes/439094-get-the-ip-address-associated-with-a-network-inter/

import socket
import fcntl
import struct

def get_ip_address(ifname):
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    return socket.inet_ntoa(fcntl.ioctl(
        s.fileno(),
        0x8915,  # SIOCGIFADDR
        struct.pack('256s', ifname[:15])
    )[20:24])

Пример результата:

>>> get_ip_address('eth0')
'38.113.228.130'

Этот метод возвращает «основной» IP-адрес в локальном поле (тот, у которого есть маршрут по умолчанию)..

• НЕ требует маршрутизируемого доступа к сети или какого-либо соединения вообще.
• Работает, даже если все интерфейсы отключены от сети.
• НЕ нужно и даже не пытается получить где-нибудь еще.
• Работает с NAT, общедоступными, частными, внешними и внутренними IP-адресами
• Чистый Python 2 (или 3) без внешних зависимостей.
• Работает в Linux, Windows и OSX.

Python 3 или 2:

import socket
def get_ip():
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    try:
        # doesn't even have to be reachable
        s.connect(('10.255.255.255', 1))
        IP = s.getsockname()[0]
    except Exception:
        IP = '127.0.0.1'
    finally:
        s.close()
    return IP

Это возвращает единственный IP-адрес, который является основным (с маршрутом по умолчанию). Если вместо этого вам нужны все IP-адреса, подключенные ко всем интерфейсам (включая localhost и т. д.), См. этот ответ.

Если вы находитесь за брандмауэром NAT, например, за вашим Wi-Fi-устройством дома, тогда он не будет отображать ваш общедоступный IP-адрес NAT, а вместо этого будет отображаться ваш частный IP-адрес в локальной сети, который имеет маршрут по умолчанию к вашему локальному маршрутизатору WIFI; получение внешнего IP-адреса вашего Wi-Fi-маршрутизатора потребует либо запуска этого в ЭТОМ поле, либо подключения к внешней службе, такой как whatismyip.com/whatismyipaddress.com, которая может отражать IP-адрес ... но это полностью отличается от исходного вопроса. :)

Это не очень похоже на Pythonic, но надежно работает в Windows.

def getWinIP(version = 'IPv4'):
    import subprocess
    if version not in ['IPv4', 'IPv6']:
        print 'error - protocol version must be "IPv4" or "IPv6"'
        return None
    ipconfig = subprocess.check_output('ipconfig')
    my_ip = []
    for line in ipconfig.split('\n'):
        if 'Address' in line and version in line:
            my_ip.append(line.split(' : ')[1].strip())
    return my_ip

print getWinIP()

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

Версия Python 3.4, использующая недавно представленный пакет asyncio.

async get_local_ip():
    loop = asyncio.get_event_loop()
    transport, protocol = await loop.create_datagram_endpoint(
        asyncio.DatagramProtocol,
        remote_addr=('8.8.8.8', 80))
    result = transport.get_extra_info('sockname')[0])
    transport.close()
    return result

Это основано на отличный ответ UnkwnTech.

Чтобы получить IP-адрес, вы можете использовать команда оболочки прямо в питон:

import socket, subprocess

def get_ip_and_hostname():
    hostname =  socket.gethostname()

    shell_cmd = "ifconfig | awk '/inet addr/{print substr(,6)}'"
    proc = subprocess.Popen([shell_cmd], stdout=subprocess.PIPE, shell=True)
    (out, err) = proc.communicate()

    ip_list = out.split('\n')
    ip = ip_list[0]

    for _ip in ip_list:
        try:
            if _ip != "127.0.0.1" and _ip.split(".")[3] != "1":
                ip = _ip
        except:
            pass
    return ip, hostname

ip_addr, hostname = get_ip_and_hostname()

Я решил использовать службу и / или API ipfy: https://www.ipify.org.

#!/usr/bin/env python3
from urllib.request import urlopen


def public_ip():
    data = urlopen('https://api.ipify.org').read()
    return str(data, encoding='utf-8')


print(public_ip())

Ответ также можно получить в форматах JSON и JSONP.

На Github есть ipifyБиблиотека Python.

Это очень похоже на ранее опубликованные ответы, но я не смог найти ни одного с таким использованием вызовов. Это то, что я использую для ipv4. Для ipv6 измените "." в ":" в

import socket
print next(i[4][0] for i in socket.getaddrinfo(
    socket.gethostname(), 80) if '127.' not in i[4][0] and '.' in i[4][0]);"

from netifaces import interfaces, ifaddresses, AF_INET
iplist = [ifaddresses(face)[AF_INET][0]["addr"] for face in interfaces() if AF_INET in ifaddresses(face)]
print(iplist)
['10.8.0.2', '192.168.1.10', '127.0.0.1']

import socket
print(socket.gethostbyname(socket.getfqdn()))

import netifaces as ni 

ni.ifaddresses('eth0')
ip = ni.ifaddresses('eth0')[ni.AF_INET][0]['addr']
print(ip)

Это вернет вам IP-адрес в системе Ubuntu, а также MacOS. На выходе будет IP-адрес системы, как у моего IP: 192.168.1.10.

Если вы ищете IPV4-адрес, отличный от IP-адреса вашего локального хоста 127.0.0.1, вот изящный фрагмент кода Python:

import subprocess
address = subprocess.check_output(['hostname', '-s', '-I'])
address = address.decode('utf-8') 
address=address[:-1]

Что также можно записать одной строкой:

address = subprocess.check_output(['hostname', '-s', '-I']).decode('utf-8')[:-1]

Даже если вы поместите localhost в /etc/hostname, код все равно предоставит ваш локальный IP-адрес.

Еще один вариант предыдущих ответов можно сохранить в исполняемом скрипте с именем my-ip-to:

#!/usr/bin/env python

import sys, socket

if len(sys.argv) > 1:
    for remote_host in sys.argv[1:]:
        # determine local host ip by outgoing test to another host
        # use port 9 (discard protocol - RFC 863) over UDP4
        with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
            s.connect((remote_host, 9))
            my_ip = s.getsockname()[0]
            print(my_ip, flush=True)
else:
    import platform

    my_name = platform.node()
    my_ip = socket.gethostbyname(my_name)
    print(my_ip)

он берет любое количество удаленных хостов и распечатывает локальные IP-адреса для доступа к ним один за другим:

$ my-ip-to z.cn g.cn localhost
192.168.11.102
192.168.11.102
127.0.0.1
$

И выведите лучший вариант, если не указан аргумент.

$ my-ip-to
192.168.11.102

Для linux env прочтите / proc / net / tcp, второй (локальный адрес) и третий (удаленный адрес) дадут IP-адреса в шестнадцатеричном формате.

Совет: если второй столбец обнулен (00000000: 0000), значит, это порт прослушивания :)

https://github.com/romol0s/python/blob/master/general/functions/getTcpListenIpsByPort.py

https://www.kernel.org/doc/Documentation/networking/proc_net_tcp.txt

Для Linux вы можете просто использовать check_output из системной команды hostname -I следующим образом:

from subprocess import check_output
check_output(['hostname', '-I'])

pyroute2 - отличная библиотека, с помощью которой можно получить не только IP-адреса, но также информацию о шлюзе и другую полезную информацию. Следующий код может получить IPv4-адрес любого интерфейса.

from pyroute2 import IPRoute
ip = IPRoute()

def get_ipv4_address(intf):
    return dict(ip.get_addr(label=intf)[0]['attrs'])['IFA_LOCAL']

print(get_ipv4_address('eth0'))

Решение для Windows, возьми или оставь.

получает только собственный IP-адрес текущего активного wlan [беспроводная локальная сеть], то есть IP-адрес компьютера (маршрутизатор Wi-Fi или сетевой коммутатор).

примечание: это не общедоступный IP-адрес устройства и не включает никаких внешних запросов, пакетов или общедоступных API.

Основная идея - проанализировать вывод shell command: ipconfig или ifconfig в Linux. мы используем подпроцесс для получения вывода.

def wlan_ip():
    import subprocess
    result=subprocess.run('ipconfig',stdout=subprocess.PIPE,text=True).stdout.lower()
    scan=0
    for i in result.split('\n'):
        if 'wireless' in i: #use "wireless" or wireless adapters and "ethernet" for wired connections
            scan=1
        if scan:
            if 'ipv4' in i:
                return i.split(':')[1].strip()
print(wlan_ip())

вот что происходит после CMD: 'ipconfig':

мы получаем этот вывод, мы захватили его в python, используя вывод подпроцесса.

C:\Users\dell>ipconfig

Wireless LAN adapter Wi-Fi:

   Connection-specific DNS Suffix  . :
   Link-local IPv6 Address . . . . . : fe80::f485:4a6a:e7d5:1b1c%4
   IPv4 Address. . . . . . . . . . . : 192.168.0.131
   Subnet Mask . . . . . . . . . . . : 255.255.255.0
   Default Gateway . . . . . . . . . : 192.168.0.1

и мы проанализировали строку в python таким образом, чтобы выбрать ip беспроводного адаптера в текущей сети.