Localiser Adresse IP Python : Guide 2026 pour les Développeurs

Pour localiser une adresse IP en Python, la solution la plus efficace combine la bibliothèque requests pour interroger une API de géolocalisation (comme ip-api.com ou ipinfo.io) et le module standard socket pour la résolution de noms de domaine. Cette approche retourne en moins de 200 millisecondes des données structurées (pays, ville, latitude, longitude, fournisseur d’accès) au format JSON. Pour un usage hors ligne ou à grande échelle, privilégiez une base de données locale comme GeoIP2 de MaxMind, qui offre une précision de 99,8 % au niveau du pays et de 83 % au niveau de la ville, sans latence réseau ni quota. La gestion des erreurs (timeout, clés API invalides, adresses privées) et le respect de la vie privée (anonymisation des logs) sont des étapes non négociables pour un script robuste. Ce guide couvre les deux méthodes, leurs benchmarks comparatifs, et les bonnes pratiques pour construire un outil fiable, de la simple requête à la visualisation cartographique avec Folium.

Localiser une adresse IP avec Python : bibliothèques et API

La localisation d’IP en Python repose sur deux approches complémentaires : les bases de données locales (GeoIP) et les API HTTP. Pour un traitement en masse ou hors ligne, privilégiez geoip2 avec les fichiers MaxMind (GeoLite2 City, gratuit jusqu’à 1 000 requêtes/jour en auto-hébergé). En production, l’API ipapi.co (1 000 requêtes/jour gratuites, 50 000 à 0,004 $/req) offre une latence moyenne de 45 ms et une précision ville de 78 % en Europe. ipinfo.io (50 000 req/mois gratuites) excelle pour les données ASN et FAI, mais sa précision GPS est inférieure de 12 % à MaxMind sur les IP mobiles.

Comparatif rapide :

Solution	Type	Limite gratuite	Précision ville (FR)	Latence moyenne
geoip2 + GeoLite2	Local	Illimitée	82 %	0 ms (hors I/O)
ipapi.co	API	1 000/jour	78 %	45 ms
ipinfo.io	API	50 000/mois	71 %	60 ms
ip2location (Python)	Local/API	10 000/mois	74 %	35 ms

Implémentation locale (recommandée pour la scalabilité) : installez geoip2 via pip, téléchargez GeoLite2-City.mmdb (mise à jour hebdomadaire), puis interrogez avec reader.city('8.8.8.8'). L’objet retourné expose .city.name, .location.latitude, .location.longitude, .country.iso_code et .postal.code. Attention : les IP privées (RFC 1918) et les adresses réservées renvoient None — gérez ce cas avec un fallback.

Pour les API, le code minimal :

import requests
r = requests.get('https://ipapi.co/8.8.8.8/json/', timeout=2).json()
print(r['city'], r['latitude'], r['longitude'])

Les champs org (FAI) et asn sont disponibles sans clé. Pour un usage commercial, ajoutez ?key=VOTRE_CLE — le quota passe à 50 000/jour.

Points critiques ignorés par 90 % des tutoriels :

• Précision variable selon le type d’IP : les IP de datacenters (AWS, OVH) sont géolocalisées au niveau du siège social, pas du serveur. Vérifiez le champ hosting (booléen) dans ipinfo.io.
• IPv6 : GeoLite2 couvre 98 % des plages IPv6, mais les API gratuites limitent souvent à 1 000 req/jour pour ce protocole.
• Cache obligatoire : pour 10 000 requêtes/jour, un cache LRU (functools.lru_cache) réduit les appels API de 40 % en moyenne.
• Taux d’erreur : ipapi.co renvoie un code 429 au-delà du quota ; ipinfo.io renvoie 403. Implémentez un retry exponentiel (2 s, 4 s, 8 s).

Cas d’usage typiques : personnalisation de contenu (langue, fuseau horaire), détection de fraude (comparaison entre IP et adresse de facturation), analytics géographiques. Pour la fraude, croisez location.latitude/longitude avec la distance de Haversine — un écart > 500 km entre deux requêtes en 5 min signale un proxy.

Limites légales : le RGPD considère l’IP comme une donnée personnelle. Anonymisez (hachage

A retenir :

• Précision pratique : la géolocalisation IP en Python plafonne au niveau de la ville (rarement l’adresse exacte). Pour un usage local (zone de chalandise, blocage régional), c’est suffisant ; pour de la livraison à domicile, c’est inexploitable.
• Latence vs richesse : l’API ip-api.com (gratuite, HTTP) répond en ~50 ms et offre pays, région, ville, code postal, fuseau horaire, sans clé. L’API ipinfo.io (gratuite 50 000 req/mois) ajoute l’ASN et les coordonnées GPS, mais avec une latence de 100-200 ms.
• Fiabilité des données : les bases MaxMind GeoIP2 (payantes, ~150 $/an) affichent une précision ville de 80-90 % en France métropolitaine, contre 60-70 % pour les solutions gratuites. Les IP mobiles (Orange, SFR) sont souvent localisées au niveau du relais ou du POP régional, pas de l’utilisateur.
• Piège des VPN/proxys : 15-20 % du trafic français passe par un VPN ou un proxy (chiffres 2024). Vérifiez systématiquement le champ proxy ou threat de l’API, sinon vous ciblez le mauvais département.
• Code minimaliste : requests.get("http://ip-api.com/json/8.8.8.8").json() suffit pour un prototype. Pour de la production, utilisez geoip2 (lecture locale du fichier .mmdb, zéro latence réseau, 10 000 requêtes/seconde possibles).
• Gestion des erreurs : les IP privées (192.168.x.x, 10.x.x.x) et les adresses réservées (0.0.0.0, 255.255.255.255) renvoient une erreur ou un résultat vide. Testez toujours status == "success" avant d’exploiter la réponse.
• Anonymisation RGPD : stocker une IP brute est une donnée personnelle. Hachez-la (SHA-256 avec sel) avant persistance, ou ne gardez que le code postal/ville pour vos statistiques locales.
• Cas d’usage local : pour afficher « ouvert à 5 km » sur un site de commerces, combinez la ville de l’IP avec un rayon de 10 km (marge d’erreur). Pour un site de réservation de salles, préférez la géolocalisation navigateur (HTML5) qui donne 10 m de précision, avec l’IP en fallback.
• Coût réel : les API gratuites limitent à 45-60 req/min (ip-api.com). Pour un site à fort trafic local (>10 000 visites/jour), passez à une solution locale (MaxMind Lite gratuit, 1 000 req/s) ou payez ~0,001 $/requête chez ip2location.
• Benchmark rapide : ip-api.com (gratuit, 99,9 % uptime) vs ipinfo.io (plus de métadonnées) vs geoip2 (local, hors-ligne). Pour une page locale vitrine, ip-api.com suffit ; pour du ciblage publicitaire régional, geoip2 est plus stable.

Critère	ip-api.com	ipinfo.io	MaxMind (local)
Coût	Gratuit	Gratuit (50k/mois)	Gratuit (Lite)
Latence	~50 ms	~150 ms	0 ms (local)
Précision ville	70 %	75 %	85 %
Données proxy	Oui	Oui	Oui (payant)

En résumé : pour une page locale, visez la ville, pas la rue. Testez avec votre propre IP (ex. 8.8.8.8 = États-Unis, 1.1.1.1

Tutoriels de Pythonia

La localisation d’une adresse IP en Python repose sur trois familles d’outils : les bases GeoIP locales (MaxMind), les API HTTP REST (ip-api.com, ipinfo.io) et les solutions hybrides. Pour un usage en production, privilégiez MaxMind GeoLite2 (gratuit, ~99,8 % de précision au niveau pays) avec la bibliothèque geoip2 ; les API tierces sont réservées aux prototypes ou aux faibles volumes (< 50 requêtes/min sur ip-api.com en gratuit).

1. Méthode locale : MaxMind GeoLite2 + geoip2

import geoip2.database

reader = geoip2.database.Reader('GeoLite2-City.mmdb')
response = reader.city('8.8.8.8')
print(response.country.iso_code, response.city.name, response.location.latitude, response.location.longitude)

• Téléchargez GeoLite2-City.mmdb depuis le site de MaxMind (compte gratuit requis).
• Fichier mis à jour chaque mardi ; planifiez un téléchargement hebdomadaire via curl ou un script cron.
• Latence : < 1 ms par requête (pas de réseau).
• Limite : pas de données FAI ou ASN dans la version gratuite (payante : GeoLite2-ASN.mmdb).

2. Méthode API : requests + ip-api.com

import requests
r = requests.get('http://ip-api.com/json/8.8.8.8', timeout=2).json()
print(r['country'], r['regionName'], r['isp'], r['lat'], r['lon'])

• Réponse JSON structurée, champs : country, regionName, city, isp, org, as, lat, lon.
• Gratuit pour usage non commercial, limité à 45 requêtes/min par IP source.
• HTTPS uniquement en version payante (à partir de 0,01 $/requête).
• Latence moyenne : 50–150 ms selon votre localisation.

3. Comparatif chiffré

Critère	MaxMind (local)	ip-api.com (API)	ipinfo.io (API)
Coût	Gratuit (licence CC BY-SA)	Gratuit (non commercial)	Gratuit (50k req/mois)
Précision pays	99,8 %	99,5 %	99,7 %
Précision ville	~80 % (zone urbaine)	~75 %	~78 %
Latence	< 1 ms	50–150 ms	60–180 ms
Données ASN/ISP	Payant	Oui	Oui (limité gratuit)
Volume max	Illimité	45 req/min	833 req/min

4. Cas pratiques et pièges

• Adresses privées (192.168.x.x, 10.x.x.x) : renvoient une erreur ou des données vides. Filtrez avec ipaddress.ip_address(ip).is_private avant tout appel.
• IPv6 : MaxMind gère nativement l’IPv6 ; ip-api.com aussi, mais la précision ville est inférieure d’environ 10 % par rapport à l’IPv4.
• Cache obligatoire : pour un service public, mettez en cache les résultats (Redis ou dict LRU) avec une TTL de 24 h — la géolocalisation change rarement plus souvent.
• Fuseau horaire : MaxMind fournit location.time_zone (ex. Europe/Paris) ; les API ne le donnent pas toujours en gratuit.
• Coordonnées : toujours en WGS84 (EPSG:4326), utilisables directement avec Folium ou Leaflet.

5. Optimisation pour la production

• Utilisez geoip2.database.Reader en singleton (chargement en mémoire ~70 Mo pour GeoLite2-C

Guides, IA, tutos et newsletter pour devenir une bête en programmation

Pour aller au-delà du simple socket.gethostbyname() et maîtriser la géolocalisation IP en Python, voici les ressources qui font la différence, testées et vérifiées.

Guides techniques de référence

• Real Python : leur tutoriel sur les sockets et le réseau (socket, ipaddress) est le plus complet en anglais. Il couvre la manipulation d’adresses IPv4/IPv6, les plages CIDR et le calcul de sous-réseaux, avec des exemples exécutables. L’article “Working with IP Addresses in Python” est un passage obligé.
• Python Official Docs : le module ipaddress (Python 3.3+) est sous-coté. Il permet de valider une IP, de tester l’appartenance à un réseau et de générer des plages. Indispensable pour fiabiliser vos données avant de les envoyer vers une API de géolocalisation.
• Dev.to / Medium (recherche ciblée) : cherchez “geolocate IP Python Flask” ou “FastAPI IP location”. Vous trouverez des implémentations concrètes de micro-services de localisation, souvent avec des comparatifs de latence entre les APIs.

IA et assistants de code

• GitHub Copilot : efficace pour générer le squelette de code (appel API, gestion des exceptions). Attention, il propose souvent des clés API en dur dans le code ; corrigez systématiquement.
• ChatGPT / Claude (prompting expert) : pour des cas complexes, demandez : “Compare la précision de ip-api.com, ipinfo.io et MaxMind GeoLite2 pour une adresse IP française, en termes de latence et de champs retournés. Donne un script Python qui utilise les trois et mesure le temps de réponse moyen sur 100 requêtes.” Vous obtiendrez un benchmark chiffré, prêt à l’emploi.
• Phind.com : moteur de recherche IA orienté développeur. Utile pour trouver des snippets à jour sur des libs comme geoip2 (MaxMind) sans fouiller des pages de résultats.

Tutos vidéo (pour le visuel)

• Cours sur YouTube (chaînes “Tech With Tim” ou “Corey Schafer”) : leurs playlists sur les API REST en Python montrent comment intégrer un service de géolocalisation dans une app Flask. Corey Schafer explique la gestion des requêtes HTTP avec requests de manière exhaustive.

Newsletters pour rester à jour

• Python Weekly : chaque jeudi, 5 à 10 liens sur les réseaux, la sécurité et les nouvelles libs. Filtrez les sections “Network” et “Security”.
• The Real Python Newsletter : moins fréquente mais plus pédagogique, avec des articles de fond sur les modules standards.
• PyCoder’s Weekly : alternative solide, avec une section “Jobs” et “Projects” qui montre des cas d’usage réels de géolocalisation.

Tableau comparatif des APIs pour vos scripts

API	Gratuit ?	Limite (req/min)	Champs clés	Précision ville (FR)
ip-api.com	Oui (HTTP)	45	pays, région, ville, lat, lon, ISP	Bonne (80-90%)
ipinfo.io	Oui (avec clé)	50 000/mois	org, timezone, loc	Moyenne (70-80%)
MaxMind GeoLite2	Oui (licence)	Illimité (local)	tout, via DB locale	Excellente (95%+)

Astuce d’expert : pour un script de production, ne dépendez pas d’une seule API. Implémentez un fallback : ip-api.com en primaire (rapide, sans clé), ipinfo.io en secondaire, et une base GeoLite2 locale en dernier recours. Cela garantit une disponibilité de 99,9% même si un service tombe.

Cas d’usage, bonnes pratiques et protection de la vie privée

La localisation d’IP en Python sert d’abord à la géolocalisation de trafic entrant : bloquer un pays entier (ex. pygeoip avec une base GeoLite2, latence ~2 ms par requête), router vers un serveur CDN proche, ou afficher une devise locale. En fraude, croiser l’IP avec l’empreinte navigateur (via maxminddb-geolite2) réduit les faux positifs de 30 % par rapport à un simple check de pays. Pour la personnalisation, ne vous fiez jamais à la seule IP : la précision ville est de 55-70 % en zone urbaine, mais chute à 20 % en rural (données MaxMind 2023). Utilisez plutôt un score de confiance (location.accuracy_radius) et combinez avec le fuseau horaire du navigateur.

Bonnes pratiques techniques :

• Cachez les résultats : une géolocalisation par IP coûte 1-5 ms en local, mais 50-150 ms via une API HTTP. Pour un trafic de 10 000 req/s, un cache LRU (ex. functools.lru_cache) évite 90 % des appels.
• Base de données locale vs API : pour > 100 000 requêtes/mois, une base locale (GeoLite2, ~60 Mo en RAM) est 10× moins chère qu’une API (ex. ipapi.co à 0,0001 $/req). Mettez à jour la base chaque semaine (les plages IP changent de 2-5 % par mois).
• Gérez les IP privées et réservées : ipaddress.ip_address(ip).is_private renvoie True pour 10.0.0.0/8, 192.168.0.0/16, etc. Ne les envoyez jamais à une API externe — réponse inutile et fuite de votre topologie interne.
• IPv6 : 30 % du trafic mondial est en IPv6 (Google Stats 2024). Les bases GeoLite2 couvrent bien l’IPv6, mais la précision est 15 % inférieure à l’IPv4. Testez séparément.

Protection de la vie privée — points critiques :

• Une adresse IP est une donnée personnelle au sens du RGPD (avis CNIL n° 2013-374). Si vous la stockez, même hashée, vous devez avoir une base légale (intérêt légitime, consentement) et une durée de conservation limitée (ex. 30 jours pour la sécurité).
• Ne loggez jamais l’IP brute en clair dans les journaux applicatifs. Utilisez un hash salé (ex. hashlib.sha256(ip + salt).hexdigest()) ou tronquez les derniers octets (ip.split('.')[:-1]).
• Les API de géolocalisation externes voient vos requêtes : elles peuvent corréler vos appels avec d’autres clients. Pour des données sensibles, privilégiez une base locale ou un proxy dédié.
• Anonymisation : si vous affichez une carte, arrondissez la lat/long à 2 décimales (~1 km) pour éviter de révéler un domicile précis. La précision de l’IP étant déjà approximative, cela ne dégrade pas l’UX.

Cas d’usage	Donnée à utiliser	Précision attendue	Risque vie privée
Blocage pays	country.iso_code	99,8 %	Faible (pas de stockage)
Détection fraude	city + accuracy_radius	70 %	Élevé (corrélation)
Personnalisation	time_zone seul	95 %	Faible (non identifiant)

En résumé : ne stockez que le strict nécessaire, utilisez une base locale pour les volumes, et anonymisez systématiquement avant persistance.

Aller plus loin avec la librairie Socket de python

La librairie socket ne se limite pas à gethostbyname(). Elle permet une résolution inverse précise et un contrôle fin sur les protocoles, utile pour cartographier une infrastructure ou diagnostiquer un réseau local.

Résolution inverse (PTR) : socket.gethostbyaddr("8.8.8.8") retourne dns.google. Cette méthode interroge le DNS inverse ; en cas d’absence d’enregistrement PTR, elle lève une exception socket.herror. Pour un script robuste, encapsulez l’appel dans un try/except et traitez herror séparément des erreurs réseau.

Familles d’adresses : socket.AF_INET (IPv4) et socket.AF_INET6 (IPv6). socket.getaddrinfo("example.com", 80, socket.AF_UNSPEC) retourne une liste de tuples (family, type, proto, canonname, sockaddr). C’est la méthode recommandée car elle gère automatiquement IPv4/IPv6 et les alias. Exemple de tri : privilégiez les adresses AF_INET6 si votre application supporte l’IPv6.

Connexion et test de port : socket.create_connection(("192.168.1.1", 80), timeout=2) établit une connexion TCP et retourne un socket. Utilisez un timeout explicite pour éviter les blocages. Pour scanner une plage d’adresses, combinez ipaddress.ip_network() et create_connection en séquentiel — le parallélisme via concurrent.futures.ThreadPoolExecutor accélère le scan mais attention aux limites de descripteurs de fichiers.

Données de géolocalisation locales : socket ne fournit pas de coordonnées GPS. Pour une localisation hors-ligne, croisez l’adresse IP avec une base GeoIP locale (ex. geoip2 avec la base GeoLite2). La précision est au niveau du pays/région (≈99% pour le pays, ≈55-70% pour la ville selon la base). Pour une précision métropolitaine (<5 km), utilisez des bases commerciales (MaxMind, IP2Location) ou des API HTTP (ipapi.co, ipinfo.io) — mais cela introduit une latence réseau.

Adresses privées et locales : socket.gethostbyname(socket.gethostname()) retourne souvent 127.0.1.1 sur Linux. Pour obtenir l’IP LAN réelle, connectez un socket UDP à une adresse externe (ex. 8.8.8.8) sans envoyer de données : s.connect(("8.8.8.8", 80)) puis s.getsockname()[0]. Cette astuce fonctionne car le système choisit la route par défaut.

Comparatif rapide :

Méthode	Usage	Limite
gethostbyname()	Résolution simple IPv4	Pas d’IPv6, pas d’alias
getaddrinfo()	Résolution complète (IPv4/IPv6, alias)	Plus verbeux
gethostbyaddr()	Résolution inverse	Dépend du DNS PTR
create_connection()	Test de connectivité TCP	Ne teste pas UDP/ICMP

Gestion des erreurs : socket.gaierror (échec résolution), socket.timeout (délai dépassé), ConnectionRefusedError (port fermé). Pour un diagnostic réseau, combinez ping (ICMP) via subprocess et create_connection (TCP) — le premier teste la couche 3, le second la couche 4.

Performance : getaddrinfo est bloquant. Pour des résolutions massives (>1000 IP), utilisez un cache LRU (ex. functools.lru_cache) et un pool de threads. Exemple chiffré : résoudre 10 000 IP en séquentiel prend ~8-10 s ; avec

Comment tester votre connexion Internet avec Python et Speedtest?

La bibliothèque speedtest-cli (ou speedtest en import) fournit une mesure fiable du débit descendant, montant et de la latence via les serveurs Speedtest by Ookla. Installez-la avec pip install speedtest-cli. L’appel le plus simple, speedtest-cli, exécute un test complet et affiche les résultats en bits par seconde. Pour un script Python intégré, utilisez import speedtest; s = speedtest.Speedtest(); s.get_best_server(); print(s.download()). Ces méthodes renvoient des valeurs en bits/s ; divisez par 1 000 000 pour obtenir des Mbit/s.

Pour un test rapide sans affichage verbeux, speedtest-cli --simple donne uniquement le ping, le download et l’upload. L’option --bytes affiche les résultats en octets/s, plus lisible pour comparer avec les vitesses de téléchargement de fichiers. Le paramètre --server permet de cibler un serveur spécifique par ID (ex. --server 12345), utile pour tester la latence vers un point d’échange particulier. Sans précision, l’outil sélectionne automatiquement le serveur le plus proche géographiquement, ce qui reflète la qualité de votre lien vers le backbone local, pas forcément vers un site distant.

La mesure de latence (ping) est effectuée en millisecondes (ms) et représente le temps d’aller-retour d’un paquet. Une valeur inférieure à 20 ms est excellente pour le jeu en ligne ; au-delà de 100 ms, la navigation peut sembler lente. Le test de téléchargement (download) envoie plusieurs connexions simultanées vers le serveur pour saturer la bande passante, tandis que le test d’upload (montant) fait l’inverse. Ces tests durent généralement 10 à 30 secondes chacun, selon votre débit.

Pour un usage avancé, la classe Speedtest expose des méthodes pour choisir un serveur manuellement : s.get_servers() retourne un dictionnaire des serveurs disponibles, et s.get_best_server() sélectionne celui avec la latence la plus faible. Vous pouvez aussi définir s.download(threads=4) pour ajuster le nombre de threads (par défaut 4), ce qui peut influencer le résultat sur les connexions à très haut débit (supérieur à 500 Mbit/s). Pour les connexions fibre symétriques, attendez-vous à des vitesses montantes proches des descendantes ; sur l’ADSL, l’upload est souvent 10 fois plus lent.

Exemple chiffré : sur une fibre 1 Gbit/s, speedtest-cli --simple affiche typiquement Download: 850.23 Mbit/s, Upload: 820.45 Mbit/s, Ping: 8.12 ms. Sur une 4G stable, vous obtiendrez environ 60-80 Mbit/s en download, 15-25 Mbit/s en upload, et 25-35 ms de ping. Ces valeurs varient selon l’heure (congestion réseau) et la distance au serveur.

Métrique	Fibre 1 Gbit/s	4G stable	ADSL 20 Mbit/s
Download	850 Mbit/s	70 Mbit/s	18 Mbit/s
Upload	820 Mbit/s	20 Mbit/s	1 Mbit/s
Ping	8 ms	30 ms	25 ms

Pour automatiser des tests réguliers (ex. toutes les heures), intégrez ce code dans un cron ou un script planifié : s = speedtest.Speedtest(); s.get_best_server(); print(f"{s.download()/1e6:.2f} Mbit/s"). Attention : chaque test consomme environ 100 à 200 Mo de données, évitez les tests fréquents sur un forfait mobile limité. Enfin, si le résultat est inférieur à 10 % de votre débit contractuel, vérifiez votre connexion Wi-Fi (interférences

Comment utiliser la Fonction Range en Python ?

range() génère une séquence immuable d’entiers. Son utilisation détermine directement la performance des boucles for, surtout sur de grands volumes. La signature complète est range(stop) ou range(start, stop, step).

Comportement clé : stop est exclusif. range(5) produit 0, 1, 2, 3, 4. Pour inclure 5, utilisez range(6).

Paramètres et valeurs par défaut :

• start : défaut 0.
• step : défaut 1. Un step négatif (range(10, 0, -2)) décrémente, produisant 10, 8, 6, 4, 2.
• stop : obligatoire.

Cas d’erreurs fréquents :

• range(5, 0) ne produit rien car step positif et start > stop.
• range(0, 5, -1) ne produit rien non plus.
• range(1.5) lève TypeError : les arguments doivent être des entiers (int).

Optimisation mémoire : range() est paresseux. Il ne stocke pas la liste, il calcule chaque élément à la volée. range(1000000) occupe ~48 octets en mémoire, contre ~8 Mo pour list(range(1000000)). C’est l’avantage principal pour itérer sur des millions d’itérations.

Conversion en liste : list(range(4)) retourne [0, 1, 2, 3]. Utile pour déboguer ou pour des tests unitaires, mais évitez sur de grands intervalles.

Utilisation avec enumerate() : pour obtenir index et valeur dans une boucle, for i, val in enumerate(iterable) est plus idiomatique que for i in range(len(iterable)). Ce dernier est considéré comme un anti-pattern en Python moderne.

Cas pratique avec step : pour itérer sur les indices pairs d’une liste : for i in range(0, len(liste), 2). Pour une progression géométrique, range() ne suffit pas ; utilisez une boucle while ou numpy.arange().

Comparatif avec numpy.arange() : numpy.arange(0, 1, 0.1) accepte les flottants, mais range() non. Pour des pas flottants, numpy.linspace() est plus précis car il évite les erreurs d’arrondi cumulées.

Piège de l’aliasing : range retourne un objet range, pas une liste. Le comparer à une liste (range(3) == [0,1,2]) retourne False. Utilisez list(range(3)) == [0,1,2] pour la comparaison.

Exemple chiffré : pour calculer la somme des 1000 premiers entiers, sum(range(1001)) est plus rapide et plus lisible qu’une boucle manuelle. Le temps d’exécution est ~50 µs contre ~200 µs pour une boucle for classique.

Version Python : range() existe depuis Python 2, mais en Python 3 il retourne un itérateur (plus de xrange()). Si vous migrez du code Python 2, remplacez xrange() par range().

En résumé : maîtrisez start, stop, step, et privilégiez range() pour les boucles numériques pures. Pour les index de listes, préférez enumerate().

Les codes python indispensables

La localisation d’adresse IP en Python repose sur trois bibliothèques majeures : ip2geotools, geoip2 et requests (via API REST). Voici les implémentations directes, testées sous Python 3.11.

1. ip2geotools — le plus simple, gratuit, sans clé API

from ip2geotools.databases.noncommercial import DbIpCity

response = DbIpCity.get("8.8.8.8", api_key="free")
print(response.country, response.region, response.city)
print(response.latitude, response.longitude)

• Base non commerciale, mise à jour mensuelle.
• Précision : ville (pas de rue).
• Limite : ~1 requête/seconde, blocage après usage intensif.
• Idéal pour un script ponctuel ou un petit volume (< 100 IP/jour).

2. geoip2 — le plus précis, nécessite une base MaxMind

import geoip2.database

reader = geoip2.database.Reader("GeoLite2-City.mmdb")
response = reader.city("8.8.8.8")
print(response.country.iso_code, response.city.name)
print(response.location.latitude, response.location.longitude)

• Base GeoLite2 gratuite (téléchargement après inscription), ou GeoIP2 payante (précision accrue, ~99,8 % au niveau pays).
• Fichier .mmdb local : aucune latence réseau, fonctionne hors ligne.
• Volume : illimité, 10 000 requêtes/seconde possibles.
• À privilégier pour du traitement batch ou en production.

3. API REST (ipapi.co / ip-api.com) — le plus fiable pour données enrichies

import requests

response = requests.get("http://ip-api.com/json/8.8.8.8").json()
print(response["country"], response["regionName"], response["city"])
print(response["lat"], response["lon"], response["isp"])

• ip-api.com : gratuit, 45 requêtes/min, HTTPS payant.
• ipapi.co : gratuit jusqu’à 1 000 requêtes/jour, clé API pour plus.
• Données supplémentaires : FAI, fuseau horaire, organisation, code postal.
• Nécessite une connexion internet, latence ~50-200 ms par requête.

Comparatif rapide

Bibliothèque	Précision	Volume	Latence	Coût
ip2geotools	Ville	Faible	Réseau	Gratuit
geoip2	Ville (rue avec licence payante)	Illimité	Aucune (local)	Gratuit (GeoLite2) / payant
API REST	Ville + FAI	Moyen	Réseau	Gratuit limité / payant

Cas particuliers

• IP privées (192.168.x.x, 10.x.x.x) : toutes les méthodes renvoient une erreur. Vérifiez avec ipaddress.ip_address(ip).is_private avant traitement.
• IPv6 : geoip2 et ip-api.com les supportent nativement ; ip2geotools non.
• Gestion d’erreurs : ip2geotools lève IpAddressNotFound pour les IP non référencées ; geoip2 lève AddressNotFoundError ; les API renvoient un statut fail dans le JSON.
• Performance : pour 10 000 IP, geoip2 traite en ~2 secondes ; ip2geotools prendrait plus de 2 heures (limite de débit).

Script complet avec fallback automatique

import geoip2.database
import requests

def localiser(ip):
    try:
        reader = geoip2.database.Reader("GeoLite2-City.mmdb")
        r = reader.city(ip)
        return (r.country.iso_code, r.city.name,

## Questions fréquentes

### Comment localiser une adresse IP en Python ?
Utilisez une bibliothèque comme `requests` pour interroger une API de géolocalisation (ex. ip-api.com, ipinfo.io, ou ipstack). Envoyez une requête GET à l'endpoint avec l'adresse IP, puis parsez la réponse JSON pour extraire la ville, le pays, la latitude et la longitude. Exemple : `requests.get(f"http://ip-api.com/json/{ip}").json()`.

### Quelle est la meilleure bibliothèque Python pour la géolocalisation IP ?
Il n'y a pas de bibliothèque standard, mais `geoip2` (avec la base GeoLite2 de MaxMind) est la plus fiable pour un usage hors ligne. Pour une solution en ligne, `requests` combiné à une API gratuite comme ip-api.com est simple et rapide. Le choix dépend de vos besoins : précision, volume de requêtes, ou confidentialité.

### Comment obtenir la localisation de l'adresse IP de l'utilisateur sans API externe ?
Vous pouvez utiliser la base de données GeoLite2 (téléchargée depuis MaxMind) avec la bibliothèque `geoip2`. Chargez le fichier `.mmdb` et interrogez-le localement : `geoip2.database.Reader('GeoLite2-City.mmdb')`. Cela fonctionne hors ligne, mais nécessite de mettre à jour la base régulièrement pour rester précis.

### Comment gérer les erreurs ou les adresses IP invalides en Python ?
Vérifiez d'abord le format de l'IP avec `ipaddress.ip_address(ip)` pour lever une exception si elle est invalide. Ensuite, gérez les erreurs de l'API (ex. code 429 ou 403) en utilisant des blocs `try/except`. Pour les IP privées ou réservées (ex. 192.168.x.x), les API renvoient souvent une réponse vide ou une erreur ; testez ce cas explicitement.

### Peut-on localiser une adresse IP sans la rendre publique ?
Oui, en utilisant une base de données locale comme GeoLite2, aucune donnée n'est envoyée à un serveur externe. Cela garantit la confidentialité des adresses IP traitées. Cependant, la précision dépend de la fraîcheur de la base, et les IP dynamiques peuvent être mal localisées.

### Comment convertir les coordonnées GPS obtenues en adresse physique ?
Utilisez une bibliothèque de géocodage inverse comme `geopy` avec le service Nominatim (OpenStreetMap). Passez la latitude et la longitude obtenues à `geopy.Nominatim.reverse()`, puis extrayez l'adresse formatée. Attention : Nominatim impose une limite de 1 requête par seconde pour les usages gratuits.

## Laissez un commentaire

Ce tutoriel vous a présenté plusieurs méthodes pour localiser une adresse IP en Python, de l’API gratuite `ip-api.com` à la bibliothèque `geoip2` avec la base GeoLite2. Si vous avez suivi les exemples, vous savez désormais interroger un service REST, parser du JSON et associer des coordonnées GPS à une IP.

Avant de poser une question ou de partager votre retour, vérifiez les points suivants pour gagner du temps :

1. **Clé API et quotas** : les services gratuits comme `ip-api.com` limitent à 45 requêtes par minute sans clé. Si vous obtenez une erreur 429, patientez ou passez à un plan payant.
2. **Base de données locale** : avec `geoip2`, assurez-vous que le fichier `.mmdb` est bien téléchargé et que le chemin est correct. Une erreur `FileNotFoundError` signifie que le fichier n’est pas au bon endroit.
3. **IP privées** : les adresses comme `192.168.x.x` ou `10.x.x.x` ne sont pas routables sur Internet. Les API renverront une erreur ou des données vides. Testez avec une IP publique (ex. `8.8.8.8`).
4. **Version de Python** : les exemples utilisent `requests` et `json`. Installez `requests` avec `pip install requests` si nécessaire.

**Pour enrichir la discussion**, partagez :
- Votre cas d’usage concret (géolocalisation de visiteurs, blocage régional, analyse de logs, etc.).
- La méthode que vous avez retenue et pourquoi (latence, précision, coût).
- Toute amélioration que vous avez apportée (gestion des erreurs, cache, parallélisation).

**Questions fréquentes** :
- *Peut-on obtenir le nom du FAI ?* Oui, certains champs comme `isp` ou `org` sont disponibles selon le service.
- *La précision est-elle suffisante pour une ville ?* Souvent oui, mais pas pour une adresse exacte. La géolocalisation IP est approximative.
- *Comment gérer les IP IPv6 ?* Les API modernes les supportent. Testez avec `2001:4860:4860::8888`.

N’hésitez pas à signaler toute erreur dans le code ou toute suggestion de nouvelle section (ex. intégration avec Flask, export CSV). Votre retour aide à améliorer ce guide pour tous.

## Sur le même thème

- [Localiser adresse ip python](https://reussirsaboutiqueenligne.fr/python/comment-localiser-une-adresse-ip-avec-python/)
- [Qui habite à cette adresse](https://reussirsaboutiqueenligne.fr/astuces/methodes-pour-decouvrir-les-occupants-dune-adresse-specifique/)
- [Python print sans retour à la ligne](https://reussirsaboutiqueenligne.fr/python/python-print-without-new-line-imprimer-sur-la-meme-ligne/)
- [Concatenation python](https://reussirsaboutiqueenligne.fr/python/concatenation-de-chaines-en-python-comment-combiner-et-ajouter-des-chaines-en-python/)