{ "cells": [ { "cell_type": "code", "execution_count": 3, "id": "22669eb0", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", "execution_count": 20, "id": "72887754", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([-0.60268622, 0.22560634, 1.11786578, 1.56517274, 0.907439 ,\n", " 0.91065235, -0.08930162, 1.14213946, -0.80313743, -0.38647779])" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "n=10\n", "samples = np.random.randn(n)\n", "samples" ] }, { "cell_type": "code", "execution_count": 21, "id": "0adf6366", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.39872726096713895" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.mean(samples)" ] }, { "cell_type": "code", "execution_count": 22, "id": "ecda2773", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.6283269615426914" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.var(samples)" ] }, { "cell_type": "code", "execution_count": 26, "id": "54e9ffff", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.6283269615426914\n" ] } ], "source": [ "x=samples\n", "myvar = np.mean([(xi - np.mean(x))**2 for xi in x])\n", "print(myvar)" ] }, { "cell_type": "code", "execution_count": 27, "id": "062f5960", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1.0028289620314856,\n", " 0.029970853574111014,\n", " 0.5171602133796587,\n", " 1.360595051272813,\n", " 0.25878763520136416,\n", " 0.2620672965912178,\n", " 0.23817218767365075,\n", " 0.5526616997955722,\n", " 1.444478745264378,\n", " 0.6165469706426626]" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "[(xi - np.mean(x))**2 for xi in x]" ] }, { "cell_type": "code", "execution_count": 34, "id": "f4447ccc", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "samples_pb = list(samples)\n", "samples_pb.append(6)\n", "plt.boxplot(samples_pb);" ] }, { "cell_type": "code", "execution_count": 36, "id": "810a0bcc", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Help on function boxplot in module matplotlib.pyplot:\n", "\n", "boxplot(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, capwidths=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", " capwidths : float or array, default: None\n", " The widths 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" ] } ], "source": [ "help(plt.boxplot)" ] }, { "cell_type": "code", "execution_count": 38, "id": "847a73f1", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.hist(samples_pb);" ] }, { "cell_type": "code", "execution_count": null, "id": "9fff3396", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "mlenv", "language": "python", "name": "mlenv" }, "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.10.6" } }, "nbformat": 4, "nbformat_minor": 5 }