clean up no code low code und use cases tutorials

src/02_basics/app_market.qmd

@@ -1,10 +0,0 @@
----
-title: "App Marktplatz beobachten"
-listing:
-  - id: app_market
-    contents: "app_market"
-    type: grid
----
-
-::: {#app_market}
-:::

src/02_basics/app_market/google-play-search.qmd

@@ -1,27 +1,27 @@
 ---
 title: "Google-Play-App-Suche"
-description: "Ein Tool zur Suche nach Apps im Google Play Store basierend auf einem Suchbegriff, einschließlich der Anzeige von App-Details und direkten Links."
-author: "Benjamin"
-date: "2024-12-16"
-date-modified: "2024-12-16"
+description: "Dieses Tool durchsucht den Google Play Store nach Apps durchsuchen, basierend auf einem Suchbegriff, und in einer übersichtliche Ergebnisliste darstellen."
 image: _9d81d3d2-f372-476b-beb6-fe6a4841739b.jpeg
 ---
 
-# Google-Play-App-Suche
+## Lernziel
 
-## Beschreibung  
-Dieses Tool durchsucht den Google Play Store nach Apps, basierend auf einem vom Nutzer eingegebenen Suchbegriff, und liefert eine übersichtliche Ergebnisliste.
+* Zu mehreren Themengebieten Listen an Links zu Anwendungen im Google Play Marktplatz erstellen und vergleichen.
 
-## Funktionen  
-- **Suchfunktion**: Eingabe eines Keywords zur Suche nach Apps.  
-- **Details zu Apps**:  
-   - App-Titel  
-   - Entwickler  
-   - Bewertung  
-   - Google Play-Link zur App  
-   - App-Icon  
-- **URL-Ausgabe**: Separates Anzeigen der direkten Google-Play-Links zu den Apps.
+## Anleitung zur Nutzung der Google-Play-App-Suche
 
-## Anwendungsfall  
-Perfekt für Nutzer, die eine schnelle Übersicht über relevante Apps im Google Play Store erhalten möchten.
+### 1. Öffnen der Anwendung
+   - Zur [Google-Play-App-Suche](https://huggingface.co/spaces/datenwerkzeuge/Google-Play-App-Search) auf Hugging Face navigieren.
 
+### 2. Suchbegriff eingeben
+   - Geben Sie einen Suchbegriff in das Eingabefeld **"Search Term"** ein.
+
+### 3. Suche starten
+   - Klicken Sie auf die Schaltfläche **"Search"**, um die Suche zu starten.
+
+### 4. Direkte Links anzeigen
+   - Zusätzlich werden die direkten Google-Play-Links zu den Apps separat angezeigt.
+
+## Fazit
+
+Apps im Google Play Store basierend auf einem Suchbegriff identifizieren und die Ergebnisse in einer übersichtlichen Liste darstellen, ein grundlegendes Vorgehen des Webscrapings und der Datenverarbeitung.

src/02_basics/pdf.qmd

@@ -1,10 +1,15 @@
 ---
 title: "PDFs auswerten"
+description: "Webseiten oder HTML-Dateien nach PDF-Links durchsuchen und basierend auf extrahierten Schlüsselwörtern gruppieren."
 listing:
   - id: pdf
     contents: "pdf"
     type: grid
 ---
 
+## Lernziel
+
+* Anwendung von PDF-Link-Extractor-Tools zur systematischen Sammlung von PDFs und Nutzung der PDF-Keyword-Grouping-App zur thematischen Gruppierung.
+
 ::: {#pdf}
 :::

src/02_basics/pdf/pdf-grouping.qmd

@@ -1,23 +1,32 @@
 ---
 title: "PDF-Keyword-Grouping-App"
 description: "Eine App zur Gruppierung von hochgeladenen PDF-Dateien basierend auf semantischen Themen, einschließlich Keyword-Extraktion und themenbasierter Gruppierung."
-author: "Benjamin"
-date: "2024-12-16"
-date-modified: "2024-12-16"
 image: _5a00e9f5-52f7-4e9b-b22d-499e40257a4b.jpeg
 ---
 
-# PDF-Keyword-Grouping-App
-
-## Beschreibung  
-Die App gruppiert hochgeladene PDF-Dateien basierend auf semantischen Themen. Sie extrahiert relevante Schlüsselwörter aus den PDFs und ordnet sie automatisch den am besten passenden Themen zu.
-
 ## Funktionen  
 - **PDF-Upload**: Mehrere PDFs gleichzeitig hochladen.  
 - **Keyword-Extraktion**: Automatische Extraktion der wichtigsten Schlüsselwörter pro PDF.  
 - **Themenbasierte Gruppierung**: PDFs werden mithilfe von KI-Modellen wie KeyBERT und Sentence Transformers in semantische Gruppen aufgeteilt.  
 - **Download als ZIP**: Die gruppierten PDFs werden in einem ZIP-Archiv zum Download bereitgestellt.  
 
-## Anwendungsfall  
-Geeignet für Nutzer, die eine große Anzahl von PDFs nach inhaltlichen Themen sortieren und effizient organisieren möchten.
+## Anleitung zur Nutzung der PDF-Keyword-Grouping-App
+
+### 1. Öffnen der Anwendung
+   - Gehen Sie zur [PDF-Keyword-Grouping-App](https://huggingface.co/spaces/datenwerkzeuge/PDF-Keyword-Grouping-App) auf Hugging Face.
+
+### 2. PDF-Dateien hochladen
+   - Klicken Sie auf die Schaltfläche **"PDFs hochladen"**.
+   - Wählen Sie die PDF-Dateien aus, die Sie gruppieren möchten. Sie können mehrere PDFs gleichzeitig hochladen.
+
+### 3. Keyword-Extraktion und themenbasierte Gruppierung
+   - Die App extrahiert automatisch die wichtigsten Schlüsselwörter aus den hochgeladenen PDFs.
+   - Die PDFs werden mithilfe von KI-Modellen wie KeyBERT und Sentence Transformers in semantische Gruppen aufgeteilt.
+
+### 4. Gruppierte PDFs herunterladen
+   - Nachdem die PDFs gruppiert wurden, stellt die App die gruppierten PDFs in einem ZIP-Archiv bereit.
+   - Klicken Sie auf die Schaltfläche **"Download als ZIP"**, um das ZIP-Archiv mit den gruppierten PDFs herunterzuladen.
+
+## Fazit
 
+Mit einfachen Mitteln und öffentlichen KI-Modelle wie KeyBERT und Sentence Transformers, kann man PDFs effektiv nach Themen  gruppieren und so die Dokumentenverwaltung zu erleichtern.

src/02_basics/pdf/pdf-link-extractor.qmd

@@ -1,17 +1,9 @@
 ---
 title: "PDF-Link-Extractor"
 description: "Eine Anwendung zur Extraktion und Organisation von PDF-Links von Webseiten oder hochgeladenen HTML-Dateien, einschließlich Download und Komprimierung."
-author: "Benjamin"
-date: "2024-12-16"
-date-modified: "2024-12-16"
 image: _30a8d023-6f69-46e3-8ae1-1d7555d04902.jpeg
 ---
 
-# PDF-Link-Extractor
-
-## Beschreibung  
-Diese Anwendung durchsucht eine angegebene Webseite oder eine hochgeladene HTML-Datei nach PDF-Links. Die gefundenen PDF-Dateien werden anschließend heruntergeladen und in einer ZIP-Datei organisiert bereitgestellt.
-
 ## Funktionen  
 - **Eingabeoptionen**:  
    - URL der Webseite  
@@ -20,6 +12,29 @@ Diese Anwendung durchsucht eine angegebene Webseite oder eine hochgeladene HTML-
 - **Download & Komprimierung**: Herunterladen der PDFs und Bereitstellung in einem ZIP-Archiv.  
 - **Übersicht der gefundenen PDFs**: Anzeige der Dateigrößen und Namen.  
 
-## Anwendungsfall  
-Ideal für Nutzer, die alle PDFs von einer Webseite systematisch sammeln und lokal speichern möchten.
+## Anleitung
+
+### 1. Google-Suche durchführen:
+   - Öffnen Sie Ihren Webbrowser und gehen Sie zu [Google](https://www.google.com).
+   - Geben Sie in die Suchleiste den folgenden Suchbegriff ein, um nach PDF-Dateien zu suchen, die zivilgesellschaftliche Themen behandeln:
+     ```
+     Digitale Gesellschaft filetype:pdf
+     ```
+   - Drücken Sie die Eingabetaste, um die Suche zu starten.
+
+### 2. Suchergebnisse speichern:
+   - Nachdem die Suchergebnisse angezeigt werden, speichern Sie die HTML-Seite der Suchergebnisse.
+   - Klicken Sie mit der rechten Maustaste auf die Seite und wählen Sie "Seite speichern unter..." oder eine ähnliche Option, je nach Browser.
+   - Speichern Sie die HTML-Datei auf Ihrem Computer.
+
+### 3. PDF-Links extrahieren und herunterladen:
+   - Verwenden Sie die Anwendung **PDF-Link-Extractor**, um die gespeicherte HTML-Datei hochzuladen und die PDF-Links zu extrahieren.
+   - Gehen Sie zur Anwendung [PDF-Link-Extractor](https://huggingface.co/spaces/datenwerkzeuge/pdfs-sammeln).
+   - Laden Sie die gespeicherte HTML-Datei hoch.
+   - Die Anwendung durchsucht die HTML-Datei nach PDF-Links, lädt die gefundenen PDFs herunter und stellt sie in einem ZIP-Archiv bereit.
+   - Laden Sie das ZIP-Archiv herunter, um die gesammelten PDF-Dateien zu erhalten.
+
+
+## Fazit
 
+Einfacher Webscrapingprozess mit Suche und Sammlung von PDF-Dateien durch die Extraktion von PDF-Links aus Webseiten oder HTML-Dateien, gefolgt von einem praktischen Download und der Bereitstellung in einem komprimierten ZIP-Archiv.

src/02_basics/webspider.qmd

@@ -1,10 +1,15 @@
 ---
 title: "Die erste Webspider"
+description: "Den Webscraping nachvollziehen durch automatisches URL Extrahieren und durchlaufen von verlinkten Webseiten."
 listing:
   - id: webspider
     contents: "webspider"
     type: grid
 ---
 
+## Lernziel
+
+* Einsatz von Tools wie dem Webseiten-URL-Extraktor zur automatischen Extraktion von Links zur Veranschaulichung des Webscraping Prozesses. Verwendung einer einfachen Webspider.
+
 ::: {#webspider}
 :::

src/02_basics/webspider/website-url-extractor.qmd

@@ -1,22 +1,37 @@
 ---
 title: "Webseiten-URL-Extraktor"
 description: "Ein Tool zur Extraktion und Darstellung aller Links von einer angegebenen Webseite, einschließlich Filterung und übersichtlicher Darstellung."
-author: "Benjamin"
-date: "2024-12-16"
-date-modified: "2024-12-16"
 image: _1fca0884-d58a-4271-b90f-90afcb2c4be9.jpeg
 ---
 
-# Webseiten-URL-Extraktor
-
-## Beschreibung  
-Dieses Tool extrahiert alle Links von einer angegebenen Webseite und stellt sie übersichtlich dar.
-
 ## Funktionen  
 - **Webseitenanalyse**: Automatische Extraktion aller URLs von einer Webseite.  
 - **Filterung**: Nur vollständige Links (z. B. beginnend mit `http`) werden angezeigt.  
 - **Einfaches Interface**: Eingabefeld für die URL und eine klare Liste der extrahierten Links.
 
-## Anwendungsfall  
-Ideal für Nutzer, die schnell alle Links einer Webseite analysieren oder weiterverarbeiten möchten.
+## Anleitung
+
+### 1. Öffnen der Anwendung
+   - Zur [Webseiten-URL-Extraktor-App](https://huggingface.co/spaces/datenwerkzeuge/Webseiten-URL-Extraktor) auf Hugging Face navigieren.
+
+### 2. Eingabemethode wählen
+   - Eingabemethode auswählen: **URL** oder **HTML-Datei hochladen**.
+
+### 3. URLs extrahieren
+
+#### URL-Eingabemethode:
+   - URL der Webseite in das Eingabefeld eingeben (z. B. `https://example.com`).
+   - Auf die Schaltfläche **"URLs extrahieren"** klicken.
+   - Die App extrahiert alle Links von der angegebenen Webseite und zeigt sie an. Nur vollständige Links, die mit `http` beginnen, werden angezeigt.
+
+#### HTML-Datei hochladen:
+   - HTML-Datei hochladen, indem auf **"HTML-Datei hochladen"** geklickt und die Datei ausgewählt wird.
+   - Auf die Schaltfläche **"URLs extrahieren"** klicken.
+   - Die App extrahiert alle Links aus der hochgeladenen HTML-Datei und zeigt sie an. Nur vollständige Links, die mit `http` beginnen, werden angezeigt.
+
+### 4. Ergebnisse anzeigen
+   - Die extrahierten URLs werden in einer übersichtlichen Liste angezeigt. Die Links können direkt angeklickt werden, um sie zu öffnen.
+
+## Fazit
 
+Das Webseiten-URL-Extraktor-Tool bietet verdeutlicht das Filtern von Links auf Webseiten oder aus HTML-Dateien, indem es nur vollständige URLs darstellt.

src/02_basics/webspider/webspider.qmd

@@ -1,15 +1,11 @@
 ---
 title: "Webspider"
 description: "Eine private Webanwendung zur Extraktion strukturierter Daten von Webseiten mithilfe von Streamlit und Scrapy, einschließlich benutzerdefinierter Scraping-Parameter und Datenexport."
-author: "Benjamin"
-date: "2024-12-16"
-date-modified: "2024-12-16"
 image: _24e522b8-a6d0-4212-a02e-7738b3098105.jpeg
 ---
 
-**Spaces / Webspider** ist eine private Webanwendung, die mithilfe von **Streamlit** und **Scrapy** entwickelt wurde, um strukturierte Daten von Webseiten zu extrahieren. Sie bietet eine benutzerfreundliche Oberfläche, um Webseiten zu durchsuchen und die Ergebnisse in einem leicht zugänglichen Format herunterzuladen.
+## Anleitung
 
-#### Hauptfunktionen:
 1. **Benutzerdefinierte Scraping-Parameter**:
    - Einstellung der maximalen **Tiefe** für die Navigation durch Seiten (Depth Limit).
    - Festlegen der **Seitenanzahl**, die maximal durchsucht werden soll (Page Count Limit).
@@ -28,14 +24,11 @@ image: _24e522b8-a6d0-4212-a02e-7738b3098105.jpeg
    - Der integrierte Spider navigiert durch die Webseiten, extrahiert Inhalte und folgt internen Links innerhalb derselben Domain.
    - Enthält eine Funktion zur Bereinigung von Text (Entfernung von HTML-Tags, Skripten und Stilen).
 
-#### Technische Highlights:
-- **Streamlit** wird für die interaktive Benutzeroberfläche genutzt.
-- **Scrapy** führt die eigentliche Datenextraktion durch.
-- Dynamische Anpassung von Scraping-Parametern wie Tiefe und Seitenanzahl.
-- Fortschrittsprotokollierung über lokale Logdateien.
-- Ergebnisanzeige mit der Option, die gesammelten Daten direkt herunterzuladen.
-
 **Einsatzmöglichkeiten**:
 Die Anwendung eignet sich für die Datenerfassung aus öffentlich zugänglichen Webseiten, sei es zur Inhaltsanalyse, Datenaggregation oder weiteren Recherchezwecken. 
 
-**Hinweis**: Sie sollte verantwortungsvoll und im Einklang mit den geltenden Nutzungsbedingungen der Zielseiten verwendet werden.
+**Hinweis**: Sie sollte verantwortungsvoll und im Einklang mit den geltenden Nutzungsbedingungen der Zielseiten verwendet werden.
+
+## Fazit
+
+Die Webspider-Anwendung bietet eine praktische Einführung in die Welt des Webscrapings, indem sie Nutzern die Möglichkeit gibt, Daten von Webseiten zu extrahieren, zu analysieren und zu exportieren. Sie vermittelt wesentliche Kenntnisse in der Handhabung von Scraping-Parametern.

src/03_low_code/app_market_scraping.qmd

@@ -1,12 +0,0 @@
----
-title: "App Marktplatz analysieren"
-description: "Informationen zu zahlreichen Apps abrufen und auswerten."
-listing:
-  - id: app_market_scraping
-    contents: "app_market_scraping"
-    type: grid
----
-
-::: {#app_market_scraping}
-:::
-

src/03_low_code/app_market_scraping/app_market_scraping.qmd

@@ -1,10 +1,85 @@
 ---
 title: "App-Market-Scraping"
 description: "Ein Tool zur Extraktion und Analyse von App-Marktdaten, einschließlich benutzerdefinierter Suchparameter und Datenexport."
-author: "Benjamin"
-date: "2024-12-16"
-date-modified: "2024-12-16"
 image: _2f0cb788-71a6-4817-ab94-d38c346e4f6f.jpeg
 ---
 
-# App Market Scraping
+## Lernziele
+
+- Installation des Google Play Scrapers
+- Einlesen einer CSV-Datei mit App-URLs
+- Abrufen von App-Informationen über einen Loop
+- Visualisierung der abgerufenen Daten
+
+## App Market Scraping
+
+### 1. Installation des Google Play Scrapers
+
+Um den Google Play Scraper zu installieren, den folgenden Befehl verwenden:
+
+```python
+!pip install google-play-scraper
+```
+
+### 2. Einlesen einer CSV-Datei mit App-URLs
+
+Eine CSV-Datei (`app_urls.csv`) erstellen, die eine Spalte url enthält, welche die URLs der Google Play Store Apps auflistet. Beispiel:
+
+```python
+url
+https://play.google.com/store/apps/details?id=com.example.app1
+https://play.google.com/store/apps/details?id=com.example.app2
+```
+
+Die CSV-Datei in ein Pandas DataFrame einlesen:
+
+```python
+import pandas as pd
+
+# CSV-Datei einlesen
+df = pd.read_csv('app_urls.csv')
+```
+
+### 3. Abrufen von App-Informationen über einen Loop
+
+Den Google Play Scraper verwenden, um Informationen über die Apps abzurufen:
+
+```python
+from google_play_scraper import app
+
+# Funktion zum Extrahieren der App-ID aus der URL
+def extract_app_id(url):
+    return url.split('id=')[-1]
+
+# Liste zum Speichern der App-Informationen
+app_info_list = []
+
+# Loop über die URLs in der CSV-Datei
+for url in df['url']:
+    app_id = extract_app_id(url)
+    app_info = app(app_id, lang='en', country='us')
+    app_info_list.append(app_info)
+
+# Erstellen eines DataFrames mit den App-Informationen
+app_info_df = pd.DataFrame(app_info_list)
+```
+
+### 4. Visualisierung der abgerufenen Daten
+
+Die abgerufenen Daten visualisieren, z. B. die Bewertungen der Apps:
+
+```python
+import matplotlib.pyplot as plt
+
+# Histogramm der App-Bewertungen
+plt.figure(figsize=(10, 6))
+plt.hist(app_info_df['score'], bins=20, color='skyblue', edgecolor='black')
+plt.title('Verteilung der App-Bewertungen')
+plt.xlabel('Bewertung')
+plt.ylabel('Anzahl der Apps')
+plt.show()
+```
+
+## Fazit
+
+Diese Schritte ermöglichen die Installation des Google Play Scrapers, das Einlesen einer CSV-Datei mit App-URLs, das Abrufen von App-Informationen und die Visualisierung der Daten. 

src/03_low_code/catalogue.qmd

@@ -7,5 +7,9 @@ listing:
     type: grid
 ---
 
+## Lernziele
+
+**Extraktion von Buchdaten von der Website "Books to Scrape" mit Python und BeautifulSoup**: Praktische Übung im Web-Scraping, um das gezielte extrahieren aus Datenstrukturen zu verstehen.
+
 ::: {#catalogue}
 :::

src/03_low_code/catalogue/bookstoscrape.qmd

@@ -1,9 +1,6 @@
 ---
 title: "Web Scraping mit Python: Bücher von Books to Scrape"
 description: "Eine Anleitung zum Scraping von Büchern von der Website Books to Scrape, einschließlich Python-Beispielen und Datenexport."
-author: "Benjamin"
-date: "2024-12-16"
-date-modified: "2024-12-16"
 image: _be1bcdc2-f540-4a95-a27c-775e8f2c1c07.jpeg
 format: 
   html:
@@ -104,9 +101,3 @@ print(books_df.head())
 # Fazit
 
 In diesem Tutorial haben wir gelernt, wie man die Website [Books to Scrape](https://books.toscrape.com/) mit Python und `BeautifulSoup` scrapt. Wir haben die Titel und Preise der Bücher extrahiert und in einem DataFrame gespeichert. Dieses Beispiel kann als Grundlage für komplexere Scraping-Projekte dienen.
-
-# Weiterführende Ressourcen
-
-- [BeautifulSoup-Dokumentation](https://www.crummy.com/software/BeautifulSoup/bs4/doc/)
-- [Requests-Dokumentation](https://docs.python-requests.org/en/latest/)
-- [Pandas-Dokumentation](https://pandas.pydata.org/docs/)

src/03_low_code/catalogue/quotes_scraper.ipynb

@@ -7,9 +7,6 @@
     "---\n",
     "title: \"Web Scraping mit Python: Bücher von Books to Scrape\"\n",
     "description: \"Eine Anleitung zum Scraping von Zitate von der Website Quotes to Scrape, einschließlich Python-Beispielen und Datenexport.\"\n",
-    "author: \"Benjamin\"\n",
-    "date: \"2024-12-16\"\n",
-    "date-modified: \"2024-12-16\"\n",
     "image: _2be49964-b89e-45be-8897-491eaa1aad84.jpeg\n",
     "---"
    ]

src/03_low_code/video_transcripts.qmd

@@ -7,5 +7,9 @@ listing:
     type: grid
 ---
 
+## Lernziele
+
+**Extraktion von YouTube-Transkripten und deren Speicherung als PDF-Dateien**: Lernen, wie man Transkripte von Bildungs- und Informationsvideos extrahiert, um diese Inhalte leichter zugänglich und weiterverwendbar für Bildungsarbeit, Advocacy und Sensibilisierungsmaßnahmen zu machen.
+
 ::: {#video_transcripts}
 :::

src/03_low_code/video_transcripts/get_videos_for_youtube_channels.ipynb

@@ -7,13 +7,19 @@
         "---\n",
         "title: \"YouTube-Transkript-Extraktion\"\n",
         "description: \"Ein Tool zur Extraktion und Analyse von YouTube-Transkripten, einschließlich der Speicherung als PDF-Dateien.\"\n",
-        "author: \"Benjamin\"\n",
-        "date: \"2024-12-16\"\n",
-        "date-modified: \"2024-12-16\"\n",
         "image: _1001328a-6814-4c32-9ce2-782aeef96791.jpeg\n",
         "---"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Laden der CSV-Dateien\n",
+        "\n",
+        "In diesem Abschnitt laden wir die CSV-Dateien als Pandas DataFrames."
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 5,
@@ -33,6 +39,15 @@
         "kassenaerztliche_df = pd.read_csv('/content/kassenaerztliche-vereinigung-youtube-channels.csv')\n"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Kombinieren der DataFrames\n",
+        "\n",
+        "In diesem Abschnitt kombinieren wir die beiden DataFrames zu einem einzigen DataFrame."
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 9,
@@ -46,6 +61,14 @@
         "combined_df = pd.concat([aerztekammer_df, kassenaerztliche_df], ignore_index=True)\n"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Funktion zur Video-ID-Ermittlung\n",
+        "In diesem Abschnitt definieren wir eine Funktion, um alle Videos von einem YouTube-Kanal zu erhalten."
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 11,
@@ -89,6 +112,14 @@
         "    return video_ids"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Video-IDs für jeden Kanal abrufen\n",
+        "In diesem Abschnitt rufen wir die Video-IDs für jeden Kanal im kombinierten DataFrame ab.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 13,
@@ -102,6 +133,14 @@
         "combined_df['video_id'] = combined_df['id'].apply(get_video_ids)"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Entfalten der Video-ID-Spalte\n",
+        "In diesem Abschnitt erweitern wir die Video-ID-Spalte, sodass jede Zeile nur eine Video-ID enthält."
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 15,
@@ -115,6 +154,14 @@
         "combined_df = combined_df.explode('video_id')\n"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Extrahieren des Benutzernamens\n",
+        "In diesem Abschnitt extrahieren wir den Benutzernamen aus der URL und fügen ihn als neue Spalte hinzu."
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 17,
@@ -128,6 +175,14 @@
         "combined_df['user_name'] = combined_df['user'].str.split('@').str[1]"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Visualisierung der Videoanzahl\n",
+        "In diesem Abschnitt visualisieren wir die Anzahl der Videos pro Benutzername.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": null,
@@ -163,6 +218,14 @@
         "plt.show()"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Speichern des kombinierten DataFrames\n",
+        "In diesem Abschnitt speichern wir den kombinierten DataFrame als komprimierte CSV-Datei."
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 19,
@@ -175,6 +238,14 @@
         "\n",
         "combined_df.to_csv('combined_df.csv.gz', compression='gzip', index=False)"
       ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Fazit\n",
+        "Dieses Notebook zeigt, wie man YouTube-Kanäle analysiert, indem man Video-IDs extrahiert, die Daten kombiniert und visualisiert, um wertvolle Einblicke in die Videoaktivitäten der Benutzer zu gewinnen."
+      ]
     }
   ],
   "metadata": {

src/03_low_code/video_transcripts/social-media.qmd

@@ -1,19 +1,16 @@
 ---
 title: "Web Scraping von Social-Media-Plattformen"
 description: "Erklärung und Python-Beispiele zum Scraping von Social-Media-Plattformen unter Berücksichtigung rechtlicher, ethischer und technischer Vorgaben."
-author: "Benjamin"
-date: "2024-12-16"
-date-modified: "2024-12-16"
 image: _26268650-a612-4658-b5e2-4cccceb05541.jpeg
 ---
 
-### Web Scraping von Social-Media-Plattformen: Erklärung und Python-Beispiele
+## Web Scraping von Social-Media-Plattformen: Erklärung und Python-Beispiele
 
 Web Scraping ist eine Technik, um Daten automatisiert aus Webseiten zu extrahieren. Beim Scraping von Social-Media-Plattformen wie Facebook, Twitter (jetzt X), Instagram oder LinkedIn müssen strenge rechtliche, ethische und technische Vorgaben eingehalten werden. Diese Regeln schützen sowohl die Plattformen als auch die Nutzer vor Missbrauch, Datenmanipulation und Verletzungen der Privatsphäre.
 
 ---
 
-#### **Wichtige Vorgaben und Einschränkungen**
+## Wichtige Vorgaben und Einschränkungen
 1. **Einhaltung der Nutzungsbedingungen**:
    - Die Nutzungsbedingungen der Plattformen verbieten oft automatisiertes Scraping ohne ausdrückliche Genehmigung.
    - Scraping, das die Plattform oder ihre Nutzer schädigt, ist unzulässig.
@@ -31,7 +28,7 @@ Web Scraping ist eine Technik, um Daten automatisiert aus Webseiten zu extrahier
 
 ---
 
-#### **Gemeinsamkeiten beim Scraping von Social Media**
+## Gemeinsamkeiten beim Scraping von Social Media
 - **Authentifizierung**:
   - Die meisten Plattformen erfordern eine Anmeldung, um auf geschützte Inhalte zuzugreifen.
   - APIs nutzen Authentifizierungsmethoden wie OAuth oder API-Keys.
@@ -47,9 +44,9 @@ Web Scraping ist eine Technik, um Daten automatisiert aus Webseiten zu extrahier
 
 ---
 
-#### **Beispiele für Scraping mit Python**
+## Beispiele für Scraping mit Python
 
-##### 1. **Nutzung der Twitter-API (via `tweepy`)**
+### 1. Nutzung der Twitter-API (via `tweepy`)
 Die API ist die offizielle und empfohlene Methode, um Twitter-Daten abzufragen.
 
 ```python
@@ -78,7 +75,7 @@ for tweet in tweets:
 
 ---
 
-##### 2. **Scraping einer öffentlichen Webseite mit `BeautifulSoup`**
+### 2. Scraping einer öffentlichen Webseite mit `BeautifulSoup`
 Manchmal möchten Entwickler Daten von öffentlich zugänglichen Social-Media-Seiten extrahieren. Dies birgt Risiken, wenn keine Genehmigung vorliegt.
 
 ```python
@@ -103,7 +100,7 @@ print([title.text for title in titles])
 
 ---
 
-##### 3. **LinkedIn API für Profildaten (via `linkedin-api`)**
+### 3. LinkedIn API für Profildaten (via `linkedin-api`)
 LinkedIn stellt eine API für Unternehmenspartner zur Verfügung. Die Nutzung erfordert Zugangsbeschränkungen und Genehmigungen.
 
 ```python
@@ -119,7 +116,7 @@ print(profile)
 
 ---
 
-#### **Zusammenfassung**
+## Zusammenfassung
 Web Scraping von Social-Media-Daten ist technisch möglich, aber nur unter strikter Beachtung der rechtlichen und ethischen Vorgaben vertretbar. Die Nutzung offizieller APIs ist der empfohlene Weg, da sie den Zugriff kontrolliert und im Einklang mit den Plattformrichtlinien erlaubt.
 
 Bevor Scraping-Projekte umgesetzt werden:
@@ -127,4 +124,4 @@ Bevor Scraping-Projekte umgesetzt werden:
 - **Respektiere die Privatsphäre und Rechte der Nutzer.**
 - **Nutze offizielle APIs, wo immer möglich.**
 
-Die Automatisierung ohne Erlaubnis kann rechtliche Konsequenzen haben, daher ist Vorsicht geboten.
+Die Automatisierung ohne Erlaubnis kann rechtliche Konsequenzen haben, daher ist Vorsicht geboten.

src/03_low_code/video_transcripts/youtube-transcript-extraction.ipynb

@@ -7,13 +7,18 @@
     "---\n",
     "title: \"Videos für YouTube-Kanäle abrufen\"\n",
     "description: \"Ein Tool zur Suche und Auflistung von Videos eines YouTube-Kanals basierend auf dem Kanalnamen, einschließlich der Anzeige von Videodetails und direkten Links.\"\n",
-    "author: \"Benjamin\"\n",
-    "date: \"2024-12-16\"\n",
-    "date-modified: \"2024-12-16\"\n",
     "image: _0b1fd4bd-7f49-4655-bb32-462a52df7eba.jpeg\n",
     "---"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Installation der benötigten Pakete\n",
+    "In diesem Abschnitt installieren wir die benötigten Python-Pakete.\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
@@ -32,6 +37,14 @@
     "# ! pip install pytube youtube-transcript-api reportlab -q"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Importieren der Bibliotheken\n",
+    "In diesem Abschnitt importieren wir die notwendigen Bibliotheken für die Transkript-Extraktion und PDF-Erstellung.\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 2,
@@ -55,6 +68,14 @@
     "import zipfile"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Funktion zum Extrahieren des Transkripts\n",
+    "In diesem Abschnitt definieren wir eine Funktion, um Transkripte von YouTube-Videos basierend auf bevorzugten Sprachen zu extrahieren."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 3,
@@ -123,7 +144,23 @@
     "    except NoTranscriptFound:\n",
     "        return \"Es wurden keine Transkripte für dieses Video gefunden.\"\n",
     "    except Exception as e:\n",
-    "        return f\"Allgemeiner Fehler beim Abrufen des Transkripts: {e}\"\n",
+    "        return f\"Allgemeiner Fehler beim Abrufen des Transkripts: {e}\"\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Funktion zum Erstellen eines PDFs\n",
+    "In diesem Abschnitt definieren wir eine Funktion, um das extrahierte Transkript als PDF-Datei zu speichern.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "\n",
     "# Funktion zum Erstellen eines PDFs\n",
     "def save_transcript_as_pdf_with_pagination(title, transcript):\n",
@@ -177,9 +214,17 @@
     "    return filename"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Eingabe der URLs\n",
+    "In diesem Abschnitt geben wir die URLs der YouTube-Videos oder -Playlists ein, deren Transkripte wir extrahieren möchten.\n"
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": null,
    "metadata": {
     "execution": {
      "iopub.execute_input": "2024-12-08T19:32:38.175946Z",
@@ -190,21 +235,7 @@
     },
     "trusted": true
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Verarbeite Video: B7uzC96-930\n",
-      "Transkript für 'B7uzC96-930' gespeichert als B7uzC96-930.pdf.\n",
-      "Verarbeite Video: 4QeKMnd8B7Q\n",
-      "Transkript für '4QeKMnd8B7Q' gespeichert als 4QeKMnd8B7Q.pdf.\n",
-      "Verarbeite Video: 30wxAJ5uyzs\n",
-      "Transkript für '30wxAJ5uyzs' gespeichert als 30wxAJ5uyzs.pdf.\n",
-      "ZIP-Archiv 'transcripts.zip' wurde erstellt.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Eingabe der URLs\n",
     "urls = \"https://www.youtube.com/playlist?list=PLf8HAovJg47MN7bswKf73pffom98Fx8Q8\"\n",
@@ -240,7 +271,23 @@
     "            print(f\"Transkript für '{title}' gespeichert als {pdf_filename}.\")\n",
     "\n",
     "        except Exception as e:\n",
-    "            print(f\"Fehler bei der Verarbeitung von {video_url}: {e}\")\n",
+    "            print(f\"Fehler bei der Verarbeitung von {video_url}: {e}\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Erstellen eines ZIP-Archivs\n",
+    "In diesem Abschnitt erstellen wir ein ZIP-Archiv, das alle generierten PDF-Dateien enthält.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "\n",
     "# Erstellen eines ZIP-Archivs\n",
     "zip_filename = \"transcripts.zip\"\n",
@@ -252,6 +299,14 @@
     "print(f\"ZIP-Archiv '{zip_filename}' wurde erstellt.\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Löschen der ZIP-Datei\n",
+    "In diesem Abschnitt löschen wir die ZIP-Datei, falls sie nicht mehr benötigt wird."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 13,
@@ -269,6 +324,14 @@
    "source": [
     "# os.remove(zip_filename)"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Fazit\n",
+    "In diesem Notebook haben wir gelernt, wie man YouTube-Transkripte extrahiert und als PDF-Dateien speichert. Wir haben die notwendigen Pakete installiert, Funktionen zur Transkript-Extraktion und PDF-Erstellung definiert, und schließlich die Transkripte von YouTube-Videos in einem ZIP-Archiv zusammengefasst. Diese Schritte ermöglichen eine effiziente Analyse und Speicherung von YouTube-Inhalten."
+   ]
   }
  ],
  "metadata": {

src/04_use_case/forum/buergergeld_forum.ipynb

@@ -7,12 +7,30 @@
         "---\n",
         "title: \"Web Scraping von Foren: Bürgergeld Forum\"\n",
         "description: \"Ein Tool zur Extraktion und Analyse von Forenbeiträgen aus dem Bürgergeld Forum, einschließlich der Verarbeitung und Visualisierung der Daten.\"\n",
-        "author: \"Benjamin\"\n",
-        "date: \"2024-12-16\"\n",
-        "date-modified: \"2024-12-16\"\n",
         "---"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Lernziele\n",
+        "\n",
+        "**Web Scraping von Foren**\n",
+        "\n",
+        "* Herunterladen und Speichern von HTML-Seiten eines Forums.\n",
+        "* Extraktion und Analyse von Forenbeiträgen und Metadaten.\n",
+        "* Verarbeitung und Bereinigung der extrahierten Daten mit Pandas."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## HTML-Seiten herunterladen\n",
+        "Dieser Code lädt HTML-Seiten des Bürgergeld Forums herunter und speichert sie in einem Ordner.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 186,
@@ -62,6 +80,14 @@
         "# download_pages(base_url, start_page, end_page, output_directory)"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Daten extrahieren\n",
+        "Dieser Code extrahiert die Texte der Elemente `<li class=\"columnSubject\">`, `<li class=\"columnStats\">` und `<li class=\"columnLastPost\">` aus den HTML-Dateien und speichert sie in einem Pandas DataFrame.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 187,
@@ -527,6 +553,21 @@
         "df"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Daten reinigen"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Spalte 'LastPost' aufteilen\n",
+        "Dieser Code teilt die Spalte `df.LastPost` in `Nutzer_LastPost` und `Datum_LastPost` auf.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 188,
@@ -1006,6 +1047,14 @@
         "df"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Spalte 'Stats' aufteilen\n",
+        "Dieser Code teilt die Spalte `df.Stats` in `Antworten` und `Zugriffe` auf.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 189,
@@ -1519,6 +1568,14 @@
         "df"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Spalte 'Zugriffe' bereinigen\n",
+        "Dieser Code bereinigt die Spalte `df.Zugriffe`, indem nur der Inhalt bis zum ersten Vorkommen von `\\n\\n\\n` behalten wird.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 190,
@@ -1533,6 +1590,14 @@
         "df['Zugriffe'] = df['Zugriffe'].str.split('\\n\\n\\n', n=1).str[0]"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Spalten 'Antworten' und 'Zugriffe' weiter aufteilen\n",
+        "Dieser Code teilt die Spalten `df.Antworten` und `df.Zugriffe` jeweils an der Stelle `\\n` und behält jeweils den zweiten Teil.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 191,
@@ -1550,6 +1615,14 @@
         "df['Zugriffe'] = df['Zugriffe'].str.split('\\n').str[1]"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Spalte 'Subject' aufteilen\n",
+        "Dieser Code teilt die Spalte `df.Subject` am ersten Vorkommen von `\\n` in zwei separate Spalten.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 192,
@@ -1607,6 +1680,14 @@
         "df[['Subject_Part2_2_2_split', 'Subject_Part2_2_2_rest']] = df['Subject_Part2_2_2'].str.split('\\n', n=1, expand=True)"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Unnötige Spalten entfernen\n",
+        "Dieser Code entfernt die Spalten `Stats`, `LastPost`, `Subject_Part2`, `Subject_Part2_2`, `Subject_Part2_2_1`, `Subject` und `Subject_Part2_2_2` aus dem DataFrame `df`.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 196,
@@ -1620,6 +1701,14 @@
         "df = df.drop(columns=['Stats', 'LastPost', 'Subject_Part2', 'Subject_Part2_2', 'Subject_Part2_2_1', 'Subject', 'Subject_Part2_2_2'])"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Spalteninhalte vergleichen\n",
+        "Dieser Code vergleicht die Inhalte der Spalten `Antworten` und `Subject_Part2_1`.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 197,
@@ -1648,6 +1737,14 @@
         "print(f\"Do the 'Antworten' and 'Subject_Part2_1' columns have the same content?: {comparison_result}\")"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Weitere Spalteninhalte vergleichen\n",
+        "Dieser Code vergleicht die Inhalte der Spalten `User_LastPost` und `Subject_Part2_2_2_split` sowie `Date_LastPost` und `Subject_Part2_2_2_rest`.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 198,
@@ -1679,6 +1776,14 @@
         "print(f\"Do the 'Date_LastPost' and 'Subject_Part2_2_2_rest' columns have the same content?: {comparison_result_date}\")"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Spalten umbenennen\n",
+        "Dieser Code benennt die Spalten im DataFrame `df` um.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 199,
@@ -1701,6 +1806,14 @@
         "})"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Spaltenreihenfolge ändern\n",
+        "Dieser Code ändert die Reihenfolge der Spalten im DataFrame `df`.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 200,
@@ -1724,6 +1837,14 @@
         "df = df[final_column_order]"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Spalte 'Zugriffe' formatieren\n",
+        "Dieser Code formatiert die Spalte `df.Zugriffe` als ganze Zahl.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 201,
@@ -1745,6 +1866,14 @@
         "df['Zugriffe'] = pd.to_numeric(df['Zugriffe'], errors='coerce').fillna(0).astype(int)"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Spalten 'Antworten' und 'Antworten2' formatieren\n",
+        "Dieser Code formatiert die Spalten `df.Antworten` und `df.Antworten2` als ganze Zahl.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 202,
@@ -1759,6 +1888,14 @@
         "df['Antworten2'] = pd.to_numeric(df['Antworten2'], errors='coerce').fillna(0).astype(int)"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Jahr aus 'Datum_Letzter_Post' extrahieren\n",
+        "Dieser Code extrahiert Jahreszahlen aus der Spalte `df.Datum_Letzter_Post` und speichert sie in der Spalte `Jahr_Letzter_Post`.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 216,
@@ -1779,6 +1916,14 @@
         "df['Jahr_Letzter_Post'] = pd.to_numeric(df['Jahr_Letzter_Post'], errors='coerce').astype('Int64')"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### DataFrame-Informationen anzeigen\n",
+        "Dieser Code zeigt Informationen über den DataFrame `df` an.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 217,
@@ -1819,6 +1964,14 @@
         "df.info()"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Transponierte Daten anzeigen\n",
+        "Dieser Code zeigt die transponierten Daten des DataFrame `df` an.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 211,
@@ -1929,7 +2082,16 @@
         "id": "TGUIR11zUVW-"
       },
       "source": [
-        "## Analyse"
+        "## Analyse\n",
+        "Dieser Abschnitt enthält die Analyse der Daten.\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Wordcloud der Themen\n",
+        "Dieser Code zeigt die Themen mit den meisten Zugriffen als Wordcloud und entfernt zuvor deutsche Stopwörter.\n"
       ]
     },
     {
@@ -1978,6 +2140,14 @@
         "plt.show()"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Lineplot der Jahreszahlen\n",
+        "Dieser Code zeigt die Spalte `df.Jahr_Letzter_Post` als Lineplot und stellt sicher, dass die x-Achse ganze Jahreszahlen zeigt.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 221,
@@ -2023,6 +2193,14 @@
         "plt.show()"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Themen mit den geringsten Jahreszahlen\n",
+        "Dieser Code zeigt die Themen und die Jahreszahl sowie `Datum_Letzter_Post` für die 10 Zeilen mit den geringsten Werten bei `df.Jahr_Letzter_Post`.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 225,
@@ -2441,6 +2619,14 @@
         "result"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Themen mit den höchsten Jahreszahlen\n",
+        "Dieser Code zeigt die Themen und die Jahreszahl sowie `Datum_Letzter_Post` für die 10 Zeilen mit den höchsten Werten bei `df.Jahr_Letzter_Post`.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 226,
@@ -2865,7 +3051,16 @@
         "id": "FanmCt50UYMD"
       },
       "source": [
-        "## Speichern"
+        "## Speichern\n",
+        "Dieser Abschnitt enthält den Code zum Speichern der Daten.\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Ordner komprimieren\n",
+        "Dieser Code komprimiert den Ordner `/content/buergergeld_forum`."
       ]
     },
     {
@@ -2909,6 +3104,32 @@
         "\n",
         "# compress_directory(directory_to_compress, output_zip_filename)"
       ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Fazit\n",
+        "\n",
+        "In diesem Notebook haben wir die grundlegenden Techniken des Web Scraping anhand des Bürgergeld Forums erlernt und angewendet. Die wichtigsten gelernten Inhalte umfassen:\n",
+        "\n",
+        "1. **HTML-Seiten herunterladen**:\n",
+        "   - Wir haben gelernt, wie man HTML-Seiten eines Forums herunterlädt und in einem Ordner speichert.\n",
+        "\n",
+        "2. **Daten extrahieren**:\n",
+        "   - Wir haben die Texte der relevanten HTML-Elemente extrahiert und in einem Pandas DataFrame gespeichert.\n",
+        "\n",
+        "3. **Daten bereinigen und verarbeiten**:\n",
+        "   - Wir haben die extrahierten Daten bereinigt und in verschiedene Spalten aufgeteilt, um sie besser analysieren zu können.\n",
+        "\n",
+        "4. **Daten analysieren**:\n",
+        "   - Wir haben verschiedene Analysetechniken angewendet, darunter das Erstellen von Wordclouds und Lineplots, um die Daten zu visualisieren und zu interpretieren.\n",
+        "\n",
+        "5. **Daten speichern und komprimieren**:\n",
+        "   - Wir haben gelernt, wie man die verarbeiteten Daten speichert und den Ordner mit den HTML-Dateien komprimiert.\n",
+        "\n",
+        "Diese Schritte haben uns gezeigt, wie man Web Scraping effektiv einsetzen kann, um wertvolle Informationen aus Online-Foren zu extrahieren und zu analysieren."
+      ]
     }
   ],
   "metadata": {

src/04_use_case/jobs/Jobboerse_API.ipynb

@@ -7,13 +7,31 @@
         "---\n",
         "title: \"Jobangebote über die Jobbörse API abrufen\"\n",
         "description: \"Ein Tool zur Suche und Analyse von Jobangeboten über die Jobbörse API, einschließlich der Verarbeitung und Visualisierung der Daten.\"\n",
-        "author: \"Benjamin\"\n",
-        "date: \"2024-12-16\"\n",
-        "date-modified: \"2024-12-16\"\n",
         "image: _f6a36d83-c0f2-4029-a621-0ccfc358b18a.jpeg\n",
         "---"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Lernziele\n",
+        "\n",
+        "**Nutzung der Jobbörse API**\n",
+        "\n",
+        "* Abrufen von Jobangeboten über die Jobbörse API.\n",
+        "* Verarbeitung und Analyse der abgerufenen Daten mit Pandas.\n",
+        "* Visualisierung der Daten und Erstellung von * Häufigkeitsverteilungen."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## API-Anfrage senden\n",
+        "Dieser Code sendet eine Anfrage an die Jobbörse API, um Jobangebote für Erzieher in Berlin abzurufen.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 2,
@@ -58,6 +76,14 @@
         "print(response.status_code)"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## API-Antwort analysieren\n",
+        "Dieser Code analysiert die API-Antwort und gibt die Schlüssel der JSON-Daten aus.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 3,
@@ -84,6 +110,14 @@
         "  print(data.keys())"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Stellenangebote extrahieren\n",
+        "Dieser Code extrahiert die Stellenangebote aus den JSON-Daten.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 4,
@@ -95,6 +129,14 @@
         "stellenangebote = data[\"stellenangebote\"]"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Stellenangebote als DataFrame darstellen\n",
+        "Dieser Code stellt die Stellenangebote als Pandas DataFrame dar.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 5,
@@ -671,6 +713,14 @@
         "df"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Häufigkeitsverteilung der Berufe\n",
+        "Dieser Code berechnet die Häufigkeitsverteilung der Berufe und stellt sie dar.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 6,
@@ -796,6 +846,14 @@
         "beruf_counts\n"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Häufigkeitsverteilung der Arbeitgeber\n",
+        "Dieser Code berechnet die Häufigkeitsverteilung der Arbeitgeber und stellt sie dar.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 7,
@@ -917,6 +975,14 @@
         "arbeitgeber_counts"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Differenz zwischen Termindaten berechnen und visualisieren\n",
+        "Dieser Code berechnet die Differenz zwischen den Termindaten der Spalten `eintrittsdatum` und `aktuelleVeroeffentlichungsdatum` und visualisiert die Differenz als Histogramm.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 8,
@@ -968,6 +1034,14 @@
         "plt.show()"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Postleitzahl extrahieren\n",
+        "Dieser Code extrahiert die Postleitzahl aus der Spalte `arbeitsort`.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 9,
@@ -1104,6 +1178,14 @@
         "df['postleitzahl']"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Häufigkeitsverteilung der Postleitzahlen\n",
+        "Dieser Code erstellt die Häufigkeitsverteilung der Postleitzahlen.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 10,
@@ -1227,6 +1309,14 @@
         "postleitzahl_counts"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## GeoJSON-Datei herunterladen\n",
+        "Dieser Code lädt die GeoJSON-Datei für die deutschen Postleitzahlen herunter.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 11,
@@ -1265,6 +1355,14 @@
         "    print(f\"Failed to download GeoJSON data. Status code: {response.status_code}\")"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## GeoJSON-Daten visualisieren\n",
+        "Dieser Code öffnet die heruntergeladene GeoJSON-Datei und zeigt sie als Grafik mit Matplotlib.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 24,
@@ -1314,6 +1412,14 @@
         "plt.show()"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Postleitzahlen filtern\n",
+        "Dieser Code wählt alle Zeilen aus der GeoJSON-Datei aus, die auch in `df.postleitzahl` enthalten sind.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 29,
@@ -1334,6 +1440,14 @@
         "filtered_gdf = gdf[gdf['plz_code'].isin(df['postleitzahl'])]"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Interaktive Deutschlandkarte erstellen\n",
+        "Dieser Code stellt die Geometrie in `filtered_gdf` auf einer interaktiven Deutschlandkarte dar und markiert die Postleitzahlgebiete anhand ihrer Value Counts auf einer Farbskala."
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 36,
@@ -4498,6 +4612,32 @@
         "# Display the map\n",
         "m"
       ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Fazit\n",
+        "\n",
+        "In diesem Notebook haben wir die grundlegenden Techniken zur Nutzung der Jobbörse API erlernt und angewendet. Die wichtigsten gelernten Inhalte umfassen:\n",
+        "\n",
+        "1. **API-Anfrage senden**:\n",
+        "   - Wir haben gelernt, wie man eine Anfrage an die Jobbörse API sendet, um spezifische Jobangebote abzurufen.\n",
+        "\n",
+        "2. **API-Antwort analysieren**:\n",
+        "   - Wir haben die Struktur der API-Antwort analysiert und die relevanten Daten extrahiert.\n",
+        "\n",
+        "3. **Datenverarbeitung und -visualisierung**:\n",
+        "   - Wir haben die extrahierten Jobangebote in einem Pandas DataFrame dargestellt und verschiedene Analysen durchgeführt, wie die Häufigkeitsverteilung der Berufe und Arbeitgeber.\n",
+        "\n",
+        "4. **Geodaten verarbeiten**:\n",
+        "   - Wir haben Postleitzahlen aus den Jobangeboten extrahiert und die Häufigkeitsverteilung der Postleitzahlen berechnet.\n",
+        "\n",
+        "5. **Interaktive Karten erstellen**:\n",
+        "   - Wir haben gelernt, wie man GeoJSON-Daten herunterlädt und visualisiert, sowie interaktive Karten erstellt, um die geografische Verteilung der Jobangebote darzustellen.\n",
+        "\n",
+        "Diese Schritte haben uns gezeigt, wie man die Jobbörse API effektiv nutzen kann, um wertvolle Informationen über Jobangebote zu extrahieren, zu analysieren und zu visualisieren."
+      ]
     }
   ],
   "metadata": {

src/04_use_case/laws/Gesetze_im_Internet_Aktualitätendienst.ipynb

@@ -7,13 +7,31 @@
         "---\n",
         "title: \"RSS-Feed-Analyse: Gesetze im Internet Aktualitätendienst\"\n",
         "description: \"Ein Tool zur Extraktion und Analyse von RSS-Feeds des Aktualitätendienstes für Gesetze im Internet, einschließlich der Verarbeitung und Visualisierung der Daten.\"\n",
-        "author: \"Benjamin\"\n",
-        "date: \"2024-12-16\"\n",
-        "date-modified: \"2024-12-16\"\n",
         "image: _d38cd4e9-1da8-4d7e-9bae-f01370cd2049.jpeg\n",
         "---"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Lernziele\n",
+        "\n",
+        "**RSS-Feed-Analyse**\n",
+        "\n",
+        "* Abrufen und Parsen von RSS-Feeds mit feedparser.\n",
+        "* Umwandlung der Feed-Daten in ein Pandas DataFrame.\n",
+        "* Analyse und Visualisierung der Feed-Daten."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Bibliothek installieren\n",
+        "Dieser Code installiert die Bibliothek `feedparser`, die für das Parsen von RSS-Feeds verwendet wird.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 36,
@@ -40,6 +58,14 @@
         "# !pip install feedparser\n"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## RSS-Feed lesen\n",
+        "Dieser Code liest den RSS-Feed von der angegebenen URL mit `feedparser` und speichert ihn in einer Variablen.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 37,
@@ -56,6 +82,14 @@
         "feed = feedparser.parse(feed_url)"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Feed in DataFrame umwandeln\n",
+        "Dieser Code wandelt die Feed-Daten in ein Pandas DataFrame um, um sie einfacher analysieren zu können.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 38,
@@ -72,6 +106,14 @@
         "df = pd.DataFrame(feed.entries)"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Ersten Eintrag darstellen\n",
+        "Dieser Code stellt den ersten Eintrag des DataFrames dar, um einen Überblick über die Struktur der Daten zu erhalten.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 39,
@@ -233,6 +275,14 @@
         "df.iloc[0]\n"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Größe des DataFrames anzeigen\n",
+        "Dieser Code zeigt die Größe des DataFrames an, um die Anzahl der Einträge und Spalten zu ermitteln.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 40,
@@ -261,6 +311,14 @@
         "df.shape"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Häufigkeitsverteilung der Spalte 'meta_initiant'\n",
+        "Dieser Code stellt die Häufigkeitsverteilung der Spalte `meta_initiant` dar, um die Verteilung der Initiatoren zu analysieren.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 41,
@@ -462,6 +520,14 @@
         "df['meta_initiant'].value_counts()"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Visualisierung der Spalte 'published'\n",
+        "Dieser Code visualisiert die Verteilung der Veröffentlichungsdaten in der Spalte `published` als Histogramm.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 42,
@@ -505,6 +571,14 @@
         "plt.show()"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Kreisdiagramm der Spalte 'meta_typ'\n",
+        "Dieser Code stellt die Verteilung der verschiedenen Typen in der Spalte `meta_typ` als Kreisdiagramm dar.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 43,
@@ -549,6 +623,14 @@
         "  print(\"Error: 'meta_typ' column not found in the DataFrame.\")"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Titel der Einträge für 'Bundesministerium für Arbeit und Soziales'\n",
+        "Dieser Code filtert die Einträge im DataFrame für den Initiator `Bundesministerium für Arbeit und Soziales` und gibt die Titel der Einträge aus.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 49,
@@ -599,6 +681,14 @@
         "    print(title) # Added indentation and print statement to display each title on a new line"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Titel der Einträge für 'Bundesministerium für Gesundheit'\n",
+        "Dieser Code filtert die Einträge im DataFrame für den Initiator `Bundesministerium für Gesundheit` und gibt die Titel der Einträge aus.\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 51,
@@ -642,6 +732,32 @@
         "for title in filtered_df['title']:\n",
         "    print(title)"
       ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Fazit\n",
+        "\n",
+        "In diesem Notebook haben wir die grundlegenden Techniken zur Analyse von RSS-Feeds anhand des Aktualitätendienstes für Gesetze im Internet erlernt und angewendet. Die wichtigsten gelernten Inhalte umfassen:\n",
+        "\n",
+        "1. **Bibliothek installieren**:\n",
+        "   - Wir haben gelernt, wie man die Bibliothek `feedparser` installiert, um RSS-Feeds zu parsen.\n",
+        "\n",
+        "2. **RSS-Feed lesen**:\n",
+        "   - Wir haben den RSS-Feed von einer URL gelesen und die Daten in einer Variablen gespeichert.\n",
+        "\n",
+        "3. **Feed in DataFrame umwandeln**:\n",
+        "   - Wir haben die Feed-Daten in ein Pandas DataFrame umgewandelt, um sie einfacher analysieren zu können.\n",
+        "\n",
+        "4. **Daten analysieren und visualisieren**:\n",
+        "   - Wir haben verschiedene Analysetechniken angewendet, darunter das Darstellen des ersten Eintrags, das Anzeigen der Größe des DataFrames, die Häufigkeitsverteilung der Spalte `meta_initiant`, die Visualisierung der Veröffentlichungsdaten und die Darstellung der Verteilung der Typen als Kreisdiagramm.\n",
+        "\n",
+        "5. **Daten filtern und ausgeben**:\n",
+        "   - Wir haben die Einträge im DataFrame für bestimmte Initiatoren gefiltert und die Titel der Einträge ausgegeben.\n",
+        "\n",
+        "Diese Schritte haben uns gezeigt, wie man RSS-Feeds effektiv analysieren und visualisieren kann, um wertvolle Informationen zu extrahieren."
+      ]
     }
   ],
   "metadata": {

src/_quarto.yml

@@ -47,19 +47,16 @@ website:
         - href: basics.qmd
           section: "No Code Übersicht"
           contents:
-          - section: "PDF"
+          - section: "PDF📝"
             href: 02_basics/pdf.qmd
             contents:
             - href: 02_basics/pdf/pdf-link-extractor.qmd
-              text: "PDF Link Extractor"
+              text: "PDF Sammler🔍"
             - href: 02_basics/pdf/pdf-grouping.qmd
-              text: "PDF Grouping"
-          - section: "App Marketplace"
-            href: 02_basics/app_market.qmd
-            contents:
-            - href: 02_basics/app_market/google-play-search.qmd
-              text: "Google Play Search"
-          - section: "Webspider"
+              text: "PDFs gruppieren🗂️"
+          - href: 02_basics/app_market/google-play-search.qmd
+            text: "Google Play Search🛒"
+          - section: "Webspider🕸️"
             href: 02_basics/webspider.qmd
             contents:
             - href: 02_basics/webspider/website-url-extractor.qmd
@@ -75,35 +72,31 @@ website:
             href: 03_low_code/catalogue.qmd
             contents:
               - href: 03_low_code/catalogue/bookstoscrape.qmd
-                text: "Bücherliste scrapen"
+                text: "Bücherliste scrapen📚"
               - href: 03_low_code/catalogue/quotes_scraper.ipynb
-                text: "Zitate scrapen"
+                text: "Zitate scrapen💬"
           - href: 03_low_code/app_market_scraping/app_market_scraping.qmd
-            text: "App Markt analysieren"
+            text: "App Markt analysieren📱"
           - section: "Video Transkripte"
             href: 03_low_code/video_transcripts.qmd
             contents:
               - href: 03_low_code/video_transcripts/social-media.qmd
-                text: "Hinweise Scraping Social Media"
+                text: "Hinweise Scraping Social Media⚠️"
               - href: 03_low_code/video_transcripts/get_videos_for_youtube_channels.ipynb
-                text: "YouTube Channel Videos"
+                text: "YouTube Channel Videos🎥"
               - href: 03_low_code/video_transcripts/youtube-transcript-extraction.ipynb
-                text: "YouTube Video Transcripts"
+                text: "YouTube Video Transcripts📝"
     - title: "Use-Case"
       contents:
         - section: "Anwendungsfall Übersicht"
           href: use_case.qmd
           contents: 
           - href: 04_use_case/laws/Gesetze_im_Internet_Aktualitätendienst.ipynb
-            text: "Aktualitätendienst Gesetze"
+            text: "Aktualitätendienst Gesetze📜"
           - href: 04_use_case/jobs/Jobboerse_API.ipynb
-            text: "Jobbörse"
+            text: "Jobbörse💼"
           - href: 04_use_case/forum/buergergeld_forum.ipynb
-            text: "Buergergeld Forum"
-    - title: "Blog"
-      contents:
-        - href: blog.qmd
-          text: "Blog"
+            text: "Buergergeld Forum💬"
 
 format:
   html:

src/basics.qmd

@@ -1,17 +1,32 @@
 ---
 listing:
   - id: no_code
-    contents: ["/02_basics/webspider.qmd","/02_basics/pdf.qmd","/02_basics/app_market.qmd"]
+    contents: ["/02_basics/webspider.qmd","/02_basics/pdf.qmd","/02_basics/app_market"]
     type: grid
 ---
 
-## Lernziele
+"No Code" ermöglicht es auch Nicht-Programmierern, komplexe Aufgaben wie Webscraping durchzuführen, ohne tiefgehende Kenntnisse in Programmiersprachen zu haben. No-Code-Tools sind besonders nützlich für schnelle Prototypenerstellung, Automatisierung von Arbeitsabläufen und die Lösung spezifischer Probleme, ohne dass umfangreiche Entwicklungsressourcen benötigt werden.
 
-**Verwendung von No-Code-Tools für Webscraping**:
-
-* Einsatz von Tools wie dem Webseiten-URL-Extraktor zur automatischen Extraktion von Links zur Veranschaulichung des Webscraping Prozesses. Verwendung einer einfachen Webspider.
-* Anwendung von PDF-Link-Extractor-Tools zur systematischen Sammlung von PDFs und Nutzung der PDF-Keyword-Grouping-App zur thematischen Gruppierung.
-* Identifizierung und Auswertung von Apps eines individuellen Themenbereich (bspw. zivilgesellschaftlich oder Gesundheit).
+## Tutorials
 
 ::: {#no_code}
 :::
+
+## No-Code Scraping
+
+### ParseHub
+
+[ParseHub](https://www.parsehub.com/) ist ein No-Code-Webscraping-Tool, das es Benutzern ermöglicht, Daten von Webseiten zu extrahieren, ohne eine einzige Zeile Code schreiben zu müssen.
+
+- **Visuelle Auswahl**: Klicken Sie auf Elemente auf der Webseite, um sie für das Scraping auszuwählen.
+- **Automatisierung**: Planen Sie Scraping-Aufgaben, um Daten regelmäßig zu extrahieren.
+- **Datenexport**: Exportieren Sie die gesammelten Daten in verschiedenen Formaten wie CSV, Excel und JSON.
+
+### Octoparse
+
+[Octoparse](https://www.octoparse.com/) bietet eine intuitive Drag-and-Drop-Oberfläche, mit der Benutzer Scraping-Workflows erstellen können, ohne eine einzige Zeile Code schreiben zu müssen.
+
+- **Drag-and-Drop-Interface**: Erstellen Sie Scraping-Workflows durch einfaches Ziehen und Ablegen von Elementen.
+- **Cloud-basierte Ausführung**: Führen Sie Scraping-Aufgaben in der Cloud aus, um die Leistung zu maximieren und lokale Ressourcen zu schonen.
+- **Datenexport**: Exportieren Sie die gesammelten Daten in verschiedenen Formaten wie CSV, Excel und JSON.
+- **API-Integration**: Integrieren Sie die gesammelten Daten direkt in Ihre Anwendungen über APIs.

src/low_code.qmd

@@ -1,14 +1,9 @@
 ---
 listing:
   - id: low_code
-    contents: ["03_low_code/catalogue.qmd","03_low_code/app_market_scraping.qmd","03_low_code/video_transcripts.qmd"]
+    contents: ["03_low_code/catalogue.qmd","03_low_code/app_market_scraping/app_market_scraping.qmd","03_low_code/video_transcripts.qmd"]
     type: grid
 ---
 
-## Lernziele
-
-**Extraktion von Buchdaten von der Website "Books to Scrape" mit Python und BeautifulSoup**: Praktische Übung im Web-Scraping, um das gezielte extrahieren aus Datenstrukturen zu verstehen.
-
-**Scraping von App-Marktdaten**: Erstellen einer Übersicht über den App-Marktplatz, um Apps zu identifizieren, die für die Arbeit von Non-Profit-Organisationen und zivilgesellschaftlichen Akteuren nützlich sein können.
-
-**Extraktion von YouTube-Transkripten und deren Speicherung als PDF-Dateien**: Lernen, wie man Transkripte von Bildungs- und Informationsvideos extrahiert, um diese Inhalte leichter zugänglich und weiterverwendbar für Bildungsarbeit, Advocacy und Sensibilisierungsmaßnahmen zu machen.
+::: {low_code}
+:::

src/use_case.qmd

@@ -5,25 +5,5 @@ listing:
     type: grid
 ---
 
-## Lernziele
-
-**Web Scraping von Foren**
-
-* Herunterladen und Speichern von HTML-Seiten eines Forums.
-* Extraktion und Analyse von Forenbeiträgen und Metadaten.
-* Verarbeitung und Bereinigung der extrahierten Daten mit Pandas.
-
-**Nutzung der Jobbörse API**
-
-* Abrufen von Jobangeboten über die Jobbörse API.
-* Verarbeitung und Analyse der abgerufenen Daten mit Pandas.
-* Visualisierung der Daten und Erstellung von * Häufigkeitsverteilungen.
-
-**RSS-Feed-Analyse**
-
-* Abrufen und Parsen von RSS-Feeds mit feedparser.
-* Umwandlung der Feed-Daten in ein Pandas DataFrame.
-* Analyse und Visualisierung der Feed-Daten.
-
 ::: {#use_case}
 :::