Trouver des adresses IP à l'aide de Python stdlib

Je viens de trouver cela, mais il semble un peu hackish, cependant, disent-ils essayé sur *nix et je l'ai fait sur windows et ça a fonctionné.

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

Cela suppose que vous avez un accès à internet, et qu'il n'y a pas de proxy local.

OriginalL'auteur UnkwnTech

Comme un alias appelé myip, qui devrait fonctionner partout:

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

• Fonctionne correctement avec Python 2.x, Python 3.x, le moderne et l'ancien des distributions Linux, OSX/mac os et Windows pour trouver l'adresse IPv4 courante.
• Ne reviendra pas le résultat correct pour les machines avec plusieurs adresses IP, IPv6, pas configuré l'adresse IP ou pas d'accès internet.

---

Même que ci-dessus, mais seulement le code 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])

• Cela va lever une exception si aucune adresse IP n'est configuré.

---

Version qui fonctionne également sur les réseaux locaux sans connexion internet:

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

(merci @ccpizza)

---

Fond:

À l'aide de socket.gethostbyname(socket.gethostname()) n'a pas de travail ici, parce que l'un des ordinateurs que j'était sur eu un /etc/hosts avec les doublons et les références à lui-même. socket.gethostbyname() retourne seulement la dernière entrée dans /etc/hosts.

C'était ma première tentative, ce qui élimine toutes les adresses commençant par "127.":

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

Cela fonctionne avec Python 2 et 3, sur Linux et Windows, mais ne permet pas de traiter avec plusieurs périphériques réseau ou IPv6. Cependant, il a cessé de travailler sur les dernières distributions Linux, j'ai donc essayé cette technique alternative à la place. Il essaie de se connecter à Google serveur DNS à 8.8.8.8 au port 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])

Alors j'ai combiné les deux techniques ci-dessus dans un one-liner qui devrait fonctionner partout, et a créé la myip alias et extrait Python en haut de cette réponse.

Avec la popularité croissante de l'IPv6, et pour les serveurs avec plusieurs interfaces réseau, à l'aide d'un tiers d'un module Python pour trouver l'adresse IP est probablement à la fois plus robuste et plus fiable que les méthodes décrites ici.

OriginalL'auteur Alexander

API Socket méthode

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

Inconvénients:

• Pas de croix-plate-forme.
• Nécessite plus de secours code, liés à l'existence des adresses sur internet
• Cela ne fonctionnera pas si vous êtes derrière un NAT
• Probablement crée une connexion UDP, non indépendant (généralement FAI) la disponibilité du DNS (voir les autres réponses pour des idées comme l'utilisation de 8.8.8.8: Google (coïncidence aussi DNS) un serveur)
• Assurez-vous de vous rendre à l'adresse de destination INACCESSIBLE, comme une adresse numérique IP, c'est-spec-garanti pour être utilisés. Ne PAS utiliser certains domaine comme fakesubdomain.google.com ou somefakewebsite.com; vous aurez toujours la spamming cette partie (maintenant ou dans l'avenir), et du spam de votre propre réseau de cases bien dans le processus.

---

Réflecteur méthode

(Notez que cela ne répond pas à l'OP de la question de l'adresse IP locale, par exemple 192.168...; il vous donne votre adresse IP publique, qui pourrait être plus souhaitable, selon les cas d'utilisation.)

Vous pouvez interroger certains sites comme whatismyip.com (mais avec une API), tels que:

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)

ou si vous utilisez 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)

Avantages:

• Un autre avantage de cette méthode est qu'il est multi-plateforme
• Il travaille à partir de derrière laid NATs (par exemple, votre routeur domestique).

Inconvénients (et les solutions):

• Nécessite de ce site web, le format change pas (presque certainement ne va pas), et de vos serveurs DNS de travail. On peut atténuer ce problème en interrogeant d'autres tiers adresse IP réflecteurs en cas de panne.
• Vecteur d'attaque Possible si vous n'avez pas de requête de plusieurs réflecteurs (pour éviter un compromis réflecteur de vous dire que votre adresse est quelque chose qu'il n'est pas), ou si vous n'utilisez pas le protocole HTTPS (pour éviter un man-in-the-middle attack prétendant être le serveur)

---

modifier: Si au départ j'ai pensé que ces méthodes ont été vraiment mauvais (sauf si vous utilisez plusieurs issues, le code peut être pas pertinent de nombreuses années à partir de maintenant), il pose la question "qu'est-ce que l'internet?". Un ordinateur peut avoir de nombreux liens pointant vers beaucoup de différents réseaux. Pour une description plus détaillée du sujet, google pour gateways and routes. Un ordinateur peut être en mesure d'accéder à un réseau interne via une gateway interne, ou d'accéder à la world-wide web par le biais d'une passerelle, par exemple un routeur (généralement le cas). L'adresse IP locale que l'OP pose des questions sur n'est bien définie par rapport à une seule couche de liaison, de sorte que vous avez à préciser que ("est-ce la carte réseau ou le câble ethernet, ce qui nous parlons?"). Il peut y avoir plusieurs non-uniques réponses à cette question posée. Cependant, l'adresse IP globale sur le world wide web est probablement bien définies (en l'absence de l'immense réseau de la fragmentation): probablement la voie de retour via la passerelle qui peut accéder au Tld.

OriginalL'auteur ninjagecko

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

OriginalL'auteur tMC

Je l'utiliser sur mon ubuntu machines:

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

Cela ne fonctionne pas.

OriginalL'auteur shino

Une version que je ne crois pas qu'a été publié pour le moment.
J'ai testé avec python 2.7 sur Ubuntu 12.04.

Trouvé cette solution : 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])

Exemple De Résultat:

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

OriginalL'auteur Graham Chap

Variation sur ninjagecko de réponse. Cela devrait fonctionner sur n'importe quel réseau local qui permet la diffusion UDP et ne nécessite pas l'accès à une adresse sur le réseau local ou internet.

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

OriginalL'auteur dlm

Un moyen simple de produire "propre" de sortie via la ligne de commande utils:

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

Il indiquera toutes les adresses IPv4 sur le système.

OriginalL'auteur viker

C'est une variante de UnkwnTech de la réponse -- il fournit un get_local_addr() la fonction, qui renvoie à la primaire de l'adresse ip LAN de l'ordinateur hôte. Je poste parce que cela ajoute un certain nombre de choses: prise en charge d'ipv6, erreur de manipulation, ignorant localhost/linklocal addrs, et utilise un TESTNET addr (rfc5737) pour vous connecter à.

# imports
import errno
import socket
# 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:
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

OriginalL'auteur Eli Collins

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

OriginalL'auteur Nakilon

127.0.1.1 est votre véritable adresse IP. De manière plus générale, un ordinateur peut avoir n'importe quel nombre d'adresses IP. Vous pouvez les filtrer pour les réseaux privés - 127.0.0.0/8, 10.0.0.0/8, 172.16.0.0/12 et 192.168.0.0/16.

Cependant, il n'y a pas de croix-plate-forme de façon à obtenir toutes les adresses IP. Sur Linux, vous pouvez utiliser le SIOCGIFCONF ioctl.

OriginalL'auteur phihag

Eh bien, vous pouvez utiliser la commande "ip route" sur GNU/Linux pour connaître votre adresse IP actuelle.

Cela montre l'IP donnée à l'interface par le serveur DHCP fonctionne sur le routeur/modem. Généralement "192.168.1.1/24" est l'adresse IP pour le réseau local où "24" s'entend de la gamme des possibles adresses IP donnée par le serveur DHCP dans le masque de la gamme.

Voici un exemple: Notez que PyNotify est juste un plus d'obtenir mon point de droit et n'est pas nécessaire à tous les

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

L'avantage, c'est que vous n'avez pas besoin de spécifier l'interface réseau. C'est très utile lors de l'exécution d'un serveur socket

Vous pouvez installer PyNotify utiliser easy_install ou même Pip:

easy_install py-notify

ou

pip install py-notify

ou à l'intérieur d'un script python/interprète

from pip import main
main(['install', 'py-notify'])

OriginalL'auteur DarkXDroid

netifaces est disponible via pip et easy_install. (Je sais, ce n'est pas dans la base, mais il pourrait être la peine de l'installer.)

netifaces a quelques bizarreries sur les plates-formes:

• Le localhost/loop-back interface peut ne pas toujours être inclus (Cygwin).
• Adresses sont répertoriées selon le protocole (par exemple, IPv4, IPv6) et les protocoles sont répertoriés par interface. Sur certains systèmes (Linux) chaque protocole de l'interface paire possède sa propre interface associés (à l'aide de la interface_name:n la notation), tandis que sur d'autres systèmes (Windows) une interface unique vous donnera une liste d'adresses pour chaque protocole. Dans les deux cas, il y a une liste de protocole, mais il peut contenir qu'un seul élément.

Voici quelques netifaces code pour jouer avec:

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.

Le code ci-dessus ne correspondent pas à une adresse de retour à son nom de l'interface (utile pour générer des ebtables/règles iptables à la volée). Voici donc une version qui conserve les informations ci-dessus avec le nom de l'interface dans un tuple:

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]

Et, non, je ne suis pas en amour avec les interprétations de la liste. C'est juste la façon dont mon cerveau fonctionne de nos jours.

L'extrait de code suivant apparaîtra à l'impression de tout:

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)

Profitez-en!

OriginalL'auteur user3712955

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

Cela vous renvoie l'adresse IP dans le système Ubuntu ainsi que MacOS. La sortie est l'adresse IP du système comme my IP: 192.168.1.10.

OriginalL'auteur Ishwarya

J'ai eu à résoudre le problème de "déterminer si une adresse IP est local ou non", et ma première pensée a été de construire une liste d'adresses ip qui ont été locale, puis match contre elle. C'est ce qui m'a amené à cette question. Cependant, j'ai réalisé plus tard il est plus simple façon de le faire: Essayer de lier sur la propriété intellectuelle et de voir si cela fonctionne.

_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

Je sais que ce n'est pas répondre directement à la question, mais cela devrait être utile pour quiconque d'essayer de résoudre la question connexe et qui avait suivi la même ligne de pensée. Cela a l'avantage d'être une solution multi-plateforme (je pense).

OriginalL'auteur Etienne Perot