pl_tseri.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "data = np.loadtxt('data2020/sha_bjfs.neu', comments='#')\n",
    "#print(data)\n",
    "\n",
    "t = data[:,0]\n",
    "n = data[:,1]*1000\n",
    "e = data[:,2]*1000\n",
    "u = data[:,3]*1000\n",
    "\n",
    "plt.figure()    # 定义一个图像窗口\n",
    "plt.plot(t,n,color=\"blue\", linewidth=1.0, linestyle=\"-\", label=\"N\") # 绘制曲线 n\n",
    "plt.plot(t,e,color=\"green\", linewidth=1.0, linestyle=\"-\", label=\"E\") # 绘制曲线 e\n",
    "plt.plot(t,u,color=\"red\", linewidth=1.0, linestyle=\"--\", label=\"U\") # 绘制曲线 u\n",
    "plt.xlabel('Year')\n",
    "plt.ylabel('mm')\n",
    "plt.title('BJFS')\n",
    "plt.legend(loc=\"lower left\")\n",
    "plt.savefig('./BJFS.pdf')\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "squares = [1, 4, 9, 16, 25]\n",
    "print(squares[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function plot in module matplotlib.pyplot:\n",
      "\n",
      "plot(*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.DataFame` 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",
      "    - Alternatively, if your data is already a 2d array, you can pass it\n",
      "      directly to *x*, *y*. A separate data set will be drawn for every\n",
      "      column.\n",
      "    \n",
      "      Example: an array ``a`` where the first column represents the *x*\n",
      "      values and the other columns are the *y* columns::\n",
      "    \n",
      "      >>> plot(a[0], a[1:])\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 the\n",
      "    'axes.prop_cycle' rcParam.\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",
      "    Other Parameters\n",
      "    ----------------\n",
      "    scalex, scaley : bool, optional, default: True\n",
      "        These parameters determined if the view limits are adapted to\n",
      "        the 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 make multiple lines with one plot command, the kwargs\n",
      "        apply to all those lines.\n",
      "    \n",
      "        Here is a list of available `.Line2D` properties:\n",
      "    \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: float\n",
      "      animated: bool\n",
      "      antialiased or aa: bool\n",
      "      clip_box: `.Bbox`\n",
      "      clip_on: bool\n",
      "      clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None]\n",
      "      color or c: color\n",
      "      contains: callable\n",
      "      dash_capstyle: {'butt', 'round', 'projecting'}\n",
      "      dash_joinstyle: {'miter', 'round', 'bevel'}\n",
      "      dashes: sequence of floats (on/off ink in points) or (None, None)\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\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)\n",
      "      path_effects: `.AbstractPathEffect`\n",
      "      picker: float or callable[[Artist, Event], Tuple[bool, dict]]\n",
      "      pickradius: float\n",
      "      rasterized: bool or None\n",
      "      sketch_params: (scale: float, length: float, randomness: float)\n",
      "      snap: bool or None\n",
      "      solid_capstyle: {'butt', 'round', 'projecting'}\n",
      "      solid_joinstyle: {'miter', 'round', 'bevel'}\n",
      "      transform: `matplotlib.transforms.Transform`\n",
      "      url: str\n",
      "      visible: bool\n",
      "      xdata: 1D array\n",
      "      ydata: 1D array\n",
      "      zorder: float\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    lines\n",
      "        A list of `.Line2D` objects representing the plotted data.\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",
      "    ``'s'``          square marker\n",
      "    ``'p'``          pentagon marker\n",
      "    ``'*'``          star marker\n",
      "    ``'h'``          hexagon1 marker\n",
      "    ``'H'``          hexagon2 marker\n",
      "    ``'+'``          plus marker\n",
      "    ``'x'``          x 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"
     ]
    }
   ],
   "source": [
    "help(plt.plot)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function xlabel in module matplotlib.pyplot:\n",
      "\n",
      "xlabel(xlabel, fontdict=None, labelpad=None, **kwargs)\n",
      "    Set the label for the x-axis.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    xlabel : str\n",
      "        The label text.\n",
      "    \n",
      "    labelpad : scalar, optional, default: None\n",
      "        Spacing in points from the axes bounding box including ticks\n",
      "        and tick labels.\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 : for information on how override and the optional args work\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(plt.xlabel)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function legend in module matplotlib.pyplot:\n",
      "\n",
      "legend(*args, **kwargs)\n",
      "    Place a legend on the axes.\n",
      "    \n",
      "    Call signatures::\n",
      "    \n",
      "        legend()\n",
      "        legend(labels)\n",
      "        legend(handles, labels)\n",
      "    \n",
      "    The call signatures correspond to three different ways how 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",
      "        line, = 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. Labeling existing plot elements**\n",
      "    \n",
      "    To make a legend for lines which already exist on the axes\n",
      "    (via plot for instance), simply call this function with an iterable\n",
      "    of strings, one for each legend item. For example::\n",
      "    \n",
      "        ax.plot([1, 2, 3])\n",
      "        ax.legend(['A simple line'])\n",
      "    \n",
      "    Note: This way of using 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",
      "    \n",
      "    **3. Explicitly defining the elements 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",
      "        legend((line1, line2, line3), ('label1', 'label2', 'label3'))\n",
      "    \n",
      "    Parameters\n",
      "    ----------\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 : sequence of strings, 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",
      "    Other Parameters\n",
      "    ----------------\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 : integer\n",
      "        The number of columns that the legend has. Default is 1.\n",
      "    \n",
      "    prop : None or :class:`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 float or {'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'}\n",
      "        Controls the font size of the legend. If the value is numeric the\n",
      "        size will be the absolute font size in points. String values are\n",
      "        relative to the current default font size. This argument is only\n",
      "        used if `prop` is not specified.\n",
      "    \n",
      "    numpoints : None or int\n",
      "        The number of marker points in the legend when creating a legend\n",
      "        entry for a `.Line2D` (line).\n",
      "        Default is ``None``, which will take the value from\n",
      "        :rc:`legend.numpoints`.\n",
      "    \n",
      "    scatterpoints : None or int\n",
      "        The number of marker points in the legend when creating\n",
      "        a legend entry for a `.PathCollection` (scatter plot).\n",
      "        Default is ``None``, which will take the value from\n",
      "        :rc:`legend.scatterpoints`.\n",
      "    \n",
      "    scatteryoffsets : iterable of floats\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]``. Default is ``[0.375, 0.5, 0.3125]``.\n",
      "    \n",
      "    markerscale : None or int or float\n",
      "        The relative size of legend markers compared with the originally\n",
      "        drawn ones.\n",
      "        Default is ``None``, which will take the value from\n",
      "        :rc:`legend.markerscale`.\n",
      "    \n",
      "    markerfirst : bool\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\n",
      "        label.\n",
      "        Default is *True*.\n",
      "    \n",
      "    frameon : None or bool\n",
      "        Control whether the legend should be drawn on a patch\n",
      "        (frame).\n",
      "        Default is ``None``, which will take the value from\n",
      "        :rc:`legend.frameon`.\n",
      "    \n",
      "    fancybox : None or bool\n",
      "        Control whether round edges should be enabled around the\n",
      "        :class:`~matplotlib.patches.FancyBboxPatch` which makes up the\n",
      "        legend's background.\n",
      "        Default is ``None``, which will take the value from\n",
      "        :rc:`legend.fancybox`.\n",
      "    \n",
      "    shadow : None or bool\n",
      "        Control whether to draw a shadow behind the legend.\n",
      "        Default is ``None``, which will take the value from\n",
      "        :rc:`legend.shadow`.\n",
      "    \n",
      "    framealpha : None or float\n",
      "        Control the alpha transparency of the legend's background.\n",
      "        Default is ``None``, which will take the value from\n",
      "        :rc:`legend.framealpha`.  If shadow is activated and\n",
      "        *framealpha* is ``None``, the default value is ignored.\n",
      "    \n",
      "    facecolor : None or \"inherit\" or a color spec\n",
      "        Control the legend's background color.\n",
      "        Default is ``None``, which will take the value from\n",
      "        :rc:`legend.facecolor`.  If ``\"inherit\"``, it will take\n",
      "        :rc:`axes.facecolor`.\n",
      "    \n",
      "    edgecolor : None or \"inherit\" or a color spec\n",
      "        Control the legend's background patch edge color.\n",
      "        Default is ``None``, which will take the value from\n",
      "        :rc:`legend.edgecolor` If ``\"inherit\"``, it will take\n",
      "        :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 :class:`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_fontsize: str or None\n",
      "        The fontsize of the legend's title.  Default is the default fontsize.\n",
      "    \n",
      "    borderpad : float or None\n",
      "        The fractional whitespace inside the legend border.\n",
      "        Measured in font-size units.\n",
      "        Default is ``None``, which will take the value from\n",
      "        :rc:`legend.borderpad`.\n",
      "    \n",
      "    labelspacing : float or None\n",
      "        The vertical space between the legend entries.\n",
      "        Measured in font-size units.\n",
      "        Default is ``None``, which will take the value from\n",
      "        :rc:`legend.labelspacing`.\n",
      "    \n",
      "    handlelength : float or None\n",
      "        The length of the legend handles.\n",
      "        Measured in font-size units.\n",
      "        Default is ``None``, which will take the value from\n",
      "        :rc:`legend.handlelength`.\n",
      "    \n",
      "    handletextpad : float or None\n",
      "        The pad between the legend handle and text.\n",
      "        Measured in font-size units.\n",
      "        Default is ``None``, which will take the value from\n",
      "        :rc:`legend.handletextpad`.\n",
      "    \n",
      "    borderaxespad : float or None\n",
      "        The pad between the axes and legend border.\n",
      "        Measured in font-size units.\n",
      "        Default is ``None``, which will take the value from\n",
      "        :rc:`legend.borderaxespad`.\n",
      "    \n",
      "    columnspacing : float or None\n",
      "        The spacing between columns.\n",
      "        Measured in font-size units.\n",
      "        Default is ``None``, which will take the value from\n",
      "        :rc:`legend.columnspacing`.\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 :func:`matplotlib.legend.Legend.get_legend_handler_map`.\n",
      "    \n",
      "    \n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    \n",
      "    :class:`matplotlib.legend.Legend` instance\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    \n",
      "    Not all kinds of artist are supported by the legend command. See\n",
      "    :doc:`/tutorials/intermediate/legend_guide` for details.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    \n",
      "    .. plot:: gallery/text_labels_and_annotations/legend.py\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(plt.legend)\n"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}