Google ist ein Phänomen: Die Suchmaschine kennt mehr als 8 Milliarden Webseiten. Dazu kommen mehr als 845 Millionen Usenet-Postings. Googles Infrastruktur umfasst inzwischen mehr als 250.000 Server. Nirgendwo anders wird eine größere Menge an Daten verarbeitet und per Website der Öffentlichkeit zugänglich gemacht. Inzwischen dürfen nicht mehr nur Menschen, sondern auch Maschinen auf den Datenschatz zugreifen: Das Zauberwort heißt “Web Services”.

Im letzten Teil der “Daten, Daten, Daten”-Serie [1] wurde das Konzept der Web Services vorgestellt. Zur Erinnerung:

Was für uns Menschen Websites sind, das sind für Computer Web Services - Internet-Dienste, die in der Regel von größeren Firmen wie Amazon, Google oder eBay angeboten werden und Unmengen an Informationen in (vornehmlich) maschinenlesbaren Formaten liefern.

Im Gegensatz zu den meisten Websites werden die Informationen bei Web Services als XML-Dateien abgerufen. XML (Extensible Markup Language) ist “ein Standard zur Erstellung strukturierter, maschinen- und menschenlesbarer Dateien.” [2]

Diese XML-Dateien werden über das SOAP-Protokoll (Simple Object Access Protocol) vom Server abgerufen und lokal weiterverarbeitet. Erfreulicherweise bleibt es dem Software-Entwickler dabei oft erspart, sich mit den Hintergründen von SOAP, XML und Co zu befassen, wenn bereits Module für die Programmiersprache und den Web Service der Wahl existieren.

Für die Google-API trifft das zu. Ob Visual Basic .Net [3], PHP [4] oder Python [5]: Für die Einbindung der API braucht es nicht mehr als ein paar Zeilen Code. Wie schon im Artikel über die Amazon Web Services verwende ich auch hier zur Demonstration der Möglichkeiten wieder Python, da der Code vergleichsweise einfach zu lesen ist und mit PyGoogle [5] ein exzellentes Modul für die API existiert.

Doch was ist mit der Google-API [6] möglich, welche Daten stellt Google bereit? Neben Suchergebnissen in maschinenlesbarer Form sind die zwischengespeicherten Cache-Seiten, die Google von fast jeder Website erstellt, sowie Googles Rechtschreibkorrektur aufrufbar.

Die Suchergebnisse sind dabei der interessanteste Part. Sie enthalten unter anderem die Anzahl der Resultate für eine bestimmte Anfrage (estimatedTotalResultsCount), die Zeit, die die Suche in Anspruch nahm (searchTime) und die einzelnen gefundenen Seiten mit URL, Titel (title), Ausschnitt aus der Seite (snippet), Dateigröße (cachedSize) und Kategorie (directoryCategory).

Ein Beispiel sagt mehr als tausend Worte, also versuchen wir uns an folgender Fragestellung: Welches der Jahre 1985-2009 wird am häufigsten im Internet erwähnt? Und wie oft wurde es im Vergleich zu den anderen Jahren erwähnt? Unser Beispielprogramm soll also Suchvorgänge nach den Phrasen “year 1985″, “year 1986″, …, “year 2009″ durchführen und jeweils die Anzahl der Gesamtsuchergebnisse ausgeben.

In Python sieht das folgendermaßen aus:import google, sys
google.setLicense('YourLicenseKey')
 
for k in range(1985,2010):
    try:
        gData = google.doGoogleSearch('\'year ' + \
str(k)+'\'')
        print k, \
str(gData.meta.estimatedTotalResultsCount).rjust(10)
    except:
        print 'Fehler:', sys.exc_info()[0]
        break;

Ist das PyGoogle-Modul installiert und ein gültiger Lizenz-Schlüssel angegeben (kann unter [8] angefordert werden), so wird das Programm der Reihe nach die Phrasen-Suchen auführen und die Suchergebnisse ausgeben:1985     117000
1986     111000
1987     126000
1988     136000
1989     148000
1990     216000
(…)
2003    2100000
2004    2840000
2005    1280000
2006     149000
2007      65400
2008      40100
2009      21400

Das Jahr 2004 wird also zurzeit am häufigsten erwähnt, etwas öfters als das Jahr 2000. Natürlich lassen sich aus der Google-API gewonnene Daten auch graphisch darstellen:

Ein weiteres Beispiel: Wir interessieren uns für alle Websites mit .de-Domain, die in den Top-50 Suchergebnissen für das Stichwort “Neuronale Netze” auftauchen. Eine alphabetisch sortierte Liste der Webadressen soll ausgegeben werden, wobei keine Domain doppelt vorkommen soll. Mit der Google-API kein Problem:import google, sys
 
google.setLicense('YourLicenseKey')
Results = []
 
for k in range(0,50,10):
    try:
        gData = \
google.doGoogleSearch('neuronale netze',k,10)
        for n in gData.results:
            Results.append(n.URL)
    except:
        print 'Fehler:', sys.exc_info()[0]
        break;
 
Results = [n[7:n.find('/',7)] \
for n in Results if (n.find('.de') != -1)]
Results = [n for i,n \
in enumerate(Results) if n not in Results[:i]]
 
Results.sort()
for n in Results:
    print n

Das Python-Programm führt 5 Suchvorgänge mit jeweils 10 Ergebnissen aus und fügt für jede URL eines Suchergebnisses der “Results”-Liste einen neuen Eintrag hinzu. Tritt ein Fehler auf (z.B. keine Internetverbindung verfügbar), so bricht das Programm ab und gibt eine entsprechende Fehlermeldung aus.

Nachdem die Ergebnisse erfolgreich abgerufen wurden, wird die “Results”-Liste auf die Einträge eingegrenzt, bei denen “.de” in der URL vorkommt. Gleichzeitig wird das “http://” am Anfang sowie der Verzeichnisstrang am Ende der URL entfernt.

In der nächsten Zeile des Programms werden sämtliche doppelten “Results”-Einträge gelöscht, danach sortiert und per “print” angezeigt. Die Ausgabe des Programms sieht dann in etwa so aus:
fuzzy.cs.uni-magdeburg.de
home.zait.uni-bremen.de
itb.biologie.hu-berlin.de
rfhs8012.fh-regensburg.de
www-lehre.inf.uos.de
www-ra.informatik.uni-tuebingen.de
www.andreas-mielke.de
www.artifin.de
www.documanager.de
www.faes.de
(…)
www.medi-informatik.de
www.neuro.ct-webspace.de
www.physik.uni-regensburg.de
www.vdi.de
wwwhni.uni-paderborn.de
wwwmath.uni-muenster.de
wwwuser.gwdg.de

Natürlich lässt sich die Google-API auch hervorragend zum Zwecke der Suchmaschinen-Analyse und Optimierung (Search Engine Optimization, SEO) verwenden. Das nächste Beispielprogramm dieses Artikels soll anhand der ersten 50 Suchergebnisse für den Begriff “SEO” feststellen, welchen Wert Google auf das Vorkommen des Suchbegriffes in Titel und URL legt bzw. bei welchem Anteil der Suchergebnisse der Suchbegriff in Titel/URL vorkommt.

Der Python-Quellcode ist weitgehend selbsterklärend:
import google, sys
 
google.setLicense('YourLicenseKey')
InTitle = 0
InURL = 0
KeyWord = 'python'
NumResults = 50
 
for k in range(0,NumResults,10):
    try:
        gData = google.doGoogleSearch(KeyWord,k,10)
        for n in gData.results:
            m = n.URL.lower()
            if (m.find(KeyWord) != -1):
                InURL += 1
            m = n.title.lower()
            if (m.find(KeyWord) != -1):
                InTitle += 1
    except:
        print 'Fehler:', sys.exc_info()[0]
        break;
 
print 'Keyword: ',KeyWord
print 'Keyword in URL: ',InURL,'von',NumResults, \
'(', float(InURL)/float(NumResults)*100, '% )'
print 'Keyword in Titel: ',InTitle,'von',NumResults, \
'(', float(InTitle)/float(NumResults)*100, '% )'
Nachdem eine Suchergebnis-Liste mit 10 Ergebnissen geladen wurde, werden für jedes Element URL und Titel in Kleinbuchstaben umgewandelt und nach dem Schlüsselwort durchsucht. Wird es gefunden, so werden die Variablen InURL bzw. InTitle um 1 erhöht. Vor das Programm endet, werden die Variablen als ganze Zahlen sowie als Prozentzahlen ausgegeben. Konkret sieht das so aus:
Keyword:           seo
Keyword in URL:    33 von 50 ( 66.0 % )
Keyword in Titel:  37 von 50 ( 74.0 % )
 
Keyword:           search
Keyword in URL:    14 von 50 ( 28.0 % )
Keyword in Titel:  25 von 50 ( 50.0 % )
 
Keyword:           python
Keyword in URL:    27 von 50 ( 54.0 % )
Keyword in Titel:  42 von 50 ( 84.0 % )

Erweiterungen sind durchaus denkbar. Das Programm könnte beispielsweise die Prozentzahlen für die ersten 50 Suchergebnisse mit denen der Suchergebnisse 50-100 vergleichen und auf Unterschiede überprüfen. Weiterhin wäre es denkbar, dass ganze Wortlisten automatisch abgearbeitet werden und die Ergebnisse in einer mit Tabellenkalkulationsprogrammen lesbaren (CSV-)Datei gespeichert werden.

Die Analyse von mehr als 20 hochfrequentierten Suchwörtern ergab folgenden Graph, die X-Achse gibt dabei die Nummer der Suchergebnis-Seite an:

Die meisten Seiten, die in den Top-200 für so hart umkämpfte Schlüsselwörter wie “advertising”, “business”, “estate”, “software” oder “marketing” vorkommen, haben das entsprechende Keyword im Titel. Den Unterschied kann die Verwendung von Keywords in der URL machen: Hier unterscheiden sich die Top-20 vom Rest.

Zum Vergleich der Graph, der sich bei der Analyse 20 weniger begehrter Keywords wie zum Beispiel “singularity”, “tschebyschew” oder “backpropagation” ergab:

Als Demonstration der Möglichkeiten der Google-API zur Suchmaschinenanalyse sollte das genügen. Was hier an Code vorgestellt wurde, ist das Ergebnis von 15 Minuten Arbeit — mit etwas größerem Zeitaufwand sind die Möglichkeiten schier unbegrenzt.

Zum Abschluss noch der Quellcode für ein Programm, das vor allem für Website-Betreibern von Nutzen ist: Ein Ranking-Checker. Das Programm ähnelt dem zuvor beschriebenen Analyse-Programm, überprüft aber anstatt des Vorkommens des Suchworts in URL/Titel das Vorkommen der eigenen URL in den Suchergebnissen. So lässt sich schnell feststellen, auf welcher Position der Suchergebnis-Seiten die eigene Website für bestimmte Keywords zu finden ist.
import google, sys
 
google.setLicense('YourLicenseKey')
KeyWord = 'singularitaet'
MySite = 'aiplayground.org'
NumResults = 100
ResFound = 0
 
for k in range(0,NumResults,10):
    try:
        gData = google.doGoogleSearch(KeyWord,k,10)
        rc = 0
        for n in gData.results:
            rc += 1
            m = n.URL.lower()
            if (m.find(MySite) != -1) and (ResFound == 0):
                ResFound = k+rc
                break;
    except:
        print 'Fehler:', sys.exc_info()[0]
        break;
 
print 'Website: ',MySite
print 'Keyword: ',KeyWord
print 'Position: ',ResFoundDie Variable “k” gibt dabei jeweils die aktuelle Seite der Suchergebnisse an (10, 20, 30, …), die Variable “rc” die Position auf dieser Seite (1, 2, 3, …). Wird die eigene Website in der URL eines Suchergebnisses gefunden, so wird die Gesamt-Position, d.h. die Summe aus “k” und “rc”, in der Variablen “ResFound” abgespeichert, weitere Suchvorgänge abgebrochen und die Position auf dem Bildschirm ausgegeben.

Ein Ablauf des Programms kann zum Beispiel so aussehen:
Website: aiplayground.org
Keyword: singularitaet
Position: 52Die Verwendung dieses Ranking-Checkers ist allerdings nur begrenzt hilfreich: Google verwendet für die API einen anderen, nicht ganz so umfangreichen Index an Websites als für die Suchergebnisse, die auf Google.com zurückgegeben werden. Wer sein genaues Ranking erfahren will und das nicht per Hand tun will, ist also gezwungen, die Suchergebnisse direkt von Googles HTML-Seiten einzulesen.

[1] Daten, Daten, Daten: Amazon Web Services
[2] Wikipedia: XML
[3] Google APIs und VB.Net
[4] Google APIs und PHP
[5] Google APIs und Python: PyGoogle
[6] Google Web APIs
[7] Google Web APIs LicenseKey anfordern
[8] Google: Mehr als 250.000 Server