OpenAPC.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ea07bbf7",
   "metadata": {},
   "outputs": [],
   "source": [
    "import urllib.request\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9fa4ec61",
   "metadata": {},
   "outputs": [],
   "source": [
    "openapc_url = \"https://raw.githubusercontent.com/OpenAPC/openapc-de/master/data/fuberlin/APC_FU_Berlin_2015.csv\"\n",
    "apc_file = \"openapc.csv\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "dfdea77c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('openapc.csv', <http.client.HTTPMessage at 0x7f6f2d4d1dc0>)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "urllib.request.urlretrieve(openapc_url, apc_file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e5dcc46f",
   "metadata": {},
   "outputs": [],
   "source": [
    "apcs = pd.read_csv(apc_file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5b647595",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Die ganze Datei als Tabelle ausgeben:\n",
    "# apcs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6909cdff",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(61, 17)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Anzahl Reihen und Spalten\n",
    "apcs.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a24e454b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['institution', 'period', 'euro', 'doi', 'is_hybrid', 'publisher',\n",
       "       'journal_full_title', 'issn', 'issn_print', 'issn_electronic',\n",
       "       'license_ref', 'indexed_in_crossref', 'pmid', 'pmcid', 'ut', 'url',\n",
       "       'doaj'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Spaltennamen\n",
    "apcs.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "dc7dc1b1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0     2000.00\n",
       "1     1503.12\n",
       "2     2000.00\n",
       "3     2000.00\n",
       "4     1805.00\n",
       "       ...   \n",
       "56    1731.45\n",
       "57    1600.00\n",
       "58     219.84\n",
       "59    1386.35\n",
       "60    2000.00\n",
       "Name: euro, Length: 61, dtype: float64"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "apcs[\"euro\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "6ce9e0ce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2000.0"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "apcs[\"euro\"].max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "b41f027e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "219.84"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "apcs[\"euro\"].min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "703879c7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1419.6080327868851"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "apcs[\"euro\"].mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "324a58fd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1410.07"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "apcs[\"euro\"].median()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "be919b19",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count      61.000000\n",
       "mean     1419.608033\n",
       "std       456.811349\n",
       "min       219.840000\n",
       "25%      1178.420000\n",
       "50%      1410.070000\n",
       "75%      1800.000000\n",
       "max      2000.000000\n",
       "Name: euro, dtype: float64"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "apcs[\"euro\"].describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "88a5a759",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 > 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "13571e3f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 < 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "daffb0ef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 == 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "dd6ec40e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0      True\n",
       "1     False\n",
       "2      True\n",
       "3      True\n",
       "4     False\n",
       "      ...  \n",
       "56    False\n",
       "57    False\n",
       "58    False\n",
       "59    False\n",
       "60     True\n",
       "Name: euro, Length: 61, dtype: bool"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "apcs[\"euro\"] >= 2000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "245a6c83",
   "metadata": {},
   "outputs": [],
   "source": [
    "apcs_2000 = apcs[apcs[\"euro\"] >= 2000]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "0e8d4413",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(11, 17)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "apcs_2000.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "5446af62",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# in diesem Fall Anzahl der Zeilen (=Treffermenge)\n",
    "len(apcs_2000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "e4b06d5e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Histogramm erstellen .. in 10 Bins eingeteilt\n",
    "apcs[\"euro\"].hist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "9141d379",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# ... mit Keyword-Parametern\n",
    "apcs[\"euro\"].hist(bins=20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "5a018a5c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "apcs[\"euro\"].hist(bins=20, color=\"pink\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "815b264b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on AxesSubplot in module matplotlib.axes._subplots object:\n",
      "\n",
      "class AxesSubplot(SubplotBase, matplotlib.axes._axes.Axes)\n",
      " |  AxesSubplot(fig, *args, **kwargs)\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      AxesSubplot\n",
      " |      SubplotBase\n",
      " |      matplotlib.axes._axes.Axes\n",
      " |      matplotlib.axes._base._AxesBase\n",
      " |      matplotlib.artist.Artist\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __reduce__(self)\n",
      " |  \n",
      " |  set(self, *, adjustable=<UNSET>, agg_filter=<UNSET>, alpha=<UNSET>, anchor=<UNSET>, animated=<UNSET>, aspect=<UNSET>, autoscale_on=<UNSET>, autoscalex_on=<UNSET>, autoscaley_on=<UNSET>, axes_locator=<UNSET>, axisbelow=<UNSET>, box_aspect=<UNSET>, clip_box=<UNSET>, clip_on=<UNSET>, clip_path=<UNSET>, facecolor=<UNSET>, frame_on=<UNSET>, gid=<UNSET>, in_layout=<UNSET>, label=<UNSET>, navigate=<UNSET>, path_effects=<UNSET>, picker=<UNSET>, position=<UNSET>, prop_cycle=<UNSET>, rasterization_zorder=<UNSET>, rasterized=<UNSET>, sketch_params=<UNSET>, snap=<UNSET>, subplotspec=<UNSET>, title=<UNSET>, transform=<UNSET>, url=<UNSET>, visible=<UNSET>, xbound=<UNSET>, xlabel=<UNSET>, xlim=<UNSET>, xmargin=<UNSET>, xscale=<UNSET>, xticklabels=<UNSET>, xticks=<UNSET>, ybound=<UNSET>, ylabel=<UNSET>, ylim=<UNSET>, ymargin=<UNSET>, yscale=<UNSET>, yticklabels=<UNSET>, yticks=<UNSET>, zorder=<UNSET>)\n",
      " |      Set multiple properties at once.\n",
      " |      \n",
      " |      Supported properties are\n",
      " |      \n",
      " |      Properties:\n",
      " |          adjustable: {'box', 'datalim'}\n",
      " |          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      " |          alpha: scalar or None\n",
      " |          anchor: (float, float) or {'C', 'SW', 'S', 'SE', 'E', 'NE', ...}\n",
      " |          animated: bool\n",
      " |          aspect: {'auto', 'equal'} or float\n",
      " |          autoscale_on: bool\n",
      " |          autoscalex_on: bool\n",
      " |          autoscaley_on: bool\n",
      " |          axes_locator: Callable[[Axes, Renderer], Bbox]\n",
      " |          axisbelow: bool or 'line'\n",
      " |          box_aspect: float or None\n",
      " |          clip_box: `.Bbox`\n",
      " |          clip_on: bool\n",
      " |          clip_path: Patch or (Path, Transform) or None\n",
      " |          facecolor or fc: color\n",
      " |          figure: `.Figure`\n",
      " |          frame_on: bool\n",
      " |          gid: str\n",
      " |          in_layout: bool\n",
      " |          label: object\n",
      " |          navigate: bool\n",
      " |          navigate_mode: unknown\n",
      " |          path_effects: `.AbstractPathEffect`\n",
      " |          picker: None or bool or float or callable\n",
      " |          position: [left, bottom, width, height] or `~matplotlib.transforms.Bbox`\n",
      " |          prop_cycle: unknown\n",
      " |          rasterization_zorder: float or None\n",
      " |          rasterized: bool\n",
      " |          sketch_params: (scale: float, length: float, randomness: float)\n",
      " |          snap: bool or None\n",
      " |          subplotspec: unknown\n",
      " |          title: str\n",
      " |          transform: `.Transform`\n",
      " |          url: str\n",
      " |          visible: bool\n",
      " |          xbound: unknown\n",
      " |          xlabel: str\n",
      " |          xlim: (bottom: float, top: float)\n",
      " |          xmargin: float greater than -0.5\n",
      " |          xscale: {\"linear\", \"log\", \"symlog\", \"logit\", ...} or `.ScaleBase`\n",
      " |          xticklabels: unknown\n",
      " |          xticks: unknown\n",
      " |          ybound: unknown\n",
      " |          ylabel: str\n",
      " |          ylim: (bottom: float, top: float)\n",
      " |          ymargin: float greater than -0.5\n",
      " |          yscale: {\"linear\", \"log\", \"symlog\", \"logit\", ...} or `.ScaleBase`\n",
      " |          yticklabels: unknown\n",
      " |          yticks: unknown\n",
      " |          zorder: float\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from SubplotBase:\n",
      " |  \n",
      " |  __init__(self, fig, *args, **kwargs)\n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      fig : `matplotlib.figure.Figure`\n",
      " |      \n",
      " |      *args : tuple (*nrows*, *ncols*, *index*) or int\n",
      " |          The array of subplots in the figure has dimensions ``(nrows,\n",
      " |          ncols)``, and *index* is the index of the subplot being created.\n",
      " |          *index* starts at 1 in the upper left corner and increases to the\n",
      " |          right.\n",
      " |      \n",
      " |          If *nrows*, *ncols*, and *index* are all single digit numbers, then\n",
      " |          *args* can be passed as a single 3-digit number (e.g. 234 for\n",
      " |          (2, 3, 4)).\n",
      " |      \n",
      " |      **kwargs\n",
      " |          Keyword arguments are passed to the Axes (sub)class constructor.\n",
      " |  \n",
      " |  change_geometry(self, numrows, numcols, num)\n",
      " |      [*Deprecated*] Change subplot geometry, e.g., from (1, 1, 1) to (2, 2, 3).\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      .. deprecated:: 3.4\n",
      " |         Use set_subplotspec instead.\n",
      " |  \n",
      " |  get_geometry(self)\n",
      " |      [*Deprecated*] Get the subplot geometry, e.g., (2, 2, 3).\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      .. deprecated:: 3.4\n",
      " |         Use get_subplotspec instead. (get_subplotspec returns a SubplotSpec instance.)\n",
      " |  \n",
      " |  get_gridspec(self)\n",
      " |      Return the `.GridSpec` instance associated with the subplot.\n",
      " |  \n",
      " |  get_subplotspec(self)\n",
      " |      Return the `.SubplotSpec` instance associated with the subplot.\n",
      " |  \n",
      " |  is_first_col(self)\n",
      " |      [*Deprecated*] \n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      .. deprecated:: 3.4\n",
      " |         Use ax.get_subplotspec().is_first_col() instead.\\\n",
      " |  \n",
      " |  is_first_row(self)\n",
      " |      [*Deprecated*] \n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      .. deprecated:: 3.4\n",
      " |         Use ax.get_subplotspec().is_first_row() instead.\\\n",
      " |  \n",
      " |  is_last_col(self)\n",
      " |      [*Deprecated*] \n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      .. deprecated:: 3.4\n",
      " |         Use ax.get_subplotspec().is_last_col() instead.\\\n",
      " |  \n",
      " |  is_last_row(self)\n",
      " |      [*Deprecated*] \n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      .. deprecated:: 3.4\n",
      " |         Use ax.get_subplotspec().is_last_row() instead.\\\n",
      " |  \n",
      " |  label_outer(self)\n",
      " |      Only show \"outer\" labels and tick labels.\n",
      " |      \n",
      " |      x-labels are only kept for subplots on the last row (or first row, if\n",
      " |      labels are on the top side); y-labels only for subplots on the first\n",
      " |      column (or last column, if labels are on the right side).\n",
      " |  \n",
      " |  set_subplotspec(self, subplotspec)\n",
      " |      Set the `.SubplotSpec`. instance associated with the subplot.\n",
      " |  \n",
      " |  update_params(self)\n",
      " |      [*Deprecated*] Update the subplot position from ``self.figure.subplotpars``.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      .. deprecated:: 3.4\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from SubplotBase:\n",
      " |  \n",
      " |  figbox\n",
      " |  \n",
      " |  numCols\n",
      " |  \n",
      " |  numRows\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from SubplotBase:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from matplotlib.axes._axes.Axes:\n",
      " |  \n",
      " |  acorr(self, x, *, data=None, **kwargs)\n",
      " |      Plot the autocorrelation of *x*.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      x : array-like\n",
      " |      \n",
      " |      detrend : callable, default: `.mlab.detrend_none` (no detrending)\n",
      " |          A detrending function applied to *x*.  It must have the\n",
      " |          signature ::\n",
      " |      \n",
      " |              detrend(x: np.ndarray) -> np.ndarray\n",
      " |      \n",
      " |      normed : bool, default: True\n",
      " |          If ``True``, input vectors are normalised to unit length.\n",
      " |      \n",
      " |      usevlines : bool, default: True\n",
      " |          Determines the plot style.\n",
      " |      \n",
      " |          If ``True``, vertical lines are plotted from 0 to the acorr value\n",
      " |          using `.Axes.vlines`. Additionally, a horizontal line is plotted\n",
      " |          at y=0 using `.Axes.axhline`.\n",
      " |      \n",
      " |          If ``False``, markers are plotted at the acorr values using\n",
      " |          `.Axes.plot`.\n",
      " |      \n",
      " |      maxlags : int, default: 10\n",
      " |          Number of lags to show. If ``None``, will return all\n",
      " |          ``2 * len(x) - 1`` lags.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      lags : array (length ``2*maxlags+1``)\n",
      " |          The lag vector.\n",
      " |      c : array  (length ``2*maxlags+1``)\n",
      " |          The auto correlation vector.\n",
      " |      line : `.LineCollection` or `.Line2D`\n",
      " |          `.Artist` added to the Axes of the correlation:\n",
      " |      \n",
      " |          - `.LineCollection` if *usevlines* is True.\n",
      " |          - `.Line2D` if *usevlines* is False.\n",
      " |      b : `.Line2D` or None\n",
      " |          Horizontal line at 0 if *usevlines* is True\n",
      " |          None *usevlines* is False.\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      linestyle : `.Line2D` property, optional\n",
      " |          The linestyle for plotting the data points.\n",
      " |          Only used if *usevlines* is ``False``.\n",
      " |      \n",
      " |      marker : str, default: 'o'\n",
      " |          The marker for plotting the data points.\n",
      " |          Only used if *usevlines* is ``False``.\n",
      " |      \n",
      " |      data : indexable object, optional\n",
      " |          If given, the following parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception):\n",
      " |      \n",
      " |          *x*\n",
      " |      \n",
      " |      **kwargs\n",
      " |          Additional parameters are passed to `.Axes.vlines` and\n",
      " |          `.Axes.axhline` if *usevlines* is ``True``; otherwise they are\n",
      " |          passed to `.Axes.plot`.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      The cross correlation is performed with `numpy.correlate` with\n",
      " |      ``mode = \"full\"``.\n",
      " |  \n",
      " |  angle_spectrum(self, x, Fs=None, Fc=None, window=None, pad_to=None, sides=None, *, data=None, **kwargs)\n",
      " |      Plot the angle spectrum.\n",
      " |      \n",
      " |      Compute the angle spectrum (wrapped phase spectrum) of *x*.\n",
      " |      Data is padded to a length of *pad_to* and the windowing function\n",
      " |      *window* is applied to the signal.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      x : 1-D array or sequence\n",
      " |          Array or sequence containing the data.\n",
      " |      \n",
      " |      Fs : float, default: 2\n",
      " |          The sampling frequency (samples per time unit).  It is used to calculate\n",
      " |          the Fourier frequencies, *freqs*, in cycles per time unit.\n",
      " |      \n",
      " |      window : callable or ndarray, default: `.window_hanning`\n",
      " |          A function or a vector of length *NFFT*.  To create window vectors see\n",
      " |          `.window_hanning`, `.window_none`, `numpy.blackman`, `numpy.hamming`,\n",
      " |          `numpy.bartlett`, `scipy.signal`, `scipy.signal.get_window`, etc.  If a\n",
      " |          function is passed as the argument, it must take a data segment as an\n",
      " |          argument and return the windowed version of the segment.\n",
      " |      \n",
      " |      sides : {'default', 'onesided', 'twosided'}, optional\n",
      " |          Which sides of the spectrum to return. 'default' is one-sided for real\n",
      " |          data and two-sided for complex data. 'onesided' forces the return of a\n",
      " |          one-sided spectrum, while 'twosided' forces two-sided.\n",
      " |      \n",
      " |      pad_to : int, optional\n",
      " |          The number of points to which the data segment is padded when performing\n",
      " |          the FFT.  While not increasing the actual resolution of the spectrum (the\n",
      " |          minimum distance between resolvable peaks), this can give more points in\n",
      " |          the plot, allowing for more detail. This corresponds to the *n* parameter\n",
      " |          in the call to fft().  The default is None, which sets *pad_to* equal to\n",
      " |          the length of the input signal (i.e. no padding).\n",
      " |      \n",
      " |      Fc : int, default: 0\n",
      " |          The center frequency of *x*, which offsets the x extents of the\n",
      " |          plot to reflect the frequency range used when a signal is acquired\n",
      " |          and then filtered and downsampled to baseband.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      spectrum : 1-D array\n",
      " |          The values for the angle spectrum in radians (real valued).\n",
      " |      \n",
      " |      freqs : 1-D array\n",
      " |          The frequencies corresponding to the elements in *spectrum*.\n",
      " |      \n",
      " |      line : `~matplotlib.lines.Line2D`\n",
      " |          The line created by this function.\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      data : indexable object, optional\n",
      " |          If given, the following parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception):\n",
      " |      \n",
      " |          *x*\n",
      " |      \n",
      " |      **kwargs\n",
      " |          Keyword arguments control the `.Line2D` properties:\n",
      " |      \n",
      " |          Properties:\n",
      " |          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      " |          alpha: scalar or None\n",
      " |          animated: bool\n",
      " |          antialiased or aa: bool\n",
      " |          clip_box: `.Bbox`\n",
      " |          clip_on: bool\n",
      " |          clip_path: Patch or (Path, Transform) or None\n",
      " |          color or c: color\n",
      " |          dash_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          dash_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          dashes: sequence of floats (on/off ink in points) or (None, None)\n",
      " |          data: (2, N) array or two 1D arrays\n",
      " |          drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'\n",
      " |          figure: `.Figure`\n",
      " |          fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}\n",
      " |          gid: str\n",
      " |          in_layout: bool\n",
      " |          label: object\n",
      " |          linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      " |          linewidth or lw: float\n",
      " |          marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`\n",
      " |          markeredgecolor or mec: color\n",
      " |          markeredgewidth or mew: float\n",
      " |          markerfacecolor or mfc: color\n",
      " |          markerfacecoloralt or mfcalt: color\n",
      " |          markersize or ms: float\n",
      " |          markevery: None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]\n",
      " |          path_effects: `.AbstractPathEffect`\n",
      " |          picker: float or callable[[Artist, Event], tuple[bool, dict]]\n",
      " |          pickradius: float\n",
      " |          rasterized: bool\n",
      " |          sketch_params: (scale: float, length: float, randomness: float)\n",
      " |          snap: bool or None\n",
      " |          solid_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          solid_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          transform: unknown\n",
      " |          url: str\n",
      " |          visible: bool\n",
      " |          xdata: 1D array\n",
      " |          ydata: 1D array\n",
      " |          zorder: float\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      magnitude_spectrum\n",
      " |          Plots the magnitudes of the corresponding frequencies.\n",
      " |      phase_spectrum\n",
      " |          Plots the unwrapped version of this function.\n",
      " |      specgram\n",
      " |          Can plot the angle spectrum of segments within the signal in a\n",
      " |          colormap.\n",
      " |  \n",
      " |  annotate(self, text, xy, *args, **kwargs)\n",
      " |      Annotate the point *xy* with text *text*.\n",
      " |      \n",
      " |      In the simplest form, the text is placed at *xy*.\n",
      " |      \n",
      " |      Optionally, the text can be displayed in another position *xytext*.\n",
      " |      An arrow pointing from the text to the annotated point *xy* can then\n",
      " |      be added by defining *arrowprops*.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      text : str\n",
      " |          The text of the annotation.\n",
      " |      \n",
      " |      xy : (float, float)\n",
      " |          The point *(x, y)* to annotate. The coordinate system is determined\n",
      " |          by *xycoords*.\n",
      " |      \n",
      " |      xytext : (float, float), default: *xy*\n",
      " |          The position *(x, y)* to place the text at. The coordinate system\n",
      " |          is determined by *textcoords*.\n",
      " |      \n",
      " |      xycoords : str or `.Artist` or `.Transform` or callable or (float, float), default: 'data'\n",
      " |      \n",
      " |          The coordinate system that *xy* is given in. The following types\n",
      " |          of values are supported:\n",
      " |      \n",
      " |          - One of the following strings:\n",
      " |      \n",
      " |            ==================== ============================================\n",
      " |            Value                Description\n",
      " |            ==================== ============================================\n",
      " |            'figure points'      Points from the lower left of the figure\n",
      " |            'figure pixels'      Pixels from the lower left of the figure\n",
      " |            'figure fraction'    Fraction of figure from lower left\n",
      " |            'subfigure points'   Points from the lower left of the subfigure\n",
      " |            'subfigure pixels'   Pixels from the lower left of the subfigure\n",
      " |            'subfigure fraction' Fraction of subfigure from lower left\n",
      " |            'axes points'        Points from lower left corner of axes\n",
      " |            'axes pixels'        Pixels from lower left corner of axes\n",
      " |            'axes fraction'      Fraction of axes from lower left\n",
      " |            'data'               Use the coordinate system of the object\n",
      " |                                 being annotated (default)\n",
      " |            'polar'              *(theta, r)* if not native 'data'\n",
      " |                                 coordinates\n",
      " |            ==================== ============================================\n",
      " |      \n",
      " |            Note that 'subfigure pixels' and 'figure pixels' are the same\n",
      " |            for the parent figure, so users who want code that is usable in\n",
      " |            a subfigure can use 'subfigure pixels'.\n",
      " |      \n",
      " |          - An `.Artist`: *xy* is interpreted as a fraction of the artist's\n",
      " |            `~matplotlib.transforms.Bbox`. E.g. *(0, 0)* would be the lower\n",
      " |            left corner of the bounding box and *(0.5, 1)* would be the\n",
      " |            center top of the bounding box.\n",
      " |      \n",
      " |          - A `.Transform` to transform *xy* to screen coordinates.\n",
      " |      \n",
      " |          - A function with one of the following signatures::\n",
      " |      \n",
      " |              def transform(renderer) -> Bbox\n",
      " |              def transform(renderer) -> Transform\n",
      " |      \n",
      " |            where *renderer* is a `.RendererBase` subclass.\n",
      " |      \n",
      " |            The result of the function is interpreted like the `.Artist` and\n",
      " |            `.Transform` cases above.\n",
      " |      \n",
      " |          - A tuple *(xcoords, ycoords)* specifying separate coordinate\n",
      " |            systems for *x* and *y*. *xcoords* and *ycoords* must each be\n",
      " |            of one of the above described types.\n",
      " |      \n",
      " |          See :ref:`plotting-guide-annotation` for more details.\n",
      " |      \n",
      " |      textcoords : str or `.Artist` or `.Transform` or callable or (float, float), default: value of *xycoords*\n",
      " |          The coordinate system that *xytext* is given in.\n",
      " |      \n",
      " |          All *xycoords* values are valid as well as the following\n",
      " |          strings:\n",
      " |      \n",
      " |          =================   =========================================\n",
      " |          Value               Description\n",
      " |          =================   =========================================\n",
      " |          'offset points'     Offset (in points) from the *xy* value\n",
      " |          'offset pixels'     Offset (in pixels) from the *xy* value\n",
      " |          =================   =========================================\n",
      " |      \n",
      " |      arrowprops : dict, optional\n",
      " |          The properties used to draw a `.FancyArrowPatch` arrow between the\n",
      " |          positions *xy* and *xytext*.  Defaults to None, i.e. no arrow is\n",
      " |          drawn.\n",
      " |      \n",
      " |          For historical reasons there are two different ways to specify\n",
      " |          arrows, \"simple\" and \"fancy\":\n",
      " |      \n",
      " |          **Simple arrow:**\n",
      " |      \n",
      " |          If *arrowprops* does not contain the key 'arrowstyle' the\n",
      " |          allowed keys are:\n",
      " |      \n",
      " |          ==========   ======================================================\n",
      " |          Key          Description\n",
      " |          ==========   ======================================================\n",
      " |          width        The width of the arrow in points\n",
      " |          headwidth    The width of the base of the arrow head in points\n",
      " |          headlength   The length of the arrow head in points\n",
      " |          shrink       Fraction of total length to shrink from both ends\n",
      " |          ?            Any key to :class:`matplotlib.patches.FancyArrowPatch`\n",
      " |          ==========   ======================================================\n",
      " |      \n",
      " |          The arrow is attached to the edge of the text box, the exact\n",
      " |          position (corners or centers) depending on where it's pointing to.\n",
      " |      \n",
      " |          **Fancy arrow:**\n",
      " |      \n",
      " |          This is used if 'arrowstyle' is provided in the *arrowprops*.\n",
      " |      \n",
      " |          Valid keys are the following `~matplotlib.patches.FancyArrowPatch`\n",
      " |          parameters:\n",
      " |      \n",
      " |          ===============  ==================================================\n",
      " |          Key              Description\n",
      " |          ===============  ==================================================\n",
      " |          arrowstyle       the arrow style\n",
      " |          connectionstyle  the connection style\n",
      " |          relpos           see below; default is (0.5, 0.5)\n",
      " |          patchA           default is bounding box of the text\n",
      " |          patchB           default is None\n",
      " |          shrinkA          default is 2 points\n",
      " |          shrinkB          default is 2 points\n",
      " |          mutation_scale   default is text size (in points)\n",
      " |          mutation_aspect  default is 1.\n",
      " |          ?                any key for :class:`matplotlib.patches.PathPatch`\n",
      " |          ===============  ==================================================\n",
      " |      \n",
      " |          The exact starting point position of the arrow is defined by\n",
      " |          *relpos*. It's a tuple of relative coordinates of the text box,\n",
      " |          where (0, 0) is the lower left corner and (1, 1) is the upper\n",
      " |          right corner. Values <0 and >1 are supported and specify points\n",
      " |          outside the text box. By default (0.5, 0.5) the starting point is\n",
      " |          centered in the text box.\n",
      " |      \n",
      " |      annotation_clip : bool or None, default: None\n",
      " |          Whether to draw the annotation when the annotation point *xy* is\n",
      " |          outside the axes area.\n",
      " |      \n",
      " |          - If *True*, the annotation will only be drawn when *xy* is\n",
      " |            within the axes.\n",
      " |          - If *False*, the annotation will always be drawn.\n",
      " |          - If *None*, the annotation will only be drawn when *xy* is\n",
      " |            within the axes and *xycoords* is 'data'.\n",
      " |      \n",
      " |      **kwargs\n",
      " |          Additional kwargs are passed to `~matplotlib.text.Text`.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `.Annotation`\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      :ref:`plotting-guide-annotation`\n",
      " |  \n",
      " |  arrow(self, x, y, dx, dy, **kwargs)\n",
      " |      Add an arrow to the Axes.\n",
      " |      \n",
      " |      This draws an arrow from ``(x, y)`` to ``(x+dx, y+dy)``.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      x, y : float\n",
      " |          The x and y coordinates of the arrow base.\n",
      " |      \n",
      " |      dx, dy : float\n",
      " |          The length of the arrow along x and y direction.\n",
      " |      \n",
      " |      width : float, default: 0.001\n",
      " |          Width of full arrow tail.\n",
      " |      \n",
      " |      length_includes_head : bool, default: False\n",
      " |          True if head is to be counted in calculating the length.\n",
      " |      \n",
      " |      head_width : float or None, default: 3*width\n",
      " |          Total width of the full arrow head.\n",
      " |      \n",
      " |      head_length : float or None, default: 1.5*head_width\n",
      " |          Length of arrow head.\n",
      " |      \n",
      " |      shape : {'full', 'left', 'right'}, default: 'full'\n",
      " |          Draw the left-half, right-half, or full arrow.\n",
      " |      \n",
      " |      overhang : float, default: 0\n",
      " |          Fraction that the arrow is swept back (0 overhang means\n",
      " |          triangular shape). Can be negative or greater than one.\n",
      " |      \n",
      " |      head_starts_at_zero : bool, default: False\n",
      " |          If True, the head starts being drawn at coordinate 0\n",
      " |          instead of ending at coordinate 0.\n",
      " |      \n",
      " |      **kwargs\n",
      " |          `.Patch` properties:\n",
      " |      \n",
      " |          Properties:\n",
      " |          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      " |          alpha: unknown\n",
      " |          animated: bool\n",
      " |          antialiased or aa: bool or None\n",
      " |          capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          clip_box: `.Bbox`\n",
      " |          clip_on: bool\n",
      " |          clip_path: Patch or (Path, Transform) or None\n",
      " |          color: color\n",
      " |          edgecolor or ec: color or None\n",
      " |          facecolor or fc: color or None\n",
      " |          figure: `.Figure`\n",
      " |          fill: bool\n",
      " |          gid: str\n",
      " |          hatch: {'/', '\\\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
      " |          in_layout: bool\n",
      " |          joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          label: object\n",
      " |          linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      " |          linewidth or lw: float or None\n",
      " |          path_effects: `.AbstractPathEffect`\n",
      " |          picker: None or bool or float or callable\n",
      " |          rasterized: bool\n",
      " |          sketch_params: (scale: float, length: float, randomness: float)\n",
      " |          snap: bool or None\n",
      " |          transform: `.Transform`\n",
      " |          url: str\n",
      " |          visible: bool\n",
      " |          zorder: float\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `.FancyArrow`\n",
      " |          The created `.FancyArrow` object.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      The resulting arrow is affected by the Axes aspect ratio and limits.\n",
      " |      This may produce an arrow whose head is not square with its stem. To\n",
      " |      create an arrow whose head is square with its stem,\n",
      " |      use :meth:`annotate` for example:\n",
      " |      \n",
      " |      >>> ax.annotate(\"\", xy=(0.5, 0.5), xytext=(0, 0),\n",
      " |      ...             arrowprops=dict(arrowstyle=\"->\"))\n",
      " |  \n",
      " |  axhline(self, y=0, xmin=0, xmax=1, **kwargs)\n",
      " |      Add a horizontal line across the Axes.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      y : float, default: 0\n",
      " |          y position in data coordinates of the horizontal line.\n",
      " |      \n",
      " |      xmin : float, default: 0\n",
      " |          Should be between 0 and 1, 0 being the far left of the plot, 1 the\n",
      " |          far right of the plot.\n",
      " |      \n",
      " |      xmax : float, default: 1\n",
      " |          Should be between 0 and 1, 0 being the far left of the plot, 1 the\n",
      " |          far right of the plot.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `~matplotlib.lines.Line2D`\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      **kwargs\n",
      " |          Valid keyword arguments are `.Line2D` properties, with the\n",
      " |          exception of 'transform':\n",
      " |      \n",
      " |          Properties:\n",
      " |          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      " |          alpha: scalar or None\n",
      " |          animated: bool\n",
      " |          antialiased or aa: bool\n",
      " |          clip_box: `.Bbox`\n",
      " |          clip_on: bool\n",
      " |          clip_path: Patch or (Path, Transform) or None\n",
      " |          color or c: color\n",
      " |          dash_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          dash_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          dashes: sequence of floats (on/off ink in points) or (None, None)\n",
      " |          data: (2, N) array or two 1D arrays\n",
      " |          drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'\n",
      " |          figure: `.Figure`\n",
      " |          fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}\n",
      " |          gid: str\n",
      " |          in_layout: bool\n",
      " |          label: object\n",
      " |          linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      " |          linewidth or lw: float\n",
      " |          marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`\n",
      " |          markeredgecolor or mec: color\n",
      " |          markeredgewidth or mew: float\n",
      " |          markerfacecolor or mfc: color\n",
      " |          markerfacecoloralt or mfcalt: color\n",
      " |          markersize or ms: float\n",
      " |          markevery: None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]\n",
      " |          path_effects: `.AbstractPathEffect`\n",
      " |          picker: float or callable[[Artist, Event], tuple[bool, dict]]\n",
      " |          pickradius: float\n",
      " |          rasterized: bool\n",
      " |          sketch_params: (scale: float, length: float, randomness: float)\n",
      " |          snap: bool or None\n",
      " |          solid_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          solid_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          transform: unknown\n",
      " |          url: str\n",
      " |          visible: bool\n",
      " |          xdata: 1D array\n",
      " |          ydata: 1D array\n",
      " |          zorder: float\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      hlines : Add horizontal lines in data coordinates.\n",
      " |      axhspan : Add a horizontal span (rectangle) across the axis.\n",
      " |      axline : Add a line with an arbitrary slope.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      * draw a thick red hline at 'y' = 0 that spans the xrange::\n",
      " |      \n",
      " |          >>> axhline(linewidth=4, color='r')\n",
      " |      \n",
      " |      * draw a default hline at 'y' = 1 that spans the xrange::\n",
      " |      \n",
      " |          >>> axhline(y=1)\n",
      " |      \n",
      " |      * draw a default hline at 'y' = .5 that spans the middle half of\n",
      " |        the xrange::\n",
      " |      \n",
      " |          >>> axhline(y=.5, xmin=0.25, xmax=0.75)\n",
      " |  \n",
      " |  axhspan(self, ymin, ymax, xmin=0, xmax=1, **kwargs)\n",
      " |      Add a horizontal span (rectangle) across the Axes.\n",
      " |      \n",
      " |      The rectangle spans from *ymin* to *ymax* vertically, and, by default,\n",
      " |      the whole x-axis horizontally.  The x-span can be set using *xmin*\n",
      " |      (default: 0) and *xmax* (default: 1) which are in axis units; e.g.\n",
      " |      ``xmin = 0.5`` always refers to the middle of the x-axis regardless of\n",
      " |      the limits set by `~.Axes.set_xlim`.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      ymin : float\n",
      " |          Lower y-coordinate of the span, in data units.\n",
      " |      ymax : float\n",
      " |          Upper y-coordinate of the span, in data units.\n",
      " |      xmin : float, default: 0\n",
      " |          Lower x-coordinate of the span, in x-axis (0-1) units.\n",
      " |      xmax : float, default: 1\n",
      " |          Upper x-coordinate of the span, in x-axis (0-1) units.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `~matplotlib.patches.Polygon`\n",
      " |          Horizontal span (rectangle) from (xmin, ymin) to (xmax, ymax).\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      **kwargs : `~matplotlib.patches.Polygon` properties\n",
      " |      \n",
      " |      Properties:\n",
      " |          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      " |          alpha: scalar or None\n",
      " |          animated: bool\n",
      " |          antialiased or aa: bool or None\n",
      " |          capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          clip_box: `.Bbox`\n",
      " |          clip_on: bool\n",
      " |          clip_path: Patch or (Path, Transform) or None\n",
      " |          closed: bool\n",
      " |          color: color\n",
      " |          edgecolor or ec: color or None\n",
      " |          facecolor or fc: color or None\n",
      " |          figure: `.Figure`\n",
      " |          fill: bool\n",
      " |          gid: str\n",
      " |          hatch: {'/', '\\\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
      " |          in_layout: bool\n",
      " |          joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          label: object\n",
      " |          linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      " |          linewidth or lw: float or None\n",
      " |          path_effects: `.AbstractPathEffect`\n",
      " |          picker: None or bool or float or callable\n",
      " |          rasterized: bool\n",
      " |          sketch_params: (scale: float, length: float, randomness: float)\n",
      " |          snap: bool or None\n",
      " |          transform: `.Transform`\n",
      " |          url: str\n",
      " |          visible: bool\n",
      " |          xy: (N, 2) array-like\n",
      " |          zorder: float\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      axvspan : Add a vertical span across the Axes.\n",
      " |  \n",
      " |  axline(self, xy1, xy2=None, *, slope=None, **kwargs)\n",
      " |      Add an infinitely long straight line.\n",
      " |      \n",
      " |      The line can be defined either by two points *xy1* and *xy2*, or\n",
      " |      by one point *xy1* and a *slope*.\n",
      " |      \n",
      " |      This draws a straight line \"on the screen\", regardless of the x and y\n",
      " |      scales, and is thus also suitable for drawing exponential decays in\n",
      " |      semilog plots, power laws in loglog plots, etc. However, *slope*\n",
      " |      should only be used with linear scales; It has no clear meaning for\n",
      " |      all other scales, and thus the behavior is undefined. Please specify\n",
      " |      the line using the points *xy1*, *xy2* for non-linear scales.\n",
      " |      \n",
      " |      The *transform* keyword argument only applies to the points *xy1*,\n",
      " |      *xy2*. The *slope* (if given) is always in data coordinates. This can\n",
      " |      be used e.g. with ``ax.transAxes`` for drawing grid lines with a fixed\n",
      " |      slope.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      xy1, xy2 : (float, float)\n",
      " |          Points for the line to pass through.\n",
      " |          Either *xy2* or *slope* has to be given.\n",
      " |      slope : float, optional\n",
      " |          The slope of the line. Either *xy2* or *slope* has to be given.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `.Line2D`\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      **kwargs\n",
      " |          Valid kwargs are `.Line2D` properties\n",
      " |      \n",
      " |          Properties:\n",
      " |          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      " |          alpha: scalar or None\n",
      " |          animated: bool\n",
      " |          antialiased or aa: bool\n",
      " |          clip_box: `.Bbox`\n",
      " |          clip_on: bool\n",
      " |          clip_path: Patch or (Path, Transform) or None\n",
      " |          color or c: color\n",
      " |          dash_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          dash_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          dashes: sequence of floats (on/off ink in points) or (None, None)\n",
      " |          data: (2, N) array or two 1D arrays\n",
      " |          drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'\n",
      " |          figure: `.Figure`\n",
      " |          fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}\n",
      " |          gid: str\n",
      " |          in_layout: bool\n",
      " |          label: object\n",
      " |          linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      " |          linewidth or lw: float\n",
      " |          marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`\n",
      " |          markeredgecolor or mec: color\n",
      " |          markeredgewidth or mew: float\n",
      " |          markerfacecolor or mfc: color\n",
      " |          markerfacecoloralt or mfcalt: color\n",
      " |          markersize or ms: float\n",
      " |          markevery: None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]\n",
      " |          path_effects: `.AbstractPathEffect`\n",
      " |          picker: float or callable[[Artist, Event], tuple[bool, dict]]\n",
      " |          pickradius: float\n",
      " |          rasterized: bool\n",
      " |          sketch_params: (scale: float, length: float, randomness: float)\n",
      " |          snap: bool or None\n",
      " |          solid_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          solid_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          transform: unknown\n",
      " |          url: str\n",
      " |          visible: bool\n",
      " |          xdata: 1D array\n",
      " |          ydata: 1D array\n",
      " |          zorder: float\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      axhline : for horizontal lines\n",
      " |      axvline : for vertical lines\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      Draw a thick red line passing through (0, 0) and (1, 1)::\n",
      " |      \n",
      " |          >>> axline((0, 0), (1, 1), linewidth=4, color='r')\n",
      " |  \n",
      " |  axvline(self, x=0, ymin=0, ymax=1, **kwargs)\n",
      " |      Add a vertical line across the Axes.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      x : float, default: 0\n",
      " |          x position in data coordinates of the vertical line.\n",
      " |      \n",
      " |      ymin : float, default: 0\n",
      " |          Should be between 0 and 1, 0 being the bottom of the plot, 1 the\n",
      " |          top of the plot.\n",
      " |      \n",
      " |      ymax : float, default: 1\n",
      " |          Should be between 0 and 1, 0 being the bottom of the plot, 1 the\n",
      " |          top of the plot.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `~matplotlib.lines.Line2D`\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      **kwargs\n",
      " |          Valid keyword arguments are `.Line2D` properties, with the\n",
      " |          exception of 'transform':\n",
      " |      \n",
      " |          Properties:\n",
      " |          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      " |          alpha: scalar or None\n",
      " |          animated: bool\n",
      " |          antialiased or aa: bool\n",
      " |          clip_box: `.Bbox`\n",
      " |          clip_on: bool\n",
      " |          clip_path: Patch or (Path, Transform) or None\n",
      " |          color or c: color\n",
      " |          dash_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          dash_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          dashes: sequence of floats (on/off ink in points) or (None, None)\n",
      " |          data: (2, N) array or two 1D arrays\n",
      " |          drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'\n",
      " |          figure: `.Figure`\n",
      " |          fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}\n",
      " |          gid: str\n",
      " |          in_layout: bool\n",
      " |          label: object\n",
      " |          linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      " |          linewidth or lw: float\n",
      " |          marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`\n",
      " |          markeredgecolor or mec: color\n",
      " |          markeredgewidth or mew: float\n",
      " |          markerfacecolor or mfc: color\n",
      " |          markerfacecoloralt or mfcalt: color\n",
      " |          markersize or ms: float\n",
      " |          markevery: None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]\n",
      " |          path_effects: `.AbstractPathEffect`\n",
      " |          picker: float or callable[[Artist, Event], tuple[bool, dict]]\n",
      " |          pickradius: float\n",
      " |          rasterized: bool\n",
      " |          sketch_params: (scale: float, length: float, randomness: float)\n",
      " |          snap: bool or None\n",
      " |          solid_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          solid_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          transform: unknown\n",
      " |          url: str\n",
      " |          visible: bool\n",
      " |          xdata: 1D array\n",
      " |          ydata: 1D array\n",
      " |          zorder: float\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      vlines : Add vertical lines in data coordinates.\n",
      " |      axvspan : Add a vertical span (rectangle) across the axis.\n",
      " |      axline : Add a line with an arbitrary slope.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      * draw a thick red vline at *x* = 0 that spans the yrange::\n",
      " |      \n",
      " |          >>> axvline(linewidth=4, color='r')\n",
      " |      \n",
      " |      * draw a default vline at *x* = 1 that spans the yrange::\n",
      " |      \n",
      " |          >>> axvline(x=1)\n",
      " |      \n",
      " |      * draw a default vline at *x* = .5 that spans the middle half of\n",
      " |        the yrange::\n",
      " |      \n",
      " |          >>> axvline(x=.5, ymin=0.25, ymax=0.75)\n",
      " |  \n",
      " |  axvspan(self, xmin, xmax, ymin=0, ymax=1, **kwargs)\n",
      " |      Add a vertical span (rectangle) across the Axes.\n",
      " |      \n",
      " |      The rectangle spans from *xmin* to *xmax* horizontally, and, by\n",
      " |      default, the whole y-axis vertically.  The y-span can be set using\n",
      " |      *ymin* (default: 0) and *ymax* (default: 1) which are in axis units;\n",
      " |      e.g. ``ymin = 0.5`` always refers to the middle of the y-axis\n",
      " |      regardless of the limits set by `~.Axes.set_ylim`.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      xmin : float\n",
      " |          Lower x-coordinate of the span, in data units.\n",
      " |      xmax : float\n",
      " |          Upper x-coordinate of the span, in data units.\n",
      " |      ymin : float, default: 0\n",
      " |          Lower y-coordinate of the span, in y-axis units (0-1).\n",
      " |      ymax : float, default: 1\n",
      " |          Upper y-coordinate of the span, in y-axis units (0-1).\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `~matplotlib.patches.Polygon`\n",
      " |          Vertical span (rectangle) from (xmin, ymin) to (xmax, ymax).\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      **kwargs : `~matplotlib.patches.Polygon` properties\n",
      " |      \n",
      " |      Properties:\n",
      " |          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      " |          alpha: scalar or None\n",
      " |          animated: bool\n",
      " |          antialiased or aa: bool or None\n",
      " |          capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          clip_box: `.Bbox`\n",
      " |          clip_on: bool\n",
      " |          clip_path: Patch or (Path, Transform) or None\n",
      " |          closed: bool\n",
      " |          color: color\n",
      " |          edgecolor or ec: color or None\n",
      " |          facecolor or fc: color or None\n",
      " |          figure: `.Figure`\n",
      " |          fill: bool\n",
      " |          gid: str\n",
      " |          hatch: {'/', '\\\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
      " |          in_layout: bool\n",
      " |          joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          label: object\n",
      " |          linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      " |          linewidth or lw: float or None\n",
      " |          path_effects: `.AbstractPathEffect`\n",
      " |          picker: None or bool or float or callable\n",
      " |          rasterized: bool\n",
      " |          sketch_params: (scale: float, length: float, randomness: float)\n",
      " |          snap: bool or None\n",
      " |          transform: `.Transform`\n",
      " |          url: str\n",
      " |          visible: bool\n",
      " |          xy: (N, 2) array-like\n",
      " |          zorder: float\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      axhspan : Add a horizontal span across the Axes.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      Draw a vertical, green, translucent rectangle from x = 1.25 to\n",
      " |      x = 1.55 that spans the yrange of the Axes.\n",
      " |      \n",
      " |      >>> axvspan(1.25, 1.55, facecolor='g', alpha=0.5)\n",
      " |  \n",
      " |  bar(self, x, height, width=0.8, bottom=None, *, align='center', data=None, **kwargs)\n",
      " |      Make a bar plot.\n",
      " |      \n",
      " |      The bars are positioned at *x* with the given *align*\\ment. Their\n",
      " |      dimensions are given by *height* and *width*. The vertical baseline\n",
      " |      is *bottom* (default 0).\n",
      " |      \n",
      " |      Many parameters can take either a single value applying to all bars\n",
      " |      or a sequence of values, one for each bar.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      x : float or array-like\n",
      " |          The x coordinates of the bars. See also *align* for the\n",
      " |          alignment of the bars to the coordinates.\n",
      " |      \n",
      " |      height : float or array-like\n",
      " |          The height(s) of the bars.\n",
      " |      \n",
      " |      width : float or array-like, default: 0.8\n",
      " |          The width(s) of the bars.\n",
      " |      \n",
      " |      bottom : float or array-like, default: 0\n",
      " |          The y coordinate(s) of the bars bases.\n",
      " |      \n",
      " |      align : {'center', 'edge'}, default: 'center'\n",
      " |          Alignment of the bars to the *x* coordinates:\n",
      " |      \n",
      " |          - 'center': Center the base on the *x* positions.\n",
      " |          - 'edge': Align the left edges of the bars with the *x* positions.\n",
      " |      \n",
      " |          To align the bars on the right edge pass a negative *width* and\n",
      " |          ``align='edge'``.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `.BarContainer`\n",
      " |          Container with all the bars and optionally errorbars.\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      color : color or list of color, optional\n",
      " |          The colors of the bar faces.\n",
      " |      \n",
      " |      edgecolor : color or list of color, optional\n",
      " |          The colors of the bar edges.\n",
      " |      \n",
      " |      linewidth : float or array-like, optional\n",
      " |          Width of the bar edge(s). If 0, don't draw edges.\n",
      " |      \n",
      " |      tick_label : str or list of str, optional\n",
      " |          The tick labels of the bars.\n",
      " |          Default: None (Use default numeric labels.)\n",
      " |      \n",
      " |      xerr, yerr : float or array-like of shape(N,) or shape(2, N), optional\n",
      " |          If not *None*, add horizontal / vertical errorbars to the bar tips.\n",
      " |          The values are +/- sizes relative to the data:\n",
      " |      \n",
      " |          - scalar: symmetric +/- values for all bars\n",
      " |          - shape(N,): symmetric +/- values for each bar\n",
      " |          - shape(2, N): Separate - and + values for each bar. First row\n",
      " |            contains the lower errors, the second row contains the upper\n",
      " |            errors.\n",
      " |          - *None*: No errorbar. (Default)\n",
      " |      \n",
      " |          See :doc:`/gallery/statistics/errorbar_features`\n",
      " |          for an example on the usage of ``xerr`` and ``yerr``.\n",
      " |      \n",
      " |      ecolor : color or list of color, default: 'black'\n",
      " |          The line color of the errorbars.\n",
      " |      \n",
      " |      capsize : float, default: :rc:`errorbar.capsize`\n",
      " |         The length of the error bar caps in points.\n",
      " |      \n",
      " |      error_kw : dict, optional\n",
      " |          Dictionary of kwargs to be passed to the `~.Axes.errorbar`\n",
      " |          method. Values of *ecolor* or *capsize* defined here take\n",
      " |          precedence over the independent kwargs.\n",
      " |      \n",
      " |      log : bool, default: False\n",
      " |          If *True*, set the y-axis to be log scale.\n",
      " |      \n",
      " |      data : indexable object, optional\n",
      " |          If given, all parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception).\n",
      " |      \n",
      " |      **kwargs : `.Rectangle` properties\n",
      " |      \n",
      " |      Properties:\n",
      " |          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      " |          alpha: scalar or None\n",
      " |          angle: unknown\n",
      " |          animated: bool\n",
      " |          antialiased or aa: bool or None\n",
      " |          bounds: (left, bottom, width, height)\n",
      " |          capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          clip_box: `.Bbox`\n",
      " |          clip_on: bool\n",
      " |          clip_path: Patch or (Path, Transform) or None\n",
      " |          color: color\n",
      " |          edgecolor or ec: color or None\n",
      " |          facecolor or fc: color or None\n",
      " |          figure: `.Figure`\n",
      " |          fill: bool\n",
      " |          gid: str\n",
      " |          hatch: {'/', '\\\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
      " |          height: unknown\n",
      " |          in_layout: bool\n",
      " |          joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          label: object\n",
      " |          linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      " |          linewidth or lw: float or None\n",
      " |          path_effects: `.AbstractPathEffect`\n",
      " |          picker: None or bool or float or callable\n",
      " |          rasterized: bool\n",
      " |          sketch_params: (scale: float, length: float, randomness: float)\n",
      " |          snap: bool or None\n",
      " |          transform: `.Transform`\n",
      " |          url: str\n",
      " |          visible: bool\n",
      " |          width: unknown\n",
      " |          x: unknown\n",
      " |          xy: (float, float)\n",
      " |          y: unknown\n",
      " |          zorder: float\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      barh : Plot a horizontal bar plot.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      Stacked bars can be achieved by passing individual *bottom* values per\n",
      " |      bar. See :doc:`/gallery/lines_bars_and_markers/bar_stacked`.\n",
      " |  \n",
      " |  bar_label(self, container, labels=None, *, fmt='%g', label_type='edge', padding=0, **kwargs)\n",
      " |      Label a bar plot.\n",
      " |      \n",
      " |      Adds labels to bars in the given `.BarContainer`.\n",
      " |      You may need to adjust the axis limits to fit the labels.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      container : `.BarContainer`\n",
      " |          Container with all the bars and optionally errorbars, likely\n",
      " |          returned from `.bar` or `.barh`.\n",
      " |      \n",
      " |      labels : array-like, optional\n",
      " |          A list of label texts, that should be displayed. If not given, the\n",
      " |          label texts will be the data values formatted with *fmt*.\n",
      " |      \n",
      " |      fmt : str, default: '%g'\n",
      " |          A format string for the label.\n",
      " |      \n",
      " |      label_type : {'edge', 'center'}, default: 'edge'\n",
      " |          The label type. Possible values:\n",
      " |      \n",
      " |          - 'edge': label placed at the end-point of the bar segment, and the\n",
      " |            value displayed will be the position of that end-point.\n",
      " |          - 'center': label placed in the center of the bar segment, and the\n",
      " |            value displayed will be the length of that segment.\n",
      " |            (useful for stacked bars, i.e.,\n",
      " |            :doc:`/gallery/lines_bars_and_markers/bar_label_demo`)\n",
      " |      \n",
      " |      padding : float, default: 0\n",
      " |          Distance of label from the end of the bar, in points.\n",
      " |      \n",
      " |      **kwargs\n",
      " |          Any remaining keyword arguments are passed through to\n",
      " |          `.Axes.annotate`.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      list of `.Text`\n",
      " |          A list of `.Text` instances for the labels.\n",
      " |  \n",
      " |  barbs(self, *args, data=None, **kwargs)\n",
      " |      Plot a 2D field of barbs.\n",
      " |      \n",
      " |      Call signature::\n",
      " |      \n",
      " |        barbs([X, Y], U, V, [C], **kw)\n",
      " |      \n",
      " |      Where *X*, *Y* define the barb locations, *U*, *V* define the barb\n",
      " |      directions, and *C* optionally sets the color.\n",
      " |      \n",
      " |      All arguments may be 1D or 2D. *U*, *V*, *C* may be masked arrays, but masked\n",
      " |      *X*, *Y* are not supported at present.\n",
      " |      \n",
      " |      Barbs are traditionally used in meteorology as a way to plot the speed\n",
      " |      and direction of wind observations, but can technically be used to\n",
      " |      plot any two dimensional vector quantity.  As opposed to arrows, which\n",
      " |      give vector magnitude by the length of the arrow, the barbs give more\n",
      " |      quantitative information about the vector magnitude by putting slanted\n",
      " |      lines or a triangle for various increments in magnitude, as show\n",
      " |      schematically below::\n",
      " |      \n",
      " |        :                   /\\    \\\n",
      " |        :                  /  \\    \\\n",
      " |        :                 /    \\    \\    \\\n",
      " |        :                /      \\    \\    \\\n",
      " |        :               ------------------------------\n",
      " |      \n",
      " |      The largest increment is given by a triangle (or \"flag\"). After those\n",
      " |      come full lines (barbs). The smallest increment is a half line.  There\n",
      " |      is only, of course, ever at most 1 half line.  If the magnitude is\n",
      " |      small and only needs a single half-line and no full lines or\n",
      " |      triangles, the half-line is offset from the end of the barb so that it\n",
      " |      can be easily distinguished from barbs with a single full line.  The\n",
      " |      magnitude for the barb shown above would nominally be 65, using the\n",
      " |      standard increments of 50, 10, and 5.\n",
      " |      \n",
      " |      See also https://en.wikipedia.org/wiki/Wind_barb.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      X, Y : 1D or 2D array-like, optional\n",
      " |          The x and y coordinates of the barb locations. See *pivot* for how the\n",
      " |          barbs are drawn to the x, y positions.\n",
      " |      \n",
      " |          If not given, they will be generated as a uniform integer meshgrid based\n",
      " |          on the dimensions of *U* and *V*.\n",
      " |      \n",
      " |          If *X* and *Y* are 1D but *U*, *V* are 2D, *X*, *Y* are expanded to 2D\n",
      " |          using ``X, Y = np.meshgrid(X, Y)``. In this case ``len(X)`` and ``len(Y)``\n",
      " |          must match the column and row dimensions of *U* and *V*.\n",
      " |      \n",
      " |      U, V : 1D or 2D array-like\n",
      " |          The x and y components of the barb shaft.\n",
      " |      \n",
      " |      C : 1D or 2D array-like, optional\n",
      " |          Numeric data that defines the barb colors by colormapping via *norm* and\n",
      " |          *cmap*.\n",
      " |      \n",
      " |          This does not support explicit colors. If you want to set colors directly,\n",
      " |          use *barbcolor* instead.\n",
      " |      \n",
      " |      length : float, default: 7\n",
      " |          Length of the barb in points; the other parts of the barb\n",
      " |          are scaled against this.\n",
      " |      \n",
      " |      pivot : {'tip', 'middle'} or float, default: 'tip'\n",
      " |          The part of the arrow that is anchored to the *X*, *Y* grid. The barb\n",
      " |          rotates about this point. This can also be a number, which shifts the\n",
      " |          start of the barb that many points away from grid point.\n",
      " |      \n",
      " |      barbcolor : color or color sequence\n",
      " |          The color of all parts of the barb except for the flags.  This parameter\n",
      " |          is analogous to the *edgecolor* parameter for polygons, which can be used\n",
      " |          instead. However this parameter will override facecolor.\n",
      " |      \n",
      " |      flagcolor : color or color sequence\n",
      " |          The color of any flags on the barb.  This parameter is analogous to the\n",
      " |          *facecolor* parameter for polygons, which can be used instead. However,\n",
      " |          this parameter will override facecolor.  If this is not set (and *C* has\n",
      " |          not either) then *flagcolor* will be set to match *barbcolor* so that the\n",
      " |          barb has a uniform color. If *C* has been set, *flagcolor* has no effect.\n",
      " |      \n",
      " |      sizes : dict, optional\n",
      " |          A dictionary of coefficients specifying the ratio of a given\n",
      " |          feature to the length of the barb. Only those values one wishes to\n",
      " |          override need to be included.  These features include:\n",
      " |      \n",
      " |          - 'spacing' - space between features (flags, full/half barbs)\n",
      " |          - 'height' - height (distance from shaft to top) of a flag or full barb\n",
      " |          - 'width' - width of a flag, twice the width of a full barb\n",
      " |          - 'emptybarb' - radius of the circle used for low magnitudes\n",
      " |      \n",
      " |      fill_empty : bool, default: False\n",
      " |          Whether the empty barbs (circles) that are drawn should be filled with\n",
      " |          the flag color.  If they are not filled, the center is transparent.\n",
      " |      \n",
      " |      rounding : bool, default: True\n",
      " |          Whether the vector magnitude should be rounded when allocating barb\n",
      " |          components.  If True, the magnitude is rounded to the nearest multiple\n",
      " |          of the half-barb increment.  If False, the magnitude is simply truncated\n",
      " |          to the next lowest multiple.\n",
      " |      \n",
      " |      barb_increments : dict, optional\n",
      " |          A dictionary of increments specifying values to associate with\n",
      " |          different parts of the barb. Only those values one wishes to\n",
      " |          override need to be included.\n",
      " |      \n",
      " |          - 'half' - half barbs (Default is 5)\n",
      " |          - 'full' - full barbs (Default is 10)\n",
      " |          - 'flag' - flags (default is 50)\n",
      " |      \n",
      " |      flip_barb : bool or array-like of bool, default: False\n",
      " |          Whether the lines and flags should point opposite to normal.\n",
      " |          Normal behavior is for the barbs and lines to point right (comes from wind\n",
      " |          barbs having these features point towards low pressure in the Northern\n",
      " |          Hemisphere).\n",
      " |      \n",
      " |          A single value is applied to all barbs. Individual barbs can be flipped by\n",
      " |          passing a bool array of the same size as *U* and *V*.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      barbs : `~matplotlib.quiver.Barbs`\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      data : indexable object, optional\n",
      " |          If given, all parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception).\n",
      " |      \n",
      " |      **kwargs\n",
      " |          The barbs can further be customized using `.PolyCollection` keyword\n",
      " |          arguments:\n",
      " |      \n",
      " |          Properties:\n",
      " |          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      " |          alpha: array-like or scalar or None\n",
      " |          animated: bool\n",
      " |          antialiased or aa or antialiaseds: bool or list of bools\n",
      " |          array: array-like or None\n",
      " |          capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          clim: (vmin: float, vmax: float)\n",
      " |          clip_box: `.Bbox`\n",
      " |          clip_on: bool\n",
      " |          clip_path: Patch or (Path, Transform) or None\n",
      " |          cmap: `.Colormap` or str or None\n",
      " |          color: color or list of rgba tuples\n",
      " |          edgecolor or ec or edgecolors: color or list of colors or 'face'\n",
      " |          facecolor or facecolors or fc: color or list of colors\n",
      " |          figure: `.Figure`\n",
      " |          gid: str\n",
      " |          hatch: {'/', '\\\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
      " |          in_layout: bool\n",
      " |          joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          label: object\n",
      " |          linestyle or dashes or linestyles or ls: str or tuple or list thereof\n",
      " |          linewidth or linewidths or lw: float or list of floats\n",
      " |          norm: `.Normalize` or None\n",
      " |          offset_transform: `.Transform`\n",
      " |          offsets: (N, 2) or (2,) array-like\n",
      " |          path_effects: `.AbstractPathEffect`\n",
      " |          paths: list of array-like\n",
      " |          picker: None or bool or float or callable\n",
      " |          pickradius: float\n",
      " |          rasterized: bool\n",
      " |          sizes: ndarray or None\n",
      " |          sketch_params: (scale: float, length: float, randomness: float)\n",
      " |          snap: bool or None\n",
      " |          transform: `.Transform`\n",
      " |          url: str\n",
      " |          urls: list of str or None\n",
      " |          verts: list of array-like\n",
      " |          verts_and_codes: unknown\n",
      " |          visible: bool\n",
      " |          zorder: float\n",
      " |  \n",
      " |  barh(self, y, width, height=0.8, left=None, *, align='center', **kwargs)\n",
      " |      Make a horizontal bar plot.\n",
      " |      \n",
      " |      The bars are positioned at *y* with the given *align*\\ment. Their\n",
      " |      dimensions are given by *width* and *height*. The horizontal baseline\n",
      " |      is *left* (default 0).\n",
      " |      \n",
      " |      Many parameters can take either a single value applying to all bars\n",
      " |      or a sequence of values, one for each bar.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      y : float or array-like\n",
      " |          The y coordinates of the bars. See also *align* for the\n",
      " |          alignment of the bars to the coordinates.\n",
      " |      \n",
      " |      width : float or array-like\n",
      " |          The width(s) of the bars.\n",
      " |      \n",
      " |      height : float or array-like, default: 0.8\n",
      " |          The heights of the bars.\n",
      " |      \n",
      " |      left : float or array-like, default: 0\n",
      " |          The x coordinates of the left sides of the bars.\n",
      " |      \n",
      " |      align : {'center', 'edge'}, default: 'center'\n",
      " |          Alignment of the base to the *y* coordinates*:\n",
      " |      \n",
      " |          - 'center': Center the bars on the *y* positions.\n",
      " |          - 'edge': Align the bottom edges of the bars with the *y*\n",
      " |            positions.\n",
      " |      \n",
      " |          To align the bars on the top edge pass a negative *height* and\n",
      " |          ``align='edge'``.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `.BarContainer`\n",
      " |          Container with all the bars and optionally errorbars.\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      color : color or list of color, optional\n",
      " |          The colors of the bar faces.\n",
      " |      \n",
      " |      edgecolor : color or list of color, optional\n",
      " |          The colors of the bar edges.\n",
      " |      \n",
      " |      linewidth : float or array-like, optional\n",
      " |          Width of the bar edge(s). If 0, don't draw edges.\n",
      " |      \n",
      " |      tick_label : str or list of str, optional\n",
      " |          The tick labels of the bars.\n",
      " |          Default: None (Use default numeric labels.)\n",
      " |      \n",
      " |      xerr, yerr : float or array-like of shape(N,) or shape(2, N), optional\n",
      " |          If not ``None``, add horizontal / vertical errorbars to the\n",
      " |          bar tips. The values are +/- sizes relative to the data:\n",
      " |      \n",
      " |          - scalar: symmetric +/- values for all bars\n",
      " |          - shape(N,): symmetric +/- values for each bar\n",
      " |          - shape(2, N): Separate - and + values for each bar. First row\n",
      " |            contains the lower errors, the second row contains the upper\n",
      " |            errors.\n",
      " |          - *None*: No errorbar. (default)\n",
      " |      \n",
      " |          See :doc:`/gallery/statistics/errorbar_features`\n",
      " |          for an example on the usage of ``xerr`` and ``yerr``.\n",
      " |      \n",
      " |      ecolor : color or list of color, default: 'black'\n",
      " |          The line color of the errorbars.\n",
      " |      \n",
      " |      capsize : float, default: :rc:`errorbar.capsize`\n",
      " |         The length of the error bar caps in points.\n",
      " |      \n",
      " |      error_kw : dict, optional\n",
      " |          Dictionary of kwargs to be passed to the `~.Axes.errorbar`\n",
      " |          method. Values of *ecolor* or *capsize* defined here take\n",
      " |          precedence over the independent kwargs.\n",
      " |      \n",
      " |      log : bool, default: False\n",
      " |          If ``True``, set the x-axis to be log scale.\n",
      " |      \n",
      " |      **kwargs : `.Rectangle` properties\n",
      " |      \n",
      " |      Properties:\n",
      " |          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      " |          alpha: scalar or None\n",
      " |          angle: unknown\n",
      " |          animated: bool\n",
      " |          antialiased or aa: bool or None\n",
      " |          bounds: (left, bottom, width, height)\n",
      " |          capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          clip_box: `.Bbox`\n",
      " |          clip_on: bool\n",
      " |          clip_path: Patch or (Path, Transform) or None\n",
      " |          color: color\n",
      " |          edgecolor or ec: color or None\n",
      " |          facecolor or fc: color or None\n",
      " |          figure: `.Figure`\n",
      " |          fill: bool\n",
      " |          gid: str\n",
      " |          hatch: {'/', '\\\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
      " |          height: unknown\n",
      " |          in_layout: bool\n",
      " |          joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          label: object\n",
      " |          linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      " |          linewidth or lw: float or None\n",
      " |          path_effects: `.AbstractPathEffect`\n",
      " |          picker: None or bool or float or callable\n",
      " |          rasterized: bool\n",
      " |          sketch_params: (scale: float, length: float, randomness: float)\n",
      " |          snap: bool or None\n",
      " |          transform: `.Transform`\n",
      " |          url: str\n",
      " |          visible: bool\n",
      " |          width: unknown\n",
      " |          x: unknown\n",
      " |          xy: (float, float)\n",
      " |          y: unknown\n",
      " |          zorder: float\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      bar : Plot a vertical bar plot.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      Stacked bars can be achieved by passing individual *left* values per\n",
      " |      bar. See\n",
      " |      :doc:`/gallery/lines_bars_and_markers/horizontal_barchart_distribution`\n",
      " |      .\n",
      " |  \n",
      " |  boxplot(self, x, notch=None, sym=None, vert=None, whis=None, positions=None, widths=None, patch_artist=None, bootstrap=None, usermedians=None, conf_intervals=None, meanline=None, showmeans=None, showcaps=None, showbox=None, showfliers=None, boxprops=None, labels=None, flierprops=None, medianprops=None, meanprops=None, capprops=None, whiskerprops=None, manage_ticks=True, autorange=False, zorder=None, *, data=None)\n",
      " |      Draw a box and whisker plot.\n",
      " |      \n",
      " |      The box extends from the first quartile (Q1) to the third\n",
      " |      quartile (Q3) of the data, with a line at the median.  The\n",
      " |      whiskers extend from the box by 1.5x the inter-quartile range\n",
      " |      (IQR).  Flier points are those past the end of the whiskers.\n",
      " |      See https://en.wikipedia.org/wiki/Box_plot for reference.\n",
      " |      \n",
      " |      .. code-block:: none\n",
      " |      \n",
      " |                Q1-1.5IQR   Q1   median  Q3   Q3+1.5IQR\n",
      " |                             |-----:-----|\n",
      " |             o      |--------|     :     |--------|    o  o\n",
      " |                             |-----:-----|\n",
      " |           flier             <----------->            fliers\n",
      " |                                  IQR\n",
      " |      \n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      x : Array or a sequence of vectors.\n",
      " |          The input data.  If a 2D array, a boxplot is drawn for each column\n",
      " |          in *x*.  If a sequence of 1D arrays, a boxplot is drawn for each\n",
      " |          array in *x*.\n",
      " |      \n",
      " |      notch : bool, default: False\n",
      " |          Whether to draw a notched boxplot (`True`), or a rectangular\n",
      " |          boxplot (`False`).  The notches represent the confidence interval\n",
      " |          (CI) around the median.  The documentation for *bootstrap*\n",
      " |          describes how the locations of the notches are computed by\n",
      " |          default, but their locations may also be overridden by setting the\n",
      " |          *conf_intervals* parameter.\n",
      " |      \n",
      " |          .. note::\n",
      " |      \n",
      " |              In cases where the values of the CI are less than the\n",
      " |              lower quartile or greater than the upper quartile, the\n",
      " |              notches will extend beyond the box, giving it a\n",
      " |              distinctive \"flipped\" appearance. This is expected\n",
      " |              behavior and consistent with other statistical\n",
      " |              visualization packages.\n",
      " |      \n",
      " |      sym : str, optional\n",
      " |          The default symbol for flier points.  An empty string ('') hides\n",
      " |          the fliers.  If `None`, then the fliers default to 'b+'.  More\n",
      " |          control is provided by the *flierprops* parameter.\n",
      " |      \n",
      " |      vert : bool, default: True\n",
      " |          If `True`, draws vertical boxes.\n",
      " |          If `False`, draw horizontal boxes.\n",
      " |      \n",
      " |      whis : float or (float, float), default: 1.5\n",
      " |          The position of the whiskers.\n",
      " |      \n",
      " |          If a float, the lower whisker is at the lowest datum above\n",
      " |          ``Q1 - whis*(Q3-Q1)``, and the upper whisker at the highest datum\n",
      " |          below ``Q3 + whis*(Q3-Q1)``, where Q1 and Q3 are the first and\n",
      " |          third quartiles.  The default value of ``whis = 1.5`` corresponds\n",
      " |          to Tukey's original definition of boxplots.\n",
      " |      \n",
      " |          If a pair of floats, they indicate the percentiles at which to\n",
      " |          draw the whiskers (e.g., (5, 95)).  In particular, setting this to\n",
      " |          (0, 100) results in whiskers covering the whole range of the data.\n",
      " |      \n",
      " |          In the edge case where ``Q1 == Q3``, *whis* is automatically set\n",
      " |          to (0, 100) (cover the whole range of the data) if *autorange* is\n",
      " |          True.\n",
      " |      \n",
      " |          Beyond the whiskers, data are considered outliers and are plotted\n",
      " |          as individual points.\n",
      " |      \n",
      " |      bootstrap : int, optional\n",
      " |          Specifies whether to bootstrap the confidence intervals\n",
      " |          around the median for notched boxplots. If *bootstrap* is\n",
      " |          None, no bootstrapping is performed, and notches are\n",
      " |          calculated using a Gaussian-based asymptotic approximation\n",
      " |          (see McGill, R., Tukey, J.W., and Larsen, W.A., 1978, and\n",
      " |          Kendall and Stuart, 1967). Otherwise, bootstrap specifies\n",
      " |          the number of times to bootstrap the median to determine its\n",
      " |          95% confidence intervals. Values between 1000 and 10000 are\n",
      " |          recommended.\n",
      " |      \n",
      " |      usermedians : 1D array-like, optional\n",
      " |          A 1D array-like of length ``len(x)``.  Each entry that is not\n",
      " |          `None` forces the value of the median for the corresponding\n",
      " |          dataset.  For entries that are `None`, the medians are computed\n",
      " |          by Matplotlib as normal.\n",
      " |      \n",
      " |      conf_intervals : array-like, optional\n",
      " |          A 2D array-like of shape ``(len(x), 2)``.  Each entry that is not\n",
      " |          None forces the location of the corresponding notch (which is\n",
      " |          only drawn if *notch* is `True`).  For entries that are `None`,\n",
      " |          the notches are computed by the method specified by the other\n",
      " |          parameters (e.g., *bootstrap*).\n",
      " |      \n",
      " |      positions : array-like, optional\n",
      " |          The positions of the boxes. The ticks and limits are\n",
      " |          automatically set to match the positions. Defaults to\n",
      " |          ``range(1, N+1)`` where N is the number of boxes to be drawn.\n",
      " |      \n",
      " |      widths : float or array-like\n",
      " |          The widths of the boxes.  The default is 0.5, or ``0.15*(distance\n",
      " |          between extreme positions)``, if that is smaller.\n",
      " |      \n",
      " |      patch_artist : bool, default: False\n",
      " |          If `False` produces boxes with the Line2D artist. Otherwise,\n",
      " |          boxes are drawn with Patch artists.\n",
      " |      \n",
      " |      labels : sequence, optional\n",
      " |          Labels for each dataset (one per dataset).\n",
      " |      \n",
      " |      manage_ticks : bool, default: True\n",
      " |          If True, the tick locations and labels will be adjusted to match\n",
      " |          the boxplot positions.\n",
      " |      \n",
      " |      autorange : bool, default: False\n",
      " |          When `True` and the data are distributed such that the 25th and\n",
      " |          75th percentiles are equal, *whis* is set to (0, 100) such\n",
      " |          that the whisker ends are at the minimum and maximum of the data.\n",
      " |      \n",
      " |      meanline : bool, default: False\n",
      " |          If `True` (and *showmeans* is `True`), will try to render the\n",
      " |          mean as a line spanning the full width of the box according to\n",
      " |          *meanprops* (see below).  Not recommended if *shownotches* is also\n",
      " |          True.  Otherwise, means will be shown as points.\n",
      " |      \n",
      " |      zorder : float, default: ``Line2D.zorder = 2``\n",
      " |          The zorder of the boxplot.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      dict\n",
      " |        A dictionary mapping each component of the boxplot to a list\n",
      " |        of the `.Line2D` instances created. That dictionary has the\n",
      " |        following keys (assuming vertical boxplots):\n",
      " |      \n",
      " |        - ``boxes``: the main body of the boxplot showing the\n",
      " |          quartiles and the median's confidence intervals if\n",
      " |          enabled.\n",
      " |      \n",
      " |        - ``medians``: horizontal lines at the median of each box.\n",
      " |      \n",
      " |        - ``whiskers``: the vertical lines extending to the most\n",
      " |          extreme, non-outlier data points.\n",
      " |      \n",
      " |        - ``caps``: the horizontal lines at the ends of the\n",
      " |          whiskers.\n",
      " |      \n",
      " |        - ``fliers``: points representing data that extend beyond\n",
      " |          the whiskers (fliers).\n",
      " |      \n",
      " |        - ``means``: points or lines representing the means.\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      showcaps : bool, default: True\n",
      " |          Show the caps on the ends of whiskers.\n",
      " |      showbox : bool, default: True\n",
      " |          Show the central box.\n",
      " |      showfliers : bool, default: True\n",
      " |          Show the outliers beyond the caps.\n",
      " |      showmeans : bool, default: False\n",
      " |          Show the arithmetic means.\n",
      " |      capprops : dict, default: None\n",
      " |          The style of the caps.\n",
      " |      boxprops : dict, default: None\n",
      " |          The style of the box.\n",
      " |      whiskerprops : dict, default: None\n",
      " |          The style of the whiskers.\n",
      " |      flierprops : dict, default: None\n",
      " |          The style of the fliers.\n",
      " |      medianprops : dict, default: None\n",
      " |          The style of the median.\n",
      " |      meanprops : dict, default: None\n",
      " |          The style of the mean.\n",
      " |      data : indexable object, optional\n",
      " |          If given, all parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception).\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      violinplot : Draw an estimate of the probability density function.\n",
      " |  \n",
      " |  broken_barh(self, xranges, yrange, *, data=None, **kwargs)\n",
      " |      Plot a horizontal sequence of rectangles.\n",
      " |      \n",
      " |      A rectangle is drawn for each element of *xranges*. All rectangles\n",
      " |      have the same vertical position and size defined by *yrange*.\n",
      " |      \n",
      " |      This is a convenience function for instantiating a\n",
      " |      `.BrokenBarHCollection`, adding it to the Axes and autoscaling the\n",
      " |      view.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      xranges : sequence of tuples (*xmin*, *xwidth*)\n",
      " |          The x-positions and extends of the rectangles. For each tuple\n",
      " |          (*xmin*, *xwidth*) a rectangle is drawn from *xmin* to *xmin* +\n",
      " |          *xwidth*.\n",
      " |      yrange : (*ymin*, *yheight*)\n",
      " |          The y-position and extend for all the rectangles.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `~.collections.BrokenBarHCollection`\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      data : indexable object, optional\n",
      " |          If given, all parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception).\n",
      " |      **kwargs : `.BrokenBarHCollection` properties\n",
      " |      \n",
      " |          Each *kwarg* can be either a single argument applying to all\n",
      " |          rectangles, e.g.::\n",
      " |      \n",
      " |              facecolors='black'\n",
      " |      \n",
      " |          or a sequence of arguments over which is cycled, e.g.::\n",
      " |      \n",
      " |              facecolors=('black', 'blue')\n",
      " |      \n",
      " |          would create interleaving black and blue rectangles.\n",
      " |      \n",
      " |          Supported keywords:\n",
      " |      \n",
      " |          Properties:\n",
      " |          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      " |          alpha: array-like or scalar or None\n",
      " |          animated: bool\n",
      " |          antialiased or aa or antialiaseds: bool or list of bools\n",
      " |          array: array-like or None\n",
      " |          capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          clim: (vmin: float, vmax: float)\n",
      " |          clip_box: `.Bbox`\n",
      " |          clip_on: bool\n",
      " |          clip_path: Patch or (Path, Transform) or None\n",
      " |          cmap: `.Colormap` or str or None\n",
      " |          color: color or list of rgba tuples\n",
      " |          edgecolor or ec or edgecolors: color or list of colors or 'face'\n",
      " |          facecolor or facecolors or fc: color or list of colors\n",
      " |          figure: `.Figure`\n",
      " |          gid: str\n",
      " |          hatch: {'/', '\\\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
      " |          in_layout: bool\n",
      " |          joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          label: object\n",
      " |          linestyle or dashes or linestyles or ls: str or tuple or list thereof\n",
      " |          linewidth or linewidths or lw: float or list of floats\n",
      " |          norm: `.Normalize` or None\n",
      " |          offset_transform: `.Transform`\n",
      " |          offsets: (N, 2) or (2,) array-like\n",
      " |          path_effects: `.AbstractPathEffect`\n",
      " |          paths: list of array-like\n",
      " |          picker: None or bool or float or callable\n",
      " |          pickradius: float\n",
      " |          rasterized: bool\n",
      " |          sizes: ndarray or None\n",
      " |          sketch_params: (scale: float, length: float, randomness: float)\n",
      " |          snap: bool or None\n",
      " |          transform: `.Transform`\n",
      " |          url: str\n",
      " |          urls: list of str or None\n",
      " |          verts: list of array-like\n",
      " |          verts_and_codes: unknown\n",
      " |          visible: bool\n",
      " |          zorder: float\n",
      " |  \n",
      " |  bxp(self, bxpstats, positions=None, widths=None, vert=True, patch_artist=False, shownotches=False, showmeans=False, showcaps=True, showbox=True, showfliers=True, boxprops=None, whiskerprops=None, flierprops=None, medianprops=None, capprops=None, meanprops=None, meanline=False, manage_ticks=True, zorder=None)\n",
      " |      Drawing function for box and whisker plots.\n",
      " |      \n",
      " |      Make a box and whisker plot for each column of *x* or each\n",
      " |      vector in sequence *x*.  The box extends from the lower to\n",
      " |      upper quartile values of the data, with a line at the median.\n",
      " |      The whiskers extend from the box to show the range of the\n",
      " |      data.  Flier points are those past the end of the whiskers.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      bxpstats : list of dicts\n",
      " |        A list of dictionaries containing stats for each boxplot.\n",
      " |        Required keys are:\n",
      " |      \n",
      " |        - ``med``: Median (scalar).\n",
      " |        - ``q1``, ``q3``: First & third quartiles (scalars).\n",
      " |        - ``whislo``, ``whishi``: Lower & upper whisker positions (scalars).\n",
      " |      \n",
      " |        Optional keys are:\n",
      " |      \n",
      " |        - ``mean``: Mean (scalar).  Needed if ``showmeans=True``.\n",
      " |        - ``fliers``: Data beyond the whiskers (array-like).\n",
      " |          Needed if ``showfliers=True``.\n",
      " |        - ``cilo``, ``cihi``: Lower & upper confidence intervals\n",
      " |          about the median. Needed if ``shownotches=True``.\n",
      " |        - ``label``: Name of the dataset (str).  If available,\n",
      " |          this will be used a tick label for the boxplot\n",
      " |      \n",
      " |      positions : array-like, default: [1, 2, ..., n]\n",
      " |        The positions of the boxes. The ticks and limits\n",
      " |        are automatically set to match the positions.\n",
      " |      \n",
      " |      widths : float or array-like, default: None\n",
      " |        The widths of the boxes.  The default is\n",
      " |        ``clip(0.15*(distance between extreme positions), 0.15, 0.5)``.\n",
      " |      \n",
      " |      vert : bool, default: True\n",
      " |        If `True` (default), makes the boxes vertical.\n",
      " |        If `False`, makes horizontal boxes.\n",
      " |      \n",
      " |      patch_artist : bool, default: False\n",
      " |        If `False` produces boxes with the `.Line2D` artist.\n",
      " |        If `True` produces boxes with the `~matplotlib.patches.Patch` artist.\n",
      " |      \n",
      " |      shownotches, showmeans, showcaps, showbox, showfliers : bool\n",
      " |        Whether to draw the CI notches, the mean value (both default to\n",
      " |        False), the caps, the box, and the fliers (all three default to\n",
      " |        True).\n",
      " |      \n",
      " |      boxprops, whiskerprops, capprops, flierprops, medianprops, meanprops : dict, optional\n",
      " |        Artist properties for the boxes, whiskers, caps, fliers, medians, and\n",
      " |        means.\n",
      " |      \n",
      " |      meanline : bool, default: False\n",
      " |        If `True` (and *showmeans* is `True`), will try to render the mean\n",
      " |        as a line spanning the full width of the box according to\n",
      " |        *meanprops*. Not recommended if *shownotches* is also True.\n",
      " |        Otherwise, means will be shown as points.\n",
      " |      \n",
      " |      manage_ticks : bool, default: True\n",
      " |        If True, the tick locations and labels will be adjusted to match the\n",
      " |        boxplot positions.\n",
      " |      \n",
      " |      zorder : float, default: ``Line2D.zorder = 2``\n",
      " |        The zorder of the resulting boxplot.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      dict\n",
      " |        A dictionary mapping each component of the boxplot to a list\n",
      " |        of the `.Line2D` instances created. That dictionary has the\n",
      " |        following keys (assuming vertical boxplots):\n",
      " |      \n",
      " |        - ``boxes``: main bodies of the boxplot showing the quartiles, and\n",
      " |          the median's confidence intervals if enabled.\n",
      " |        - ``medians``: horizontal lines at the median of each box.\n",
      " |        - ``whiskers``: vertical lines up to the last non-outlier data.\n",
      " |        - ``caps``: horizontal lines at the ends of the whiskers.\n",
      " |        - ``fliers``: points representing data beyond the whiskers (fliers).\n",
      " |        - ``means``: points or lines representing the means.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      .. plot:: gallery/statistics/bxp.py\n",
      " |  \n",
      " |  clabel(self, CS, levels=None, **kwargs)\n",
      " |      Label a contour plot.\n",
      " |      \n",
      " |      Adds labels to line contours in given `.ContourSet`.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      CS : `.ContourSet` instance\n",
      " |          Line contours to label.\n",
      " |      \n",
      " |      levels : array-like, optional\n",
      " |          A list of level values, that should be labeled. The list must be\n",
      " |          a subset of ``CS.levels``. If not given, all levels are labeled.\n",
      " |      \n",
      " |      **kwargs\n",
      " |          All other parameters are documented in `~.ContourLabeler.clabel`.\n",
      " |  \n",
      " |  cohere(self, x, y, NFFT=256, Fs=2, Fc=0, detrend=<function detrend_none at 0x7f6f2b6afee0>, window=<function window_hanning at 0x7f6f2b6afaf0>, noverlap=0, pad_to=None, sides='default', scale_by_freq=None, *, data=None, **kwargs)\n",
      " |      Plot the coherence between *x* and *y*.\n",
      " |      \n",
      " |      Plot the coherence between *x* and *y*.  Coherence is the\n",
      " |      normalized cross spectral density:\n",
      " |      \n",
      " |      .. math::\n",
      " |      \n",
      " |        C_{xy} = \\frac{|P_{xy}|^2}{P_{xx}P_{yy}}\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      Fs : float, default: 2\n",
      " |          The sampling frequency (samples per time unit).  It is used to calculate\n",
      " |          the Fourier frequencies, *freqs*, in cycles per time unit.\n",
      " |      \n",
      " |      window : callable or ndarray, default: `.window_hanning`\n",
      " |          A function or a vector of length *NFFT*.  To create window vectors see\n",
      " |          `.window_hanning`, `.window_none`, `numpy.blackman`, `numpy.hamming`,\n",
      " |          `numpy.bartlett`, `scipy.signal`, `scipy.signal.get_window`, etc.  If a\n",
      " |          function is passed as the argument, it must take a data segment as an\n",
      " |          argument and return the windowed version of the segment.\n",
      " |      \n",
      " |      sides : {'default', 'onesided', 'twosided'}, optional\n",
      " |          Which sides of the spectrum to return. 'default' is one-sided for real\n",
      " |          data and two-sided for complex data. 'onesided' forces the return of a\n",
      " |          one-sided spectrum, while 'twosided' forces two-sided.\n",
      " |      \n",
      " |      pad_to : int, optional\n",
      " |          The number of points to which the data segment is padded when performing\n",
      " |          the FFT.  This can be different from *NFFT*, which specifies the number\n",
      " |          of data points used.  While not increasing the actual resolution of the\n",
      " |          spectrum (the minimum distance between resolvable peaks), this can give\n",
      " |          more points in the plot, allowing for more detail. This corresponds to\n",
      " |          the *n* parameter in the call to fft(). The default is None, which sets\n",
      " |          *pad_to* equal to *NFFT*\n",
      " |      \n",
      " |      NFFT : int, default: 256\n",
      " |          The number of data points used in each block for the FFT.  A power 2 is\n",
      " |          most efficient.  This should *NOT* be used to get zero padding, or the\n",
      " |          scaling of the result will be incorrect; use *pad_to* for this instead.\n",
      " |      \n",
      " |      detrend : {'none', 'mean', 'linear'} or callable, default: 'none'\n",
      " |          The function applied to each segment before fft-ing, designed to remove\n",
      " |          the mean or linear trend.  Unlike in MATLAB, where the *detrend* parameter\n",
      " |          is a vector, in Matplotlib it is a function.  The :mod:`~matplotlib.mlab`\n",
      " |          module defines `.detrend_none`, `.detrend_mean`, and `.detrend_linear`,\n",
      " |          but you can use a custom function as well.  You can also use a string to\n",
      " |          choose one of the functions: 'none' calls `.detrend_none`. 'mean' calls\n",
      " |          `.detrend_mean`. 'linear' calls `.detrend_linear`.\n",
      " |      \n",
      " |      scale_by_freq : bool, default: True\n",
      " |          Whether the resulting density values should be scaled by the scaling\n",
      " |          frequency, which gives density in units of Hz^-1.  This allows for\n",
      " |          integration over the returned frequency values.  The default is True for\n",
      " |          MATLAB compatibility.\n",
      " |      \n",
      " |      noverlap : int, default: 0 (no overlap)\n",
      " |          The number of points of overlap between blocks.\n",
      " |      \n",
      " |      Fc : int, default: 0\n",
      " |          The center frequency of *x*, which offsets the x extents of the\n",
      " |          plot to reflect the frequency range used when a signal is acquired\n",
      " |          and then filtered and downsampled to baseband.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Cxy : 1-D array\n",
      " |          The coherence vector.\n",
      " |      \n",
      " |      freqs : 1-D array\n",
      " |          The frequencies for the elements in *Cxy*.\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      data : indexable object, optional\n",
      " |          If given, the following parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception):\n",
      " |      \n",
      " |          *x*, *y*\n",
      " |      \n",
      " |      **kwargs\n",
      " |          Keyword arguments control the `.Line2D` properties:\n",
      " |      \n",
      " |          Properties:\n",
      " |          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      " |          alpha: scalar or None\n",
      " |          animated: bool\n",
      " |          antialiased or aa: bool\n",
      " |          clip_box: `.Bbox`\n",
      " |          clip_on: bool\n",
      " |          clip_path: Patch or (Path, Transform) or None\n",
      " |          color or c: color\n",
      " |          dash_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          dash_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          dashes: sequence of floats (on/off ink in points) or (None, None)\n",
      " |          data: (2, N) array or two 1D arrays\n",
      " |          drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'\n",
      " |          figure: `.Figure`\n",
      " |          fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}\n",
      " |          gid: str\n",
      " |          in_layout: bool\n",
      " |          label: object\n",
      " |          linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      " |          linewidth or lw: float\n",
      " |          marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`\n",
      " |          markeredgecolor or mec: color\n",
      " |          markeredgewidth or mew: float\n",
      " |          markerfacecolor or mfc: color\n",
      " |          markerfacecoloralt or mfcalt: color\n",
      " |          markersize or ms: float\n",
      " |          markevery: None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]\n",
      " |          path_effects: `.AbstractPathEffect`\n",
      " |          picker: float or callable[[Artist, Event], tuple[bool, dict]]\n",
      " |          pickradius: float\n",
      " |          rasterized: bool\n",
      " |          sketch_params: (scale: float, length: float, randomness: float)\n",
      " |          snap: bool or None\n",
      " |          solid_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          solid_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          transform: unknown\n",
      " |          url: str\n",
      " |          visible: bool\n",
      " |          xdata: 1D array\n",
      " |          ydata: 1D array\n",
      " |          zorder: float\n",
      " |      \n",
      " |      References\n",
      " |      ----------\n",
      " |      Bendat & Piersol -- Random Data: Analysis and Measurement Procedures,\n",
      " |      John Wiley & Sons (1986)\n",
      " |  \n",
      " |  contour(self, *args, data=None, **kwargs)\n",
      " |      Plot contour lines.\n",
      " |      \n",
      " |      Call signature::\n",
      " |      \n",
      " |          contour([X, Y,] Z, [levels], **kwargs)\n",
      " |      \n",
      " |      `.contour` and `.contourf` draw contour lines and filled contours,\n",
      " |      respectively.  Except as noted, function signatures and return values\n",
      " |      are the same for both versions.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      X, Y : array-like, optional\n",
      " |          The coordinates of the values in *Z*.\n",
      " |      \n",
      " |          *X* and *Y* must both be 2D with the same shape as *Z* (e.g.\n",
      " |          created via `numpy.meshgrid`), or they must both be 1-D such\n",
      " |          that ``len(X) == N`` is the number of columns in *Z* and\n",
      " |          ``len(Y) == M`` is the number of rows in *Z*.\n",
      " |      \n",
      " |          *X* and *Y* must both be ordered monotonically.\n",
      " |      \n",
      " |          If not given, they are assumed to be integer indices, i.e.\n",
      " |          ``X = range(N)``, ``Y = range(M)``.\n",
      " |      \n",
      " |      Z : (M, N) array-like\n",
      " |          The height values over which the contour is drawn.\n",
      " |      \n",
      " |      levels : int or array-like, optional\n",
      " |          Determines the number and positions of the contour lines / regions.\n",
      " |      \n",
      " |          If an int *n*, use `~matplotlib.ticker.MaxNLocator`, which tries\n",
      " |          to automatically choose no more than *n+1* \"nice\" contour levels\n",
      " |          between *vmin* and *vmax*.\n",
      " |      \n",
      " |          If array-like, draw contour lines at the specified levels.\n",
      " |          The values must be in increasing order.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `~.contour.QuadContourSet`\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      corner_mask : bool, default: :rc:`contour.corner_mask`\n",
      " |          Enable/disable corner masking, which only has an effect if *Z* is\n",
      " |          a masked array.  If ``False``, any quad touching a masked point is\n",
      " |          masked out.  If ``True``, only the triangular corners of quads\n",
      " |          nearest those points are always masked out, other triangular\n",
      " |          corners comprising three unmasked points are contoured as usual.\n",
      " |      \n",
      " |      colors : color string or sequence of colors, optional\n",
      " |          The colors of the levels, i.e. the lines for `.contour` and the\n",
      " |          areas for `.contourf`.\n",
      " |      \n",
      " |          The sequence is cycled for the levels in ascending order. If the\n",
      " |          sequence is shorter than the number of levels, it's repeated.\n",
      " |      \n",
      " |          As a shortcut, single color strings may be used in place of\n",
      " |          one-element lists, i.e. ``'red'`` instead of ``['red']`` to color\n",
      " |          all levels with the same color. This shortcut does only work for\n",
      " |          color strings, not for other ways of specifying colors.\n",
      " |      \n",
      " |          By default (value *None*), the colormap specified by *cmap*\n",
      " |          will be used.\n",
      " |      \n",
      " |      alpha : float, default: 1\n",
      " |          The alpha blending value, between 0 (transparent) and 1 (opaque).\n",
      " |      \n",
      " |      cmap : str or `.Colormap`, default: :rc:`image.cmap`\n",
      " |          A `.Colormap` instance or registered colormap name. The colormap\n",
      " |          maps the level values to colors.\n",
      " |      \n",
      " |          If both *colors* and *cmap* are given, an error is raised.\n",
      " |      \n",
      " |      norm : `~matplotlib.colors.Normalize`, optional\n",
      " |          If a colormap is used, the `.Normalize` instance scales the level\n",
      " |          values to the canonical colormap range [0, 1] for mapping to\n",
      " |          colors. If not given, the default linear scaling is used.\n",
      " |      \n",
      " |      vmin, vmax : float, optional\n",
      " |          If not *None*, either or both of these values will be supplied to\n",
      " |          the `.Normalize` instance, overriding the default color scaling\n",
      " |          based on *levels*.\n",
      " |      \n",
      " |      origin : {*None*, 'upper', 'lower', 'image'}, default: None\n",
      " |          Determines the orientation and exact position of *Z* by specifying\n",
      " |          the position of ``Z[0, 0]``.  This is only relevant, if *X*, *Y*\n",
      " |          are not given.\n",
      " |      \n",
      " |          - *None*: ``Z[0, 0]`` is at X=0, Y=0 in the lower left corner.\n",
      " |          - 'lower': ``Z[0, 0]`` is at X=0.5, Y=0.5 in the lower left corner.\n",
      " |          - 'upper': ``Z[0, 0]`` is at X=N+0.5, Y=0.5 in the upper left\n",
      " |            corner.\n",
      " |          - 'image': Use the value from :rc:`image.origin`.\n",
      " |      \n",
      " |      extent : (x0, x1, y0, y1), optional\n",
      " |          If *origin* is not *None*, then *extent* is interpreted as in\n",
      " |          `.imshow`: it gives the outer pixel boundaries. In this case, the\n",
      " |          position of Z[0, 0] is the center of the pixel, not a corner. If\n",
      " |          *origin* is *None*, then (*x0*, *y0*) is the position of Z[0, 0],\n",
      " |          and (*x1*, *y1*) is the position of Z[-1, -1].\n",
      " |      \n",
      " |          This argument is ignored if *X* and *Y* are specified in the call\n",
      " |          to contour.\n",
      " |      \n",
      " |      locator : ticker.Locator subclass, optional\n",
      " |          The locator is used to determine the contour levels if they\n",
      " |          are not given explicitly via *levels*.\n",
      " |          Defaults to `~.ticker.MaxNLocator`.\n",
      " |      \n",
      " |      extend : {'neither', 'both', 'min', 'max'}, default: 'neither'\n",
      " |          Determines the ``contourf``-coloring of values that are outside the\n",
      " |          *levels* range.\n",
      " |      \n",
      " |          If 'neither', values outside the *levels* range are not colored.\n",
      " |          If 'min', 'max' or 'both', color the values below, above or below\n",
      " |          and above the *levels* range.\n",
      " |      \n",
      " |          Values below ``min(levels)`` and above ``max(levels)`` are mapped\n",
      " |          to the under/over values of the `.Colormap`. Note that most\n",
      " |          colormaps do not have dedicated colors for these by default, so\n",
      " |          that the over and under values are the edge values of the colormap.\n",
      " |          You may want to set these values explicitly using\n",
      " |          `.Colormap.set_under` and `.Colormap.set_over`.\n",
      " |      \n",
      " |          .. note::\n",
      " |      \n",
      " |              An existing `.QuadContourSet` does not get notified if\n",
      " |              properties of its colormap are changed. Therefore, an explicit\n",
      " |              call `.QuadContourSet.changed()` is needed after modifying the\n",
      " |              colormap. The explicit call can be left out, if a colorbar is\n",
      " |              assigned to the `.QuadContourSet` because it internally calls\n",
      " |              `.QuadContourSet.changed()`.\n",
      " |      \n",
      " |          Example::\n",
      " |      \n",
      " |              x = np.arange(1, 10)\n",
      " |              y = x.reshape(-1, 1)\n",
      " |              h = x * y\n",
      " |      \n",
      " |              cs = plt.contourf(h, levels=[10, 30, 50],\n",
      " |                  colors=['#808080', '#A0A0A0', '#C0C0C0'], extend='both')\n",
      " |              cs.cmap.set_over('red')\n",
      " |              cs.cmap.set_under('blue')\n",
      " |              cs.changed()\n",
      " |      \n",
      " |      xunits, yunits : registered units, optional\n",
      " |          Override axis units by specifying an instance of a\n",
      " |          :class:`matplotlib.units.ConversionInterface`.\n",
      " |      \n",
      " |      antialiased : bool, optional\n",
      " |          Enable antialiasing, overriding the defaults.  For\n",
      " |          filled contours, the default is *True*.  For line contours,\n",
      " |          it is taken from :rc:`lines.antialiased`.\n",
      " |      \n",
      " |      nchunk : int >= 0, optional\n",
      " |          If 0, no subdivision of the domain.  Specify a positive integer to\n",
      " |          divide the domain into subdomains of *nchunk* by *nchunk* quads.\n",
      " |          Chunking reduces the maximum length of polygons generated by the\n",
      " |          contouring algorithm which reduces the rendering workload passed\n",
      " |          on to the backend and also requires slightly less RAM.  It can\n",
      " |          however introduce rendering artifacts at chunk boundaries depending\n",
      " |          on the backend, the *antialiased* flag and value of *alpha*.\n",
      " |      \n",
      " |      linewidths : float or array-like, default: :rc:`contour.linewidth`\n",
      " |          *Only applies to* `.contour`.\n",
      " |      \n",
      " |          The line width of the contour lines.\n",
      " |      \n",
      " |          If a number, all levels will be plotted with this linewidth.\n",
      " |      \n",
      " |          If a sequence, the levels in ascending order will be plotted with\n",
      " |          the linewidths in the order specified.\n",
      " |      \n",
      " |          If None, this falls back to :rc:`lines.linewidth`.\n",
      " |      \n",
      " |      linestyles : {*None*, 'solid', 'dashed', 'dashdot', 'dotted'}, optional\n",
      " |          *Only applies to* `.contour`.\n",
      " |      \n",
      " |          If *linestyles* is *None*, the default is 'solid' unless the lines\n",
      " |          are monochrome.  In that case, negative contours will take their\n",
      " |          linestyle from :rc:`contour.negative_linestyle` setting.\n",
      " |      \n",
      " |          *linestyles* can also be an iterable of the above strings\n",
      " |          specifying a set of linestyles to be used. If this\n",
      " |          iterable is shorter than the number of contour levels\n",
      " |          it will be repeated as necessary.\n",
      " |      \n",
      " |      hatches : list[str], optional\n",
      " |          *Only applies to* `.contourf`.\n",
      " |      \n",
      " |          A list of cross hatch patterns to use on the filled areas.\n",
      " |          If None, no hatching will be added to the contour.\n",
      " |          Hatching is supported in the PostScript, PDF, SVG and Agg\n",
      " |          backends only.\n",
      " |      \n",
      " |      data : indexable object, optional\n",
      " |          If given, all parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception).\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      1. `.contourf` differs from the MATLAB version in that it does not draw\n",
      " |         the polygon edges. To draw edges, add line contours with calls to\n",
      " |         `.contour`.\n",
      " |      \n",
      " |      2. `.contourf` fills intervals that are closed at the top; that is, for\n",
      " |         boundaries *z1* and *z2*, the filled region is::\n",
      " |      \n",
      " |            z1 < Z <= z2\n",
      " |      \n",
      " |         except for the lowest interval, which is closed on both sides (i.e.\n",
      " |         it includes the lowest value).\n",
      " |      \n",
      " |      3. `.contour` and `.contourf` use a `marching squares\n",
      " |         <https://en.wikipedia.org/wiki/Marching_squares>`_ algorithm to\n",
      " |         compute contour locations.  More information can be found in\n",
      " |         the source ``src/_contour.h``.\n",
      " |  \n",
      " |  contourf(self, *args, data=None, **kwargs)\n",
      " |      Plot filled contours.\n",
      " |      \n",
      " |      Call signature::\n",
      " |      \n",
      " |          contourf([X, Y,] Z, [levels], **kwargs)\n",
      " |      \n",
      " |      `.contour` and `.contourf` draw contour lines and filled contours,\n",
      " |      respectively.  Except as noted, function signatures and return values\n",
      " |      are the same for both versions.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      X, Y : array-like, optional\n",
      " |          The coordinates of the values in *Z*.\n",
      " |      \n",
      " |          *X* and *Y* must both be 2D with the same shape as *Z* (e.g.\n",
      " |          created via `numpy.meshgrid`), or they must both be 1-D such\n",
      " |          that ``len(X) == N`` is the number of columns in *Z* and\n",
      " |          ``len(Y) == M`` is the number of rows in *Z*.\n",
      " |      \n",
      " |          *X* and *Y* must both be ordered monotonically.\n",
      " |      \n",
      " |          If not given, they are assumed to be integer indices, i.e.\n",
      " |          ``X = range(N)``, ``Y = range(M)``.\n",
      " |      \n",
      " |      Z : (M, N) array-like\n",
      " |          The height values over which the contour is drawn.\n",
      " |      \n",
      " |      levels : int or array-like, optional\n",
      " |          Determines the number and positions of the contour lines / regions.\n",
      " |      \n",
      " |          If an int *n*, use `~matplotlib.ticker.MaxNLocator`, which tries\n",
      " |          to automatically choose no more than *n+1* \"nice\" contour levels\n",
      " |          between *vmin* and *vmax*.\n",
      " |      \n",
      " |          If array-like, draw contour lines at the specified levels.\n",
      " |          The values must be in increasing order.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `~.contour.QuadContourSet`\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      corner_mask : bool, default: :rc:`contour.corner_mask`\n",
      " |          Enable/disable corner masking, which only has an effect if *Z* is\n",
      " |          a masked array.  If ``False``, any quad touching a masked point is\n",
      " |          masked out.  If ``True``, only the triangular corners of quads\n",
      " |          nearest those points are always masked out, other triangular\n",
      " |          corners comprising three unmasked points are contoured as usual.\n",
      " |      \n",
      " |      colors : color string or sequence of colors, optional\n",
      " |          The colors of the levels, i.e. the lines for `.contour` and the\n",
      " |          areas for `.contourf`.\n",
      " |      \n",
      " |          The sequence is cycled for the levels in ascending order. If the\n",
      " |          sequence is shorter than the number of levels, it's repeated.\n",
      " |      \n",
      " |          As a shortcut, single color strings may be used in place of\n",
      " |          one-element lists, i.e. ``'red'`` instead of ``['red']`` to color\n",
      " |          all levels with the same color. This shortcut does only work for\n",
      " |          color strings, not for other ways of specifying colors.\n",
      " |      \n",
      " |          By default (value *None*), the colormap specified by *cmap*\n",
      " |          will be used.\n",
      " |      \n",
      " |      alpha : float, default: 1\n",
      " |          The alpha blending value, between 0 (transparent) and 1 (opaque).\n",
      " |      \n",
      " |      cmap : str or `.Colormap`, default: :rc:`image.cmap`\n",
      " |          A `.Colormap` instance or registered colormap name. The colormap\n",
      " |          maps the level values to colors.\n",
      " |      \n",
      " |          If both *colors* and *cmap* are given, an error is raised.\n",
      " |      \n",
      " |      norm : `~matplotlib.colors.Normalize`, optional\n",
      " |          If a colormap is used, the `.Normalize` instance scales the level\n",
      " |          values to the canonical colormap range [0, 1] for mapping to\n",
      " |          colors. If not given, the default linear scaling is used.\n",
      " |      \n",
      " |      vmin, vmax : float, optional\n",
      " |          If not *None*, either or both of these values will be supplied to\n",
      " |          the `.Normalize` instance, overriding the default color scaling\n",
      " |          based on *levels*.\n",
      " |      \n",
      " |      origin : {*None*, 'upper', 'lower', 'image'}, default: None\n",
      " |          Determines the orientation and exact position of *Z* by specifying\n",
      " |          the position of ``Z[0, 0]``.  This is only relevant, if *X*, *Y*\n",
      " |          are not given.\n",
      " |      \n",
      " |          - *None*: ``Z[0, 0]`` is at X=0, Y=0 in the lower left corner.\n",
      " |          - 'lower': ``Z[0, 0]`` is at X=0.5, Y=0.5 in the lower left corner.\n",
      " |          - 'upper': ``Z[0, 0]`` is at X=N+0.5, Y=0.5 in the upper left\n",
      " |            corner.\n",
      " |          - 'image': Use the value from :rc:`image.origin`.\n",
      " |      \n",
      " |      extent : (x0, x1, y0, y1), optional\n",
      " |          If *origin* is not *None*, then *extent* is interpreted as in\n",
      " |          `.imshow`: it gives the outer pixel boundaries. In this case, the\n",
      " |          position of Z[0, 0] is the center of the pixel, not a corner. If\n",
      " |          *origin* is *None*, then (*x0*, *y0*) is the position of Z[0, 0],\n",
      " |          and (*x1*, *y1*) is the position of Z[-1, -1].\n",
      " |      \n",
      " |          This argument is ignored if *X* and *Y* are specified in the call\n",
      " |          to contour.\n",
      " |      \n",
      " |      locator : ticker.Locator subclass, optional\n",
      " |          The locator is used to determine the contour levels if they\n",
      " |          are not given explicitly via *levels*.\n",
      " |          Defaults to `~.ticker.MaxNLocator`.\n",
      " |      \n",
      " |      extend : {'neither', 'both', 'min', 'max'}, default: 'neither'\n",
      " |          Determines the ``contourf``-coloring of values that are outside the\n",
      " |          *levels* range.\n",
      " |      \n",
      " |          If 'neither', values outside the *levels* range are not colored.\n",
      " |          If 'min', 'max' or 'both', color the values below, above or below\n",
      " |          and above the *levels* range.\n",
      " |      \n",
      " |          Values below ``min(levels)`` and above ``max(levels)`` are mapped\n",
      " |          to the under/over values of the `.Colormap`. Note that most\n",
      " |          colormaps do not have dedicated colors for these by default, so\n",
      " |          that the over and under values are the edge values of the colormap.\n",
      " |          You may want to set these values explicitly using\n",
      " |          `.Colormap.set_under` and `.Colormap.set_over`.\n",
      " |      \n",
      " |          .. note::\n",
      " |      \n",
      " |              An existing `.QuadContourSet` does not get notified if\n",
      " |              properties of its colormap are changed. Therefore, an explicit\n",
      " |              call `.QuadContourSet.changed()` is needed after modifying the\n",
      " |              colormap. The explicit call can be left out, if a colorbar is\n",
      " |              assigned to the `.QuadContourSet` because it internally calls\n",
      " |              `.QuadContourSet.changed()`.\n",
      " |      \n",
      " |          Example::\n",
      " |      \n",
      " |              x = np.arange(1, 10)\n",
      " |              y = x.reshape(-1, 1)\n",
      " |              h = x * y\n",
      " |      \n",
      " |              cs = plt.contourf(h, levels=[10, 30, 50],\n",
      " |                  colors=['#808080', '#A0A0A0', '#C0C0C0'], extend='both')\n",
      " |              cs.cmap.set_over('red')\n",
      " |              cs.cmap.set_under('blue')\n",
      " |              cs.changed()\n",
      " |      \n",
      " |      xunits, yunits : registered units, optional\n",
      " |          Override axis units by specifying an instance of a\n",
      " |          :class:`matplotlib.units.ConversionInterface`.\n",
      " |      \n",
      " |      antialiased : bool, optional\n",
      " |          Enable antialiasing, overriding the defaults.  For\n",
      " |          filled contours, the default is *True*.  For line contours,\n",
      " |          it is taken from :rc:`lines.antialiased`.\n",
      " |      \n",
      " |      nchunk : int >= 0, optional\n",
      " |          If 0, no subdivision of the domain.  Specify a positive integer to\n",
      " |          divide the domain into subdomains of *nchunk* by *nchunk* quads.\n",
      " |          Chunking reduces the maximum length of polygons generated by the\n",
      " |          contouring algorithm which reduces the rendering workload passed\n",
      " |          on to the backend and also requires slightly less RAM.  It can\n",
      " |          however introduce rendering artifacts at chunk boundaries depending\n",
      " |          on the backend, the *antialiased* flag and value of *alpha*.\n",
      " |      \n",
      " |      linewidths : float or array-like, default: :rc:`contour.linewidth`\n",
      " |          *Only applies to* `.contour`.\n",
      " |      \n",
      " |          The line width of the contour lines.\n",
      " |      \n",
      " |          If a number, all levels will be plotted with this linewidth.\n",
      " |      \n",
      " |          If a sequence, the levels in ascending order will be plotted with\n",
      " |          the linewidths in the order specified.\n",
      " |      \n",
      " |          If None, this falls back to :rc:`lines.linewidth`.\n",
      " |      \n",
      " |      linestyles : {*None*, 'solid', 'dashed', 'dashdot', 'dotted'}, optional\n",
      " |          *Only applies to* `.contour`.\n",
      " |      \n",
      " |          If *linestyles* is *None*, the default is 'solid' unless the lines\n",
      " |          are monochrome.  In that case, negative contours will take their\n",
      " |          linestyle from :rc:`contour.negative_linestyle` setting.\n",
      " |      \n",
      " |          *linestyles* can also be an iterable of the above strings\n",
      " |          specifying a set of linestyles to be used. If this\n",
      " |          iterable is shorter than the number of contour levels\n",
      " |          it will be repeated as necessary.\n",
      " |      \n",
      " |      hatches : list[str], optional\n",
      " |          *Only applies to* `.contourf`.\n",
      " |      \n",
      " |          A list of cross hatch patterns to use on the filled areas.\n",
      " |          If None, no hatching will be added to the contour.\n",
      " |          Hatching is supported in the PostScript, PDF, SVG and Agg\n",
      " |          backends only.\n",
      " |      \n",
      " |      data : indexable object, optional\n",
      " |          If given, all parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception).\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      1. `.contourf` differs from the MATLAB version in that it does not draw\n",
      " |         the polygon edges. To draw edges, add line contours with calls to\n",
      " |         `.contour`.\n",
      " |      \n",
      " |      2. `.contourf` fills intervals that are closed at the top; that is, for\n",
      " |         boundaries *z1* and *z2*, the filled region is::\n",
      " |      \n",
      " |            z1 < Z <= z2\n",
      " |      \n",
      " |         except for the lowest interval, which is closed on both sides (i.e.\n",
      " |         it includes the lowest value).\n",
      " |      \n",
      " |      3. `.contour` and `.contourf` use a `marching squares\n",
      " |         <https://en.wikipedia.org/wiki/Marching_squares>`_ algorithm to\n",
      " |         compute contour locations.  More information can be found in\n",
      " |         the source ``src/_contour.h``.\n",
      " |  \n",
      " |  csd(self, x, y, NFFT=None, Fs=None, Fc=None, detrend=None, window=None, noverlap=None, pad_to=None, sides=None, scale_by_freq=None, return_line=None, *, data=None, **kwargs)\n",
      " |      Plot the cross-spectral density.\n",
      " |      \n",
      " |      The cross spectral density :math:`P_{xy}` by Welch's average\n",
      " |      periodogram method.  The vectors *x* and *y* are divided into\n",
      " |      *NFFT* length segments.  Each segment is detrended by function\n",
      " |      *detrend* and windowed by function *window*.  *noverlap* gives\n",
      " |      the length of the overlap between segments.  The product of\n",
      " |      the direct FFTs of *x* and *y* are averaged over each segment\n",
      " |      to compute :math:`P_{xy}`, with a scaling to correct for power\n",
      " |      loss due to windowing.\n",
      " |      \n",
      " |      If len(*x*) < *NFFT* or len(*y*) < *NFFT*, they will be zero\n",
      " |      padded to *NFFT*.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      x, y : 1-D arrays or sequences\n",
      " |          Arrays or sequences containing the data.\n",
      " |      \n",
      " |      Fs : float, default: 2\n",
      " |          The sampling frequency (samples per time unit).  It is used to calculate\n",
      " |          the Fourier frequencies, *freqs*, in cycles per time unit.\n",
      " |      \n",
      " |      window : callable or ndarray, default: `.window_hanning`\n",
      " |          A function or a vector of length *NFFT*.  To create window vectors see\n",
      " |          `.window_hanning`, `.window_none`, `numpy.blackman`, `numpy.hamming`,\n",
      " |          `numpy.bartlett`, `scipy.signal`, `scipy.signal.get_window`, etc.  If a\n",
      " |          function is passed as the argument, it must take a data segment as an\n",
      " |          argument and return the windowed version of the segment.\n",
      " |      \n",
      " |      sides : {'default', 'onesided', 'twosided'}, optional\n",
      " |          Which sides of the spectrum to return. 'default' is one-sided for real\n",
      " |          data and two-sided for complex data. 'onesided' forces the return of a\n",
      " |          one-sided spectrum, while 'twosided' forces two-sided.\n",
      " |      \n",
      " |      pad_to : int, optional\n",
      " |          The number of points to which the data segment is padded when performing\n",
      " |          the FFT.  This can be different from *NFFT*, which specifies the number\n",
      " |          of data points used.  While not increasing the actual resolution of the\n",
      " |          spectrum (the minimum distance between resolvable peaks), this can give\n",
      " |          more points in the plot, allowing for more detail. This corresponds to\n",
      " |          the *n* parameter in the call to fft(). The default is None, which sets\n",
      " |          *pad_to* equal to *NFFT*\n",
      " |      \n",
      " |      NFFT : int, default: 256\n",
      " |          The number of data points used in each block for the FFT.  A power 2 is\n",
      " |          most efficient.  This should *NOT* be used to get zero padding, or the\n",
      " |          scaling of the result will be incorrect; use *pad_to* for this instead.\n",
      " |      \n",
      " |      detrend : {'none', 'mean', 'linear'} or callable, default: 'none'\n",
      " |          The function applied to each segment before fft-ing, designed to remove\n",
      " |          the mean or linear trend.  Unlike in MATLAB, where the *detrend* parameter\n",
      " |          is a vector, in Matplotlib it is a function.  The :mod:`~matplotlib.mlab`\n",
      " |          module defines `.detrend_none`, `.detrend_mean`, and `.detrend_linear`,\n",
      " |          but you can use a custom function as well.  You can also use a string to\n",
      " |          choose one of the functions: 'none' calls `.detrend_none`. 'mean' calls\n",
      " |          `.detrend_mean`. 'linear' calls `.detrend_linear`.\n",
      " |      \n",
      " |      scale_by_freq : bool, default: True\n",
      " |          Whether the resulting density values should be scaled by the scaling\n",
      " |          frequency, which gives density in units of Hz^-1.  This allows for\n",
      " |          integration over the returned frequency values.  The default is True for\n",
      " |          MATLAB compatibility.\n",
      " |      \n",
      " |      noverlap : int, default: 0 (no overlap)\n",
      " |          The number of points of overlap between segments.\n",
      " |      \n",
      " |      Fc : int, default: 0\n",
      " |          The center frequency of *x*, which offsets the x extents of the\n",
      " |          plot to reflect the frequency range used when a signal is acquired\n",
      " |          and then filtered and downsampled to baseband.\n",
      " |      \n",
      " |      return_line : bool, default: False\n",
      " |          Whether to include the line object plotted in the returned values.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Pxy : 1-D array\n",
      " |          The values for the cross spectrum :math:`P_{xy}` before scaling\n",
      " |          (complex valued).\n",
      " |      \n",
      " |      freqs : 1-D array\n",
      " |          The frequencies corresponding to the elements in *Pxy*.\n",
      " |      \n",
      " |      line : `~matplotlib.lines.Line2D`\n",
      " |          The line created by this function.\n",
      " |          Only returned if *return_line* is True.\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      data : indexable object, optional\n",
      " |          If given, the following parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception):\n",
      " |      \n",
      " |          *x*, *y*\n",
      " |      \n",
      " |      **kwargs\n",
      " |          Keyword arguments control the `.Line2D` properties:\n",
      " |      \n",
      " |          Properties:\n",
      " |          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      " |          alpha: scalar or None\n",
      " |          animated: bool\n",
      " |          antialiased or aa: bool\n",
      " |          clip_box: `.Bbox`\n",
      " |          clip_on: bool\n",
      " |          clip_path: Patch or (Path, Transform) or None\n",
      " |          color or c: color\n",
      " |          dash_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          dash_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          dashes: sequence of floats (on/off ink in points) or (None, None)\n",
      " |          data: (2, N) array or two 1D arrays\n",
      " |          drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'\n",
      " |          figure: `.Figure`\n",
      " |          fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}\n",
      " |          gid: str\n",
      " |          in_layout: bool\n",
      " |          label: object\n",
      " |          linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      " |          linewidth or lw: float\n",
      " |          marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`\n",
      " |          markeredgecolor or mec: color\n",
      " |          markeredgewidth or mew: float\n",
      " |          markerfacecolor or mfc: color\n",
      " |          markerfacecoloralt or mfcalt: color\n",
      " |          markersize or ms: float\n",
      " |          markevery: None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]\n",
      " |          path_effects: `.AbstractPathEffect`\n",
      " |          picker: float or callable[[Artist, Event], tuple[bool, dict]]\n",
      " |          pickradius: float\n",
      " |          rasterized: bool\n",
      " |          sketch_params: (scale: float, length: float, randomness: float)\n",
      " |          snap: bool or None\n",
      " |          solid_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          solid_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          transform: unknown\n",
      " |          url: str\n",
      " |          visible: bool\n",
      " |          xdata: 1D array\n",
      " |          ydata: 1D array\n",
      " |          zorder: float\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      psd : is equivalent to setting ``y = x``.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      For plotting, the power is plotted as\n",
      " |      :math:`10 \\log_{10}(P_{xy})` for decibels, though :math:`P_{xy}` itself\n",
      " |      is returned.\n",
      " |      \n",
      " |      References\n",
      " |      ----------\n",
      " |      Bendat & Piersol -- Random Data: Analysis and Measurement Procedures,\n",
      " |      John Wiley & Sons (1986)\n",
      " |  \n",
      " |  errorbar(self, x, y, yerr=None, xerr=None, fmt='', ecolor=None, elinewidth=None, capsize=None, barsabove=False, lolims=False, uplims=False, xlolims=False, xuplims=False, errorevery=1, capthick=None, *, data=None, **kwargs)\n",
      " |      Plot y versus x as lines and/or markers with attached errorbars.\n",
      " |      \n",
      " |      *x*, *y* define the data locations, *xerr*, *yerr* define the errorbar\n",
      " |      sizes. By default, this draws the data markers/lines as well the\n",
      " |      errorbars. Use fmt='none' to draw errorbars without any data markers.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      x, y : float or array-like\n",
      " |          The data positions.\n",
      " |      \n",
      " |      xerr, yerr : float or array-like, shape(N,) or shape(2, N), optional\n",
      " |          The errorbar sizes:\n",
      " |      \n",
      " |          - scalar: Symmetric +/- values for all data points.\n",
      " |          - shape(N,): Symmetric +/-values for each data point.\n",
      " |          - shape(2, N): Separate - and + values for each bar. First row\n",
      " |            contains the lower errors, the second row contains the upper\n",
      " |            errors.\n",
      " |          - *None*: No errorbar.\n",
      " |      \n",
      " |          Note that all error arrays should have *positive* values.\n",
      " |      \n",
      " |          See :doc:`/gallery/statistics/errorbar_features`\n",
      " |          for an example on the usage of ``xerr`` and ``yerr``.\n",
      " |      \n",
      " |      fmt : str, default: ''\n",
      " |          The format for the data points / data lines. See `.plot` for\n",
      " |          details.\n",
      " |      \n",
      " |          Use 'none' (case insensitive) to plot errorbars without any data\n",
      " |          markers.\n",
      " |      \n",
      " |      ecolor : color, default: None\n",
      " |          The color of the errorbar lines.  If None, use the color of the\n",
      " |          line connecting the markers.\n",
      " |      \n",
      " |      elinewidth : float, default: None\n",
      " |          The linewidth of the errorbar lines. If None, the linewidth of\n",
      " |          the current style is used.\n",
      " |      \n",
      " |      capsize : float, default: :rc:`errorbar.capsize`\n",
      " |          The length of the error bar caps in points.\n",
      " |      \n",
      " |      capthick : float, default: None\n",
      " |          An alias to the keyword argument *markeredgewidth* (a.k.a. *mew*).\n",
      " |          This setting is a more sensible name for the property that\n",
      " |          controls the thickness of the error bar cap in points. For\n",
      " |          backwards compatibility, if *mew* or *markeredgewidth* are given,\n",
      " |          then they will over-ride *capthick*. This may change in future\n",
      " |          releases.\n",
      " |      \n",
      " |      barsabove : bool, default: False\n",
      " |          If True, will plot the errorbars above the plot\n",
      " |          symbols. Default is below.\n",
      " |      \n",
      " |      lolims, uplims, xlolims, xuplims : bool, default: False\n",
      " |          These arguments can be used to indicate that a value gives only\n",
      " |          upper/lower limits.  In that case a caret symbol is used to\n",
      " |          indicate this. *lims*-arguments may be scalars, or array-likes of\n",
      " |          the same length as *xerr* and *yerr*.  To use limits with inverted\n",
      " |          axes, `~.Axes.set_xlim` or `~.Axes.set_ylim` must be called before\n",
      " |          :meth:`errorbar`.  Note the tricky parameter names: setting e.g.\n",
      " |          *lolims* to True means that the y-value is a *lower* limit of the\n",
      " |          True value, so, only an *upward*-pointing arrow will be drawn!\n",
      " |      \n",
      " |      errorevery : int or (int, int), default: 1\n",
      " |          draws error bars on a subset of the data. *errorevery* =N draws\n",
      " |          error bars on the points (x[::N], y[::N]).\n",
      " |          *errorevery* =(start, N) draws error bars on the points\n",
      " |          (x[start::N], y[start::N]). e.g. errorevery=(6, 3)\n",
      " |          adds error bars to the data at (x[6], x[9], x[12], x[15], ...).\n",
      " |          Used to avoid overlapping error bars when two series share x-axis\n",
      " |          values.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `.ErrorbarContainer`\n",
      " |          The container contains:\n",
      " |      \n",
      " |          - plotline: `.Line2D` instance of x, y plot markers and/or line.\n",
      " |          - caplines: A tuple of `.Line2D` instances of the error bar caps.\n",
      " |          - barlinecols: A tuple of `.LineCollection` with the horizontal and\n",
      " |            vertical error ranges.\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      data : indexable object, optional\n",
      " |          If given, the following parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception):\n",
      " |      \n",
      " |          *x*, *y*, *xerr*, *yerr*\n",
      " |      \n",
      " |      **kwargs\n",
      " |          All other keyword arguments are passed on to the `~.Axes.plot` call\n",
      " |          drawing the markers. For example, this code makes big red squares\n",
      " |          with thick green edges::\n",
      " |      \n",
      " |              x, y, yerr = rand(3, 10)\n",
      " |              errorbar(x, y, yerr, marker='s', mfc='red',\n",
      " |                       mec='green', ms=20, mew=4)\n",
      " |      \n",
      " |          where *mfc*, *mec*, *ms* and *mew* are aliases for the longer\n",
      " |          property names, *markerfacecolor*, *markeredgecolor*, *markersize*\n",
      " |          and *markeredgewidth*.\n",
      " |      \n",
      " |          Valid kwargs for the marker properties are `.Line2D` properties:\n",
      " |      \n",
      " |          Properties:\n",
      " |          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      " |          alpha: scalar or None\n",
      " |          animated: bool\n",
      " |          antialiased or aa: bool\n",
      " |          clip_box: `.Bbox`\n",
      " |          clip_on: bool\n",
      " |          clip_path: Patch or (Path, Transform) or None\n",
      " |          color or c: color\n",
      " |          dash_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          dash_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          dashes: sequence of floats (on/off ink in points) or (None, None)\n",
      " |          data: (2, N) array or two 1D arrays\n",
      " |          drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'\n",
      " |          figure: `.Figure`\n",
      " |          fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}\n",
      " |          gid: str\n",
      " |          in_layout: bool\n",
      " |          label: object\n",
      " |          linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      " |          linewidth or lw: float\n",
      " |          marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`\n",
      " |          markeredgecolor or mec: color\n",
      " |          markeredgewidth or mew: float\n",
      " |          markerfacecolor or mfc: color\n",
      " |          markerfacecoloralt or mfcalt: color\n",
      " |          markersize or ms: float\n",
      " |          markevery: None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]\n",
      " |          path_effects: `.AbstractPathEffect`\n",
      " |          picker: float or callable[[Artist, Event], tuple[bool, dict]]\n",
      " |          pickradius: float\n",
      " |          rasterized: bool\n",
      " |          sketch_params: (scale: float, length: float, randomness: float)\n",
      " |          snap: bool or None\n",
      " |          solid_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          solid_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          transform: unknown\n",
      " |          url: str\n",
      " |          visible: bool\n",
      " |          xdata: 1D array\n",
      " |          ydata: 1D array\n",
      " |          zorder: float\n",
      " |  \n",
      " |  eventplot(self, positions, orientation='horizontal', lineoffsets=1, linelengths=1, linewidths=None, colors=None, linestyles='solid', *, data=None, **kwargs)\n",
      " |      Plot identical parallel lines at the given positions.\n",
      " |      \n",
      " |      This type of plot is commonly used in neuroscience for representing\n",
      " |      neural events, where it is usually called a spike raster, dot raster,\n",
      " |      or raster plot.\n",
      " |      \n",
      " |      However, it is useful in any situation where you wish to show the\n",
      " |      timing or position of multiple sets of discrete events, such as the\n",
      " |      arrival times of people to a business on each day of the month or the\n",
      " |      date of hurricanes each year of the last century.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      positions : array-like or list of array-like\n",
      " |          A 1D array-like defines the positions of one sequence of events.\n",
      " |      \n",
      " |          Multiple groups of events may be passed as a list of array-likes.\n",
      " |          Each group can be styled independently by passing lists of values\n",
      " |          to *lineoffsets*, *linelengths*, *linewidths*, *colors* and\n",
      " |          *linestyles*.\n",
      " |      \n",
      " |          Note that *positions* can be a 2D array, but in practice different\n",
      " |          event groups usually have different counts so that one will use a\n",
      " |          list of different-length arrays rather than a 2D array.\n",
      " |      \n",
      " |      orientation : {'horizontal', 'vertical'}, default: 'horizontal'\n",
      " |          The direction of the event sequence:\n",
      " |      \n",
      " |          - 'horizontal': the events are arranged horizontally.\n",
      " |            The indicator lines are vertical.\n",
      " |          - 'vertical': the events are arranged vertically.\n",
      " |            The indicator lines are horizontal.\n",
      " |      \n",
      " |      lineoffsets : float or array-like, default: 1\n",
      " |          The offset of the center of the lines from the origin, in the\n",
      " |          direction orthogonal to *orientation*.\n",
      " |      \n",
      " |          If *positions* is 2D, this can be a sequence with length matching\n",
      " |          the length of *positions*.\n",
      " |      \n",
      " |      linelengths : float or array-like, default: 1\n",
      " |          The total height of the lines (i.e. the lines stretches from\n",
      " |          ``lineoffset - linelength/2`` to ``lineoffset + linelength/2``).\n",
      " |      \n",
      " |          If *positions* is 2D, this can be a sequence with length matching\n",
      " |          the length of *positions*.\n",
      " |      \n",
      " |      linewidths : float or array-like, default: :rc:`lines.linewidth`\n",
      " |          The line width(s) of the event lines, in points.\n",
      " |      \n",
      " |          If *positions* is 2D, this can be a sequence with length matching\n",
      " |          the length of *positions*.\n",
      " |      \n",
      " |      colors : color or list of colors, default: :rc:`lines.color`\n",
      " |          The color(s) of the event lines.\n",
      " |      \n",
      " |          If *positions* is 2D, this can be a sequence with length matching\n",
      " |          the length of *positions*.\n",
      " |      \n",
      " |      linestyles : str or tuple or list of such values, default: 'solid'\n",
      " |          Default is 'solid'. Valid strings are ['solid', 'dashed',\n",
      " |          'dashdot', 'dotted', '-', '--', '-.', ':']. Dash tuples\n",
      " |          should be of the form::\n",
      " |      \n",
      " |              (offset, onoffseq),\n",
      " |      \n",
      " |          where *onoffseq* is an even length tuple of on and off ink\n",
      " |          in points.\n",
      " |      \n",
      " |          If *positions* is 2D, this can be a sequence with length matching\n",
      " |          the length of *positions*.\n",
      " |      \n",
      " |      data : indexable object, optional\n",
      " |          If given, the following parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception):\n",
      " |      \n",
      " |          *positions*, *lineoffsets*, *linelengths*, *linewidths*, *colors*, *linestyles*\n",
      " |      \n",
      " |      **kwargs\n",
      " |          Other keyword arguments are line collection properties.  See\n",
      " |          `.LineCollection` for a list of the valid properties.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      list of `.EventCollection`\n",
      " |          The `.EventCollection` that were added.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      For *linelengths*, *linewidths*, *colors*, and *linestyles*, if only\n",
      " |      a single value is given, that value is applied to all lines.  If an\n",
      " |      array-like is given, it must have the same length as *positions*, and\n",
      " |      each value will be applied to the corresponding row of the array.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      .. plot:: gallery/lines_bars_and_markers/eventplot_demo.py\n",
      " |  \n",
      " |  fill(self, *args, data=None, **kwargs)\n",
      " |      Plot filled polygons.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      *args : sequence of x, y, [color]\n",
      " |          Each polygon is defined by the lists of *x* and *y* positions of\n",
      " |          its nodes, optionally followed by a *color* specifier. See\n",
      " |          :mod:`matplotlib.colors` for supported color specifiers. The\n",
      " |          standard color cycle is used for polygons without a color\n",
      " |          specifier.\n",
      " |      \n",
      " |          You can plot multiple polygons by providing multiple *x*, *y*,\n",
      " |          *[color]* groups.\n",
      " |      \n",
      " |          For example, each of the following is legal::\n",
      " |      \n",
      " |              ax.fill(x, y)                    # a polygon with default color\n",
      " |              ax.fill(x, y, \"b\")               # a blue polygon\n",
      " |              ax.fill(x, y, x2, y2)            # two polygons\n",
      " |              ax.fill(x, y, \"b\", x2, y2, \"r\")  # a blue and a red polygon\n",
      " |      \n",
      " |      data : indexable object, optional\n",
      " |          An object with labelled data. If given, provide the label names to\n",
      " |          plot in *x* and *y*, e.g.::\n",
      " |      \n",
      " |              ax.fill(\"time\", \"signal\",\n",
      " |                      data={\"time\": [0, 1, 2], \"signal\": [0, 1, 0]})\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      list of `~matplotlib.patches.Polygon`\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      **kwargs : `~matplotlib.patches.Polygon` properties\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      Use :meth:`fill_between` if you would like to fill the region between\n",
      " |      two curves.\n",
      " |  \n",
      " |  fill_between(self, x, y1, y2=0, where=None, interpolate=False, step=None, *, data=None, **kwargs)\n",
      " |      Fill the area between two horizontal curves.\n",
      " |      \n",
      " |      The curves are defined by the points (*x*, *y1*) and (*x*,\n",
      " |      *y2*).  This creates one or multiple polygons describing the filled\n",
      " |      area.\n",
      " |      \n",
      " |      You may exclude some horizontal sections from filling using *where*.\n",
      " |      \n",
      " |      By default, the edges connect the given points directly.  Use *step*\n",
      " |      if the filling should be a step function, i.e. constant in between\n",
      " |      *x*.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      x : array (length N)\n",
      " |          The x coordinates of the nodes defining the curves.\n",
      " |      \n",
      " |      y1 : array (length N) or scalar\n",
      " |          The y coordinates of the nodes defining the first curve.\n",
      " |      \n",
      " |      y2 : array (length N) or scalar, default: 0\n",
      " |          The y coordinates of the nodes defining the second curve.\n",
      " |      \n",
      " |      where : array of bool (length N), optional\n",
      " |          Define *where* to exclude some horizontal regions from being filled.\n",
      " |          The filled regions are defined by the coordinates ``x[where]``.\n",
      " |          More precisely, fill between ``x[i]`` and ``x[i+1]`` if\n",
      " |          ``where[i] and where[i+1]``.  Note that this definition implies\n",
      " |          that an isolated *True* value between two *False* values in *where*\n",
      " |          will not result in filling.  Both sides of the *True* position\n",
      " |          remain unfilled due to the adjacent *False* values.\n",
      " |      \n",
      " |      interpolate : bool, default: False\n",
      " |          This option is only relevant if *where* is used and the two curves\n",
      " |          are crossing each other.\n",
      " |      \n",
      " |          Semantically, *where* is often used for *y1* > *y2* or\n",
      " |          similar.  By default, the nodes of the polygon defining the filled\n",
      " |          region will only be placed at the positions in the *x* array.\n",
      " |          Such a polygon cannot describe the above semantics close to the\n",
      " |          intersection.  The x-sections containing the intersection are\n",
      " |          simply clipped.\n",
      " |      \n",
      " |          Setting *interpolate* to *True* will calculate the actual\n",
      " |          intersection point and extend the filled region up to this point.\n",
      " |      \n",
      " |      step : {'pre', 'post', 'mid'}, optional\n",
      " |          Define *step* if the filling should be a step function,\n",
      " |          i.e. constant in between *x*.  The value determines where the\n",
      " |          step will occur:\n",
      " |      \n",
      " |          - 'pre': The y value is continued constantly to the left from\n",
      " |            every *x* position, i.e. the interval ``(x[i-1], x[i]]`` has the\n",
      " |            value ``y[i]``.\n",
      " |          - 'post': The y value is continued constantly to the right from\n",
      " |            every *x* position, i.e. the interval ``[x[i], x[i+1])`` has the\n",
      " |            value ``y[i]``.\n",
      " |          - 'mid': Steps occur half-way between the *x* positions.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `.PolyCollection`\n",
      " |          A `.PolyCollection` containing the plotted polygons.\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      data : indexable object, optional\n",
      " |          If given, the following parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception):\n",
      " |      \n",
      " |          *x*, *y1*, *y2*, *where*\n",
      " |      \n",
      " |      **kwargs\n",
      " |          All other keyword arguments are passed on to `.PolyCollection`.\n",
      " |          They control the `.Polygon` properties:\n",
      " |      \n",
      " |          Properties:\n",
      " |          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      " |          alpha: array-like or scalar or None\n",
      " |          animated: bool\n",
      " |          antialiased or aa or antialiaseds: bool or list of bools\n",
      " |          array: array-like or None\n",
      " |          capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          clim: (vmin: float, vmax: float)\n",
      " |          clip_box: `.Bbox`\n",
      " |          clip_on: bool\n",
      " |          clip_path: Patch or (Path, Transform) or None\n",
      " |          cmap: `.Colormap` or str or None\n",
      " |          color: color or list of rgba tuples\n",
      " |          edgecolor or ec or edgecolors: color or list of colors or 'face'\n",
      " |          facecolor or facecolors or fc: color or list of colors\n",
      " |          figure: `.Figure`\n",
      " |          gid: str\n",
      " |          hatch: {'/', '\\\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
      " |          in_layout: bool\n",
      " |          joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          label: object\n",
      " |          linestyle or dashes or linestyles or ls: str or tuple or list thereof\n",
      " |          linewidth or linewidths or lw: float or list of floats\n",
      " |          norm: `.Normalize` or None\n",
      " |          offset_transform: `.Transform`\n",
      " |          offsets: (N, 2) or (2,) array-like\n",
      " |          path_effects: `.AbstractPathEffect`\n",
      " |          paths: list of array-like\n",
      " |          picker: None or bool or float or callable\n",
      " |          pickradius: float\n",
      " |          rasterized: bool\n",
      " |          sizes: ndarray or None\n",
      " |          sketch_params: (scale: float, length: float, randomness: float)\n",
      " |          snap: bool or None\n",
      " |          transform: `.Transform`\n",
      " |          url: str\n",
      " |          urls: list of str or None\n",
      " |          verts: list of array-like\n",
      " |          verts_and_codes: unknown\n",
      " |          visible: bool\n",
      " |          zorder: float\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      fill_between : Fill between two sets of y-values.\n",
      " |      fill_betweenx : Fill between two sets of x-values.\n",
      " |  \n",
      " |  fill_betweenx(self, y, x1, x2=0, where=None, step=None, interpolate=False, *, data=None, **kwargs)\n",
      " |      Fill the area between two vertical curves.\n",
      " |      \n",
      " |      The curves are defined by the points (*y*, *x1*) and (*y*,\n",
      " |      *x2*).  This creates one or multiple polygons describing the filled\n",
      " |      area.\n",
      " |      \n",
      " |      You may exclude some vertical sections from filling using *where*.\n",
      " |      \n",
      " |      By default, the edges connect the given points directly.  Use *step*\n",
      " |      if the filling should be a step function, i.e. constant in between\n",
      " |      *y*.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      y : array (length N)\n",
      " |          The y coordinates of the nodes defining the curves.\n",
      " |      \n",
      " |      x1 : array (length N) or scalar\n",
      " |          The x coordinates of the nodes defining the first curve.\n",
      " |      \n",
      " |      x2 : array (length N) or scalar, default: 0\n",
      " |          The x coordinates of the nodes defining the second curve.\n",
      " |      \n",
      " |      where : array of bool (length N), optional\n",
      " |          Define *where* to exclude some vertical regions from being filled.\n",
      " |          The filled regions are defined by the coordinates ``y[where]``.\n",
      " |          More precisely, fill between ``y[i]`` and ``y[i+1]`` if\n",
      " |          ``where[i] and where[i+1]``.  Note that this definition implies\n",
      " |          that an isolated *True* value between two *False* values in *where*\n",
      " |          will not result in filling.  Both sides of the *True* position\n",
      " |          remain unfilled due to the adjacent *False* values.\n",
      " |      \n",
      " |      interpolate : bool, default: False\n",
      " |          This option is only relevant if *where* is used and the two curves\n",
      " |          are crossing each other.\n",
      " |      \n",
      " |          Semantically, *where* is often used for *x1* > *x2* or\n",
      " |          similar.  By default, the nodes of the polygon defining the filled\n",
      " |          region will only be placed at the positions in the *y* array.\n",
      " |          Such a polygon cannot describe the above semantics close to the\n",
      " |          intersection.  The y-sections containing the intersection are\n",
      " |          simply clipped.\n",
      " |      \n",
      " |          Setting *interpolate* to *True* will calculate the actual\n",
      " |          intersection point and extend the filled region up to this point.\n",
      " |      \n",
      " |      step : {'pre', 'post', 'mid'}, optional\n",
      " |          Define *step* if the filling should be a step function,\n",
      " |          i.e. constant in between *y*.  The value determines where the\n",
      " |          step will occur:\n",
      " |      \n",
      " |          - 'pre': The y value is continued constantly to the left from\n",
      " |            every *x* position, i.e. the interval ``(x[i-1], x[i]]`` has the\n",
      " |            value ``y[i]``.\n",
      " |          - 'post': The y value is continued constantly to the right from\n",
      " |            every *x* position, i.e. the interval ``[x[i], x[i+1])`` has the\n",
      " |            value ``y[i]``.\n",
      " |          - 'mid': Steps occur half-way between the *x* positions.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `.PolyCollection`\n",
      " |          A `.PolyCollection` containing the plotted polygons.\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      data : indexable object, optional\n",
      " |          If given, the following parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception):\n",
      " |      \n",
      " |          *y*, *x1*, *x2*, *where*\n",
      " |      \n",
      " |      **kwargs\n",
      " |          All other keyword arguments are passed on to `.PolyCollection`.\n",
      " |          They control the `.Polygon` properties:\n",
      " |      \n",
      " |          Properties:\n",
      " |          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      " |          alpha: array-like or scalar or None\n",
      " |          animated: bool\n",
      " |          antialiased or aa or antialiaseds: bool or list of bools\n",
      " |          array: array-like or None\n",
      " |          capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          clim: (vmin: float, vmax: float)\n",
      " |          clip_box: `.Bbox`\n",
      " |          clip_on: bool\n",
      " |          clip_path: Patch or (Path, Transform) or None\n",
      " |          cmap: `.Colormap` or str or None\n",
      " |          color: color or list of rgba tuples\n",
      " |          edgecolor or ec or edgecolors: color or list of colors or 'face'\n",
      " |          facecolor or facecolors or fc: color or list of colors\n",
      " |          figure: `.Figure`\n",
      " |          gid: str\n",
      " |          hatch: {'/', '\\\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
      " |          in_layout: bool\n",
      " |          joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          label: object\n",
      " |          linestyle or dashes or linestyles or ls: str or tuple or list thereof\n",
      " |          linewidth or linewidths or lw: float or list of floats\n",
      " |          norm: `.Normalize` or None\n",
      " |          offset_transform: `.Transform`\n",
      " |          offsets: (N, 2) or (2,) array-like\n",
      " |          path_effects: `.AbstractPathEffect`\n",
      " |          paths: list of array-like\n",
      " |          picker: None or bool or float or callable\n",
      " |          pickradius: float\n",
      " |          rasterized: bool\n",
      " |          sizes: ndarray or None\n",
      " |          sketch_params: (scale: float, length: float, randomness: float)\n",
      " |          snap: bool or None\n",
      " |          transform: `.Transform`\n",
      " |          url: str\n",
      " |          urls: list of str or None\n",
      " |          verts: list of array-like\n",
      " |          verts_and_codes: unknown\n",
      " |          visible: bool\n",
      " |          zorder: float\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      fill_between : Fill between two sets of y-values.\n",
      " |      fill_betweenx : Fill between two sets of x-values.\n",
      " |  \n",
      " |  get_legend_handles_labels(self, legend_handler_map=None)\n",
      " |      Return handles and labels for legend\n",
      " |      \n",
      " |      ``ax.legend()`` is equivalent to ::\n",
      " |      \n",
      " |        h, l = ax.get_legend_handles_labels()\n",
      " |        ax.legend(h, l)\n",
      " |  \n",
      " |  get_title(self, loc='center')\n",
      " |      Get an Axes title.\n",
      " |      \n",
      " |      Get one of the three available Axes titles. The available titles\n",
      " |      are positioned above the Axes in the center, flush with the left\n",
      " |      edge, and flush with the right edge.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      loc : {'center', 'left', 'right'}, str, default: 'center'\n",
      " |          Which title to return.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      str\n",
      " |          The title text string.\n",
      " |  \n",
      " |  hexbin(self, x, y, C=None, gridsize=100, bins=None, xscale='linear', yscale='linear', extent=None, cmap=None, norm=None, vmin=None, vmax=None, alpha=None, linewidths=None, edgecolors='face', reduce_C_function=<function mean at 0x7f6f490feee0>, mincnt=None, marginals=False, *, data=None, **kwargs)\n",
      " |      Make a 2D hexagonal binning plot of points *x*, *y*.\n",
      " |      \n",
      " |      If *C* is *None*, the value of the hexagon is determined by the number\n",
      " |      of points in the hexagon. Otherwise, *C* specifies values at the\n",
      " |      coordinate (x[i], y[i]). For each hexagon, these values are reduced\n",
      " |      using *reduce_C_function*.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      x, y : array-like\n",
      " |          The data positions. *x* and *y* must be of the same length.\n",
      " |      \n",
      " |      C : array-like, optional\n",
      " |          If given, these values are accumulated in the bins. Otherwise,\n",
      " |          every point has a value of 1. Must be of the same length as *x*\n",
      " |          and *y*.\n",
      " |      \n",
      " |      gridsize : int or (int, int), default: 100\n",
      " |          If a single int, the number of hexagons in the *x*-direction.\n",
      " |          The number of hexagons in the *y*-direction is chosen such that\n",
      " |          the hexagons are approximately regular.\n",
      " |      \n",
      " |          Alternatively, if a tuple (*nx*, *ny*), the number of hexagons\n",
      " |          in the *x*-direction and the *y*-direction.\n",
      " |      \n",
      " |      bins : 'log' or int or sequence, default: None\n",
      " |          Discretization of the hexagon values.\n",
      " |      \n",
      " |          - If *None*, no binning is applied; the color of each hexagon\n",
      " |            directly corresponds to its count value.\n",
      " |          - If 'log', use a logarithmic scale for the colormap.\n",
      " |            Internally, :math:`log_{10}(i+1)` is used to determine the\n",
      " |            hexagon color. This is equivalent to ``norm=LogNorm()``.\n",
      " |          - If an integer, divide the counts in the specified number\n",
      " |            of bins, and color the hexagons accordingly.\n",
      " |          - If a sequence of values, the values of the lower bound of\n",
      " |            the bins to be used.\n",
      " |      \n",
      " |      xscale : {'linear', 'log'}, default: 'linear'\n",
      " |          Use a linear or log10 scale on the horizontal axis.\n",
      " |      \n",
      " |      yscale : {'linear', 'log'}, default: 'linear'\n",
      " |          Use a linear or log10 scale on the vertical axis.\n",
      " |      \n",
      " |      mincnt : int > 0, default: *None*\n",
      " |          If not *None*, only display cells with more than *mincnt*\n",
      " |          number of points in the cell.\n",
      " |      \n",
      " |      marginals : bool, default: *False*\n",
      " |          If marginals is *True*, plot the marginal density as\n",
      " |          colormapped rectangles along the bottom of the x-axis and\n",
      " |          left of the y-axis.\n",
      " |      \n",
      " |      extent : 4-tuple of float, default: *None*\n",
      " |          The limits of the bins (xmin, xmax, ymin, ymax).\n",
      " |          The default assigns the limits based on\n",
      " |          *gridsize*, *x*, *y*, *xscale* and *yscale*.\n",
      " |      \n",
      " |          If *xscale* or *yscale* is set to 'log', the limits are\n",
      " |          expected to be the exponent for a power of 10. E.g. for\n",
      " |          x-limits of 1 and 50 in 'linear' scale and y-limits\n",
      " |          of 10 and 1000 in 'log' scale, enter (1, 50, 1, 3).\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `~matplotlib.collections.PolyCollection`\n",
      " |          A `.PolyCollection` defining the hexagonal bins.\n",
      " |      \n",
      " |          - `.PolyCollection.get_offsets` contains a Mx2 array containing\n",
      " |            the x, y positions of the M hexagon centers.\n",
      " |          - `.PolyCollection.get_array` contains the values of the M\n",
      " |            hexagons.\n",
      " |      \n",
      " |          If *marginals* is *True*, horizontal\n",
      " |          bar and vertical bar (both PolyCollections) will be attached\n",
      " |          to the return collection as attributes *hbar* and *vbar*.\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      cmap : str or `~matplotlib.colors.Colormap`, default: :rc:`image.cmap`\n",
      " |          The Colormap instance or registered colormap name used to map\n",
      " |          the bin values to colors.\n",
      " |      \n",
      " |      norm : `~matplotlib.colors.Normalize`, optional\n",
      " |          The Normalize instance scales the bin values to the canonical\n",
      " |          colormap range [0, 1] for mapping to colors. By default, the data\n",
      " |          range is mapped to the colorbar range using linear scaling.\n",
      " |      \n",
      " |      vmin, vmax : float, default: None\n",
      " |          The colorbar range. If *None*, suitable min/max values are\n",
      " |          automatically chosen by the `.Normalize` instance (defaults to\n",
      " |          the respective min/max values of the bins in case of the default\n",
      " |          linear scaling).\n",
      " |          It is an error to use *vmin*/*vmax* when *norm* is given.\n",
      " |      \n",
      " |      alpha : float between 0 and 1, optional\n",
      " |          The alpha blending value, between 0 (transparent) and 1 (opaque).\n",
      " |      \n",
      " |      linewidths : float, default: *None*\n",
      " |          If *None*, defaults to 1.0.\n",
      " |      \n",
      " |      edgecolors : {'face', 'none', *None*} or color, default: 'face'\n",
      " |          The color of the hexagon edges. Possible values are:\n",
      " |      \n",
      " |          - 'face': Draw the edges in the same color as the fill color.\n",
      " |          - 'none': No edges are drawn. This can sometimes lead to unsightly\n",
      " |            unpainted pixels between the hexagons.\n",
      " |          - *None*: Draw outlines in the default color.\n",
      " |          - An explicit color.\n",
      " |      \n",
      " |      reduce_C_function : callable, default: `numpy.mean`\n",
      " |          The function to aggregate *C* within the bins. It is ignored if\n",
      " |          *C* is not given. This must have the signature::\n",
      " |      \n",
      " |              def reduce_C_function(C: array) -> float\n",
      " |      \n",
      " |          Commonly used functions are:\n",
      " |      \n",
      " |          - `numpy.mean`: average of the points\n",
      " |          - `numpy.sum`: integral of the point values\n",
      " |          - `numpy.amax`: value taken from the largest point\n",
      " |      \n",
      " |      data : indexable object, optional\n",
      " |          If given, the following parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception):\n",
      " |      \n",
      " |          *x*, *y*, *C*\n",
      " |      \n",
      " |      **kwargs : `~matplotlib.collections.PolyCollection` properties\n",
      " |          All other keyword arguments are passed on to `.PolyCollection`:\n",
      " |      \n",
      " |          Properties:\n",
      " |          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      " |          alpha: array-like or scalar or None\n",
      " |          animated: bool\n",
      " |          antialiased or aa or antialiaseds: bool or list of bools\n",
      " |          array: array-like or None\n",
      " |          capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          clim: (vmin: float, vmax: float)\n",
      " |          clip_box: `.Bbox`\n",
      " |          clip_on: bool\n",
      " |          clip_path: Patch or (Path, Transform) or None\n",
      " |          cmap: `.Colormap` or str or None\n",
      " |          color: color or list of rgba tuples\n",
      " |          edgecolor or ec or edgecolors: color or list of colors or 'face'\n",
      " |          facecolor or facecolors or fc: color or list of colors\n",
      " |          figure: `.Figure`\n",
      " |          gid: str\n",
      " |          hatch: {'/', '\\\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
      " |          in_layout: bool\n",
      " |          joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          label: object\n",
      " |          linestyle or dashes or linestyles or ls: str or tuple or list thereof\n",
      " |          linewidth or linewidths or lw: float or list of floats\n",
      " |          norm: `.Normalize` or None\n",
      " |          offset_transform: `.Transform`\n",
      " |          offsets: (N, 2) or (2,) array-like\n",
      " |          path_effects: `.AbstractPathEffect`\n",
      " |          paths: list of array-like\n",
      " |          picker: None or bool or float or callable\n",
      " |          pickradius: float\n",
      " |          rasterized: bool\n",
      " |          sizes: ndarray or None\n",
      " |          sketch_params: (scale: float, length: float, randomness: float)\n",
      " |          snap: bool or None\n",
      " |          transform: `.Transform`\n",
      " |          url: str\n",
      " |          urls: list of str or None\n",
      " |          verts: list of array-like\n",
      " |          verts_and_codes: unknown\n",
      " |          visible: bool\n",
      " |          zorder: float\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      hist2d : 2D histogram rectangular bins\n",
      " |  \n",
      " |  hist(self, x, bins=None, range=None, density=False, weights=None, cumulative=False, bottom=None, histtype='bar', align='mid', orientation='vertical', rwidth=None, log=False, color=None, label=None, stacked=False, *, data=None, **kwargs)\n",
      " |      Plot a histogram.\n",
      " |      \n",
      " |      Compute and draw the histogram of *x*.  The return value is a tuple\n",
      " |      (*n*, *bins*, *patches*) or ([*n0*, *n1*, ...], *bins*, [*patches0*,\n",
      " |      *patches1*, ...]) if the input contains multiple data.  See the\n",
      " |      documentation of the *weights* parameter to draw a histogram of\n",
      " |      already-binned data.\n",
      " |      \n",
      " |      Multiple data can be provided via *x* as a list of datasets\n",
      " |      of potentially different length ([*x0*, *x1*, ...]), or as\n",
      " |      a 2D ndarray in which each column is a dataset.  Note that\n",
      " |      the ndarray form is transposed relative to the list form.\n",
      " |      \n",
      " |      Masked arrays are not supported.\n",
      " |      \n",
      " |      The *bins*, *range*, *weights*, and *density* parameters behave as in\n",
      " |      `numpy.histogram`.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      x : (n,) array or sequence of (n,) arrays\n",
      " |          Input values, this takes either a single array or a sequence of\n",
      " |          arrays which are not required to be of the same length.\n",
      " |      \n",
      " |      bins : int or sequence or str, default: :rc:`hist.bins`\n",
      " |          If *bins* is an integer, it defines the number of equal-width bins\n",
      " |          in the range.\n",
      " |      \n",
      " |          If *bins* is a sequence, it defines the bin edges, including the\n",
      " |          left edge of the first bin and the right edge of the last bin;\n",
      " |          in this case, bins may be unequally spaced.  All but the last\n",
      " |          (righthand-most) bin is half-open.  In other words, if *bins* is::\n",
      " |      \n",
      " |              [1, 2, 3, 4]\n",
      " |      \n",
      " |          then the first bin is ``[1, 2)`` (including 1, but excluding 2) and\n",
      " |          the second ``[2, 3)``.  The last bin, however, is ``[3, 4]``, which\n",
      " |          *includes* 4.\n",
      " |      \n",
      " |          If *bins* is a string, it is one of the binning strategies\n",
      " |          supported by `numpy.histogram_bin_edges`: 'auto', 'fd', 'doane',\n",
      " |          'scott', 'stone', 'rice', 'sturges', or 'sqrt'.\n",
      " |      \n",
      " |      range : tuple or None, default: None\n",
      " |          The lower and upper range of the bins. Lower and upper outliers\n",
      " |          are ignored. If not provided, *range* is ``(x.min(), x.max())``.\n",
      " |          Range has no effect if *bins* is a sequence.\n",
      " |      \n",
      " |          If *bins* is a sequence or *range* is specified, autoscaling\n",
      " |          is based on the specified bin range instead of the\n",
      " |          range of x.\n",
      " |      \n",
      " |      density : bool, default: False\n",
      " |          If ``True``, draw and return a probability density: each bin\n",
      " |          will display the bin's raw count divided by the total number of\n",
      " |          counts *and the bin width*\n",
      " |          (``density = counts / (sum(counts) * np.diff(bins))``),\n",
      " |          so that the area under the histogram integrates to 1\n",
      " |          (``np.sum(density * np.diff(bins)) == 1``).\n",
      " |      \n",
      " |          If *stacked* is also ``True``, the sum of the histograms is\n",
      " |          normalized to 1.\n",
      " |      \n",
      " |      weights : (n,) array-like or None, default: None\n",
      " |          An array of weights, of the same shape as *x*.  Each value in\n",
      " |          *x* only contributes its associated weight towards the bin count\n",
      " |          (instead of 1).  If *density* is ``True``, the weights are\n",
      " |          normalized, so that the integral of the density over the range\n",
      " |          remains 1.\n",
      " |      \n",
      " |          This parameter can be used to draw a histogram of data that has\n",
      " |          already been binned, e.g. using `numpy.histogram` (by treating each\n",
      " |          bin as a single point with a weight equal to its count) ::\n",
      " |      \n",
      " |              counts, bins = np.histogram(data)\n",
      " |              plt.hist(bins[:-1], bins, weights=counts)\n",
      " |      \n",
      " |          (or you may alternatively use `~.bar()`).\n",
      " |      \n",
      " |      cumulative : bool or -1, default: False\n",
      " |          If ``True``, then a histogram is computed where each bin gives the\n",
      " |          counts in that bin plus all bins for smaller values. The last bin\n",
      " |          gives the total number of datapoints.\n",
      " |      \n",
      " |          If *density* is also ``True`` then the histogram is normalized such\n",
      " |          that the last bin equals 1.\n",
      " |      \n",
      " |          If *cumulative* is a number less than 0 (e.g., -1), the direction\n",
      " |          of accumulation is reversed.  In this case, if *density* is also\n",
      " |          ``True``, then the histogram is normalized such that the first bin\n",
      " |          equals 1.\n",
      " |      \n",
      " |      bottom : array-like, scalar, or None, default: None\n",
      " |          Location of the bottom of each bin, ie. bins are drawn from\n",
      " |          ``bottom`` to ``bottom + hist(x, bins)`` If a scalar, the bottom\n",
      " |          of each bin is shifted by the same amount. If an array, each bin\n",
      " |          is shifted independently and the length of bottom must match the\n",
      " |          number of bins. If None, defaults to 0.\n",
      " |      \n",
      " |      histtype : {'bar', 'barstacked', 'step', 'stepfilled'}, default: 'bar'\n",
      " |          The type of histogram to draw.\n",
      " |      \n",
      " |          - 'bar' is a traditional bar-type histogram.  If multiple data\n",
      " |            are given the bars are arranged side by side.\n",
      " |          - 'barstacked' is a bar-type histogram where multiple\n",
      " |            data are stacked on top of each other.\n",
      " |          - 'step' generates a lineplot that is by default unfilled.\n",
      " |          - 'stepfilled' generates a lineplot that is by default filled.\n",
      " |      \n",
      " |      align : {'left', 'mid', 'right'}, default: 'mid'\n",
      " |          The horizontal alignment of the histogram bars.\n",
      " |      \n",
      " |          - 'left': bars are centered on the left bin edges.\n",
      " |          - 'mid': bars are centered between the bin edges.\n",
      " |          - 'right': bars are centered on the right bin edges.\n",
      " |      \n",
      " |      orientation : {'vertical', 'horizontal'}, default: 'vertical'\n",
      " |          If 'horizontal', `~.Axes.barh` will be used for bar-type histograms\n",
      " |          and the *bottom* kwarg will be the left edges.\n",
      " |      \n",
      " |      rwidth : float or None, default: None\n",
      " |          The relative width of the bars as a fraction of the bin width.  If\n",
      " |          ``None``, automatically compute the width.\n",
      " |      \n",
      " |          Ignored if *histtype* is 'step' or 'stepfilled'.\n",
      " |      \n",
      " |      log : bool, default: False\n",
      " |          If ``True``, the histogram axis will be set to a log scale.\n",
      " |      \n",
      " |      color : color or array-like of colors or None, default: None\n",
      " |          Color or sequence of colors, one per dataset.  Default (``None``)\n",
      " |          uses the standard line color sequence.\n",
      " |      \n",
      " |      label : str or None, default: None\n",
      " |          String, or sequence of strings to match multiple datasets.  Bar\n",
      " |          charts yield multiple patches per dataset, but only the first gets\n",
      " |          the label, so that `~.Axes.legend` will work as expected.\n",
      " |      \n",
      " |      stacked : bool, default: False\n",
      " |          If ``True``, multiple data are stacked on top of each other If\n",
      " |          ``False`` multiple data are arranged side by side if histtype is\n",
      " |          'bar' or on top of each other if histtype is 'step'\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      n : array or list of arrays\n",
      " |          The values of the histogram bins. See *density* and *weights* for a\n",
      " |          description of the possible semantics.  If input *x* is an array,\n",
      " |          then this is an array of length *nbins*. If input is a sequence of\n",
      " |          arrays ``[data1, data2, ...]``, then this is a list of arrays with\n",
      " |          the values of the histograms for each of the arrays in the same\n",
      " |          order.  The dtype of the array *n* (or of its element arrays) will\n",
      " |          always be float even if no weighting or normalization is used.\n",
      " |      \n",
      " |      bins : array\n",
      " |          The edges of the bins. Length nbins + 1 (nbins left edges and right\n",
      " |          edge of last bin).  Always a single array even when multiple data\n",
      " |          sets are passed in.\n",
      " |      \n",
      " |      patches : `.BarContainer` or list of a single `.Polygon` or list of such objects\n",
      " |          Container of individual artists used to create the histogram\n",
      " |          or list of such containers if there are multiple input datasets.\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      data : indexable object, optional\n",
      " |          If given, the following parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception):\n",
      " |      \n",
      " |          *x*, *weights*\n",
      " |      \n",
      " |      **kwargs\n",
      " |          `~matplotlib.patches.Patch` properties\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      hist2d : 2D histogram with rectangular bins\n",
      " |      hexbin : 2D histogram with hexagonal bins\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      For large numbers of bins (>1000), 'step' and 'stepfilled' can be\n",
      " |      significantly faster than 'bar' and 'barstacked'.\n",
      " |  \n",
      " |  hist2d(self, x, y, bins=10, range=None, density=False, weights=None, cmin=None, cmax=None, *, data=None, **kwargs)\n",
      " |      Make a 2D histogram plot.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      x, y : array-like, shape (n, )\n",
      " |          Input values\n",
      " |      \n",
      " |      bins : None or int or [int, int] or array-like or [array, array]\n",
      " |      \n",
      " |          The bin specification:\n",
      " |      \n",
      " |          - If int, the number of bins for the two dimensions\n",
      " |            (nx=ny=bins).\n",
      " |          - If ``[int, int]``, the number of bins in each dimension\n",
      " |            (nx, ny = bins).\n",
      " |          - If array-like, the bin edges for the two dimensions\n",
      " |            (x_edges=y_edges=bins).\n",
      " |          - If ``[array, array]``, the bin edges in each dimension\n",
      " |            (x_edges, y_edges = bins).\n",
      " |      \n",
      " |          The default value is 10.\n",
      " |      \n",
      " |      range : array-like shape(2, 2), optional\n",
      " |          The leftmost and rightmost edges of the bins along each dimension\n",
      " |          (if not specified explicitly in the bins parameters): ``[[xmin,\n",
      " |          xmax], [ymin, ymax]]``. All values outside of this range will be\n",
      " |          considered outliers and not tallied in the histogram.\n",
      " |      \n",
      " |      density : bool, default: False\n",
      " |          Normalize histogram.  See the documentation for the *density*\n",
      " |          parameter of `~.Axes.hist` for more details.\n",
      " |      \n",
      " |      weights : array-like, shape (n, ), optional\n",
      " |          An array of values w_i weighing each sample (x_i, y_i).\n",
      " |      \n",
      " |      cmin, cmax : float, default: None\n",
      " |          All bins that has count less than *cmin* or more than *cmax* will\n",
      " |          not be displayed (set to NaN before passing to imshow) and these\n",
      " |          count values in the return value count histogram will also be set\n",
      " |          to nan upon return.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      h : 2D array\n",
      " |          The bi-dimensional histogram of samples x and y. Values in x are\n",
      " |          histogrammed along the first dimension and values in y are\n",
      " |          histogrammed along the second dimension.\n",
      " |      xedges : 1D array\n",
      " |          The bin edges along the x axis.\n",
      " |      yedges : 1D array\n",
      " |          The bin edges along the y axis.\n",
      " |      image : `~.matplotlib.collections.QuadMesh`\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      cmap : Colormap or str, optional\n",
      " |          A `.colors.Colormap` instance.  If not set, use rc settings.\n",
      " |      \n",
      " |      norm : Normalize, optional\n",
      " |          A `.colors.Normalize` instance is used to\n",
      " |          scale luminance data to ``[0, 1]``. If not set, defaults to\n",
      " |          `.colors.Normalize()`.\n",
      " |      \n",
      " |      vmin/vmax : None or scalar, optional\n",
      " |          Arguments passed to the `~.colors.Normalize` instance.\n",
      " |      \n",
      " |      alpha : ``0 <= scalar <= 1`` or ``None``, optional\n",
      " |          The alpha blending value.\n",
      " |      \n",
      " |      data : indexable object, optional\n",
      " |          If given, the following parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception):\n",
      " |      \n",
      " |          *x*, *y*, *weights*\n",
      " |      \n",
      " |      **kwargs\n",
      " |          Additional parameters are passed along to the\n",
      " |          `~.Axes.pcolormesh` method and `~matplotlib.collections.QuadMesh`\n",
      " |          constructor.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      hist : 1D histogram plotting\n",
      " |      hexbin : 2D histogram with hexagonal bins\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      - Currently ``hist2d`` calculates its own axis limits, and any limits\n",
      " |        previously set are ignored.\n",
      " |      - Rendering the histogram with a logarithmic color scale is\n",
      " |        accomplished by passing a `.colors.LogNorm` instance to the *norm*\n",
      " |        keyword argument. Likewise, power-law normalization (similar\n",
      " |        in effect to gamma correction) can be accomplished with\n",
      " |        `.colors.PowerNorm`.\n",
      " |  \n",
      " |  hlines(self, y, xmin, xmax, colors=None, linestyles='solid', label='', *, data=None, **kwargs)\n",
      " |      Plot horizontal lines at each *y* from *xmin* to *xmax*.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      y : float or array-like\n",
      " |          y-indexes where to plot the lines.\n",
      " |      \n",
      " |      xmin, xmax : float or array-like\n",
      " |          Respective beginning and end of each line. If scalars are\n",
      " |          provided, all lines will have same length.\n",
      " |      \n",
      " |      colors : list of colors, default: :rc:`lines.color`\n",
      " |      \n",
      " |      linestyles : {'solid', 'dashed', 'dashdot', 'dotted'}, optional\n",
      " |      \n",
      " |      label : str, default: ''\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `~matplotlib.collections.LineCollection`\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      data : indexable object, optional\n",
      " |          If given, the following parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception):\n",
      " |      \n",
      " |          *y*, *xmin*, *xmax*, *colors*\n",
      " |      **kwargs :  `~matplotlib.collections.LineCollection` properties.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      vlines : vertical lines\n",
      " |      axhline : horizontal line across the Axes\n",
      " |  \n",
      " |  imshow(self, X, cmap=None, norm=None, *, aspect=None, interpolation=None, alpha=None, vmin=None, vmax=None, origin=None, extent=None, interpolation_stage=None, filternorm=True, filterrad=4.0, resample=None, url=None, data=None, **kwargs)\n",
      " |      Display data as an image, i.e., on a 2D regular raster.\n",
      " |      \n",
      " |      The input may either be actual RGB(A) data, or 2D scalar data, which\n",
      " |      will be rendered as a pseudocolor image. For displaying a grayscale\n",
      " |      image set up the colormapping using the parameters\n",
      " |      ``cmap='gray', vmin=0, vmax=255``.\n",
      " |      \n",
      " |      The number of pixels used to render an image is set by the Axes size\n",
      " |      and the *dpi* of the figure. This can lead to aliasing artifacts when\n",
      " |      the image is resampled because the displayed image size will usually\n",
      " |      not match the size of *X* (see\n",
      " |      :doc:`/gallery/images_contours_and_fields/image_antialiasing`).\n",
      " |      The resampling can be controlled via the *interpolation* parameter\n",
      " |      and/or :rc:`image.interpolation`.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      X : array-like or PIL image\n",
      " |          The image data. Supported array shapes are:\n",
      " |      \n",
      " |          - (M, N): an image with scalar data. The values are mapped to\n",
      " |            colors using normalization and a colormap. See parameters *norm*,\n",
      " |            *cmap*, *vmin*, *vmax*.\n",
      " |          - (M, N, 3): an image with RGB values (0-1 float or 0-255 int).\n",
      " |          - (M, N, 4): an image with RGBA values (0-1 float or 0-255 int),\n",
      " |            i.e. including transparency.\n",
      " |      \n",
      " |          The first two dimensions (M, N) define the rows and columns of\n",
      " |          the image.\n",
      " |      \n",
      " |          Out-of-range RGB(A) values are clipped.\n",
      " |      \n",
      " |      cmap : str or `~matplotlib.colors.Colormap`, default: :rc:`image.cmap`\n",
      " |          The Colormap instance or registered colormap name used to map\n",
      " |          scalar data to colors. This parameter is ignored for RGB(A) data.\n",
      " |      \n",
      " |      norm : `~matplotlib.colors.Normalize`, optional\n",
      " |          The `.Normalize` instance used to scale scalar data to the [0, 1]\n",
      " |          range before mapping to colors using *cmap*. By default, a linear\n",
      " |          scaling mapping the lowest value to 0 and the highest to 1 is used.\n",
      " |          This parameter is ignored for RGB(A) data.\n",
      " |      \n",
      " |      aspect : {'equal', 'auto'} or float, default: :rc:`image.aspect`\n",
      " |          The aspect ratio of the Axes.  This parameter is particularly\n",
      " |          relevant for images since it determines whether data pixels are\n",
      " |          square.\n",
      " |      \n",
      " |          This parameter is a shortcut for explicitly calling\n",
      " |          `.Axes.set_aspect`. See there for further details.\n",
      " |      \n",
      " |          - 'equal': Ensures an aspect ratio of 1. Pixels will be square\n",
      " |            (unless pixel sizes are explicitly made non-square in data\n",
      " |            coordinates using *extent*).\n",
      " |          - 'auto': The Axes is kept fixed and the aspect is adjusted so\n",
      " |            that the data fit in the Axes. In general, this will result in\n",
      " |            non-square pixels.\n",
      " |      \n",
      " |      interpolation : str, default: :rc:`image.interpolation`\n",
      " |          The interpolation method used.\n",
      " |      \n",
      " |          Supported values are 'none', 'antialiased', 'nearest', 'bilinear',\n",
      " |          'bicubic', 'spline16', 'spline36', 'hanning', 'hamming', 'hermite',\n",
      " |          'kaiser', 'quadric', 'catrom', 'gaussian', 'bessel', 'mitchell',\n",
      " |          'sinc', 'lanczos', 'blackman'.\n",
      " |      \n",
      " |          If *interpolation* is 'none', then no interpolation is performed\n",
      " |          on the Agg, ps, pdf and svg backends. Other backends will fall back\n",
      " |          to 'nearest'. Note that most SVG renderers perform interpolation at\n",
      " |          rendering and that the default interpolation method they implement\n",
      " |          may differ.\n",
      " |      \n",
      " |          If *interpolation* is the default 'antialiased', then 'nearest'\n",
      " |          interpolation is used if the image is upsampled by more than a\n",
      " |          factor of three (i.e. the number of display pixels is at least\n",
      " |          three times the size of the data array).  If the upsampling rate is\n",
      " |          smaller than 3, or the image is downsampled, then 'hanning'\n",
      " |          interpolation is used to act as an anti-aliasing filter, unless the\n",
      " |          image happens to be upsampled by exactly a factor of two or one.\n",
      " |      \n",
      " |          See\n",
      " |          :doc:`/gallery/images_contours_and_fields/interpolation_methods`\n",
      " |          for an overview of the supported interpolation methods, and\n",
      " |          :doc:`/gallery/images_contours_and_fields/image_antialiasing` for\n",
      " |          a discussion of image antialiasing.\n",
      " |      \n",
      " |          Some interpolation methods require an additional radius parameter,\n",
      " |          which can be set by *filterrad*. Additionally, the antigrain image\n",
      " |          resize filter is controlled by the parameter *filternorm*.\n",
      " |      \n",
      " |      interpolation_stage : {'data', 'rgba'}, default: 'data'\n",
      " |          If 'data', interpolation\n",
      " |          is carried out on the data provided by the user.  If 'rgba', the\n",
      " |          interpolation is carried out after the colormapping has been\n",
      " |          applied (visual interpolation).\n",
      " |      \n",
      " |      alpha : float or array-like, optional\n",
      " |          The alpha blending value, between 0 (transparent) and 1 (opaque).\n",
      " |          If *alpha* is an array, the alpha blending values are applied pixel\n",
      " |          by pixel, and *alpha* must have the same shape as *X*.\n",
      " |      \n",
      " |      vmin, vmax : float, optional\n",
      " |          When using scalar data and no explicit *norm*, *vmin* and *vmax*\n",
      " |          define the data range that the colormap covers. By default,\n",
      " |          the colormap covers the complete value range of the supplied\n",
      " |          data. It is an error to use *vmin*/*vmax* when *norm* is given.\n",
      " |          When using RGB(A) data, parameters *vmin*/*vmax* are ignored.\n",
      " |      \n",
      " |      origin : {'upper', 'lower'}, default: :rc:`image.origin`\n",
      " |          Place the [0, 0] index of the array in the upper left or lower\n",
      " |          left corner of the Axes. The convention (the default) 'upper' is\n",
      " |          typically used for matrices and images.\n",
      " |      \n",
      " |          Note that the vertical axis points upward for 'lower'\n",
      " |          but downward for 'upper'.\n",
      " |      \n",
      " |          See the :doc:`/tutorials/intermediate/imshow_extent` tutorial for\n",
      " |          examples and a more detailed description.\n",
      " |      \n",
      " |      extent : floats (left, right, bottom, top), optional\n",
      " |          The bounding box in data coordinates that the image will fill.\n",
      " |          The image is stretched individually along x and y to fill the box.\n",
      " |      \n",
      " |          The default extent is determined by the following conditions.\n",
      " |          Pixels have unit size in data coordinates. Their centers are on\n",
      " |          integer coordinates, and their center coordinates range from 0 to\n",
      " |          columns-1 horizontally and from 0 to rows-1 vertically.\n",
      " |      \n",
      " |          Note that the direction of the vertical axis and thus the default\n",
      " |          values for top and bottom depend on *origin*:\n",
      " |      \n",
      " |          - For ``origin == 'upper'`` the default is\n",
      " |            ``(-0.5, numcols-0.5, numrows-0.5, -0.5)``.\n",
      " |          - For ``origin == 'lower'`` the default is\n",
      " |            ``(-0.5, numcols-0.5, -0.5, numrows-0.5)``.\n",
      " |      \n",
      " |          See the :doc:`/tutorials/intermediate/imshow_extent` tutorial for\n",
      " |          examples and a more detailed description.\n",
      " |      \n",
      " |      filternorm : bool, default: True\n",
      " |          A parameter for the antigrain image resize filter (see the\n",
      " |          antigrain documentation).  If *filternorm* is set, the filter\n",
      " |          normalizes integer values and corrects the rounding errors. It\n",
      " |          doesn't do anything with the source floating point values, it\n",
      " |          corrects only integers according to the rule of 1.0 which means\n",
      " |          that any sum of pixel weights must be equal to 1.0.  So, the\n",
      " |          filter function must produce a graph of the proper shape.\n",
      " |      \n",
      " |      filterrad : float > 0, default: 4.0\n",
      " |          The filter radius for filters that have a radius parameter, i.e.\n",
      " |          when interpolation is one of: 'sinc', 'lanczos' or 'blackman'.\n",
      " |      \n",
      " |      resample : bool, default: :rc:`image.resample`\n",
      " |          When *True*, use a full resampling method.  When *False*, only\n",
      " |          resample when the output image is larger than the input image.\n",
      " |      \n",
      " |      url : str, optional\n",
      " |          Set the url of the created `.AxesImage`. See `.Artist.set_url`.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `~matplotlib.image.AxesImage`\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      data : indexable object, optional\n",
      " |          If given, all parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception).\n",
      " |      \n",
      " |      **kwargs : `~matplotlib.artist.Artist` properties\n",
      " |          These parameters are passed on to the constructor of the\n",
      " |          `.AxesImage` artist.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      matshow : Plot a matrix or an array as an image.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      Unless *extent* is used, pixel centers will be located at integer\n",
      " |      coordinates. In other words: the origin will coincide with the center\n",
      " |      of pixel (0, 0).\n",
      " |      \n",
      " |      There are two common representations for RGB images with an alpha\n",
      " |      channel:\n",
      " |      \n",
      " |      -   Straight (unassociated) alpha: R, G, and B channels represent the\n",
      " |          color of the pixel, disregarding its opacity.\n",
      " |      -   Premultiplied (associated) alpha: R, G, and B channels represent\n",
      " |          the color of the pixel, adjusted for its opacity by multiplication.\n",
      " |      \n",
      " |      `~matplotlib.pyplot.imshow` expects RGB images adopting the straight\n",
      " |      (unassociated) alpha representation.\n",
      " |  \n",
      " |  indicate_inset(self, bounds, inset_ax=None, *, transform=None, facecolor='none', edgecolor='0.5', alpha=0.5, zorder=4.99, **kwargs)\n",
      " |      Add an inset indicator to the Axes.  This is a rectangle on the plot\n",
      " |      at the position indicated by *bounds* that optionally has lines that\n",
      " |      connect the rectangle to an inset Axes (`.Axes.inset_axes`).\n",
      " |      \n",
      " |      Warnings\n",
      " |      --------\n",
      " |      This method is experimental as of 3.0, and the API may change.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      bounds : [x0, y0, width, height]\n",
      " |          Lower-left corner of rectangle to be marked, and its width\n",
      " |          and height.\n",
      " |      \n",
      " |      inset_ax : `.Axes`\n",
      " |          An optional inset Axes to draw connecting lines to.  Two lines are\n",
      " |          drawn connecting the indicator box to the inset Axes on corners\n",
      " |          chosen so as to not overlap with the indicator box.\n",
      " |      \n",
      " |      transform : `.Transform`\n",
      " |          Transform for the rectangle coordinates. Defaults to\n",
      " |          `ax.transAxes`, i.e. the units of *rect* are in Axes-relative\n",
      " |          coordinates.\n",
      " |      \n",
      " |      facecolor : color, default: 'none'\n",
      " |          Facecolor of the rectangle.\n",
      " |      \n",
      " |      edgecolor : color, default: '0.5'\n",
      " |          Color of the rectangle and color of the connecting lines.\n",
      " |      \n",
      " |      alpha : float, default: 0.5\n",
      " |          Transparency of the rectangle and connector lines.\n",
      " |      \n",
      " |      zorder : float, default: 4.99\n",
      " |          Drawing order of the rectangle and connector lines.  The default,\n",
      " |          4.99, is just below the default level of inset Axes.\n",
      " |      \n",
      " |      **kwargs\n",
      " |          Other keyword arguments are passed on to the `.Rectangle` patch:\n",
      " |      \n",
      " |          Properties:\n",
      " |          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      " |          alpha: scalar or None\n",
      " |          angle: unknown\n",
      " |          animated: bool\n",
      " |          antialiased or aa: bool or None\n",
      " |          bounds: (left, bottom, width, height)\n",
      " |          capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          clip_box: `.Bbox`\n",
      " |          clip_on: bool\n",
      " |          clip_path: Patch or (Path, Transform) or None\n",
      " |          color: color\n",
      " |          edgecolor or ec: color or None\n",
      " |          facecolor or fc: color or None\n",
      " |          figure: `.Figure`\n",
      " |          fill: bool\n",
      " |          gid: str\n",
      " |          hatch: {'/', '\\\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
      " |          height: unknown\n",
      " |          in_layout: bool\n",
      " |          joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          label: object\n",
      " |          linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      " |          linewidth or lw: float or None\n",
      " |          path_effects: `.AbstractPathEffect`\n",
      " |          picker: None or bool or float or callable\n",
      " |          rasterized: bool\n",
      " |          sketch_params: (scale: float, length: float, randomness: float)\n",
      " |          snap: bool or None\n",
      " |          transform: `.Transform`\n",
      " |          url: str\n",
      " |          visible: bool\n",
      " |          width: unknown\n",
      " |          x: unknown\n",
      " |          xy: (float, float)\n",
      " |          y: unknown\n",
      " |          zorder: float\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      rectangle_patch : `.patches.Rectangle`\n",
      " |           The indicator frame.\n",
      " |      \n",
      " |      connector_lines : 4-tuple of `.patches.ConnectionPatch`\n",
      " |          The four connector lines connecting to (lower_left, upper_left,\n",
      " |          lower_right upper_right) corners of *inset_ax*. Two lines are\n",
      " |          set with visibility to *False*,  but the user can set the\n",
      " |          visibility to True if the automatic choice is not deemed correct.\n",
      " |  \n",
      " |  indicate_inset_zoom(self, inset_ax, **kwargs)\n",
      " |      Add an inset indicator rectangle to the Axes based on the axis\n",
      " |      limits for an *inset_ax* and draw connectors between *inset_ax*\n",
      " |      and the rectangle.\n",
      " |      \n",
      " |      Warnings\n",
      " |      --------\n",
      " |      This method is experimental as of 3.0, and the API may change.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      inset_ax : `.Axes`\n",
      " |          Inset Axes to draw connecting lines to.  Two lines are\n",
      " |          drawn connecting the indicator box to the inset Axes on corners\n",
      " |          chosen so as to not overlap with the indicator box.\n",
      " |      \n",
      " |      **kwargs\n",
      " |          Other keyword arguments are passed on to `.Axes.indicate_inset`\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      rectangle_patch : `.patches.Rectangle`\n",
      " |           Rectangle artist.\n",
      " |      \n",
      " |      connector_lines : 4-tuple of `.patches.ConnectionPatch`\n",
      " |          Each of four connector lines coming from the rectangle drawn on\n",
      " |          this axis, in the order lower left, upper left, lower right,\n",
      " |          upper right.\n",
      " |          Two are set with visibility to *False*,  but the user can\n",
      " |          set the visibility to *True* if the automatic choice is not deemed\n",
      " |          correct.\n",
      " |  \n",
      " |  inset_axes(self, bounds, *, transform=None, zorder=5, **kwargs)\n",
      " |      Add a child inset Axes to this existing Axes.\n",
      " |      \n",
      " |      Warnings\n",
      " |      --------\n",
      " |      This method is experimental as of 3.0, and the API may change.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      bounds : [x0, y0, width, height]\n",
      " |          Lower-left corner of inset Axes, and its width and height.\n",
      " |      \n",
      " |      transform : `.Transform`\n",
      " |          Defaults to `ax.transAxes`, i.e. the units of *rect* are in\n",
      " |          Axes-relative coordinates.\n",
      " |      \n",
      " |      zorder : number\n",
      " |          Defaults to 5 (same as `.Axes.legend`).  Adjust higher or lower\n",
      " |          to change whether it is above or below data plotted on the\n",
      " |          parent Axes.\n",
      " |      \n",
      " |      **kwargs\n",
      " |          Other keyword arguments are passed on to the child `.Axes`.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      ax\n",
      " |          The created `~.axes.Axes` instance.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      This example makes two inset Axes, the first is in Axes-relative\n",
      " |      coordinates, and the second in data-coordinates::\n",
      " |      \n",
      " |          fig, ax = plt.subplots()\n",
      " |          ax.plot(range(10))\n",
      " |          axin1 = ax.inset_axes([0.8, 0.1, 0.15, 0.15])\n",
      " |          axin2 = ax.inset_axes(\n",
      " |                  [5, 7, 2.3, 2.3], transform=ax.transData)\n",
      " |  \n",
      " |  legend(self, *args, **kwargs)\n",
      " |      Place a legend on the Axes.\n",
      " |      \n",
      " |      Call signatures::\n",
      " |      \n",
      " |          legend()\n",
      " |          legend(handles, labels)\n",
      " |          legend(handles=handles)\n",
      " |          legend(labels)\n",
      " |      \n",
      " |      The call signatures correspond to the following different ways to use\n",
      " |      this method:\n",
      " |      \n",
      " |      **1. Automatic detection of elements to be shown in the legend**\n",
      " |      \n",
      " |      The elements to be added to the legend are automatically determined,\n",
      " |      when you do not pass in any extra arguments.\n",
      " |      \n",
      " |      In this case, the labels are taken from the artist. You can specify\n",
      " |      them either at artist creation or by calling the\n",
      " |      :meth:`~.Artist.set_label` method on the artist::\n",
      " |      \n",
      " |          ax.plot([1, 2, 3], label='Inline label')\n",
      " |          ax.legend()\n",
      " |      \n",
      " |      or::\n",
      " |      \n",
      " |          line, = ax.plot([1, 2, 3])\n",
      " |          line.set_label('Label via method')\n",
      " |          ax.legend()\n",
      " |      \n",
      " |      Specific lines can be excluded from the automatic legend element\n",
      " |      selection by defining a label starting with an underscore.\n",
      " |      This is default for all artists, so calling `.Axes.legend` without\n",
      " |      any arguments and without setting the labels manually will result in\n",
      " |      no legend being drawn.\n",
      " |      \n",
      " |      \n",
      " |      **2. Explicitly listing the artists and labels in the legend**\n",
      " |      \n",
      " |      For full control of which artists have a legend entry, it is possible\n",
      " |      to pass an iterable of legend artists followed by an iterable of\n",
      " |      legend labels respectively::\n",
      " |      \n",
      " |          ax.legend([line1, line2, line3], ['label1', 'label2', 'label3'])\n",
      " |      \n",
      " |      \n",
      " |      **3. Explicitly listing the artists in the legend**\n",
      " |      \n",
      " |      This is similar to 2, but the labels are taken from the artists'\n",
      " |      label properties. Example::\n",
      " |      \n",
      " |          line1, = ax.plot([1, 2, 3], label='label1')\n",
      " |          line2, = ax.plot([1, 2, 3], label='label2')\n",
      " |          ax.legend(handles=[line1, line2])\n",
      " |      \n",
      " |      \n",
      " |      **4. Labeling existing plot elements**\n",
      " |      \n",
      " |      .. admonition:: Discouraged\n",
      " |      \n",
      " |          This call signature is discouraged, because the relation between\n",
      " |          plot elements and labels is only implicit by their order and can\n",
      " |          easily be mixed up.\n",
      " |      \n",
      " |      To make a legend for all artists on an Axes, call this function with\n",
      " |      an iterable of strings, one for each legend item. For example::\n",
      " |      \n",
      " |          ax.plot([1, 2, 3])\n",
      " |          ax.plot([5, 6, 7])\n",
      " |          ax.legend(['First line', 'Second line'])\n",
      " |      \n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      handles : sequence of `.Artist`, optional\n",
      " |          A list of Artists (lines, patches) to be added to the legend.\n",
      " |          Use this together with *labels*, if you need full control on what\n",
      " |          is shown in the legend and the automatic mechanism described above\n",
      " |          is not sufficient.\n",
      " |      \n",
      " |          The length of handles and labels should be the same in this\n",
      " |          case. If they are not, they are truncated to the smaller length.\n",
      " |      \n",
      " |      labels : list of str, optional\n",
      " |          A list of labels to show next to the artists.\n",
      " |          Use this together with *handles*, if you need full control on what\n",
      " |          is shown in the legend and the automatic mechanism described above\n",
      " |          is not sufficient.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `~matplotlib.legend.Legend`\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      \n",
      " |      loc : str or pair of floats, default: :rc:`legend.loc` ('best' for axes, 'upper right' for figures)\n",
      " |          The location of the legend.\n",
      " |      \n",
      " |          The strings\n",
      " |          ``'upper left', 'upper right', 'lower left', 'lower right'``\n",
      " |          place the legend at the corresponding corner of the axes/figure.\n",
      " |      \n",
      " |          The strings\n",
      " |          ``'upper center', 'lower center', 'center left', 'center right'``\n",
      " |          place the legend at the center of the corresponding edge of the\n",
      " |          axes/figure.\n",
      " |      \n",
      " |          The string ``'center'`` places the legend at the center of the axes/figure.\n",
      " |      \n",
      " |          The string ``'best'`` places the legend at the location, among the nine\n",
      " |          locations defined so far, with the minimum overlap with other drawn\n",
      " |          artists.  This option can be quite slow for plots with large amounts of\n",
      " |          data; your plotting speed may benefit from providing a specific location.\n",
      " |      \n",
      " |          The location can also be a 2-tuple giving the coordinates of the lower-left\n",
      " |          corner of the legend in axes coordinates (in which case *bbox_to_anchor*\n",
      " |          will be ignored).\n",
      " |      \n",
      " |          For back-compatibility, ``'center right'`` (but no other location) can also\n",
      " |          be spelled ``'right'``, and each \"string\" locations can also be given as a\n",
      " |          numeric value:\n",
      " |      \n",
      " |              ===============   =============\n",
      " |              Location String   Location Code\n",
      " |              ===============   =============\n",
      " |              'best'            0\n",
      " |              'upper right'     1\n",
      " |              'upper left'      2\n",
      " |              'lower left'      3\n",
      " |              'lower right'     4\n",
      " |              'right'           5\n",
      " |              'center left'     6\n",
      " |              'center right'    7\n",
      " |              'lower center'    8\n",
      " |              'upper center'    9\n",
      " |              'center'          10\n",
      " |              ===============   =============\n",
      " |      \n",
      " |      bbox_to_anchor : `.BboxBase`, 2-tuple, or 4-tuple of floats\n",
      " |          Box that is used to position the legend in conjunction with *loc*.\n",
      " |          Defaults to `axes.bbox` (if called as a method to `.Axes.legend`) or\n",
      " |          `figure.bbox` (if `.Figure.legend`).  This argument allows arbitrary\n",
      " |          placement of the legend.\n",
      " |      \n",
      " |          Bbox coordinates are interpreted in the coordinate system given by\n",
      " |          *bbox_transform*, with the default transform\n",
      " |          Axes or Figure coordinates, depending on which ``legend`` is called.\n",
      " |      \n",
      " |          If a 4-tuple or `.BboxBase` is given, then it specifies the bbox\n",
      " |          ``(x, y, width, height)`` that the legend is placed in.\n",
      " |          To put the legend in the best location in the bottom right\n",
      " |          quadrant of the axes (or figure)::\n",
      " |      \n",
      " |              loc='best', bbox_to_anchor=(0.5, 0., 0.5, 0.5)\n",
      " |      \n",
      " |          A 2-tuple ``(x, y)`` places the corner of the legend specified by *loc* at\n",
      " |          x, y.  For example, to put the legend's upper right-hand corner in the\n",
      " |          center of the axes (or figure) the following keywords can be used::\n",
      " |      \n",
      " |              loc='upper right', bbox_to_anchor=(0.5, 0.5)\n",
      " |      \n",
      " |      ncol : int, default: 1\n",
      " |          The number of columns that the legend has.\n",
      " |      \n",
      " |      prop : None or `matplotlib.font_manager.FontProperties` or dict\n",
      " |          The font properties of the legend. If None (default), the current\n",
      " |          :data:`matplotlib.rcParams` will be used.\n",
      " |      \n",
      " |      fontsize : int or {'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'}\n",
      " |          The font size of the legend. If the value is numeric the size will be the\n",
      " |          absolute font size in points. String values are relative to the current\n",
      " |          default font size. This argument is only used if *prop* is not specified.\n",
      " |      \n",
      " |      labelcolor : str or list, default: :rc:`legend.labelcolor`\n",
      " |          The color of the text in the legend. Either a valid color string\n",
      " |          (for example, 'red'), or a list of color strings. The labelcolor can\n",
      " |          also be made to match the color of the line or marker using 'linecolor',\n",
      " |          'markerfacecolor' (or 'mfc'), or 'markeredgecolor' (or 'mec').\n",
      " |      \n",
      " |          Labelcolor can be set globally using :rc:`legend.labelcolor`. If None,\n",
      " |          use :rc:`text.color`.\n",
      " |      \n",
      " |      numpoints : int, default: :rc:`legend.numpoints`\n",
      " |          The number of marker points in the legend when creating a legend\n",
      " |          entry for a `.Line2D` (line).\n",
      " |      \n",
      " |      scatterpoints : int, default: :rc:`legend.scatterpoints`\n",
      " |          The number of marker points in the legend when creating\n",
      " |          a legend entry for a `.PathCollection` (scatter plot).\n",
      " |      \n",
      " |      scatteryoffsets : iterable of floats, default: ``[0.375, 0.5, 0.3125]``\n",
      " |          The vertical offset (relative to the font size) for the markers\n",
      " |          created for a scatter plot legend entry. 0.0 is at the base the\n",
      " |          legend text, and 1.0 is at the top. To draw all markers at the\n",
      " |          same height, set to ``[0.5]``.\n",
      " |      \n",
      " |      markerscale : float, default: :rc:`legend.markerscale`\n",
      " |          The relative size of legend markers compared with the originally\n",
      " |          drawn ones.\n",
      " |      \n",
      " |      markerfirst : bool, default: True\n",
      " |          If *True*, legend marker is placed to the left of the legend label.\n",
      " |          If *False*, legend marker is placed to the right of the legend label.\n",
      " |      \n",
      " |      frameon : bool, default: :rc:`legend.frameon`\n",
      " |          Whether the legend should be drawn on a patch (frame).\n",
      " |      \n",
      " |      fancybox : bool, default: :rc:`legend.fancybox`\n",
      " |          Whether round edges should be enabled around the `.FancyBboxPatch` which\n",
      " |          makes up the legend's background.\n",
      " |      \n",
      " |      shadow : bool, default: :rc:`legend.shadow`\n",
      " |          Whether to draw a shadow behind the legend.\n",
      " |      \n",
      " |      framealpha : float, default: :rc:`legend.framealpha`\n",
      " |          The alpha transparency of the legend's background.\n",
      " |          If *shadow* is activated and *framealpha* is ``None``, the default value is\n",
      " |          ignored.\n",
      " |      \n",
      " |      facecolor : \"inherit\" or color, default: :rc:`legend.facecolor`\n",
      " |          The legend's background color.\n",
      " |          If ``\"inherit\"``, use :rc:`axes.facecolor`.\n",
      " |      \n",
      " |      edgecolor : \"inherit\" or color, default: :rc:`legend.edgecolor`\n",
      " |          The legend's background patch edge color.\n",
      " |          If ``\"inherit\"``, use take :rc:`axes.edgecolor`.\n",
      " |      \n",
      " |      mode : {\"expand\", None}\n",
      " |          If *mode* is set to ``\"expand\"`` the legend will be horizontally\n",
      " |          expanded to fill the axes area (or *bbox_to_anchor* if defines\n",
      " |          the legend's size).\n",
      " |      \n",
      " |      bbox_transform : None or `matplotlib.transforms.Transform`\n",
      " |          The transform for the bounding box (*bbox_to_anchor*). For a value\n",
      " |          of ``None`` (default) the Axes'\n",
      " |          :data:`~matplotlib.axes.Axes.transAxes` transform will be used.\n",
      " |      \n",
      " |      title : str or None\n",
      " |          The legend's title. Default is no title (``None``).\n",
      " |      \n",
      " |      title_fontproperties : None or `matplotlib.font_manager.FontProperties` or dict\n",
      " |          The font properties of the legend's title. If None (default), the\n",
      " |          *title_fontsize* argument will be used if present; if *title_fontsize* is\n",
      " |          also None, the current :rc:`legend.title_fontsize` will be used.\n",
      " |      \n",
      " |      title_fontsize : int or {'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'}, default: :rc:`legend.title_fontsize`\n",
      " |          The font size of the legend's title.\n",
      " |          Note: This cannot be combined with *title_fontproperties*. If you want\n",
      " |          to set the fontsize alongside other font properties, use the *size*\n",
      " |          parameter in *title_fontproperties*.\n",
      " |      \n",
      " |      borderpad : float, default: :rc:`legend.borderpad`\n",
      " |          The fractional whitespace inside the legend border, in font-size units.\n",
      " |      \n",
      " |      labelspacing : float, default: :rc:`legend.labelspacing`\n",
      " |          The vertical space between the legend entries, in font-size units.\n",
      " |      \n",
      " |      handlelength : float, default: :rc:`legend.handlelength`\n",
      " |          The length of the legend handles, in font-size units.\n",
      " |      \n",
      " |      handleheight : float, default: :rc:`legend.handleheight`\n",
      " |          The height of the legend handles, in font-size units.\n",
      " |      \n",
      " |      handletextpad : float, default: :rc:`legend.handletextpad`\n",
      " |          The pad between the legend handle and text, in font-size units.\n",
      " |      \n",
      " |      borderaxespad : float, default: :rc:`legend.borderaxespad`\n",
      " |          The pad between the axes and legend border, in font-size units.\n",
      " |      \n",
      " |      columnspacing : float, default: :rc:`legend.columnspacing`\n",
      " |          The spacing between columns, in font-size units.\n",
      " |      \n",
      " |      handler_map : dict or None\n",
      " |          The custom dictionary mapping instances or types to a legend\n",
      " |          handler. This *handler_map* updates the default handler map\n",
      " |          found at `matplotlib.legend.Legend.get_legend_handler_map`.\n",
      " |      \n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      .Figure.legend\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      Some artists are not supported by this function.  See\n",
      " |      :doc:`/tutorials/intermediate/legend_guide` for details.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      .. plot:: gallery/text_labels_and_annotations/legend.py\n",
      " |  \n",
      " |  loglog(self, *args, **kwargs)\n",
      " |      Make a plot with log scaling on both the x and y axis.\n",
      " |      \n",
      " |      Call signatures::\n",
      " |      \n",
      " |          loglog([x], y, [fmt], data=None, **kwargs)\n",
      " |          loglog([x], y, [fmt], [x2], y2, [fmt2], ..., **kwargs)\n",
      " |      \n",
      " |      This is just a thin wrapper around `.plot` which additionally changes\n",
      " |      both the x-axis and the y-axis to log scaling. All of the concepts and\n",
      " |      parameters of plot can be used here as well.\n",
      " |      \n",
      " |      The additional parameters *base*, *subs* and *nonpositive* control the\n",
      " |      x/y-axis properties. They are just forwarded to `.Axes.set_xscale` and\n",
      " |      `.Axes.set_yscale`. To use different properties on the x-axis and the\n",
      " |      y-axis, use e.g.\n",
      " |      ``ax.set_xscale(\"log\", base=10); ax.set_yscale(\"log\", base=2)``.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      base : float, default: 10\n",
      " |          Base of the logarithm.\n",
      " |      \n",
      " |      subs : sequence, optional\n",
      " |          The location of the minor ticks. If *None*, reasonable locations\n",
      " |          are automatically chosen depending on the number of decades in the\n",
      " |          plot. See `.Axes.set_xscale`/`.Axes.set_yscale` for details.\n",
      " |      \n",
      " |      nonpositive : {'mask', 'clip'}, default: 'mask'\n",
      " |          Non-positive values can be masked as invalid, or clipped to a very\n",
      " |          small positive number.\n",
      " |      \n",
      " |      **kwargs\n",
      " |          All parameters supported by `.plot`.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      list of `.Line2D`\n",
      " |          Objects representing the plotted data.\n",
      " |  \n",
      " |  magnitude_spectrum(self, x, Fs=None, Fc=None, window=None, pad_to=None, sides=None, scale=None, *, data=None, **kwargs)\n",
      " |      Plot the magnitude spectrum.\n",
      " |      \n",
      " |      Compute the magnitude spectrum of *x*.  Data is padded to a\n",
      " |      length of *pad_to* and the windowing function *window* is applied to\n",
      " |      the signal.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      x : 1-D array or sequence\n",
      " |          Array or sequence containing the data.\n",
      " |      \n",
      " |      Fs : float, default: 2\n",
      " |          The sampling frequency (samples per time unit).  It is used to calculate\n",
      " |          the Fourier frequencies, *freqs*, in cycles per time unit.\n",
      " |      \n",
      " |      window : callable or ndarray, default: `.window_hanning`\n",
      " |          A function or a vector of length *NFFT*.  To create window vectors see\n",
      " |          `.window_hanning`, `.window_none`, `numpy.blackman`, `numpy.hamming`,\n",
      " |          `numpy.bartlett`, `scipy.signal`, `scipy.signal.get_window`, etc.  If a\n",
      " |          function is passed as the argument, it must take a data segment as an\n",
      " |          argument and return the windowed version of the segment.\n",
      " |      \n",
      " |      sides : {'default', 'onesided', 'twosided'}, optional\n",
      " |          Which sides of the spectrum to return. 'default' is one-sided for real\n",
      " |          data and two-sided for complex data. 'onesided' forces the return of a\n",
      " |          one-sided spectrum, while 'twosided' forces two-sided.\n",
      " |      \n",
      " |      pad_to : int, optional\n",
      " |          The number of points to which the data segment is padded when performing\n",
      " |          the FFT.  While not increasing the actual resolution of the spectrum (the\n",
      " |          minimum distance between resolvable peaks), this can give more points in\n",
      " |          the plot, allowing for more detail. This corresponds to the *n* parameter\n",
      " |          in the call to fft().  The default is None, which sets *pad_to* equal to\n",
      " |          the length of the input signal (i.e. no padding).\n",
      " |      \n",
      " |      scale : {'default', 'linear', 'dB'}\n",
      " |          The scaling of the values in the *spec*.  'linear' is no scaling.\n",
      " |          'dB' returns the values in dB scale, i.e., the dB amplitude\n",
      " |          (20 * log10). 'default' is 'linear'.\n",
      " |      \n",
      " |      Fc : int, default: 0\n",
      " |          The center frequency of *x*, which offsets the x extents of the\n",
      " |          plot to reflect the frequency range used when a signal is acquired\n",
      " |          and then filtered and downsampled to baseband.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      spectrum : 1-D array\n",
      " |          The values for the magnitude spectrum before scaling (real valued).\n",
      " |      \n",
      " |      freqs : 1-D array\n",
      " |          The frequencies corresponding to the elements in *spectrum*.\n",
      " |      \n",
      " |      line : `~matplotlib.lines.Line2D`\n",
      " |          The line created by this function.\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      data : indexable object, optional\n",
      " |          If given, the following parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception):\n",
      " |      \n",
      " |          *x*\n",
      " |      \n",
      " |      **kwargs\n",
      " |          Keyword arguments control the `.Line2D` properties:\n",
      " |      \n",
      " |          Properties:\n",
      " |          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      " |          alpha: scalar or None\n",
      " |          animated: bool\n",
      " |          antialiased or aa: bool\n",
      " |          clip_box: `.Bbox`\n",
      " |          clip_on: bool\n",
      " |          clip_path: Patch or (Path, Transform) or None\n",
      " |          color or c: color\n",
      " |          dash_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          dash_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          dashes: sequence of floats (on/off ink in points) or (None, None)\n",
      " |          data: (2, N) array or two 1D arrays\n",
      " |          drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'\n",
      " |          figure: `.Figure`\n",
      " |          fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}\n",
      " |          gid: str\n",
      " |          in_layout: bool\n",
      " |          label: object\n",
      " |          linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      " |          linewidth or lw: float\n",
      " |          marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`\n",
      " |          markeredgecolor or mec: color\n",
      " |          markeredgewidth or mew: float\n",
      " |          markerfacecolor or mfc: color\n",
      " |          markerfacecoloralt or mfcalt: color\n",
      " |          markersize or ms: float\n",
      " |          markevery: None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]\n",
      " |          path_effects: `.AbstractPathEffect`\n",
      " |          picker: float or callable[[Artist, Event], tuple[bool, dict]]\n",
      " |          pickradius: float\n",
      " |          rasterized: bool\n",
      " |          sketch_params: (scale: float, length: float, randomness: float)\n",
      " |          snap: bool or None\n",
      " |          solid_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          solid_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          transform: unknown\n",
      " |          url: str\n",
      " |          visible: bool\n",
      " |          xdata: 1D array\n",
      " |          ydata: 1D array\n",
      " |          zorder: float\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      psd\n",
      " |          Plots the power spectral density.\n",
      " |      angle_spectrum\n",
      " |          Plots the angles of the corresponding frequencies.\n",
      " |      phase_spectrum\n",
      " |          Plots the phase (unwrapped angle) of the corresponding frequencies.\n",
      " |      specgram\n",
      " |          Can plot the magnitude spectrum of segments within the signal in a\n",
      " |          colormap.\n",
      " |  \n",
      " |  matshow(self, Z, **kwargs)\n",
      " |      Plot the values of a 2D matrix or array as color-coded image.\n",
      " |      \n",
      " |      The matrix will be shown the way it would be printed, with the first\n",
      " |      row at the top.  Row and column numbering is zero-based.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      Z : (M, N) array-like\n",
      " |          The matrix to be displayed.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `~matplotlib.image.AxesImage`\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      **kwargs : `~matplotlib.axes.Axes.imshow` arguments\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      imshow : More general function to plot data on a 2D regular raster.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      This is just a convenience function wrapping `.imshow` to set useful\n",
      " |      defaults for displaying a matrix. In particular:\n",
      " |      \n",
      " |      - Set ``origin='upper'``.\n",
      " |      - Set ``interpolation='nearest'``.\n",
      " |      - Set ``aspect='equal'``.\n",
      " |      - Ticks are placed to the left and above.\n",
      " |      - Ticks are formatted to show integer indices.\n",
      " |  \n",
      " |  pcolor(self, *args, shading=None, alpha=None, norm=None, cmap=None, vmin=None, vmax=None, data=None, **kwargs)\n",
      " |      Create a pseudocolor plot with a non-regular rectangular grid.\n",
      " |      \n",
      " |      Call signature::\n",
      " |      \n",
      " |          pcolor([X, Y,] C, **kwargs)\n",
      " |      \n",
      " |      *X* and *Y* can be used to specify the corners of the quadrilaterals.\n",
      " |      \n",
      " |      .. hint::\n",
      " |      \n",
      " |          ``pcolor()`` can be very slow for large arrays. In most\n",
      " |          cases you should use the similar but much faster\n",
      " |          `~.Axes.pcolormesh` instead. See\n",
      " |          :ref:`Differences between pcolor() and pcolormesh()\n",
      " |          <differences-pcolor-pcolormesh>` for a discussion of the\n",
      " |          differences.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      C : 2D array-like\n",
      " |          The color-mapped values.\n",
      " |      \n",
      " |      X, Y : array-like, optional\n",
      " |          The coordinates of the corners of quadrilaterals of a pcolormesh::\n",
      " |      \n",
      " |              (X[i+1, j], Y[i+1, j])       (X[i+1, j+1], Y[i+1, j+1])\n",
      " |                                    +-----+\n",
      " |                                    |     |\n",
      " |                                    +-----+\n",
      " |                  (X[i, j], Y[i, j])       (X[i, j+1], Y[i, j+1])\n",
      " |      \n",
      " |          Note that the column index corresponds to the x-coordinate, and\n",
      " |          the row index corresponds to y. For details, see the\n",
      " |          :ref:`Notes <axes-pcolormesh-grid-orientation>` section below.\n",
      " |      \n",
      " |          If ``shading='flat'`` the dimensions of *X* and *Y* should be one\n",
      " |          greater than those of *C*, and the quadrilateral is colored due\n",
      " |          to the value at ``C[i, j]``.  If *X*, *Y* and *C* have equal\n",
      " |          dimensions, a warning will be raised and the last row and column\n",
      " |          of *C* will be ignored.\n",
      " |      \n",
      " |          If ``shading='nearest'``, the dimensions of *X* and *Y* should be\n",
      " |          the same as those of *C* (if not, a ValueError will be raised). The\n",
      " |          color ``C[i, j]`` will be centered on ``(X[i, j], Y[i, j])``.\n",
      " |      \n",
      " |          If *X* and/or *Y* are 1-D arrays or column vectors they will be\n",
      " |          expanded as needed into the appropriate 2D arrays, making a\n",
      " |          rectangular grid.\n",
      " |      \n",
      " |      shading : {'flat', 'nearest', 'auto'}, default: :rc:`pcolor.shading`\n",
      " |          The fill style for the quadrilateral. Possible values:\n",
      " |      \n",
      " |          - 'flat': A solid color is used for each quad. The color of the\n",
      " |            quad (i, j), (i+1, j), (i, j+1), (i+1, j+1) is given by\n",
      " |            ``C[i, j]``. The dimensions of *X* and *Y* should be\n",
      " |            one greater than those of *C*; if they are the same as *C*,\n",
      " |            then a deprecation warning is raised, and the last row\n",
      " |            and column of *C* are dropped.\n",
      " |          - 'nearest': Each grid point will have a color centered on it,\n",
      " |            extending halfway between the adjacent grid centers.  The\n",
      " |            dimensions of *X* and *Y* must be the same as *C*.\n",
      " |          - 'auto': Choose 'flat' if dimensions of *X* and *Y* are one\n",
      " |            larger than *C*.  Choose 'nearest' if dimensions are the same.\n",
      " |      \n",
      " |          See :doc:`/gallery/images_contours_and_fields/pcolormesh_grids`\n",
      " |          for more description.\n",
      " |      \n",
      " |      cmap : str or `~matplotlib.colors.Colormap`, default: :rc:`image.cmap`\n",
      " |          A Colormap instance or registered colormap name. The colormap\n",
      " |          maps the *C* values to colors.\n",
      " |      \n",
      " |      norm : `~matplotlib.colors.Normalize`, optional\n",
      " |          The Normalize instance scales the data values to the canonical\n",
      " |          colormap range [0, 1] for mapping to colors. By default, the data\n",
      " |          range is mapped to the colorbar range using linear scaling.\n",
      " |      \n",
      " |      vmin, vmax : float, default: None\n",
      " |          The colorbar range. If *None*, suitable min/max values are\n",
      " |          automatically chosen by the `.Normalize` instance (defaults to\n",
      " |          the respective min/max values of *C* in case of the default linear\n",
      " |          scaling).\n",
      " |          It is an error to use *vmin*/*vmax* when *norm* is given.\n",
      " |      \n",
      " |      edgecolors : {'none', None, 'face', color, color sequence}, optional\n",
      " |          The color of the edges. Defaults to 'none'. Possible values:\n",
      " |      \n",
      " |          - 'none' or '': No edge.\n",
      " |          - *None*: :rc:`patch.edgecolor` will be used. Note that currently\n",
      " |            :rc:`patch.force_edgecolor` has to be True for this to work.\n",
      " |          - 'face': Use the adjacent face color.\n",
      " |          - A color or sequence of colors will set the edge color.\n",
      " |      \n",
      " |          The singular form *edgecolor* works as an alias.\n",
      " |      \n",
      " |      alpha : float, default: None\n",
      " |          The alpha blending value of the face color, between 0 (transparent)\n",
      " |          and 1 (opaque). Note: The edgecolor is currently not affected by\n",
      " |          this.\n",
      " |      \n",
      " |      snap : bool, default: False\n",
      " |          Whether to snap the mesh to pixel boundaries.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `matplotlib.collections.Collection`\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      antialiaseds : bool, default: False\n",
      " |          The default *antialiaseds* is False if the default\n",
      " |          *edgecolors*\\ =\"none\" is used.  This eliminates artificial lines\n",
      " |          at patch boundaries, and works regardless of the value of alpha.\n",
      " |          If *edgecolors* is not \"none\", then the default *antialiaseds*\n",
      " |          is taken from :rc:`patch.antialiased`.\n",
      " |          Stroking the edges may be preferred if *alpha* is 1, but will\n",
      " |          cause artifacts otherwise.\n",
      " |      \n",
      " |      data : indexable object, optional\n",
      " |          If given, all parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception).\n",
      " |      \n",
      " |      **kwargs\n",
      " |          Additionally, the following arguments are allowed. They are passed\n",
      " |          along to the `~matplotlib.collections.PolyCollection` constructor:\n",
      " |      \n",
      " |      Properties:\n",
      " |          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      " |          alpha: array-like or scalar or None\n",
      " |          animated: bool\n",
      " |          antialiased or aa or antialiaseds: bool or list of bools\n",
      " |          array: array-like or None\n",
      " |          capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          clim: (vmin: float, vmax: float)\n",
      " |          clip_box: `.Bbox`\n",
      " |          clip_on: bool\n",
      " |          clip_path: Patch or (Path, Transform) or None\n",
      " |          cmap: `.Colormap` or str or None\n",
      " |          color: color or list of rgba tuples\n",
      " |          edgecolor or ec or edgecolors: color or list of colors or 'face'\n",
      " |          facecolor or facecolors or fc: color or list of colors\n",
      " |          figure: `.Figure`\n",
      " |          gid: str\n",
      " |          hatch: {'/', '\\\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
      " |          in_layout: bool\n",
      " |          joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          label: object\n",
      " |          linestyle or dashes or linestyles or ls: str or tuple or list thereof\n",
      " |          linewidth or linewidths or lw: float or list of floats\n",
      " |          norm: `.Normalize` or None\n",
      " |          offset_transform: `.Transform`\n",
      " |          offsets: (N, 2) or (2,) array-like\n",
      " |          path_effects: `.AbstractPathEffect`\n",
      " |          paths: list of array-like\n",
      " |          picker: None or bool or float or callable\n",
      " |          pickradius: float\n",
      " |          rasterized: bool\n",
      " |          sizes: ndarray or None\n",
      " |          sketch_params: (scale: float, length: float, randomness: float)\n",
      " |          snap: bool or None\n",
      " |          transform: `.Transform`\n",
      " |          url: str\n",
      " |          urls: list of str or None\n",
      " |          verts: list of array-like\n",
      " |          verts_and_codes: unknown\n",
      " |          visible: bool\n",
      " |          zorder: float\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      pcolormesh : for an explanation of the differences between\n",
      " |          pcolor and pcolormesh.\n",
      " |      imshow : If *X* and *Y* are each equidistant, `~.Axes.imshow` can be a\n",
      " |          faster alternative.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      **Masked arrays**\n",
      " |      \n",
      " |      *X*, *Y* and *C* may be masked arrays. If either ``C[i, j]``, or one\n",
      " |      of the vertices surrounding ``C[i, j]`` (*X* or *Y* at\n",
      " |      ``[i, j], [i+1, j], [i, j+1], [i+1, j+1]``) is masked, nothing is\n",
      " |      plotted.\n",
      " |      \n",
      " |      .. _axes-pcolor-grid-orientation:\n",
      " |      \n",
      " |      **Grid orientation**\n",
      " |      \n",
      " |      The grid orientation follows the standard matrix convention: An array\n",
      " |      *C* with shape (nrows, ncolumns) is plotted with the column number as\n",
      " |      *X* and the row number as *Y*.\n",
      " |  \n",
      " |  pcolorfast(self, *args, alpha=None, norm=None, cmap=None, vmin=None, vmax=None, data=None, **kwargs)\n",
      " |      Create a pseudocolor plot with a non-regular rectangular grid.\n",
      " |      \n",
      " |      Call signature::\n",
      " |      \n",
      " |        ax.pcolorfast([X, Y], C, /, **kwargs)\n",
      " |      \n",
      " |      This method is similar to `~.Axes.pcolor` and `~.Axes.pcolormesh`.\n",
      " |      It's designed to provide the fastest pcolor-type plotting with the\n",
      " |      Agg backend. To achieve this, it uses different algorithms internally\n",
      " |      depending on the complexity of the input grid (regular rectangular,\n",
      " |      non-regular rectangular or arbitrary quadrilateral).\n",
      " |      \n",
      " |      .. warning::\n",
      " |      \n",
      " |         This method is experimental. Compared to `~.Axes.pcolor` or\n",
      " |         `~.Axes.pcolormesh` it has some limitations:\n",
      " |      \n",
      " |         - It supports only flat shading (no outlines)\n",
      " |         - It lacks support for log scaling of the axes.\n",
      " |         - It does not have a have a pyplot wrapper.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      C : array-like\n",
      " |          The image data. Supported array shapes are:\n",
      " |      \n",
      " |          - (M, N): an image with scalar data. The data is visualized\n",
      " |            using a colormap.\n",
      " |          - (M, N, 3): an image with RGB values (0-1 float or 0-255 int).\n",
      " |          - (M, N, 4): an image with RGBA values (0-1 float or 0-255 int),\n",
      " |            i.e. including transparency.\n",
      " |      \n",
      " |          The first two dimensions (M, N) define the rows and columns of\n",
      " |          the image.\n",
      " |      \n",
      " |          This parameter can only be passed positionally.\n",
      " |      \n",
      " |      X, Y : tuple or array-like, default: ``(0, N)``, ``(0, M)``\n",
      " |          *X* and *Y* are used to specify the coordinates of the\n",
      " |          quadrilaterals. There are different ways to do this:\n",
      " |      \n",
      " |          - Use tuples ``X=(xmin, xmax)`` and ``Y=(ymin, ymax)`` to define\n",
      " |            a *uniform rectangular grid*.\n",
      " |      \n",
      " |            The tuples define the outer edges of the grid. All individual\n",
      " |            quadrilaterals will be of the same size. This is the fastest\n",
      " |            version.\n",
      " |      \n",
      " |          - Use 1D arrays *X*, *Y* to specify a *non-uniform rectangular\n",
      " |            grid*.\n",
      " |      \n",
      " |            In this case *X* and *Y* have to be monotonic 1D arrays of length\n",
      " |            *N+1* and *M+1*, specifying the x and y boundaries of the cells.\n",
      " |      \n",
      " |            The speed is intermediate. Note: The grid is checked, and if\n",
      " |            found to be uniform the fast version is used.\n",
      " |      \n",
      " |          - Use 2D arrays *X*, *Y* if you need an *arbitrary quadrilateral\n",
      " |            grid* (i.e. if the quadrilaterals are not rectangular).\n",
      " |      \n",
      " |            In this case *X* and *Y* are 2D arrays with shape (M + 1, N + 1),\n",
      " |            specifying the x and y coordinates of the corners of the colored\n",
      " |            quadrilaterals.\n",
      " |      \n",
      " |            This is the most general, but the slowest to render.  It may\n",
      " |            produce faster and more compact output using ps, pdf, and\n",
      " |            svg backends, however.\n",
      " |      \n",
      " |          These arguments can only be passed positionally.\n",
      " |      \n",
      " |      cmap : str or `~matplotlib.colors.Colormap`, default: :rc:`image.cmap`\n",
      " |          A Colormap instance or registered colormap name. The colormap\n",
      " |          maps the *C* values to colors.\n",
      " |      \n",
      " |      norm : `~matplotlib.colors.Normalize`, optional\n",
      " |          The Normalize instance scales the data values to the canonical\n",
      " |          colormap range [0, 1] for mapping to colors. By default, the data\n",
      " |          range is mapped to the colorbar range using linear scaling.\n",
      " |      \n",
      " |      vmin, vmax : float, default: None\n",
      " |          The colorbar range. If *None*, suitable min/max values are\n",
      " |          automatically chosen by the `.Normalize` instance (defaults to\n",
      " |          the respective min/max values of *C* in case of the default linear\n",
      " |          scaling).\n",
      " |          It is an error to use *vmin*/*vmax* when *norm* is given.\n",
      " |      \n",
      " |      alpha : float, default: None\n",
      " |          The alpha blending value, between 0 (transparent) and 1 (opaque).\n",
      " |      \n",
      " |      snap : bool, default: False\n",
      " |          Whether to snap the mesh to pixel boundaries.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `.AxesImage` or `.PcolorImage` or `.QuadMesh`\n",
      " |          The return type depends on the type of grid:\n",
      " |      \n",
      " |          - `.AxesImage` for a regular rectangular grid.\n",
      " |          - `.PcolorImage` for a non-regular rectangular grid.\n",
      " |          - `.QuadMesh` for a non-rectangular grid.\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      data : indexable object, optional\n",
      " |          If given, all parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception).\n",
      " |      \n",
      " |      **kwargs\n",
      " |          Supported additional parameters depend on the type of grid.\n",
      " |          See return types of *image* for further description.\n",
      " |  \n",
      " |  pcolormesh(self, *args, alpha=None, norm=None, cmap=None, vmin=None, vmax=None, shading=None, antialiased=False, data=None, **kwargs)\n",
      " |      Create a pseudocolor plot with a non-regular rectangular grid.\n",
      " |      \n",
      " |      Call signature::\n",
      " |      \n",
      " |          pcolormesh([X, Y,] C, **kwargs)\n",
      " |      \n",
      " |      *X* and *Y* can be used to specify the corners of the quadrilaterals.\n",
      " |      \n",
      " |      .. hint::\n",
      " |      \n",
      " |         `~.Axes.pcolormesh` is similar to `~.Axes.pcolor`. It is much faster\n",
      " |         and preferred in most cases. For a detailed discussion on the\n",
      " |         differences see :ref:`Differences between pcolor() and pcolormesh()\n",
      " |         <differences-pcolor-pcolormesh>`.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      C : 2D array-like\n",
      " |          The color-mapped values.\n",
      " |      \n",
      " |      X, Y : array-like, optional\n",
      " |          The coordinates of the corners of quadrilaterals of a pcolormesh::\n",
      " |      \n",
      " |              (X[i+1, j], Y[i+1, j])       (X[i+1, j+1], Y[i+1, j+1])\n",
      " |                                    +-----+\n",
      " |                                    |     |\n",
      " |                                    +-----+\n",
      " |                  (X[i, j], Y[i, j])       (X[i, j+1], Y[i, j+1])\n",
      " |      \n",
      " |          Note that the column index corresponds to the x-coordinate, and\n",
      " |          the row index corresponds to y. For details, see the\n",
      " |          :ref:`Notes <axes-pcolormesh-grid-orientation>` section below.\n",
      " |      \n",
      " |          If ``shading='flat'`` the dimensions of *X* and *Y* should be one\n",
      " |          greater than those of *C*, and the quadrilateral is colored due\n",
      " |          to the value at ``C[i, j]``.  If *X*, *Y* and *C* have equal\n",
      " |          dimensions, a warning will be raised and the last row and column\n",
      " |          of *C* will be ignored.\n",
      " |      \n",
      " |          If ``shading='nearest'`` or ``'gouraud'``, the dimensions of *X*\n",
      " |          and *Y* should be the same as those of *C* (if not, a ValueError\n",
      " |          will be raised).  For ``'nearest'`` the color ``C[i, j]`` is\n",
      " |          centered on ``(X[i, j], Y[i, j])``.  For ``'gouraud'``, a smooth\n",
      " |          interpolation is caried out between the quadrilateral corners.\n",
      " |      \n",
      " |          If *X* and/or *Y* are 1-D arrays or column vectors they will be\n",
      " |          expanded as needed into the appropriate 2D arrays, making a\n",
      " |          rectangular grid.\n",
      " |      \n",
      " |      cmap : str or `~matplotlib.colors.Colormap`, default: :rc:`image.cmap`\n",
      " |          A Colormap instance or registered colormap name. The colormap\n",
      " |          maps the *C* values to colors.\n",
      " |      \n",
      " |      norm : `~matplotlib.colors.Normalize`, optional\n",
      " |          The Normalize instance scales the data values to the canonical\n",
      " |          colormap range [0, 1] for mapping to colors. By default, the data\n",
      " |          range is mapped to the colorbar range using linear scaling.\n",
      " |      \n",
      " |      vmin, vmax : float, default: None\n",
      " |          The colorbar range. If *None*, suitable min/max values are\n",
      " |          automatically chosen by the `.Normalize` instance (defaults to\n",
      " |          the respective min/max values of *C* in case of the default linear\n",
      " |          scaling).\n",
      " |          It is an error to use *vmin*/*vmax* when *norm* is given.\n",
      " |      \n",
      " |      edgecolors : {'none', None, 'face', color, color sequence}, optional\n",
      " |          The color of the edges. Defaults to 'none'. Possible values:\n",
      " |      \n",
      " |          - 'none' or '': No edge.\n",
      " |          - *None*: :rc:`patch.edgecolor` will be used. Note that currently\n",
      " |            :rc:`patch.force_edgecolor` has to be True for this to work.\n",
      " |          - 'face': Use the adjacent face color.\n",
      " |          - A color or sequence of colors will set the edge color.\n",
      " |      \n",
      " |          The singular form *edgecolor* works as an alias.\n",
      " |      \n",
      " |      alpha : float, default: None\n",
      " |          The alpha blending value, between 0 (transparent) and 1 (opaque).\n",
      " |      \n",
      " |      shading : {'flat', 'nearest', 'gouraud', 'auto'}, optional\n",
      " |          The fill style for the quadrilateral; defaults to\n",
      " |          'flat' or :rc:`pcolor.shading`. Possible values:\n",
      " |      \n",
      " |          - 'flat': A solid color is used for each quad. The color of the\n",
      " |            quad (i, j), (i+1, j), (i, j+1), (i+1, j+1) is given by\n",
      " |            ``C[i, j]``. The dimensions of *X* and *Y* should be\n",
      " |            one greater than those of *C*; if they are the same as *C*,\n",
      " |            then a deprecation warning is raised, and the last row\n",
      " |            and column of *C* are dropped.\n",
      " |          - 'nearest': Each grid point will have a color centered on it,\n",
      " |            extending halfway between the adjacent grid centers.  The\n",
      " |            dimensions of *X* and *Y* must be the same as *C*.\n",
      " |          - 'gouraud': Each quad will be Gouraud shaded: The color of the\n",
      " |            corners (i', j') are given by ``C[i', j']``. The color values of\n",
      " |            the area in between is interpolated from the corner values.\n",
      " |            The dimensions of *X* and *Y* must be the same as *C*. When\n",
      " |            Gouraud shading is used, *edgecolors* is ignored.\n",
      " |          - 'auto': Choose 'flat' if dimensions of *X* and *Y* are one\n",
      " |            larger than *C*.  Choose 'nearest' if dimensions are the same.\n",
      " |      \n",
      " |          See :doc:`/gallery/images_contours_and_fields/pcolormesh_grids`\n",
      " |          for more description.\n",
      " |      \n",
      " |      snap : bool, default: False\n",
      " |          Whether to snap the mesh to pixel boundaries.\n",
      " |      \n",
      " |      rasterized : bool, optional\n",
      " |          Rasterize the pcolormesh when drawing vector graphics.  This can\n",
      " |          speed up rendering and produce smaller files for large data sets.\n",
      " |          See also :doc:`/gallery/misc/rasterization_demo`.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `matplotlib.collections.QuadMesh`\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      data : indexable object, optional\n",
      " |          If given, all parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception).\n",
      " |      \n",
      " |      **kwargs\n",
      " |          Additionally, the following arguments are allowed. They are passed\n",
      " |          along to the `~matplotlib.collections.QuadMesh` constructor:\n",
      " |      \n",
      " |      Properties:\n",
      " |          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      " |          alpha: array-like or scalar or None\n",
      " |          animated: bool\n",
      " |          antialiased or aa or antialiaseds: bool or list of bools\n",
      " |          array: (M, N) array-like or M*N array-like\n",
      " |          capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          clim: (vmin: float, vmax: float)\n",
      " |          clip_box: `.Bbox`\n",
      " |          clip_on: bool\n",
      " |          clip_path: Patch or (Path, Transform) or None\n",
      " |          cmap: `.Colormap` or str or None\n",
      " |          color: color or list of rgba tuples\n",
      " |          edgecolor or ec or edgecolors: color or list of colors or 'face'\n",
      " |          facecolor or facecolors or fc: color or list of colors\n",
      " |          figure: `.Figure`\n",
      " |          gid: str\n",
      " |          hatch: {'/', '\\\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
      " |          in_layout: bool\n",
      " |          joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          label: object\n",
      " |          linestyle or dashes or linestyles or ls: str or tuple or list thereof\n",
      " |          linewidth or linewidths or lw: float or list of floats\n",
      " |          norm: `.Normalize` or None\n",
      " |          offset_transform: `.Transform`\n",
      " |          offsets: (N, 2) or (2,) array-like\n",
      " |          path_effects: `.AbstractPathEffect`\n",
      " |          picker: None or bool or float or callable\n",
      " |          pickradius: float\n",
      " |          rasterized: bool\n",
      " |          sketch_params: (scale: float, length: float, randomness: float)\n",
      " |          snap: bool or None\n",
      " |          transform: `.Transform`\n",
      " |          url: str\n",
      " |          urls: list of str or None\n",
      " |          visible: bool\n",
      " |          zorder: float\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      pcolor : An alternative implementation with slightly different\n",
      " |          features. For a detailed discussion on the differences see\n",
      " |          :ref:`Differences between pcolor() and pcolormesh()\n",
      " |          <differences-pcolor-pcolormesh>`.\n",
      " |      imshow : If *X* and *Y* are each equidistant, `~.Axes.imshow` can be a\n",
      " |          faster alternative.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      **Masked arrays**\n",
      " |      \n",
      " |      *C* may be a masked array. If ``C[i, j]`` is masked, the corresponding\n",
      " |      quadrilateral will be transparent. Masking of *X* and *Y* is not\n",
      " |      supported. Use `~.Axes.pcolor` if you need this functionality.\n",
      " |      \n",
      " |      .. _axes-pcolormesh-grid-orientation:\n",
      " |      \n",
      " |      **Grid orientation**\n",
      " |      \n",
      " |      The grid orientation follows the standard matrix convention: An array\n",
      " |      *C* with shape (nrows, ncolumns) is plotted with the column number as\n",
      " |      *X* and the row number as *Y*.\n",
      " |      \n",
      " |      .. _differences-pcolor-pcolormesh:\n",
      " |      \n",
      " |      **Differences between pcolor() and pcolormesh()**\n",
      " |      \n",
      " |      Both methods are used to create a pseudocolor plot of a 2D array\n",
      " |      using quadrilaterals.\n",
      " |      \n",
      " |      The main difference lies in the created object and internal data\n",
      " |      handling:\n",
      " |      While `~.Axes.pcolor` returns a `.PolyCollection`, `~.Axes.pcolormesh`\n",
      " |      returns a `.QuadMesh`. The latter is more specialized for the given\n",
      " |      purpose and thus is faster. It should almost always be preferred.\n",
      " |      \n",
      " |      There is also a slight difference in the handling of masked arrays.\n",
      " |      Both `~.Axes.pcolor` and `~.Axes.pcolormesh` support masked arrays\n",
      " |      for *C*. However, only `~.Axes.pcolor` supports masked arrays for *X*\n",
      " |      and *Y*. The reason lies in the internal handling of the masked values.\n",
      " |      `~.Axes.pcolor` leaves out the respective polygons from the\n",
      " |      PolyCollection. `~.Axes.pcolormesh` sets the facecolor of the masked\n",
      " |      elements to transparent. You can see the difference when using\n",
      " |      edgecolors. While all edges are drawn irrespective of masking in a\n",
      " |      QuadMesh, the edge between two adjacent masked quadrilaterals in\n",
      " |      `~.Axes.pcolor` is not drawn as the corresponding polygons do not\n",
      " |      exist in the PolyCollection.\n",
      " |      \n",
      " |      Another difference is the support of Gouraud shading in\n",
      " |      `~.Axes.pcolormesh`, which is not available with `~.Axes.pcolor`.\n",
      " |  \n",
      " |  phase_spectrum(self, x, Fs=None, Fc=None, window=None, pad_to=None, sides=None, *, data=None, **kwargs)\n",
      " |      Plot the phase spectrum.\n",
      " |      \n",
      " |      Compute the phase spectrum (unwrapped angle spectrum) of *x*.\n",
      " |      Data is padded to a length of *pad_to* and the windowing function\n",
      " |      *window* is applied to the signal.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      x : 1-D array or sequence\n",
      " |          Array or sequence containing the data\n",
      " |      \n",
      " |      Fs : float, default: 2\n",
      " |          The sampling frequency (samples per time unit).  It is used to calculate\n",
      " |          the Fourier frequencies, *freqs*, in cycles per time unit.\n",
      " |      \n",
      " |      window : callable or ndarray, default: `.window_hanning`\n",
      " |          A function or a vector of length *NFFT*.  To create window vectors see\n",
      " |          `.window_hanning`, `.window_none`, `numpy.blackman`, `numpy.hamming`,\n",
      " |          `numpy.bartlett`, `scipy.signal`, `scipy.signal.get_window`, etc.  If a\n",
      " |          function is passed as the argument, it must take a data segment as an\n",
      " |          argument and return the windowed version of the segment.\n",
      " |      \n",
      " |      sides : {'default', 'onesided', 'twosided'}, optional\n",
      " |          Which sides of the spectrum to return. 'default' is one-sided for real\n",
      " |          data and two-sided for complex data. 'onesided' forces the return of a\n",
      " |          one-sided spectrum, while 'twosided' forces two-sided.\n",
      " |      \n",
      " |      pad_to : int, optional\n",
      " |          The number of points to which the data segment is padded when performing\n",
      " |          the FFT.  While not increasing the actual resolution of the spectrum (the\n",
      " |          minimum distance between resolvable peaks), this can give more points in\n",
      " |          the plot, allowing for more detail. This corresponds to the *n* parameter\n",
      " |          in the call to fft().  The default is None, which sets *pad_to* equal to\n",
      " |          the length of the input signal (i.e. no padding).\n",
      " |      \n",
      " |      Fc : int, default: 0\n",
      " |          The center frequency of *x*, which offsets the x extents of the\n",
      " |          plot to reflect the frequency range used when a signal is acquired\n",
      " |          and then filtered and downsampled to baseband.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      spectrum : 1-D array\n",
      " |          The values for the phase spectrum in radians (real valued).\n",
      " |      \n",
      " |      freqs : 1-D array\n",
      " |          The frequencies corresponding to the elements in *spectrum*.\n",
      " |      \n",
      " |      line : `~matplotlib.lines.Line2D`\n",
      " |          The line created by this function.\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      data : indexable object, optional\n",
      " |          If given, the following parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception):\n",
      " |      \n",
      " |          *x*\n",
      " |      \n",
      " |      **kwargs\n",
      " |          Keyword arguments control the `.Line2D` properties:\n",
      " |      \n",
      " |          Properties:\n",
      " |          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      " |          alpha: scalar or None\n",
      " |          animated: bool\n",
      " |          antialiased or aa: bool\n",
      " |          clip_box: `.Bbox`\n",
      " |          clip_on: bool\n",
      " |          clip_path: Patch or (Path, Transform) or None\n",
      " |          color or c: color\n",
      " |          dash_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          dash_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          dashes: sequence of floats (on/off ink in points) or (None, None)\n",
      " |          data: (2, N) array or two 1D arrays\n",
      " |          drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'\n",
      " |          figure: `.Figure`\n",
      " |          fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}\n",
      " |          gid: str\n",
      " |          in_layout: bool\n",
      " |          label: object\n",
      " |          linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      " |          linewidth or lw: float\n",
      " |          marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`\n",
      " |          markeredgecolor or mec: color\n",
      " |          markeredgewidth or mew: float\n",
      " |          markerfacecolor or mfc: color\n",
      " |          markerfacecoloralt or mfcalt: color\n",
      " |          markersize or ms: float\n",
      " |          markevery: None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]\n",
      " |          path_effects: `.AbstractPathEffect`\n",
      " |          picker: float or callable[[Artist, Event], tuple[bool, dict]]\n",
      " |          pickradius: float\n",
      " |          rasterized: bool\n",
      " |          sketch_params: (scale: float, length: float, randomness: float)\n",
      " |          snap: bool or None\n",
      " |          solid_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          solid_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          transform: unknown\n",
      " |          url: str\n",
      " |          visible: bool\n",
      " |          xdata: 1D array\n",
      " |          ydata: 1D array\n",
      " |          zorder: float\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      magnitude_spectrum\n",
      " |          Plots the magnitudes of the corresponding frequencies.\n",
      " |      angle_spectrum\n",
      " |          Plots the wrapped version of this function.\n",
      " |      specgram\n",
      " |          Can plot the phase spectrum of segments within the signal in a\n",
      " |          colormap.\n",
      " |  \n",
      " |  pie(self, x, explode=None, labels=None, colors=None, autopct=None, pctdistance=0.6, shadow=False, labeldistance=1.1, startangle=0, radius=1, counterclock=True, wedgeprops=None, textprops=None, center=(0, 0), frame=False, rotatelabels=False, *, normalize=True, data=None)\n",
      " |      Plot a pie chart.\n",
      " |      \n",
      " |      Make a pie chart of array *x*.  The fractional area of each wedge is\n",
      " |      given by ``x/sum(x)``.\n",
      " |      \n",
      " |      The wedges are plotted counterclockwise, by default starting from the\n",
      " |      x-axis.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      x : 1D array-like\n",
      " |          The wedge sizes.\n",
      " |      \n",
      " |      explode : array-like, default: None\n",
      " |          If not *None*, is a ``len(x)`` array which specifies the fraction\n",
      " |          of the radius with which to offset each wedge.\n",
      " |      \n",
      " |      labels : list, default: None\n",
      " |          A sequence of strings providing the labels for each wedge\n",
      " |      \n",
      " |      colors : array-like, default: None\n",
      " |          A sequence of colors through which the pie chart will cycle.  If\n",
      " |          *None*, will use the colors in the currently active cycle.\n",
      " |      \n",
      " |      autopct : None or str or callable, default: None\n",
      " |          If not *None*, is a string or function used to label the wedges\n",
      " |          with their numeric value.  The label will be placed inside the\n",
      " |          wedge.  If it is a format string, the label will be ``fmt % pct``.\n",
      " |          If it is a function, it will be called.\n",
      " |      \n",
      " |      pctdistance : float, default: 0.6\n",
      " |          The ratio between the center of each pie slice and the start of\n",
      " |          the text generated by *autopct*.  Ignored if *autopct* is *None*.\n",
      " |      \n",
      " |      shadow : bool, default: False\n",
      " |          Draw a shadow beneath the pie.\n",
      " |      \n",
      " |      normalize : bool, default: True\n",
      " |          When *True*, always make a full pie by normalizing x so that\n",
      " |          ``sum(x) == 1``. *False* makes a partial pie if ``sum(x) <= 1``\n",
      " |          and raises a `ValueError` for ``sum(x) > 1``.\n",
      " |      \n",
      " |      labeldistance : float or None, default: 1.1\n",
      " |          The radial distance at which the pie labels are drawn.\n",
      " |          If set to ``None``, label are not drawn, but are stored for use in\n",
      " |          ``legend()``\n",
      " |      \n",
      " |      startangle : float, default: 0 degrees\n",
      " |          The angle by which the start of the pie is rotated,\n",
      " |          counterclockwise from the x-axis.\n",
      " |      \n",
      " |      radius : float, default: 1\n",
      " |          The radius of the pie.\n",
      " |      \n",
      " |      counterclock : bool, default: True\n",
      " |          Specify fractions direction, clockwise or counterclockwise.\n",
      " |      \n",
      " |      wedgeprops : dict, default: None\n",
      " |          Dict of arguments passed to the wedge objects making the pie.\n",
      " |          For example, you can pass in ``wedgeprops = {'linewidth': 3}``\n",
      " |          to set the width of the wedge border lines equal to 3.\n",
      " |          For more details, look at the doc/arguments of the wedge object.\n",
      " |          By default ``clip_on=False``.\n",
      " |      \n",
      " |      textprops : dict, default: None\n",
      " |          Dict of arguments to pass to the text objects.\n",
      " |      \n",
      " |      center : (float, float), default: (0, 0)\n",
      " |          The coordinates of the center of the chart.\n",
      " |      \n",
      " |      frame : bool, default: False\n",
      " |          Plot Axes frame with the chart if true.\n",
      " |      \n",
      " |      rotatelabels : bool, default: False\n",
      " |          Rotate each label to the angle of the corresponding slice if true.\n",
      " |      \n",
      " |      data : indexable object, optional\n",
      " |          If given, the following parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception):\n",
      " |      \n",
      " |          *x*, *explode*, *labels*, *colors*\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      patches : list\n",
      " |          A sequence of `matplotlib.patches.Wedge` instances\n",
      " |      \n",
      " |      texts : list\n",
      " |          A list of the label `.Text` instances.\n",
      " |      \n",
      " |      autotexts : list\n",
      " |          A list of `.Text` instances for the numeric labels. This will only\n",
      " |          be returned if the parameter *autopct* is not *None*.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      The pie chart will probably look best if the figure and Axes are\n",
      " |      square, or the Axes aspect is equal.\n",
      " |      This method sets the aspect ratio of the axis to \"equal\".\n",
      " |      The Axes aspect ratio can be controlled with `.Axes.set_aspect`.\n",
      " |  \n",
      " |  plot(self, *args, scalex=True, scaley=True, data=None, **kwargs)\n",
      " |      Plot y versus x as lines and/or markers.\n",
      " |      \n",
      " |      Call signatures::\n",
      " |      \n",
      " |          plot([x], y, [fmt], *, data=None, **kwargs)\n",
      " |          plot([x], y, [fmt], [x2], y2, [fmt2], ..., **kwargs)\n",
      " |      \n",
      " |      The coordinates of the points or line nodes are given by *x*, *y*.\n",
      " |      \n",
      " |      The optional parameter *fmt* is a convenient way for defining basic\n",
      " |      formatting like color, marker and linestyle. It's a shortcut string\n",
      " |      notation described in the *Notes* section below.\n",
      " |      \n",
      " |      >>> plot(x, y)        # plot x and y using default line style and color\n",
      " |      >>> plot(x, y, 'bo')  # plot x and y using blue circle markers\n",
      " |      >>> plot(y)           # plot y using x as index array 0..N-1\n",
      " |      >>> plot(y, 'r+')     # ditto, but with red plusses\n",
      " |      \n",
      " |      You can use `.Line2D` properties as keyword arguments for more\n",
      " |      control on the appearance. Line properties and *fmt* can be mixed.\n",
      " |      The following two calls yield identical results:\n",
      " |      \n",
      " |      >>> plot(x, y, 'go--', linewidth=2, markersize=12)\n",
      " |      >>> plot(x, y, color='green', marker='o', linestyle='dashed',\n",
      " |      ...      linewidth=2, markersize=12)\n",
      " |      \n",
      " |      When conflicting with *fmt*, keyword arguments take precedence.\n",
      " |      \n",
      " |      \n",
      " |      **Plotting labelled data**\n",
      " |      \n",
      " |      There's a convenient way for plotting objects with labelled data (i.e.\n",
      " |      data that can be accessed by index ``obj['y']``). Instead of giving\n",
      " |      the data in *x* and *y*, you can provide the object in the *data*\n",
      " |      parameter and just give the labels for *x* and *y*::\n",
      " |      \n",
      " |      >>> plot('xlabel', 'ylabel', data=obj)\n",
      " |      \n",
      " |      All indexable objects are supported. This could e.g. be a `dict`, a\n",
      " |      `pandas.DataFrame` or a structured numpy array.\n",
      " |      \n",
      " |      \n",
      " |      **Plotting multiple sets of data**\n",
      " |      \n",
      " |      There are various ways to plot multiple sets of data.\n",
      " |      \n",
      " |      - The most straight forward way is just to call `plot` multiple times.\n",
      " |        Example:\n",
      " |      \n",
      " |        >>> plot(x1, y1, 'bo')\n",
      " |        >>> plot(x2, y2, 'go')\n",
      " |      \n",
      " |      - If *x* and/or *y* are 2D arrays a separate data set will be drawn\n",
      " |        for every column. If both *x* and *y* are 2D, they must have the\n",
      " |        same shape. If only one of them is 2D with shape (N, m) the other\n",
      " |        must have length N and will be used for every data set m.\n",
      " |      \n",
      " |        Example:\n",
      " |      \n",
      " |        >>> x = [1, 2, 3]\n",
      " |        >>> y = np.array([[1, 2], [3, 4], [5, 6]])\n",
      " |        >>> plot(x, y)\n",
      " |      \n",
      " |        is equivalent to:\n",
      " |      \n",
      " |        >>> for col in range(y.shape[1]):\n",
      " |        ...     plot(x, y[:, col])\n",
      " |      \n",
      " |      - The third way is to specify multiple sets of *[x]*, *y*, *[fmt]*\n",
      " |        groups::\n",
      " |      \n",
      " |        >>> plot(x1, y1, 'g^', x2, y2, 'g-')\n",
      " |      \n",
      " |        In this case, any additional keyword argument applies to all\n",
      " |        datasets. Also this syntax cannot be combined with the *data*\n",
      " |        parameter.\n",
      " |      \n",
      " |      By default, each line is assigned a different style specified by a\n",
      " |      'style cycle'. The *fmt* and line property parameters are only\n",
      " |      necessary if you want explicit deviations from these defaults.\n",
      " |      Alternatively, you can also change the style cycle using\n",
      " |      :rc:`axes.prop_cycle`.\n",
      " |      \n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      x, y : array-like or scalar\n",
      " |          The horizontal / vertical coordinates of the data points.\n",
      " |          *x* values are optional and default to ``range(len(y))``.\n",
      " |      \n",
      " |          Commonly, these parameters are 1D arrays.\n",
      " |      \n",
      " |          They can also be scalars, or two-dimensional (in that case, the\n",
      " |          columns represent separate data sets).\n",
      " |      \n",
      " |          These arguments cannot be passed as keywords.\n",
      " |      \n",
      " |      fmt : str, optional\n",
      " |          A format string, e.g. 'ro' for red circles. See the *Notes*\n",
      " |          section for a full description of the format strings.\n",
      " |      \n",
      " |          Format strings are just an abbreviation for quickly setting\n",
      " |          basic line properties. All of these and more can also be\n",
      " |          controlled by keyword arguments.\n",
      " |      \n",
      " |          This argument cannot be passed as keyword.\n",
      " |      \n",
      " |      data : indexable object, optional\n",
      " |          An object with labelled data. If given, provide the label names to\n",
      " |          plot in *x* and *y*.\n",
      " |      \n",
      " |          .. note::\n",
      " |              Technically there's a slight ambiguity in calls where the\n",
      " |              second label is a valid *fmt*. ``plot('n', 'o', data=obj)``\n",
      " |              could be ``plt(x, y)`` or ``plt(y, fmt)``. In such cases,\n",
      " |              the former interpretation is chosen, but a warning is issued.\n",
      " |              You may suppress the warning by adding an empty format string\n",
      " |              ``plot('n', 'o', '', data=obj)``.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      list of `.Line2D`\n",
      " |          A list of lines representing the plotted data.\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      scalex, scaley : bool, default: True\n",
      " |          These parameters determine if the view limits are adapted to the\n",
      " |          data limits. The values are passed on to `autoscale_view`.\n",
      " |      \n",
      " |      **kwargs : `.Line2D` properties, optional\n",
      " |          *kwargs* are used to specify properties like a line label (for\n",
      " |          auto legends), linewidth, antialiasing, marker face color.\n",
      " |          Example::\n",
      " |      \n",
      " |          >>> plot([1, 2, 3], [1, 2, 3], 'go-', label='line 1', linewidth=2)\n",
      " |          >>> plot([1, 2, 3], [1, 4, 9], 'rs', label='line 2')\n",
      " |      \n",
      " |          If you specify multiple lines with one plot call, the kwargs apply\n",
      " |          to all those lines. In case the label object is iterable, each\n",
      " |          element is used as labels for each set of data.\n",
      " |      \n",
      " |          Here is a list of available `.Line2D` properties:\n",
      " |      \n",
      " |          Properties:\n",
      " |          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      " |          alpha: scalar or None\n",
      " |          animated: bool\n",
      " |          antialiased or aa: bool\n",
      " |          clip_box: `.Bbox`\n",
      " |          clip_on: bool\n",
      " |          clip_path: Patch or (Path, Transform) or None\n",
      " |          color or c: color\n",
      " |          dash_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          dash_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          dashes: sequence of floats (on/off ink in points) or (None, None)\n",
      " |          data: (2, N) array or two 1D arrays\n",
      " |          drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'\n",
      " |          figure: `.Figure`\n",
      " |          fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}\n",
      " |          gid: str\n",
      " |          in_layout: bool\n",
      " |          label: object\n",
      " |          linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      " |          linewidth or lw: float\n",
      " |          marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`\n",
      " |          markeredgecolor or mec: color\n",
      " |          markeredgewidth or mew: float\n",
      " |          markerfacecolor or mfc: color\n",
      " |          markerfacecoloralt or mfcalt: color\n",
      " |          markersize or ms: float\n",
      " |          markevery: None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]\n",
      " |          path_effects: `.AbstractPathEffect`\n",
      " |          picker: float or callable[[Artist, Event], tuple[bool, dict]]\n",
      " |          pickradius: float\n",
      " |          rasterized: bool\n",
      " |          sketch_params: (scale: float, length: float, randomness: float)\n",
      " |          snap: bool or None\n",
      " |          solid_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          solid_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          transform: unknown\n",
      " |          url: str\n",
      " |          visible: bool\n",
      " |          xdata: 1D array\n",
      " |          ydata: 1D array\n",
      " |          zorder: float\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      scatter : XY scatter plot with markers of varying size and/or color (\n",
      " |          sometimes also called bubble chart).\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      **Format Strings**\n",
      " |      \n",
      " |      A format string consists of a part for color, marker and line::\n",
      " |      \n",
      " |          fmt = '[marker][line][color]'\n",
      " |      \n",
      " |      Each of them is optional. If not provided, the value from the style\n",
      " |      cycle is used. Exception: If ``line`` is given, but no ``marker``,\n",
      " |      the data will be a line without markers.\n",
      " |      \n",
      " |      Other combinations such as ``[color][marker][line]`` are also\n",
      " |      supported, but note that their parsing may be ambiguous.\n",
      " |      \n",
      " |      **Markers**\n",
      " |      \n",
      " |      =============   ===============================\n",
      " |      character       description\n",
      " |      =============   ===============================\n",
      " |      ``'.'``         point marker\n",
      " |      ``','``         pixel marker\n",
      " |      ``'o'``         circle marker\n",
      " |      ``'v'``         triangle_down marker\n",
      " |      ``'^'``         triangle_up marker\n",
      " |      ``'<'``         triangle_left marker\n",
      " |      ``'>'``         triangle_right marker\n",
      " |      ``'1'``         tri_down marker\n",
      " |      ``'2'``         tri_up marker\n",
      " |      ``'3'``         tri_left marker\n",
      " |      ``'4'``         tri_right marker\n",
      " |      ``'8'``         octagon marker\n",
      " |      ``'s'``         square marker\n",
      " |      ``'p'``         pentagon marker\n",
      " |      ``'P'``         plus (filled) marker\n",
      " |      ``'*'``         star marker\n",
      " |      ``'h'``         hexagon1 marker\n",
      " |      ``'H'``         hexagon2 marker\n",
      " |      ``'+'``         plus marker\n",
      " |      ``'x'``         x marker\n",
      " |      ``'X'``         x (filled) marker\n",
      " |      ``'D'``         diamond marker\n",
      " |      ``'d'``         thin_diamond marker\n",
      " |      ``'|'``         vline marker\n",
      " |      ``'_'``         hline marker\n",
      " |      =============   ===============================\n",
      " |      \n",
      " |      **Line Styles**\n",
      " |      \n",
      " |      =============    ===============================\n",
      " |      character        description\n",
      " |      =============    ===============================\n",
      " |      ``'-'``          solid line style\n",
      " |      ``'--'``         dashed line style\n",
      " |      ``'-.'``         dash-dot line style\n",
      " |      ``':'``          dotted line style\n",
      " |      =============    ===============================\n",
      " |      \n",
      " |      Example format strings::\n",
      " |      \n",
      " |          'b'    # blue markers with default shape\n",
      " |          'or'   # red circles\n",
      " |          '-g'   # green solid line\n",
      " |          '--'   # dashed line with default color\n",
      " |          '^k:'  # black triangle_up markers connected by a dotted line\n",
      " |      \n",
      " |      **Colors**\n",
      " |      \n",
      " |      The supported color abbreviations are the single letter codes\n",
      " |      \n",
      " |      =============    ===============================\n",
      " |      character        color\n",
      " |      =============    ===============================\n",
      " |      ``'b'``          blue\n",
      " |      ``'g'``          green\n",
      " |      ``'r'``          red\n",
      " |      ``'c'``          cyan\n",
      " |      ``'m'``          magenta\n",
      " |      ``'y'``          yellow\n",
      " |      ``'k'``          black\n",
      " |      ``'w'``          white\n",
      " |      =============    ===============================\n",
      " |      \n",
      " |      and the ``'CN'`` colors that index into the default property cycle.\n",
      " |      \n",
      " |      If the color is the only part of the format string, you can\n",
      " |      additionally use any  `matplotlib.colors` spec, e.g. full names\n",
      " |      (``'green'``) or hex strings (``'#008000'``).\n",
      " |  \n",
      " |  plot_date(self, x, y, fmt='o', tz=None, xdate=True, ydate=False, *, data=None, **kwargs)\n",
      " |      Plot coercing the axis to treat floats as dates.\n",
      " |      \n",
      " |      .. admonition:: Discouraged\n",
      " |      \n",
      " |          This method exists for historic reasons and will be deprecated in\n",
      " |          the future.\n",
      " |      \n",
      " |          - ``datetime``-like data should directly be plotted using\n",
      " |            `~.Axes.plot`.\n",
      " |          -  If you need to plot plain numeric data as :ref:`date-format` or\n",
      " |             need to set a timezone, call ``ax.xaxis.axis_date`` /\n",
      " |             ``ax.yaxis.axis_date`` before `~.Axes.plot`. See\n",
      " |             `.Axis.axis_date`.\n",
      " |      \n",
      " |      Similar to `.plot`, this plots *y* vs. *x* as lines or markers.\n",
      " |      However, the axis labels are formatted as dates depending on *xdate*\n",
      " |      and *ydate*.  Note that `.plot` will work with `datetime` and\n",
      " |      `numpy.datetime64` objects without resorting to this method.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      x, y : array-like\n",
      " |          The coordinates of the data points. If *xdate* or *ydate* is\n",
      " |          *True*, the respective values *x* or *y* are interpreted as\n",
      " |          :ref:`Matplotlib dates <date-format>`.\n",
      " |      \n",
      " |      fmt : str, optional\n",
      " |          The plot format string. For details, see the corresponding\n",
      " |          parameter in `.plot`.\n",
      " |      \n",
      " |      tz : timezone string or `datetime.tzinfo`, default: :rc:`timezone`\n",
      " |          The time zone to use in labeling dates.\n",
      " |      \n",
      " |      xdate : bool, default: True\n",
      " |          If *True*, the *x*-axis will be interpreted as Matplotlib dates.\n",
      " |      \n",
      " |      ydate : bool, default: False\n",
      " |          If *True*, the *y*-axis will be interpreted as Matplotlib dates.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      list of `.Line2D`\n",
      " |          Objects representing the plotted data.\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      data : indexable object, optional\n",
      " |          If given, the following parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception):\n",
      " |      \n",
      " |          *x*, *y*\n",
      " |      **kwargs\n",
      " |          Keyword arguments control the `.Line2D` properties:\n",
      " |      \n",
      " |          Properties:\n",
      " |          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      " |          alpha: scalar or None\n",
      " |          animated: bool\n",
      " |          antialiased or aa: bool\n",
      " |          clip_box: `.Bbox`\n",
      " |          clip_on: bool\n",
      " |          clip_path: Patch or (Path, Transform) or None\n",
      " |          color or c: color\n",
      " |          dash_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          dash_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          dashes: sequence of floats (on/off ink in points) or (None, None)\n",
      " |          data: (2, N) array or two 1D arrays\n",
      " |          drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'\n",
      " |          figure: `.Figure`\n",
      " |          fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}\n",
      " |          gid: str\n",
      " |          in_layout: bool\n",
      " |          label: object\n",
      " |          linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      " |          linewidth or lw: float\n",
      " |          marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`\n",
      " |          markeredgecolor or mec: color\n",
      " |          markeredgewidth or mew: float\n",
      " |          markerfacecolor or mfc: color\n",
      " |          markerfacecoloralt or mfcalt: color\n",
      " |          markersize or ms: float\n",
      " |          markevery: None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]\n",
      " |          path_effects: `.AbstractPathEffect`\n",
      " |          picker: float or callable[[Artist, Event], tuple[bool, dict]]\n",
      " |          pickradius: float\n",
      " |          rasterized: bool\n",
      " |          sketch_params: (scale: float, length: float, randomness: float)\n",
      " |          snap: bool or None\n",
      " |          solid_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          solid_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          transform: unknown\n",
      " |          url: str\n",
      " |          visible: bool\n",
      " |          xdata: 1D array\n",
      " |          ydata: 1D array\n",
      " |          zorder: float\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      matplotlib.dates : Helper functions on dates.\n",
      " |      matplotlib.dates.date2num : Convert dates to num.\n",
      " |      matplotlib.dates.num2date : Convert num to dates.\n",
      " |      matplotlib.dates.drange : Create an equally spaced sequence of dates.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      If you are using custom date tickers and formatters, it may be\n",
      " |      necessary to set the formatters/locators after the call to\n",
      " |      `.plot_date`. `.plot_date` will set the default tick locator to\n",
      " |      `.AutoDateLocator` (if the tick locator is not already set to a\n",
      " |      `.DateLocator` instance) and the default tick formatter to\n",
      " |      `.AutoDateFormatter` (if the tick formatter is not already set to a\n",
      " |      `.DateFormatter` instance).\n",
      " |  \n",
      " |  psd(self, x, NFFT=None, Fs=None, Fc=None, detrend=None, window=None, noverlap=None, pad_to=None, sides=None, scale_by_freq=None, return_line=None, *, data=None, **kwargs)\n",
      " |      Plot the power spectral density.\n",
      " |      \n",
      " |      The power spectral density :math:`P_{xx}` by Welch's average\n",
      " |      periodogram method.  The vector *x* is divided into *NFFT* length\n",
      " |      segments.  Each segment is detrended by function *detrend* and\n",
      " |      windowed by function *window*.  *noverlap* gives the length of\n",
      " |      the overlap between segments.  The :math:`|\\mathrm{fft}(i)|^2`\n",
      " |      of each segment :math:`i` are averaged to compute :math:`P_{xx}`,\n",
      " |      with a scaling to correct for power loss due to windowing.\n",
      " |      \n",
      " |      If len(*x*) < *NFFT*, it will be zero padded to *NFFT*.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      x : 1-D array or sequence\n",
      " |          Array or sequence containing the data\n",
      " |      \n",
      " |      Fs : float, default: 2\n",
      " |          The sampling frequency (samples per time unit).  It is used to calculate\n",
      " |          the Fourier frequencies, *freqs*, in cycles per time unit.\n",
      " |      \n",
      " |      window : callable or ndarray, default: `.window_hanning`\n",
      " |          A function or a vector of length *NFFT*.  To create window vectors see\n",
      " |          `.window_hanning`, `.window_none`, `numpy.blackman`, `numpy.hamming`,\n",
      " |          `numpy.bartlett`, `scipy.signal`, `scipy.signal.get_window`, etc.  If a\n",
      " |          function is passed as the argument, it must take a data segment as an\n",
      " |          argument and return the windowed version of the segment.\n",
      " |      \n",
      " |      sides : {'default', 'onesided', 'twosided'}, optional\n",
      " |          Which sides of the spectrum to return. 'default' is one-sided for real\n",
      " |          data and two-sided for complex data. 'onesided' forces the return of a\n",
      " |          one-sided spectrum, while 'twosided' forces two-sided.\n",
      " |      \n",
      " |      pad_to : int, optional\n",
      " |          The number of points to which the data segment is padded when performing\n",
      " |          the FFT.  This can be different from *NFFT*, which specifies the number\n",
      " |          of data points used.  While not increasing the actual resolution of the\n",
      " |          spectrum (the minimum distance between resolvable peaks), this can give\n",
      " |          more points in the plot, allowing for more detail. This corresponds to\n",
      " |          the *n* parameter in the call to fft(). The default is None, which sets\n",
      " |          *pad_to* equal to *NFFT*\n",
      " |      \n",
      " |      NFFT : int, default: 256\n",
      " |          The number of data points used in each block for the FFT.  A power 2 is\n",
      " |          most efficient.  This should *NOT* be used to get zero padding, or the\n",
      " |          scaling of the result will be incorrect; use *pad_to* for this instead.\n",
      " |      \n",
      " |      detrend : {'none', 'mean', 'linear'} or callable, default: 'none'\n",
      " |          The function applied to each segment before fft-ing, designed to remove\n",
      " |          the mean or linear trend.  Unlike in MATLAB, where the *detrend* parameter\n",
      " |          is a vector, in Matplotlib it is a function.  The :mod:`~matplotlib.mlab`\n",
      " |          module defines `.detrend_none`, `.detrend_mean`, and `.detrend_linear`,\n",
      " |          but you can use a custom function as well.  You can also use a string to\n",
      " |          choose one of the functions: 'none' calls `.detrend_none`. 'mean' calls\n",
      " |          `.detrend_mean`. 'linear' calls `.detrend_linear`.\n",
      " |      \n",
      " |      scale_by_freq : bool, default: True\n",
      " |          Whether the resulting density values should be scaled by the scaling\n",
      " |          frequency, which gives density in units of Hz^-1.  This allows for\n",
      " |          integration over the returned frequency values.  The default is True for\n",
      " |          MATLAB compatibility.\n",
      " |      \n",
      " |      noverlap : int, default: 0 (no overlap)\n",
      " |          The number of points of overlap between segments.\n",
      " |      \n",
      " |      Fc : int, default: 0\n",
      " |          The center frequency of *x*, which offsets the x extents of the\n",
      " |          plot to reflect the frequency range used when a signal is acquired\n",
      " |          and then filtered and downsampled to baseband.\n",
      " |      \n",
      " |      return_line : bool, default: False\n",
      " |          Whether to include the line object plotted in the returned values.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Pxx : 1-D array\n",
      " |          The values for the power spectrum :math:`P_{xx}` before scaling\n",
      " |          (real valued).\n",
      " |      \n",
      " |      freqs : 1-D array\n",
      " |          The frequencies corresponding to the elements in *Pxx*.\n",
      " |      \n",
      " |      line : `~matplotlib.lines.Line2D`\n",
      " |          The line created by this function.\n",
      " |          Only returned if *return_line* is True.\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      data : indexable object, optional\n",
      " |          If given, the following parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception):\n",
      " |      \n",
      " |          *x*\n",
      " |      \n",
      " |      **kwargs\n",
      " |          Keyword arguments control the `.Line2D` properties:\n",
      " |      \n",
      " |          Properties:\n",
      " |          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      " |          alpha: scalar or None\n",
      " |          animated: bool\n",
      " |          antialiased or aa: bool\n",
      " |          clip_box: `.Bbox`\n",
      " |          clip_on: bool\n",
      " |          clip_path: Patch or (Path, Transform) or None\n",
      " |          color or c: color\n",
      " |          dash_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          dash_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          dashes: sequence of floats (on/off ink in points) or (None, None)\n",
      " |          data: (2, N) array or two 1D arrays\n",
      " |          drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'\n",
      " |          figure: `.Figure`\n",
      " |          fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}\n",
      " |          gid: str\n",
      " |          in_layout: bool\n",
      " |          label: object\n",
      " |          linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      " |          linewidth or lw: float\n",
      " |          marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`\n",
      " |          markeredgecolor or mec: color\n",
      " |          markeredgewidth or mew: float\n",
      " |          markerfacecolor or mfc: color\n",
      " |          markerfacecoloralt or mfcalt: color\n",
      " |          markersize or ms: float\n",
      " |          markevery: None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]\n",
      " |          path_effects: `.AbstractPathEffect`\n",
      " |          picker: float or callable[[Artist, Event], tuple[bool, dict]]\n",
      " |          pickradius: float\n",
      " |          rasterized: bool\n",
      " |          sketch_params: (scale: float, length: float, randomness: float)\n",
      " |          snap: bool or None\n",
      " |          solid_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          solid_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          transform: unknown\n",
      " |          url: str\n",
      " |          visible: bool\n",
      " |          xdata: 1D array\n",
      " |          ydata: 1D array\n",
      " |          zorder: float\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      specgram\n",
      " |          Differs in the default overlap; in not returning the mean of the\n",
      " |          segment periodograms; in returning the times of the segments; and\n",
      " |          in plotting a colormap instead of a line.\n",
      " |      magnitude_spectrum\n",
      " |          Plots the magnitude spectrum.\n",
      " |      csd\n",
      " |          Plots the spectral density between two signals.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      For plotting, the power is plotted as\n",
      " |      :math:`10\\log_{10}(P_{xx})` for decibels, though *Pxx* itself\n",
      " |      is returned.\n",
      " |      \n",
      " |      References\n",
      " |      ----------\n",
      " |      Bendat & Piersol -- Random Data: Analysis and Measurement Procedures,\n",
      " |      John Wiley & Sons (1986)\n",
      " |  \n",
      " |  quiver(self, *args, data=None, **kwargs)\n",
      " |      Plot a 2D field of arrows.\n",
      " |      \n",
      " |      Call signature::\n",
      " |      \n",
      " |        quiver([X, Y], U, V, [C], **kw)\n",
      " |      \n",
      " |      *X*, *Y* define the arrow locations, *U*, *V* define the arrow directions, and\n",
      " |      *C* optionally sets the color.\n",
      " |      \n",
      " |      Each arrow is internally represented by a filled polygon with a default edge\n",
      " |      linewidth of 0. As a result, an arrow is rather a filled area, not a line with\n",
      " |      a head, and `.PolyCollection` properties like *linewidth*, *linestyle*,\n",
      " |      *facecolor*, etc. act accordingly.\n",
      " |      \n",
      " |      **Arrow size**\n",
      " |      \n",
      " |      The default settings auto-scales the length of the arrows to a reasonable size.\n",
      " |      To change this behavior see the *scale* and *scale_units* parameters.\n",
      " |      \n",
      " |      **Arrow shape**\n",
      " |      \n",
      " |      The defaults give a slightly swept-back arrow; to make the head a\n",
      " |      triangle, make *headaxislength* the same as *headlength*. To make the\n",
      " |      arrow more pointed, reduce *headwidth* or increase *headlength* and\n",
      " |      *headaxislength*. To make the head smaller relative to the shaft,\n",
      " |      scale down all the head parameters. You will probably do best to leave\n",
      " |      minshaft alone.\n",
      " |      \n",
      " |      **Arrow outline**\n",
      " |      \n",
      " |      *linewidths* and *edgecolors* can be used to customize the arrow\n",
      " |      outlines.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      X, Y : 1D or 2D array-like, optional\n",
      " |          The x and y coordinates of the arrow locations.\n",
      " |      \n",
      " |          If not given, they will be generated as a uniform integer meshgrid based\n",
      " |          on the dimensions of *U* and *V*.\n",
      " |      \n",
      " |          If *X* and *Y* are 1D but *U*, *V* are 2D, *X*, *Y* are expanded to 2D\n",
      " |          using ``X, Y = np.meshgrid(X, Y)``. In this case ``len(X)`` and ``len(Y)``\n",
      " |          must match the column and row dimensions of *U* and *V*.\n",
      " |      \n",
      " |      U, V : 1D or 2D array-like\n",
      " |          The x and y direction components of the arrow vectors.\n",
      " |      \n",
      " |          They must have the same number of elements, matching the number of arrow\n",
      " |          locations. *U* and *V* may be masked. Only locations unmasked in\n",
      " |          *U*, *V*, and *C* will be drawn.\n",
      " |      \n",
      " |      C : 1D or 2D array-like, optional\n",
      " |          Numeric data that defines the arrow colors by colormapping via *norm* and\n",
      " |          *cmap*.\n",
      " |      \n",
      " |          This does not support explicit colors. If you want to set colors directly,\n",
      " |          use *color* instead.  The size of *C* must match the number of arrow\n",
      " |          locations.\n",
      " |      \n",
      " |      units : {'width', 'height', 'dots', 'inches', 'x', 'y', 'xy'}, default: 'width'\n",
      " |          The arrow dimensions (except for *length*) are measured in multiples of\n",
      " |          this unit.\n",
      " |      \n",
      " |          The following values are supported:\n",
      " |      \n",
      " |          - 'width', 'height': The width or height of the axis.\n",
      " |          - 'dots', 'inches': Pixels or inches based on the figure dpi.\n",
      " |          - 'x', 'y', 'xy': *X*, *Y* or :math:`\\sqrt{X^2 + Y^2}` in data units.\n",
      " |      \n",
      " |          The arrows scale differently depending on the units.  For\n",
      " |          'x' or 'y', the arrows get larger as one zooms in; for other\n",
      " |          units, the arrow size is independent of the zoom state.  For\n",
      " |          'width or 'height', the arrow size increases with the width and\n",
      " |          height of the axes, respectively, when the window is resized;\n",
      " |          for 'dots' or 'inches', resizing does not change the arrows.\n",
      " |      \n",
      " |      angles : {'uv', 'xy'} or array-like, default: 'uv'\n",
      " |          Method for determining the angle of the arrows.\n",
      " |      \n",
      " |          - 'uv': The arrow axis aspect ratio is 1 so that\n",
      " |            if *U* == *V* the orientation of the arrow on the plot is 45 degrees\n",
      " |            counter-clockwise from the horizontal axis (positive to the right).\n",
      " |      \n",
      " |            Use this if the arrows symbolize a quantity that is not based on\n",
      " |            *X*, *Y* data coordinates.\n",
      " |      \n",
      " |          - 'xy': Arrows point from (x, y) to (x+u, y+v).\n",
      " |            Use this for plotting a gradient field, for example.\n",
      " |      \n",
      " |          - Alternatively, arbitrary angles may be specified explicitly as an array\n",
      " |            of values in degrees, counter-clockwise from the horizontal axis.\n",
      " |      \n",
      " |            In this case *U*, *V* is only used to determine the length of the\n",
      " |            arrows.\n",
      " |      \n",
      " |          Note: inverting a data axis will correspondingly invert the\n",
      " |          arrows only with ``angles='xy'``.\n",
      " |      \n",
      " |      scale : float, optional\n",
      " |          Number of data units per arrow length unit, e.g., m/s per plot width; a\n",
      " |          smaller scale parameter makes the arrow longer. Default is *None*.\n",
      " |      \n",
      " |          If *None*, a simple autoscaling algorithm is used, based on the average\n",
      " |          vector length and the number of vectors. The arrow length unit is given by\n",
      " |          the *scale_units* parameter.\n",
      " |      \n",
      " |      scale_units : {'width', 'height', 'dots', 'inches', 'x', 'y', 'xy'}, optional\n",
      " |          If the *scale* kwarg is *None*, the arrow length unit. Default is *None*.\n",
      " |      \n",
      " |          e.g. *scale_units* is 'inches', *scale* is 2.0, and ``(u, v) = (1, 0)``,\n",
      " |          then the vector will be 0.5 inches long.\n",
      " |      \n",
      " |          If *scale_units* is 'width' or 'height', then the vector will be half the\n",
      " |          width/height of the axes.\n",
      " |      \n",
      " |          If *scale_units* is 'x' then the vector will be 0.5 x-axis\n",
      " |          units. To plot vectors in the x-y plane, with u and v having\n",
      " |          the same units as x and y, use\n",
      " |          ``angles='xy', scale_units='xy', scale=1``.\n",
      " |      \n",
      " |      width : float, optional\n",
      " |          Shaft width in arrow units; default depends on choice of units,\n",
      " |          above, and number of vectors; a typical starting value is about\n",
      " |          0.005 times the width of the plot.\n",
      " |      \n",
      " |      headwidth : float, default: 3\n",
      " |          Head width as multiple of shaft width.\n",
      " |      \n",
      " |      headlength : float, default: 5\n",
      " |          Head length as multiple of shaft width.\n",
      " |      \n",
      " |      headaxislength : float, default: 4.5\n",
      " |          Head length at shaft intersection.\n",
      " |      \n",
      " |      minshaft : float, default: 1\n",
      " |          Length below which arrow scales, in units of head length. Do not\n",
      " |          set this to less than 1, or small arrows will look terrible!\n",
      " |      \n",
      " |      minlength : float, default: 1\n",
      " |          Minimum length as a multiple of shaft width; if an arrow length\n",
      " |          is less than this, plot a dot (hexagon) of this diameter instead.\n",
      " |      \n",
      " |      pivot : {'tail', 'mid', 'middle', 'tip'}, default: 'tail'\n",
      " |          The part of the arrow that is anchored to the *X*, *Y* grid. The arrow\n",
      " |          rotates about this point.\n",
      " |      \n",
      " |          'mid' is a synonym for 'middle'.\n",
      " |      \n",
      " |      color : color or color sequence, optional\n",
      " |          Explicit color(s) for the arrows. If *C* has been set, *color* has no\n",
      " |          effect.\n",
      " |      \n",
      " |          This is a synonym for the `.PolyCollection` *facecolor* parameter.\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      data : indexable object, optional\n",
      " |          If given, all parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception).\n",
      " |      \n",
      " |      **kwargs : `~matplotlib.collections.PolyCollection` properties, optional\n",
      " |          All other keyword arguments are passed on to `.PolyCollection`:\n",
      " |      \n",
      " |          Properties:\n",
      " |          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      " |          alpha: array-like or scalar or None\n",
      " |          animated: bool\n",
      " |          antialiased or aa or antialiaseds: bool or list of bools\n",
      " |          array: array-like or None\n",
      " |          capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          clim: (vmin: float, vmax: float)\n",
      " |          clip_box: `.Bbox`\n",
      " |          clip_on: bool\n",
      " |          clip_path: Patch or (Path, Transform) or None\n",
      " |          cmap: `.Colormap` or str or None\n",
      " |          color: color or list of rgba tuples\n",
      " |          edgecolor or ec or edgecolors: color or list of colors or 'face'\n",
      " |          facecolor or facecolors or fc: color or list of colors\n",
      " |          figure: `.Figure`\n",
      " |          gid: str\n",
      " |          hatch: {'/', '\\\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
      " |          in_layout: bool\n",
      " |          joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          label: object\n",
      " |          linestyle or dashes or linestyles or ls: str or tuple or list thereof\n",
      " |          linewidth or linewidths or lw: float or list of floats\n",
      " |          norm: `.Normalize` or None\n",
      " |          offset_transform: `.Transform`\n",
      " |          offsets: (N, 2) or (2,) array-like\n",
      " |          path_effects: `.AbstractPathEffect`\n",
      " |          paths: list of array-like\n",
      " |          picker: None or bool or float or callable\n",
      " |          pickradius: float\n",
      " |          rasterized: bool\n",
      " |          sizes: ndarray or None\n",
      " |          sketch_params: (scale: float, length: float, randomness: float)\n",
      " |          snap: bool or None\n",
      " |          transform: `.Transform`\n",
      " |          url: str\n",
      " |          urls: list of str or None\n",
      " |          verts: list of array-like\n",
      " |          verts_and_codes: unknown\n",
      " |          visible: bool\n",
      " |          zorder: float\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `~matplotlib.quiver.Quiver`\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      .Axes.quiverkey : Add a key to a quiver plot.\n",
      " |  \n",
      " |  quiverkey(self, Q, X, Y, U, label, **kwargs)\n",
      " |      Add a key to a quiver plot.\n",
      " |      \n",
      " |      The positioning of the key depends on *X*, *Y*, *coordinates*, and\n",
      " |      *labelpos*.  If *labelpos* is 'N' or 'S', *X*, *Y* give the position of\n",
      " |      the middle of the key arrow.  If *labelpos* is 'E', *X*, *Y* positions\n",
      " |      the head, and if *labelpos* is 'W', *X*, *Y* positions the tail; in\n",
      " |      either of these two cases, *X*, *Y* is somewhere in the middle of the\n",
      " |      arrow+label key object.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      Q : `matplotlib.quiver.Quiver`\n",
      " |          A `.Quiver` object as returned by a call to `~.Axes.quiver()`.\n",
      " |      X, Y : float\n",
      " |          The location of the key.\n",
      " |      U : float\n",
      " |          The length of the key.\n",
      " |      label : str\n",
      " |          The key label (e.g., length and units of the key).\n",
      " |      angle : float, default: 0\n",
      " |          The angle of the key arrow, in degrees anti-clockwise from the\n",
      " |          x-axis.\n",
      " |      coordinates : {'axes', 'figure', 'data', 'inches'}, default: 'axes'\n",
      " |          Coordinate system and units for *X*, *Y*: 'axes' and 'figure' are\n",
      " |          normalized coordinate systems with (0, 0) in the lower left and\n",
      " |          (1, 1) in the upper right; 'data' are the axes data coordinates\n",
      " |          (used for the locations of the vectors in the quiver plot itself);\n",
      " |          'inches' is position in the figure in inches, with (0, 0) at the\n",
      " |          lower left corner.\n",
      " |      color : color\n",
      " |          Overrides face and edge colors from *Q*.\n",
      " |      labelpos : {'N', 'S', 'E', 'W'}\n",
      " |          Position the label above, below, to the right, to the left of the\n",
      " |          arrow, respectively.\n",
      " |      labelsep : float, default: 0.1\n",
      " |          Distance in inches between the arrow and the label.\n",
      " |      labelcolor : color, default: :rc:`text.color`\n",
      " |          Label color.\n",
      " |      fontproperties : dict, optional\n",
      " |          A dictionary with keyword arguments accepted by the\n",
      " |          `~matplotlib.font_manager.FontProperties` initializer:\n",
      " |          *family*, *style*, *variant*, *size*, *weight*.\n",
      " |      **kwargs\n",
      " |          Any additional keyword arguments are used to override vector\n",
      " |          properties taken from *Q*.\n",
      " |  \n",
      " |  scatter(self, x, y, s=None, c=None, marker=None, cmap=None, norm=None, vmin=None, vmax=None, alpha=None, linewidths=None, *, edgecolors=None, plotnonfinite=False, data=None, **kwargs)\n",
      " |      A scatter plot of *y* vs. *x* with varying marker size and/or color.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      x, y : float or array-like, shape (n, )\n",
      " |          The data positions.\n",
      " |      \n",
      " |      s : float or array-like, shape (n, ), optional\n",
      " |          The marker size in points**2.\n",
      " |          Default is ``rcParams['lines.markersize'] ** 2``.\n",
      " |      \n",
      " |      c : array-like or list of colors or color, optional\n",
      " |          The marker colors. Possible values:\n",
      " |      \n",
      " |          - A scalar or sequence of n numbers to be mapped to colors using\n",
      " |            *cmap* and *norm*.\n",
      " |          - A 2D array in which the rows are RGB or RGBA.\n",
      " |          - A sequence of colors of length n.\n",
      " |          - A single color format string.\n",
      " |      \n",
      " |          Note that *c* should not be a single numeric RGB or RGBA sequence\n",
      " |          because that is indistinguishable from an array of values to be\n",
      " |          colormapped. If you want to specify the same RGB or RGBA value for\n",
      " |          all points, use a 2D array with a single row.  Otherwise, value-\n",
      " |          matching will have precedence in case of a size matching with *x*\n",
      " |          and *y*.\n",
      " |      \n",
      " |          If you wish to specify a single color for all points\n",
      " |          prefer the *color* keyword argument.\n",
      " |      \n",
      " |          Defaults to `None`. In that case the marker color is determined\n",
      " |          by the value of *color*, *facecolor* or *facecolors*. In case\n",
      " |          those are not specified or `None`, the marker color is determined\n",
      " |          by the next color of the ``Axes``' current \"shape and fill\" color\n",
      " |          cycle. This cycle defaults to :rc:`axes.prop_cycle`.\n",
      " |      \n",
      " |      marker : `~.markers.MarkerStyle`, default: :rc:`scatter.marker`\n",
      " |          The marker style. *marker* can be either an instance of the class\n",
      " |          or the text shorthand for a particular marker.\n",
      " |          See :mod:`matplotlib.markers` for more information about marker\n",
      " |          styles.\n",
      " |      \n",
      " |      cmap : str or `~matplotlib.colors.Colormap`, default: :rc:`image.cmap`\n",
      " |          A `.Colormap` instance or registered colormap name. *cmap* is only\n",
      " |          used if *c* is an array of floats.\n",
      " |      \n",
      " |      norm : `~matplotlib.colors.Normalize`, default: None\n",
      " |          If *c* is an array of floats, *norm* is used to scale the color\n",
      " |          data, *c*, in the range 0 to 1, in order to map into the colormap\n",
      " |          *cmap*.\n",
      " |          If *None*, use the default `.colors.Normalize`.\n",
      " |      \n",
      " |      vmin, vmax : float, default: None\n",
      " |          *vmin* and *vmax* are used in conjunction with the default norm to\n",
      " |          map the color array *c* to the colormap *cmap*. If None, the\n",
      " |          respective min and max of the color array is used.\n",
      " |          It is an error to use *vmin*/*vmax* when *norm* is given.\n",
      " |      \n",
      " |      alpha : float, default: None\n",
      " |          The alpha blending value, between 0 (transparent) and 1 (opaque).\n",
      " |      \n",
      " |      linewidths : float or array-like, default: :rc:`lines.linewidth`\n",
      " |          The linewidth of the marker edges. Note: The default *edgecolors*\n",
      " |          is 'face'. You may want to change this as well.\n",
      " |      \n",
      " |      edgecolors : {'face', 'none', *None*} or color or sequence of color, default: :rc:`scatter.edgecolors`\n",
      " |          The edge color of the marker. Possible values:\n",
      " |      \n",
      " |          - 'face': The edge color will always be the same as the face color.\n",
      " |          - 'none': No patch boundary will be drawn.\n",
      " |          - A color or sequence of colors.\n",
      " |      \n",
      " |          For non-filled markers, *edgecolors* is ignored. Instead, the color\n",
      " |          is determined like with 'face', i.e. from *c*, *colors*, or\n",
      " |          *facecolors*.\n",
      " |      \n",
      " |      plotnonfinite : bool, default: False\n",
      " |          Whether to plot points with nonfinite *c* (i.e. ``inf``, ``-inf``\n",
      " |          or ``nan``). If ``True`` the points are drawn with the *bad*\n",
      " |          colormap color (see `.Colormap.set_bad`).\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `~matplotlib.collections.PathCollection`\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      data : indexable object, optional\n",
      " |          If given, the following parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception):\n",
      " |      \n",
      " |          *x*, *y*, *s*, *linewidths*, *edgecolors*, *c*, *facecolor*, *facecolors*, *color*\n",
      " |      **kwargs : `~matplotlib.collections.Collection` properties\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      plot : To plot scatter plots when markers are identical in size and\n",
      " |          color.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      * The `.plot` function will be faster for scatterplots where markers\n",
      " |        don't vary in size or color.\n",
      " |      \n",
      " |      * Any or all of *x*, *y*, *s*, and *c* may be masked arrays, in which\n",
      " |        case all masks will be combined and only unmasked points will be\n",
      " |        plotted.\n",
      " |      \n",
      " |      * Fundamentally, scatter works with 1D arrays; *x*, *y*, *s*, and *c*\n",
      " |        may be input as N-D arrays, but within scatter they will be\n",
      " |        flattened. The exception is *c*, which will be flattened only if its\n",
      " |        size matches the size of *x* and *y*.\n",
      " |  \n",
      " |  secondary_xaxis(self, location, *, functions=None, **kwargs)\n",
      " |      Add a second x-axis to this Axes.\n",
      " |      \n",
      " |      For example if we want to have a second scale for the data plotted on\n",
      " |      the xaxis.\n",
      " |      \n",
      " |      \n",
      " |      Warnings\n",
      " |      --------\n",
      " |      This method is experimental as of 3.1, and the API may change.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      location : {'top', 'bottom', 'left', 'right'} or float\n",
      " |          The position to put the secondary axis.  Strings can be 'top' or\n",
      " |          'bottom' for orientation='x' and 'right' or 'left' for\n",
      " |          orientation='y'. A float indicates the relative position on the\n",
      " |          parent axes to put the new axes, 0.0 being the bottom (or left)\n",
      " |          and 1.0 being the top (or right).\n",
      " |      \n",
      " |      functions : 2-tuple of func, or Transform with an inverse\n",
      " |      \n",
      " |          If a 2-tuple of functions, the user specifies the transform\n",
      " |          function and its inverse.  i.e.\n",
      " |          ``functions=(lambda x: 2 / x, lambda x: 2 / x)`` would be an\n",
      " |          reciprocal transform with a factor of 2. Both functions must accept\n",
      " |          numpy arrays as input.\n",
      " |      \n",
      " |          The user can also directly supply a subclass of\n",
      " |          `.transforms.Transform` so long as it has an inverse.\n",
      " |      \n",
      " |          See :doc:`/gallery/subplots_axes_and_figures/secondary_axis`\n",
      " |          for examples of making these conversions.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      ax : axes._secondary_axes.SecondaryAxis\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      **kwargs : `~matplotlib.axes.Axes` properties.\n",
      " |          Other miscellaneous axes parameters.\n",
      " |      \n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      The main axis shows frequency, and the secondary axis shows period.\n",
      " |      \n",
      " |      .. plot::\n",
      " |      \n",
      " |          fig, ax = plt.subplots()\n",
      " |          ax.loglog(range(1, 360, 5), range(1, 360, 5))\n",
      " |          ax.set_xlabel('frequency [Hz]')\n",
      " |      \n",
      " |          def invert(x):\n",
      " |              # 1/x with special treatment of x == 0\n",
      " |              x = np.array(x).astype(float)\n",
      " |              near_zero = np.isclose(x, 0)\n",
      " |              x[near_zero] = np.inf\n",
      " |              x[~near_zero] = 1 / x[~near_zero]\n",
      " |              return x\n",
      " |      \n",
      " |          # the inverse of 1/x is itself\n",
      " |          secax = ax.secondary_xaxis('top', functions=(invert, invert))\n",
      " |          secax.set_xlabel('Period [s]')\n",
      " |          plt.show()\n",
      " |  \n",
      " |  secondary_yaxis(self, location, *, functions=None, **kwargs)\n",
      " |      Add a second y-axis to this Axes.\n",
      " |      \n",
      " |      For example if we want to have a second scale for the data plotted on\n",
      " |      the yaxis.\n",
      " |      \n",
      " |      \n",
      " |      Warnings\n",
      " |      --------\n",
      " |      This method is experimental as of 3.1, and the API may change.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      location : {'top', 'bottom', 'left', 'right'} or float\n",
      " |          The position to put the secondary axis.  Strings can be 'top' or\n",
      " |          'bottom' for orientation='x' and 'right' or 'left' for\n",
      " |          orientation='y'. A float indicates the relative position on the\n",
      " |          parent axes to put the new axes, 0.0 being the bottom (or left)\n",
      " |          and 1.0 being the top (or right).\n",
      " |      \n",
      " |      functions : 2-tuple of func, or Transform with an inverse\n",
      " |      \n",
      " |          If a 2-tuple of functions, the user specifies the transform\n",
      " |          function and its inverse.  i.e.\n",
      " |          ``functions=(lambda x: 2 / x, lambda x: 2 / x)`` would be an\n",
      " |          reciprocal transform with a factor of 2. Both functions must accept\n",
      " |          numpy arrays as input.\n",
      " |      \n",
      " |          The user can also directly supply a subclass of\n",
      " |          `.transforms.Transform` so long as it has an inverse.\n",
      " |      \n",
      " |          See :doc:`/gallery/subplots_axes_and_figures/secondary_axis`\n",
      " |          for examples of making these conversions.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      ax : axes._secondary_axes.SecondaryAxis\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      **kwargs : `~matplotlib.axes.Axes` properties.\n",
      " |          Other miscellaneous axes parameters.\n",
      " |      \n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      Add a secondary Axes that converts from radians to degrees\n",
      " |      \n",
      " |      .. plot::\n",
      " |      \n",
      " |          fig, ax = plt.subplots()\n",
      " |          ax.plot(range(1, 360, 5), range(1, 360, 5))\n",
      " |          ax.set_ylabel('degrees')\n",
      " |          secax = ax.secondary_yaxis('right', functions=(np.deg2rad,\n",
      " |                                                         np.rad2deg))\n",
      " |          secax.set_ylabel('radians')\n",
      " |  \n",
      " |  semilogx(self, *args, **kwargs)\n",
      " |      Make a plot with log scaling on the x axis.\n",
      " |      \n",
      " |      Call signatures::\n",
      " |      \n",
      " |          semilogx([x], y, [fmt], data=None, **kwargs)\n",
      " |          semilogx([x], y, [fmt], [x2], y2, [fmt2], ..., **kwargs)\n",
      " |      \n",
      " |      This is just a thin wrapper around `.plot` which additionally changes\n",
      " |      the x-axis to log scaling. All of the concepts and parameters of plot\n",
      " |      can be used here as well.\n",
      " |      \n",
      " |      The additional parameters *base*, *subs*, and *nonpositive* control the\n",
      " |      x-axis properties. They are just forwarded to `.Axes.set_xscale`.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      base : float, default: 10\n",
      " |          Base of the x logarithm.\n",
      " |      \n",
      " |      subs : array-like, optional\n",
      " |          The location of the minor xticks. If *None*, reasonable locations\n",
      " |          are automatically chosen depending on the number of decades in the\n",
      " |          plot. See `.Axes.set_xscale` for details.\n",
      " |      \n",
      " |      nonpositive : {'mask', 'clip'}, default: 'mask'\n",
      " |          Non-positive values in x can be masked as invalid, or clipped to a\n",
      " |          very small positive number.\n",
      " |      \n",
      " |      **kwargs\n",
      " |          All parameters supported by `.plot`.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      list of `.Line2D`\n",
      " |          Objects representing the plotted data.\n",
      " |  \n",
      " |  semilogy(self, *args, **kwargs)\n",
      " |      Make a plot with log scaling on the y axis.\n",
      " |      \n",
      " |      Call signatures::\n",
      " |      \n",
      " |          semilogy([x], y, [fmt], data=None, **kwargs)\n",
      " |          semilogy([x], y, [fmt], [x2], y2, [fmt2], ..., **kwargs)\n",
      " |      \n",
      " |      This is just a thin wrapper around `.plot` which additionally changes\n",
      " |      the y-axis to log scaling. All of the concepts and parameters of plot\n",
      " |      can be used here as well.\n",
      " |      \n",
      " |      The additional parameters *base*, *subs*, and *nonpositive* control the\n",
      " |      y-axis properties. They are just forwarded to `.Axes.set_yscale`.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      base : float, default: 10\n",
      " |          Base of the y logarithm.\n",
      " |      \n",
      " |      subs : array-like, optional\n",
      " |          The location of the minor yticks. If *None*, reasonable locations\n",
      " |          are automatically chosen depending on the number of decades in the\n",
      " |          plot. See `.Axes.set_yscale` for details.\n",
      " |      \n",
      " |      nonpositive : {'mask', 'clip'}, default: 'mask'\n",
      " |          Non-positive values in y can be masked as invalid, or clipped to a\n",
      " |          very small positive number.\n",
      " |      \n",
      " |      **kwargs\n",
      " |          All parameters supported by `.plot`.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      list of `.Line2D`\n",
      " |          Objects representing the plotted data.\n",
      " |  \n",
      " |  set_title(self, label, fontdict=None, loc=None, pad=None, *, y=None, **kwargs)\n",
      " |      Set a title for the Axes.\n",
      " |      \n",
      " |      Set one of the three available Axes titles. The available titles\n",
      " |      are positioned above the Axes in the center, flush with the left\n",
      " |      edge, and flush with the right edge.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      label : str\n",
      " |          Text to use for the title\n",
      " |      \n",
      " |      fontdict : dict\n",
      " |          A dictionary controlling the appearance of the title text,\n",
      " |          the default *fontdict* is::\n",
      " |      \n",
      " |             {'fontsize': rcParams['axes.titlesize'],\n",
      " |              'fontweight': rcParams['axes.titleweight'],\n",
      " |              'color': rcParams['axes.titlecolor'],\n",
      " |              'verticalalignment': 'baseline',\n",
      " |              'horizontalalignment': loc}\n",
      " |      \n",
      " |      loc : {'center', 'left', 'right'}, default: :rc:`axes.titlelocation`\n",
      " |          Which title to set.\n",
      " |      \n",
      " |      y : float, default: :rc:`axes.titley`\n",
      " |          Vertical Axes location for the title (1.0 is the top).  If\n",
      " |          None (the default) and :rc:`axes.titley` is also None, y is\n",
      " |          determined automatically to avoid decorators on the Axes.\n",
      " |      \n",
      " |      pad : float, default: :rc:`axes.titlepad`\n",
      " |          The offset of the title from the top of the Axes, in points.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `.Text`\n",
      " |          The matplotlib text instance representing the title\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      **kwargs : `.Text` properties\n",
      " |          Other keyword arguments are text properties, see `.Text` for a list\n",
      " |          of valid text properties.\n",
      " |  \n",
      " |  specgram(self, x, NFFT=None, Fs=None, Fc=None, detrend=None, window=None, noverlap=None, cmap=None, xextent=None, pad_to=None, sides=None, scale_by_freq=None, mode=None, scale=None, vmin=None, vmax=None, *, data=None, **kwargs)\n",
      " |      Plot a spectrogram.\n",
      " |      \n",
      " |      Compute and plot a spectrogram of data in *x*.  Data are split into\n",
      " |      *NFFT* length segments and the spectrum of each section is\n",
      " |      computed.  The windowing function *window* is applied to each\n",
      " |      segment, and the amount of overlap of each segment is\n",
      " |      specified with *noverlap*. The spectrogram is plotted as a colormap\n",
      " |      (using imshow).\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      x : 1-D array or sequence\n",
      " |          Array or sequence containing the data.\n",
      " |      \n",
      " |      Fs : float, default: 2\n",
      " |          The sampling frequency (samples per time unit).  It is used to calculate\n",
      " |          the Fourier frequencies, *freqs*, in cycles per time unit.\n",
      " |      \n",
      " |      window : callable or ndarray, default: `.window_hanning`\n",
      " |          A function or a vector of length *NFFT*.  To create window vectors see\n",
      " |          `.window_hanning`, `.window_none`, `numpy.blackman`, `numpy.hamming`,\n",
      " |          `numpy.bartlett`, `scipy.signal`, `scipy.signal.get_window`, etc.  If a\n",
      " |          function is passed as the argument, it must take a data segment as an\n",
      " |          argument and return the windowed version of the segment.\n",
      " |      \n",
      " |      sides : {'default', 'onesided', 'twosided'}, optional\n",
      " |          Which sides of the spectrum to return. 'default' is one-sided for real\n",
      " |          data and two-sided for complex data. 'onesided' forces the return of a\n",
      " |          one-sided spectrum, while 'twosided' forces two-sided.\n",
      " |      \n",
      " |      pad_to : int, optional\n",
      " |          The number of points to which the data segment is padded when performing\n",
      " |          the FFT.  This can be different from *NFFT*, which specifies the number\n",
      " |          of data points used.  While not increasing the actual resolution of the\n",
      " |          spectrum (the minimum distance between resolvable peaks), this can give\n",
      " |          more points in the plot, allowing for more detail. This corresponds to\n",
      " |          the *n* parameter in the call to fft(). The default is None, which sets\n",
      " |          *pad_to* equal to *NFFT*\n",
      " |      \n",
      " |      NFFT : int, default: 256\n",
      " |          The number of data points used in each block for the FFT.  A power 2 is\n",
      " |          most efficient.  This should *NOT* be used to get zero padding, or the\n",
      " |          scaling of the result will be incorrect; use *pad_to* for this instead.\n",
      " |      \n",
      " |      detrend : {'none', 'mean', 'linear'} or callable, default: 'none'\n",
      " |          The function applied to each segment before fft-ing, designed to remove\n",
      " |          the mean or linear trend.  Unlike in MATLAB, where the *detrend* parameter\n",
      " |          is a vector, in Matplotlib it is a function.  The :mod:`~matplotlib.mlab`\n",
      " |          module defines `.detrend_none`, `.detrend_mean`, and `.detrend_linear`,\n",
      " |          but you can use a custom function as well.  You can also use a string to\n",
      " |          choose one of the functions: 'none' calls `.detrend_none`. 'mean' calls\n",
      " |          `.detrend_mean`. 'linear' calls `.detrend_linear`.\n",
      " |      \n",
      " |      scale_by_freq : bool, default: True\n",
      " |          Whether the resulting density values should be scaled by the scaling\n",
      " |          frequency, which gives density in units of Hz^-1.  This allows for\n",
      " |          integration over the returned frequency values.  The default is True for\n",
      " |          MATLAB compatibility.\n",
      " |      \n",
      " |      mode : {'default', 'psd', 'magnitude', 'angle', 'phase'}\n",
      " |          What sort of spectrum to use.  Default is 'psd', which takes the\n",
      " |          power spectral density.  'magnitude' returns the magnitude\n",
      " |          spectrum.  'angle' returns the phase spectrum without unwrapping.\n",
      " |          'phase' returns the phase spectrum with unwrapping.\n",
      " |      \n",
      " |      noverlap : int, default: 128\n",
      " |          The number of points of overlap between blocks.\n",
      " |      \n",
      " |      scale : {'default', 'linear', 'dB'}\n",
      " |          The scaling of the values in the *spec*.  'linear' is no scaling.\n",
      " |          'dB' returns the values in dB scale.  When *mode* is 'psd',\n",
      " |          this is dB power (10 * log10).  Otherwise this is dB amplitude\n",
      " |          (20 * log10). 'default' is 'dB' if *mode* is 'psd' or\n",
      " |          'magnitude' and 'linear' otherwise.  This must be 'linear'\n",
      " |          if *mode* is 'angle' or 'phase'.\n",
      " |      \n",
      " |      Fc : int, default: 0\n",
      " |          The center frequency of *x*, which offsets the x extents of the\n",
      " |          plot to reflect the frequency range used when a signal is acquired\n",
      " |          and then filtered and downsampled to baseband.\n",
      " |      \n",
      " |      cmap : `.Colormap`, default: :rc:`image.cmap`\n",
      " |      \n",
      " |      xextent : *None* or (xmin, xmax)\n",
      " |          The image extent along the x-axis. The default sets *xmin* to the\n",
      " |          left border of the first bin (*spectrum* column) and *xmax* to the\n",
      " |          right border of the last bin. Note that for *noverlap>0* the width\n",
      " |          of the bins is smaller than those of the segments.\n",
      " |      \n",
      " |      data : indexable object, optional\n",
      " |          If given, the following parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception):\n",
      " |      \n",
      " |          *x*\n",
      " |      \n",
      " |      **kwargs\n",
      " |          Additional keyword arguments are passed on to `~.axes.Axes.imshow`\n",
      " |          which makes the specgram image. The origin keyword argument\n",
      " |          is not supported.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      spectrum : 2D array\n",
      " |          Columns are the periodograms of successive segments.\n",
      " |      \n",
      " |      freqs : 1-D array\n",
      " |          The frequencies corresponding to the rows in *spectrum*.\n",
      " |      \n",
      " |      t : 1-D array\n",
      " |          The times corresponding to midpoints of segments (i.e., the columns\n",
      " |          in *spectrum*).\n",
      " |      \n",
      " |      im : `.AxesImage`\n",
      " |          The image created by imshow containing the spectrogram.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      psd\n",
      " |          Differs in the default overlap; in returning the mean of the\n",
      " |          segment periodograms; in not returning times; and in generating a\n",
      " |          line plot instead of colormap.\n",
      " |      magnitude_spectrum\n",
      " |          A single spectrum, similar to having a single segment when *mode*\n",
      " |          is 'magnitude'. Plots a line instead of a colormap.\n",
      " |      angle_spectrum\n",
      " |          A single spectrum, similar to having a single segment when *mode*\n",
      " |          is 'angle'. Plots a line instead of a colormap.\n",
      " |      phase_spectrum\n",
      " |          A single spectrum, similar to having a single segment when *mode*\n",
      " |          is 'phase'. Plots a line instead of a colormap.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      The parameters *detrend* and *scale_by_freq* do only apply when *mode*\n",
      " |      is set to 'psd'.\n",
      " |  \n",
      " |  spy(self, Z, precision=0, marker=None, markersize=None, aspect='equal', origin='upper', **kwargs)\n",
      " |      Plot the sparsity pattern of a 2D array.\n",
      " |      \n",
      " |      This visualizes the non-zero values of the array.\n",
      " |      \n",
      " |      Two plotting styles are available: image and marker. Both\n",
      " |      are available for full arrays, but only the marker style\n",
      " |      works for `scipy.sparse.spmatrix` instances.\n",
      " |      \n",
      " |      **Image style**\n",
      " |      \n",
      " |      If *marker* and *markersize* are *None*, `~.Axes.imshow` is used. Any\n",
      " |      extra remaining keyword arguments are passed to this method.\n",
      " |      \n",
      " |      **Marker style**\n",
      " |      \n",
      " |      If *Z* is a `scipy.sparse.spmatrix` or *marker* or *markersize* are\n",
      " |      *None*, a `.Line2D` object will be returned with the value of marker\n",
      " |      determining the marker type, and any remaining keyword arguments\n",
      " |      passed to `~.Axes.plot`.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      Z : (M, N) array-like\n",
      " |          The array to be plotted.\n",
      " |      \n",
      " |      precision : float or 'present', default: 0\n",
      " |          If *precision* is 0, any non-zero value will be plotted. Otherwise,\n",
      " |          values of :math:`|Z| > precision` will be plotted.\n",
      " |      \n",
      " |          For `scipy.sparse.spmatrix` instances, you can also\n",
      " |          pass 'present'. In this case any value present in the array\n",
      " |          will be plotted, even if it is identically zero.\n",
      " |      \n",
      " |      aspect : {'equal', 'auto', None} or float, default: 'equal'\n",
      " |          The aspect ratio of the Axes.  This parameter is particularly\n",
      " |          relevant for images since it determines whether data pixels are\n",
      " |          square.\n",
      " |      \n",
      " |          This parameter is a shortcut for explicitly calling\n",
      " |          `.Axes.set_aspect`. See there for further details.\n",
      " |      \n",
      " |          - 'equal': Ensures an aspect ratio of 1. Pixels will be square.\n",
      " |          - 'auto': The Axes is kept fixed and the aspect is adjusted so\n",
      " |            that the data fit in the Axes. In general, this will result in\n",
      " |            non-square pixels.\n",
      " |          - *None*: Use :rc:`image.aspect`.\n",
      " |      \n",
      " |      origin : {'upper', 'lower'}, default: :rc:`image.origin`\n",
      " |          Place the [0, 0] index of the array in the upper left or lower left\n",
      " |          corner of the Axes. The convention 'upper' is typically used for\n",
      " |          matrices and images.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `~matplotlib.image.AxesImage` or `.Line2D`\n",
      " |          The return type depends on the plotting style (see above).\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      **kwargs\n",
      " |          The supported additional parameters depend on the plotting style.\n",
      " |      \n",
      " |          For the image style, you can pass the following additional\n",
      " |          parameters of `~.Axes.imshow`:\n",
      " |      \n",
      " |          - *cmap*\n",
      " |          - *alpha*\n",
      " |          - *url*\n",
      " |          - any `.Artist` properties (passed on to the `.AxesImage`)\n",
      " |      \n",
      " |          For the marker style, you can pass any `.Line2D` property except\n",
      " |          for *linestyle*:\n",
      " |      \n",
      " |          Properties:\n",
      " |          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      " |          alpha: scalar or None\n",
      " |          animated: bool\n",
      " |          antialiased or aa: bool\n",
      " |          clip_box: `.Bbox`\n",
      " |          clip_on: bool\n",
      " |          clip_path: Patch or (Path, Transform) or None\n",
      " |          color or c: color\n",
      " |          dash_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          dash_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          dashes: sequence of floats (on/off ink in points) or (None, None)\n",
      " |          data: (2, N) array or two 1D arrays\n",
      " |          drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'\n",
      " |          figure: `.Figure`\n",
      " |          fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}\n",
      " |          gid: str\n",
      " |          in_layout: bool\n",
      " |          label: object\n",
      " |          linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      " |          linewidth or lw: float\n",
      " |          marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`\n",
      " |          markeredgecolor or mec: color\n",
      " |          markeredgewidth or mew: float\n",
      " |          markerfacecolor or mfc: color\n",
      " |          markerfacecoloralt or mfcalt: color\n",
      " |          markersize or ms: float\n",
      " |          markevery: None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]\n",
      " |          path_effects: `.AbstractPathEffect`\n",
      " |          picker: float or callable[[Artist, Event], tuple[bool, dict]]\n",
      " |          pickradius: float\n",
      " |          rasterized: bool\n",
      " |          sketch_params: (scale: float, length: float, randomness: float)\n",
      " |          snap: bool or None\n",
      " |          solid_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          solid_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          transform: unknown\n",
      " |          url: str\n",
      " |          visible: bool\n",
      " |          xdata: 1D array\n",
      " |          ydata: 1D array\n",
      " |          zorder: float\n",
      " |  \n",
      " |  stackplot(axes, x, *args, labels=(), colors=None, baseline='zero', data=None, **kwargs)\n",
      " |      Draw a stacked area plot.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      x : (N,) array-like\n",
      " |      \n",
      " |      y : (M, N) array-like\n",
      " |          The data is assumed to be unstacked. Each of the following\n",
      " |          calls is legal::\n",
      " |      \n",
      " |              stackplot(x, y)           # where y has shape (M, N)\n",
      " |              stackplot(x, y1, y2, y3)  # where y1, y2, y3, y4 have length N\n",
      " |      \n",
      " |      baseline : {'zero', 'sym', 'wiggle', 'weighted_wiggle'}\n",
      " |          Method used to calculate the baseline:\n",
      " |      \n",
      " |          - ``'zero'``: Constant zero baseline, i.e. a simple stacked plot.\n",
      " |          - ``'sym'``:  Symmetric around zero and is sometimes called\n",
      " |            'ThemeRiver'.\n",
      " |          - ``'wiggle'``: Minimizes the sum of the squared slopes.\n",
      " |          - ``'weighted_wiggle'``: Does the same but weights to account for\n",
      " |            size of each layer. It is also called 'Streamgraph'-layout. More\n",
      " |            details can be found at http://leebyron.com/streamgraph/.\n",
      " |      \n",
      " |      labels : list of str, optional\n",
      " |          A sequence of labels to assign to each data series. If unspecified,\n",
      " |          then no labels will be applied to artists.\n",
      " |      \n",
      " |      colors : list of color, optional\n",
      " |          A sequence of colors to be cycled through and used to color the stacked\n",
      " |          areas. The sequence need not be exactly the same length as the number\n",
      " |          of provided *y*, in which case the colors will repeat from the\n",
      " |          beginning.\n",
      " |      \n",
      " |          If not specified, the colors from the Axes property cycle will be used.\n",
      " |      \n",
      " |      data : indexable object, optional\n",
      " |          If given, all parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception).\n",
      " |      \n",
      " |      **kwargs\n",
      " |          All other keyword arguments are passed to `.Axes.fill_between`.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      list of `.PolyCollection`\n",
      " |          A list of `.PolyCollection` instances, one for each element in the\n",
      " |          stacked area plot.\n",
      " |  \n",
      " |  stairs(self, values, edges=None, *, orientation='vertical', baseline=0, fill=False, data=None, **kwargs)\n",
      " |      A stepwise constant function as a line with bounding edges\n",
      " |      or a filled plot.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      values : array-like\n",
      " |          The step heights.\n",
      " |      \n",
      " |      edges : array-like\n",
      " |          The edge positions, with ``len(edges) == len(vals) + 1``,\n",
      " |          between which the curve takes on vals values.\n",
      " |      \n",
      " |      orientation : {'vertical', 'horizontal'}, default: 'vertical'\n",
      " |          The direction of the steps. Vertical means that *values* are along\n",
      " |          the y-axis, and edges are along the x-axis.\n",
      " |      \n",
      " |      baseline : float, array-like or None, default: 0\n",
      " |          The bottom value of the bounding edges or when\n",
      " |          ``fill=True``, position of lower edge. If *fill* is\n",
      " |          True or an array is passed to *baseline*, a closed\n",
      " |          path is drawn.\n",
      " |      \n",
      " |      fill : bool, default: False\n",
      " |          Whether the area under the step curve should be filled.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      StepPatch : `matplotlib.patches.StepPatch`\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      data : indexable object, optional\n",
      " |          If given, all parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception).\n",
      " |      \n",
      " |      **kwargs\n",
      " |          `~matplotlib.patches.StepPatch` properties\n",
      " |  \n",
      " |  stem(self, *args, linefmt=None, markerfmt=None, basefmt=None, bottom=0, label=None, use_line_collection=True, orientation='vertical', data=None)\n",
      " |      Create a stem plot.\n",
      " |      \n",
      " |      A stem plot draws lines perpendicular to a baseline at each location\n",
      " |      *locs* from the baseline to *heads*, and places a marker there. For\n",
      " |      vertical stem plots (the default), the *locs* are *x* positions, and\n",
      " |      the *heads* are *y* values. For horizontal stem plots, the *locs* are\n",
      " |      *y* positions, and the *heads* are *x* values.\n",
      " |      \n",
      " |      Call signature::\n",
      " |      \n",
      " |        stem([locs,] heads, linefmt=None, markerfmt=None, basefmt=None)\n",
      " |      \n",
      " |      The *locs*-positions are optional. The formats may be provided either\n",
      " |      as positional or as keyword-arguments.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      locs : array-like, default: (0, 1, ..., len(heads) - 1)\n",
      " |          For vertical stem plots, the x-positions of the stems.\n",
      " |          For horizontal stem plots, the y-positions of the stems.\n",
      " |      \n",
      " |      heads : array-like\n",
      " |          For vertical stem plots, the y-values of the stem heads.\n",
      " |          For horizontal stem plots, the x-values of the stem heads.\n",
      " |      \n",
      " |      linefmt : str, optional\n",
      " |          A string defining the color and/or linestyle of the vertical lines:\n",
      " |      \n",
      " |          =========  =============\n",
      " |          Character  Line Style\n",
      " |          =========  =============\n",
      " |          ``'-'``    solid line\n",
      " |          ``'--'``   dashed line\n",
      " |          ``'-.'``   dash-dot line\n",
      " |          ``':'``    dotted line\n",
      " |          =========  =============\n",
      " |      \n",
      " |          Default: 'C0-', i.e. solid line with the first color of the color\n",
      " |          cycle.\n",
      " |      \n",
      " |          Note: Markers specified through this parameter (e.g. 'x') will be\n",
      " |          silently ignored (unless using ``use_line_collection=False``).\n",
      " |          Instead, markers should be specified using *markerfmt*.\n",
      " |      \n",
      " |      markerfmt : str, optional\n",
      " |          A string defining the color and/or shape of the markers at the stem\n",
      " |          heads.  Default: 'C0o', i.e. filled circles with the first color of\n",
      " |          the color cycle.\n",
      " |      \n",
      " |      basefmt : str, default: 'C3-' ('C2-' in classic mode)\n",
      " |          A format string defining the properties of the baseline.\n",
      " |      \n",
      " |      orientation : str, default: 'vertical'\n",
      " |          If 'vertical', will produce a plot with stems oriented vertically,\n",
      " |          otherwise the stems will be oriented horizontally.\n",
      " |      \n",
      " |      bottom : float, default: 0\n",
      " |          The y/x-position of the baseline (depending on orientation).\n",
      " |      \n",
      " |      label : str, default: None\n",
      " |          The label to use for the stems in legends.\n",
      " |      \n",
      " |      use_line_collection : bool, default: True\n",
      " |          If ``True``, store and plot the stem lines as a\n",
      " |          `~.collections.LineCollection` instead of individual lines, which\n",
      " |          significantly increases performance.  If ``False``, defaults to the\n",
      " |          old behavior of using a list of `.Line2D` objects.  This parameter\n",
      " |          may be deprecated in the future.\n",
      " |      \n",
      " |      data : indexable object, optional\n",
      " |          If given, all parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception).\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `.StemContainer`\n",
      " |          The container may be treated like a tuple\n",
      " |          (*markerline*, *stemlines*, *baseline*)\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      .. seealso::\n",
      " |          The MATLAB function\n",
      " |          `stem <https://www.mathworks.com/help/matlab/ref/stem.html>`_\n",
      " |          which inspired this method.\n",
      " |  \n",
      " |  step(self, x, y, *args, where='pre', data=None, **kwargs)\n",
      " |      Make a step plot.\n",
      " |      \n",
      " |      Call signatures::\n",
      " |      \n",
      " |          step(x, y, [fmt], *, data=None, where='pre', **kwargs)\n",
      " |          step(x, y, [fmt], x2, y2, [fmt2], ..., *, where='pre', **kwargs)\n",
      " |      \n",
      " |      This is just a thin wrapper around `.plot` which changes some\n",
      " |      formatting options. Most of the concepts and parameters of plot can be\n",
      " |      used here as well.\n",
      " |      \n",
      " |      .. note::\n",
      " |      \n",
      " |          This method uses a standard plot with a step drawstyle: The *x*\n",
      " |          values are the reference positions and steps extend left/right/both\n",
      " |          directions depending on *where*.\n",
      " |      \n",
      " |          For the common case where you know the values and edges of the\n",
      " |          steps, use `~.Axes.stairs` instead.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      x : array-like\n",
      " |          1D sequence of x positions. It is assumed, but not checked, that\n",
      " |          it is uniformly increasing.\n",
      " |      \n",
      " |      y : array-like\n",
      " |          1D sequence of y levels.\n",
      " |      \n",
      " |      fmt : str, optional\n",
      " |          A format string, e.g. 'g' for a green line. See `.plot` for a more\n",
      " |          detailed description.\n",
      " |      \n",
      " |          Note: While full format strings are accepted, it is recommended to\n",
      " |          only specify the color. Line styles are currently ignored (use\n",
      " |          the keyword argument *linestyle* instead). Markers are accepted\n",
      " |          and plotted on the given positions, however, this is a rarely\n",
      " |          needed feature for step plots.\n",
      " |      \n",
      " |      where : {'pre', 'post', 'mid'}, default: 'pre'\n",
      " |          Define where the steps should be placed:\n",
      " |      \n",
      " |          - 'pre': The y value is continued constantly to the left from\n",
      " |            every *x* position, i.e. the interval ``(x[i-1], x[i]]`` has the\n",
      " |            value ``y[i]``.\n",
      " |          - 'post': The y value is continued constantly to the right from\n",
      " |            every *x* position, i.e. the interval ``[x[i], x[i+1])`` has the\n",
      " |            value ``y[i]``.\n",
      " |          - 'mid': Steps occur half-way between the *x* positions.\n",
      " |      \n",
      " |      data : indexable object, optional\n",
      " |          An object with labelled data. If given, provide the label names to\n",
      " |          plot in *x* and *y*.\n",
      " |      \n",
      " |      **kwargs\n",
      " |          Additional parameters are the same as those for `.plot`.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      list of `.Line2D`\n",
      " |          Objects representing the plotted data.\n",
      " |  \n",
      " |  streamplot(axes, x, y, u, v, density=1, linewidth=None, color=None, cmap=None, norm=None, arrowsize=1, arrowstyle='-|>', minlength=0.1, transform=None, zorder=None, start_points=None, maxlength=4.0, integration_direction='both', *, data=None)\n",
      " |      Draw streamlines of a vector flow.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      x, y : 1D/2D arrays\n",
      " |          Evenly spaced strictly increasing arrays to make a grid.  If 2D, all\n",
      " |          rows of *x* must be equal and all columns of *y* must be equal; i.e.,\n",
      " |          they must be as if generated by ``np.meshgrid(x_1d, y_1d)``.\n",
      " |      u, v : 2D arrays\n",
      " |          *x* and *y*-velocities. The number of rows and columns must match\n",
      " |          the length of *y* and *x*, respectively.\n",
      " |      density : float or (float, float)\n",
      " |          Controls the closeness of streamlines. When ``density = 1``, the domain\n",
      " |          is divided into a 30x30 grid. *density* linearly scales this grid.\n",
      " |          Each cell in the grid can have, at most, one traversing streamline.\n",
      " |          For different densities in each direction, use a tuple\n",
      " |          (density_x, density_y).\n",
      " |      linewidth : float or 2D array\n",
      " |          The width of the stream lines. With a 2D array the line width can be\n",
      " |          varied across the grid. The array must have the same shape as *u*\n",
      " |          and *v*.\n",
      " |      color : color or 2D array\n",
      " |          The streamline color. If given an array, its values are converted to\n",
      " |          colors using *cmap* and *norm*.  The array must have the same shape\n",
      " |          as *u* and *v*.\n",
      " |      cmap : `~matplotlib.colors.Colormap`\n",
      " |          Colormap used to plot streamlines and arrows. This is only used if\n",
      " |          *color* is an array.\n",
      " |      norm : `~matplotlib.colors.Normalize`\n",
      " |          Normalize object used to scale luminance data to 0, 1. If ``None``,\n",
      " |          stretch (min, max) to (0, 1). This is only used if *color* is an array.\n",
      " |      arrowsize : float\n",
      " |          Scaling factor for the arrow size.\n",
      " |      arrowstyle : str\n",
      " |          Arrow style specification.\n",
      " |          See `~matplotlib.patches.FancyArrowPatch`.\n",
      " |      minlength : float\n",
      " |          Minimum length of streamline in axes coordinates.\n",
      " |      start_points : Nx2 array\n",
      " |          Coordinates of starting points for the streamlines in data coordinates\n",
      " |          (the same coordinates as the *x* and *y* arrays).\n",
      " |      zorder : int\n",
      " |          The zorder of the stream lines and arrows.\n",
      " |          Artists with lower zorder values are drawn first.\n",
      " |      maxlength : float\n",
      " |          Maximum length of streamline in axes coordinates.\n",
      " |      integration_direction : {'forward', 'backward', 'both'}, default: 'both'\n",
      " |          Integrate the streamline in forward, backward or both directions.\n",
      " |      data : indexable object, optional\n",
      " |          If given, the following parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception):\n",
      " |      \n",
      " |          *x*, *y*, *u*, *v*, *start_points*\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      StreamplotSet\n",
      " |          Container object with attributes\n",
      " |      \n",
      " |          - ``lines``: `.LineCollection` of streamlines\n",
      " |      \n",
      " |          - ``arrows``: `.PatchCollection` containing `.FancyArrowPatch`\n",
      " |            objects representing the arrows half-way along stream lines.\n",
      " |      \n",
      " |          This container will probably change in the future to allow changes\n",
      " |          to the colormap, alpha, etc. for both lines and arrows, but these\n",
      " |          changes should be backward compatible.\n",
      " |  \n",
      " |  table(ax, cellText=None, cellColours=None, cellLoc='right', colWidths=None, rowLabels=None, rowColours=None, rowLoc='left', colLabels=None, colColours=None, colLoc='center', loc='bottom', bbox=None, edges='closed', **kwargs)\n",
      " |      Add a table to an `~.axes.Axes`.\n",
      " |      \n",
      " |      At least one of *cellText* or *cellColours* must be specified. These\n",
      " |      parameters must be 2D lists, in which the outer lists define the rows and\n",
      " |      the inner list define the column values per row. Each row must have the\n",
      " |      same number of elements.\n",
      " |      \n",
      " |      The table can optionally have row and column headers, which are configured\n",
      " |      using *rowLabels*, *rowColours*, *rowLoc* and *colLabels*, *colColours*,\n",
      " |      *colLoc* respectively.\n",
      " |      \n",
      " |      For finer grained control over tables, use the `.Table` class and add it to\n",
      " |      the axes with `.Axes.add_table`.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      cellText : 2D list of str, optional\n",
      " |          The texts to place into the table cells.\n",
      " |      \n",
      " |          *Note*: Line breaks in the strings are currently not accounted for and\n",
      " |          will result in the text exceeding the cell boundaries.\n",
      " |      \n",
      " |      cellColours : 2D list of colors, optional\n",
      " |          The background colors of the cells.\n",
      " |      \n",
      " |      cellLoc : {'left', 'center', 'right'}, default: 'right'\n",
      " |          The alignment of the text within the cells.\n",
      " |      \n",
      " |      colWidths : list of float, optional\n",
      " |          The column widths in units of the axes. If not given, all columns will\n",
      " |          have a width of *1 / ncols*.\n",
      " |      \n",
      " |      rowLabels : list of str, optional\n",
      " |          The text of the row header cells.\n",
      " |      \n",
      " |      rowColours : list of colors, optional\n",
      " |          The colors of the row header cells.\n",
      " |      \n",
      " |      rowLoc : {'left', 'center', 'right'}, default: 'left'\n",
      " |          The text alignment of the row header cells.\n",
      " |      \n",
      " |      colLabels : list of str, optional\n",
      " |          The text of the column header cells.\n",
      " |      \n",
      " |      colColours : list of colors, optional\n",
      " |          The colors of the column header cells.\n",
      " |      \n",
      " |      colLoc : {'left', 'center', 'right'}, default: 'left'\n",
      " |          The text alignment of the column header cells.\n",
      " |      \n",
      " |      loc : str, optional\n",
      " |          The position of the cell with respect to *ax*. This must be one of\n",
      " |          the `~.Table.codes`.\n",
      " |      \n",
      " |      bbox : `.Bbox`, optional\n",
      " |          A bounding box to draw the table into. If this is not *None*, this\n",
      " |          overrides *loc*.\n",
      " |      \n",
      " |      edges : substring of 'BRTL' or {'open', 'closed', 'horizontal', 'vertical'}\n",
      " |          The cell edges to be drawn with a line. See also\n",
      " |          `~.Cell.visible_edges`.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `~matplotlib.table.Table`\n",
      " |          The created table.\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      **kwargs\n",
      " |          `.Table` properties.\n",
      " |      \n",
      " |      Properties:\n",
      " |          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      " |          alpha: scalar or None\n",
      " |          animated: bool\n",
      " |          clip_box: `.Bbox`\n",
      " |          clip_on: bool\n",
      " |          clip_path: Patch or (Path, Transform) or None\n",
      " |          figure: `.Figure`\n",
      " |          fontsize: float\n",
      " |          gid: str\n",
      " |          in_layout: bool\n",
      " |          label: object\n",
      " |          path_effects: `.AbstractPathEffect`\n",
      " |          picker: None or bool or float or callable\n",
      " |          rasterized: bool\n",
      " |          sketch_params: (scale: float, length: float, randomness: float)\n",
      " |          snap: bool or None\n",
      " |          transform: `.Transform`\n",
      " |          url: str\n",
      " |          visible: bool\n",
      " |          zorder: float\n",
      " |  \n",
      " |  text(self, x, y, s, fontdict=None, **kwargs)\n",
      " |      Add text to the Axes.\n",
      " |      \n",
      " |      Add the text *s* to the Axes at location *x*, *y* in data coordinates.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      x, y : float\n",
      " |          The position to place the text. By default, this is in data\n",
      " |          coordinates. The coordinate system can be changed using the\n",
      " |          *transform* parameter.\n",
      " |      \n",
      " |      s : str\n",
      " |          The text.\n",
      " |      \n",
      " |      fontdict : dict, default: None\n",
      " |          A dictionary to override the default text properties. If fontdict\n",
      " |          is None, the defaults are determined by `.rcParams`.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `.Text`\n",
      " |          The created `.Text` instance.\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      **kwargs : `~matplotlib.text.Text` properties.\n",
      " |          Other miscellaneous text parameters.\n",
      " |      \n",
      " |          Properties:\n",
      " |          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      " |          alpha: scalar or None\n",
      " |          animated: bool\n",
      " |          backgroundcolor: color\n",
      " |          bbox: dict with properties for `.patches.FancyBboxPatch`\n",
      " |          clip_box: unknown\n",
      " |          clip_on: unknown\n",
      " |          clip_path: unknown\n",
      " |          color or c: color\n",
      " |          figure: `.Figure`\n",
      " |          fontfamily or family: {FONTNAME, 'serif', 'sans-serif', 'cursive', 'fantasy', 'monospace'}\n",
      " |          fontproperties or font or font_properties: `.font_manager.FontProperties` or `str` or `pathlib.Path`\n",
      " |          fontsize or size: float or {'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'}\n",
      " |          fontstretch or stretch: {a numeric value in range 0-1000, 'ultra-condensed', 'extra-condensed', 'condensed', 'semi-condensed', 'normal', 'semi-expanded', 'expanded', 'extra-expanded', 'ultra-expanded'}\n",
      " |          fontstyle or style: {'normal', 'italic', 'oblique'}\n",
      " |          fontvariant or variant: {'normal', 'small-caps'}\n",
      " |          fontweight or weight: {a numeric value in range 0-1000, 'ultralight', 'light', 'normal', 'regular', 'book', 'medium', 'roman', 'semibold', 'demibold', 'demi', 'bold', 'heavy', 'extra bold', 'black'}\n",
      " |          gid: str\n",
      " |          horizontalalignment or ha: {'center', 'right', 'left'}\n",
      " |          in_layout: bool\n",
      " |          label: object\n",
      " |          linespacing: float (multiple of font size)\n",
      " |          math_fontfamily: str\n",
      " |          multialignment or ma: {'left', 'right', 'center'}\n",
      " |          parse_math: bool\n",
      " |          path_effects: `.AbstractPathEffect`\n",
      " |          picker: None or bool or float or callable\n",
      " |          position: (float, float)\n",
      " |          rasterized: bool\n",
      " |          rotation: float or {'vertical', 'horizontal'}\n",
      " |          rotation_mode: {None, 'default', 'anchor'}\n",
      " |          sketch_params: (scale: float, length: float, randomness: float)\n",
      " |          snap: bool or None\n",
      " |          text: object\n",
      " |          transform: `.Transform`\n",
      " |          transform_rotates_text: bool\n",
      " |          url: str\n",
      " |          usetex: bool or None\n",
      " |          verticalalignment or va: {'center', 'top', 'bottom', 'baseline', 'center_baseline'}\n",
      " |          visible: bool\n",
      " |          wrap: bool\n",
      " |          x: float\n",
      " |          y: float\n",
      " |          zorder: float\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      Individual keyword arguments can be used to override any given\n",
      " |      parameter::\n",
      " |      \n",
      " |          >>> text(x, y, s, fontsize=12)\n",
      " |      \n",
      " |      The default transform specifies that text is in data coords,\n",
      " |      alternatively, you can specify text in axis coords ((0, 0) is\n",
      " |      lower-left and (1, 1) is upper-right).  The example below places\n",
      " |      text in the center of the Axes::\n",
      " |      \n",
      " |          >>> text(0.5, 0.5, 'matplotlib', horizontalalignment='center',\n",
      " |          ...      verticalalignment='center', transform=ax.transAxes)\n",
      " |      \n",
      " |      You can put a rectangular box around the text instance (e.g., to\n",
      " |      set a background color) by using the keyword *bbox*.  *bbox* is\n",
      " |      a dictionary of `~matplotlib.patches.Rectangle`\n",
      " |      properties.  For example::\n",
      " |      \n",
      " |          >>> text(x, y, s, bbox=dict(facecolor='red', alpha=0.5))\n",
      " |  \n",
      " |  tricontour(ax, *args, **kwargs)\n",
      " |      Draw contour lines on an unstructured triangular grid.\n",
      " |      \n",
      " |      The triangulation can be specified in one of two ways; either ::\n",
      " |      \n",
      " |          tricontour(triangulation, ...)\n",
      " |      \n",
      " |      where *triangulation* is a `.Triangulation` object, or ::\n",
      " |      \n",
      " |          tricontour(x, y, ...)\n",
      " |          tricontour(x, y, triangles, ...)\n",
      " |          tricontour(x, y, triangles=triangles, ...)\n",
      " |          tricontour(x, y, mask=mask, ...)\n",
      " |          tricontour(x, y, triangles, mask=mask, ...)\n",
      " |      \n",
      " |      in which case a `.Triangulation` object will be created.  See that class'\n",
      " |      docstring for an explanation of these cases.\n",
      " |      \n",
      " |      The remaining arguments may be::\n",
      " |      \n",
      " |          tricontour(..., Z)\n",
      " |      \n",
      " |      where *Z* is the array of values to contour, one per point in the\n",
      " |      triangulation.  The level values are chosen automatically.\n",
      " |      \n",
      " |      ::\n",
      " |      \n",
      " |          tricontour(..., Z, levels)\n",
      " |      \n",
      " |      contour up to *levels+1* automatically chosen contour levels (*levels*\n",
      " |      intervals).\n",
      " |      \n",
      " |      ::\n",
      " |      \n",
      " |          tricontour(..., Z, levels)\n",
      " |      \n",
      " |      draw contour lines at the values specified in sequence *levels*, which must\n",
      " |      be in increasing order.\n",
      " |      \n",
      " |      ::\n",
      " |      \n",
      " |          tricontour(Z, **kwargs)\n",
      " |      \n",
      " |      Use keyword arguments to control colors, linewidth, origin, cmap ... see below\n",
      " |      for more details.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      triangulation : `.Triangulation`, optional\n",
      " |          The unstructured triangular grid.\n",
      " |      \n",
      " |          If specified, then *x*, *y*, *triangles*, and *mask* are not accepted.\n",
      " |      \n",
      " |      x, y : array-like, optional\n",
      " |          The coordinates of the values in *Z*.\n",
      " |      \n",
      " |      triangles : (ntri, 3) array-like of int, optional\n",
      " |          For each triangle, the indices of the three points that make up the\n",
      " |          triangle, ordered in an anticlockwise manner.  If not specified, the\n",
      " |          Delaunay triangulation is calculated.\n",
      " |      \n",
      " |      mask : (ntri,) array-like of bool, optional\n",
      " |          Which triangles are masked out.\n",
      " |      \n",
      " |      Z : 2D array-like\n",
      " |          The height values over which the contour is drawn.\n",
      " |      \n",
      " |      levels : int or array-like, optional\n",
      " |          Determines the number and positions of the contour lines / regions.\n",
      " |      \n",
      " |          If an int *n*, use `~matplotlib.ticker.MaxNLocator`, which tries to\n",
      " |          automatically choose no more than *n+1* \"nice\" contour levels between\n",
      " |          *vmin* and *vmax*.\n",
      " |      \n",
      " |          If array-like, draw contour lines at the specified levels.  The values must\n",
      " |          be in increasing order.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `~matplotlib.tri.TriContourSet`\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      colors : color string or sequence of colors, optional\n",
      " |          The colors of the levels, i.e., the contour lines.\n",
      " |      \n",
      " |          The sequence is cycled for the levels in ascending order. If the sequence\n",
      " |          is shorter than the number of levels, it's repeated.\n",
      " |      \n",
      " |          As a shortcut, single color strings may be used in place of one-element\n",
      " |          lists, i.e. ``'red'`` instead of ``['red']`` to color all levels with the\n",
      " |          same color. This shortcut does only work for color strings, not for other\n",
      " |          ways of specifying colors.\n",
      " |      \n",
      " |          By default (value *None*), the colormap specified by *cmap* will be used.\n",
      " |      \n",
      " |      alpha : float, default: 1\n",
      " |          The alpha blending value, between 0 (transparent) and 1 (opaque).\n",
      " |      \n",
      " |      cmap : str or `.Colormap`, default: :rc:`image.cmap`\n",
      " |          A `.Colormap` instance or registered colormap name. The colormap maps the\n",
      " |          level values to colors.\n",
      " |      \n",
      " |          If both *colors* and *cmap* are given, an error is raised.\n",
      " |      \n",
      " |      norm : `~matplotlib.colors.Normalize`, optional\n",
      " |          If a colormap is used, the `.Normalize` instance scales the level values to\n",
      " |          the canonical colormap range [0, 1] for mapping to colors. If not given,\n",
      " |          the default linear scaling is used.\n",
      " |      \n",
      " |      vmin, vmax : float, optional\n",
      " |          If not *None*, either or both of these values will be supplied to\n",
      " |          the `.Normalize` instance, overriding the default color scaling\n",
      " |          based on *levels*.\n",
      " |      \n",
      " |      origin : {*None*, 'upper', 'lower', 'image'}, default: None\n",
      " |          Determines the orientation and exact position of *Z* by specifying the\n",
      " |          position of ``Z[0, 0]``.  This is only relevant, if *X*, *Y* are not given.\n",
      " |      \n",
      " |          - *None*: ``Z[0, 0]`` is at X=0, Y=0 in the lower left corner.\n",
      " |          - 'lower': ``Z[0, 0]`` is at X=0.5, Y=0.5 in the lower left corner.\n",
      " |          - 'upper': ``Z[0, 0]`` is at X=N+0.5, Y=0.5 in the upper left corner.\n",
      " |          - 'image': Use the value from :rc:`image.origin`.\n",
      " |      \n",
      " |      extent : (x0, x1, y0, y1), optional\n",
      " |          If *origin* is not *None*, then *extent* is interpreted as in `.imshow`: it\n",
      " |          gives the outer pixel boundaries. In this case, the position of Z[0, 0] is\n",
      " |          the center of the pixel, not a corner. If *origin* is *None*, then\n",
      " |          (*x0*, *y0*) is the position of Z[0, 0], and (*x1*, *y1*) is the position\n",
      " |          of Z[-1, -1].\n",
      " |      \n",
      " |          This argument is ignored if *X* and *Y* are specified in the call to\n",
      " |          contour.\n",
      " |      \n",
      " |      locator : ticker.Locator subclass, optional\n",
      " |          The locator is used to determine the contour levels if they are not given\n",
      " |          explicitly via *levels*.\n",
      " |          Defaults to `~.ticker.MaxNLocator`.\n",
      " |      \n",
      " |      extend : {'neither', 'both', 'min', 'max'}, default: 'neither'\n",
      " |          Determines the ``tricontour``-coloring of values that are outside the\n",
      " |          *levels* range.\n",
      " |      \n",
      " |          If 'neither', values outside the *levels* range are not colored.  If 'min',\n",
      " |          'max' or 'both', color the values below, above or below and above the\n",
      " |          *levels* range.\n",
      " |      \n",
      " |          Values below ``min(levels)`` and above ``max(levels)`` are mapped to the\n",
      " |          under/over values of the `.Colormap`. Note that most colormaps do not have\n",
      " |          dedicated colors for these by default, so that the over and under values\n",
      " |          are the edge values of the colormap.  You may want to set these values\n",
      " |          explicitly using `.Colormap.set_under` and `.Colormap.set_over`.\n",
      " |      \n",
      " |          .. note::\n",
      " |      \n",
      " |              An existing `.TriContourSet` does not get notified if properties of its\n",
      " |              colormap are changed. Therefore, an explicit call to\n",
      " |              `.ContourSet.changed()` is needed after modifying the colormap. The\n",
      " |              explicit call can be left out, if a colorbar is assigned to the\n",
      " |              `.TriContourSet` because it internally calls `.ContourSet.changed()`.\n",
      " |      \n",
      " |      xunits, yunits : registered units, optional\n",
      " |          Override axis units by specifying an instance of a\n",
      " |          :class:`matplotlib.units.ConversionInterface`.\n",
      " |      \n",
      " |      antialiased : bool, optional\n",
      " |          Enable antialiasing, overriding the defaults.  For\n",
      " |          filled contours, the default is *True*.  For line contours,\n",
      " |          it is taken from :rc:`lines.antialiased`.\n",
      " |      \n",
      " |      linewidths : float or array-like, default: :rc:`contour.linewidth`\n",
      " |          The line width of the contour lines.\n",
      " |      \n",
      " |          If a number, all levels will be plotted with this linewidth.\n",
      " |      \n",
      " |          If a sequence, the levels in ascending order will be plotted with\n",
      " |          the linewidths in the order specified.\n",
      " |      \n",
      " |          If None, this falls back to :rc:`lines.linewidth`.\n",
      " |      \n",
      " |      linestyles : {*None*, 'solid', 'dashed', 'dashdot', 'dotted'}, optional\n",
      " |          If *linestyles* is *None*, the default is 'solid' unless the lines are\n",
      " |          monochrome.  In that case, negative contours will take their linestyle\n",
      " |          from :rc:`contour.negative_linestyle` setting.\n",
      " |      \n",
      " |          *linestyles* can also be an iterable of the above strings specifying a\n",
      " |          set of linestyles to be used. If this iterable is shorter than the\n",
      " |          number of contour levels it will be repeated as necessary.\n",
      " |  \n",
      " |  tricontourf(ax, *args, **kwargs)\n",
      " |      Draw contour regions on an unstructured triangular grid.\n",
      " |      \n",
      " |      The triangulation can be specified in one of two ways; either ::\n",
      " |      \n",
      " |          tricontourf(triangulation, ...)\n",
      " |      \n",
      " |      where *triangulation* is a `.Triangulation` object, or ::\n",
      " |      \n",
      " |          tricontourf(x, y, ...)\n",
      " |          tricontourf(x, y, triangles, ...)\n",
      " |          tricontourf(x, y, triangles=triangles, ...)\n",
      " |          tricontourf(x, y, mask=mask, ...)\n",
      " |          tricontourf(x, y, triangles, mask=mask, ...)\n",
      " |      \n",
      " |      in which case a `.Triangulation` object will be created.  See that class'\n",
      " |      docstring for an explanation of these cases.\n",
      " |      \n",
      " |      The remaining arguments may be::\n",
      " |      \n",
      " |          tricontourf(..., Z)\n",
      " |      \n",
      " |      where *Z* is the array of values to contour, one per point in the\n",
      " |      triangulation.  The level values are chosen automatically.\n",
      " |      \n",
      " |      ::\n",
      " |      \n",
      " |          tricontourf(..., Z, levels)\n",
      " |      \n",
      " |      contour up to *levels+1* automatically chosen contour levels (*levels*\n",
      " |      intervals).\n",
      " |      \n",
      " |      ::\n",
      " |      \n",
      " |          tricontourf(..., Z, levels)\n",
      " |      \n",
      " |      draw contour regions at the values specified in sequence *levels*, which must\n",
      " |      be in increasing order.\n",
      " |      \n",
      " |      ::\n",
      " |      \n",
      " |          tricontourf(Z, **kwargs)\n",
      " |      \n",
      " |      Use keyword arguments to control colors, linewidth, origin, cmap ... see below\n",
      " |      for more details.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      triangulation : `.Triangulation`, optional\n",
      " |          The unstructured triangular grid.\n",
      " |      \n",
      " |          If specified, then *x*, *y*, *triangles*, and *mask* are not accepted.\n",
      " |      \n",
      " |      x, y : array-like, optional\n",
      " |          The coordinates of the values in *Z*.\n",
      " |      \n",
      " |      triangles : (ntri, 3) array-like of int, optional\n",
      " |          For each triangle, the indices of the three points that make up the\n",
      " |          triangle, ordered in an anticlockwise manner.  If not specified, the\n",
      " |          Delaunay triangulation is calculated.\n",
      " |      \n",
      " |      mask : (ntri,) array-like of bool, optional\n",
      " |          Which triangles are masked out.\n",
      " |      \n",
      " |      Z : 2D array-like\n",
      " |          The height values over which the contour is drawn.\n",
      " |      \n",
      " |      levels : int or array-like, optional\n",
      " |          Determines the number and positions of the contour lines / regions.\n",
      " |      \n",
      " |          If an int *n*, use `~matplotlib.ticker.MaxNLocator`, which tries to\n",
      " |          automatically choose no more than *n+1* \"nice\" contour levels between\n",
      " |          *vmin* and *vmax*.\n",
      " |      \n",
      " |          If array-like, draw contour lines at the specified levels.  The values must\n",
      " |          be in increasing order.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `~matplotlib.tri.TriContourSet`\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      colors : color string or sequence of colors, optional\n",
      " |          The colors of the levels, i.e., the contour regions.\n",
      " |      \n",
      " |          The sequence is cycled for the levels in ascending order. If the sequence\n",
      " |          is shorter than the number of levels, it's repeated.\n",
      " |      \n",
      " |          As a shortcut, single color strings may be used in place of one-element\n",
      " |          lists, i.e. ``'red'`` instead of ``['red']`` to color all levels with the\n",
      " |          same color. This shortcut does only work for color strings, not for other\n",
      " |          ways of specifying colors.\n",
      " |      \n",
      " |          By default (value *None*), the colormap specified by *cmap* will be used.\n",
      " |      \n",
      " |      alpha : float, default: 1\n",
      " |          The alpha blending value, between 0 (transparent) and 1 (opaque).\n",
      " |      \n",
      " |      cmap : str or `.Colormap`, default: :rc:`image.cmap`\n",
      " |          A `.Colormap` instance or registered colormap name. The colormap maps the\n",
      " |          level values to colors.\n",
      " |      \n",
      " |          If both *colors* and *cmap* are given, an error is raised.\n",
      " |      \n",
      " |      norm : `~matplotlib.colors.Normalize`, optional\n",
      " |          If a colormap is used, the `.Normalize` instance scales the level values to\n",
      " |          the canonical colormap range [0, 1] for mapping to colors. If not given,\n",
      " |          the default linear scaling is used.\n",
      " |      \n",
      " |      vmin, vmax : float, optional\n",
      " |          If not *None*, either or both of these values will be supplied to\n",
      " |          the `.Normalize` instance, overriding the default color scaling\n",
      " |          based on *levels*.\n",
      " |      \n",
      " |      origin : {*None*, 'upper', 'lower', 'image'}, default: None\n",
      " |          Determines the orientation and exact position of *Z* by specifying the\n",
      " |          position of ``Z[0, 0]``.  This is only relevant, if *X*, *Y* are not given.\n",
      " |      \n",
      " |          - *None*: ``Z[0, 0]`` is at X=0, Y=0 in the lower left corner.\n",
      " |          - 'lower': ``Z[0, 0]`` is at X=0.5, Y=0.5 in the lower left corner.\n",
      " |          - 'upper': ``Z[0, 0]`` is at X=N+0.5, Y=0.5 in the upper left corner.\n",
      " |          - 'image': Use the value from :rc:`image.origin`.\n",
      " |      \n",
      " |      extent : (x0, x1, y0, y1), optional\n",
      " |          If *origin* is not *None*, then *extent* is interpreted as in `.imshow`: it\n",
      " |          gives the outer pixel boundaries. In this case, the position of Z[0, 0] is\n",
      " |          the center of the pixel, not a corner. If *origin* is *None*, then\n",
      " |          (*x0*, *y0*) is the position of Z[0, 0], and (*x1*, *y1*) is the position\n",
      " |          of Z[-1, -1].\n",
      " |      \n",
      " |          This argument is ignored if *X* and *Y* are specified in the call to\n",
      " |          contour.\n",
      " |      \n",
      " |      locator : ticker.Locator subclass, optional\n",
      " |          The locator is used to determine the contour levels if they are not given\n",
      " |          explicitly via *levels*.\n",
      " |          Defaults to `~.ticker.MaxNLocator`.\n",
      " |      \n",
      " |      extend : {'neither', 'both', 'min', 'max'}, default: 'neither'\n",
      " |          Determines the ``tricontourf``-coloring of values that are outside the\n",
      " |          *levels* range.\n",
      " |      \n",
      " |          If 'neither', values outside the *levels* range are not colored.  If 'min',\n",
      " |          'max' or 'both', color the values below, above or below and above the\n",
      " |          *levels* range.\n",
      " |      \n",
      " |          Values below ``min(levels)`` and above ``max(levels)`` are mapped to the\n",
      " |          under/over values of the `.Colormap`. Note that most colormaps do not have\n",
      " |          dedicated colors for these by default, so that the over and under values\n",
      " |          are the edge values of the colormap.  You may want to set these values\n",
      " |          explicitly using `.Colormap.set_under` and `.Colormap.set_over`.\n",
      " |      \n",
      " |          .. note::\n",
      " |      \n",
      " |              An existing `.TriContourSet` does not get notified if properties of its\n",
      " |              colormap are changed. Therefore, an explicit call to\n",
      " |              `.ContourSet.changed()` is needed after modifying the colormap. The\n",
      " |              explicit call can be left out, if a colorbar is assigned to the\n",
      " |              `.TriContourSet` because it internally calls `.ContourSet.changed()`.\n",
      " |      \n",
      " |      xunits, yunits : registered units, optional\n",
      " |          Override axis units by specifying an instance of a\n",
      " |          :class:`matplotlib.units.ConversionInterface`.\n",
      " |      \n",
      " |      antialiased : bool, optional\n",
      " |          Enable antialiasing, overriding the defaults.  For\n",
      " |          filled contours, the default is *True*.  For line contours,\n",
      " |          it is taken from :rc:`lines.antialiased`.\n",
      " |      \n",
      " |      hatches : list[str], optional\n",
      " |          A list of cross hatch patterns to use on the filled areas.\n",
      " |          If None, no hatching will be added to the contour.\n",
      " |          Hatching is supported in the PostScript, PDF, SVG and Agg\n",
      " |          backends only.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      `.tricontourf` fills intervals that are closed at the top; that is, for\n",
      " |      boundaries *z1* and *z2*, the filled region is::\n",
      " |      \n",
      " |          z1 < Z <= z2\n",
      " |      \n",
      " |      except for the lowest interval, which is closed on both sides (i.e. it\n",
      " |      includes the lowest value).\n",
      " |  \n",
      " |  tripcolor(ax, *args, alpha=1.0, norm=None, cmap=None, vmin=None, vmax=None, shading='flat', facecolors=None, **kwargs)\n",
      " |      Create a pseudocolor plot of an unstructured triangular grid.\n",
      " |      \n",
      " |      The triangulation can be specified in one of two ways; either::\n",
      " |      \n",
      " |        tripcolor(triangulation, ...)\n",
      " |      \n",
      " |      where triangulation is a `.Triangulation` object, or\n",
      " |      \n",
      " |      ::\n",
      " |      \n",
      " |        tripcolor(x, y, ...)\n",
      " |        tripcolor(x, y, triangles, ...)\n",
      " |        tripcolor(x, y, triangles=triangles, ...)\n",
      " |        tripcolor(x, y, mask=mask, ...)\n",
      " |        tripcolor(x, y, triangles, mask=mask, ...)\n",
      " |      \n",
      " |      in which case a Triangulation object will be created.  See `.Triangulation`\n",
      " |      for a explanation of these possibilities.\n",
      " |      \n",
      " |      The next argument must be *C*, the array of color values, either\n",
      " |      one per point in the triangulation if color values are defined at\n",
      " |      points, or one per triangle in the triangulation if color values\n",
      " |      are defined at triangles. If there are the same number of points\n",
      " |      and triangles in the triangulation it is assumed that color\n",
      " |      values are defined at points; to force the use of color values at\n",
      " |      triangles use the kwarg ``facecolors=C`` instead of just ``C``.\n",
      " |      \n",
      " |      *shading* may be 'flat' (the default) or 'gouraud'. If *shading*\n",
      " |      is 'flat' and C values are defined at points, the color values\n",
      " |      used for each triangle are from the mean C of the triangle's\n",
      " |      three points. If *shading* is 'gouraud' then color values must be\n",
      " |      defined at points.\n",
      " |      \n",
      " |      The remaining kwargs are the same as for `~.Axes.pcolor`.\n",
      " |  \n",
      " |  triplot(ax, *args, **kwargs)\n",
      " |      Draw a unstructured triangular grid as lines and/or markers.\n",
      " |      \n",
      " |      The triangulation to plot can be specified in one of two ways; either::\n",
      " |      \n",
      " |        triplot(triangulation, ...)\n",
      " |      \n",
      " |      where triangulation is a `.Triangulation` object, or\n",
      " |      \n",
      " |      ::\n",
      " |      \n",
      " |        triplot(x, y, ...)\n",
      " |        triplot(x, y, triangles, ...)\n",
      " |        triplot(x, y, triangles=triangles, ...)\n",
      " |        triplot(x, y, mask=mask, ...)\n",
      " |        triplot(x, y, triangles, mask=mask, ...)\n",
      " |      \n",
      " |      in which case a Triangulation object will be created.  See `.Triangulation`\n",
      " |      for a explanation of these possibilities.\n",
      " |      \n",
      " |      The remaining args and kwargs are the same as for `~.Axes.plot`.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      lines : `~matplotlib.lines.Line2D`\n",
      " |          The drawn triangles edges.\n",
      " |      markers : `~matplotlib.lines.Line2D`\n",
      " |          The drawn marker nodes.\n",
      " |  \n",
      " |  violin(self, vpstats, positions=None, vert=True, widths=0.5, showmeans=False, showextrema=True, showmedians=False)\n",
      " |      Drawing function for violin plots.\n",
      " |      \n",
      " |      Draw a violin plot for each column of *vpstats*. Each filled area\n",
      " |      extends to represent the entire data range, with optional lines at the\n",
      " |      mean, the median, the minimum, the maximum, and the quantiles values.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      vpstats : list of dicts\n",
      " |        A list of dictionaries containing stats for each violin plot.\n",
      " |        Required keys are:\n",
      " |      \n",
      " |        - ``coords``: A list of scalars containing the coordinates that\n",
      " |          the violin's kernel density estimate were evaluated at.\n",
      " |      \n",
      " |        - ``vals``: A list of scalars containing the values of the\n",
      " |          kernel density estimate at each of the coordinates given\n",
      " |          in *coords*.\n",
      " |      \n",
      " |        - ``mean``: The mean value for this violin's dataset.\n",
      " |      \n",
      " |        - ``median``: The median value for this violin's dataset.\n",
      " |      \n",
      " |        - ``min``: The minimum value for this violin's dataset.\n",
      " |      \n",
      " |        - ``max``: The maximum value for this violin's dataset.\n",
      " |      \n",
      " |        Optional keys are:\n",
      " |      \n",
      " |        - ``quantiles``: A list of scalars containing the quantile values\n",
      " |          for this violin's dataset.\n",
      " |      \n",
      " |      positions : array-like, default: [1, 2, ..., n]\n",
      " |        The positions of the violins. The ticks and limits are\n",
      " |        automatically set to match the positions.\n",
      " |      \n",
      " |      vert : bool, default: True.\n",
      " |        If true, plots the violins vertically.\n",
      " |        Otherwise, plots the violins horizontally.\n",
      " |      \n",
      " |      widths : array-like, default: 0.5\n",
      " |        Either a scalar or a vector that sets the maximal width of\n",
      " |        each violin. The default is 0.5, which uses about half of the\n",
      " |        available horizontal space.\n",
      " |      \n",
      " |      showmeans : bool, default: False\n",
      " |        If true, will toggle rendering of the means.\n",
      " |      \n",
      " |      showextrema : bool, default: True\n",
      " |        If true, will toggle rendering of the extrema.\n",
      " |      \n",
      " |      showmedians : bool, default: False\n",
      " |        If true, will toggle rendering of the medians.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      dict\n",
      " |        A dictionary mapping each component of the violinplot to a\n",
      " |        list of the corresponding collection instances created. The\n",
      " |        dictionary has the following keys:\n",
      " |      \n",
      " |        - ``bodies``: A list of the `~.collections.PolyCollection`\n",
      " |          instances containing the filled area of each violin.\n",
      " |      \n",
      " |        - ``cmeans``: A `~.collections.LineCollection` instance that marks\n",
      " |          the mean values of each of the violin's distribution.\n",
      " |      \n",
      " |        - ``cmins``: A `~.collections.LineCollection` instance that marks\n",
      " |          the bottom of each violin's distribution.\n",
      " |      \n",
      " |        - ``cmaxes``: A `~.collections.LineCollection` instance that marks\n",
      " |          the top of each violin's distribution.\n",
      " |      \n",
      " |        - ``cbars``: A `~.collections.LineCollection` instance that marks\n",
      " |          the centers of each violin's distribution.\n",
      " |      \n",
      " |        - ``cmedians``: A `~.collections.LineCollection` instance that\n",
      " |          marks the median values of each of the violin's distribution.\n",
      " |      \n",
      " |        - ``cquantiles``: A `~.collections.LineCollection` instance created\n",
      " |          to identify the quantiles values of each of the violin's\n",
      " |          distribution.\n",
      " |  \n",
      " |  violinplot(self, dataset, positions=None, vert=True, widths=0.5, showmeans=False, showextrema=True, showmedians=False, quantiles=None, points=100, bw_method=None, *, data=None)\n",
      " |      Make a violin plot.\n",
      " |      \n",
      " |      Make a violin plot for each column of *dataset* or each vector in\n",
      " |      sequence *dataset*.  Each filled area extends to represent the\n",
      " |      entire data range, with optional lines at the mean, the median,\n",
      " |      the minimum, the maximum, and user-specified quantiles.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      dataset : Array or a sequence of vectors.\n",
      " |        The input data.\n",
      " |      \n",
      " |      positions : array-like, default: [1, 2, ..., n]\n",
      " |        The positions of the violins. The ticks and limits are\n",
      " |        automatically set to match the positions.\n",
      " |      \n",
      " |      vert : bool, default: True.\n",
      " |        If true, creates a vertical violin plot.\n",
      " |        Otherwise, creates a horizontal violin plot.\n",
      " |      \n",
      " |      widths : array-like, default: 0.5\n",
      " |        Either a scalar or a vector that sets the maximal width of\n",
      " |        each violin. The default is 0.5, which uses about half of the\n",
      " |        available horizontal space.\n",
      " |      \n",
      " |      showmeans : bool, default: False\n",
      " |        If `True`, will toggle rendering of the means.\n",
      " |      \n",
      " |      showextrema : bool, default: True\n",
      " |        If `True`, will toggle rendering of the extrema.\n",
      " |      \n",
      " |      showmedians : bool, default: False\n",
      " |        If `True`, will toggle rendering of the medians.\n",
      " |      \n",
      " |      quantiles : array-like, default: None\n",
      " |        If not None, set a list of floats in interval [0, 1] for each violin,\n",
      " |        which stands for the quantiles that will be rendered for that\n",
      " |        violin.\n",
      " |      \n",
      " |      points : int, default: 100\n",
      " |        Defines the number of points to evaluate each of the\n",
      " |        gaussian kernel density estimations at.\n",
      " |      \n",
      " |      bw_method : str, scalar or callable, optional\n",
      " |        The method used to calculate the estimator bandwidth.  This can be\n",
      " |        'scott', 'silverman', a scalar constant or a callable.  If a\n",
      " |        scalar, this will be used directly as `kde.factor`.  If a\n",
      " |        callable, it should take a `GaussianKDE` instance as its only\n",
      " |        parameter and return a scalar. If None (default), 'scott' is used.\n",
      " |      \n",
      " |      data : indexable object, optional\n",
      " |          If given, the following parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception):\n",
      " |      \n",
      " |          *dataset*\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      dict\n",
      " |        A dictionary mapping each component of the violinplot to a\n",
      " |        list of the corresponding collection instances created. The\n",
      " |        dictionary has the following keys:\n",
      " |      \n",
      " |        - ``bodies``: A list of the `~.collections.PolyCollection`\n",
      " |          instances containing the filled area of each violin.\n",
      " |      \n",
      " |        - ``cmeans``: A `~.collections.LineCollection` instance that marks\n",
      " |          the mean values of each of the violin's distribution.\n",
      " |      \n",
      " |        - ``cmins``: A `~.collections.LineCollection` instance that marks\n",
      " |          the bottom of each violin's distribution.\n",
      " |      \n",
      " |        - ``cmaxes``: A `~.collections.LineCollection` instance that marks\n",
      " |          the top of each violin's distribution.\n",
      " |      \n",
      " |        - ``cbars``: A `~.collections.LineCollection` instance that marks\n",
      " |          the centers of each violin's distribution.\n",
      " |      \n",
      " |        - ``cmedians``: A `~.collections.LineCollection` instance that\n",
      " |          marks the median values of each of the violin's distribution.\n",
      " |      \n",
      " |        - ``cquantiles``: A `~.collections.LineCollection` instance created\n",
      " |          to identify the quantile values of each of the violin's\n",
      " |          distribution.\n",
      " |  \n",
      " |  vlines(self, x, ymin, ymax, colors=None, linestyles='solid', label='', *, data=None, **kwargs)\n",
      " |      Plot vertical lines at each *x* from *ymin* to *ymax*.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      x : float or array-like\n",
      " |          x-indexes where to plot the lines.\n",
      " |      \n",
      " |      ymin, ymax : float or array-like\n",
      " |          Respective beginning and end of each line. If scalars are\n",
      " |          provided, all lines will have same length.\n",
      " |      \n",
      " |      colors : list of colors, default: :rc:`lines.color`\n",
      " |      \n",
      " |      linestyles : {'solid', 'dashed', 'dashdot', 'dotted'}, optional\n",
      " |      \n",
      " |      label : str, default: ''\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `~matplotlib.collections.LineCollection`\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      data : indexable object, optional\n",
      " |          If given, the following parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception):\n",
      " |      \n",
      " |          *x*, *ymin*, *ymax*, *colors*\n",
      " |      **kwargs : `~matplotlib.collections.LineCollection` properties.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      hlines : horizontal lines\n",
      " |      axvline : vertical line across the Axes\n",
      " |  \n",
      " |  xcorr(self, x, y, normed=True, detrend=<function detrend_none at 0x7f6f2b6afee0>, usevlines=True, maxlags=10, *, data=None, **kwargs)\n",
      " |      Plot the cross correlation between *x* and *y*.\n",
      " |      \n",
      " |      The correlation with lag k is defined as\n",
      " |      :math:`\\sum_n x[n+k] \\cdot y^*[n]`, where :math:`y^*` is the complex\n",
      " |      conjugate of :math:`y`.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      x, y : array-like of length n\n",
      " |      \n",
      " |      detrend : callable, default: `.mlab.detrend_none` (no detrending)\n",
      " |          A detrending function applied to *x* and *y*.  It must have the\n",
      " |          signature ::\n",
      " |      \n",
      " |              detrend(x: np.ndarray) -> np.ndarray\n",
      " |      \n",
      " |      normed : bool, default: True\n",
      " |          If ``True``, input vectors are normalised to unit length.\n",
      " |      \n",
      " |      usevlines : bool, default: True\n",
      " |          Determines the plot style.\n",
      " |      \n",
      " |          If ``True``, vertical lines are plotted from 0 to the xcorr value\n",
      " |          using `.Axes.vlines`. Additionally, a horizontal line is plotted\n",
      " |          at y=0 using `.Axes.axhline`.\n",
      " |      \n",
      " |          If ``False``, markers are plotted at the xcorr values using\n",
      " |          `.Axes.plot`.\n",
      " |      \n",
      " |      maxlags : int, default: 10\n",
      " |          Number of lags to show. If None, will return all ``2 * len(x) - 1``\n",
      " |          lags.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      lags : array (length ``2*maxlags+1``)\n",
      " |          The lag vector.\n",
      " |      c : array  (length ``2*maxlags+1``)\n",
      " |          The auto correlation vector.\n",
      " |      line : `.LineCollection` or `.Line2D`\n",
      " |          `.Artist` added to the Axes of the correlation:\n",
      " |      \n",
      " |          - `.LineCollection` if *usevlines* is True.\n",
      " |          - `.Line2D` if *usevlines* is False.\n",
      " |      b : `.Line2D` or None\n",
      " |          Horizontal line at 0 if *usevlines* is True\n",
      " |          None *usevlines* is False.\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      linestyle : `.Line2D` property, optional\n",
      " |          The linestyle for plotting the data points.\n",
      " |          Only used if *usevlines* is ``False``.\n",
      " |      \n",
      " |      marker : str, default: 'o'\n",
      " |          The marker for plotting the data points.\n",
      " |          Only used if *usevlines* is ``False``.\n",
      " |      \n",
      " |      data : indexable object, optional\n",
      " |          If given, the following parameters also accept a string ``s``, which is\n",
      " |          interpreted as ``data[s]`` (unless this raises an exception):\n",
      " |      \n",
      " |          *x*, *y*\n",
      " |      \n",
      " |      **kwargs\n",
      " |          Additional parameters are passed to `.Axes.vlines` and\n",
      " |          `.Axes.axhline` if *usevlines* is ``True``; otherwise they are\n",
      " |          passed to `.Axes.plot`.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      The cross correlation is performed with `numpy.correlate` with\n",
      " |      ``mode = \"full\"``.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from matplotlib.axes._base._AxesBase:\n",
      " |  \n",
      " |  __getstate__(self)\n",
      " |  \n",
      " |  __repr__(self)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __setstate__(self, state)\n",
      " |  \n",
      " |  __str__(self)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  add_artist(self, a)\n",
      " |      Add an `.Artist` to the Axes; return the artist.\n",
      " |      \n",
      " |      Use `add_artist` only for artists for which there is no dedicated\n",
      " |      \"add\" method; and if necessary, use a method such as `update_datalim`\n",
      " |      to manually update the dataLim if the artist is to be included in\n",
      " |      autoscaling.\n",
      " |      \n",
      " |      If no ``transform`` has been specified when creating the artist (e.g.\n",
      " |      ``artist.get_transform() == None``) then the transform is set to\n",
      " |      ``ax.transData``.\n",
      " |  \n",
      " |  add_child_axes(self, ax)\n",
      " |      Add an `.AxesBase` to the Axes' children; return the child Axes.\n",
      " |      \n",
      " |      This is the lowlevel version.  See `.axes.Axes.inset_axes`.\n",
      " |  \n",
      " |  add_collection(self, collection, autolim=True)\n",
      " |      Add a `.Collection` to the Axes; return the collection.\n",
      " |  \n",
      " |  add_container(self, container)\n",
      " |      Add a `.Container` to the axes' containers; return the container.\n",
      " |  \n",
      " |  add_image(self, image)\n",
      " |      Add an `.AxesImage` to the Axes; return the image.\n",
      " |  \n",
      " |  add_line(self, line)\n",
      " |      Add a `.Line2D` to the Axes; return the line.\n",
      " |  \n",
      " |  add_patch(self, p)\n",
      " |      Add a `.Patch` to the Axes; return the patch.\n",
      " |  \n",
      " |  add_table(self, tab)\n",
      " |      Add a `.Table` to the Axes; return the table.\n",
      " |  \n",
      " |  apply_aspect(self, position=None)\n",
      " |      Adjust the Axes for a specified data aspect ratio.\n",
      " |      \n",
      " |      Depending on `.get_adjustable` this will modify either the\n",
      " |      Axes box (position) or the view limits. In the former case,\n",
      " |      `~matplotlib.axes.Axes.get_anchor` will affect the position.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      This is called automatically when each Axes is drawn.  You may need\n",
      " |      to call it yourself if you need to update the Axes position and/or\n",
      " |      view limits before the Figure is drawn.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      matplotlib.axes.Axes.set_aspect\n",
      " |          For a description of aspect ratio handling.\n",
      " |      matplotlib.axes.Axes.set_adjustable\n",
      " |          Set how the Axes adjusts to achieve the required aspect ratio.\n",
      " |      matplotlib.axes.Axes.set_anchor\n",
      " |          Set the position in case of extra space.\n",
      " |  \n",
      " |  autoscale(self, enable=True, axis='both', tight=None)\n",
      " |      Autoscale the axis view to the data (toggle).\n",
      " |      \n",
      " |      Convenience method for simple axis view autoscaling.\n",
      " |      It turns autoscaling on or off, and then,\n",
      " |      if autoscaling for either axis is on, it performs\n",
      " |      the autoscaling on the specified axis or Axes.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      enable : bool or None, default: True\n",
      " |          True turns autoscaling on, False turns it off.\n",
      " |          None leaves the autoscaling state unchanged.\n",
      " |      axis : {'both', 'x', 'y'}, default: 'both'\n",
      " |          Which axis to operate on.\n",
      " |      tight : bool or None, default: None\n",
      " |          If True, first set the margins to zero.  Then, this argument is\n",
      " |          forwarded to `autoscale_view` (regardless of its value); see the\n",
      " |          description of its behavior there.\n",
      " |  \n",
      " |  autoscale_view(self, tight=None, scalex=True, scaley=True)\n",
      " |      Autoscale the view limits using the data limits.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      tight : bool or None\n",
      " |          If *True*, only expand the axis limits using the margins.  Note\n",
      " |          that unlike for `autoscale`, ``tight=True`` does *not* set the\n",
      " |          margins to zero.\n",
      " |      \n",
      " |          If *False* and :rc:`axes.autolimit_mode` is 'round_numbers', then\n",
      " |          after expansion by the margins, further expand the axis limits\n",
      " |          using the axis major locator.\n",
      " |      \n",
      " |          If None (the default), reuse the value set in the previous call to\n",
      " |          `autoscale_view` (the initial value is False, but the default style\n",
      " |          sets :rc:`axes.autolimit_mode` to 'data', in which case this\n",
      " |          behaves like True).\n",
      " |      \n",
      " |      scalex : bool, default: True\n",
      " |          Whether to autoscale the x axis.\n",
      " |      \n",
      " |      scaley : bool, default: True\n",
      " |          Whether to autoscale the y axis.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      The autoscaling preserves any preexisting axis direction reversal.\n",
      " |      \n",
      " |      The data limits are not updated automatically when artist data are\n",
      " |      changed after the artist has been added to an Axes instance.  In that\n",
      " |      case, use :meth:`matplotlib.axes.Axes.relim` prior to calling\n",
      " |      autoscale_view.\n",
      " |      \n",
      " |      If the views of the Axes are fixed, e.g. via `set_xlim`, they will\n",
      " |      not be changed by autoscale_view().\n",
      " |      See :meth:`matplotlib.axes.Axes.autoscale` for an alternative.\n",
      " |  \n",
      " |  axis(self, *args, emit=True, **kwargs)\n",
      " |      Convenience method to get or set some axis properties.\n",
      " |      \n",
      " |      Call signatures::\n",
      " |      \n",
      " |        xmin, xmax, ymin, ymax = axis()\n",
      " |        xmin, xmax, ymin, ymax = axis([xmin, xmax, ymin, ymax])\n",
      " |        xmin, xmax, ymin, ymax = axis(option)\n",
      " |        xmin, xmax, ymin, ymax = axis(**kwargs)\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      xmin, xmax, ymin, ymax : float, optional\n",
      " |          The axis limits to be set.  This can also be achieved using ::\n",
      " |      \n",
      " |              ax.set(xlim=(xmin, xmax), ylim=(ymin, ymax))\n",
      " |      \n",
      " |      option : bool or str\n",
      " |          If a bool, turns axis lines and labels on or off. If a string,\n",
      " |          possible values are:\n",
      " |      \n",
      " |          ======== ==========================================================\n",
      " |          Value    Description\n",
      " |          ======== ==========================================================\n",
      " |          'on'     Turn on axis lines and labels. Same as ``True``.\n",
      " |          'off'    Turn off axis lines and labels. Same as ``False``.\n",
      " |          'equal'  Set equal scaling (i.e., make circles circular) by\n",
      " |                   changing axis limits. This is the same as\n",
      " |                   ``ax.set_aspect('equal', adjustable='datalim')``.\n",
      " |                   Explicit data limits may not be respected in this case.\n",
      " |          'scaled' Set equal scaling (i.e., make circles circular) by\n",
      " |                   changing dimensions of the plot box. This is the same as\n",
      " |                   ``ax.set_aspect('equal', adjustable='box', anchor='C')``.\n",
      " |                   Additionally, further autoscaling will be disabled.\n",
      " |          'tight'  Set limits just large enough to show all data, then\n",
      " |                   disable further autoscaling.\n",
      " |          'auto'   Automatic scaling (fill plot box with data).\n",
      " |          'image'  'scaled' with axis limits equal to data limits.\n",
      " |          'square' Square plot; similar to 'scaled', but initially forcing\n",
      " |                   ``xmax-xmin == ymax-ymin``.\n",
      " |          ======== ==========================================================\n",
      " |      \n",
      " |      emit : bool, default: True\n",
      " |          Whether observers are notified of the axis limit change.\n",
      " |          This option is passed on to `~.Axes.set_xlim` and\n",
      " |          `~.Axes.set_ylim`.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      xmin, xmax, ymin, ymax : float\n",
      " |          The axis limits.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      matplotlib.axes.Axes.set_xlim\n",
      " |      matplotlib.axes.Axes.set_ylim\n",
      " |  \n",
      " |  can_pan(self)\n",
      " |      Return whether this Axes supports any pan/zoom button functionality.\n",
      " |  \n",
      " |  can_zoom(self)\n",
      " |      Return whether this Axes supports the zoom box button functionality.\n",
      " |  \n",
      " |  cla(self)\n",
      " |      Clear the Axes.\n",
      " |  \n",
      " |  clear(self)\n",
      " |      Clear the Axes.\n",
      " |  \n",
      " |  contains(self, mouseevent)\n",
      " |      Test whether the artist contains the mouse event.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      mouseevent : `matplotlib.backend_bases.MouseEvent`\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      contains : bool\n",
      " |          Whether any values are within the radius.\n",
      " |      details : dict\n",
      " |          An artist-specific dictionary of details of the event context,\n",
      " |          such as which points are contained in the pick radius. See the\n",
      " |          individual Artist subclasses for details.\n",
      " |  \n",
      " |  contains_point(self, point)\n",
      " |      Return whether *point* (pair of pixel coordinates) is inside the axes\n",
      " |      patch.\n",
      " |  \n",
      " |  drag_pan(self, button, key, x, y)\n",
      " |      Called when the mouse moves during a pan operation.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      button : `.MouseButton`\n",
      " |          The pressed mouse button.\n",
      " |      key : str or None\n",
      " |          The pressed key, if any.\n",
      " |      x, y : float\n",
      " |          The mouse coordinates in display coords.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      This is intended to be overridden by new projection types.\n",
      " |  \n",
      " |  draw(self, renderer)\n",
      " |      Draw the Artist (and its children) using the given renderer.\n",
      " |      \n",
      " |      This has no effect if the artist is not visible (`.Artist.get_visible`\n",
      " |      returns False).\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      renderer : `.RendererBase` subclass.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      This method is overridden in the Artist subclasses.\n",
      " |  \n",
      " |  draw_artist(self, a)\n",
      " |      Efficiently redraw a single artist.\n",
      " |      \n",
      " |      This method can only be used after an initial draw of the figure,\n",
      " |      because that creates and caches the renderer needed here.\n",
      " |  \n",
      " |  end_pan(self)\n",
      " |      Called when a pan operation completes (when the mouse button is up.)\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      This is intended to be overridden by new projection types.\n",
      " |  \n",
      " |  format_coord(self, x, y)\n",
      " |      Return a format string formatting the *x*, *y* coordinates.\n",
      " |  \n",
      " |  format_xdata(self, x)\n",
      " |      Return *x* formatted as an x-value.\n",
      " |      \n",
      " |      This function will use the `.fmt_xdata` attribute if it is not None,\n",
      " |      else will fall back on the xaxis major formatter.\n",
      " |  \n",
      " |  format_ydata(self, y)\n",
      " |      Return *y* formatted as an y-value.\n",
      " |      \n",
      " |      This function will use the `.fmt_ydata` attribute if it is not None,\n",
      " |      else will fall back on the yaxis major formatter.\n",
      " |  \n",
      " |  get_adjustable(self)\n",
      " |      Return whether the Axes will adjust its physical dimension ('box') or\n",
      " |      its data limits ('datalim') to achieve the desired aspect ratio.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      matplotlib.axes.Axes.set_adjustable\n",
      " |          Set how the Axes adjusts to achieve the required aspect ratio.\n",
      " |      matplotlib.axes.Axes.set_aspect\n",
      " |          For a description of aspect handling.\n",
      " |  \n",
      " |  get_anchor(self)\n",
      " |      Get the anchor location.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      matplotlib.axes.Axes.set_anchor\n",
      " |          for a description of the anchor.\n",
      " |      matplotlib.axes.Axes.set_aspect\n",
      " |          for a description of aspect handling.\n",
      " |  \n",
      " |  get_aspect(self)\n",
      " |      Return the aspect ratio of the axes scaling.\n",
      " |      \n",
      " |      This is either \"auto\" or a float giving the ratio of y/x-scale.\n",
      " |  \n",
      " |  get_autoscale_on(self)\n",
      " |      Return True if each axis is autoscaled, False otherwise.\n",
      " |  \n",
      " |  get_autoscalex_on(self)\n",
      " |      Return whether the x-axis is autoscaled.\n",
      " |  \n",
      " |  get_autoscaley_on(self)\n",
      " |      Return whether the y-axis is autoscaled.\n",
      " |  \n",
      " |  get_axes_locator(self)\n",
      " |      Return the axes_locator.\n",
      " |  \n",
      " |  get_axisbelow(self)\n",
      " |      Get whether axis ticks and gridlines are above or below most artists.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      bool or 'line'\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      set_axisbelow\n",
      " |  \n",
      " |  get_box_aspect(self)\n",
      " |      Return the Axes box aspect, i.e. the ratio of height to width.\n",
      " |      \n",
      " |      The box aspect is ``None`` (i.e. chosen depending on the available\n",
      " |      figure space) unless explicitly specified.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      matplotlib.axes.Axes.set_box_aspect\n",
      " |          for a description of box aspect.\n",
      " |      matplotlib.axes.Axes.set_aspect\n",
      " |          for a description of aspect handling.\n",
      " |  \n",
      " |  get_children(self)\n",
      " |      Return a list of the child `.Artist`\\s of this `.Artist`.\n",
      " |  \n",
      " |  get_data_ratio(self)\n",
      " |      Return the aspect ratio of the scaled data.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      This method is intended to be overridden by new projection types.\n",
      " |  \n",
      " |  get_default_bbox_extra_artists(self)\n",
      " |      Return a default list of artists that are used for the bounding box\n",
      " |      calculation.\n",
      " |      \n",
      " |      Artists are excluded either by not being visible or\n",
      " |      ``artist.set_in_layout(False)``.\n",
      " |  \n",
      " |  get_facecolor(self)\n",
      " |      Get the facecolor of the Axes.\n",
      " |  \n",
      " |  get_fc(self)\n",
      " |      Alias for `get_facecolor`.\n",
      " |  \n",
      " |  get_frame_on(self)\n",
      " |      Get whether the Axes rectangle patch is drawn.\n",
      " |  \n",
      " |  get_images(self)\n",
      " |      Return a list of `.AxesImage`\\s contained by the Axes.\n",
      " |  \n",
      " |  get_legend(self)\n",
      " |      Return the `.Legend` instance, or None if no legend is defined.\n",
      " |  \n",
      " |  get_lines(self)\n",
      " |      Return a list of lines contained by the Axes.\n",
      " |  \n",
      " |  get_navigate(self)\n",
      " |      Get whether the Axes responds to navigation commands.\n",
      " |  \n",
      " |  get_navigate_mode(self)\n",
      " |      Get the navigation toolbar button status: 'PAN', 'ZOOM', or None.\n",
      " |  \n",
      " |  get_position(self, original=False)\n",
      " |      Return the position of the Axes within the figure as a `.Bbox`.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      original : bool\n",
      " |          If ``True``, return the original position. Otherwise return the\n",
      " |          active position. For an explanation of the positions see\n",
      " |          `.set_position`.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `.Bbox`\n",
      " |  \n",
      " |  get_rasterization_zorder(self)\n",
      " |      Return the zorder value below which artists will be rasterized.\n",
      " |  \n",
      " |  get_renderer_cache(self)\n",
      " |  \n",
      " |  get_shared_x_axes(self)\n",
      " |      Return a reference to the shared axes Grouper object for x axes.\n",
      " |  \n",
      " |  get_shared_y_axes(self)\n",
      " |      Return a reference to the shared axes Grouper object for y axes.\n",
      " |  \n",
      " |  get_tightbbox(self, renderer, call_axes_locator=True, bbox_extra_artists=None, *, for_layout_only=False)\n",
      " |      Return the tight bounding box of the axes, including axis and their\n",
      " |      decorators (xlabel, title, etc).\n",
      " |      \n",
      " |      Artists that have ``artist.set_in_layout(False)`` are not included\n",
      " |      in the bbox.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      renderer : `.RendererBase` subclass\n",
      " |          renderer that will be used to draw the figures (i.e.\n",
      " |          ``fig.canvas.get_renderer()``)\n",
      " |      \n",
      " |      bbox_extra_artists : list of `.Artist` or ``None``\n",
      " |          List of artists to include in the tight bounding box.  If\n",
      " |          ``None`` (default), then all artist children of the Axes are\n",
      " |          included in the tight bounding box.\n",
      " |      \n",
      " |      call_axes_locator : bool, default: True\n",
      " |          If *call_axes_locator* is ``False``, it does not call the\n",
      " |          ``_axes_locator`` attribute, which is necessary to get the correct\n",
      " |          bounding box. ``call_axes_locator=False`` can be used if the\n",
      " |          caller is only interested in the relative size of the tightbbox\n",
      " |          compared to the Axes bbox.\n",
      " |      \n",
      " |      for_layout_only : default: False\n",
      " |          The bounding box will *not* include the x-extent of the title and\n",
      " |          the xlabel, or the y-extent of the ylabel.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      `.BboxBase`\n",
      " |          Bounding box in figure pixel coordinates.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      matplotlib.axes.Axes.get_window_extent\n",
      " |      matplotlib.axis.Axis.get_tightbbox\n",
      " |      matplotlib.spines.Spine.get_window_extent\n",
      " |  \n",
      " |  get_window_extent(self, *args, **kwargs)\n",
      " |      Return the Axes bounding box in display space; *args* and *kwargs*\n",
      " |      are empty.\n",
      " |      \n",
      " |      This bounding box does not include the spines, ticks, ticklables,\n",
      " |      or other labels.  For a bounding box including these elements use\n",
      " |      `~matplotlib.axes.Axes.get_tightbbox`.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      matplotlib.axes.Axes.get_tightbbox\n",
      " |      matplotlib.axis.Axis.get_tightbbox\n",
      " |      matplotlib.spines.Spine.get_window_extent\n",
      " |  \n",
      " |  get_xaxis(self)\n",
      " |      Return the XAxis instance.\n",
      " |      \n",
      " |      The use of this function is discouraged. You should instead directly\n",
      " |      access the attribute ``ax.xaxis``.\n",
      " |  \n",
      " |  get_xaxis_text1_transform(self, pad_points)\n",
      " |      Returns\n",
      " |      -------\n",
      " |      transform : Transform\n",
      " |          The transform used for drawing x-axis labels, which will add\n",
      " |          *pad_points* of padding (in points) between the axis and the label.\n",
      " |          The x-direction is in data coordinates and the y-direction is in\n",
      " |          axis coordinates\n",
      " |      valign : {'center', 'top', 'bottom', 'baseline', 'center_baseline'}\n",
      " |          The text vertical alignment.\n",
      " |      halign : {'center', 'left', 'right'}\n",
      " |          The text horizontal alignment.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      This transformation is primarily used by the `~matplotlib.axis.Axis`\n",
      " |      class, and is meant to be overridden by new kinds of projections that\n",
      " |      may need to place axis elements in different locations.\n",
      " |  \n",
      " |  get_xaxis_text2_transform(self, pad_points)\n",
      " |      Returns\n",
      " |      -------\n",
      " |      transform : Transform\n",
      " |          The transform used for drawing secondary x-axis labels, which will\n",
      " |          add *pad_points* of padding (in points) between the axis and the\n",
      " |          label.  The x-direction is in data coordinates and the y-direction\n",
      " |          is in axis coordinates\n",
      " |      valign : {'center', 'top', 'bottom', 'baseline', 'center_baseline'}\n",
      " |          The text vertical alignment.\n",
      " |      halign : {'center', 'left', 'right'}\n",
      " |          The text horizontal alignment.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      This transformation is primarily used by the `~matplotlib.axis.Axis`\n",
      " |      class, and is meant to be overridden by new kinds of projections that\n",
      " |      may need to place axis elements in different locations.\n",
      " |  \n",
      " |  get_xaxis_transform(self, which='grid')\n",
      " |      Get the transformation used for drawing x-axis labels, ticks\n",
      " |      and gridlines.  The x-direction is in data coordinates and the\n",
      " |      y-direction is in axis coordinates.\n",
      " |      \n",
      " |      .. note::\n",
      " |      \n",
      " |          This transformation is primarily used by the\n",
      " |          `~matplotlib.axis.Axis` class, and is meant to be\n",
      " |          overridden by new kinds of projections that may need to\n",
      " |          place axis elements in different locations.\n",
      " |  \n",
      " |  get_xbound(self)\n",
      " |      Return the lower and upper x-axis bounds, in increasing order.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      set_xbound\n",
      " |      get_xlim, set_xlim\n",
      " |      invert_xaxis, xaxis_inverted\n",
      " |  \n",
      " |  get_xgridlines(self)\n",
      " |      Return the xaxis' grid lines as a list of `.Line2D`\\s.\n",
      " |  \n",
      " |  get_xlabel(self)\n",
      " |      Get the xlabel text string.\n",
      " |  \n",
      " |  get_xlim(self)\n",
      " |      Return the x-axis view limits.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      left, right : (float, float)\n",
      " |          The current x-axis limits in data coordinates.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      set_xlim\n",
      " |      set_xbound, get_xbound\n",
      " |      invert_xaxis, xaxis_inverted\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      The x-axis may be inverted, in which case the *left* value will\n",
      " |      be greater than the *right* value.\n",
      " |  \n",
      " |  get_xmajorticklabels(self)\n",
      " |      Return the xaxis' major tick labels, as a list of `~.text.Text`.\n",
      " |  \n",
      " |  get_xminorticklabels(self)\n",
      " |      Return the xaxis' minor tick labels, as a list of `~.text.Text`.\n",
      " |  \n",
      " |  get_xscale(self)\n",
      " |      Return the xaxis' scale (as a str).\n",
      " |  \n",
      " |  get_xticklabels(self, minor=False, which=None)\n",
      " |      Get the xaxis' tick labels.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      minor : bool\n",
      " |         Whether to return the minor or the major ticklabels.\n",
      " |      \n",
      " |      which : None, ('minor', 'major', 'both')\n",
      " |         Overrides *minor*.\n",
      " |      \n",
      " |         Selects which ticklabels to return\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      list of `~matplotlib.text.Text`\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      The tick label strings are not populated until a ``draw`` method has\n",
      " |      been called.\n",
      " |      \n",
      " |      See also: `~.pyplot.draw` and `~.FigureCanvasBase.draw`.\n",
      " |  \n",
      " |  get_xticklines(self, minor=False)\n",
      " |      Return the xaxis' tick lines as a list of `.Line2D`\\s.\n",
      " |  \n",
      " |  get_xticks(self, *, minor=False)\n",
      " |      Return the xaxis' tick locations in data coordinates.\n",
      " |  \n",
      " |  get_yaxis(self)\n",
      " |      Return the YAxis instance.\n",
      " |      \n",
      " |      The use of this function is discouraged. You should instead directly\n",
      " |      access the attribute ``ax.yaxis``.\n",
      " |  \n",
      " |  get_yaxis_text1_transform(self, pad_points)\n",
      " |      Returns\n",
      " |      -------\n",
      " |      transform : Transform\n",
      " |          The transform used for drawing y-axis labels, which will add\n",
      " |          *pad_points* of padding (in points) between the axis and the label.\n",
      " |          The x-direction is in axis coordinates and the y-direction is in\n",
      " |          data coordinates\n",
      " |      valign : {'center', 'top', 'bottom', 'baseline', 'center_baseline'}\n",
      " |          The text vertical alignment.\n",
      " |      halign : {'center', 'left', 'right'}\n",
      " |          The text horizontal alignment.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      This transformation is primarily used by the `~matplotlib.axis.Axis`\n",
      " |      class, and is meant to be overridden by new kinds of projections that\n",
      " |      may need to place axis elements in different locations.\n",
      " |  \n",
      " |  get_yaxis_text2_transform(self, pad_points)\n",
      " |      Returns\n",
      " |      -------\n",
      " |      transform : Transform\n",
      " |          The transform used for drawing secondart y-axis labels, which will\n",
      " |          add *pad_points* of padding (in points) between the axis and the\n",
      " |          label.  The x-direction is in axis coordinates and the y-direction\n",
      " |          is in data coordinates\n",
      " |      valign : {'center', 'top', 'bottom', 'baseline', 'center_baseline'}\n",
      " |          The text vertical alignment.\n",
      " |      halign : {'center', 'left', 'right'}\n",
      " |          The text horizontal alignment.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      This transformation is primarily used by the `~matplotlib.axis.Axis`\n",
      " |      class, and is meant to be overridden by new kinds of projections that\n",
      " |      may need to place axis elements in different locations.\n",
      " |  \n",
      " |  get_yaxis_transform(self, which='grid')\n",
      " |      Get the transformation used for drawing y-axis labels, ticks\n",
      " |      and gridlines.  The x-direction is in axis coordinates and the\n",
      " |      y-direction is in data coordinates.\n",
      " |      \n",
      " |      .. note::\n",
      " |      \n",
      " |          This transformation is primarily used by the\n",
      " |          `~matplotlib.axis.Axis` class, and is meant to be\n",
      " |          overridden by new kinds of projections that may need to\n",
      " |          place axis elements in different locations.\n",
      " |  \n",
      " |  get_ybound(self)\n",
      " |      Return the lower and upper y-axis bounds, in increasing order.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      set_ybound\n",
      " |      get_ylim, set_ylim\n",
      " |      invert_yaxis, yaxis_inverted\n",
      " |  \n",
      " |  get_ygridlines(self)\n",
      " |      Return the yaxis' grid lines as a list of `.Line2D`\\s.\n",
      " |  \n",
      " |  get_ylabel(self)\n",
      " |      Get the ylabel text string.\n",
      " |  \n",
      " |  get_ylim(self)\n",
      " |      Return the y-axis view limits.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      bottom, top : (float, float)\n",
      " |          The current y-axis limits in data coordinates.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      set_ylim\n",
      " |      set_ybound, get_ybound\n",
      " |      invert_yaxis, yaxis_inverted\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      The y-axis may be inverted, in which case the *bottom* value\n",
      " |      will be greater than the *top* value.\n",
      " |  \n",
      " |  get_ymajorticklabels(self)\n",
      " |      Return the yaxis' major tick labels, as a list of `~.text.Text`.\n",
      " |  \n",
      " |  get_yminorticklabels(self)\n",
      " |      Return the yaxis' minor tick labels, as a list of `~.text.Text`.\n",
      " |  \n",
      " |  get_yscale(self)\n",
      " |      Return the yaxis' scale (as a str).\n",
      " |  \n",
      " |  get_yticklabels(self, minor=False, which=None)\n",
      " |      Get the yaxis' tick labels.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      minor : bool\n",
      " |         Whether to return the minor or the major ticklabels.\n",
      " |      \n",
      " |      which : None, ('minor', 'major', 'both')\n",
      " |         Overrides *minor*.\n",
      " |      \n",
      " |         Selects which ticklabels to return\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      list of `~matplotlib.text.Text`\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      The tick label strings are not populated until a ``draw`` method has\n",
      " |      been called.\n",
      " |      \n",
      " |      See also: `~.pyplot.draw` and `~.FigureCanvasBase.draw`.\n",
      " |  \n",
      " |  get_yticklines(self, minor=False)\n",
      " |      Return the yaxis' tick lines as a list of `.Line2D`\\s.\n",
      " |  \n",
      " |  get_yticks(self, *, minor=False)\n",
      " |      Return the yaxis' tick locations in data coordinates.\n",
      " |  \n",
      " |  grid(self, visible=None, which='major', axis='both', **kwargs)\n",
      " |      Configure the grid lines.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      visible : bool or None, optional\n",
      " |          Whether to show the grid lines.  If any *kwargs* are supplied, it\n",
      " |          is assumed you want the grid on and *visible* will be set to True.\n",
      " |      \n",
      " |          If *visible* is *None* and there are no *kwargs*, this toggles the\n",
      " |          visibility of the lines.\n",
      " |      \n",
      " |      which : {'major', 'minor', 'both'}, optional\n",
      " |          The grid lines to apply the changes on.\n",
      " |      \n",
      " |      axis : {'both', 'x', 'y'}, optional\n",
      " |          The axis to apply the changes on.\n",
      " |      \n",
      " |      **kwargs : `.Line2D` properties\n",
      " |          Define the line properties of the grid, e.g.::\n",
      " |      \n",
      " |              grid(color='r', linestyle='-', linewidth=2)\n",
      " |      \n",
      " |          Valid keyword arguments are:\n",
      " |      \n",
      " |          Properties:\n",
      " |          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      " |          alpha: scalar or None\n",
      " |          animated: bool\n",
      " |          antialiased or aa: bool\n",
      " |          clip_box: `.Bbox`\n",
      " |          clip_on: bool\n",
      " |          clip_path: Patch or (Path, Transform) or None\n",
      " |          color or c: color\n",
      " |          dash_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          dash_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          dashes: sequence of floats (on/off ink in points) or (None, None)\n",
      " |          data: (2, N) array or two 1D arrays\n",
      " |          drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'\n",
      " |          figure: `.Figure`\n",
      " |          fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}\n",
      " |          gid: str\n",
      " |          in_layout: bool\n",
      " |          label: object\n",
      " |          linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      " |          linewidth or lw: float\n",
      " |          marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`\n",
      " |          markeredgecolor or mec: color\n",
      " |          markeredgewidth or mew: float\n",
      " |          markerfacecolor or mfc: color\n",
      " |          markerfacecoloralt or mfcalt: color\n",
      " |          markersize or ms: float\n",
      " |          markevery: None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]\n",
      " |          path_effects: `.AbstractPathEffect`\n",
      " |          picker: float or callable[[Artist, Event], tuple[bool, dict]]\n",
      " |          pickradius: float\n",
      " |          rasterized: bool\n",
      " |          sketch_params: (scale: float, length: float, randomness: float)\n",
      " |          snap: bool or None\n",
      " |          solid_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      " |          solid_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      " |          transform: unknown\n",
      " |          url: str\n",
      " |          visible: bool\n",
      " |          xdata: 1D array\n",
      " |          ydata: 1D array\n",
      " |          zorder: float\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      The axis is drawn as a unit, so the effective zorder for drawing the\n",
      " |      grid is determined by the zorder of each axis, not by the zorder of the\n",
      " |      `.Line2D` objects comprising the grid.  Therefore, to set grid zorder,\n",
      " |      use `.set_axisbelow` or, for more control, call the\n",
      " |      `~.Artist.set_zorder` method of each axis.\n",
      " |  \n",
      " |  has_data(self)\n",
      " |      Return whether any artists have been added to the Axes.\n",
      " |      \n",
      " |      This should not be used to determine whether the *dataLim*\n",
      " |      need to be updated, and may not actually be useful for\n",
      " |      anything.\n",
      " |  \n",
      " |  in_axes(self, mouseevent)\n",
      " |      Return whether the given event (in display coords) is in the Axes.\n",
      " |  \n",
      " |  invert_xaxis(self)\n",
      " |      Invert the x-axis.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      xaxis_inverted\n",
      " |      get_xlim, set_xlim\n",
      " |      get_xbound, set_xbound\n",
      " |  \n",
      " |  invert_yaxis(self)\n",
      " |      Invert the y-axis.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      yaxis_inverted\n",
      " |      get_ylim, set_ylim\n",
      " |      get_ybound, set_ybound\n",
      " |  \n",
      " |  locator_params(self, axis='both', tight=None, **kwargs)\n",
      " |      Control behavior of major tick locators.\n",
      " |      \n",
      " |      Because the locator is involved in autoscaling, `~.Axes.autoscale_view`\n",
      " |      is called automatically after the parameters are changed.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axis : {'both', 'x', 'y'}, default: 'both'\n",
      " |          The axis on which to operate.\n",
      " |      \n",
      " |      tight : bool or None, optional\n",
      " |          Parameter passed to `~.Axes.autoscale_view`.\n",
      " |          Default is None, for no change.\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      **kwargs\n",
      " |          Remaining keyword arguments are passed to directly to the\n",
      " |          ``set_params()`` method of the locator. Supported keywords depend\n",
      " |          on the type of the locator. See for example\n",
      " |          `~.ticker.MaxNLocator.set_params` for the `.ticker.MaxNLocator`\n",
      " |          used by default for linear axes.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      When plotting small subplots, one might want to reduce the maximum\n",
      " |      number of ticks and use tight bounds, for example::\n",
      " |      \n",
      " |          ax.locator_params(tight=True, nbins=4)\n",
      " |  \n",
      " |  margins(self, *margins, x=None, y=None, tight=True)\n",
      " |      Set or retrieve autoscaling margins.\n",
      " |      \n",
      " |      The padding added to each limit of the Axes is the *margin*\n",
      " |      times the data interval. All input parameters must be floats\n",
      " |      within the range [0, 1]. Passing both positional and keyword\n",
      " |      arguments is invalid and will raise a TypeError. If no\n",
      " |      arguments (positional or otherwise) are provided, the current\n",
      " |      margins will remain in place and simply be returned.\n",
      " |      \n",
      " |      Specifying any margin changes only the autoscaling; for example,\n",
      " |      if *xmargin* is not None, then *xmargin* times the X data\n",
      " |      interval will be added to each end of that interval before\n",
      " |      it is used in autoscaling.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      *margins : float, optional\n",
      " |          If a single positional argument is provided, it specifies\n",
      " |          both margins of the x-axis and y-axis limits. If two\n",
      " |          positional arguments are provided, they will be interpreted\n",
      " |          as *xmargin*, *ymargin*. If setting the margin on a single\n",
      " |          axis is desired, use the keyword arguments described below.\n",
      " |      \n",
      " |      x, y : float, optional\n",
      " |          Specific margin values for the x-axis and y-axis,\n",
      " |          respectively. These cannot be used with positional\n",
      " |          arguments, but can be used individually to alter on e.g.,\n",
      " |          only the y-axis.\n",
      " |      \n",
      " |      tight : bool or None, default: True\n",
      " |          The *tight* parameter is passed to :meth:`autoscale_view`,\n",
      " |          which is executed after a margin is changed; the default\n",
      " |          here is *True*, on the assumption that when margins are\n",
      " |          specified, no additional padding to match tick marks is\n",
      " |          usually desired.  Set *tight* to *None* will preserve\n",
      " |          the previous setting.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      xmargin, ymargin : float\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      If a previously used Axes method such as :meth:`pcolor` has set\n",
      " |      :attr:`use_sticky_edges` to `True`, only the limits not set by\n",
      " |      the \"sticky artists\" will be modified. To force all of the\n",
      " |      margins to be set, set :attr:`use_sticky_edges` to `False`\n",
      " |      before calling :meth:`margins`.\n",
      " |  \n",
      " |  minorticks_off(self)\n",
      " |      Remove minor ticks from the Axes.\n",
      " |  \n",
      " |  minorticks_on(self)\n",
      " |      Display minor ticks on the Axes.\n",
      " |      \n",
      " |      Displaying minor ticks may reduce performance; you may turn them off\n",
      " |      using `minorticks_off()` if drawing speed is a problem.\n",
      " |  \n",
      " |  redraw_in_frame(self)\n",
      " |      Efficiently redraw Axes data, but not axis ticks, labels, etc.\n",
      " |      \n",
      " |      This method can only be used after an initial draw which caches the\n",
      " |      renderer.\n",
      " |  \n",
      " |  relim(self, visible_only=False)\n",
      " |      Recompute the data limits based on current artists.\n",
      " |      \n",
      " |      At present, `.Collection` instances are not supported.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      visible_only : bool, default: False\n",
      " |          Whether to exclude invisible artists.\n",
      " |  \n",
      " |  reset_position(self)\n",
      " |      Reset the active position to the original position.\n",
      " |      \n",
      " |      This resets the a possible position change due to aspect constraints.\n",
      " |      For an explanation of the positions see `.set_position`.\n",
      " |  \n",
      " |  set_adjustable(self, adjustable, share=False)\n",
      " |      Set how the Axes adjusts to achieve the required aspect ratio.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      adjustable : {'box', 'datalim'}\n",
      " |          If 'box', change the physical dimensions of the Axes.\n",
      " |          If 'datalim', change the ``x`` or ``y`` data limits.\n",
      " |      \n",
      " |      share : bool, default: False\n",
      " |          If ``True``, apply the settings to all shared Axes.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      matplotlib.axes.Axes.set_aspect\n",
      " |          For a description of aspect handling.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      Shared Axes (of which twinned Axes are a special case)\n",
      " |      impose restrictions on how aspect ratios can be imposed.\n",
      " |      For twinned Axes, use 'datalim'.  For Axes that share both\n",
      " |      x and y, use 'box'.  Otherwise, either 'datalim' or 'box'\n",
      " |      may be used.  These limitations are partly a requirement\n",
      " |      to avoid over-specification, and partly a result of the\n",
      " |      particular implementation we are currently using, in\n",
      " |      which the adjustments for aspect ratios are done sequentially\n",
      " |      and independently on each Axes as it is drawn.\n",
      " |  \n",
      " |  set_anchor(self, anchor, share=False)\n",
      " |      Define the anchor location.\n",
      " |      \n",
      " |      The actual drawing area (active position) of the Axes may be smaller\n",
      " |      than the Bbox (original position) when a fixed aspect is required. The\n",
      " |      anchor defines where the drawing area will be located within the\n",
      " |      available space.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      anchor : (float, float) or {'C', 'SW', 'S', 'SE', 'E', 'NE', ...}\n",
      " |          Either an (*x*, *y*) pair of relative coordinates (0 is left or\n",
      " |          bottom, 1 is right or top), 'C' (center), or a cardinal direction\n",
      " |          ('SW', southwest, is bottom left, etc.).  str inputs are shorthands\n",
      " |          for (*x*, *y*) coordinates, as shown in the following table::\n",
      " |      \n",
      " |          .. code-block:: none\n",
      " |      \n",
      " |             +-----------------+-----------------+-----------------+\n",
      " |             | 'NW' (0.0, 1.0) | 'N' (0.5, 1.0)  | 'NE' (1.0, 1.0) |\n",
      " |             +-----------------+-----------------+-----------------+\n",
      " |             | 'W'  (0.0, 0.5) | 'C' (0.5, 0.5)  | 'E'  (1.0, 0.5) |\n",
      " |             +-----------------+-----------------+-----------------+\n",
      " |             | 'SW' (0.0, 0.0) | 'S' (0.5, 0.0)  | 'SE' (1.0, 0.0) |\n",
      " |             +-----------------+-----------------+-----------------+\n",
      " |      \n",
      " |      share : bool, default: False\n",
      " |          If ``True``, apply the settings to all shared Axes.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      matplotlib.axes.Axes.set_aspect\n",
      " |          for a description of aspect handling.\n",
      " |  \n",
      " |  set_aspect(self, aspect, adjustable=None, anchor=None, share=False)\n",
      " |      Set the aspect ratio of the axes scaling, i.e. y/x-scale.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      aspect : {'auto', 'equal'} or float\n",
      " |          Possible values:\n",
      " |      \n",
      " |          - 'auto': fill the position rectangle with data.\n",
      " |          - 'equal': same as ``aspect=1``, i.e. same scaling for x and y.\n",
      " |          - *float*: The displayed size of 1 unit in y-data coordinates will\n",
      " |            be *aspect* times the displayed size of 1 unit in x-data\n",
      " |            coordinates; e.g. for ``aspect=2`` a square in data coordinates\n",
      " |            will be rendered with a height of twice its width.\n",
      " |      \n",
      " |      adjustable : None or {'box', 'datalim'}, optional\n",
      " |          If not ``None``, this defines which parameter will be adjusted to\n",
      " |          meet the required aspect. See `.set_adjustable` for further\n",
      " |          details.\n",
      " |      \n",
      " |      anchor : None or str or (float, float), optional\n",
      " |          If not ``None``, this defines where the Axes will be drawn if there\n",
      " |          is extra space due to aspect constraints. The most common way to\n",
      " |          to specify the anchor are abbreviations of cardinal directions:\n",
      " |      \n",
      " |          =====   =====================\n",
      " |          value   description\n",
      " |          =====   =====================\n",
      " |          'C'     centered\n",
      " |          'SW'    lower left corner\n",
      " |          'S'     middle of bottom edge\n",
      " |          'SE'    lower right corner\n",
      " |          etc.\n",
      " |          =====   =====================\n",
      " |      \n",
      " |          See `~.Axes.set_anchor` for further details.\n",
      " |      \n",
      " |      share : bool, default: False\n",
      " |          If ``True``, apply the settings to all shared Axes.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      matplotlib.axes.Axes.set_adjustable\n",
      " |          Set how the Axes adjusts to achieve the required aspect ratio.\n",
      " |      matplotlib.axes.Axes.set_anchor\n",
      " |          Set the position in case of extra space.\n",
      " |  \n",
      " |  set_autoscale_on(self, b)\n",
      " |      Set whether autoscaling is applied to each axis on the next draw or\n",
      " |      call to `.Axes.autoscale_view`.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      b : bool\n",
      " |  \n",
      " |  set_autoscalex_on(self, b)\n",
      " |      Set whether the x-axis is autoscaled on the next draw or call to\n",
      " |      `.Axes.autoscale_view`.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      b : bool\n",
      " |  \n",
      " |  set_autoscaley_on(self, b)\n",
      " |      Set whether the y-axis is autoscaled on the next draw or call to\n",
      " |      `.Axes.autoscale_view`.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      b : bool\n",
      " |  \n",
      " |  set_axes_locator(self, locator)\n",
      " |      Set the Axes locator.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      locator : Callable[[Axes, Renderer], Bbox]\n",
      " |  \n",
      " |  set_axis_off(self)\n",
      " |      Turn the x- and y-axis off.\n",
      " |      \n",
      " |      This affects the axis lines, ticks, ticklabels, grid and axis labels.\n",
      " |  \n",
      " |  set_axis_on(self)\n",
      " |      Turn the x- and y-axis on.\n",
      " |      \n",
      " |      This affects the axis lines, ticks, ticklabels, grid and axis labels.\n",
      " |  \n",
      " |  set_axisbelow(self, b)\n",
      " |      Set whether axis ticks and gridlines are above or below most artists.\n",
      " |      \n",
      " |      This controls the zorder of the ticks and gridlines. For more\n",
      " |      information on the zorder see :doc:`/gallery/misc/zorder_demo`.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      b : bool or 'line'\n",
      " |          Possible values:\n",
      " |      \n",
      " |          - *True* (zorder = 0.5): Ticks and gridlines are below all Artists.\n",
      " |          - 'line' (zorder = 1.5): Ticks and gridlines are above patches\n",
      " |            (e.g. rectangles, with default zorder = 1) but still below lines\n",
      " |            and markers (with their default zorder = 2).\n",
      " |          - *False* (zorder = 2.5): Ticks and gridlines are above patches\n",
      " |            and lines / markers.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      get_axisbelow\n",
      " |  \n",
      " |  set_box_aspect(self, aspect=None)\n",
      " |      Set the Axes box aspect, i.e. the ratio of height to width.\n",
      " |      \n",
      " |      This defines the aspect of the Axes in figure space and is not to be\n",
      " |      confused with the data aspect (see `~.Axes.set_aspect`).\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      aspect : float or None\n",
      " |          Changes the physical dimensions of the Axes, such that the ratio\n",
      " |          of the Axes height to the Axes width in physical units is equal to\n",
      " |          *aspect*. Defining a box aspect will change the *adjustable*\n",
      " |          property to 'datalim' (see `~.Axes.set_adjustable`).\n",
      " |      \n",
      " |          *None* will disable a fixed box aspect so that height and width\n",
      " |          of the Axes are chosen independently.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      matplotlib.axes.Axes.set_aspect\n",
      " |          for a description of aspect handling.\n",
      " |  \n",
      " |  set_facecolor(self, color)\n",
      " |      Set the facecolor of the Axes.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      color : color\n",
      " |  \n",
      " |  set_fc(self, color)\n",
      " |      Alias for `set_facecolor`.\n",
      " |  \n",
      " |  set_figure(self, fig)\n",
      " |      Set the `.Figure` instance the artist belongs to.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      fig : `.Figure`\n",
      " |  \n",
      " |  set_frame_on(self, b)\n",
      " |      Set whether the Axes rectangle patch is drawn.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      b : bool\n",
      " |  \n",
      " |  set_navigate(self, b)\n",
      " |      Set whether the Axes responds to navigation toolbar commands.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      b : bool\n",
      " |  \n",
      " |  set_navigate_mode(self, b)\n",
      " |      Set the navigation toolbar button status.\n",
      " |      \n",
      " |      .. warning ::\n",
      " |          this is not a user-API function.\n",
      " |  \n",
      " |  set_position(self, pos, which='both')\n",
      " |      Set the Axes position.\n",
      " |      \n",
      " |      Axes have two position attributes. The 'original' position is the\n",
      " |      position allocated for the Axes. The 'active' position is the\n",
      " |      position the Axes is actually drawn at. These positions are usually\n",
      " |      the same unless a fixed aspect is set to the Axes. See\n",
      " |      `.Axes.set_aspect` for details.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      pos : [left, bottom, width, height] or `~matplotlib.transforms.Bbox`\n",
      " |          The new position of the in `.Figure` coordinates.\n",
      " |      \n",
      " |      which : {'both', 'active', 'original'}, default: 'both'\n",
      " |          Determines which position variables to change.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      matplotlib.transforms.Bbox.from_bounds\n",
      " |      matplotlib.transforms.Bbox.from_extents\n",
      " |  \n",
      " |  set_prop_cycle(self, *args, **kwargs)\n",
      " |      Set the property cycle of the Axes.\n",
      " |      \n",
      " |      The property cycle controls the style properties such as color,\n",
      " |      marker and linestyle of future plot commands. The style properties\n",
      " |      of data already added to the Axes are not modified.\n",
      " |      \n",
      " |      Call signatures::\n",
      " |      \n",
      " |        set_prop_cycle(cycler)\n",
      " |        set_prop_cycle(label=values[, label2=values2[, ...]])\n",
      " |        set_prop_cycle(label, values)\n",
      " |      \n",
      " |      Form 1 sets given `~cycler.Cycler` object.\n",
      " |      \n",
      " |      Form 2 creates a `~cycler.Cycler` which cycles over one or more\n",
      " |      properties simultaneously and set it as the property cycle of the\n",
      " |      Axes. If multiple properties are given, their value lists must have\n",
      " |      the same length. This is just a shortcut for explicitly creating a\n",
      " |      cycler and passing it to the function, i.e. it's short for\n",
      " |      ``set_prop_cycle(cycler(label=values label2=values2, ...))``.\n",
      " |      \n",
      " |      Form 3 creates a `~cycler.Cycler` for a single property and set it\n",
      " |      as the property cycle of the Axes. This form exists for compatibility\n",
      " |      with the original `cycler.cycler` interface. Its use is discouraged\n",
      " |      in favor of the kwarg form, i.e. ``set_prop_cycle(label=values)``.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      cycler : Cycler\n",
      " |          Set the given Cycler. *None* resets to the cycle defined by the\n",
      " |          current style.\n",
      " |      \n",
      " |      label : str\n",
      " |          The property key. Must be a valid `.Artist` property.\n",
      " |          For example, 'color' or 'linestyle'. Aliases are allowed,\n",
      " |          such as 'c' for 'color' and 'lw' for 'linewidth'.\n",
      " |      \n",
      " |      values : iterable\n",
      " |          Finite-length iterable of the property values. These values\n",
      " |          are validated and will raise a ValueError if invalid.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      matplotlib.rcsetup.cycler\n",
      " |          Convenience function for creating validated cyclers for properties.\n",
      " |      cycler.cycler\n",
      " |          The original function for creating unvalidated cyclers.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      Setting the property cycle for a single property:\n",
      " |      \n",
      " |      >>> ax.set_prop_cycle(color=['red', 'green', 'blue'])\n",
      " |      \n",
      " |      Setting the property cycle for simultaneously cycling over multiple\n",
      " |      properties (e.g. red circle, green plus, blue cross):\n",
      " |      \n",
      " |      >>> ax.set_prop_cycle(color=['red', 'green', 'blue'],\n",
      " |      ...                   marker=['o', '+', 'x'])\n",
      " |  \n",
      " |  set_rasterization_zorder(self, z)\n",
      " |      Set the zorder threshold for rasterization for vector graphics output.\n",
      " |      \n",
      " |      All artists with a zorder below the given value will be rasterized if\n",
      " |      they support rasterization.\n",
      " |      \n",
      " |      This setting is ignored for pixel-based output.\n",
      " |      \n",
      " |      See also :doc:`/gallery/misc/rasterization_demo`.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      z : float or None\n",
      " |          The zorder below which artists are rasterized.\n",
      " |          If ``None`` rasterization based on zorder is deactivated.\n",
      " |  \n",
      " |  set_xbound(self, lower=None, upper=None)\n",
      " |      Set the lower and upper numerical bounds of the x-axis.\n",
      " |      \n",
      " |      This method will honor axis inversion regardless of parameter order.\n",
      " |      It will not change the autoscaling setting (`.get_autoscalex_on()`).\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      lower, upper : float or None\n",
      " |          The lower and upper bounds. If *None*, the respective axis bound\n",
      " |          is not modified.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      get_xbound\n",
      " |      get_xlim, set_xlim\n",
      " |      invert_xaxis, xaxis_inverted\n",
      " |  \n",
      " |  set_xlabel(self, xlabel, fontdict=None, labelpad=None, *, loc=None, **kwargs)\n",
      " |      Set the label for the x-axis.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      xlabel : str\n",
      " |          The label text.\n",
      " |      \n",
      " |      labelpad : float, default: :rc:`axes.labelpad`\n",
      " |          Spacing in points from the Axes bounding box including ticks\n",
      " |          and tick labels.  If None, the previous value is left as is.\n",
      " |      \n",
      " |      loc : {'left', 'center', 'right'}, default: :rc:`xaxis.labellocation`\n",
      " |          The label position. This is a high-level alternative for passing\n",
      " |          parameters *x* and *horizontalalignment*.\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      **kwargs : `.Text` properties\n",
      " |          `.Text` properties control the appearance of the label.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      text : Documents the properties supported by `.Text`.\n",
      " |  \n",
      " |  set_xlim(self, left=None, right=None, emit=True, auto=False, *, xmin=None, xmax=None)\n",
      " |      Set the x-axis view limits.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      left : float, optional\n",
      " |          The left xlim in data coordinates. Passing *None* leaves the\n",
      " |          limit unchanged.\n",
      " |      \n",
      " |          The left and right xlims may also be passed as the tuple\n",
      " |          (*left*, *right*) as the first positional argument (or as\n",
      " |          the *left* keyword argument).\n",
      " |      \n",
      " |          .. ACCEPTS: (bottom: float, top: float)\n",
      " |      \n",
      " |      right : float, optional\n",
      " |          The right xlim in data coordinates. Passing *None* leaves the\n",
      " |          limit unchanged.\n",
      " |      \n",
      " |      emit : bool, default: True\n",
      " |          Whether to notify observers of limit change.\n",
      " |      \n",
      " |      auto : bool or None, default: False\n",
      " |          Whether to turn on autoscaling of the x-axis. True turns on,\n",
      " |          False turns off, None leaves unchanged.\n",
      " |      \n",
      " |      xmin, xmax : float, optional\n",
      " |          They are equivalent to left and right respectively,\n",
      " |          and it is an error to pass both *xmin* and *left* or\n",
      " |          *xmax* and *right*.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      left, right : (float, float)\n",
      " |          The new x-axis limits in data coordinates.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      get_xlim\n",
      " |      set_xbound, get_xbound\n",
      " |      invert_xaxis, xaxis_inverted\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      The *left* value may be greater than the *right* value, in which\n",
      " |      case the x-axis values will decrease from left to right.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> set_xlim(left, right)\n",
      " |      >>> set_xlim((left, right))\n",
      " |      >>> left, right = set_xlim(left, right)\n",
      " |      \n",
      " |      One limit may be left unchanged.\n",
      " |      \n",
      " |      >>> set_xlim(right=right_lim)\n",
      " |      \n",
      " |      Limits may be passed in reverse order to flip the direction of\n",
      " |      the x-axis. For example, suppose *x* represents the number of\n",
      " |      years before present. The x-axis limits might be set like the\n",
      " |      following so 5000 years ago is on the left of the plot and the\n",
      " |      present is on the right.\n",
      " |      \n",
      " |      >>> set_xlim(5000, 0)\n",
      " |  \n",
      " |  set_xmargin(self, m)\n",
      " |      Set padding of X data limits prior to autoscaling.\n",
      " |      \n",
      " |      *m* times the data interval will be added to each\n",
      " |      end of that interval before it is used in autoscaling.\n",
      " |      For example, if your data is in the range [0, 2], a factor of\n",
      " |      ``m = 0.1`` will result in a range [-0.2, 2.2].\n",
      " |      \n",
      " |      Negative values -0.5 < m < 0 will result in clipping of the data range.\n",
      " |      I.e. for a data range [0, 2], a factor of ``m = -0.1`` will result in\n",
      " |      a range [0.2, 1.8].\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      m : float greater than -0.5\n",
      " |  \n",
      " |  set_xscale(self, value, **kwargs)\n",
      " |      Set the x-axis scale.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      value : {\"linear\", \"log\", \"symlog\", \"logit\", ...} or `.ScaleBase`\n",
      " |          The axis scale type to apply.\n",
      " |      \n",
      " |      **kwargs\n",
      " |          Different keyword arguments are accepted, depending on the scale.\n",
      " |          See the respective class keyword arguments:\n",
      " |      \n",
      " |          - `matplotlib.scale.LinearScale`\n",
      " |          - `matplotlib.scale.LogScale`\n",
      " |          - `matplotlib.scale.SymmetricalLogScale`\n",
      " |          - `matplotlib.scale.LogitScale`\n",
      " |          - `matplotlib.scale.FuncScale`\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      By default, Matplotlib supports the above mentioned scales.\n",
      " |      Additionally, custom scales may be registered using\n",
      " |      `matplotlib.scale.register_scale`. These scales can then also\n",
      " |      be used here.\n",
      " |  \n",
      " |  set_xticklabels(self, labels, *, fontdict=None, minor=False, **kwargs)\n",
      " |      Set the xaxis' labels with list of string labels.\n",
      " |      \n",
      " |      .. warning::\n",
      " |          This method should only be used after fixing the tick positions\n",
      " |          using `.Axes.set_xticks`. Otherwise, the labels may end up in\n",
      " |          unexpected positions.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      labels : list of str\n",
      " |          The label texts.\n",
      " |      \n",
      " |      fontdict : dict, optional\n",
      " |          A dictionary controlling the appearance of the ticklabels.\n",
      " |          The default *fontdict* is::\n",
      " |      \n",
      " |             {'fontsize': rcParams['axes.titlesize'],\n",
      " |              'fontweight': rcParams['axes.titleweight'],\n",
      " |              'verticalalignment': 'baseline',\n",
      " |              'horizontalalignment': loc}\n",
      " |      \n",
      " |      minor : bool, default: False\n",
      " |          Whether to set the minor ticklabels rather than the major ones.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      list of `.Text`\n",
      " |          The labels.\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      **kwargs : `~.text.Text` properties.\n",
      " |  \n",
      " |  set_xticks(self, ticks, labels=None, *, minor=False, **kwargs)\n",
      " |      Set the xaxis' tick locations and optionally labels.\n",
      " |      \n",
      " |      If necessary, the view limits of the Axis are expanded so that all\n",
      " |      given ticks are visible.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      ticks : list of floats\n",
      " |          List of tick locations.\n",
      " |      labels : list of str, optional\n",
      " |          List of tick labels. If not set, the labels show the data value.\n",
      " |      minor : bool, default: False\n",
      " |          If ``False``, set the major ticks; if ``True``, the minor ticks.\n",
      " |      **kwargs\n",
      " |          `.Text` properties for the labels. These take effect only if you\n",
      " |          pass *labels*. In other cases, please use `~.Axes.tick_params`.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      The mandatory expansion of the view limits is an intentional design\n",
      " |      choice to prevent the surprise of a non-visible tick. If you need\n",
      " |      other limits, you should set the limits explicitly after setting the\n",
      " |      ticks.\n",
      " |  \n",
      " |  set_ybound(self, lower=None, upper=None)\n",
      " |      Set the lower and upper numerical bounds of the y-axis.\n",
      " |      \n",
      " |      This method will honor axis inversion regardless of parameter order.\n",
      " |      It will not change the autoscaling setting (`.get_autoscaley_on()`).\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      lower, upper : float or None\n",
      " |          The lower and upper bounds. If *None*, the respective axis bound\n",
      " |          is not modified.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      get_ybound\n",
      " |      get_ylim, set_ylim\n",
      " |      invert_yaxis, yaxis_inverted\n",
      " |  \n",
      " |  set_ylabel(self, ylabel, fontdict=None, labelpad=None, *, loc=None, **kwargs)\n",
      " |      Set the label for the y-axis.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      ylabel : str\n",
      " |          The label text.\n",
      " |      \n",
      " |      labelpad : float, default: :rc:`axes.labelpad`\n",
      " |          Spacing in points from the Axes bounding box including ticks\n",
      " |          and tick labels.  If None, the previous value is left as is.\n",
      " |      \n",
      " |      loc : {'bottom', 'center', 'top'}, default: :rc:`yaxis.labellocation`\n",
      " |          The label position. This is a high-level alternative for passing\n",
      " |          parameters *y* and *horizontalalignment*.\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      **kwargs : `.Text` properties\n",
      " |          `.Text` properties control the appearance of the label.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      text : Documents the properties supported by `.Text`.\n",
      " |  \n",
      " |  set_ylim(self, bottom=None, top=None, emit=True, auto=False, *, ymin=None, ymax=None)\n",
      " |      Set the y-axis view limits.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      bottom : float, optional\n",
      " |          The bottom ylim in data coordinates. Passing *None* leaves the\n",
      " |          limit unchanged.\n",
      " |      \n",
      " |          The bottom and top ylims may also be passed as the tuple\n",
      " |          (*bottom*, *top*) as the first positional argument (or as\n",
      " |          the *bottom* keyword argument).\n",
      " |      \n",
      " |          .. ACCEPTS: (bottom: float, top: float)\n",
      " |      \n",
      " |      top : float, optional\n",
      " |          The top ylim in data coordinates. Passing *None* leaves the\n",
      " |          limit unchanged.\n",
      " |      \n",
      " |      emit : bool, default: True\n",
      " |          Whether to notify observers of limit change.\n",
      " |      \n",
      " |      auto : bool or None, default: False\n",
      " |          Whether to turn on autoscaling of the y-axis. *True* turns on,\n",
      " |          *False* turns off, *None* leaves unchanged.\n",
      " |      \n",
      " |      ymin, ymax : float, optional\n",
      " |          They are equivalent to bottom and top respectively,\n",
      " |          and it is an error to pass both *ymin* and *bottom* or\n",
      " |          *ymax* and *top*.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      bottom, top : (float, float)\n",
      " |          The new y-axis limits in data coordinates.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      get_ylim\n",
      " |      set_ybound, get_ybound\n",
      " |      invert_yaxis, yaxis_inverted\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      The *bottom* value may be greater than the *top* value, in which\n",
      " |      case the y-axis values will decrease from *bottom* to *top*.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> set_ylim(bottom, top)\n",
      " |      >>> set_ylim((bottom, top))\n",
      " |      >>> bottom, top = set_ylim(bottom, top)\n",
      " |      \n",
      " |      One limit may be left unchanged.\n",
      " |      \n",
      " |      >>> set_ylim(top=top_lim)\n",
      " |      \n",
      " |      Limits may be passed in reverse order to flip the direction of\n",
      " |      the y-axis. For example, suppose ``y`` represents depth of the\n",
      " |      ocean in m. The y-axis limits might be set like the following\n",
      " |      so 5000 m depth is at the bottom of the plot and the surface,\n",
      " |      0 m, is at the top.\n",
      " |      \n",
      " |      >>> set_ylim(5000, 0)\n",
      " |  \n",
      " |  set_ymargin(self, m)\n",
      " |      Set padding of Y data limits prior to autoscaling.\n",
      " |      \n",
      " |      *m* times the data interval will be added to each\n",
      " |      end of that interval before it is used in autoscaling.\n",
      " |      For example, if your data is in the range [0, 2], a factor of\n",
      " |      ``m = 0.1`` will result in a range [-0.2, 2.2].\n",
      " |      \n",
      " |      Negative values -0.5 < m < 0 will result in clipping of the data range.\n",
      " |      I.e. for a data range [0, 2], a factor of ``m = -0.1`` will result in\n",
      " |      a range [0.2, 1.8].\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      m : float greater than -0.5\n",
      " |  \n",
      " |  set_yscale(self, value, **kwargs)\n",
      " |      Set the y-axis scale.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      value : {\"linear\", \"log\", \"symlog\", \"logit\", ...} or `.ScaleBase`\n",
      " |          The axis scale type to apply.\n",
      " |      \n",
      " |      **kwargs\n",
      " |          Different keyword arguments are accepted, depending on the scale.\n",
      " |          See the respective class keyword arguments:\n",
      " |      \n",
      " |          - `matplotlib.scale.LinearScale`\n",
      " |          - `matplotlib.scale.LogScale`\n",
      " |          - `matplotlib.scale.SymmetricalLogScale`\n",
      " |          - `matplotlib.scale.LogitScale`\n",
      " |          - `matplotlib.scale.FuncScale`\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      By default, Matplotlib supports the above mentioned scales.\n",
      " |      Additionally, custom scales may be registered using\n",
      " |      `matplotlib.scale.register_scale`. These scales can then also\n",
      " |      be used here.\n",
      " |  \n",
      " |  set_yticklabels(self, labels, *, fontdict=None, minor=False, **kwargs)\n",
      " |      Set the yaxis' labels with list of string labels.\n",
      " |      \n",
      " |      .. warning::\n",
      " |          This method should only be used after fixing the tick positions\n",
      " |          using `.Axes.set_yticks`. Otherwise, the labels may end up in\n",
      " |          unexpected positions.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      labels : list of str\n",
      " |          The label texts.\n",
      " |      \n",
      " |      fontdict : dict, optional\n",
      " |          A dictionary controlling the appearance of the ticklabels.\n",
      " |          The default *fontdict* is::\n",
      " |      \n",
      " |             {'fontsize': rcParams['axes.titlesize'],\n",
      " |              'fontweight': rcParams['axes.titleweight'],\n",
      " |              'verticalalignment': 'baseline',\n",
      " |              'horizontalalignment': loc}\n",
      " |      \n",
      " |      minor : bool, default: False\n",
      " |          Whether to set the minor ticklabels rather than the major ones.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      list of `.Text`\n",
      " |          The labels.\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      **kwargs : `~.text.Text` properties.\n",
      " |  \n",
      " |  set_yticks(self, ticks, labels=None, *, minor=False, **kwargs)\n",
      " |      Set the yaxis' tick locations and optionally labels.\n",
      " |      \n",
      " |      If necessary, the view limits of the Axis are expanded so that all\n",
      " |      given ticks are visible.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      ticks : list of floats\n",
      " |          List of tick locations.\n",
      " |      labels : list of str, optional\n",
      " |          List of tick labels. If not set, the labels show the data value.\n",
      " |      minor : bool, default: False\n",
      " |          If ``False``, set the major ticks; if ``True``, the minor ticks.\n",
      " |      **kwargs\n",
      " |          `.Text` properties for the labels. These take effect only if you\n",
      " |          pass *labels*. In other cases, please use `~.Axes.tick_params`.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      The mandatory expansion of the view limits is an intentional design\n",
      " |      choice to prevent the surprise of a non-visible tick. If you need\n",
      " |      other limits, you should set the limits explicitly after setting the\n",
      " |      ticks.\n",
      " |  \n",
      " |  sharex(self, other)\n",
      " |      Share the x-axis with *other*.\n",
      " |      \n",
      " |      This is equivalent to passing ``sharex=other`` when constructing the\n",
      " |      axes, and cannot be used if the x-axis is already being shared with\n",
      " |      another Axes.\n",
      " |  \n",
      " |  sharey(self, other)\n",
      " |      Share the y-axis with *other*.\n",
      " |      \n",
      " |      This is equivalent to passing ``sharey=other`` when constructing the\n",
      " |      axes, and cannot be used if the y-axis is already being shared with\n",
      " |      another Axes.\n",
      " |  \n",
      " |  start_pan(self, x, y, button)\n",
      " |      Called when a pan operation has started.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      x, y : float\n",
      " |          The mouse coordinates in display coords.\n",
      " |      button : `.MouseButton`\n",
      " |          The pressed mouse button.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      This is intended to be overridden by new projection types.\n",
      " |  \n",
      " |  tick_params(self, axis='both', **kwargs)\n",
      " |      Change the appearance of ticks, tick labels, and gridlines.\n",
      " |      \n",
      " |      Tick properties that are not explicitly set using the keyword\n",
      " |      arguments remain unchanged unless *reset* is True.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axis : {'x', 'y', 'both'}, default: 'both'\n",
      " |          The axis to which the parameters are applied.\n",
      " |      which : {'major', 'minor', 'both'}, default: 'major'\n",
      " |          The group of ticks to which the parameters are applied.\n",
      " |      reset : bool, default: False\n",
      " |          Whether to reset the ticks to defaults before updating them.\n",
      " |      \n",
      " |      Other Parameters\n",
      " |      ----------------\n",
      " |      direction : {'in', 'out', 'inout'}\n",
      " |          Puts ticks inside the axes, outside the axes, or both.\n",
      " |      length : float\n",
      " |          Tick length in points.\n",
      " |      width : float\n",
      " |          Tick width in points.\n",
      " |      color : color\n",
      " |          Tick color.\n",
      " |      pad : float\n",
      " |          Distance in points between tick and label.\n",
      " |      labelsize : float or str\n",
      " |          Tick label font size in points or as a string (e.g., 'large').\n",
      " |      labelcolor : color\n",
      " |          Tick label color.\n",
      " |      colors : color\n",
      " |          Tick color and label color.\n",
      " |      zorder : float\n",
      " |          Tick and label zorder.\n",
      " |      bottom, top, left, right : bool\n",
      " |          Whether to draw the respective ticks.\n",
      " |      labelbottom, labeltop, labelleft, labelright : bool\n",
      " |          Whether to draw the respective tick labels.\n",
      " |      labelrotation : float\n",
      " |          Tick label rotation\n",
      " |      grid_color : color\n",
      " |          Gridline color.\n",
      " |      grid_alpha : float\n",
      " |          Transparency of gridlines: 0 (transparent) to 1 (opaque).\n",
      " |      grid_linewidth : float\n",
      " |          Width of gridlines in points.\n",
      " |      grid_linestyle : str\n",
      " |          Any valid `.Line2D` line style spec.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      ::\n",
      " |      \n",
      " |          ax.tick_params(direction='out', length=6, width=2, colors='r',\n",
      " |                         grid_color='r', grid_alpha=0.5)\n",
      " |      \n",
      " |      This will make all major ticks be red, pointing out of the box,\n",
      " |      and with dimensions 6 points by 2 points.  Tick labels will\n",
      " |      also be red.  Gridlines will be red and translucent.\n",
      " |  \n",
      " |  ticklabel_format(self, *, axis='both', style='', scilimits=None, useOffset=None, useLocale=None, useMathText=None)\n",
      " |      Configure the `.ScalarFormatter` used by default for linear axes.\n",
      " |      \n",
      " |      If a parameter is not set, the corresponding property of the formatter\n",
      " |      is left unchanged.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axis : {'x', 'y', 'both'}, default: 'both'\n",
      " |          The axis to configure.  Only major ticks are affected.\n",
      " |      \n",
      " |      style : {'sci', 'scientific', 'plain'}\n",
      " |          Whether to use scientific notation.\n",
      " |          The formatter default is to use scientific notation.\n",
      " |      \n",
      " |      scilimits : pair of ints (m, n)\n",
      " |          Scientific notation is used only for numbers outside the range\n",
      " |          10\\ :sup:`m` to 10\\ :sup:`n` (and only if the formatter is\n",
      " |          configured to use scientific notation at all).  Use (0, 0) to\n",
      " |          include all numbers.  Use (m, m) where m != 0 to fix the order of\n",
      " |          magnitude to 10\\ :sup:`m`.\n",
      " |          The formatter default is :rc:`axes.formatter.limits`.\n",
      " |      \n",
      " |      useOffset : bool or float\n",
      " |          If True, the offset is calculated as needed.\n",
      " |          If False, no offset is used.\n",
      " |          If a numeric value, it sets the offset.\n",
      " |          The formatter default is :rc:`axes.formatter.useoffset`.\n",
      " |      \n",
      " |      useLocale : bool\n",
      " |          Whether to format the number using the current locale or using the\n",
      " |          C (English) locale.  This affects e.g. the decimal separator.  The\n",
      " |          formatter default is :rc:`axes.formatter.use_locale`.\n",
      " |      \n",
      " |      useMathText : bool\n",
      " |          Render the offset and scientific notation in mathtext.\n",
      " |          The formatter default is :rc:`axes.formatter.use_mathtext`.\n",
      " |      \n",
      " |      Raises\n",
      " |      ------\n",
      " |      AttributeError\n",
      " |          If the current formatter is not a `.ScalarFormatter`.\n",
      " |  \n",
      " |  twinx(self)\n",
      " |      Create a twin Axes sharing the xaxis.\n",
      " |      \n",
      " |      Create a new Axes with an invisible x-axis and an independent\n",
      " |      y-axis positioned opposite to the original one (i.e. at right). The\n",
      " |      x-axis autoscale setting will be inherited from the original\n",
      " |      Axes.  To ensure that the tick marks of both y-axes align, see\n",
      " |      `~matplotlib.ticker.LinearLocator`.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Axes\n",
      " |          The newly created Axes instance\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      For those who are 'picking' artists while using twinx, pick\n",
      " |      events are only called for the artists in the top-most Axes.\n",
      " |  \n",
      " |  twiny(self)\n",
      " |      Create a twin Axes sharing the yaxis.\n",
      " |      \n",
      " |      Create a new Axes with an invisible y-axis and an independent\n",
      " |      x-axis positioned opposite to the original one (i.e. at top). The\n",
      " |      y-axis autoscale setting will be inherited from the original Axes.\n",
      " |      To ensure that the tick marks of both x-axes align, see\n",
      " |      `~matplotlib.ticker.LinearLocator`.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Axes\n",
      " |          The newly created Axes instance\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      For those who are 'picking' artists while using twiny, pick\n",
      " |      events are only called for the artists in the top-most Axes.\n",
      " |  \n",
      " |  update_datalim(self, xys, updatex=True, updatey=True)\n",
      " |      Extend the `~.Axes.dataLim` Bbox to include the given points.\n",
      " |      \n",
      " |      If no data is set currently, the Bbox will ignore its limits and set\n",
      " |      the bound to be the bounds of the xydata (*xys*). Otherwise, it will\n",
      " |      compute the bounds of the union of its current data and the data in\n",
      " |      *xys*.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      xys : 2D array-like\n",
      " |          The points to include in the data limits Bbox. This can be either\n",
      " |          a list of (x, y) tuples or a Nx2 array.\n",
      " |      \n",
      " |      updatex, updatey : bool, default: True\n",
      " |          Whether to update the x/y limits.\n",
      " |  \n",
      " |  xaxis_date(self, tz=None)\n",
      " |      Set up axis ticks and labels to treat data along the xaxis as dates.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      tz : str or `datetime.tzinfo`, default: :rc:`timezone`\n",
      " |          The timezone used to create date labels.\n",
      " |  \n",
      " |  xaxis_inverted(self)\n",
      " |      Return whether the xaxis is oriented in the \"inverse\" direction.\n",
      " |      \n",
      " |      The \"normal\" direction is increasing to the right for the x-axis and to\n",
      " |      the top for the y-axis; the \"inverse\" direction is increasing to the\n",
      " |      left for the x-axis and to the bottom for the y-axis.\n",
      " |  \n",
      " |  yaxis_date(self, tz=None)\n",
      " |      Set up axis ticks and labels to treat data along the yaxis as dates.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      tz : str or `datetime.tzinfo`, default: :rc:`timezone`\n",
      " |          The timezone used to create date labels.\n",
      " |  \n",
      " |  yaxis_inverted(self)\n",
      " |      Return whether the yaxis is oriented in the \"inverse\" direction.\n",
      " |      \n",
      " |      The \"normal\" direction is increasing to the right for the x-axis and to\n",
      " |      the top for the y-axis; the \"inverse\" direction is increasing to the\n",
      " |      left for the x-axis and to the bottom for the y-axis.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from matplotlib.axes._base._AxesBase:\n",
      " |  \n",
      " |  artists\n",
      " |  \n",
      " |  collections\n",
      " |  \n",
      " |  images\n",
      " |  \n",
      " |  lines\n",
      " |  \n",
      " |  patches\n",
      " |  \n",
      " |  tables\n",
      " |  \n",
      " |  texts\n",
      " |  \n",
      " |  viewLim\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from matplotlib.axes._base._AxesBase:\n",
      " |  \n",
      " |  use_sticky_edges\n",
      " |      When autoscaling, whether to obey all `Artist.sticky_edges`.\n",
      " |      \n",
      " |      Default is ``True``.\n",
      " |      \n",
      " |      Setting this to ``False`` ensures that the specified margins\n",
      " |      will be applied, even if the plot includes an image, for\n",
      " |      example, which would otherwise force a view limit to coincide\n",
      " |      with its data limit.\n",
      " |      \n",
      " |      The changing this property does not change the plot until\n",
      " |      `autoscale` or `autoscale_view` is called.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from matplotlib.axes._base._AxesBase:\n",
      " |  \n",
      " |  ArtistList = <class 'matplotlib.axes._base._AxesBase.ArtistList'>\n",
      " |      A sublist of Axes children based on their type.\n",
      " |      \n",
      " |      The type-specific children sublists will become immutable in\n",
      " |      Matplotlib 3.7. Then, these artist lists will likely be replaced by\n",
      " |      tuples. Use as if this is a tuple already.\n",
      " |      \n",
      " |      This class exists only for the transition period to warn on the\n",
      " |      deprecated modifcation of artist lists.\n",
      " |  \n",
      " |  \n",
      " |  name = 'rectilinear'\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from matplotlib.artist.Artist:\n",
      " |  \n",
      " |  add_callback(self, func)\n",
      " |      Add a callback function that will be called whenever one of the\n",
      " |      `.Artist`'s properties changes.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      func : callable\n",
      " |          The callback function. It must have the signature::\n",
      " |      \n",
      " |              def func(artist: Artist) -> Any\n",
      " |      \n",
      " |          where *artist* is the calling `.Artist`. Return values may exist\n",
      " |          but are ignored.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      int\n",
      " |          The observer id associated with the callback. This id can be\n",
      " |          used for removing the callback with `.remove_callback` later.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      remove_callback\n",
      " |  \n",
      " |  convert_xunits(self, x)\n",
      " |      Convert *x* using the unit type of the xaxis.\n",
      " |      \n",
      " |      If the artist is not in contained in an Axes or if the xaxis does not\n",
      " |      have units, *x* itself is returned.\n",
      " |  \n",
      " |  convert_yunits(self, y)\n",
      " |      Convert *y* using the unit type of the yaxis.\n",
      " |      \n",
      " |      If the artist is not in contained in an Axes or if the yaxis does not\n",
      " |      have units, *y* itself is returned.\n",
      " |  \n",
      " |  findobj(self, match=None, include_self=True)\n",
      " |      Find artist objects.\n",
      " |      \n",
      " |      Recursively find all `.Artist` instances contained in the artist.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      match\n",
      " |          A filter criterion for the matches. This can be\n",
      " |      \n",
      " |          - *None*: Return all objects contained in artist.\n",
      " |          - A function with signature ``def match(artist: Artist) -> bool``.\n",
      " |            The result will only contain artists for which the function\n",
      " |            returns *True*.\n",
      " |          - A class instance: e.g., `.Line2D`. The result will only contain\n",
      " |            artists of this class or its subclasses (``isinstance`` check).\n",
      " |      \n",
      " |      include_self : bool\n",
      " |          Include *self* in the list to be checked for a match.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      list of `.Artist`\n",
      " |  \n",
      " |  format_cursor_data(self, data)\n",
      " |      Return a string representation of *data*.\n",
      " |      \n",
      " |      .. note::\n",
      " |          This method is intended to be overridden by artist subclasses.\n",
      " |          As an end-user of Matplotlib you will most likely not call this\n",
      " |          method yourself.\n",
      " |      \n",
      " |      The default implementation converts ints and floats and arrays of ints\n",
      " |      and floats into a comma-separated string enclosed in square brackets,\n",
      " |      unless the artist has an associated colorbar, in which case scalar\n",
      " |      values are formatted using the colorbar's formatter.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      get_cursor_data\n",
      " |  \n",
      " |  get_agg_filter(self)\n",
      " |      Return filter function to be used for agg filter.\n",
      " |  \n",
      " |  get_alpha(self)\n",
      " |      Return the alpha value used for blending - not supported on all\n",
      " |      backends.\n",
      " |  \n",
      " |  get_animated(self)\n",
      " |      Return whether the artist is animated.\n",
      " |  \n",
      " |  get_clip_box(self)\n",
      " |      Return the clipbox.\n",
      " |  \n",
      " |  get_clip_on(self)\n",
      " |      Return whether the artist uses clipping.\n",
      " |  \n",
      " |  get_clip_path(self)\n",
      " |      Return the clip path.\n",
      " |  \n",
      " |  get_cursor_data(self, event)\n",
      " |      Return the cursor data for a given event.\n",
      " |      \n",
      " |      .. note::\n",
      " |          This method is intended to be overridden by artist subclasses.\n",
      " |          As an end-user of Matplotlib you will most likely not call this\n",
      " |          method yourself.\n",
      " |      \n",
      " |      Cursor data can be used by Artists to provide additional context\n",
      " |      information for a given event. The default implementation just returns\n",
      " |      *None*.\n",
      " |      \n",
      " |      Subclasses can override the method and return arbitrary data. However,\n",
      " |      when doing so, they must ensure that `.format_cursor_data` can convert\n",
      " |      the data to a string representation.\n",
      " |      \n",
      " |      The only current use case is displaying the z-value of an `.AxesImage`\n",
      " |      in the status bar of a plot window, while moving the mouse.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      event : `matplotlib.backend_bases.MouseEvent`\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      format_cursor_data\n",
      " |  \n",
      " |  get_figure(self)\n",
      " |      Return the `.Figure` instance the artist belongs to.\n",
      " |  \n",
      " |  get_gid(self)\n",
      " |      Return the group id.\n",
      " |  \n",
      " |  get_in_layout(self)\n",
      " |      Return boolean flag, ``True`` if artist is included in layout\n",
      " |      calculations.\n",
      " |      \n",
      " |      E.g. :doc:`/tutorials/intermediate/constrainedlayout_guide`,\n",
      " |      `.Figure.tight_layout()`, and\n",
      " |      ``fig.savefig(fname, bbox_inches='tight')``.\n",
      " |  \n",
      " |  get_label(self)\n",
      " |      Return the label used for this artist in the legend.\n",
      " |  \n",
      " |  get_path_effects(self)\n",
      " |  \n",
      " |  get_picker(self)\n",
      " |      Return the picking behavior of the artist.\n",
      " |      \n",
      " |      The possible values are described in `.set_picker`.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      set_picker, pickable, pick\n",
      " |  \n",
      " |  get_rasterized(self)\n",
      " |      Return whether the artist is to be rasterized.\n",
      " |  \n",
      " |  get_sketch_params(self)\n",
      " |      Return the sketch parameters for the artist.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      tuple or None\n",
      " |      \n",
      " |          A 3-tuple with the following elements:\n",
      " |      \n",
      " |          - *scale*: The amplitude of the wiggle perpendicular to the\n",
      " |            source line.\n",
      " |          - *length*: The length of the wiggle along the line.\n",
      " |          - *randomness*: The scale factor by which the length is\n",
      " |            shrunken or expanded.\n",
      " |      \n",
      " |          Returns *None* if no sketch parameters were set.\n",
      " |  \n",
      " |  get_snap(self)\n",
      " |      Return the snap setting.\n",
      " |      \n",
      " |      See `.set_snap` for details.\n",
      " |  \n",
      " |  get_transform(self)\n",
      " |      Return the `.Transform` instance used by this artist.\n",
      " |  \n",
      " |  get_transformed_clip_path_and_affine(self)\n",
      " |      Return the clip path with the non-affine part of its\n",
      " |      transformation applied, and the remaining affine part of its\n",
      " |      transformation.\n",
      " |  \n",
      " |  get_url(self)\n",
      " |      Return the url.\n",
      " |  \n",
      " |  get_visible(self)\n",
      " |      Return the visibility.\n",
      " |  \n",
      " |  get_zorder(self)\n",
      " |      Return the artist's zorder.\n",
      " |  \n",
      " |  have_units(self)\n",
      " |      Return whether units are set on any axis.\n",
      " |  \n",
      " |  is_transform_set(self)\n",
      " |      Return whether the Artist has an explicitly set transform.\n",
      " |      \n",
      " |      This is *True* after `.set_transform` has been called.\n",
      " |  \n",
      " |  pchanged(self)\n",
      " |      Call all of the registered callbacks.\n",
      " |      \n",
      " |      This function is triggered internally when a property is changed.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      add_callback\n",
      " |      remove_callback\n",
      " |  \n",
      " |  pick(self, mouseevent)\n",
      " |      Process a pick event.\n",
      " |      \n",
      " |      Each child artist will fire a pick event if *mouseevent* is over\n",
      " |      the artist and the artist has picker set.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      set_picker, get_picker, pickable\n",
      " |  \n",
      " |  pickable(self)\n",
      " |      Return whether the artist is pickable.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      set_picker, get_picker, pick\n",
      " |  \n",
      " |  properties(self)\n",
      " |      Return a dictionary of all the properties of the artist.\n",
      " |  \n",
      " |  remove(self)\n",
      " |      Remove the artist from the figure if possible.\n",
      " |      \n",
      " |      The effect will not be visible until the figure is redrawn, e.g.,\n",
      " |      with `.FigureCanvasBase.draw_idle`.  Call `~.axes.Axes.relim` to\n",
      " |      update the axes limits if desired.\n",
      " |      \n",
      " |      Note: `~.axes.Axes.relim` will not see collections even if the\n",
      " |      collection was added to the axes with *autolim* = True.\n",
      " |      \n",
      " |      Note: there is no support for removing the artist's legend entry.\n",
      " |  \n",
      " |  remove_callback(self, oid)\n",
      " |      Remove a callback based on its observer id.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      add_callback\n",
      " |  \n",
      " |  set_agg_filter(self, filter_func)\n",
      " |      Set the agg filter.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      filter_func : callable\n",
      " |          A filter function, which takes a (m, n, 3) float array and a dpi\n",
      " |          value, and returns a (m, n, 3) array.\n",
      " |      \n",
      " |          .. ACCEPTS: a filter function, which takes a (m, n, 3) float array\n",
      " |              and a dpi value, and returns a (m, n, 3) array\n",
      " |  \n",
      " |  set_alpha(self, alpha)\n",
      " |      Set the alpha value used for blending - not supported on all backends.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      alpha : scalar or None\n",
      " |          *alpha* must be within the 0-1 range, inclusive.\n",
      " |  \n",
      " |  set_animated(self, b)\n",
      " |      Set whether the artist is intended to be used in an animation.\n",
      " |      \n",
      " |      If True, the artist is excluded from regular drawing of the figure.\n",
      " |      You have to call `.Figure.draw_artist` / `.Axes.draw_artist`\n",
      " |      explicitly on the artist. This appoach is used to speed up animations\n",
      " |      using blitting.\n",
      " |      \n",
      " |      See also `matplotlib.animation` and\n",
      " |      :doc:`/tutorials/advanced/blitting`.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      b : bool\n",
      " |  \n",
      " |  set_clip_box(self, clipbox)\n",
      " |      Set the artist's clip `.Bbox`.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      clipbox : `.Bbox`\n",
      " |  \n",
      " |  set_clip_on(self, b)\n",
      " |      Set whether the artist uses clipping.\n",
      " |      \n",
      " |      When False artists will be visible outside of the axes which\n",
      " |      can lead to unexpected results.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      b : bool\n",
      " |  \n",
      " |  set_clip_path(self, path, transform=None)\n",
      " |      Set the artist's clip path.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      path : `.Patch` or `.Path` or `.TransformedPath` or None\n",
      " |          The clip path. If given a `.Path`, *transform* must be provided as\n",
      " |          well. If *None*, a previously set clip path is removed.\n",
      " |      transform : `~matplotlib.transforms.Transform`, optional\n",
      " |          Only used if *path* is a `.Path`, in which case the given `.Path`\n",
      " |          is converted to a `.TransformedPath` using *transform*.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      For efficiency, if *path* is a `.Rectangle` this method will set the\n",
      " |      clipping box to the corresponding rectangle and set the clipping path\n",
      " |      to ``None``.\n",
      " |      \n",
      " |      For technical reasons (support of `~.Artist.set`), a tuple\n",
      " |      (*path*, *transform*) is also accepted as a single positional\n",
      " |      parameter.\n",
      " |      \n",
      " |      .. ACCEPTS: Patch or (Path, Transform) or None\n",
      " |  \n",
      " |  set_gid(self, gid)\n",
      " |      Set the (group) id for the artist.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      gid : str\n",
      " |  \n",
      " |  set_in_layout(self, in_layout)\n",
      " |      Set if artist is to be included in layout calculations,\n",
      " |      E.g. :doc:`/tutorials/intermediate/constrainedlayout_guide`,\n",
      " |      `.Figure.tight_layout()`, and\n",
      " |      ``fig.savefig(fname, bbox_inches='tight')``.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      in_layout : bool\n",
      " |  \n",
      " |  set_label(self, s)\n",
      " |      Set a label that will be displayed in the legend.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      s : object\n",
      " |          *s* will be converted to a string by calling `str`.\n",
      " |  \n",
      " |  set_path_effects(self, path_effects)\n",
      " |      Set the path effects.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      path_effects : `.AbstractPathEffect`\n",
      " |  \n",
      " |  set_picker(self, picker)\n",
      " |      Define the picking behavior of the artist.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      picker : None or bool or float or callable\n",
      " |          This can be one of the following:\n",
      " |      \n",
      " |          - *None*: Picking is disabled for this artist (default).\n",
      " |      \n",
      " |          - A boolean: If *True* then picking will be enabled and the\n",
      " |            artist will fire a pick event if the mouse event is over\n",
      " |            the artist.\n",
      " |      \n",
      " |          - A float: If picker is a number it is interpreted as an\n",
      " |            epsilon tolerance in points and the artist will fire\n",
      " |            off an event if its data is within epsilon of the mouse\n",
      " |            event.  For some artists like lines and patch collections,\n",
      " |            the artist may provide additional data to the pick event\n",
      " |            that is generated, e.g., the indices of the data within\n",
      " |            epsilon of the pick event\n",
      " |      \n",
      " |          - A function: If picker is callable, it is a user supplied\n",
      " |            function which determines whether the artist is hit by the\n",
      " |            mouse event::\n",
      " |      \n",
      " |              hit, props = picker(artist, mouseevent)\n",
      " |      \n",
      " |            to determine the hit test.  if the mouse event is over the\n",
      " |            artist, return *hit=True* and props is a dictionary of\n",
      " |            properties you want added to the PickEvent attributes.\n",
      " |  \n",
      " |  set_rasterized(self, rasterized)\n",
      " |      Force rasterized (bitmap) drawing for vector graphics output.\n",
      " |      \n",
      " |      Rasterized drawing is not supported by all artists. If you try to\n",
      " |      enable this on an artist that does not support it, the command has no\n",
      " |      effect and a warning will be issued.\n",
      " |      \n",
      " |      This setting is ignored for pixel-based output.\n",
      " |      \n",
      " |      See also :doc:`/gallery/misc/rasterization_demo`.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      rasterized : bool\n",
      " |  \n",
      " |  set_sketch_params(self, scale=None, length=None, randomness=None)\n",
      " |      Set the sketch parameters.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      scale : float, optional\n",
      " |          The amplitude of the wiggle perpendicular to the source\n",
      " |          line, in pixels.  If scale is `None`, or not provided, no\n",
      " |          sketch filter will be provided.\n",
      " |      length : float, optional\n",
      " |           The length of the wiggle along the line, in pixels\n",
      " |           (default 128.0)\n",
      " |      randomness : float, optional\n",
      " |          The scale factor by which the length is shrunken or\n",
      " |          expanded (default 16.0)\n",
      " |      \n",
      " |          The PGF backend uses this argument as an RNG seed and not as\n",
      " |          described above. Using the same seed yields the same random shape.\n",
      " |      \n",
      " |          .. ACCEPTS: (scale: float, length: float, randomness: float)\n",
      " |  \n",
      " |  set_snap(self, snap)\n",
      " |      Set the snapping behavior.\n",
      " |      \n",
      " |      Snapping aligns positions with the pixel grid, which results in\n",
      " |      clearer images. For example, if a black line of 1px width was\n",
      " |      defined at a position in between two pixels, the resulting image\n",
      " |      would contain the interpolated value of that line in the pixel grid,\n",
      " |      which would be a grey value on both adjacent pixel positions. In\n",
      " |      contrast, snapping will move the line to the nearest integer pixel\n",
      " |      value, so that the resulting image will really contain a 1px wide\n",
      " |      black line.\n",
      " |      \n",
      " |      Snapping is currently only supported by the Agg and MacOSX backends.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      snap : bool or None\n",
      " |          Possible values:\n",
      " |      \n",
      " |          - *True*: Snap vertices to the nearest pixel center.\n",
      " |          - *False*: Do not modify vertex positions.\n",
      " |          - *None*: (auto) If the path contains only rectilinear line\n",
      " |            segments, round to the nearest pixel center.\n",
      " |  \n",
      " |  set_transform(self, t)\n",
      " |      Set the artist transform.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      t : `.Transform`\n",
      " |  \n",
      " |  set_url(self, url)\n",
      " |      Set the url for the artist.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      url : str\n",
      " |  \n",
      " |  set_visible(self, b)\n",
      " |      Set the artist's visibility.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      b : bool\n",
      " |  \n",
      " |  set_zorder(self, level)\n",
      " |      Set the zorder for the artist.  Artists with lower zorder\n",
      " |      values are drawn first.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      level : float\n",
      " |  \n",
      " |  update(self, props)\n",
      " |      Update this artist's properties from the dict *props*.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      props : dict\n",
      " |  \n",
      " |  update_from(self, other)\n",
      " |      Copy properties from *other* to *self*.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from matplotlib.artist.Artist:\n",
      " |  \n",
      " |  __init_subclass__() from builtins.type\n",
      " |      This method is called when a class is subclassed.\n",
      " |      \n",
      " |      The default implementation does nothing. It may be\n",
      " |      overridden to extend subclasses.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from matplotlib.artist.Artist:\n",
      " |  \n",
      " |  sticky_edges\n",
      " |      ``x`` and ``y`` sticky edge lists for autoscaling.\n",
      " |      \n",
      " |      When performing autoscaling, if a data limit coincides with a value in\n",
      " |      the corresponding sticky_edges list, then no margin will be added--the\n",
      " |      view limit \"sticks\" to the edge. A typical use case is histograms,\n",
      " |      where one usually expects no margin on the bottom edge (0) of the\n",
      " |      histogram.\n",
      " |      \n",
      " |      Moreover, margin expansion \"bumps\" against sticky edges and cannot\n",
      " |      cross them.  For example, if the upper data limit is 1.0, the upper\n",
      " |      view limit computed by simple margin application is 1.2, but there is a\n",
      " |      sticky edge at 1.1, then the actual upper view limit will be 1.1.\n",
      " |      \n",
      " |      This attribute cannot be assigned to; however, the ``x`` and ``y``\n",
      " |      lists can be modified in place as needed.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> artist.sticky_edges.x[:] = (xmin, xmax)\n",
      " |      >>> artist.sticky_edges.y[:] = (ymin, ymax)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from matplotlib.artist.Artist:\n",
      " |  \n",
      " |  axes\n",
      " |      The `~.axes.Axes` instance the artist resides in, or *None*.\n",
      " |  \n",
      " |  mouseover\n",
      " |      If this property is set to *True*, the artist will be queried for\n",
      " |      custom context information when the mouse cursor moves over it.\n",
      " |      \n",
      " |      See also :meth:`get_cursor_data`, :class:`.ToolCursorPosition` and\n",
      " |      :class:`.NavigationToolbar2`.\n",
      " |  \n",
      " |  stale\n",
      " |      Whether the artist is 'stale' and needs to be re-drawn for the output\n",
      " |      to match the internal state of the artist.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from matplotlib.artist.Artist:\n",
      " |  \n",
      " |  zorder = 0\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Hilfe aufrufen zu Funktionen\n",
    "help(apcs[\"euro\"].hist())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "2c5bd1b8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0                      Springer Nature\n",
       "1      American Physical Society (APS)\n",
       "2                      Springer Nature\n",
       "3     Public Library of Science (PLoS)\n",
       "4                      Springer Nature\n",
       "                    ...               \n",
       "56                     Springer Nature\n",
       "57                  Frontiers Media SA\n",
       "58                  Frontiers Media SA\n",
       "59                     Springer Nature\n",
       "60      Hindawi Publishing Corporation\n",
       "Name: publisher, Length: 61, dtype: object"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "apcs[\"publisher\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "afdb4083",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Frontiers Media SA                                  16\n",
       "Springer Nature                                     13\n",
       "Public Library of Science (PLoS)                    13\n",
       "Copernicus GmbH                                      3\n",
       "Schweizerbart                                        3\n",
       "Hindawi Publishing Corporation                       3\n",
       "Scientific Research Publishing, Inc,                 2\n",
       "American Physical Society (APS)                      1\n",
       "PAGEPress Publications                               1\n",
       "IOP Publishing                                       1\n",
       "Elsevier BV                                          1\n",
       "Inter-Research Science Center                        1\n",
       "MDPI AG                                              1\n",
       "Cogitatio                                            1\n",
       "The Korean Society of Veterinary Science (KAMJE)     1\n",
       "Name: publisher, dtype: int64"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Zählen der Häufigkeiten von Einträgen (SQL=Count)\n",
    "apcs[\"publisher\"].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "d6003633",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "apcs[\"publisher\"].value_counts().plot.bar()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "7936f4b1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "apcs[\"publisher\"].value_counts().plot.barh()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "5b029eeb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# zwei Spalten ausschneiden in neuen Dataframe\n",
    "apcs_pub_and_euro = apcs[[\"publisher\", \"euro\"]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "af53cbad",
   "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>euro</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>publisher</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>American Physical Society (APS)</th>\n",
       "      <td>1503.12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Cogitatio</th>\n",
       "      <td>430.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Copernicus GmbH</th>\n",
       "      <td>3272.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Elsevier BV</th>\n",
       "      <td>1550.33</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Frontiers Media SA</th>\n",
       "      <td>21772.15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Hindawi Publishing Corporation</th>\n",
       "      <td>4305.22</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IOP Publishing</th>\n",
       "      <td>1392.30</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Inter-Research Science Center</th>\n",
       "      <td>1785.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>MDPI AG</th>\n",
       "      <td>1150.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>PAGEPress Publications</th>\n",
       "      <td>892.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Public Library of Science (PLoS)</th>\n",
       "      <td>18688.52</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Schweizerbart</th>\n",
       "      <td>5374.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Scientific Research Publishing, Inc,</th>\n",
       "      <td>1289.30</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Springer Nature</th>\n",
       "      <td>22118.10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>The Korean Society of Veterinary Science (KAMJE)</th>\n",
       "      <td>1072.55</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                      euro\n",
       "publisher                                                 \n",
       "American Physical Society (APS)                    1503.12\n",
       "Cogitatio                                           430.50\n",
       "Copernicus GmbH                                    3272.50\n",
       "Elsevier BV                                        1550.33\n",
       "Frontiers Media SA                                21772.15\n",
       "Hindawi Publishing Corporation                     4305.22\n",
       "IOP Publishing                                     1392.30\n",
       "Inter-Research Science Center                      1785.00\n",
       "MDPI AG                                            1150.00\n",
       "PAGEPress Publications                              892.50\n",
       "Public Library of Science (PLoS)                  18688.52\n",
       "Schweizerbart                                      5374.00\n",
       "Scientific Research Publishing, Inc,               1289.30\n",
       "Springer Nature                                   22118.10\n",
       "The Korean Society of Veterinary Science (KAMJE)   1072.55"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "apcs_pub_and_euro.groupby(\"publisher\").sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "783f14f3",
   "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>euro</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>publisher</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>American Physical Society (APS)</th>\n",
       "      <td>1503.12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Cogitatio</th>\n",
       "      <td>430.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Copernicus GmbH</th>\n",
       "      <td>1160.25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Elsevier BV</th>\n",
       "      <td>1550.33</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Frontiers Media SA</th>\n",
       "      <td>2000.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Hindawi Publishing Corporation</th>\n",
       "      <td>2000.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IOP Publishing</th>\n",
       "      <td>1392.30</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Inter-Research Science Center</th>\n",
       "      <td>1785.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>MDPI AG</th>\n",
       "      <td>1150.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>PAGEPress Publications</th>\n",
       "      <td>892.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Public Library of Science (PLoS)</th>\n",
       "      <td>2000.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Schweizerbart</th>\n",
       "      <td>2000.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Scientific Research Publishing, Inc,</th>\n",
       "      <td>853.84</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Springer Nature</th>\n",
       "      <td>2000.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>The Korean Society of Veterinary Science (KAMJE)</th>\n",
       "      <td>1072.55</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                     euro\n",
       "publisher                                                \n",
       "American Physical Society (APS)                   1503.12\n",
       "Cogitatio                                          430.50\n",
       "Copernicus GmbH                                   1160.25\n",
       "Elsevier BV                                       1550.33\n",
       "Frontiers Media SA                                2000.00\n",
       "Hindawi Publishing Corporation                    2000.00\n",
       "IOP Publishing                                    1392.30\n",
       "Inter-Research Science Center                     1785.00\n",
       "MDPI AG                                           1150.00\n",
       "PAGEPress Publications                             892.50\n",
       "Public Library of Science (PLoS)                  2000.00\n",
       "Schweizerbart                                     2000.00\n",
       "Scientific Research Publishing, Inc,               853.84\n",
       "Springer Nature                                   2000.00\n",
       "The Korean Society of Veterinary Science (KAMJE)  1072.55"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "apcs_pub_and_euro.groupby(\"publisher\").max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e7e5264",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}