{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e16c6f29",
   "metadata": {},
   "source": [
    "# Indizierung und Slicing\n",
    "\n",
    "Indizierung ist die Auswahl einer Teilmenge eurer Daten oder einzelner Elemente. In eindimensionalen Arrays ist das sehr einfach; verhalten sie sich doch ähnlich wie Python-Listen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "7eed4014",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-05-21T17:13:00.857844Z",
     "iopub.status.busy": "2026-05-21T17:13:00.857736Z",
     "iopub.status.idle": "2026-05-21T17:13:00.889953Z",
     "shell.execute_reply": "2026-05-21T17:13:00.889633Z",
     "shell.execute_reply.started": "2026-05-21T17:13:00.857829Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8d71c545",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-05-21T17:13:00.890409Z",
     "iopub.status.busy": "2026-05-21T17:13:00.890290Z",
     "iopub.status.idle": "2026-05-21T17:13:00.900655Z",
     "shell.execute_reply": "2026-05-21T17:13:00.900397Z",
     "shell.execute_reply.started": "2026-05-21T17:13:00.890400Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.55088682, -0.19252388, -0.41198448],\n",
       "       [-0.85917748, -0.62768546,  1.21933903],\n",
       "       [ 0.8389391 , -0.88456804, -0.67016679],\n",
       "       [-1.70774438, -0.78328505,  0.37689532]])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rng = np.random.default_rng()\n",
    "data = rng.normal(size=(4, 3))\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4202c561",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-05-21T17:13:00.901444Z",
     "iopub.status.busy": "2026-05-21T17:13:00.901139Z",
     "iopub.status.idle": "2026-05-21T17:13:00.903764Z",
     "shell.execute_reply": "2026-05-21T17:13:00.903499Z",
     "shell.execute_reply.started": "2026-05-21T17:13:00.901432Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1.70774438, -0.78328505,  0.37689532])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "23ee62b6",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-05-21T17:13:00.904279Z",
     "iopub.status.busy": "2026-05-21T17:13:00.904192Z",
     "iopub.status.idle": "2026-05-21T17:13:00.906672Z",
     "shell.execute_reply": "2026-05-21T17:13:00.906449Z",
     "shell.execute_reply.started": "2026-05-21T17:13:00.904270Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.85917748, -0.62768546,  1.21933903],\n",
       "       [ 0.8389391 , -0.88456804, -0.67016679]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[1:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "11a26b4b",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-05-21T17:13:00.907009Z",
     "iopub.status.busy": "2026-05-21T17:13:00.906941Z",
     "iopub.status.idle": "2026-05-21T17:13:00.908662Z",
     "shell.execute_reply": "2026-05-21T17:13:00.908454Z",
     "shell.execute_reply.started": "2026-05-21T17:13:00.907001Z"
    }
   },
   "outputs": [],
   "source": [
    "data[1:3] = rng.normal(size=(2, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "78f018d3",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-05-21T17:13:00.911107Z",
     "iopub.status.busy": "2026-05-21T17:13:00.910773Z",
     "iopub.status.idle": "2026-05-21T17:13:00.913387Z",
     "shell.execute_reply": "2026-05-21T17:13:00.913102Z",
     "shell.execute_reply.started": "2026-05-21T17:13:00.911097Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.55088682, -0.19252388, -0.41198448],\n",
       "       [ 1.06439017, -0.68654884,  1.1958988 ],\n",
       "       [ 0.22420899, -0.09198245, -0.1812715 ],\n",
       "       [-1.70774438, -0.78328505,  0.37689532]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab9427bb",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "\n",
    "**Bemerkung:**\n",
    "\n",
    "Array-Slices unterscheiden sich von Python-Listen dadurch, dass sie Sichten (_views_) auf das ursprüngliche Array sind. Das bedeutet, dass die Daten nicht kopiert werden und dass alle Änderungen an der View im Ausgangsarray wiedergegeben werden.\n",
    "\n",
    "Wenn ihr eine Kopie eines Teils eines `ndarray` erstellen wollt, könnt ihr das Array explizit kopieren – z.B. mit `data[2:5].copy()`.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c1201a1",
   "metadata": {},
   "source": [
    "_Slicing_ in dieser Weise führt immer zu Array-Ansichten mit der gleichen Anzahl von Dimensionen. Wenn ihr jedoch ganzzahlige Indizes und Slices mischt, erhaltet ihr Slices mit niedrigeren Dimensionen. So können wir z.B. die zweite Zeile, aber nur die ersten beiden Spalten wie folgt auswählen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "fcef2893",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-05-21T17:13:00.913788Z",
     "iopub.status.busy": "2026-05-21T17:13:00.913716Z",
     "iopub.status.idle": "2026-05-21T17:13:00.915855Z",
     "shell.execute_reply": "2026-05-21T17:13:00.915637Z",
     "shell.execute_reply.started": "2026-05-21T17:13:00.913781Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.06439017, -0.68654884])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[1, :2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07d3f5fd",
   "metadata": {},
   "source": [
    "Ein Doppelpunkt bedeutet, dass die gesamte Achse genommen wird, so dass ihr auch höherdimensionale Achsen auswählen könnt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "505acd40",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-05-21T17:13:00.916228Z",
     "iopub.status.busy": "2026-05-21T17:13:00.916154Z",
     "iopub.status.idle": "2026-05-21T17:13:00.918368Z",
     "shell.execute_reply": "2026-05-21T17:13:00.918148Z",
     "shell.execute_reply.started": "2026-05-21T17:13:00.916219Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.55088682],\n",
       "       [ 1.06439017],\n",
       "       [ 0.22420899],\n",
       "       [-1.70774438]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[:, :1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ecf4b02",
   "metadata": {},
   "source": [
    "## Boolesche Indizierung\n",
    "\n",
    "Betrachten wir ein Beispiel, bei dem wir einige Daten in einem Array und ein Array von Namen mit Duplikaten haben. Ich werde hier die Funktion `randn` in `numpy.random` verwenden, um einige zufällige normalverteilte Daten zu erzeugen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f22c1d6e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-05-21T17:13:00.918969Z",
     "iopub.status.busy": "2026-05-21T17:13:00.918833Z",
     "iopub.status.idle": "2026-05-21T17:13:00.920443Z",
     "shell.execute_reply": "2026-05-21T17:13:00.920217Z",
     "shell.execute_reply.started": "2026-05-21T17:13:00.918958Z"
    }
   },
   "outputs": [],
   "source": [
    "names = np.array(\n",
    "    [\n",
    "        \"Andrea\",\n",
    "        \"Tim\",\n",
    "        \"Veit\",\n",
    "        \"Tim\",\n",
    "    ]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "322b0502",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-05-21T17:13:00.921108Z",
     "iopub.status.busy": "2026-05-21T17:13:00.920975Z",
     "iopub.status.idle": "2026-05-21T17:13:00.923112Z",
     "shell.execute_reply": "2026-05-21T17:13:00.922861Z",
     "shell.execute_reply.started": "2026-05-21T17:13:00.921100Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Andrea', 'Tim', 'Veit', 'Tim'], dtype='<U6')"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e1ca2b9b",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-05-21T17:13:00.923641Z",
     "iopub.status.busy": "2026-05-21T17:13:00.923562Z",
     "iopub.status.idle": "2026-05-21T17:13:00.925793Z",
     "shell.execute_reply": "2026-05-21T17:13:00.925516Z",
     "shell.execute_reply.started": "2026-05-21T17:13:00.923635Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.55088682, -0.19252388, -0.41198448],\n",
       "       [ 1.06439017, -0.68654884,  1.1958988 ],\n",
       "       [ 0.22420899, -0.09198245, -0.1812715 ],\n",
       "       [-1.70774438, -0.78328505,  0.37689532]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00f9db15",
   "metadata": {},
   "source": [
    "Angenommen, jeder Name entspricht einer Zeile im Datenarray und wir wollen alle Zeilen mit dem entsprechenden Namen _Tim_ auswählen. Wie arithmetische Operationen werden auch Vergleiche wie `==` mit Arrays vektorisiert. Der Vergleich von Namen mit der Zeichenkette `Tim` ergibt also ein boolesches Array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "469a5d26",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-05-21T17:13:00.926189Z",
     "iopub.status.busy": "2026-05-21T17:13:00.926120Z",
     "iopub.status.idle": "2026-05-21T17:13:00.928614Z",
     "shell.execute_reply": "2026-05-21T17:13:00.928396Z",
     "shell.execute_reply.started": "2026-05-21T17:13:00.926183Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False,  True, False,  True])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names == \"Tim\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcab016d",
   "metadata": {},
   "source": [
    "Dieses boolesche Array kann beim Indizieren des Arrays übergeben werden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "3637b5d4",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-05-21T17:13:00.929076Z",
     "iopub.status.busy": "2026-05-21T17:13:00.929005Z",
     "iopub.status.idle": "2026-05-21T17:13:00.931682Z",
     "shell.execute_reply": "2026-05-21T17:13:00.931468Z",
     "shell.execute_reply.started": "2026-05-21T17:13:00.929069Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.06439017, -0.68654884,  1.1958988 ],\n",
       "       [-1.70774438, -0.78328505,  0.37689532]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[names == \"Tim\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7249e46",
   "metadata": {},
   "source": [
    "Dabei muss das boolesche Array die gleiche Länge haben wie die Arrayachse, die es indiziert."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e69904c7",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "\n",
    "**Bemerkung:**\n",
    "\n",
    "Die Auswahl von Daten aus einem Array durch boolesche Indizierung und die Zuweisung des Ergebnisses an eine neue Variable erzeugt immer eine Kopie der Daten, selbst wenn das zurückgegebene Array unverändert ist.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2cdde717",
   "metadata": {},
   "source": [
    "Im folgenden Beispiel wähle ich die Zeilen aus, in denen `Namen == \"Tim\"` ist und indiziere auch die Spalten:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "6981b0ea",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-05-21T17:13:00.932088Z",
     "iopub.status.busy": "2026-05-21T17:13:00.932023Z",
     "iopub.status.idle": "2026-05-21T17:13:00.934218Z",
     "shell.execute_reply": "2026-05-21T17:13:00.933951Z",
     "shell.execute_reply.started": "2026-05-21T17:13:00.932081Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.1958988 ],\n",
       "       [0.37689532]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[names == \"Tim\", 2:]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f12a10f0",
   "metadata": {},
   "source": [
    "Um alles außer _Tim_ auszuwählen, könnt ihr entweder `!=` verwenden oder die Bedingung mit `~` negieren:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "6f23e3fb",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-05-21T17:13:00.934574Z",
     "iopub.status.busy": "2026-05-21T17:13:00.934490Z",
     "iopub.status.idle": "2026-05-21T17:13:00.936579Z",
     "shell.execute_reply": "2026-05-21T17:13:00.936336Z",
     "shell.execute_reply.started": "2026-05-21T17:13:00.934564Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False,  True, False])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names != \"Tim\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "46e40ec4",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-05-21T17:13:00.937160Z",
     "iopub.status.busy": "2026-05-21T17:13:00.937023Z",
     "iopub.status.idle": "2026-05-21T17:13:00.939126Z",
     "shell.execute_reply": "2026-05-21T17:13:00.938856Z",
     "shell.execute_reply.started": "2026-05-21T17:13:00.937148Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.55088682, -0.19252388, -0.41198448],\n",
       "       [ 0.22420899, -0.09198245, -0.1812715 ]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cond = names == \"Tim\"\n",
    "data[~cond]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ac9f026",
   "metadata": {},
   "source": [
    "Wenn ihr zwei der drei Namen auswählt, um mehrere boolesche Bedingungen zu kombinieren, könnt ihr die booleschen arithmetischen Operatoren `&` (und) und `|` (oder) verwenden.\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\">\n",
    "\n",
    "**Warnung:**\n",
    "\n",
    "Die Python-Schlüsselwörter `and` und `or` funktionieren nicht mit booleschen Arrays.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "42cc2666",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-05-21T17:13:00.939482Z",
     "iopub.status.busy": "2026-05-21T17:13:00.939420Z",
     "iopub.status.idle": "2026-05-21T17:13:00.941091Z",
     "shell.execute_reply": "2026-05-21T17:13:00.940861Z",
     "shell.execute_reply.started": "2026-05-21T17:13:00.939475Z"
    }
   },
   "outputs": [],
   "source": [
    "mask = (names == \"Tim\") | (names == \"Veit\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "bf18e5dc",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-05-21T17:13:00.941445Z",
     "iopub.status.busy": "2026-05-21T17:13:00.941369Z",
     "iopub.status.idle": "2026-05-21T17:13:00.943445Z",
     "shell.execute_reply": "2026-05-21T17:13:00.943211Z",
     "shell.execute_reply.started": "2026-05-21T17:13:00.941438Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False,  True,  True,  True])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "21d90f8e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-05-21T17:13:00.943897Z",
     "iopub.status.busy": "2026-05-21T17:13:00.943809Z",
     "iopub.status.idle": "2026-05-21T17:13:00.946346Z",
     "shell.execute_reply": "2026-05-21T17:13:00.946024Z",
     "shell.execute_reply.started": "2026-05-21T17:13:00.943889Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.06439017, -0.68654884,  1.1958988 ],\n",
       "       [ 0.22420899, -0.09198245, -0.1812715 ],\n",
       "       [-1.70774438, -0.78328505,  0.37689532]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[mask]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b6dfc27",
   "metadata": {},
   "source": [
    "## Ganzzahlige Array-Indizierung\n",
    "\n",
    "Ganzzahlige Array-Indizierung ermöglicht die Auswahl beliebiger Elemente im Array auf der Grundlage eures N-dimensionalen Index. Jedes Integer-Array repräsentiert eine Anzahl von Indizes in dieser Dimension. \n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "\n",
    "**Siehe auch:**\n",
    "\n",
    "* [Integer array indexing](https://numpy.org/doc/stable/user/basics.indexing.html#integer-array-indexing)\n",
    "</div>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.13 Kernel",
   "language": "python",
   "name": "python313"
  },
  "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.13.0"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}