Objectif Récupérer automatiquement les adresses géographiques associées à 3 000 noms d’entreprises à partir d’un fichier Excel.

Approche choisie Utilisation de l’API de Gaode Maps (AMAP), offrant un quota gratuit de 5 000 requêtes par mois, ce qui rend la solution économiquement viable pour ce projet. L’alternative (comme Qichacha) impliquerait un coût significatif (environ 500 yuan).

Configuration API

• URL de l’API : https://lbs.amap.com/api/webservice/guide/api-advanced/search
• Création d’une clé API : https://lbs.amap.com/api/webservice/create-project-and-key

Script principle Le script suivant utilise la bibliothèque requests pour interroger l’API Gaode et extraire les informations petrinentes.

import requests
from typing import Tuple, Optional

def query_company_location(company_name: str) -> Optional[Tuple[str, str, str]]:
    """
    Récupère le nom, la ville et l'adresse d'une entreprise via l'API Gaode.
    
    Args:
        company_name: Nom de l'entreprise à rechercher
        
    Returns:
        Tuple contenant (nom, ville, adresse) ou None en cas d'échec
    """
    api_url = "https://restapi.amap.com/v3/place/text"
    
    params = {
        "key": "votre_clé_api_ici",  # Remplacer par votre clé réelle
        "keywords": company_name,
        "types": "公司企业",  # Type spécifique aux entreprises
        "children": 1,
        "offset": 10,
        "extensions": "base"
    }
    
    try:
        response = requests.get(api_url, params=params, timeout=10)
        if response.status_code != 200:
            return None
            
        data = response.json()
        if not data.get("pois") or len(data["pois"]) == 0:
            return None
            
        result = data["pois"][0]
        return (
            result.get("pname", ""),
            result.get("cityname", ""),
            result.get("address", "")
        )
        
    except Exception as e:
        print(f"Erreur lors de la requête pour '{company_name}': {e}")
        return None

Script d'orchestration Ce script lit un fichier Excel, traite chaque entrée, sauvegarde progressivement les résultats et gère les échecs.

import pandas as pd
import time
from pathlib import Path

def load_data(filepath: str) -> pd.DataFrame:
    """Charge le fichier Excel contenant les noms d'entreprises."""
    df = pd.read_excel(filepath)
    return df

def process_companies():
    input_file = "company.xlsx"
    output_file = "company_with_location.xlsx"
    
    df = load_data(input_file)
    
    # Assurez-vous que les colonnes existent
    for col in ['pname', 'cityname', 'address']:
        if col not in df.columns:
            df[col] = None
    
    total_rows = len(df)
    valid_count = df.iloc[:, 0].notna().sum()
    
    print(f"Total lignes : {total_rows}, Traitement requis : {valid_count}")
    
    processed = 0
    success = 0
    failed = 0
    
    for idx, name in enumerate(df.iloc[:, 0]):
        if pd.isna(name):
            continue
            
        processed += 1
        print(f"\n[{processed}/{valid_count}] Traitement : {name}")
        
        result = query_company_location(str(name))
        
        if result:
            pname, city, addr = result
            df.at[idx, 'pname'] = pname
            df.at[idx, 'cityname'] = city
            df.at[idx, 'address'] = addr
            print(f"✓ Réussi : {pname} | {city} | {addr}")
            success += 1
        else:
            df.at[idx, 'pname'] = "Non trouvé"
            df.at[idx, 'cityname'] = ""
            df.at[idx, 'address'] = ""
            print("✗ Échec")
            failed += 1
        
        # Sauvegarde temporaire toutes les 10 requêtes
        if processed % 10 == 0:
            backup_path = f"progress_{processed}.xlsx"
            df.to_excel(backup_path, index=False)
            print(f"💾 Sauvegarde partielle : {backup_path}")
            
        # Respecter la limite de fréquence
        time.sleep(0.1)
    
    # Sauvegarde finale
    df.to_excel(output_file, index=False)
    print(f"\n✅ Traitement terminé. Résultats sauvegardés dans : {output_file}")
    print(f"Statistiques : {success} réussites, {failed} échecs")
    
    return df

if __name__ == "__main__":
    final_df = process_companies()
    
    # Affichage des premières lignes
    print("\n=== Aperçu des résultats ===")
    print(final_df.head(10))
    
    # Calcul du taux de succès
    total_valid = final_df['pname'].notna().sum()
    success_rate = (final_df['pname'].apply(lambda x: x != "Non trouvé").sum() / total_valid * 100) if total_valid > 0 else 0
    print(f"\nTaux de réussite : {success_rate:.1f}% ({final_df['pname'].apply(lambda x: x != 'Non trouvé').sum()}/{total_valid})")

Structure du projet

project/
├── company.xlsx              # Fichier source avec les noms
├── query_location.py         # Fonction de requête API
├── main_processor.py         # Script principal de traitement
└── results/
    └── company_with_location.xlsx  # Résultat final

Conseisl pratiques

• Utilisez une clé API dédiée avec accès limité au service de recherche.
• Limitez les requêtes à 10 par seconde environ pour éviter les blocages.
• Activez les logs si nécessaire pour surveiller les erreurs.
• Testez sur un petit jeu de données avant le traitement complet.