Wyszukiwanie lokalnych adresów IP przy użyciu Stdlib Pythona

Właśnie znalazłem to, ale wydaje się to trochę hakerskie, jednak mówią, że próbowałem go na * nix i zrobiłem na windows i to działało.

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

Zakłada to, że masz dostęp do Internetu i że nie ma lokalnego proxy.

Ta metoda zwraca "główny" adres IP w polu lokalnym (tym z domyślną trasą) .

• nie wymaga routowalnego dostępu do sieci ani żadnego połączenia.
• działa nawet wtedy, gdy wszystkie interfejsy są odłączone od sieci.
• nie potrzebuje ani nawet nie próbuje dostaćgdziekolwiek indziej .
W tym celu należy skontaktować się z Działem obsługi klienta.]}
• czysty Python 2 (lub 3) bez zewnętrznych zależności.
• działa na Linuksie, Windows i OSX.

Python 3 lub 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

Zwraca pojedynczy adres IP, który jest głównym (tym z domyślną trasą). Jeśli zamiast tego potrzebujesz wszystkich adresów IP dołączonych do wszystkich interfejsów (w tym localhost, itp.), Zobacz ta odpowiedź.

Jeśli znajdujesz się za zaporą NAT, taką jak twoja skrzynka Wi-Fi w domu, to nie wyświetli twojego publicznego adresu IP NAT, ale zamiast tego twój prywatny adres IP w sieci lokalnej, który ma domyślną trasę do lokalnego routera Wi-Fi; uzyskanie routera Wi-Fi zewnętrzny IP wymagałby albo uruchomienia tego na tej skrzynce, albo połączenia z zewnętrzną usługą, taką jak whatismyip.com/whatismyipaddress.com to może odzwierciedlać IP... ale to jest zupełnie inne od pierwotnego pytania. :)

Jako alias o nazwie myip, który powinien działać wszędzie:

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])'"

• działa poprawnie z Pythonem 2.x, Python 3.x, nowoczesne i stare dystrybucje Linuksa, OSX / macOS i Windows do znalezienia bieżącego adresu IPv4.
• nie zwróci poprawnego wyniku dla komputerów z wieloma adresami IP, IPv6, bez skonfigurowanego adresu IP lub bez dostępu do Internetu.

Uwaga: jeśli zamierzasz używać czegoś takiego w programie Pythona, właściwym sposobem jest aby skorzystać z modułu Pythona, który ma obsługę IPv6.

To samo co wyżej, ale tylko Kod Pythona:

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])

• spowoduje to wyświetlenie wyjątku, jeśli nie jest skonfigurowany żaden adres IP.

Wersja, która będzie działać również na sieci LAN bez połączenia z Internetem:

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])

(thanks @ ccpizza)

Tło :

Używanie socket.gethostbyname(socket.gethostname()) nie zadziałało tutaj, ponieważ jeden z komputerów na którym byłem miał /etc/hosts z duplikatami wpisów i odniesieniami do siebie. socket.gethostbyname() zwraca tylko ostatni wpis w /etc/hosts.

To była moja pierwsza próba, która wypowiada wszystkie adresy zaczynające się od "127.":

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

To działa z Pythonem 2 i 3, na Linuksie i Windows, ale nie zajmuje się kilkoma urządzeniami sieciowymi lub IPv6. Jednak przestał działać na ostatnich dystrybucjach Linuksa, więc zamiast tego wypróbowałem tę alternatywną technikę. Próbuje połączyć się z serwerem DNS Google na 8.8.8.8 na porcie 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])

Następnie połączyłem dwie powyższe techniki w jedną linijkę, która powinna działać wszędzie i stworzyłem myip alias i fragment Pythona na górze tej odpowiedzi.

Wraz ze wzrostem popularności IPv6 i dla serwerów z wieloma interfejsami sieciowymi, użycie zewnętrznego modułu Pythona do wyszukiwania adresu IP jest prawdopodobnie bardziej niezawodne i niezawodne niż jakakolwiek z wymienionych tutaj metod.

Możesz użyć modułunetifaces . Wpisz tylko:

pip install netifaces

W powłoce poleceń i zainstaluje się na domyślnej instalacji Pythona.

Wtedy możesz użyć go tak:

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))

Na moim komputerze Wydrukowano:

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

Autor tego modułu twierdzi, że powinien on działać na systemach Windows, UNIX i Mac OS X.

Jeśli komputer ma trasę do Internetu, to Zawsze będzie działać, aby uzyskać preferowany lokalny adres ip, nawet jeśli /etc / hosts nie jest ustawiony poprawnie.

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]

Metoda Socket API

Zobacz https://stackoverflow.com/a/28950776/711085

Wady:

• Nie między platformami.
• wymaga więcej kodu awaryjnego, związanego z istnieniem konkretnych adresów w Internecie
• to również nie zadziała, jeśli jesteś za NAT
• prawdopodobnie tworzy połączenie UDP, nie niezależne od (Zwykle ISP) dostępności DNS (zobacz inne odpowiedzi na pomysły, takie jak za pomocą 8.8.8.8: Google (przypadkowo również serwer DNS))
• upewnij się, że adres docelowy jest nieosiągalny, podobnie jak numeryczny adres IP, który jest spec-gwarantowany jako nieużywany. Nie używaj jakiejś domeny jak fakesubdomain.google.com lub somefakewebsite.com; nadal będziesz spamować tę stronę (Teraz lub w przyszłości), a także spamować własne skrzynki sieciowe.

Metoda Reflektora

(zauważ, że nie odpowiada to na pytanie OP dotyczące lokalnego IP adres, np. 192.168...; daje Twój publiczny adres IP, który może być bardziej pożądany w zależności od przypadku użycia.)

Możesz odpytywać jakąś stronę jak whatismyip.com (ale z API), np.:

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)

Lub jeśli używasz 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)

Zalety:

Jedną z zalet tej metody jest jej wieloplatformowość.]}
• Działa zza brzydkich natów (np. routera domowego).

Wady (i obejścia):

• wymaga tej strony aby być, format się nie zmienia (prawie na pewno nie będzie), a serwery DNS do pracy. Można złagodzić ten problem, pytając również o reflektory adresów IP innych firm w przypadku awarii.
• możliwy wektor ataku, jeśli nie odpytywasz wielu reflektorów (aby uniemożliwić zagrożonemu reflektorowi poinformowanie Cię, że twój adres jest czymś, czym nie jest) lub jeśli nie używasz HTTPS (aby zapobiec atakowi man-in-the-middle udającemu, że jest Serwer)

edit: chociaż początkowo myślałem, że te metody są naprawdę złe (chyba, że używasz wielu fallbacków, kod może być nieistotny za wiele lat), rodzi to pytanie " co to jest internet?". Komputer może mieć wiele interfejsów wskazujących na wiele różnych sieci. Aby uzyskać dokładniejszy opis tematu, poszukaj w google dla gateways and routes. Komputer może być w stanie uzyskać dostęp do sieci wewnętrznej za pośrednictwem bramy wewnętrznej lub uzyskać dostęp do sieci ogólnoświatowej za pośrednictwem bramy na przykład na routerze (zwykle w przypadku). Lokalny adres IP, o który pyta OP, jest dobrze zdefiniowany tylko w odniesieniu do pojedynczej warstwy łącza, więc musisz to określić ("czy to Karta sieciowa, czy kabel ethernet, o którym mówimy?"). Może istnieć wiele nie unikalnych odpowiedzi na to pytanie, jak postawione. Jednak globalny adres IP w sieci ogólnoświatowej jest prawdopodobnie dobrze zdefiniowany( przy braku ogromnej fragmentacji sieci): prawdopodobnie ścieżka powrotna przez bramę, która może uzyskać dostęp do TLD.

Na Linuksie:

>>> 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'
>>> 

Im za pomocą następującego modułu:

#!/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

Testowane z windows i linux (i nie wymaga dodatkowych modułów dla tych) przeznaczony do stosowania w systemach, które są w pojedynczej sieci LAN opartej na protokole IPv4.

Stała lista nazw interfejsów nie działa dla najnowszych wersji Linuksa, które przyjęły zmianę systemd v197 dotyczącą przewidywalnych nazw interfejsów, jak wskazał Alexander . W takich przypadkach należy ręcznie zastąpić listę nazwami interfejsów w systemie, lub użyć innego rozwiązania, takiego jak netifaces .

Używam tego na moich maszynach ubuntu:

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

Jeśli nie chcesz używać zewnętrznych pakietów i nie chcesz polegać na zewnętrznych serwerach internetowych, może to pomóc. Jest to przykład kodu, który znalazłem w Google Code Search i zmodyfikowałem, aby zwrócić wymagane informacje:

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

Użycie:

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

Ponieważ opiera się na windll, będzie działać tylko w systemie Windows.

Wersja, której nie sądzę, że została jeszcze opublikowana. Testowałem z Pythonem 2.7 na Ubuntu 12.04.

Znalazłem to rozwiązanie na: 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])

Przykładowy Wynik:

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

Na Debianie (przetestowany) i podejrzewam, że większość Linuksa..

import commands

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

Na MS Windows (testowany)

import socket

socket.gethostbyname(socket.gethostname())

Wariacja na temat odpowiedzi ninjagecko. Powinno to działać w każdej sieci LAN, która umożliwia transmisję UDP i nie wymaga dostępu do adresu W SIECI LAN lub Internecie.

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())

Jest to wariant odpowiedzi UnkwnTech -- dostarcza ona funkcji get_local_addr(), która zwraca główny adres ip LAN hosta. Zamieszczam go, ponieważ dodaje to wiele rzeczy: wsparcie dla ipv6, obsługę błędów, ignorowanie adresów localhost/linklocal i używa ADDR TESTNET (rfc5737) do połączenia.

# 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

Obawiam się, że nie ma żadnych dobrych niezależnych od platformy sposobów, aby to zrobić, poza połączeniem się z innym komputerem i wysłaniem przez niego adresu IP. Na przykład: findmyipaddress. Zauważ, że to nie zadziała, jeśli potrzebujesz adresu IP, który znajduje się za NAT, chyba że komputer, z którym się łączysz, również znajduje się za NAT.

Oto jedno rozwiązanie, które działa w Linuksie: Uzyskaj adres IP powiązany z interfejsem sieciowym .

FYI mogę zweryfikować, że metoda:

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

Działa w OS X (10.6,10.5), Windows XP oraz na dobrze zarządzanym serwerze RHEL department. To nie działa na bardzo minimalnym CentOS VM, że po prostu zrobić kilka kernel hacking na. Tak więc w tym przypadku możesz po prostu sprawdzić adres 127.0.0.1 i w takim przypadku wykonać następujące czynności:

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

A następnie przeanalizuj adres ip z wyjścia. Należy zauważyć, że ifconfig domyślnie nie znajduje się w ścieżce normalnego użytkownika i dlatego daję pełna ścieżka w poleceniu. Mam nadzieję, że to pomoże.

Jeden prosty sposób na uzyskanie "czystego" wyjścia za pomocą utils wiersza poleceń:

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

Wyświetli wszystkie adresy IPv4 w systemie.

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

To będzie działać na większości linuksowych pudełek:

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()

Ta odpowiedź jest moją osobistą próbą rozwiązania problemu uzyskania IP LAN, ponieważ socket.gethostbyname(socket.gethostname()) również zwrócił 127.0.0.1. Ta metoda nie wymaga internetu tylko połączenia LAN. Kod jest dla Pythona 3.x, ale może być łatwo przekonwertowany na 2.x. Using UDP Broadcast:

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())

Jeśli szukasz adresu IPV4 innego niż adres IP localhost 127.0.0.1, Oto zgrabny fragment kodu Pythona:

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

Które można również zapisać w jednej linijce:

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

Nawet jeśli umieścisz localhost w /etc/hostname, Kod nadal poda Twój lokalny adres IP.

Dla Linuksa, możesz po prostu użyć check_output z hostname -I polecenia systemowego w następujący sposób:

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

127.0.1.1 to twój prawdziwy adres IP. Mówiąc bardziej ogólnie, komputer może mieć dowolną liczbę adresów IP. Możesz filtrować je dla sieci prywatnych- 127.0.0.0/8, 10.0.0.0/8, 172.16.0.0/12 i 192.168.0.0/16.

Nie ma jednak wieloplatformowego sposobu na uzyskanie wszystkich adresów IP. Na Linuksie możesz użyć SIOCGIFCONF ioctl.

Niewielkie udoskonalenie wersji poleceń, która używa polecenia IP i zwraca adresy IPv4 i 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)]

Cóż, możesz użyć polecenia "trasa ip" na GNU / Linuksie, aby poznać swój aktualny adres IP.

Pokazuje adres IP podany interfejsowi przez serwer DHCP działający na routerze / modemie. Zwykle" 192.168.1.1/24 "to adres IP dla sieci lokalnej, gdzie "24"oznacza zakres możliwych adresów IP podanych przez serwer DHCP w zakresie maski.

Oto przykład: zauważ, że PyNotify jest tylko dodatkiem, aby wyprostować mój punkt widzenia i nie jest wcale wymagany

#! /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()    

Korzyść jest to, że nie trzeba określać interfejsu sieciowego. Jest to bardzo przydatne podczas uruchamiania serwera socket

easy_install py-notify

Lub

pip install py-notify

Lub w skrypcie/interpreterze Pythona

from pip import main

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

Uwaga: nie jest to użycie biblioteki standardowej, ale dość proste.

$ pip install pif

from pif import get_public_ip
get_public_ip()

Netifaces jest dostępny przez pip i easy_install. (Wiem, nie jest w bazie, ale może warto zainstalować.)

• interfejs localhost / loop-back nie zawsze może być dołączony (Cygwin).
IPv4, IPv6), a protokoły są wymienione na interfejsie. W niektórych systemach (Linuksie) każda para protokołów-interfejsów ma swój własny powiązany interfejs (używając notacji interface_name: n) podczas gdy w innych systemach (Windows) pojedynczy interfejs będzie miał listę adresów dla każdego protokołu. W obu przypadkach istnieje lista protokołów, ale może ona zawierać tylko jeden element.

Oto kod netifaces do zabawy:

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.

Powyższy kod nie mapuje adresu z powrotem do jego nazwy interfejsu(przydatne do generowania reguł ebtables/iptables w locie). Oto więc wersja, która przechowuje powyższe informacje z nazwą interfejsu w krotce:

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]

Oraz, Nie, Nie jestem zakochana w składaniu list. Tak działa mój mózg.

Poniższy fragment wydrukuje to wszystko:

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)

Wersja Pythona 3.4 wykorzystująca nowo wprowadzony pakiet 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

import netifaces as ni 

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

Zwróci ci adres IP w systemie Ubuntu oraz MacOS. Wyjściem będzie systemowy adres IP jak mój IP: 192.168.1.10.