Für alle Python Grundlagen Themen verwende ich eine eigene Umgebung. Wie du diese erstellen kannst, und wie du grundsätzlich Scripte startest oder Befehle in der CLI ausführst, erkläre ich in diesem Artikel

Ein Beispiel ohne Python Funktionen

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

import requests
import sys
#******Erste Abfrage für die erste 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'}
url = 'https://darkwolfcave.de/'
r = requests.get(url,headers=headers,timeout=3)
if r.status_code != 200:
        rstat="Seite nicht erreichbar, Zugriff verweigert oder LogIn notwendig. StatusCode:",r.status_code

else:
        rstat='Seite erreichbar. StatusCode:',r.status_code
#***Ausgabe des Ergebnis der ersten URL
print('Webseite1:',url, rstat)

#******Zweite Abfrage für die zweite URL
url2 = 'https://testing.darkwolfcave.de'
r = requests.get(url2,headers=headers,timeout=3)
if r.status_code != 200:
        rstat="Seite nicht erreichbar, Zugriff verweigert oder LogIn notwendig. StatusCode:",r.status_code

else:
        rstat='Seite erreichbar. StatusCode:',r.status_code
#***Ausgabe des Ergebnis der zweiten URL
print('Webseite2:',url2, rstat)

Der Sourcecode läuft von oben nach unten ab und führt entsprechend die Anweisungen aus.
Wir wollen wissen ob eine Webseite erreichbar ist, dafür übergeben wir eine URL und lassen uns die Antworten ausgeben.
Wie du bei den markierten Zeilen erkennen kannst, haben wir hier den Quelltext doppelt ausgeführt, lediglich die URL wurde geändert.
Jetzt stell dir mal vor, du möchtest 100 Seiten gleichzeitig abfragen….
Und genau hier kommen, unter anderem, Funktionen ins Spiel.

Bauen wir das Beispiel von oben ein wenig um und gehen danach auf die einzelnen Schritte näher ein:

Das Beispiel mit Python Funktionen

#!/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 url, rstat, r.status_code
                else:
                        rstat='Seite erreichbar. StatusCode:'
                        return url, rstat, r.status_code
        except requests.exceptions.RequestException as e:
                return 'Timeout? Fehlermeldung: ',SystemExit(e)

print ('Ergebnis Website1: ',check_site('https://darkwolfcave.de'))
print ('Ergebnis Website2: ',check_site('https://testing.darkwolfcave.de'))

Die markierten Zeilen sind unsere Funktion.
Mit check_site können wir diese sooft aufrufen wie wir wollen. (siehe Zeile 24 und 25).
Wir übergeben also jedesmal nur unsere URL zu der Funktion anstelle den gesamten Code erneut schreiben zu müssen.

Wie erstellt man Python Funktionen?

Python Funktionen definiert man immer mit ‚def‘ und dem Namen sowie evtl. erwartete Parameter und einem abschließendem Doppelpunkt ( : ).
Danach MUSS der weitere Code, der zu dieser Funktion gehört, eingerückt werden. Ansonsten erkennt Python diesen nicht mehr als Teil der Funktion.

def check_site(url):
def NAME(PARAMETER):

#!/usr/bin/python3
# -*- coding: utf-8 -*-

def meine_funktion():
        print ('Du siehst mich nur, wenn die Funktion aufgerufen wird')
print ('Mich siehst du immer...')
meine_funktion()

In diesem Beispiel sieht man recht deutlich warum das Einrücken wichtig ist.
Setze mal ein # in die Zeile mit ‚meine_funktion()‘ und führe das Script erneut aus. Jetzt siehst du, dass der letzte Print Befehl weiterhin ausgeführt wird, alles innerhalb der Funktion aber nicht mehr.

Werte zurückgeben / return / print

return url, rstat, r.status_code

Ein kurzer Ausflug zur Erklärung was in einer Funktion so passiert, bzw. wie Variablen behandelt werden.
Wenn du eine Funktion aufrufst, dann werden alle Variablen in dieser Funktion auch NUR für diese zur Verfügung stehen – sprich sie sind lokal definiert.
Der aufrufende Prozess kann somit nicht auf die Inhalte zugreifen. Oder einfach: Was in der Funktion passiert, bleibt auch in der Funktion.
Ein kleines Beispiel:

#!/usr/bin/python3
# -*- coding: utf-8 -*-
variable = 'Brauchen wir, sonst gibt es unten eine Fehlermeldung'

def meine_funktion():
        print ('Du siehst mich nur, wenn die Funktion aufgerufen wird')
        variable = 'Mich wirst du nie lesen...'

print ('Mich siehst du immer...')
meine_funktion()
print (variable)

Führe das Script einmal aus, und du erkennst, dass der Inhalt der ‚variable‘ innerhalb der Funktion nicht ausgegeben wird.
Wenn wir die erste Zuweisung in Zeile 3 nicht durchführen würden, dann gäbe es beim Aufruf des Scripts eine Fehlermeldung das ‚variable‘ nicht definiert sei (in Zeile 11)

Wie kommen wir nun an den Inhalt der ‚variable‘ aus der Funktion?
Da gibt es auch mehrere Wege… einen davon erwähne ich jetzt kurz, aber vergiss diesen am besten wieder.

1. Möglichkeit: Wir setzen eine Variable innerhalb von Python Funktionen auf ‚global‘

variable = 'Brauchen wir, sonst gibt es unten eine Fehlermeldung'

def meine_funktion():
        print ('Du siehst mich nur, wenn die Funktion aufgerufen wird')
        global variable
        variable = 'Mich wirst du nie lesen…'
print ('Mich siehst du immer...')
meine_funktion()
print (variable)

Wenn du nach diesen Änderungen das Script startest, erhältst du den Wert aus der ‚variable‘ innerhalb der Funktion. Dafür wird der Inhalt der bereits definierten ‚variable‘ (variable = ‚Brauchen wir, sonst gibt es unten eine Fehlermeldung‘) überschrieben.
Das hört sich zwar praktisch an, aber eine Variable als global zu verwenden ist selten der richtige Weg. Du kannst dir, gerade bei komplexeren Code, sehr viele Fehler und Stolpersteine so einbauen.
Daher nutze dies lieber erst gar nicht oder nur in ganz bestimmten Fällen.

2. Möglichkeit: Der ‚print‘ Befehl

variable = 'Brauchen wir, sonst gibt es unten eine Fehlermeldung'

def meine_funktion():
        print ('Du siehst mich nur, wenn die Funktion aufgerufen wird')
        variable = 'Mich wirst du nie lesen…'
        print(variable)
print ('Mich siehst du immer...')
meine_funktion()
print (variable)

Hiermit wird direkt in der Funktion der Inhalt der lokalen Variable ausgegeben. Beim ausführen des Scripts erhältst du somit diesen Wert und den Wert der bereits zuvor deklarierten ‚variable‘ außerhalb der Funktion.
Diese Variante kannst du nutzen, wenn deine Funktion nur etwas auf dem Bildschirm ausgeben soll.
Problematisch wird es aber, wenn du mit einem ermittelten Wert in deinem Script weiterarbeiten willst.
Da hilft dir aber die nächste Möglichkeit weiter

3. Möglichkeit: Der ‚return‘ Befehl

variable = 'Brauchen wir, sonst gibt es unten eine Fehlermeldung'

def meine_funktion():
        print ('Du siehst mich nur, wenn die Funktion aufgerufen wird')
        variable = 'Mich wirst du nie lesen...'
        return variable
print ('Mich siehst du immer...')
print (meine_funktion())
print (variable)

Mit ‚return variable‘ geben wir dem aufrufenden Prozess einen ermittelten Wert zurück. Willst du keinen Wert zurückgeben, weil bei einer bestimmten Konstellation innerhalb der Funktion kein Wert zurückgegeben werden darf, dann kannst du dies mit ‚return none‘ erreichen.
Außerhalb der Funktion kannst du jetzt, wie im Beispiel zu sehen ist, den Wert aus der Funktion mit ‚print (meine_funktion())‘ anzeigen lassen.
Weiterhin könntest du diesen Wert auch wieder in eine Variable setzen und mit dieser weiter arbeiten: neue_variable = meine_funktion()

Weitere Python Grundlagen Themen