DNB_Titelanalyse_MARC_Tutorial_Teil1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DNBLab Jupyter Notebook Tutorial "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Titelanalyse, TOC-Volltextsuche und Ergebnisvisualisierung"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dieses DNBLab Tutorial besteht aus mehreren Teilen und dient als Einführung in die Titelanalyse sowie die Volltextsuche mit Python. Die Titelsuchen werden dabei anhand bibliothekarischer Metadaten durchgeführt, die im Format MARC21-XML vorliegen. Diese können bspw. in Form verschiedener Datensets im [DNBLab](https://www.dnb.de/dnblab) oder als Gesamtabzüge unter https://www.dnb.de/gesamtabzuege heruntergeladen und genutzt werden. Die Volltextsuchen werden anschließend anhand digitalisierter Inhaltsverzeichnisse (kurz TOC für \"table of content\") bearbeitet. Im letzten Teil des Tutorials werden die Ergebnisse dieser Analysen visualisiert.     \n",
    "\n",
    "Das Tutorial wird exemplarisch anhand eines Szenarios durchgeführt, in dem wir uns für Hochschulschriften zum Thema \"Reform\" interessieren, die in der Sachgruppe \"Wirtschaft\" publiziert wurden. Ausgangsbasis für die Analyse ist das auf der DNBLab-Seite verfügbare Set \"Freie Online-Hochschulschriften\". Da die Datei allerdings sehr groß ist, wurde für dieses Tutorial ein spezielles Datenset erstellt, welches sich direkt auf die bibliographischen Einträge der freien Online-Hochschulschriften beschränkt, die sich in der Sachgruppe \"330 Wirtschaft\" befinden und im Zeitraum zwischen den Jahren 2000 und 2010 erschienen sind.   \n",
    "\n",
    "\n",
    "\n",
    "**Inhaltsverzeichnis:** \n",
    "\n",
    "* [Einrichten der Arbeitsumgebung](#Teil1) \n",
    "* [Tutorial 1 - Titelanalyse - Teil 1](#Teil2)\n",
    "* [Tutorial 2 - Titelanalyse - Teil 2 (Daten in ein Dataframe überführen)](DNB_Titelanalyse_MARC_Tutorial_Teil2.ipynb)\n",
    "* [Tutorial 2 - OC-Volltextsuche]  - in Arbeit\n",
    "* [Tutorial 3 - Ergebnisvisualisierung]  - in Arbeit\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Einrichten der Arbeitsumgebung - Let's get started  <a class=\"anchor\" id=\"Teil1\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Um die Arbeitsumgebung für die folgenden Schritte passend einzurichten, sollten zunächst die benötigten Python-Biblitoheken importiert werden. Wir laden dazu ElementTree (als ET), um unser MARC21-XML analysieren zu können sowie Pandas (als pd) zur Datenmanipulation und -analyse.:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Laden benötigter Python-Bibliotheken\n",
    "import xml.etree.ElementTree as ET\n",
    "import pandas as pd\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Im nächsten Schritt laden wir die MARC21-XML-Datei, die wir im folgenden analysieren wollen, in ElementTree und suchen zunächst nach dem Rootverzeichnis. Da uns außerdem interessiert, wieviele verschiedenene Einträge sich überhaupt in der XML-Datei befinden, lassen wir uns dies anzeigen:    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gesamtzahl bibliographischer Einträge:  2828\n"
     ]
    }
   ],
   "source": [
    "tree = ET.parse('data/dataset_tutorial_eco.xml')  # Laden der MARC-Datei in ElementTree \n",
    "root = tree.getroot()                           # Laden des Root-Verzeichnisses des XML\n",
    "\n",
    "records = list(root)\n",
    "total_records = len(records)  \n",
    "\n",
    "#Ausgabe der Gesamtzahl der in der Datei vorhandenen Records:\n",
    "print(\"Gesamtzahl bibliographischer Einträge: \",total_records)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wir wissen nun also, wieviele Titeleinträge sich insgesamt in der Datei befinden und haben schon einmal alles für die weitere Analyse vorbereitet. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Ausgabe von Titeln, die ein bestimmtes Suchwort enthalten: "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die für unsere Fragestellung interessanten Daten befinden sich in der XML-Datei als Inhalt zwischen bestimmten Tags. Wir brauchen also zunächst eine Möglichkeit, diesen Inhalt in Textform aus dem XML zu \"holen\". \n",
    "\n",
    "Da wir zwar nur in den Titeltexten nach unserem Schlüsselwort suchen wollen, als Ergebnis aber möglichst nicht nur den Titel selbst, sondern auch Angaben wir Autor, Publikationsdatum, ISBN etc. wünschen, schreiben wir uns eine allgemeine Funktion für unser XML, um an den Inhalt der unterschiedlichen Felder gelangen zu können. \n",
    "\n",
    "\n",
    "Zur Erinnerung: Unser XML ist folgendermaßen aufgabaut: \n",
    "```\n",
    "<?xml version=\"1.0\" encoding=\"UTF-8\"?><collection xmlns=\"http://www.loc.gov/MARC21/slim\">\n",
    "    <record type=\"Bibliographic\">\n",
    "        <leader> ... </leader>\n",
    "        <controlfield> ... </controlfield>\n",
    "        ...\n",
    "        <controlfield> ... </controlfield>\n",
    "        <datafield tag=\"123\" ... >\n",
    "            <subfield code=\"x\"> ... </subfield>\n",
    "            ...\n",
    "            <subfield code=\"x\"> ... </subfield>\n",
    "        </datafield>\n",
    "        <datafield tag=\"456\" ...> \n",
    "        .... \n",
    "```         \n",
    "Für die Lokalisierung der gewünschen Informationen müssen wir nun natürlich wissen, in welchen Feldern sich welche Informationen befinden -> dies kann bei Bedarf in der MARC-Dokumentation (LINK LINK LINK) nachgeschaut werden. \n",
    "\n",
    "Anhand der tag-Information innerhalb der Datafield-tags wird also das entsprechende Feld identifiziert: Das &lt;datafield&gt; mit dem tag=\"245\" steht dabei für den Titeleintrag, im Unterfeld \"a\" steht dabei der Haupttitel, in ```b``` der Untitel, sofern vorhanden und im Unterfeld \"c\" wird der oder die für die Publikation Verantwortliche angegeben - dabei kann es sich sowohl um eine Person als auch eine Körperschaft handeln. \n",
    "    \n",
    "Die für uns relevanten Informationen befinden sich also zumeist zwischen bestimmten &lt;subfields&gt;-Tags, die ihrerseits wiederrum anhand der \"tag\"-Information innerhalb des jeweils übergeordneten &lt;datafield&gt;-Tags identifiziert werden können. In unserem Fall wäre dies beispielhaft für den Haupttitel das &lt;datafield&gt; mit dem tag 245, innerhalb dessen wir den Haupttitel im &lt;subfields&gt; mit dem code \"a\" finden.\n",
    "    \n",
    "Wir schreiben uns deshalb eine Funktion, die uns den Inhalt aus den entsprechenden &lt;subfields&gt; holt und nennen sie entsprechend \"get_subfield_text\". Die Funktion wird mehrere Parameter brauchen, um die unterschiedlichen Felder anzusprechen. Da wir diese allgemein halten wollen, nennen wir die Variablen, die später die jeweiligen Parameter übergeben bekommen, \"element\", \"tag\" und \"subfield\":    \n",
    "          "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_subfield_text(element, tag, subfield):\n",
    "    if element.attrib['tag'] == tag:\n",
    "            for subelement in element:\n",
    "                if subelement.attrib['code'] == subfield:\n",
    "                    return subelement.text\n",
    "    return None\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Diese Funktion bekommt später als \"element\" eine passende XML-node übergeben. Als \"tag\" wollen wir das jeweiilige MARC-Tag übergeben, welches spezifieren wird, wonach wir genau suchen: Um nach einem Titel zu suchen, wollen wir also bspw. alle Datafield-Tags nach dem \"tag\" \"245\" durchsuchen. Wenn wir dagegen nach Autoren suchen wollen, ändern wir die Variable \"tag\" entsprechend auf \"100\" usw. Die Variable \"subfield\" steht, wie der Name sagt, für das jeweilige Subfield, in dem sich die Information befindet: Für unser Titelbeispiel also das Subfield \"a\" - würden wir hier nur den Untertitel extrahieren wollen, würden wir dagegen im Subfield \"b\" suchen. \n",
    "\n",
    "Mit dieser Funktion haben wir also die Möglichkeit, je nach Bedarf den Text aus den unterschiedlichen Subfields ausgeben zu lassen. :) \n",
    "\n",
    "\n",
    "Im weiteren Verlauf legen wir nun ein Keyword fest, nachdem wir suchen möchten. Danach schreiben wir eine Schleife, die durch alle entsprechenden XML-nodes läuft und dabei unsere Funktion aufruft und den Titeltext übergibt. Daraufhin fragen wir, ob unser Keyword im Titeltext enthalten ist. Wenn dies der Fall ist, schreiben wir den Titel in eine Liste namens \"Titelsammlung\", die wir zuvor definiert haben und erweitern diese Liste, wenn ein weiterer Treffer gefunden wird: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "keyword = \"Reform\"      # Hier legen wir unser Suchwort fest - dieses kann natürlich geändert werden\n",
    "titelsammlung = []      # Definition unser Listenvarialbe für die Titelsammlung \n",
    "\n",
    "\n",
    "for record in records:  \n",
    "        \n",
    "    for child in record.findall('{http://www.loc.gov/MARC21/slim}datafield'):             \n",
    "        title = get_subfield_text(child, \"245\", \"a\") # Aufruf der oben geschriebenen Funktion, Übergabe der Parameter\n",
    "        if title:\n",
    "            if keyword in title:\n",
    "                titelsammlung.append(title)\n",
    "                \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Um zu sehen, welche Titel unser Code nun gefunden hat, gibt es verschiedene Möglichkeiten: Die einfachste ist sicherlich, einfach unsere Liste über den print-Befehl anzeigen zu lassen: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['\\x98Die\\x9c Armutsfestigkeit des deutschen Vorsorgesystems unter besonderer Berücksichtigung möglicher Reformierungsvorschläge der gesetzlichen Rentenversicherung', 'Institutionen und Reformen', 'Haushaltskonsolidierungen und Reformprozesse', 'Reforms and foreign direct investment', '\\x98Die\\x9c Gewerkschaftskrise und der Reformprozess des Gewerkschaftssystems in Südkorea', 'Reformaufgaben im Rahmen einer Neuordnung der Finanzierung des öffentlichen Personennahverkehrs (ÖPNV)', 'Indiens wirtschaftspolitische Reformen nach 1991: eine Fallstudie des Stromsektors', 'Ärztenetzwerke als Reformansatz für den ambulanten Sektor', 'Vergleichende Analyse der Reformen im Bereich der Alterssicherung in Westeuropa und in Mittel- und Osteuropa', 'Zur Reform des Internationalen Währungsfonds (IWF)', 'Indiens wirtschaftspolitische Reformen nach 1991', '\\x98Die\\x9c Reform der EU-Strukturfonds von 1999', 'Reform der gemeinsamen Agrarpolitik und EU-Integration Polens']\n"
     ]
    }
   ],
   "source": [
    "print(titelsammlung)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternativ können wir aber bspw. auch ein Dataframe erstellen lassen: Diese Option bietet uns die Programmbibliothek \"Pandas\" für Python, die wir beim Einrichten unserer Arbeitsumgebung bereits importiert haben - \"Pandas\" selbst steht dabei für die \"Python Data Analysis Library\". Ein Pandas-Dataframe kann man sich am besten wie eine Tabelle bzw. einfache Datenbank vorstellen. \n",
    "\n",
    "Wir erstellen dazu nun exemplarisch ein Set, welches wir \"result\" nennen. Da wir bislang nur mit einer Ausgabe-Variable arbeiten, wäre dies noch nicht zwingend nötig, wird aber im Anschluss sinnvoll sein. In ein Set können Objekte beliebigen Datentyps  gespeichert werden. Dieses Set überführen wir im Anschluss in ein Dataframe und lassen uns zuletzt mit dem Befehl \"df.head()\" die ersten 5 Zeilen des Dataframe anzeigen: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>title</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Die Armutsfestigkeit des deutschen Vorsorges...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Institutionen und Reformen</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Haushaltskonsolidierungen und Reformprozesse</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Reforms and foreign direct investment</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Die Gewerkschaftskrise und der Reformprozess...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                               title\n",
       "0  Die Armutsfestigkeit des deutschen Vorsorges...\n",
       "1                         Institutionen und Reformen\n",
       "2       Haushaltskonsolidierungen und Reformprozesse\n",
       "3              Reforms and foreign direct investment\n",
       "4  Die Gewerkschaftskrise und der Reformprozess..."
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = {'title' : titelsammlung}\n",
    "df = pd.DataFrame(result)\n",
    "\n",
    "#Gibt die ersten 5 Zeilen des Dataframes aus (zur Kontrolle):\n",
    "df.head() \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternativ können wir uns auch die letzten 5 Zeilen anzeigen lassen oder das Dataframe komplett als CSV exportieren. Um den Export vorzunehmen, sollte im folgenden Code-Snippet allerdings der Befehl df.tail() \"auskommentiert\" werden (also einfach eine # davorsetzen, so dass der Code als Kommentar behandelt und nicht ausgeführt wird). Im Gegenzug muss die # vor der letzten Zeile \"df.to_csv\" natürlich entfernt werden:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>title</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>Vergleichende Analyse der Reformen im Bereich ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>Zur Reform des Internationalen Währungsfonds ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>Indiens wirtschaftspolitische Reformen nach 1991</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>Die Reform der EU-Strukturfonds von 1999</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>Reform der gemeinsamen Agrarpolitik und EU-Int...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                title\n",
       "8   Vergleichende Analyse der Reformen im Bereich ...\n",
       "9   Zur Reform des Internationalen Währungsfonds ...\n",
       "10   Indiens wirtschaftspolitische Reformen nach 1991\n",
       "11         Die Reform der EU-Strukturfonds von 1999\n",
       "12  Reform der gemeinsamen Agrarpolitik und EU-Int..."
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.tail() # Zeigt die letzten 5 Zeilen des Dataframes an\n",
    "\n",
    "#Exportieren des gesamten Dataframe als CSV-Datei: \n",
    "#df.to_csv(\"Titeltest.csv\", index=False) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Auf diese Art können wir also innerhalb einer MARC21-XML Datei nach einem von uns gewählten Schlüsselwort in den Titelangaben suchen. Außerdem können wir den Code anpassen, um nach anderen Begriffen oder Namen in beliebigen MARC-Feldern im XML zu suchen. Die Ergebnisse können wir uns im Anschluss anzeigen lassen oder, nach Belieben, in eine Variable speichern und als Datei ausgeben lassen. \n",
    "\n",
    "Da unser Ziel allerdings eine Ausgabe mehrerer bibliographischer Angaben zu einem Titel ist, der nicht nur ein bestimmtes Suchwort (\"Klimawandel\") beinhaltet, sondern außerdem der Sachgruppe \"Wirtschaft\" zugeordnet wurde, müssen wir im folgenden noch etwas tiefer einsteigen. \n",
    "\n",
    "[Hier geht es mit der Titelanalyse weiter](DNB_Titelanalyse_MARC_Tutorial_Teil2.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}