00_Einfuehrung.ipynb

{
 "metadata": {
  "name": ""
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "# NumPy\n",
      "---\n",
      "## Einf\u00fchrung in NumPy\n",
      "\n",
      "von Henning Dickten und Christian Geier\n",
      "\n",
      "[Tutorium](https://2013.de.pycon.org/schedule/sessions/62/) bei der PyCon.DE 2013, K\u00f6ln\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "slide"
      }
     },
     "source": [
      "# 00 Einf\u00fchrung: \u00dcberblick \u00fcber NumPy"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "* NumPy ist ein Python Modul\n",
      "* Unterst\u00fctzung f\u00fcr (gro\u00dfe und schnelle) Arrays und Matrizen\n",
      "* 2005: Travis Oliphant f\u00fchrt NumPys Vorl\u00e4ufer *Numarray* und *Numeric* zusammen\n",
      "* seit dem das Standardmodul zur numerischen Rechnungen mit Arrays und Matrizen\n",
      "* wird aktiv als Community Projekt weiterentwickelt\n",
      "* NumPy ist Teil des SciPy Projektes\n",
      "* arbeitet gut mit SciPy, Matplotlib, IPython, Pandas\u2026 zusammen\n",
      "* NumPy ist Open Source \u00ae, Free Software, ver\u00f6ffentlicht unter der BSD Lizenz (3-clause)"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "* NumPy ist nicht in Python sondern in C geschrieben\n",
      "* NumPy benutzt BLAS und LAPACK (wie MATLAB\u00ae)\n",
      "* NumPy unterst\u00fctzt nur cpython (die Standard Python Version), an pypy wird gearbeitet"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "* NumPy wird kanonisch import mit:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import numpy as np"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 1
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "* die wichtigste Klasse ist **ndarray** (**n**-**d**imensionaler **array**), von jetzt an als *array* bezeichnet"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Documentation und Hilfen"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "* http://docs.scipy.org/doc/ Referenz und Einf\u00fchrung (Englisch!)\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Docstrings\n",
      "\n",
      "NumPys Docstrings sind sehr informativ, ausf\u00fchrlich und meistens mit hilfreichen Beispielen und Referenzen zu \u00e4hnlichen Funktionen versehen. \n",
      "\n",
      "* np.func? (in IPython)\n",
      "* np.info(np.func)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.ndarray?"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 2
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.info(np.ndarray)  # funktioniert im Notebook nicht"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " ndarray()\n",
        "\n",
        "ndarray(shape, dtype=float, buffer=None, offset=0,\n",
        "        strides=None, order=None)\n",
        "\n",
        "An array object represents a multidimensional, homogeneous array\n",
        "of fixed-size items.  An associated data-type object describes the\n",
        "format of each element in the array (its byte-order, how many bytes it\n",
        "occupies in memory, whether it is an integer, a floating point number,\n",
        "or something else, etc.)\n",
        "\n",
        "Arrays should be constructed using `array`, `zeros` or `empty` (refer\n",
        "to the See Also section below).  The parameters given here refer to\n",
        "a low-level method (`ndarray(...)`) for instantiating an array.\n",
        "\n",
        "For more information, refer to the `numpy` module and examine the\n",
        "the methods and attributes of an array.\n",
        "\n",
        "Parameters\n",
        "----------\n",
        "(for the __new__ method; see Notes below)\n",
        "\n",
        "shape : tuple of ints\n",
        "    Shape of created array.\n",
        "dtype : data-type, optional\n",
        "    Any object that can be interpreted as a numpy data type.\n",
        "buffer : object exposing buffer interface, optional\n",
        "    Used to fill the array with data.\n",
        "offset : int, optional\n",
        "    Offset of array data in buffer.\n",
        "strides : tuple of ints, optional\n",
        "    Strides of data in memory.\n",
        "order : {'C', 'F'}, optional\n",
        "    Row-major or column-major order.\n",
        "\n",
        "Attributes\n",
        "----------\n",
        "T : ndarray\n",
        "    Transpose of the array.\n",
        "data : buffer\n",
        "    The array's elements, in memory.\n",
        "dtype : dtype object\n",
        "    Describes the format of the elements in the array.\n",
        "flags : dict\n",
        "    Dictionary containing information related to memory use, e.g.,\n",
        "    'C_CONTIGUOUS', 'OWNDATA', 'WRITEABLE', etc.\n",
        "flat : numpy.flatiter object\n",
        "    Flattened version of the array as an iterator.  The iterator\n",
        "    allows assignments, e.g., ``x.flat = 3`` (See `ndarray.flat` for\n",
        "    assignment examples; TODO).\n",
        "imag : ndarray\n",
        "    Imaginary part of the array.\n",
        "real : ndarray\n",
        "    Real part of the array.\n",
        "size : int\n",
        "    Number of elements in the array.\n",
        "itemsize : int\n",
        "    The memory use of each array element in bytes.\n",
        "nbytes : int\n",
        "    The total number of bytes required to store the array data,\n",
        "    i.e., ``itemsize * size``.\n",
        "ndim : int\n",
        "    The array's number of dimensions.\n",
        "shape : tuple of ints\n",
        "    Shape of the array.\n",
        "strides : tuple of ints\n",
        "    The step-size required to move from one element to the next in\n",
        "    memory. For example, a contiguous ``(3, 4)`` array of type\n",
        "    ``int16`` in C-order has strides ``(8, 2)``.  This implies that\n",
        "    to move from element to element in memory requires jumps of 2 bytes.\n",
        "    To move from row-to-row, one needs to jump 8 bytes at a time\n",
        "    (``2 * 4``).\n",
        "ctypes : ctypes object\n",
        "    Class containing properties of the array needed for interaction\n",
        "    with ctypes.\n",
        "base : ndarray\n",
        "    If the array is a view into another array, that array is its `base`\n",
        "    (unless that array is also a view).  The `base` array is where the\n",
        "    array data is actually stored.\n",
        "\n",
        "See Also\n",
        "--------\n",
        "array : Construct an array.\n",
        "zeros : Create an array, each element of which is zero.\n",
        "empty : Create an array, but leave its allocated memory unchanged (i.e.,\n",
        "        it contains \"garbage\").\n",
        "dtype : Create a data-type.\n",
        "\n",
        "Notes\n",
        "-----\n",
        "There are two modes of creating an array using ``__new__``:\n",
        "\n",
        "1. If `buffer` is None, then only `shape`, `dtype`, and `order`\n",
        "   are used.\n",
        "2. If `buffer` is an object exposing the buffer interface, then\n",
        "   all keywords are interpreted.\n",
        "\n",
        "No ``__init__`` method is needed because the array is fully initialized\n",
        "after the ``__new__`` method.\n",
        "\n",
        "Examples\n",
        "--------\n",
        "These examples illustrate the low-level `ndarray` constructor.  Refer\n",
        "to the `See Also` section above for easier ways of constructing an\n",
        "ndarray.\n",
        "\n",
        "First mode, `buffer` is None:\n",
        "\n",
        ">>> np.ndarray(shape=(2,2), dtype=float, order='F')\n",
        "array([[ -1.13698227e+002,   4.25087011e-303],\n",
        "       [  2.88528414e-306,   3.27025015e-309]])         #random\n",
        "\n",
        "Second mode:\n",
        "\n",
        ">>> np.ndarray((2,), buffer=np.array([1,2,3]),\n",
        "...            offset=np.int_().itemsize,\n",
        "...            dtype=int) # offset = 1*itemsize, i.e. skip first element\n",
        "array([2, 3])\n",
        "\n",
        "\n",
        "Methods:\n",
        "\n",
        "  all  --  a.all(axis=None, out=None)\n",
        "  cumsum  --  a.cumsum(axis=None, dtype=None, out=None)\n",
        "  ptp  --  a.ptp(axis=None, out=None)\n",
        "  squeeze  --  a.squeeze()\n",
        "  choose  --  a.choose(choices, out=None, mode='raise')\n",
        "  swapaxes  --  a.swapaxes(axis1, axis2)\n",
        "  setfield  --  a.setfield(val, dtype, offset=0)\n",
        "  ravel  --  a.ravel([order])\n",
        "  tostring  --  a.tostring(order='C')\n",
        "  dumps  --  a.dumps()\n",
        "  item  --  a.item(*args)\n",
        "  byteswap  --  a.byteswap(inplace)\n",
        "  setflags  --  a.setflags(write=None, align=None, uic=None)\n",
        "  round  --  a.round(decimals=0, out=None)\n",
        "  mean  --  a.mean(axis=None, dtype=None, out=None)\n",
        "  dump  --  a.dump(file)\n",
        "  tolist  --  a.tolist()\n",
        "  argmax  --  a.argmax(axis=None, out=None)\n",
        "  tofile  --  a.tofile(fid, sep=\"\", format=\"%s\")\n",
        "  flatten  --  a.flatten(order='C')\n",
        "  sum  --  a.sum(axis=None, dtype=None, out=None)\n",
        "  prod  --  a.prod(axis=None, dtype=None, out=None)\n",
        "  setasflat  --  a.setasflat(arr)\n",
        "  transpose  --  a.transpose(*axes)\n",
        "  diagonal  --  a.diagonal(offset=0, axis1=0, axis2=1)\n",
        "  cumprod  --  a.cumprod(axis=None, dtype=None, out=None)\n",
        "  argsort  --  a.argsort(axis=-1, kind='quicksort', order=None)\n",
        "  view  --  a.view(dtype=None, type=None)\n",
        "  put  --  a.put(indices, values, mode='raise')\n",
        "  var  --  a.var(axis=None, dtype=None, out=None, ddof=0)\n",
        "  sort  --  a.sort(axis=-1, kind='quicksort', order=None)\n",
        "  itemset  --  a.itemset(*args)\n",
        "  copy  --  a.copy(order='C')\n",
        "  resize  --  a.resize(new_shape, refcheck=True)\n",
        "  std  --  a.std(axis=None, dtype=None, out=None, ddof=0)\n",
        "  argmin  --  a.argmin(axis=None, out=None)\n",
        "  newbyteorder  --  arr.newbyteorder(new_order='S')\n",
        "  clip  --  a.clip(a_min, a_max, out=None)\n",
        "  getfield  --  a.getfield(dtype, offset)\n",
        "  conjugate  --  a.conjugate()\n",
        "  any  --  a.any(axis=None, out=None)\n",
        "  fill  --  a.fill(value)\n",
        "  reshape  --  a.reshape(shape, order='C')\n",
        "  astype  --  a.astype(t)\n",
        "  take  --  a.take(indices, axis=None, out=None, mode='raise')\n",
        "  conj  --  a.conj()\n",
        "  nonzero  --  a.nonzero()\n",
        "  repeat  --  a.repeat(repeats, axis=None)\n",
        "  trace  --  a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)\n",
        "  max  --  a.max(axis=None, out=None)\n",
        "  compress  --  a.compress(condition, axis=None, out=None)\n",
        "  min  --  a.min(axis=None, out=None)\n",
        "  searchsorted  --  a.searchsorted(v, side='left')\n",
        "  dot  --  a.dot(b, out=None)\n"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Funktionen finden\n",
      "\n",
      "np.lookfor('suchstring')"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.lookfor('diagonal')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Search results for 'diagonal'\n",
        "-----------------------------\n",
        "numpy.diagonal\n",
        "    Return specified diagonals.\n",
        "numpy.eye\n",
        "    Return a 2-D array with ones on the diagonal and zeros elsewhere.\n",
        "numpy.tri\n",
        "    An array with ones at and below the given diagonal and zeros elsewhere.\n",
        "numpy.diag\n",
        "    Extract a diagonal or construct a diagonal array.\n",
        "numpy.triu\n",
        "    Upper triangle of an array.\n",
        "numpy.tril\n",
        "    Lower triangle of an array.\n",
        "numpy.trace\n",
        "    Return the sum along diagonals of the array.\n",
        "numpy.fill_diagonal\n",
        "    Fill the main diagonal of the given array of any dimensionality.\n",
        "numpy.diagflat\n",
        "    Create a two-dimensional array with the flattened input as a diagonal.\n",
        "numpy.ma.diagonal\n",
        "    diagonal\n",
        "numpy.ma.diag\n",
        "    Extract a diagonal or construct a diagonal array.\n",
        "numpy.diag_indices\n",
        "    Return the indices to access the main diagonal of an array.\n",
        "numpy.matlib.eye\n",
        "    Return a matrix with ones on the diagonal and zeros elsewhere.\n",
        "numpy.ma.diagflat\n",
        "    Create a two-dimensional array with the flattened input as a diagonal.\n",
        "numpy.chararray.diagonal\n",
        "    Return specified diagonals.\n",
        "numpy.diag_indices_from\n",
        "    Return the indices to access the main diagonal of an n-dimensional array.\n",
        "numpy.chararray.trace\n",
        "    Return the sum along diagonals of the array.\n",
        "numpy.ma.mvoid.trace\n",
        "    Return the sum along diagonals of the array.\n",
        "numpy.ma.MaskedArray.diagonal\n",
        "    Return specified diagonals.\n",
        "numpy.oldnumeric.ma.diagonal\n",
        "    \n",
        "numpy.oldnumeric.ma.trace\n",
        "    (defined by the last two dimenions) of the array.\n",
        "numpy.ma.MaskedArray.trace\n",
        "    Return the sum along diagonals of the array.\n",
        "numpy.oldnumeric.mlab.tri\n",
        "    returns a N-by-M array where all the diagonals starting from\n",
        "numpy.oldnumeric.mlab.eye\n",
        "    eye returns a N-by-M 2-d array where the  k-th diagonal is all ones,\n",
        "numpy.einsum\n",
        "    Evaluates the Einstein summation convention on the operands.\n",
        "numpy.select\n",
        "    Return an array drawn from elements in choicelist, depending on conditions.\n",
        "numpy.compress\n",
        "    Return selected slices of an array along given axis.\n",
        "numpy.identity\n",
        "    Return the identity array.\n",
        "numpy.ma.mrecords.MaskedRecords.trace\n",
        "    Return the sum along diagonals of the array.\n",
        "numpy.mask_indices\n",
        "    Return the indices to access (n, n) arrays, given a masking function.\n",
        "numpy.triu_indices\n",
        "    Return the indices for the upper-triangle of an (n, n) array.\n",
        "numpy.tril_indices\n",
        "    Return the indices for the lower-triangle of an (n, n) array.\n",
        "numpy.ma.trace\n",
        "    a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)\n",
        "numpy.linalg.qr\n",
        "    Compute the qr factorization of a matrix.\n",
        "numpy.linalg.pinv\n",
        "    Compute the (Moore-Penrose) pseudo-inverse of a matrix.\n",
        "numpy.ma.identity\n",
        "    Return the identity array.\n",
        "numpy.tril_indices_from\n",
        "    Return the indices for the lower-triangle of arr.\n",
        "numpy.triu_indices_from\n",
        "    Return the indices for the upper-triangle of an (n, n) array.\n",
        "numpy.linalg.eigvals\n",
        "    Compute the eigenvalues of a general matrix.\n",
        "numpy.matlib.identity\n",
        "    Returns the square identity matrix of given size.\n",
        "numpy.ma.tests.test_subclassing.MMatrix.trace\n",
        "    Return the sum along diagonals of the array.\n",
        "numpy.ma.tests.test_subclassing.MSubArray.trace\n",
        "    Return the sum along diagonals of the array."
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "<p align=\"center\">Tutorial: Einf\u00fchrung in NumPy von Henning Dickten und Christian Geier, PyCon.DE 2013</p>\n",
      "<p align=\"center\"><a rel=\"license\" href=\"http://creativecommons.org/licenses/by-nc-sa/3.0/deed.de\"><img alt=\"Creative Commons Lizenzvertrag\" style=\"border-width:0\" src=\"http://i.creativecommons.org/l/by-nc-sa/3.0/88x31.png\"/></a></p>\n",
      "\n",
      "<p align=\"center\">Dieses Werk bzw. Inhalt ist lizenziert unter einer <a rel=\"license\" href=\"http://creativecommons.org/licenses/by-nc-sa/3.0/deed.de\">Creative Commons Namensnennung - Nicht-kommerziell - Weitergabe unter gleichen Bedingungen 3.0 Unported Lizenz</a>.</p>\n",
      "\n"
     ]
    }
   ],
   "metadata": {}
  }
 ]
}