Parse usable Indirizzo, città, stato, CAP da una stringa [chiuso]

Problema: ho un campo indirizzo da un database di Access che è stato convertito in SQL Server 2005. Questo campo ha tutto in un unico campo. Devo analizzare le singole sezioni dell'indirizzo nei rispettivi campi in una tabella normalizzata. Devo farlo per circa 4.000 dischi e deve essere ripetibile.

ipotesi:

1. Supponi un indirizzo negli Stati Uniti (per ora)

2. supponiamo che la stringa di input conterrà talvolta un destinatario (la persona a cui viene indirizzato) e / o un secondo indirizzo (es. Suite B)

3. gli stati possono essere abbreviati

4. il codice postale può essere standard a 5 cifre o zip + 4

5. ci sono errori di battitura in alcuni casi

AGGIORNAMENTO: in risposta alle domande poste, gli standard non sono stati seguiti universalmente, ho bisogno di memorizzare i singoli valori, non solo geocodice ed errori significa errore di battitura (corretto sopra)

Dati di esempio:

• AP Croll & Son 2299 Lewes-Georgetown Hwy, Georgetown, DE 19947

• 11522 Shawnee Road, Greenwood DE 19950

• 144 Kings Highway, SW Dover, DE 19901

• Cost. Integrata Servizi 2 Penns Way Suite 405 New Castle, DE 19720

• Humes Realty 33 Bridle Ridge Court, Lewes, DE 19958

• Nichols Excavation 2742 Pulaski Hwy Newark, DE 19711

• 2284 Bryn Zion Road, Smyrna, DE 19904

• VEI Dover Crossroads, LLC 1500 Serpentine Road, Suite 100 Baltimore MD 21

• 580 North Dupont Highway Dover, DE 19901

• Casella postale 778 Dover, DE 19903

Ho lavorato molto su questo tipo di analisi. Poiché ci sono errori, non otterrai una precisione del 100%, ma ci sono alcune cose che puoi fare per ottenere la maggior parte del percorso e quindi eseguire un test BS visivo. Ecco il modo generale di procedere. Non è un codice, perché è abbastanza accademico scriverlo, non c'è stranezza, solo molta gestione delle stringhe.

(Ora che hai pubblicato alcuni dati di esempio, ho apportato alcune modifiche minori)

1. Lavora all'indietro. Inizia dal codice postale, che sarà vicino alla fine, e in uno dei due formati noti: XXXXX o XXXXX-XXXX. Se questo non appare, puoi presumere che sei nella città, porzione di stato, sotto.
2. La prossima cosa, prima della zip, sarà lo stato, e sarà in un formato a due lettere o come parole. Sai anche cosa saranno: ce ne sono solo 50. Inoltre, è possibile scrivere le parole per aiutare a compensare gli errori di ortografia.
3. prima quella è la città, ed è probabilmente sulla stessa linea dello stato. È possibile utilizzare un database di codici postali per controllare la città e lo stato in base allo zip, o almeno utilizzarlo come rilevatore BS.
4. L'indirizzo sarà generalmente una o due righe. La seconda riga sarà generalmente il numero della suite se ce n'è uno, ma potrebbe anche essere una casella postale.
5. Sarà quasi impossibile rilevare un nome sulla prima o seconda riga, anche se se non ha il prefisso con un numero (o se è preceduto da un "attn:" o "attenzione a:" potrebbe darti un suggerimento come se si tratta di un nome o di una riga di indirizzo.

Spero che questo aiuti un po '.

Penso che l'outsourcing del problema sia la soluzione migliore: inviarlo al geocoder Google (o Yahoo). Il geocoder restituisce non solo il lat / long (che qui non sono di interesse), ma anche una ricca analisi dell'indirizzo, con i campi compilati che non hai inviato (inclusi ZIP + 4 e contea).

Ad esempio, analizzando i rendimenti di "1600 Amphitheatre Parkway, Mountain View, CA"

{
  "name": "1600 Amphitheatre Parkway, Mountain View, CA, USA",
  "Status": {
    "code": 200,
    "request": "geocode"
  },
  "Placemark": [
    {
      "address": "1600 Amphitheatre Pkwy, Mountain View, CA 94043, USA",
      "AddressDetails": {
        "Country": {
          "CountryNameCode": "US",
          "AdministrativeArea": {
            "AdministrativeAreaName": "CA",
            "SubAdministrativeArea": {
              "SubAdministrativeAreaName": "Santa Clara",
              "Locality": {
                "LocalityName": "Mountain View",
                "Thoroughfare": {
                  "ThoroughfareName": "1600 Amphitheatre Pkwy"
                },
                "PostalCode": {
                  "PostalCodeNumber": "94043"
                }
              }
            }
          }
        },
        "Accuracy": 8
      },
      "Point": {
        "coordinates": [-122.083739, 37.423021, 0]
      }
    }
  ]
}

Ora che è parseable!

Il poster originale è probabilmente andato avanti a lungo, ma ho preso una pugnalata nel porting di Perl Geo :: StreetAddress: modulo USA usato da geocoder.us su C #, scaricato su CodePlex e penso che le persone che si imbattono in questa domanda in futuro potrebbero lo trova utile:

Parser indirizzo USA

Nella home page del progetto, provo a parlare delle sue (molto reali) limitazioni. Dal momento che non è supportato dal database USPS di indirizzi stradali validi, l'analisi può essere ambigua e non può confermare né negare la validità di un determinato indirizzo. Può solo provare a estrarre i dati dalla stringa.

È pensato per il caso in cui è necessario ottenere un set di dati principalmente nei campi giusti o se si desidera fornire un collegamento alla voce di dati (che consente agli utenti di incollare un indirizzo in una casella di testo anziché tabulare tra più campi). Non ha lo scopo di verificare la consegna di un indirizzo.

Non tenta di analizzare nulla al di sopra della linea della strada, ma probabilmente si potrebbe indovinare con la regex per ottenere qualcosa di ragionevolmente vicino - probabilmente lo spezzerei semplicemente al numero civico.

SmartyStreets ha una nuova funzionalità che estrae gli indirizzi da stringhe di input arbitrarie. (Nota: non lavoro su SmartyStreets.)

Ha estratto con successo tutti gli indirizzi dall'input di esempio fornito nella domanda precedente. (A proposito, solo 9 di questi 10 indirizzi sono validi.)

Ecco alcuni dei risultati:

Ed ecco l'output in formato CSV della stessa richiesta:

ID,Start,End,Segment,Verified,Candidate,Firm,FirstLine,SecondLine,LastLine,City,State,ZIPCode,County,DpvFootnotes,DeliveryPointBarcode,Active,Vacant,CMRA,MatchCode,Latitude,Longitude,Precision,RDI,RecordType,BuildingDefaultIndicator,CongressionalDistrict,Footnotes
1,32,79,"2299 Lewes-Georgetown Hwy, Georgetown, DE 19947",N,,,,,,,,,,,,,,,,,,,,,,
2,81,119,"11522 Shawnee Road, Greenwood DE 19950",Y,0,,11522 Shawnee Rd,,Greenwood DE 19950-5209,Greenwood,DE,19950,Sussex,AABB,199505209226,Y,N,N,Y,38.82865,-75.54907,Zip9,Residential,S,,AL,N#
3,121,160,"144 Kings Highway, S.W. Dover, DE 19901",Y,0,,144 Kings Hwy,,Dover DE 19901-7308,Dover,DE,19901,Kent,AABB,199017308444,Y,N,N,Y,39.16081,-75.52377,Zip9,Commercial,S,,AL,L#
4,190,232,"2 Penns Way Suite 405 New Castle, DE 19720",Y,0,,2 Penns Way Ste 405,,New Castle DE 19720-2407,New Castle,DE,19720,New Castle,AABB,197202407053,Y,N,N,Y,39.68332,-75.61043,Zip9,Commercial,H,,AL,N#
5,247,285,"33 Bridle Ridge Court, Lewes, DE 19958",Y,0,,33 Bridle Ridge Cir,,Lewes DE 19958-8961,Lewes,DE,19958,Sussex,AABB,199588961338,Y,N,N,Y,38.72749,-75.17055,Zip7,Residential,S,,AL,L#
6,306,339,"2742 Pulaski Hwy Newark, DE 19711",Y,0,,2742 Pulaski Hwy,,Newark DE 19702-3911,Newark,DE,19702,New Castle,AABB,197023911421,Y,N,N,Y,39.60328,-75.75869,Zip9,Commercial,S,,AL,A#
7,341,378,"2284 Bryn Zion Road, Smyrna, DE 19904",Y,0,,2284 Bryn Zion Rd,,Smyrna DE 19977-3895,Smyrna,DE,19977,Kent,AABB,199773895840,Y,N,N,Y,39.23937,-75.64065,Zip7,Residential,S,,AL,A#N#
8,406,450,"1500 Serpentine Road, Suite 100 Baltimore MD",Y,0,,1500 Serpentine Rd Ste 100,,Baltimore MD 21209-2034,Baltimore,MD,21209,Baltimore,AABB,212092034250,Y,N,N,Y,39.38194,-76.65856,Zip9,Commercial,H,,03,N#
9,455,495,"580 North Dupont Highway Dover, DE 19901",Y,0,,580 N DuPont Hwy,,Dover DE 19901-3961,Dover,DE,19901,Kent,AABB,199013961803,Y,N,N,Y,39.17576,-75.5241,Zip9,Commercial,S,,AL,N#
10,497,525,"P.O. Box 778 Dover, DE 19903",Y,0,,PO Box 778,,Dover DE 19903-0778,Dover,DE,19903,Kent,AABB,199030778781,Y,N,N,Y,39.20946,-75.57012,Zip5,Residential,P,,AL,

Ero lo sviluppatore che originariamente ha scritto il servizio. L'algoritmo che abbiamo implementato è un po 'diverso da qualsiasi risposta specifica qui, ma ogni indirizzo estratto viene verificato rispetto all'API di ricerca dell'indirizzo, quindi puoi essere sicuro che sia valido o meno. Ogni risultato verificato è garantito, ma sappiamo che gli altri risultati non saranno perfetti perché, come è stato ampiamente chiarito in questa discussione, gli indirizzi sono imprevedibili, anche a volte per gli umani.

L'ho fatto in passato.

O eseguilo manualmente (crea una bella interfaccia grafica che aiuti l'utente a farlo rapidamente) o fallo automatizzare e controlla un database di indirizzi recente (devi acquistarlo) e gestisci manualmente gli errori.

La gestione manuale richiederà circa 10 secondi ciascuno, il che significa che puoi fare 3600/10 = 360 all'ora, quindi 4000 dovrebbero durare circa 11-12 ore. Questo ti darà un alto tasso di precisione.

Per l'automazione, è necessario un recente database di indirizzi negli Stati Uniti e modificare le regole a tale proposito. Suggerisco di non impazzire per la regex (difficile da mantenere a lungo termine, tante eccezioni). Cerca una corrispondenza del 90% rispetto al database, fai il resto manualmente.

Ottieni una copia degli Standard di indirizzo postale (USPS) su http://pe.usps.gov/cpim/ftp/pubs/Pub28/pub28.pdf e nota che è lunga più di 130 pagine. Rileva l'implementazione che sarebbe pazzesca.

Per gli indirizzi internazionali, tutte le scommesse sono disattivate. I lavoratori con sede negli Stati Uniti non sarebbero in grado di convalidare.

In alternativa, utilizzare un servizio dati. Non ho, tuttavia, raccomandazioni.

Inoltre: quando invii le cose per posta (è per questo, no?) Assicurati di mettere "correzione indirizzo richiesta" sulla busta (nel posto giusto) e aggiorni il database. (Abbiamo realizzato una semplice interfaccia grafica per l'addetto alla reception per farlo; la persona che effettivamente ordina la posta)

Alla fine, quando hai cancellato i dati, cerca i duplicati.

Dopo il consiglio qui, ho ideato la seguente funzione in VB che crea dati utilizzabili passabili, sebbene non sempre perfetti (se vengono forniti un nome di società e una linea di suite, combina la suite e la città). Non esitate a commentare / refactor / urlare contro di me per aver infranto una delle mie regole, ecc .:

Public Function parseAddress(ByVal input As String) As Collection
    input = input.Replace(",", "")
    input = input.Replace("  ", " ")
    Dim splitString() As String = Split(input)
    Dim streetMarker() As String = New String() {"street", "st", "st.", "avenue", "ave", "ave.", "blvd", "blvd.", "highway", "hwy", "hwy.", "box", "road", "rd", "rd.", "lane", "ln", "ln.", "circle", "circ", "circ.", "court", "ct", "ct."}
    Dim address1 As String
    Dim address2 As String = ""
    Dim city As String
    Dim state As String
    Dim zip As String
    Dim streetMarkerIndex As Integer

    zip = splitString(splitString.Length - 1).ToString()
    state = splitString(splitString.Length - 2).ToString()
    streetMarkerIndex = getLastIndexOf(splitString, streetMarker) + 1
    Dim sb As New StringBuilder

    For counter As Integer = streetMarkerIndex To splitString.Length - 3
        sb.Append(splitString(counter) + " ")
    Next counter
    city = RTrim(sb.ToString())
    Dim addressIndex As Integer = 0

    For counter As Integer = 0 To streetMarkerIndex
        If IsNumeric(splitString(counter)) _
            Or splitString(counter).ToString.ToLower = "po" _
            Or splitString(counter).ToString().ToLower().Replace(".", "") = "po" Then
                addressIndex = counter
            Exit For
        End If
    Next counter

    sb = New StringBuilder
    For counter As Integer = addressIndex To streetMarkerIndex - 1
        sb.Append(splitString(counter) + " ")
    Next counter

    address1 = RTrim(sb.ToString())

    sb = New StringBuilder

    If addressIndex = 0 Then
        If splitString(splitString.Length - 2).ToString() <> splitString(streetMarkerIndex + 1) Then
            For counter As Integer = streetMarkerIndex To splitString.Length - 2
                sb.Append(splitString(counter) + " ")
            Next counter
        End If
    Else
        For counter As Integer = 0 To addressIndex - 1
            sb.Append(splitString(counter) + " ")
        Next counter
    End If
    address2 = RTrim(sb.ToString())

    Dim output As New Collection
    output.Add(address1, "Address1")
    output.Add(address2, "Address2")
    output.Add(city, "City")
    output.Add(state, "State")
    output.Add(zip, "Zip")
    Return output
End Function

Private Function getLastIndexOf(ByVal sArray As String(), ByVal checkArray As String()) As Integer
    Dim sourceIndex As Integer = 0
    Dim outputIndex As Integer = 0
    For Each item As String In checkArray
        For Each source As String In sArray
            If source.ToLower = item.ToLower Then
                outputIndex = sourceIndex
                If item.ToLower = "box" Then
                    outputIndex = outputIndex + 1
                End If
            End If
            sourceIndex = sourceIndex + 1
        Next
        sourceIndex = 0
    Next
    Return outputIndex
End Function

Passando la parseAddressfunzione "AP Croll & Son 2299 Lewes-Georgetown Hwy, Georgetown, DE 19947" ritorna:

2299 Lewes-Georgetown Hwy
A. P. Croll & Son  
Georgetown
DE
19947

Lavoro nel settore dell'elaborazione degli indirizzi da circa 5 anni e in realtà non esiste un proiettile d'argento. La soluzione corretta dipenderà dal valore dei dati. Se non è molto prezioso, lancialo attraverso un parser come suggeriscono le altre risposte. Se è anche un po 'prezioso, avrai sicuramente bisogno che un umano valuti / correggi tutti i risultati del parser. Se stai cercando una soluzione completamente automatizzata e ripetibile, probabilmente vorrai parlare con un fornitore di correzione indirizzi come Group1 o Trillium.

Questo non risolverà il tuo problema, ma se hai bisogno solo di dati lat / long per questi indirizzi, l'API di Google Maps analizzerà abbastanza bene gli indirizzi non formattati.

Buon suggerimento, in alternativa puoi eseguire una richiesta CURL per ciascun indirizzo a Google Maps e restituirà l'indirizzo correttamente formattato. Da ciò, puoi regex al contenuto del tuo cuore.

+1 sulla soluzione suggerita da James A. Rosen in quanto ha funzionato bene per me, tuttavia per i completisti questo sito è una lettura affascinante e il miglior tentativo che ho visto nel documentare indirizzi in tutto il mondo: http://www.columbia.edu/kermit /postal.html

Ci sono degli standard nel modo in cui gli indirizzi vengono registrati? Per esempio:

1. Ci sono sempre virgole o nuove linee che separano street1 da street2 dalla città dallo stato da zip?
2. I tipi di indirizzo (strada, via, viale, ecc.) Sono sempre indicati? sempre abbreviato? Alcuni di ciascuno?
3. Definire "errore".

La mia risposta generale è una serie di espressioni regolari, sebbene la complessità dipenda dalla risposta. E se non c'è alcuna coerenza, allora potresti essere in grado di ottenere solo un parziale successo con un Regex (cioè: filtrare il codice postale e lo stato) e dovrai fare il resto a mano (o almeno passare tutto il resto molto attentamente per assicurarsi di individuare gli errori).

Un'altra richiesta di dati di esempio.

Come è stato detto, lavorerei all'indietro dalla zip.

Una volta che hai una zip vorrei interrogare un database zip, archiviare i risultati e rimuoverli e la zip dalla stringa.

Questo ti lascerà con il disordine degli indirizzi. La maggior parte degli indirizzi (Tutti?) Inizierà con un numero, quindi trova la prima occorrenza di un numero nella stringa rimanente e prendi tutto da esso alla (nuova) fine della stringa. Questo sarà il tuo indirizzo. Qualunque cosa alla sinistra di quel numero è probabilmente un destinatario.

Ora dovresti avere la città, lo stato e lo zip memorizzati in una tabella e possibilmente due stringhe, un destinatario e un indirizzo. Per l'indirizzo, controlla l'esistenza di "Suite" o "Apt." ecc. e dividerlo in due valori (indirizzo 1 e 2).

Per il destinatario vorrei puntare e prendere l'ultima parola di quella stringa come cognome e mettere il resto nel campo del nome. Se non vuoi farlo, dovrai verificare il saluto (Mr., Ms., Dr., ecc.) All'inizio e fare delle ipotesi basate sul numero di spazi su come il nome è costituita.

Non credo che ci sia modo di analizzare con una precisione del 100%.

Prova www.address-parser.com . Usiamo il loro servizio web, che puoi testare online

Sulla base dei dati di esempio:

1. Vorrei iniziare alla fine della stringa. Analizzare un codice di avviamento postale (entrambi i formati). Leggi fine al primo spazio. Se non è stato trovato alcun codice postale Errore.

2. Taglia la fine quindi per spazi e caratteri speciali (virgole)

3. Quindi passare allo stato, utilizzare nuovamente lo spazio come delimitatore. Forse utilizzare un elenco di ricerca per convalidare codici di stato a 2 lettere e nomi di stato completi. Se non viene trovato uno stato valido, errore.

4. Taglia nuovamente spazi e virgole dalla fine.

5. La città diventa complicata, in realtà userei una virgola qui, a rischio di ottenere troppi dati in città. Cerca la virgola o l'inizio della riga.

6. Se hai ancora caratteri nella stringa, inseriscili tutti in un campo indirizzo.

Questo non è perfetto, ma dovrebbe essere un buon punto di partenza.

Se si tratta di dati immessi umani, passerai troppo tempo a cercare di codificare le eccezioni.

Provare:

1. Espressione regolare per estrarre il codice postale

2. Ricerca del codice postale (tramite DB governativo appropriato) per ottenere l'indirizzo corretto

3. Chiedi a uno stagista di verificare manualmente che i nuovi dati corrispondano a quelli precedenti

Questo non risolverà il tuo problema, ma se hai bisogno solo di dati lat / long per questi indirizzi, l'API di Google Maps analizzerà abbastanza bene gli indirizzi non formattati.

RecogniContact è un oggetto COM di Windows che analizza gli indirizzi statunitensi ed europei. Puoi provarlo direttamente su http://www.loquisoft.com/index.php?page=8

Potresti voler dare un'occhiata !! http://jgeocoder.sourceforge.net/parser.html Ha funzionato come un incantesimo per me.

Questo tipo di problema è difficile da risolvere a causa delle ambiguità sottostanti nei dati.

Ecco una soluzione basata sul Perl che definisce un albero grammaticale di discesa ricorsivo basato su espressioni regolari per analizzare molte combinazioni valide di indirizzi stradali: http://search.cpan.org/~kimryan/Lingua-EN-AddressParse-1.20/lib/Lingua /EN/AddressParse.pm . Ciò include le proprietà secondarie all'interno di un indirizzo come: 12 1st Avenue N Suite # 2 Somewhere CA 12345 USA

È simile a http://search.cpan.org/~timb/Geo-StreetAddress-US-1.03/US.pm sopra menzionato, ma funziona anche per indirizzi che non provengono dagli Stati Uniti, come Regno Unito, Australia e Canada.

Ecco l'output per uno dei tuoi indirizzi di esempio. Si noti che la sezione del nome dovrebbe essere rimossa prima da "AP Croll & Son 2299 Lewes-Georgetown Hwy, Georgetown, DE 19947" per ridurla a "2299 Lewes-Georgetown Hwy, Georgetown, DE 19947". Ciò si ottiene facilmente rimuovendo tutti i dati fino al primo numero trovato nella stringa.

Non matching part       ''
Error                   '0'
Error descriptions      ''
Case all                '2299 Lewes-Georgetown Hwy Georgetown DE 19947'
COMPONENTS              ''
country                 ''
po_box_type             ''
post_box                ''
post_code               '19947'
pre_cursor              ''
property_identifier     '2299'
property_name           ''
road_box                ''
street                  'Lewes-Georgetown'
street_direction        ''
street_type             'Hwy'
sub_property_identifier ''
subcountry              'DE'
suburb                  'Georgetown'

Poiché esiste la possibilità di errore a parole, pensa a utilizzare SOUNDEX combinato con l'algoritmo LCS per confrontare le stringhe, questo ti aiuterà molto!

utilizzando l'API di google

$d=str_replace(" ", "+", $address_url);
$completeurl ="http://maps.googleapis.com/maps/api/geocode/xml?address=".$d."&sensor=true"; 
$phpobject = simplexml_load_file($completeurl);
print_r($phpobject);

Per gli sviluppatori di ruby ​​o rails c'è una bella gemma disponibile chiamata street_address . Ho usato questo su uno dei miei progetti e fa il lavoro di cui ho bisogno.

L'unico problema che ho avuto è stato ogni volta che un indirizzo è in questo formato P. O. Box 1410 Durham, NC 27702 ha restituito zero e quindi ho dovuto sostituire "PO Box" con "" e dopo questo sono stato in grado di analizzarlo.

Ci sono servizi dati che hanno dato un codice postale ti daranno un elenco di nomi di strade in quel codice postale.

Usa un regex per estrarre lo stato di Zip o City - trova quello corretto o se un errore ottiene entrambi. estrarre l'elenco delle strade da un'origine dati Correggere la città e lo stato, quindi l'indirizzo. Una volta ottenuta una riga Indirizzo 1, città, stato e CAP validi, è possibile fare ipotesi sulla riga Indirizzo 2..3

Non so QUANTO FATTO sarebbe, ma non l'ho visto menzionato, quindi ho pensato di andare avanti e suggerire questo:

Se sei rigorosamente negli Stati Uniti ... ottieni un enorme database di tutti i codici postali, stati, città e strade. Ora cerca questi nei tuoi indirizzi. Puoi convalidare ciò che trovi testando, per esempio, se la città che hai trovato esiste nello stato che hai trovato o controllando se la strada che hai trovato esiste nella città che hai trovato. Altrimenti, è probabile che John non sia per John's Street, ma è il nome del destinatario ... Fondamentalmente, ottieni il maggior numero di informazioni possibile e controlla i tuoi indirizzi contro di essa. Un esempio estremo sarebbe quello di ottenere un ELENCO DI TUTTI GLI INDIRIZZI NEGLI USA DI A e quindi trovare quale ha la corrispondenza più pertinente con ciascuno dei tuoi indirizzi ...

Esiste una porta javascript di perl Geo :: StreetAddress :: pacchetto USA: https://github.com/hassansin/parse-address . È basato su regex e funziona abbastanza bene.