Jobangebote über die Jobbörse API abrufen

Ein Tool zur Suche und Analyse von Jobangeboten über die Jobbörse API, einschließlich der Verarbeitung und Visualisierung der Daten.

Lernziele

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.

API-Anfrage senden

Dieser Code sendet eine Anfrage an die Jobbörse API, um Jobangebote für Erzieher in Berlin abzurufen.

import requests

headers = {
    "X-API-Key": "jobboerse-jobsuche",
}

params = {
    "was": "Erzieher",
    "wo": "Berlin",
    "umkreis": "200",
    "page": "1",
    "size": "200",
}

response = requests.get(
    "https://rest.arbeitsagentur.de/jobboerse/jobsuche-service/pc/v4/jobs",
    headers=headers,
    params=params,
    timeout=60,
)

print(response.status_code)

API-Antwort analysieren

Dieser Code analysiert die API-Antwort und gibt die Schlüssel der JSON-Daten aus.

data = response.json()

if isinstance(data, dict):
  print(data.keys())

Stellenangebote extrahieren

Dieser Code extrahiert die Stellenangebote aus den JSON-Daten.

stellenangebote = data["stellenangebote"]

Stellenangebote als DataFrame darstellen

Dieser Code stellt die Stellenangebote als Pandas DataFrame dar.

# prompt: stelle die variable stellenangebot als pandas dataframe dar

import pandas as pd

# Assuming 'stellenangebote' is already defined from the previous code

df = pd.DataFrame(stellenangebote)
df

Häufigkeitsverteilung der Berufe

Dieser Code berechnet die Häufigkeitsverteilung der Berufe und stellt sie dar.

# prompt: Using dataframe df: erstelle eine value counts für die spalte beruf

# Calculate the value counts for the 'beruf' column
beruf_counts = df['beruf'].value_counts()

# Display the value counts
beruf_counts

Häufigkeitsverteilung der Arbeitgeber

Dieser Code berechnet die Häufigkeitsverteilung der Arbeitgeber und stellt sie dar.

# prompt: unter verwendung des dataframe df, erstelle eine häufigkeitenverteilung der spalte arbeitgeber

# Calculate the value counts for the 'arbeitgeber' column
arbeitgeber_counts = df['arbeitgeber'].value_counts()

# Display the value counts
arbeitgeber_counts

Differenz zwischen Termindaten berechnen und visualisieren

Dieser Code berechnet die Differenz zwischen den Termindaten der Spalten eintrittsdatum und aktuelleVeroeffentlichungsdatum und visualisiert die Differenz als Histogramm.

# prompt: berechne die differenz zwischen den termindaten der spalten eintrittsdatum und aktuelleVeroeffentlichungsdatum . beide spalten haben das format wie bpsw 2024-11-29   . beide spalten sind im dataframe df enthalten. bitte visualisiere die differenz als histogramm

import pandas as pd
import matplotlib.pyplot as plt

# Assuming 'df' is already defined and contains columns 'eintrittsdatum' and 'aktuelleVeroeffentlichungsdatum'

# Convert the date columns to datetime objects
df['eintrittsdatum'] = pd.to_datetime(df['eintrittsdatum'], errors='coerce')
df['aktuelleVeroeffentlichungsdatum'] = pd.to_datetime(df['aktuelleVeroeffentlichungsdatum'], errors='coerce')

# Calculate the difference between the dates
df['date_difference'] = (df['eintrittsdatum'] - df['aktuelleVeroeffentlichungsdatum']).dt.days

# Drop rows with NaT values (invalid dates)
df = df.dropna(subset=['date_difference'])

# Create the histogram
plt.figure(figsize=(10, 6))  # Adjust figure size if needed
plt.hist(df['date_difference'], bins=30, edgecolor='black') # Adjust number of bins as needed
plt.xlabel('Difference in Days')
plt.ylabel('Frequency')
plt.title('Distribution of Differences between Eintrittsdatum and aktuelleVeroeffentlichungsdatum')
plt.grid(True)
plt.show()

Postleitzahl extrahieren

Dieser Code extrahiert die Postleitzahl aus der Spalte arbeitsort.

# prompt: bitte extrahiere die postleitzahl aus der spalte df arbeitsort

import re

# Assuming 'df' is already defined and contains the 'arbeitsort' column

def extract_postcode(arbeitsort):
  """Extracts the postcode from the arbeitsort string.

  Args:
    arbeitsort: The string containing the place of work.

  Returns:
    The extracted postcode as a string, or None if no postcode is found.
  """
  if pd.isna(arbeitsort):
      return None
  match = re.search(r'\b\d{5}\b', str(arbeitsort)) # Regular expression to match 5 digits
  if match:
    return match.group(0)
  else:
    return None

df['postleitzahl'] = df['arbeitsort'].apply(extract_postcode)

# Display the DataFrame with the new 'postleitzahl' column
df['postleitzahl']

Häufigkeitsverteilung der Postleitzahlen

Dieser Code erstellt die Häufigkeitsverteilung der Postleitzahlen.

# prompt: erstelle die häufigkeitsverteilung für df.postleitzahl

# Assuming 'df' is already defined and contains the 'postleitzahl' column

# Calculate the frequency distribution of postleitzahl
postleitzahl_counts = df['postleitzahl'].value_counts()

# Display the frequency distribution
postleitzahl_counts

GeoJSON-Datei herunterladen

Dieser Code lädt die GeoJSON-Datei für die deutschen Postleitzahlen herunter.

# prompt: lade die geojson https://public.opendatasoft.com/api/explore/v2.1/catalog/datasets/georef-germany-postleitzahl/exports/geojson?lang=en&timezone=Europe%2FBerlin herunter

import requests

# Download the GeoJSON data
url = "https://public.opendatasoft.com/api/explore/v2.1/catalog/datasets/georef-germany-postleitzahl/exports/geojson?lang=en&timezone=Europe%2FBerlin"
response = requests.get(url)

# Check if the request was successful
if response.status_code == 200:
    # Save the GeoJSON data to a file
    with open("plz_germany.geojson", "w") as f:
        f.write(response.text)
    print("GeoJSON file downloaded successfully!")
else:
    print(f"Failed to download GeoJSON data. Status code: {response.status_code}")

GeoJSON-Daten visualisieren

Dieser Code öffnet die heruntergeladene GeoJSON-Datei und zeigt sie als Grafik mit Matplotlib.

# prompt: öffne die datei /content/plz_germany.geojson und zeige sie als eine grafik mit matplotlib

import json
import matplotlib.pyplot as plt
import geopandas as gpd

# Load the GeoJSON data
try:
    gdf = gpd.read_file("/content/plz_germany.geojson")
except FileNotFoundError:
    print("Error: plz_germany.geojson not found. Please make sure the file exists in the /content directory and the previous code to download it has been executed successfully.")
    exit()

# Plot the GeoJSON data
fig, ax = plt.subplots(1, 1, figsize=(10, 10))
gdf.plot(ax=ax, color="lightgray", edgecolor="black")

# Customize the plot (optional)
ax.set_title("Germany Postleitzahlen")
ax.set_axis_off()  # Turn off axis ticks and labels

# Show the plot
plt.show()

Postleitzahlen filtern

Dieser Code wählt alle Zeilen aus der GeoJSON-Datei aus, die auch in df.postleitzahl enthalten sind.

# prompt: aus der datei /content/plz_germany.geojson wähle alle zeilen aus die auch in df.postleitzahl enthalten sind. die postleitzahlen sind in gdf.plz_code enthalten

# Convert 'plz_code' column to string type to ensure consistent comparison
gdf['plz_code'] = gdf['plz_code'].astype(str)

# Convert 'postleitzahl' column in df to string type as well
df['postleitzahl'] = df['postleitzahl'].astype(str)

# Filter the GeoDataFrame
filtered_gdf = gdf[gdf['plz_code'].isin(df['postleitzahl'])]

Interaktive Deutschlandkarte erstellen

Dieser Code stellt die Geometrie in filtered_gdf auf einer interaktiven Deutschlandkarte dar und markiert die Postleitzahlgebiete anhand ihrer Value Counts auf einer Farbskala.

# prompt: stelle die geometry in filtered_gdf auf einer interaktiven deutschlandkarte dar. auf einer farbskala markiere die postleitzahl gebieten in filtered_gdf anhand ihrer valuecounts. zeige im hintergrund einen ausschnitt der deutschlandkarte auf den sich die postleitzahlen beziehen

import folium
from branca.colormap import linear

# Assuming filtered_gdf is already defined from the previous code

# Create a map centered on Germany
m = folium.Map(location=[51.1657, 10.4515], zoom_start=6)

# Calculate value counts for postleitzahlen in filtered_gdf
plz_counts = filtered_gdf['plz_code'].value_counts()

# Create a colormap based on the value counts
colormap = linear.YlOrRd_09.scale(min(plz_counts), max(plz_counts))

# Add GeoJSON data to the map with color based on value counts
for index, row in filtered_gdf.iterrows():
    plz = row['plz_code']
    count = plz_counts[plz]
    color = colormap(count)
    folium.GeoJson(
        row.geometry,
        style_function=lambda feature, color=color: {
            'fillColor': color,
            'color': 'black',  # Set border color
            'weight': 1,        # Set border width
            'fillOpacity': 0.7,
        },
        tooltip=f"PLZ: {plz}, Anzahl Stellenangebote: {count}"
    ).add_to(m)


# Add a background layer (optional - You can modify or remove this part)
#  Uncomment the following lines to add a tile layer
#  folium.TileLayer('OpenStreetMap').add_to(m)  # Add OpenStreetMap as the base layer
#  folium.LayerControl().add_to(m)


# Display the map
m

Fazit

In diesem Notebook haben wir die grundlegenden Techniken zur Nutzung der Jobbörse API erlernt und angewendet. Die wichtigsten gelernten Inhalte umfassen:

  1. API-Anfrage senden:
    • Wir haben gelernt, wie man eine Anfrage an die Jobbörse API sendet, um spezifische Jobangebote abzurufen.
  2. API-Antwort analysieren:
    • Wir haben die Struktur der API-Antwort analysiert und die relevanten Daten extrahiert.
  3. Datenverarbeitung und -visualisierung:
    • Wir haben die extrahierten Jobangebote in einem Pandas DataFrame dargestellt und verschiedene Analysen durchgeführt, wie die Häufigkeitsverteilung der Berufe und Arbeitgeber.
  4. Geodaten verarbeiten:
    • Wir haben Postleitzahlen aus den Jobangeboten extrahiert und die Häufigkeitsverteilung der Postleitzahlen berechnet.
  5. Interaktive Karten erstellen:
    • Wir haben gelernt, wie man GeoJSON-Daten herunterlädt und visualisiert, sowie interaktive Karten erstellt, um die geografische Verteilung der Jobangebote darzustellen.

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.