{ "cells": [ { "cell_type": "markdown", "metadata": { "hideCode": false, "hidePrompt": false }, "source": [ "# NumPy: creating and manipulating numerical data " ] }, { "cell_type": "markdown", "metadata": { "hideCode": false, "hidePrompt": false }, "source": [ "## Section 1: What is NumPy and numpy arrays\n", "\n", "**Python:** - has built-in\n", "- containers (costless insertion and append), dictionnaries (fast lookup)\n", "- high-level number objects (integers, floating points)\n", "\n", "**NumPy** is:\n", "- extension package to Python to multidimensional arrays\n", "- faster (as you'll see below)\n", "- convenient and tested by scientific community" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [], "source": [ "import numpy as np" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3])" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = np.array([0,1,2,3])\n", "a" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "319 µs ± 10.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n" ] } ], "source": [ "l = range(1000)\n", "\n", "%timeit [i**2 for i in l]" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1.04 µs ± 39 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n" ] } ], "source": [ "a = np.arange(1000)\n", "%timeit a**2" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Help on built-in function array in module numpy:\n", "\n", "array(...)\n", " array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0)\n", " \n", " Create an array.\n", " \n", " Parameters\n", " ----------\n", " object : array_like\n", " An array, any object exposing the array interface, an object whose\n", " __array__ method returns an array, or any (nested) sequence.\n", " dtype : data-type, optional\n", " The desired data-type for the array. If not given, then the type will\n", " be determined as the minimum type required to hold the objects in the\n", " sequence.\n", " copy : bool, optional\n", " If true (default), then the object is copied. Otherwise, a copy will\n", " only be made if __array__ returns a copy, if obj is a nested sequence,\n", " or if a copy is needed to satisfy any of the other requirements\n", " (`dtype`, `order`, etc.).\n", " order : {'K', 'A', 'C', 'F'}, optional\n", " Specify the memory layout of the array. If object is not an array, the\n", " newly created array will be in C order (row major) unless 'F' is\n", " specified, in which case it will be in Fortran order (column major).\n", " If object is an array the following holds.\n", " \n", " ===== ========= ===================================================\n", " order no copy copy=True\n", " ===== ========= ===================================================\n", " 'K' unchanged F & C order preserved, otherwise most similar order\n", " 'A' unchanged F order if input is F and not C, otherwise C order\n", " 'C' C order C order\n", " 'F' F order F order\n", " ===== ========= ===================================================\n", " \n", " When ``copy=False`` and a copy is made for other reasons, the result is\n", " the same as if ``copy=True``, with some exceptions for `A`, see the\n", " Notes section. The default order is 'K'.\n", " subok : bool, optional\n", " If True, then sub-classes will be passed-through, otherwise\n", " the returned array will be forced to be a base-class array (default).\n", " ndmin : int, optional\n", " Specifies the minimum number of dimensions that the resulting\n", " array should have. Ones will be pre-pended to the shape as\n", " needed to meet this requirement.\n", " \n", " Returns\n", " -------\n", " out : ndarray\n", " An array object satisfying the specified requirements.\n", " \n", " See Also\n", " --------\n", " empty_like : Return an empty array with shape and type of input.\n", " ones_like : Return an array of ones with shape and type of input.\n", " zeros_like : Return an array of zeros with shape and type of input.\n", " full_like : Return a new array with shape of input filled with value.\n", " empty : Return a new uninitialized array.\n", " ones : Return a new array setting values to one.\n", " zeros : Return a new array setting values to zero.\n", " full : Return a new array of given shape filled with value.\n", " \n", " \n", " Notes\n", " -----\n", " When order is 'A' and `object` is an array in neither 'C' nor 'F' order,\n", " and a copy is forced by a change in dtype, then the order of the result is\n", " not necessarily 'C' as expected. This is likely a bug.\n", " \n", " Examples\n", " --------\n", " >>> np.array([1, 2, 3])\n", " array([1, 2, 3])\n", " \n", " Upcasting:\n", " \n", " >>> np.array([1, 2, 3.0])\n", " array([ 1., 2., 3.])\n", " \n", " More than one dimension:\n", " \n", " >>> np.array([[1, 2], [3, 4]])\n", " array([[1, 2],\n", " [3, 4]])\n", " \n", " Minimum dimensions 2:\n", " \n", " >>> np.array([1, 2, 3], ndmin=2)\n", " array([[1, 2, 3]])\n", " \n", " Type provided:\n", " \n", " >>> np.array([1, 2, 3], dtype=complex)\n", " array([ 1.+0.j, 2.+0.j, 3.+0.j])\n", " \n", " Data-type consisting of more than one element:\n", " \n", " >>> x = np.array([(1,2),(3,4)],dtype=[('a','>> x['a']\n", " array([1, 3])\n", " \n", " Creating an array from sub-classes:\n", " \n", " >>> np.array(np.mat('1 2; 3 4'))\n", " array([[1, 2],\n", " [3, 4]])\n", " \n", " >>> np.array(np.mat('1 2; 3 4'), subok=True)\n", " matrix([[1, 2],\n", " [3, 4]])\n", "\n" ] } ], "source": [ "help(np.array)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Search results for 'create array'\n", "---------------------------------\n", "numpy.array\n", " Create an array.\n", "numpy.memmap\n", " Create a memory-map to an array stored in a *binary* file on disk.\n", "numpy.diagflat\n", " Create a two-dimensional array with the flattened input as a diagonal.\n", "numpy.fromiter\n", " Create a new 1-dimensional array from an iterable object.\n", "numpy.partition\n", " Return a partitioned copy of an array.\n", "numpy.ctypeslib.as_array\n", " Create a numpy array from a ctypes array or POINTER.\n", "numpy.ma.diagflat\n", " Create a two-dimensional array with the flattened input as a diagonal.\n", "numpy.ma.make_mask\n", " Create a boolean mask from an array.\n", "numpy.lib.Arrayterator\n", " Buffered iterator for big arrays.\n", "numpy.ctypeslib.as_ctypes\n", " Create and return a ctypes object from a numpy array. Actually\n", "numpy.ma.mrecords.fromarrays\n", " Creates a mrecarray from a (flat) list of masked arrays.\n", "numpy.ma.mvoid.__new__\n", " Create a new masked array from scratch.\n", "numpy.ma.MaskedArray.__new__\n", " Create a new masked array from scratch.\n", "numpy.ma.mrecords.fromtextfile\n", " Creates a mrecarray from data stored in the file `filename`.\n", "numpy.asarray\n", " Convert the input to an array.\n", "numpy.ndarray\n", " ndarray(shape, dtype=float, buffer=None, offset=0,\n", "numpy.recarray\n", " Construct an ndarray that allows field access using attributes.\n", "numpy.chararray\n", " chararray(shape, itemsize=1, unicode=False, buffer=None, offset=0,\n", "numpy.exp\n", " Calculate the exponential of all elements in the input array.\n", "numpy.pad\n", " Pad an array.\n", "numpy.asanyarray\n", " Convert the input to an ndarray, but pass ndarray subclasses through.\n", "numpy.cbrt\n", " Return the cube-root of an array, element-wise.\n", "numpy.copy\n", " Return an array copy of the given object.\n", "numpy.diag\n", " Extract a diagonal or construct a diagonal array.\n", "numpy.exp2\n", " Calculate `2**p` for all `p` in the input array.\n", "numpy.fmax\n", " Element-wise maximum of array elements.\n", "numpy.fmin\n", " Element-wise minimum of array elements.\n", "numpy.load\n", " Load arrays or pickled objects from ``.npy``, ``.npz`` or pickled files.\n", "numpy.modf\n", " Return the fractional and integral parts of an array, element-wise.\n", "numpy.rint\n", " Round elements of the array to the nearest integer.\n", "numpy.sort\n", " Return a sorted copy of an array.\n", "numpy.sqrt\n", " Return the non-negative square-root of an array, element-wise.\n", "numpy.array_equiv\n", " Returns True if input arrays are shape consistent and all elements equal.\n", "numpy.dtype\n", " Create a data type object.\n", "numpy.expm1\n", " Calculate ``exp(x) - 1`` for all elements in the array.\n", "numpy.isnan\n", " Test element-wise for NaN and return result as a boolean array.\n", "numpy.isnat\n", " Test element-wise for NaT (not a time) and return result as a boolean array.\n", "numpy.log10\n", " Return the base 10 logarithm of the input array, element-wise.\n", "numpy.log1p\n", " Return the natural logarithm of one plus the input array, element-wise.\n", "numpy.power\n", " First array elements raised to powers from second array, element-wise.\n", "numpy.ufunc\n", " Functions that operate element by element on whole arrays.\n", "numpy.choose\n", " Construct an array from an index array and a set of arrays to choose from.\n", "numpy.nditer\n", " Efficient multi-dimensional iterator object to iterate over arrays.\n", "numpy.maximum\n", " Element-wise maximum of array elements.\n", "numpy.minimum\n", " Element-wise minimum of array elements.\n", "numpy.swapaxes\n", " Interchange two axes of an array.\n", "numpy.full_like\n", " Return a full array with the same shape and type as a given array.\n", "numpy.ones_like\n", " Return an array of ones with the same shape and type as a given array.\n", "numpy.bitwise_or\n", " Compute the bit-wise OR of two arrays element-wise.\n", "numpy.empty_like\n", " Return a new array with the same shape and type as a given array.\n", "numpy.zeros_like\n", " Return an array of zeros with the same shape and type as a given array.\n", "numpy.asarray_chkfinite\n", " Convert the input to an array, checking for NaNs or Infs.\n", "numpy.bitwise_and\n", " Compute the bit-wise AND of two arrays element-wise.\n", "numpy.bitwise_xor\n", " Compute the bit-wise XOR of two arrays element-wise.\n", "numpy.float_power\n", " First array elements raised to powers from second array, element-wise.\n", "numpy.ma.exp\n", " Calculate the exponential of all elements in the input array.\n", "numpy.diag_indices\n", " Return the indices to access the main diagonal of an array.\n", "numpy.nested_iters\n", " Create nditers for use in nested loops\n", "numpy.ma.sqrt\n", " Return the non-negative square-root of an array, element-wise.\n", "numpy.ma.log10\n", " Return the base 10 logarithm of the input array, element-wise.\n", "numpy.chararray.tolist\n", " a.tolist()\n", "numpy.put_along_axis\n", " Put values into the destination array by matching 1d index and data slices.\n", "numpy.ma.choose\n", " Use an index array to construct a new array from a set of choices.\n", "numpy.ma.maximum\n", " Element-wise maximum of array elements.\n", "numpy.ma.minimum\n", " Element-wise minimum of array elements.\n", "numpy.ma.mrecords.MaskedRecords.__new__\n", " Create a new masked array from scratch.\n", "numpy.savez_compressed\n", " Save several arrays into a single file in compressed ``.npz`` format.\n", "numpy.matlib.rand\n", " Return a matrix of random values with given shape.\n", "numpy.datetime_as_string\n", " Convert an array of datetimes into an array of strings.\n", "numpy.ma.bitwise_or\n", " Compute the bit-wise OR of two arrays element-wise.\n", "numpy.ma.bitwise_and\n", " Compute the bit-wise AND of two arrays element-wise.\n", "numpy.ma.bitwise_xor\n", " Compute the bit-wise XOR of two arrays element-wise.\n", "numpy.ma.make_mask_none\n", " Return a boolean mask of the given shape, filled with False.\n", "numpy.core._multiarray_umath.clip\n", " Clip (limit) the values in an array.\n", "numpy.core.tests.test_overrides._new_duck_type_and_implements\n", " Create a duck array type and implements functions.\n", "numpy.ma.mrecords.fromrecords\n", " Creates a MaskedRecords from a list of records.\n", "numpy.core._multiarray_umath.empty_like\n", " Return a new array with the same shape and type as a given array.\n", "numpy.f2py.tests.test_array_from_pyobj.Array.has_shared_memory\n", " Check that created array shares data with input array.\n", "numpy.core._dtype._construction_repr\n", " Creates a string repr of the dtype, excluding the 'dtype()' part\n", "numpy.abs\n", " Calculate the absolute value element-wise.\n", "numpy.add\n", " Add arguments element-wise.\n", "numpy.cos\n", " Cosine element-wise.\n", "numpy.log\n", " Natural logarithm, element-wise.\n", "numpy.mod\n", " Return element-wise remainder of division.\n", "numpy.lib.recfunctions.require_fields\n", " Casts a structured array to a new dtype using assignment by field-name.\n", "numpy.sin\n", " Trigonometric sine, element-wise.\n", "numpy.tan\n", " Compute tangent element-wise.\n", "numpy.ceil\n", " Return the ceiling of the input, element-wise.\n", "numpy.conj\n", " Return the complex conjugate, element-wise.\n", "numpy.cosh\n", " Hyperbolic cosine, element-wise.\n", "numpy.fabs\n", " Compute the absolute values element-wise.\n", "numpy.fmod\n", " Return the element-wise remainder of division.\n", "numpy.less\n", " Return the truth value of (x1 < x2) element-wise.\n", "numpy.log2\n", " Base-2 logarithm of `x`.\n", "numpy.sign\n", " Returns an element-wise indication of the sign of a number.\n", "numpy.sinh\n", " Hyperbolic sine, element-wise.\n", "numpy.tanh\n", " Compute hyperbolic tangent element-wise.\n", "numpy.equal\n", " Return (x1 == x2) element-wise.\n", "numpy.core._multiarray_umath.datetime_as_string\n", " Convert an array of datetimes into an array of strings.\n", "numpy.floor\n", " Return the floor of the input, element-wise.\n", "numpy.frexp\n", " Decompose the elements of x into mantissa and twos exponent.\n", "numpy.hypot\n", " Given the \"legs\" of a right triangle, return its hypotenuse.\n", "numpy.isinf\n", " Test element-wise for positive or negative infinity.\n", "numpy.ldexp\n", " Returns x1 * 2**x2, element-wise.\n", "numpy.trunc\n", " Return the truncated value of the input, element-wise.\n", "numpy.arccos\n", " Trigonometric inverse cosine, element-wise.\n", "numpy.arcsin\n", " Inverse sine, element-wise.\n", "numpy.arctan\n", " Trigonometric inverse tangent, element-wise.\n", "numpy.around\n", " Evenly round to the given number of decimals.\n", "numpy.divide\n", " Returns a true division of the inputs, element-wise.\n", "numpy.divmod\n", " Return element-wise quotient and remainder simultaneously.\n", "numpy.source\n", " Print or write to a file the source code for a NumPy object.\n", "numpy.square\n", " Return the element-wise square of the input.\n", "numpy.arccosh\n", " Inverse hyperbolic cosine, element-wise.\n", "numpy.arcsinh\n", " Inverse hyperbolic sine element-wise.\n", "numpy.arctan2\n", " Element-wise arc tangent of ``x1/x2`` choosing the quadrant correctly.\n", "numpy.arctanh\n", " Inverse hyperbolic tangent element-wise.\n", "numpy.deg2rad\n", " Convert angles from degrees to radians.\n", "numpy.degrees\n", " Convert angles from radians to degrees.\n", "numpy.greater\n", " Return the truth value of (x1 > x2) element-wise.\n", "numpy.rad2deg\n", " Convert angles from radians to degrees.\n", "numpy.radians\n", " Convert angles from degrees to radians.\n", "numpy.signbit\n", " Returns element-wise True where signbit is set (less than zero).\n", "numpy.spacing\n", " Return the distance between x and the nearest adjacent number.\n", "numpy.copysign\n", " Change the sign of x1 to that of x2, element-wise.\n", "numpy.diagonal\n", " Return specified diagonals.\n", "numpy.isfinite\n", " Test element-wise for finiteness (not infinity or not Not a Number).\n", "numpy.multiply\n", " Multiply arguments element-wise.\n", "numpy.negative\n", " Numerical negative, element-wise.\n", "numpy.subtract\n", " Subtract arguments, element-wise.\n", "numpy.heaviside\n", " Compute the Heaviside step function.\n", "numpy.logaddexp\n", " Logarithm of the sum of exponentiations of the inputs.\n", "numpy.nextafter\n", " Return the next floating-point value after x1 towards x2, element-wise.\n", "numpy.not_equal\n", " Return (x1 != x2) element-wise.\n", "numpy.left_shift\n", " Shift the bits of an integer to the left.\n", "numpy.less_equal\n", " Return the truth value of (x1 =< x2) element-wise.\n", "numpy.logaddexp2\n", " Logarithm of the sum of exponentiations of the inputs in base-2.\n", "numpy.logical_or\n", " Compute the truth value of x1 OR x2 element-wise.\n", "numpy.nan_to_num\n", " Replace NaN with zero and infinity with large finite numbers (default\n", "numpy.reciprocal\n", " Return the reciprocal of the argument, element-wise.\n", "numpy.bitwise_not\n", " Compute bit-wise inversion, or bit-wise NOT, element-wise.\n", "numpy.einsum_path\n", " Evaluates the lowest cost contraction order for an einsum expression by\n", "numpy.histogram2d\n", " Compute the bi-dimensional histogram of two data samples.\n", "numpy.logical_and\n", " Compute the truth value of x1 AND x2 element-wise.\n", "numpy.logical_not\n", " Compute the truth value of NOT x element-wise.\n", "numpy.logical_xor\n", " Compute the truth value of x1 XOR x2, element-wise.\n", "numpy.right_shift\n", " Shift the bits of an integer to the right.\n", "numpy.ma.abs\n", " Calculate the absolute value element-wise.\n", "numpy.ma.add\n", " Add arguments element-wise.\n", "numpy.ma.cos\n", " Cosine element-wise.\n", "numpy.ma.log\n", " Natural logarithm, element-wise.\n", "numpy.ma.mod\n", " Return element-wise remainder of division.\n", "numpy.ma.sin\n", " Trigonometric sine, element-wise.\n", "numpy.ma.tan\n", " Compute tangent element-wise.\n", "numpy.floor_divide\n", " Return the largest integer smaller or equal to the division of the inputs.\n", "numpy.ma.ceil\n", " Return the ceiling of the input, element-wise.\n", "numpy.ma.cosh\n", " Hyperbolic cosine, element-wise.\n", "numpy.fft.ifft\n", " Compute the one-dimensional inverse discrete Fourier Transform.\n", "numpy.ma.fabs\n", " Compute the absolute values element-wise.\n", "numpy.ma.fmod\n", " Return the element-wise remainder of division.\n", "numpy.ma.less\n", " Return the truth value of (x1 < x2) element-wise.\n", "numpy.ma.log2\n", " Base-2 logarithm of `x`.\n", "numpy.ma.sinh\n", " Hyperbolic sine, element-wise.\n", "numpy.ma.tanh\n", " Compute hyperbolic tangent element-wise.\n", "numpy.greater_equal\n", " Return the truth value of (x1 >= x2) element-wise.\n", "numpy.fft.ifftn\n", " Compute the N-dimensional inverse discrete Fourier Transform.\n", "numpy.ma.equal\n", " Return (x1 == x2) element-wise.\n", "numpy.ma.floor\n", " Return the floor of the input, element-wise.\n", "numpy.ma.hypot\n", " Given the \"legs\" of a right triangle, return its hypotenuse.\n", "numpy.busdaycalendar\n", " A business day calendar object that efficiently stores information\n", "numpy.ma.arccos\n", " Trigonometric inverse cosine, element-wise.\n", "numpy.ma.arcsin\n", " Inverse sine, element-wise.\n", "numpy.ma.arctan\n", " Trigonometric inverse tangent, element-wise.\n", "numpy.ma.divide\n", " Returns a true division of the inputs, element-wise.\n", "numpy.lib.recfunctions.unstructured_to_structured\n", " Converts and n-D unstructured array into an (n-1)-D structured array.\n", "numpy.ma.arccosh\n", " Inverse hyperbolic cosine, element-wise.\n", "numpy.ma.arcsinh\n", " Inverse hyperbolic sine element-wise.\n", "numpy.ma.arctan2\n", " Element-wise arc tangent of ``x1/x2`` choosing the quadrant correctly.\n", "numpy.ma.arctanh\n", " Inverse hyperbolic tangent element-wise.\n", "numpy.ma.greater\n", " Return the truth value of (x1 > x2) element-wise.\n", "numpy.ma.multiply\n", " Multiply arguments element-wise.\n", "numpy.ma.negative\n", " Numerical negative, element-wise.\n", "numpy.ma.subtract\n", " Subtract arguments, element-wise.\n", "numpy.ma.conjugate\n", " Return the complex conjugate, element-wise.\n", "numpy.ma.not_equal\n", " Return (x1 != x2) element-wise.\n", "numpy.ma.remainder\n", " Return element-wise remainder of division.\n", "numpy.ma.empty_like\n", " empty_like(prototype, dtype=None, order='K', subok=True, shape=None)\n", "numpy.ma.less_equal\n", " Return the truth value of (x1 =< x2) element-wise.\n", "numpy.ma.logical_or\n", " Compute the truth value of x1 OR x2 element-wise.\n", "numpy.ma.logical_and\n", " Compute the truth value of x1 AND x2 element-wise.\n", "numpy.ma.logical_not\n", " Compute the truth value of NOT x element-wise.\n", "numpy.ma.logical_xor\n", " Compute the truth value of x1 XOR x2, element-wise.\n", "numpy.ma.true_divide\n", " Returns a true division of the inputs, element-wise.\n", "numpy.ma.floor_divide\n", " Return the largest integer smaller or equal to the division of the inputs.\n", "numpy.ma.greater_equal\n", " Return the truth value of (x1 >= x2) element-wise.\n", "numpy.core.tests.test_function_base.PhysicalQuantity2\n", " ndarray(shape, dtype=float, buffer=None, offset=0,\n", "numpy.lib.tests.test_stride_tricks.SimpleSubClass\n", " ndarray(shape, dtype=float, buffer=None, offset=0,\n", "numpy.core.tests.test_numeric.TestKeepdims.sub_array\n", " ndarray(shape, dtype=float, buffer=None, offset=0,\n", "numpy.lib.tests.test_stride_tricks.VerySimpleSubClass\n", " ndarray(shape, dtype=float, buffer=None, offset=0,\n", "numpy.core.tests.test_multiarray.TestArrayPriority.Foo\n", " ndarray(shape, dtype=float, buffer=None, offset=0,\n", "numpy.core.tests.test_multiarray.TestArrayPriority.Bar\n", " ndarray(shape, dtype=float, buffer=None, offset=0,\n", "numpy.testing._gen_alignment_data\n", " generator producing data with different alignment and offsets\n", "numpy.random.RandomState.rand\n", " Random values in a given shape." ] } ], "source": [ "np.lookfor('create array')" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Help on function lookfor in module numpy:\n", "\n", "lookfor(what, module=None, import_modules=True, regenerate=False, output=None)\n", " Do a keyword search on docstrings.\n", " \n", " A list of objects that matched the search is displayed,\n", " sorted by relevance. All given keywords need to be found in the\n", " docstring for it to be returned as a result, but the order does\n", " not matter.\n", " \n", " Parameters\n", " ----------\n", " what : str\n", " String containing words to look for.\n", " module : str or list, optional\n", " Name of module(s) whose docstrings to go through.\n", " import_modules : bool, optional\n", " Whether to import sub-modules in packages. Default is True.\n", " regenerate : bool, optional\n", " Whether to re-generate the docstring cache. Default is False.\n", " output : file-like, optional\n", " File-like object to write the output to. If omitted, use a pager.\n", " \n", " See Also\n", " --------\n", " source, info\n", " \n", " Notes\n", " -----\n", " Relevance is determined only roughly, by checking if the keywords occur\n", " in the function name, at the start of a docstring, etc.\n", " \n", " Examples\n", " --------\n", " >>> np.lookfor('binary representation') # doctest: +SKIP\n", " Search results for 'binary representation'\n", " ------------------------------------------\n", " numpy.binary_repr\n", " Return the binary representation of the input number as a string.\n", " numpy.core.setup_common.long_double_representation\n", " Given a binary dump as given by GNU od -b, look for long double\n", " numpy.base_repr\n", " Return a string representation of a number in the given base system.\n", " ...\n", "\n" ] } ], "source": [ "help(np.lookfor)" ] }, { "cell_type": "markdown", "metadata": { "hideCode": false, "hidePrompt": false }, "source": [ "## Creating Arrays\n", "\n", "### 1-Dimensional" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3])" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = np.array([0,1,2,3])\n", "a" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a.ndim" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "(4,)" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a.shape" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "4" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "len(a)" ] }, { "cell_type": "markdown", "metadata": { "hideCode": false, "hidePrompt": false }, "source": [ "### 2-D, 3-D and more " ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([[0, 1, 2],\n", " [3, 4, 5]])" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b = np.array([[0, 1, 2], [3, 4, 5]])\n", "b" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "2" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b.ndim" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "(2, 3)" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b.shape" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "2" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "len(b)" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([[[1],\n", " [2]],\n", "\n", " [[3],\n", " [4]]])" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "c = np.array([[[1], [2]], [[3], [4]]])\n", "c" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "(2, 2, 1)" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "c.shape" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Number of dimensions in array c: 3\n" ] } ], "source": [ "print(\"Number of dimensions in array c: \",c.ndim)" ] }, { "cell_type": "markdown", "metadata": { "hideCode": false, "hidePrompt": false }, "source": [ "### Evenly spaced " ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#Evenly spaced - notice how it always starts with 0 .. (n-1) and not 1!\n", "a = np.arange(10)\n", "a" ] }, { "cell_type": "markdown", "metadata": { "hideCode": false, "hidePrompt": false }, "source": [ "### or, number of points using linspace " ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([0. , 0.125, 0.25 , 0.375, 0.5 , 0.625, 0.75 , 0.875, 1. ])" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# number of points\n", "c = np.linspace(0, 1, 9) # start, end, number of points\n", "c" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([0. , 0.2, 0.4, 0.6, 0.8])" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "d = np.linspace(0, 1, 5, endpoint=False) # meaning it doesn't stop at 1.\n", "d" ] }, { "cell_type": "markdown", "metadata": { "hideCode": false, "hidePrompt": false }, "source": [ "### Common arrays " ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([[1., 1., 1.],\n", " [1., 1., 1.],\n", " [1., 1., 1.]])" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = np.ones((3, 3)) # (3, 3) would be a tuple here\n", "a" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "numpy.ndarray" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(a)" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([[0., 0.],\n", " [0., 0.]])" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b = np.zeros((2 ,2))\n", "b" ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([[1., 0., 0.],\n", " [0., 1., 0.],\n", " [0., 0., 1.]])" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "c = np.eye(3) # An identity matrix\n", "c" ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([[1, 0, 0, 0],\n", " [0, 2, 0, 0],\n", " [0, 0, 3, 0],\n", " [0, 0, 0, 4]])" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "d = np.diag(np.array([1,2,3,4]))\n", "d" ] }, { "cell_type": "markdown", "metadata": { "hideCode": false, "hidePrompt": false }, "source": [ "### Random numbers " ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([0.50755507, 0.0211933 , 0.43352176, 0.44631306])" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "e = np.random.rand(4) # uniform in [0, 1]\n", "e" ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([ 0.65034618, -0.51433646, 0.53942869, 1.52676162])" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "f = np.random.randn(4) #Gaussian\n", "f\n", "# type help(np.random.randn) to understand more" ] }, { "cell_type": "code", "execution_count": 29, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Help on built-in function seed:\n", "\n", "seed(...) method of numpy.random.mtrand.RandomState instance\n", " seed(self, seed=None)\n", " \n", " Reseed a legacy MT19937 BitGenerator\n", " \n", " Notes\n", " -----\n", " This is a convenience, legacy function.\n", " \n", " The best practice is to **not** reseed a BitGenerator, rather to\n", " recreate a new one. This method is here for legacy reasons.\n", " This example demonstrates best practice.\n", " \n", " >>> from numpy.random import MT19937\n", " >>> from numpy.random import RandomState, SeedSequence\n", " >>> rs = RandomState(MT19937(SeedSequence(123456789)))\n", " # Later, you want to restart the stream\n", " >>> rs = RandomState(MT19937(SeedSequence(987654321)))\n", "\n" ] } ], "source": [ "np.random.seed(1234) #setting the random seed\n", "help(np.random.seed)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": { "hideCode": false, "hidePrompt": false }, "source": [ "## Exercise 1\n", "\n", "**Create an array that looks like this:**\n", "\n", "$$x = \n", "\\begin{bmatrix}\n", " 1 & 1 & 1 & 1 \\\\\n", " 1 & 1 & 1 & 1 \\\\\n", " 1 & 1 & 1 & 8 \\\\\n", " 1 & 6 & 1 & 1 \\\\\n", "\\end{bmatrix}\\tag{1}$$ and, \n", "\n", "**another one** that looks like this:\n", "\n", "$$y = \n", "\\begin{bmatrix}\n", " 0. & 0. & 0. & 0. & 0.\\\\\n", " 7. & 0. & 0. & 0. & 0.\\\\\n", " 0. & 8. & 0. & 0. & 0.\\\\\n", " 0. & 0. & 9. & 0. & 0.\\\\\n", " 0. & 0. & 0. & 10. & 0.\\\\\n", " 0. & 0. & 0. & 0. & 11.\\\\\n", "\\end{bmatrix}\\tag{2}$$\n", "\n", "and lastly,\n", "\n", "**create** this simple array\n", "\n", "$$\\begin{bmatrix}\n", " 0. & 0. & 0. & 0. & 0.\\\\\n", " 0. & 0. & 0. & 0. & 0.\\\\\n", " 1. & 0. & 0. & 0. & 0.\\\\\n", " 0. & 1. & 0. & 0. & 0.\\\\\n", " 0. & 0. & 1. & 0. & 0.\\\\\n", " 0. & 0. & 0. & 1. & 0.\\\\\n", "\\end{bmatrix}\\tag{3}$$" ] }, { "cell_type": "code", "execution_count": 30, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Help on function eye in module numpy:\n", "\n", "eye(N, M=None, k=0, dtype=, order='C')\n", " Return a 2-D array with ones on the diagonal and zeros elsewhere.\n", " \n", " Parameters\n", " ----------\n", " N : int\n", " Number of rows in the output.\n", " M : int, optional\n", " Number of columns in the output. If None, defaults to `N`.\n", " k : int, optional\n", " Index of the diagonal: 0 (the default) refers to the main diagonal,\n", " a positive value refers to an upper diagonal, and a negative value\n", " to a lower diagonal.\n", " dtype : data-type, optional\n", " Data-type of the returned array.\n", " order : {'C', 'F'}, optional\n", " Whether the output should be stored in row-major (C-style) or\n", " column-major (Fortran-style) order in memory.\n", " \n", " .. versionadded:: 1.14.0\n", " \n", " Returns\n", " -------\n", " I : ndarray of shape (N,M)\n", " An array where all elements are equal to zero, except for the `k`-th\n", " diagonal, whose values are equal to one.\n", " \n", " See Also\n", " --------\n", " identity : (almost) equivalent function\n", " diag : diagonal 2-D array from a 1-D array specified by the user.\n", " \n", " Examples\n", " --------\n", " >>> np.eye(2, dtype=int)\n", " array([[1, 0],\n", " [0, 1]])\n", " >>> np.eye(3, k=1)\n", " array([[0., 1., 0.],\n", " [0., 0., 1.],\n", " [0., 0., 0.]])\n", "\n", "Help on function diag in module numpy:\n", "\n", "diag(v, k=0)\n", " Extract a diagonal or construct a diagonal array.\n", " \n", " See the more detailed documentation for ``numpy.diagonal`` if you use this\n", " function to extract a diagonal and wish to write to the resulting array;\n", " whether it returns a copy or a view depends on what version of numpy you\n", " are using.\n", " \n", " Parameters\n", " ----------\n", " v : array_like\n", " If `v` is a 2-D array, return a copy of its `k`-th diagonal.\n", " If `v` is a 1-D array, return a 2-D array with `v` on the `k`-th\n", " diagonal.\n", " k : int, optional\n", " Diagonal in question. The default is 0. Use `k>0` for diagonals\n", " above the main diagonal, and `k<0` for diagonals below the main\n", " diagonal.\n", " \n", " Returns\n", " -------\n", " out : ndarray\n", " The extracted diagonal or constructed diagonal array.\n", " \n", " See Also\n", " --------\n", " diagonal : Return specified diagonals.\n", " diagflat : Create a 2-D array with the flattened input as a diagonal.\n", " trace : Sum along diagonals.\n", " triu : Upper triangle of an array.\n", " tril : Lower triangle of an array.\n", " \n", " Examples\n", " --------\n", " >>> x = np.arange(9).reshape((3,3))\n", " >>> x\n", " array([[0, 1, 2],\n", " [3, 4, 5],\n", " [6, 7, 8]])\n", " \n", " >>> np.diag(x)\n", " array([0, 4, 8])\n", " >>> np.diag(x, k=1)\n", " array([1, 5])\n", " >>> np.diag(x, k=-1)\n", " array([3, 7])\n", " \n", " >>> np.diag(np.diag(x))\n", " array([[0, 0, 0],\n", " [0, 4, 0],\n", " [0, 0, 8]])\n", "\n" ] } ], "source": [ "help(np.eye)\n", "help(np.diag)" ] }, { "cell_type": "markdown", "metadata": { "hideCode": false, "hidePrompt": false }, "source": [ "### Basic Data Types " ] }, { "cell_type": "code", "execution_count": 31, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "dtype('int64')" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = np.array([1,2,3])\n", "a.dtype" ] }, { "cell_type": "code", "execution_count": 32, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "dtype('float64')" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b = np.array([1., 2., 3.])\n", "b.dtype" ] }, { "cell_type": "markdown", "metadata": { "hideCode": false, "hidePrompt": false }, "source": [ "### Note: Datatype and performance\n", "\n", "Remember, different datatypes allow us to store data more compactly but most of the time folks as well as the interpreter auto-detects the datatype from input." ] }, { "cell_type": "code", "execution_count": 33, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "dtype('float64')" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Make it explicit\n", "c = np.array([1, 2, 3], dtype=float)\n", "c.dtype" ] }, { "cell_type": "code", "execution_count": 34, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "dtype('float64')" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Default data type is automatically float\n", "a = np.ones((3,3))\n", "a.dtype" ] }, { "cell_type": "markdown", "metadata": { "hideCode": false, "hidePrompt": false }, "source": [ "### More datatypes\n", "\n", "**Complex**\n", "\n", "** Bool **\n", "\n", "** Strings **\n", "\n", "** Integers **" ] }, { "cell_type": "code", "execution_count": 35, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "dtype('complex128')" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Complex\n", "\n", "d = np.array([1+2j, 4+5j, 6+8*1j])\n", "d.dtype" ] }, { "cell_type": "code", "execution_count": 36, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "dtype('bool')" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Bool\n", "e = np.array([True, False, False, True])\n", "e.dtype" ] }, { "cell_type": "code", "execution_count": 37, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "dtype(']" ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "x = np.linspace(0, 3, 20)\n", "y = np.linspace(0, 9, 20)\n", "plt.plot(x, y) # plots a line" ] }, { "cell_type": "code", "execution_count": 40, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 40, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.plot(x, y, 'o')" ] }, { "cell_type": "markdown", "metadata": { "hideCode": false, "hidePrompt": false }, "source": [ "### 2D arrays " ] }, { "cell_type": "code", "execution_count": 41, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 41, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "image = np.random.rand(40, 40)\n", "plt.imshow(image, cmap=plt.cm.Blues)\n", "plt.colorbar()" ] }, { "cell_type": "code", "execution_count": 42, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 42, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD6CAYAAABnLjEDAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO2dfZiVZdW+z/WSH4SRXyC8CKFGGYZSbpI0yyyDTNIsskhDLaVMI4jSjAQKTYtXsswkkZxSFClSKZP4iSZGIhsbRRJFlBQUh0gCzCRx/f7YG2X2fd05zcAw+KzzODhm9sV6PvbH2nv29ax7LXN3giB47fM/2/sEgiBoHSLZg6AgRLIHQUGIZA+CghDJHgQFIZI9CApCi5LdzAaa2cNm9qiZnbe1TioIgq2PNfc6u5m1Ax4BjgFWAAuAT7v7X3LbdDDzPWq0Lvtngp8WWu9dM8EvJcr6hRtlpAltt0M7ZPbbU2jPJoovfEofa08hdskcaieh3Z+J/V+h/UuH1v891foeqg4G0DmVFq5Mtf301g8/nmpvzRyJQ9+Sausf0bGPCe0Q/VrYuDB9IHbuJgK7dNXH+ot44fXWr48nFj6XaD0O1rtV/O0Bre996JtT8aFHdfDbGj8Zy5ev5m9/W69e5i1K9ncDY919QPX2NwDc/bu5bfY183NqtHN/mQm+UGj39c4Ep0/wnaZeIdBOaEf64Zn9Xi20XyXKRhstt975M0L8RuZQnYSWeT0yTmhLdOhe16XaGlfvFgBfThQXf7DZ9XrrIz+danNzfztu+n+pducHdexgoa3Wr4Xlln7W9LxYBJ77LX2svt9JtXr9+jjL5iXaFSv0bhVX7av1M/w3qdjvOB284NpGN0ulb1EuPyaTvSV/xncDntzi9oqqFgRBG+R1LdhWvXskfyaY2ZnAmQC7t+BgQRC0jJZ8sq8Aum9xe18g+fLq7j9195K7l3LfjIMg2Pa05Dv766gYdB8AVlIx6Ia4++LcNq838wNrtE9kYsVXTRb/ORO8QGgZm/DAH6TaEvE1DWCV+FrXRXwPH6xOFpj+cyE+KTSg4zdTbd2NOpbBNwjxokzwfKEtz8SelCj3WOoi9c/5LD9LpUt/q0NHvj7V+vxTxy56txDnpUYpwMlWawEr+xam/lsfi58K7WYdeuLvU+1jmd2e4pNTcf/PZ3acSh3/T4f+seb2p4DF7vI7e7P/jHf3F83sbGAWFd9ryn9K9CAIti8t+c6Ou98K3LqVziUIgm1IVNAFQUGIZA+CghDJHgQFoUXf2f9bereHcm2V5Nd17PlDbkrFm07Qwcem0vAzdegSZc2aKtGCLu+YnorCoc8UQokLkcAzOnSdi0sNx71DB9/8qVTLleFOSK3dvvY7GVpfTrX+Lkpon27Qx/r4OxNp5Lj7dOyYtLb2fabrcLv/KdWevCp13QGUyT5NPLYrTT+2qjhw1HtlKDNcvEYzpYwzLXXej9a7ZaJw3tcpNx9gZeP9the5sJn4ZA+CghDJHgQFIZI9CApCJHsQFIRWNeg4ELirRtstYzwwMpXE2myAhVmHLKVBvL11vlsYccDhYlWhqui8JXewNwrt3NpFvhUWCMNILHQEKrXJtUx2Xf85ztK168pWAkCsOt29lJpxa3NmEccLTa3dhaOFGaeKgAEuX59qZ71Bx04TBuqd4rE9ylXDBBh1b7qu+NbD9LEmW2oYz/AeMnaQi/X7rJKxo5mSin/MFJbfXXN7jQ6D+GQPgsIQyR4EBSGSPQgKQiR7EBSESPYgKAjNbl7RHHqY+VdrtOG6LyTspzpV/CET/CWhfVSHfkOUiuZ2O090uhANHrhSd4b0L6ZapncFPXxsol1lqQZwxgviWLvo/Zpspvk3HfyE6O6qGoPkmmpMOy3VGkRHC4CPpFJ3Ua4LutVGu0yjCz6eSuvEU95RNJ4AGPohcV6ZQ40Xz8PQzPNQpz5WVT9T4HjxMN6cbYp6WaNbpdJnKZf/stUbTgZBsAMRyR4EBSGSPQgKQosq6MxsObAe2AS86O6lrXFSQRBsfVpk0FWTveTuGcenMaVSXy+Xa2syMy7FTWJ03AminhNgnZgkoqc/0UtUby7NLBu/R3iEalqVWF0OwBzvmIqnrdPBw4S2OrNjtaw/9zar9pEbrPMb0bF153Td+F6Zzqxr1CQTtOv2vDAf22fqjjcKrzVj+6GGQg0V05QOz0xTmneHEI8SrXABWSi9q55qUy/MvL65KVwbVY9a4WgC9G68nr30OJSf191l48/4ICgILU12B35vZgurk1+CIGijtHTV2xHu/pSZdQZmm9kSd2+0rm3L8U89evwXy9OCINiqtOiT3d2fqv5sAH4NvEvEvDz+qVOnvVpyuCAIWkCzk93MOpjZGzb/DnwIeHBrnVgQBFuXlsx625/KpzlUvg5MdXc1Vf1l2pl5rVuamxR+jNCuyBj3J34u1dQIc4BThFafmV3WRfQLWJVMmIcl9iO5/YHKjb9Iu/EHiFlvy3KP5vtSafx7dOhoT/7Ygqn36uClQksbxoJwtwGmC5d/sOes/wGptGGiDlUdec/K7HbWiFS7N91vQ6YhRWflPM3Qsd3FNagnMzPZGClqp8nYXIvTy0NHvl2Hzq35Zlx6Bsobt/6st8eAQ5q7fRAErUtceguCghDJHgQFIZI9CApCq65n39XMa9cGD8nEjhPm1BhhYgGMu1iIymwCmCzajz77HR27xzWJ9Ec7NdH+kTnUsX8VYo9cZ1axEHu2HnG0Sqy57vLzzG5PGZRqN82UoUNElaawu+jnot0rQB/R8vWzmfMSj82lP9ahquL3u5/J7Pfa51Ntr/ap9pDefMw+qTY7cyi1wrxdJlYVwPavbe6wmQnKtv6yjr2tcVl56ctQfiTKZYOg0ESyB0FBiGQPgoIQyR4EBSGSPQgKQqu68aXSPl4u13RnnaJLTVVJKD/J7HhC2gW2j31Fhi4SM7fONtFVlXSMFuh3x0wvBxapasjsALf0eTjRpKmKesS65Z7HLmIfqybo2EtGpdq5i0TgLL09VyRKT9Ptg5e7uFzyxV56r1em2lk+XsbW2ehEmyfiJuUuoXQUM+BG6e7Bqitxl0yH3FXqaskpuUtGqrB1mYy8yBo3y/gxsNLDjQ+CQhPJHgQFIZI9CApCJHsQFITWNegOMC9/r0bMlAxuEuWUapw9wDIXJbD1ugT2GNFJdrarMU+gDKflwszr6R/Wmw9N5w7lylpXqfXKmaam08Vy9ME+WAf79FTLGZ1qDJZwH+f8OtUAjlYtX0/dWcbeaWn736O+oPc7SBh0M9Uad4DOwnyUxqO2VcdZ2vL1h5lDrVE9BOZmOiAzLZWOvUqH3npNItWJMm1Imwp/ElgcBl0QFJtI9iAoCJHsQVAQItmDoCC8qkFnZlOA44AGd397VduTiuPQk8r47E+6u5gd1JhSX/Nk+pP2b+j8xlT7bWa//ZS/NlwbJWssHc+TtpCsMFVVwImpVIvUTCigj39NqAdljvb1RLnNGmTkQJ+b2YfAj0w1u0GGTrN0kNVJn1SB788cTFhZt/XRoQPFOSzTg7R6iQaXS/3Ter/trk+1TWKm0/H6PgwVE53qVLUf0NnSir+G+/VpDRPdGnNDpSbKEVSZ9FrWuOdB6QQoL2q+QXcNMLBGOw+43d17AbcjUyAIgrbEqyZ7dcLL32vk44G66u916FGDQRC0IZr7nX0fd38aoPqzcy7QzM40s7KZlVevaebRgiBoMdvcoGs0/immPwXBdqO5yf6MmXUFqP7UTlIQBG2G5k6EuQUYClxc/Xlz047WDvausdkPrLUDKqhunPWZ3fYbvmei9RGuO8Ai0cS1968yOz5OaKIktI/qbgvo0XcflZEThPM+KlcS+njqsN+WuSIw0MVsqxFirhVw0thUe0JoHW5UdjFsInXeO7vqDQuXWadEGz5fhrJUjFTqY8J1BxaJCyBXWOq8516ws0TpdTfhugM0+OOJttL2k7GT3pRqn1fdh4Gh4kJB3Zt0p2G+X3P7nzoMmvDJbmbXA38C3mpmK8zsc1SS/BgzW0plLFv25R4EQdvgVT/Z3XMXNPnAVj6XIAi2IVFBFwQFIZI9CApCq65n39vMa+2pKS4a/AHjLW3yN1rNOwc4Xsw8v1lf+l8sjLD36r2yRlVU/iKV+u2bagALRPPBdbULkKt0FGvMf6FGegPdhHa059ZRpzOVzja9IP1ytYsPiPXhL4r14QBiPfrnr9ahaul8rgT2JGHGTcusfecnYxPpAEu1ZY9mthe106PTtgSAbrup7Ui4VGjaYoTpYvpTr6d07FK/rdHtUukcyuVHYj17EBSZSPYgKAiR7EFQECLZg6AgRLIHQUFo5fFPb/VyeVKN+m0Ze4mlJZnnpsZyhbOuEaKaHwX9RTmjbuUAPdXkooeFlpv/NEh0fG0Q3V6Bhn1SbWJmt9/1tDx4o+my448Ibfb6zI53Swshe1naqmBIZvNxosnEsxnX+91Cy7S5YLroCHz4n3XsPD9GqOklkNPtu3L73kIbJRpPAFD/pBCPkKGn2xOJNqXGSX+F2hwB9tJXUIbVPO0zgNXRXTYIik0kexAUhEj2ICgIkexBUBBa1aBrb+a1Ho6oDARglhjJ9I3MzHU1qbudqscEUKabagILIGZ49xNm3IK3Zbb/o9D20GW8cj277E4L3a12ETM86ZNl7DT7fKLdKiNhnNB6uqrZXSu3XyfKWnOT3AeLsV93inXrAKcKbXlmBJU6YC8xPmqp53q7qt5peoHnOksnv/8rs9cOSsuUTnOy0DKJMq6m++8k4Kkw6IKg2ESyB0FBiGQPgoIQyR4EBaEpPeimmFmDmT24hTbWzFaaWX3137Hb9jSDIGgpTZn19l5gA/DzLWa9jQU2uLvobJCnVOrq5fJpjcWnddniaOE+jnc9la2L/SjRVv1en8O5H0o1XVirSzpFk1DWiXJOAO57V6rV36tjpwntDTp0r2+m2pqfZ87hlOcTqc7ay9Chqhz5LNVQYrHcfpU9kGhpYW+Fnf0hcV76soZyuJdk9jtRzKa77cZUGzhWb3+40OftkjnY4UKbk2nz+2x6GWhq5sFR12CuypzCsTWNU0rPQHljM934zPinIAh2MFrynf1sM3ug+md+pql1EARtheYm+0+AA4C+wNNAphyiZtbb6v/QwT4Igm1Ks5Ld3Z9x903u/hKVrxPiy+nLsa/MeuuUq1oKgmBb06RyWTPrCfxmC4Ou6+YprmY2AjjM3T/1avt5nZnvVqOtFYYZALOUGTdAhk61dE7TEE+NKYCOwpzKNRrt7Acn2iBhQs3MlT3+RWjPZWZuNKSlps+LNe4AYtk4K3N3YqDQlo7QsZeKFfQj54pAVQcMvC9d+975Lh2qbCzhowHQQ3TeJdNomDmpdLbocHu5qyJrYOPoVKt90b4cm/YrGGC6X4EyvRZ8NrPfurTN7/DMOLPLaloQlH4E5RXaoHvViTDV8U9HAXub2QpgDHCUmfUFHFgODHu1/QRBsH1p7vinTDfwIAjaKlFBFwQFIZI9CApCJHsQFIRWbV7xejM/sEbLFdWrsWP3+DU6+LBTE+nETFXqjPlC/GHmJFQDjLTKkzGZstZxwsWds0HHqt4EqoIWYEztwDyAtEcFAO8Usao3AsBhQjtCzBhbmWmk0O2tQrxdx44S8/Em5MqOVVeNQb+RoRvFlZmd/cNp4G2ZAW7qysrumfN6XdpddoZ1l6HnCi1tQVIhvaYBS1Zkgrs1ttRKpVmUy2uieUUQFJlI9iAoCJHsQVAQItmDoCBs//FPA96vg4XPMTtTyqP8tZmuy/XPstS5u8Lfq3es7MMhwj6Z+ku9ec9PJNJlf9Whw9X6+1Myp5U23oV0clOFLygtMzvpAuGQffuaRBpmp8rNrxXac9dlzqteaN/LrAXnIKFdpEOnpkOkFn4mDTvUP6a331W0rc0tJt9VaLo9A5eKh3xkrsx6gTAfF6bGI8BRNftYCKyP7rJBUGwi2YOgIESyB0FBiGQPgoIQyR4EBaF13fh9zcvDG2tDvq5jp/4357VMmI+5+Wuqo+cqXXo5Q5RenvgnEZhxYHvekmr9Mqc13cVAMl7MRHdJlCWWOv8AYjQdfe7O7FY12zhjfardoOuDR4jF0BM9bfBQIZ0XN8Bmy0g1969zZu5fg39DqAcIbaE+rbvSThmrMu2Hu4gLM9MyV0VO8rGJNs5SDWCM+gjepLt1LLF1jW5/Angw3PggKDaR7EFQECLZg6AgNGX8U3czu8PMHjKzxWY2vKrvaWazzWxp9Wf0jg+CNkxTxj91Bbq6+31m9gYqzsYJwKnA3939YjM7D9jD3dWy3Zcp7W9erqlynJJptnq6MDS4XWggu9ZPzSxXHiJa6g2ytLMr6F62nYR20k/1sWTwCc/K0HHivXJMpuR3hCj5zc3haueLEu10S0tKAVSz06NclTNPkdsPsP0SbVauV4AyslZOlqFHW7pY/+jMbtUzqbrWaktWe63HZ2LVFITpws8EmC48zcGu7+8qcX+7qHwAptWYfOcDy5pr0Ln70+5+X/X39VTaN3Sj8hjUVcPqqLwBBEHQRvmvvrNX+8e/A5gP7LO5d3z1Z+etfXJBEGw9mpzsZrYb8CvgK+6+7tXit9julfFPmT9xgiDY9jQp2c1sJyqJfp27z6jKz1S/z2/+Xt+gtm00/inTqy0Igm1PUww6o/Kd/O/u/pUt9O8Da7Yw6PZ090w9XIXS/5iXd64Rv5wJ/ofQZmVi02IsnlXbA3uokUq9MvtVa65vE9oRmbKp74sSq5/p0NtEI8uBshoMxlhqI41Ta9wBPpfRFaJh5BDRcHKqZwaLjxBDji7IHEu1AMiNB12i2o9mytpG75Rq4mnonvngeVI+5nrt/EpLfbBu/kW946lihlXOVVVz3y/Xa/1nWuO57yOBpRmD7lUnwgBHUGmjsMjMNr/8z6fip95oZp8DngBydZFBELQBmjL+6W5AvlMAH9i6pxMEwbYiKuiCoCBEsgdBQYhkD4KC0Lrr2Tual2s7as45Qwc/IFp6ZsYDDXsp1SZlRhSxUji79XrQvbQcxZilXmpeD7DUxWry6cItBhis3FZdh/uspee7hyxrBela3ztWh5aFdtblqXbY2XLzGWLk1ol+jD7W42LteqbJb0cx+midKAMG4Jq0FLjjaWL7TJk24qWwKHNFo496yFWJNMB7hHbOtzLBjwpNzS0DRjd240tXQ/npWM8eBIUmkj0ICkIkexAUhEj2ICgIrWvQifXs2cXCE4V2fo9M8GKhHaFDb3ggkUZlzJoJYqz3PWKdfG6O+kRPz/ed9oSMVe0E78x4MrLk9j4dukSYZrlhV2oClSiAJWOpsszTOs8GmydjO7sw/vhVZs/KqMw047wy7TT6iKhgfYvfJDc/yNKV2rkacDXnvt2bMsHLRafSy94tQy8SvTTPz/VMOOOORjdLpWGUyw+HQRcERSaSPQgKQiR7EBSESPYgKAiR7EFQEFrVje9k5rXm+2TX3VZHiG6rE32Q3vEDM1NNOOkAV4lmDGcI17zCR1JpuGhCMCOVADqLMs9cleZlwsmml3ay14hqSnG3AOizWoh7Z57zC4SJ++20K8bozOil8S66MTwxSh/rQ0Jbopt1TBPNOk66UO+22zdTbeXrU22Tag0LHCu0v+pQ1CSwXTOx7VXptKxPhtMtdemnnJnZ8crGN0t3Q3ltlMsGQaGJZA+CghDJHgQFoSXjn8aa2Uozq6/+U193giBoI7Rk/NMngQ3uypXRlHYyL+9VI65SnUOBz4uFxZNza7bVoKbv6dCj0wLQw+8QccA8YSJdJmpKMyvUUd5YrvSyvd+Qin0+JWPHPZhqY7y2bW+Fg2xjoqkGu6CNqGVqqf9n9Pbjxbrx0TljaazQumaGMg0/LtUue1LHju6eSB2FmbcuY+Aiyl2HX6lDL/tDqp2eaXo7Ra1nn6vN6dOFOa0aHQPUPusPAhua2122Ou1l8+SX9Wa2efxTEAQ7EC0Z/wRwtpk9YGZTYoprELRtWjL+6SfAAUBfKp/8ssV/o/FPon1UEAStQ7PHP7n7M+6+yd1fAq4C5HzhRuOfwvsPgu1GU9x4A64GHnL3S7fQu24R9jEq3kAQBG2Uprjx7wHmAouAzX+In0+l8rMv4MByYNjmEc453mjmtS0lbvWMLTpTdIkY9BYZeqQ9kmhzPePWqlYTMzMlnYPEYLdOA1Mt48DynVS6p7cO7X+/EDMloUw7OJGusrQpB8AZLt7Pj8x8n1outCdTh3y4CXccUEN6p4hSVQC+JLTvqQJUeEKUj34hs9tbfYFQpyZKN1PdUfRTOdX1ZLNhNj3RJmXG/jE3lZb8VoeqazD1nrlkVHMNpVQaS7n8eLPd+Nz4p1tfbdsgCNoO8S06CApCJHsQFIRI9iAoCK3bXfYd5uU5NWJmig8fE9qajP/X0DXVztGhK29MtZGZU5gmTL65lpZjCu8FgNrKYIBhrvrIAsxKpZN191HE9KV1mVD1MNTlrpuItrPdRHvZlZlyWXWH636oQ88S2nPy4i1wYCod9XMdeqfoeTDd0n4HuQ65lwmtLhM7x8WLtOHXMnaGqFFOV+lXWJA2yAUxLQuAXRrfLH0QyvWxnj0ICk0kexAUhEj2ICgIkexBUBAi2YOgILxqBd3W5Jl6mLBnY22UaroJsEbY9MOE6w4gmrB2yTjOqz6batPO07HDhPM+6c9p3Onv0NsvfbtSh+rgA1M7/ZiHdejq61ItN2LsZnVVI/OYD1DOu6t+uH+U26s5dnqiGjy3ixB7ZYKXptKdqqkGcLxw3m8W3UXOyTwGQ8UVgaHz1Vw6UA1Sbsp0BjlRdLM9JFdK3CeVDtpXhy6uvdqhhvNViU/2ICgIkexBUBAi2YOgIESyB0FBaFWDbjegtslmfaY160ThUtR5xig5PK0fXZVb/ntU2qH2HtPBclTTkam09M2ZYy1SnXNFS1KAN6TSksxu+wlNNS8FmCaqN0+aoVw7mOVpl97ulq4cfzLTuPc+F/W2ve7SwaIh8IIf69B+d4vNM3d4lhwR9o9EGWWZ8xqnRG1IMiA1JE9Ip2UBcKIw42bkmiVPSxs2L/57pufCLTW312b2SXyyB0FhiGQPgoIQyR4EBaEpDSd3NbN7zez+6vincVV9PzObb2ZLzWyamemRJEEQtAma0nDSgA7uvqHaUvpuYDiVZeAz3P0GM7sSuN/dxfDyV+hu5iNqtIwnw7LrhfiYjj1RzOSekamQGi8Mwdpz2kwHMZ6d4UJbl9nBx9O16wtMB/f7pBAvyOxXDdz6WWcZusgaEq1PpmJwhmiWeGJJBC7QztLxwuj8hD4Up3jaNJNLdNNMzlWG4hWZPf9LaMK1ukCXPQ4QTUJn5ao8lVGpR8zLXgEjhPEIMFHOcs9lSuMGDaXS/ZTLG5q3nt0rbKje3Kn6z4GjgV9W9Toq89+CIGijNHVIRDszqwcaqPTMWAasdfcXqyEriPlvQdCmaVKyVye/9AX2pTL5RTXOkd8Hthz/9FzzzzMIghbyX7nx7r4WuBPoD+xuZpuLcvYFnsps8/L4pw4tOdMgCFpEU9z4Tma2e/X39sAHgYeAO3jFfxkK3LytTjIIgpbTFDf+YCoGXDsqbw43uvu3zWx/4AZgT+DPwMnu/sJ/2ldpF/NyzZL0SX/VsYcJre8vhQjcJCzfE1y3Ku1s9yZag3LdAdLpPvqKQM6aFNOjPFNaqy4+DHE97ooN6bgrUREKQE+xDvr7OpTB6q3/0lQ65it6+9OENsSPyRxNlQ33l5H1orS1r+8vY+ssfYJUW4FD/Yv6tMQFpYbMR2JnNepJ1ljDANFwQP4pDCzyr6XizMyzNuhbjW6WSpMpl59q9vinB6jMZK/VHyMzuTUIgrZHVNAFQUGIZA+CghDJHgQFoVXHP3U081rjbbbr+sJelg7HWeoPydhfWHrZ/xTPlOp32Zhq7XToTOGgDBINKy/KjCISk6YQ/SoBMNUoMDdm6dZ0ZvrozMz08auFuPe3hAinW1orOsXVyK0DMieWPhAHmC6YvUFo/eRadJgrmkiq8VGg56ur56EhY34+Z6n52UHNuAf6WjrnXrQlAGCuKg9up8uDB6e7Zfr/ZnZc03y0NAzKD8f4pyAoNJHsQVAQItmDoCBEsgdBQYhkD4KC0KrdZd/SHmbXmKCXCdcdYKlqmvCiWmynS01POU247gCrVFHnT2XooJlpp4sFH03jMlOaeFJouek8e50qxEN07AHCeX9jZr+TO6Xaqs+KDg3AyUrsJ0ZuLVAOPcDxiSImVVV2OzbVLhWuO8BI4WR3Me1kX+6nJNr77BdpYF9Rcgx0EC+x44XrDlDv1ybacJOPIvD1RNn9JR2r+qOwMr1fAI/U3DfVumMz8ckeBAUhkj0ICkIkexAUhEj2ICgIrWrQ0bsTlBuXTw6XBY4AG4SmF7/f6ssTbaYyZYBBPxPi9MwMqsHPJlK/6/ZItLpcKaN6K1UToYCLhGd2/s3p8QHeenF6DrdmSjo5OzWXFmYala6UB1PiYr2D76e9Avr78zq2d/tEGrmfDuWm1IybLcwxgP7CILtHdB8ecaE+1ERRXtxJmJwAHcWx1n1Vx3YWsWszsQf+X6qty7yeJ3pjw3nXUu08qFeIT/YgKAiR7EFQECLZg6AgtGT80zVm9riZ1Vf/9d32pxsEQXNpikH3AnD0luOfzOx31f/7mrtn2kAGQdCWaErDSecVa3zL8U/N4DlgYSNlsenxcAftLUTdUJQuqQnMKtWxAFDFrVPVnDVgyD6p6y0vHmTM/AZRK3pG5qxu/n2qDTdxfCpzt2pRjRQA6sV78aGXT5Ox11vaTveUa0Wji6EflNsPFU08/vn11HUH+LDQTvcfyFgOF+1sD9GlpveoumEx1k257gCIQ032dGYfwGREW+LxqngbGtR8ve76FNYLbWLmqsbh1vjxXaJ3CTRz/JO7z6/+14Vm9oCZTTSzXZqyryAItg/NGv9kZm+nMq/yQKAfld7x56pttxz/tHr1iyokCIJWoLnjnwa6+9PVCa8vAD8j00N+y/FPnTq1bg1PEASv0NzxT0vMrGtVMyozUR7clicaBEHLaMpHbVegzsy2HCmd254AAAXFSURBVP/0GzObY2adAAPqgS807XB7NVJ+mIl8/d9S7RKhAVyltIzpdsaF8xJtSGb804Dfptos0T700qv19iPFfkeJfQLs/qFUW5szrHZOXaRRYsxTBWXZzJKRE0RZqewkW3eT3L7uKTEH6/36rLqLY803PVdq0j5C3O9jesd9fp1q6qJwWW/OmUrcVYZ2sNSMuyez2z5ibNiAjOG88ktKrZOx83xpo9ulUuZxoWXjn5QpHARBGyUq6IKgIESyB0FBiGQPgoIQyR4EBaF1L3z/ex2s/F0jaZLvKUPXieFn2kOGQfNTbXjtULnN/CGVuohSVYBVokzycluXaCNddawFuD1R5tgTMnKtT0i0ARl3+lihDV+hz2CMjU60TM8EOl6caqPs1ESb4D3k9j1FY461mWYd9Wp76UIDA5SYeYIvSN34Lm9Ow1Y9mjnWAenzAOfLUHVNoo+YBQhwsnDeZ2VmBHJ4Kh1p+mLX3NrGKbkyYOKTPQgKQyR7EBSESPYgKAiR7EFQEKyyXL11KHUyL9dOCJr8Xhk7yO5KtJmipBTQC7wzRsVFonPn+Zluq5zVW4hpZ9U+ZnJzNYpn6ZczxxJrro/O+H5znkq1kzIdbpWNNdIzdZpHpjWdj9ydhr0l9xGxKTVbxwujFfRorEmf0bvdS/QFeDxzCv9W2yvTLDMn6TnRB2Fy5ljqPkzQk7VATbaaf04m+Aih5RzFxg9aqfRRyuUH5AsyPtmDoCBEsgdBQYhkD4KCEMkeBAUhkj0ICkKruvE9zLy2VHP4PzLBk4SmewiA6iSbaV7RX7jhf8nsdp1qojr7YCFepHfw7HGJNFRXB1OnTOtcfbBqUbteXTmAQZbeu5m52XSi5HYv8XGwxm/T279vYCL1Ty+qAHCPmNV2spiHBnCtX5lol2fKR892UZ87JH0iN+kmsLIw9pLca7TjpxNpuWhoAdDTxeWhAZkhcqKD8dmysUg6/XAusNY93PggKDKR7EFQECLZg6AgRLIHQUFoVYPOzFbziqewN5DpF7tDE/drx+O1dN/e5O7S+WvVZG90YLOyu5e2y8G3IXG/djxey/dtS+LP+CAoCJHsQVAQtmey/3Q7HntbEvdrx+O1fN9eZrt9Zw+CoHWJP+ODoCC0erKb2UAze9jMHjWz81r7+FsTM5tiZg1m9uAW2p5mNtvMllZ/7rE9z7E5mFl3M7vDzB4ys8VmNryq79D3zcx2NbN7zez+6v0aV9X3M7P51fs1zcx23t7nui1o1WSvToL9MfBhoDfwaTPTKzh2DK4Bald/nAfc7u69qDSO3xHf0F4EvurubwP6A1+qPk87+n17ATja3Q+hMtt1oJn1By4BJlbv17PA57bjOW4zWvuT/V3Ao+7+mLtvBG4AarvS7TC4+11A7Xq143llvm4dldn1OxTu/rS731f9fT3wENCNHfy+eYUN1Zs7Vf85lS6Gv6zqO9z9aiqtnezdaNynb0VVey2xj7s/DZWkATpv5/NpEWbWk0o7zPm8Bu6bmbUzs3qgAZgNLAPWuvuL1ZDX4msSaP1kV+ts43JAG8XMdgN+BXzF3dO5Vzsg7r7J3fsC+1L5S/NtKqx1z6p1aO1kXwF03+L2voBojLxD84yZdQWo/mzYzufTLMxsJyqJfp27z6jKr4n7BuDua4E7qXgSu5vZ5rmHr8XXJND6yb4A6FV1P3cGPgXc0srnsK25BRha/X0ocPN2PJdmYWYGXA085O6XbvFfO/R9M7NOZrZ79ff2wAep+BF3AJ+ohu1w96uptHpRjZkdC/wAaAdMcfcLW/UEtiJmdj1wFJVVU88AY6gM97wR6AE8AQx2dz0poY1iZu+h0uFoEfBSVT6fyvf2Hfa+mdnBVAy4dlQ+6G5092+b2f5UzOI9gT8DJ7v7C9vvTLcNUUEXBAUhKuiCoCBEsgdBQYhkD4KCEMkeBAUhkj0ICkIkexAUhEj2ICgIkexBUBD+P7urV3914sObAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# or...\n", "plt.imshow(image, cmap=plt.cm.hot)" ] }, { "cell_type": "markdown", "metadata": { "hideCode": false, "hidePrompt": false }, "source": [ "## Indexing and Slicing \n", "\n", "- In 2D, the first dimension corresponds to rows, the second to columns.\n", "- for multidimensional a, a[0] is interpreted by taking all elements in the unspecified dimensions." ] }, { "cell_type": "code", "execution_count": 43, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])" ] }, "execution_count": 43, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = np.arange(10)\n", "a # indexing begins at 0 , unlike fortran or " ] }, { "cell_type": "code", "execution_count": 44, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([[0, 0, 0],\n", " [0, 1, 0],\n", " [0, 0, 2]])" ] }, "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# For multi-dimensional arrays, indexing are tuples of integers\n", "a = np.diag(np.arange(3))\n", "a" ] }, { "cell_type": "code", "execution_count": 45, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 45, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a[1,1]" ] }, { "cell_type": "code", "execution_count": 46, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 0])" ] }, "execution_count": 46, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a[1]" ] }, { "cell_type": "code", "execution_count": 47, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [], "source": [ "a[2, 1] = 10 # replaces row 3, second value" ] }, { "cell_type": "code", "execution_count": 48, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 0, 0, 0],\n", " [ 0, 1, 0],\n", " [ 0, 10, 2]])" ] }, "execution_count": 48, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a" ] }, { "cell_type": "code", "execution_count": 49, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])" ] }, "execution_count": 49, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Slicing\n", "a = np.arange(10)\n", "a" ] }, { "cell_type": "code", "execution_count": 50, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([2, 5, 8])" ] }, "execution_count": 50, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a[2:9:3] # [start:end:step]" ] }, { "cell_type": "code", "execution_count": 51, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3])" ] }, "execution_count": 51, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a[:4] # note: last index isn't included" ] }, { "cell_type": "code", "execution_count": 52, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [], "source": [ "# all three slice components are not required" ] }, { "cell_type": "markdown", "metadata": { "hideCode": false, "hidePrompt": false }, "source": [ "### An illustration of Numpy indexing and splicing\n", "\n", "" ] }, { "cell_type": "code", "execution_count": 53, "metadata": { "hideCode": false, "hidePrompt": false, "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Answer to above questions is: \n" ] }, { "data": { "text/plain": [ "array([[ 0, 1, 2, 3, 4, 5],\n", " [10, 11, 12, 13, 14, 15],\n", " [20, 21, 22, 23, 24, 25],\n", " [30, 31, 32, 33, 34, 35],\n", " [40, 41, 42, 43, 44, 45],\n", " [50, 51, 52, 53, 54, 55]])" ] }, "execution_count": 53, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = np.arange(6) + np.arange(0, 51, 10)[:, np.newaxis]\n", "print(\"Answer to above questions is: \")\n", "a" ] }, { "cell_type": "code", "execution_count": 54, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Orange is: [3 4]\n" ] } ], "source": [ "print(\"Orange is: \", a[0, 3:5])\n", "# Try similarly others to get more answers and play with this array a bit more" ] }, { "cell_type": "code", "execution_count": 55, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([[4, 0, 0, 0],\n", " [0, 4, 0, 0],\n", " [0, 0, 4, 0],\n", " [0, 0, 0, 4]])" ] }, "execution_count": 55, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.diag(np.tile(4,4))" ] }, { "cell_type": "code", "execution_count": 56, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2])" ] }, "execution_count": 56, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x = np.array([0, 1, 2])\n", "np.tile(x, 4)" ] }, { "cell_type": "code", "execution_count": 57, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([[1, 2, 1, 2, 1, 2],\n", " [3, 4, 3, 4, 3, 4]])" ] }, "execution_count": 57, "metadata": {}, "output_type": "execute_result" } ], "source": [ "y = np.array([[1,2], [3,4]])\n", "np.tile(y, 3)" ] }, { "cell_type": "markdown", "metadata": { "hideCode": false, "hidePrompt": false }, "source": [ "### Solve this puzzel to arrive to the following answer:\n", "\n", "$$x = \n", "\\begin{bmatrix}\n", " 4 & 5 & 4 & 5 & 4 & 5 \\\\\n", " 6 & 7 & 6 & 7 & 6 & 7 \\\\\n", " 4 & 5 & 4 & 5 & 4 & 5 \\\\\n", " 6 & 7 & 6 & 7 & 6 & 7 \\\\\n", "\\end{bmatrix}\\tag{1}$$\n", "\n", "**Hint**: play with np.tile()\n", "\n", "##### I will publish a full solution page later..." ] }, { "cell_type": "markdown", "metadata": { "hideCode": false, "hidePrompt": false }, "source": [ "## Copies and views\n", "\n", "A slicing operation creates a view on the original array, which is just a way of accessing array data. Thus the original array is not copied in memory. You can use `np.may_share_memory()` to check if two arrays share the same memory block. Note however, that this uses heuristics and may give you false positives." ] }, { "cell_type": "code", "execution_count": 58, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])" ] }, "execution_count": 58, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = np.arange(10)\n", "a # you get the range from 0 to 9 - total of 10" ] }, { "cell_type": "code", "execution_count": 59, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([0, 2, 4, 6, 8])" ] }, "execution_count": 59, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b = a[::2]\n", "b # you get every 3rd object, as 0,1 -->2, 2,2 -->4 and so on" ] }, { "cell_type": "code", "execution_count": 60, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 60, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.may_share_memory(a, b)" ] }, { "cell_type": "code", "execution_count": 61, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([12, 2, 4, 6, 8])" ] }, "execution_count": 61, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b[0] = 12 #we replace 0 with 12\n", "b" ] }, { "cell_type": "code", "execution_count": 62, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([12, 1, 2, 3, 4, 5, 6, 7, 8, 9])" ] }, "execution_count": 62, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# So what is a then?\n", "a" ] }, { "cell_type": "code", "execution_count": 63, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])" ] }, "execution_count": 63, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Let's rearrange\n", "a = np.arange(10)\n", "c = a[::2].copy() # we force copy\n", "c[0] = 12\n", "a" ] }, { "cell_type": "markdown", "metadata": { "hideCode": false, "hidePrompt": false }, "source": [ "#### So, what happened?\n", "\n", "Let's do it step by step" ] }, { "cell_type": "code", "execution_count": 64, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])" ] }, "execution_count": 64, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = np.arange(10)\n", "a" ] }, { "cell_type": "code", "execution_count": 65, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([0, 2, 4, 6, 8])" ] }, "execution_count": 65, "metadata": {}, "output_type": "execute_result" } ], "source": [ "c = a[::2].copy()\n", "c" ] }, { "cell_type": "code", "execution_count": 66, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([12, 2, 4, 6, 8])" ] }, "execution_count": 66, "metadata": {}, "output_type": "execute_result" } ], "source": [ "c[0] = 12\n", "c" ] }, { "cell_type": "code", "execution_count": 67, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])" ] }, "execution_count": 67, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a" ] }, { "cell_type": "markdown", "metadata": { "hideCode": false, "hidePrompt": false }, "source": [ "#### They simply didnt share the same memory block and thus giving you a false positive!\n" ] }, { "cell_type": "code", "execution_count": 68, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 68, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.may_share_memory(a, c)" ] }, { "cell_type": "markdown", "metadata": { "hideCode": false, "hidePrompt": false }, "source": [ "## Fancy Indexing\n", "\n", "NumPy arrays can be indexed with slices, but also with boolean or integer arrays **(masks)**. This method is called fancy indexing. It creates copies **not** views." ] }, { "cell_type": "code", "execution_count": 69, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([10, 3, 8, 0, 19, 10, 11, 9, 10, 6, 0, 12, 7, 14, 17])" ] }, "execution_count": 69, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.random.seed(3)\n", "a = np.random.randint(0, 20, 15)\n", "a" ] }, { "cell_type": "code", "execution_count": 70, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([False, True, False, True, False, False, False, True, False,\n", " True, True, True, False, False, False])" ] }, "execution_count": 70, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(a % 3 ==0)" ] }, { "cell_type": "code", "execution_count": 71, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([ 3, 0, 9, 6, 0, 12])" ] }, "execution_count": 71, "metadata": {}, "output_type": "execute_result" } ], "source": [ "mask = (a % 3 == 0)\n", "get_from_a = a[mask]\n", "get_from_a # you extract a sub-array from mask" ] }, { "cell_type": "code", "execution_count": 72, "metadata": { "hideCode": false, "hideOutput": true, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([10, -1, 8, -1, 19, 10, 11, -1, 10, -1, -1, -1, 7, 14, 17])" ] }, "execution_count": 72, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Indexing with mask can be fun to assign a new value to a sub-array\n", "a[a % 3 == 0] = -1\n", "a" ] }, { "cell_type": "markdown", "metadata": { "hideCode": false, "hidePrompt": false }, "source": [ "## Indexing with array of integers " ] }, { "cell_type": "code", "execution_count": 73, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [], "source": [ "a = np.arange(10)\n", "idx = np.array([[3,4], [6,7]])" ] }, { "cell_type": "code", "execution_count": 74, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(2, 2)" ] }, "execution_count": 74, "metadata": {}, "output_type": "execute_result" } ], "source": [ "idx.shape" ] }, { "cell_type": "code", "execution_count": 75, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[3, 4],\n", " [6, 7]])" ] }, "execution_count": 75, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a[idx]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Here's another fun exercise to play with...\n", "\n", "This image shows various ways to index, play with these and come back with your own results 👇\n", "\n", "\n", "\n", "and your little exercise could be:\n", "\n", "### Exercise 2 : Reproduce this fancy index" ] }, { "cell_type": "markdown", "metadata": { "hideCode": false, "hideOutput": true, "hidePrompt": false }, "source": [ "# SOLUTIONS\n", "\n", "## Exercise 1, Solutions 1, 2, 3\n", "\n", "**Hint**: use help(np.diag) for info.\n", "\n", "and also try out some more yourself!\n", "\n", "**NOTE**: As this Numpy lecture expands, the exercise portion will expand too and the solutions will be provided in another ipynb notebook later" ] }, { "cell_type": "markdown", "metadata": { "hideCode": false, "hidePrompt": false }, "source": [ "### --------------------------------------------------------------------------------------------------------------###\n", "# Solutions and explanations to exercises \n", "### --------------------------------------------------------------------------------------------------------------###" ] }, { "cell_type": "markdown", "metadata": { "hideCode": false, "hidePrompt": false }, "source": [ "### Exercise 1: Solution 1" ] }, { "cell_type": "code", "execution_count": 76, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Help on function diag in module numpy:\n", "\n", "diag(v, k=0)\n", " Extract a diagonal or construct a diagonal array.\n", " \n", " See the more detailed documentation for ``numpy.diagonal`` if you use this\n", " function to extract a diagonal and wish to write to the resulting array;\n", " whether it returns a copy or a view depends on what version of numpy you\n", " are using.\n", " \n", " Parameters\n", " ----------\n", " v : array_like\n", " If `v` is a 2-D array, return a copy of its `k`-th diagonal.\n", " If `v` is a 1-D array, return a 2-D array with `v` on the `k`-th\n", " diagonal.\n", " k : int, optional\n", " Diagonal in question. The default is 0. Use `k>0` for diagonals\n", " above the main diagonal, and `k<0` for diagonals below the main\n", " diagonal.\n", " \n", " Returns\n", " -------\n", " out : ndarray\n", " The extracted diagonal or constructed diagonal array.\n", " \n", " See Also\n", " --------\n", " diagonal : Return specified diagonals.\n", " diagflat : Create a 2-D array with the flattened input as a diagonal.\n", " trace : Sum along diagonals.\n", " triu : Upper triangle of an array.\n", " tril : Lower triangle of an array.\n", " \n", " Examples\n", " --------\n", " >>> x = np.arange(9).reshape((3,3))\n", " >>> x\n", " array([[0, 1, 2],\n", " [3, 4, 5],\n", " [6, 7, 8]])\n", " \n", " >>> np.diag(x)\n", " array([0, 4, 8])\n", " >>> np.diag(x, k=1)\n", " array([1, 5])\n", " >>> np.diag(x, k=-1)\n", " array([3, 7])\n", " \n", " >>> np.diag(np.diag(x))\n", " array([[0, 0, 0],\n", " [0, 4, 0],\n", " [0, 0, 8]])\n", "\n" ] } ], "source": [ "help(np.diag)" ] }, { "cell_type": "markdown", "metadata": { "hideCode": false, "hidePrompt": false }, "source": [ "### Exercise 1: Solution 1" ] }, { "cell_type": "code", "execution_count": 77, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[1 1 1 1]\n", " [1 1 1 1]\n", " [1 1 1 8]\n", " [1 6 1 1]]\n" ] } ], "source": [ "a = np.ones((4, 4), dtype=int)\n", "a[3, 1] = 6\n", "a[2, 3] = 8\n", "#a[[3, 1], [2, 3]] = [6, 8] - - yoc can also do them together\n", "print(a)" ] }, { "cell_type": "markdown", "metadata": { "hideCode": false, "hidePrompt": false }, "source": [ "### Exercise 1: Solution 2" ] }, { "cell_type": "code", "execution_count": 78, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 0., 0., 0., 0., 0.],\n", " [ 7., 0., 0., 0., 0.],\n", " [ 0., 8., 0., 0., 0.],\n", " [ 0., 0., 9., 0., 0.],\n", " [ 0., 0., 0., 10., 0.],\n", " [ 0., 0., 0., 0., 11.]])" ] }, "execution_count": 78, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b = np.zeros((6, 5))\n", "b[1:] = np.diag(np.arange(7,12))\n", "b" ] }, { "cell_type": "markdown", "metadata": { "hideCode": false, "hidePrompt": false }, "source": [ "### Exercise 1: Solution 3 " ] }, { "cell_type": "code", "execution_count": 79, "metadata": { "hideCode": false, "hidePrompt": false }, "outputs": [ { "data": { "text/plain": [ "array([[0., 0., 0., 0., 0.],\n", " [0., 0., 0., 0., 0.],\n", " [1., 0., 0., 0., 0.],\n", " [0., 1., 0., 0., 0.],\n", " [0., 0., 1., 0., 0.],\n", " [0., 0., 0., 1., 0.]])" ] }, "execution_count": 79, "metadata": {}, "output_type": "execute_result" } ], "source": [ "y = np.eye(6, 5, k=-2, dtype=float)\n", "y" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "celltoolbar": "Hide code", "hide_code_all_hidden": 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.8.3" } }, "nbformat": 4, "nbformat_minor": 2 }