Inhaltsverzeichnis

Toggle

In diesem Teil der Python Grundlagen werden wir zusammen ein sehr einfaches Script erstellen, welches prüft ob eine Webseite erreichbar ist. Hierfür solltest du bereits die Python 3 Umgebung fertig installiert haben. Wie dies genau funktioniert kannst du in diesem Artikel nachlesen.
Ich beziehe mich hier immer auf eine Python Installation die auf meinem Raspberry Pi läuft. Natürlich geht dies auch auf jeder anderen Linux, MAC und Windows Umgebung, auf der Python installiert ist.

Ziel / Beschreibung des Python Scripts

Das Python Script wird mit Angabe einer HTML-Seite aufgerufen, dieser Wert wird dann an eine Funktion übergeben und prüft ob sich diese erreichen lässt. Sollte es einen Timeout oder anderen Fehler geben, wird dieser abgefangen und angezeigt. Bei einer positiven Rückantwort der Webseite, wird noch geprüft welchen Code diese zurück gibt und ausgewertet.

Was kann ich hier lernen?

• Wie man eine benötigte Bibliothek installiert und importiert
• Wie man eine Funktion erstellt
• Wie man bei Aufruf des Scripts mit Parameter weiterarbeiten kann
• Wie man Fehlercode abfängt
• Was ein ‘return’ bedeutet
• Was eine IF-Abfrage ist und kann

Das fertige Python Script

#!/usr/bin/python3
# -*- coding: utf-8 -*-
#*****************************
#*****Name: check_site.py*****
#*******DarkWolfCave.de*******
#*****************************
import requests
import sys

def check_site(url):
        headers = {'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'}
        try:
                r = requests.get(url,headers=headers,timeout=3)
                if r.status_code != 200:
                        rstat="Seite nicht erreichbar, Zugriff verweigert oder LogIn notwendig. StatusCode:"
                        return rstat, r.status_code
                else:
                        rstat='Seite erreichbar. StatusCode:'
                        return rstat, r.status_code
        except requests.exceptions.RequestException as e:
                return 'Timeout? Fehlermeldung: ',SystemExit(e)

text,code = check_site(sys.argv[1])
print (text,code)

Wir fangen an – und starten unser env

Wenn du meiner Anleitung zu den Python Grundlagen – Umgebung gefolgt bist, solltest du eine eigene env erstellt haben, die wir jetzt noch aktivieren müssen.
Falls du keine hast und auch nicht nutzen möchtest, erstelle dir einfach einen Ordner indem du das Script speicherst. Oder du siehst in diesem Artikel nach und richtest dir schnell eine eigene Umgebung (env) dazu ein. Ich warte auch solange ;-)

Geh in deinem Ordner wo du die env eingerichtet hast und starte diese mit folgendem Befehl:
source ./DEINE_ENV/bin/activate
Jetzt werden alle pip-Installationen nur noch in dieser env und nicht im gesamten System installiert.
Achte also immer darauf ob du dich in deiner aktivierten env befindest. Dies erkennst du unter anderem an dem prompt, welcher den Namen deiner Umgebung enthält.

Bibliotheken installieren mit pip

Wir benötigen, zur einfacheren Abfrage und Auswertung der Webseiten, die Bibliothek ‘requests’ die wir zuerst installieren müssen.
In den Vorbereitungen haben wir ja schon ‘pip’ installiert – dies ist ein Tool, das Python-Programmierpakete/Bibliotheken installieren und verwalten kann. Daher laden wir uns jetzt direkt die benötigte Bibliothek herunter:

python3 -m pip install requests

Legen wir los und erstellen check_site.py

Erstelle eine Datei mit dem Namen check_site.py. Dazu kannst du vi check_site.py oder nano check_site.py benutzen. In diese fügst du dann den, unter dem Punkt “Das fertige Script”, gezeigte Code hinein.

(kleiner Hinweis für alle nicht Python-Nutzer: Bei Python ist es enorm wichtig die TABs einzuhalten. Denn ansonsten wird das Script nicht funktionieren. Wer mit nano / vi dabei Probleme hat, sollte zum Beispiel Notepad++ oder VisualStudioCode benutzen. Danach die Datei mit MobaXterm / FileZilla usw. in den entsprechenden Ordner laden).

In den ersten beiden Zeilen kommen Encoding-Parameter für den Interpreter hinein. In diesem Fall sagen wir, bei einem Aufruf des Script ohne spezielle Angabe von z.B. Python3 soll “Zeile1” genutzt werden . hier: #!/usr/bin/python3.
Das heißt, wenn du das Script später mit ./check_site.py aufrufst, soll python3 den Code verarbeiten.
In der zweiten Zeile steht die Zeichencodierung die wir nutzen wollen: # -*- coding: utf-8 -*-

Ich nutze diese beiden Zeilen eigentlich in jedem meiner Python Scripte.

Importieren der genutzten Bibliotheken

Jetzt müssen wir noch angeben, welche Bibliotheken wir verwenden wollen. Also welche Funktionen / Klassen wir benötigen.
Hier kann man zum einen nur die genutzten Funktionen importieren oder, wie wir es jetzt machen, die gesamte Bibliothek.

Dazu verwenden wir den import Befehl.
Wir benötigen die ‘requests’ um später eine GET Anfrage an eine Webseite senden und die Antwort auswerten zu können.
Weiterhin möchten wir mit übermittelten Argumente/Werten arbeiten. Dies ist in der Bibiothek ‘sys’ hinterlegt. Davon werden wir ‘argv’ später benutzen:

import requests
import sys

Nachdem du die benötigten Bibliotheken importiert hast, können wir ab jetzt auf deren Funktionen zugreifen.

Unsere eigene Funktion ( check_site(url) )

Da wir unser Python Script später mit einem Parameter – der URL – aufrufen und diese dann prüfen wollen, erstellen wir uns eine eigene Funktion.
Möchtest du weitere Informationen über Funktionen, dann empfehle ich dir diesen Artikel von mir.

def check_site(url):
        headers = {'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'}
        try:
                r = requests.get(url,headers=headers,timeout=3)
                if r.status_code != 200:
                        rstat="Seite nicht erreichbar, Zugriff verweigert oder LogIn notwendig. StatusCode:"
                        return rstat, r.status_code
                else:
                        rstat='Seite erreichbar. StatusCode:'
                        return rstat, r.status_code
        except requests.exceptions.RequestException as e:
                return 'Timeout? Fehlermeldung: ',SystemExit(e)

Wir nennen unsere Funktion einfach mal ‘check_site’ und erwarten einen Parameter ‘(URL)’.
Weiterhin legen wir in einer Variable (headers) einen user-agent fest, dieser muss zwar nicht mit angegeben werden, allerdings werden je nach Konfiguration der zu prüfenden Website, Anfragen, ohne einen solchen user-agent im header, einfach abgelehnt.
In meinem Beispiel nehme ich einen aktuellen Browser(user-agent): Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36.

Als nächstes sagen wir mit ‘try:’ dass der folgende, und eingerückte Code, ausgeführt werden soll. Bei einem Fehler wird mit ‘except’ die Fehlerbehandlung gestartet. Bleiben wir aber zuerst in dem try: Bereich.

r = requests.get(url,headers=headers,timeout=3)

Wir basteln uns eine Anfrage an eine Website und speichern dieses Ergebnis in einer Variable ( hier ‘r’ ) welche später dann die Antwort als Objekt enthalten wird..
‘requests.get’ bezieht sich auf die anfangs importierte Bibliothek ‘requests’ und nutzt deren Funktion ‘get’.
Diese Funktion erwartet, wie auch unsere eigene, diverse Parameter.

Zuerst teilen wir die URL mit, auf die wir zugreifen wollen. Dafür nehmen wir die Variable aus unserer eigenen Funktion (hier: ‘URL’).
In dieser wird später die entsprechende Website-Adresse enthalten sein, mit der wir unser Script aufrufen.
‘headers=headers’ übergibt bei der Anfrage an die Website im header-bereich unseren user-agent, den wir ja weiter oben in der Variable ‘headers’ festgelegt haben.
Mit ‘timeout=3’ sagen wir lediglich, dass die Anfrage maximal 3 Sekunden auf eine Antwort der Website warten soll.
Falls diese nicht erreichbar ist, würden wir so einen Timeout erhalten, den wir im Bereich ‘except’ später abfangen werden..

Mit dieser einen Zeile haben wir schon alles, um prüfen zu können, ob eine Website erreichbar ist oder nicht.
Das Ergebnis könnten wir jetzt einfach mit z.B. print ausgeben – aber das wäre ja langweilig :-P

Daher zeige ich dir jetzt noch wie du mit einer ‘IF ELSE’ Abfrage bestimmte Bedingungen prüfen kannst.

IF – ELSE Abfrage

if r.status_code != 200:
                        rstat="Seite nicht erreichbar, Zugriff verweigert oder LogIn notwendig. StatusCode:"
                        return rstat, r.status_code
                else:
                        rstat='Seite erreichbar. StatusCode:'
                        return rstat, r.status_code

Auch hier ist es wieder wichtig, dass du darauf achtest den Code nach der IF-Anweisung einzurücken.
Denn nur der eingerückte Code gehört dann zu der “inneren” IF-Bedingung und würde ausgeführt werden.

if r.status_code != 200:

Einfach gesagt: Ist das Ergebnis aus unserer Anfrage NICHT 200, dann führe den folgenden Code aus:
Etwas komplizierter gesagt: ‘r.status_code’ bezieht sich auf unser Objekt mit dem Ergebnis der Anfrage und nutzt die Funktion ‘status_code’, die im Prinzip einfach die “Zahl” aus der Response ausschneidet.

Hier mal ein Bild was es vielleicht verständlicher macht:

Das erste Ergebnis wäre ein einfaches Print unseres Objektes (<Response [200]>). Dies lässt sich aber recht schlecht mit einer Zahl vergleichen. Und hier nutzen wir dann ‘status_code’ – dies extrahiert die Zahl und enthält somit nur noch die “200”.

Also wieder zurück zu unserer IF-Abfrage. Wenn also r.status_code NICHT 200 enthält, dann führe den nachfolgenden Code aus.
Bekommen wir eine 403 zurück, meldet der Server “forbidden” und die Abfrage würde den weiteren eingerückten Code ausführen, da 403 ja nicht 200 ist. :-)

rstat="Seite nicht erreichbar, Zugriff verweigert oder LogIn notwendig. StatusCode:"
return rstat, r.status_code

In die Variable ‘rstat’ schreiben wir einen netten Text und geben diesen, sowie den eigentlichen Code mit ‘r.status_code’ über die Funktion ‘return’ zurück. Hiermit wäre unsere Funktion auch beendet und die Werte erhält der aufrufende Prozess zurück.

Und was ist nun wenn die Webseite ein “200” (also ‘ok’) zurück meldet?
200 ist nicht, nicht 200…. also springt der Interpreter weiter in die ‘else:’ und verarbeitet den danach eingerückten Code

else:
rstat='Seite erreichbar. StatusCode:'
return rstat, r.status_code

Auch hier erstellen wir eine Variable ‘rstat’ und füllen diese mit Text. mit ‘return rstat, r.status_code’ geben wir die Variable und den eigentlichen Status Code zurück an den aufrufenden Prozess.

except / Fehlerbehandlung

Achja.. da war ja am Anfang noch was. Wir haben einen ‘try:’ Bereich erschaffen der ausgeführt werden sollte.
Und falls bei diesem “Versuch” etwas falsch läuft, müssten wir diesen Fehler jetzt noch abfangen.
Da uns in diesem Fall wirklich nur der zurückgegebene Fehler interessiert, halten wir es hier recht einfach und allgemein.
except requests.exceptions.RequestException as e:
return 'Timeout? Fehlermeldung: ',SystemExit(e)

TRY: und EXCEPT: gehören gewissermaßen zusammen.
Sollte der Try-Bereich nicht erfolgreich sein, erfahren wir hier den zurückgemeldeten Fehler, indem wir uns auf Funktionen der Bibliothek requests (requests.exceptions.RequestException) beziehen und diese dann mit ‘SystemExit(e)’ per ‘return’ an den aufrufenden Prozess zurückgeben.

Aufruf der Funktion und Anzeige des Ergebnisses

Bisher haben wir eine Funktion erstellt und definiert was diese genau machen soll, außerdem fangen wir eventuelle Fehler dabei ab und prüfen welchen Status-Code eine Webseite zurückmeldet.
Allerdings fehlt uns noch der eigentliche Aufruf unserer Funktion und die Anzeige. Sonst sehen wir ja nichts…

text,code = check_site(sys.argv[1])
print (text,code)

Wenn du dir die Funktion nochmal anschaust, wirst du erkennen dass wir immer 2 Werte über ‘return’ zurückgeben.
Daher weisen wir beim Aufruf der Funktion diesen jetzt zwei Variablen zu.:

text,code = check_site(sys.argv[1])

Somit werden die Ergebnisse aus unserer check_site in ‘text‘ und ‘code‘ gespeichert und in der nächsten Zeile mit Print ausgegeben.
Wir haben die Funktion check_site ja so definiert, dass diese einen Parameter erwartet (URL). Daher müssen wir diesen auch beim starten mit angeben. Dies geschieht hier, indem wir auf einen bereits bei Aufruf des Scripts gelieferten Parameter zurückgreifen.
Dafür haben wir am Anfang die Bibliothek ‘sys’ importiert und können jetzt auf dessen Funktionen zugreifen und nutzen ‘sys.argv[1]’.
Hier wird später unsere URL gespeichert sein, die wir beim ausführen des gesamten Scripts angegeben haben.

Sobald wir ein Script starten, enthält sys.argv Parameter, auf diese wir zugreifen können. Ein Beispiel:
python3 test.py “ich”,”bin”,”am testen”
Wenn wir jetzt auf die einzelnen Argumente zugreifen wollen, würde das mit sys.argv[] gehen, wobei die [0] immer den Namen des gestarteten Scripts enthält.
sys.argv[0] = test.py
sys.argv[1] = ich
sys.argv[2] = bin
sys.argv[3] = am testen

Nun kannst du das Script selbst testen. Dafür führst du einfach nur folgendes im Terminal aus – natürlich kannst du auch eine andere URL angeben:

python3 check_site.py "https://darkwolfcave.de"

Querverweise