{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Useful Jupyter features" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Running terminal commands" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "When you prefix a line with ``!`` it will be executed by the shell.\n", "\n", "_Note:_ These commands will fail on Windows because Windows uses a different terminal but they will work on ." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# List the content of the current directory\n", "!ls" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Get the path to the current directory\n", "!pwd" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Running Jupyter specific commands" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "When you prefix a line with ``%`` it will be processed by Juypter.\n", "\n", "**Run the next cell to install numpy and matplotlib**. They will be needed for this lecture.\n", "\n", "**Important:** When you use _Linux_ do not use pip. Use your package manager instead. Otherwise this will create conflicts.\n", "\n", "```\n", "apt install python3-numpy python3-matplotlib\n", "```" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%pip install numpy matplotlib" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Numpy" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Based on \"Numpy - multidimensional data arrays\" by J.R. Johansson (CC-BY).\n", "\n", "Original available at [http://github.com/jrjohansson/scientific-python-lectures](http://github.com/jrjohansson/scientific-python-lectures)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Introduction" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `numpy` package (module) is used in almost all numerical computation using Python.\n", "\n", "Provides high-performance vector, matrix and higher-dimensional data structures for Python. It is implemented in C and Fortran.\n", "\n", "When calculations are vectorized (formulated with vectors and matrices), performance is very good.\n", "\n", "To use `numpy` you need to import the module. The typical way to use ``numpy`` is to alias it as ``np``. This way the global namespace is not polluted and you have less letters to type." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "import numpy as np" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the `numpy` package the terminology used for vectors, matrices and higher-dimensional data sets is *array*. \n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For creating graphs / plots the ``matplotlib`` module is required.\n", "\n", "We will not use it alot in this lecture but in some cases it is very useful for visualisation." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt" ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "## Creating `numpy` arrays" ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "There are a number of ways to initialize new numpy arrays, for example from\n", "\n", "* a Python list or tuples\n", "* using functions that are dedicated to generating numpy arrays, such as `arange`, `linspace`, etc.\n", "* reading data from files (_later lecture_)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### From lists" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To create new vector and matrix arrays from Python lists use the `numpy.array` function." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To create a matrix simply pass a nested list to the array function." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `v` and `m` objects are both of the type `ndarray` that the `numpy` module provides." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The difference between the `v` and `m` arrays is only their shapes." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The number of elements in the array is available through the `ndarray.size` property:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "So far the `numpy.ndarray` looks like a Python list (or nested list) but there are several differences:\n", "\n", "- Python lists are very general\n", " - They can contain any kind of object.\n", " - They are dynamically typed.\n", " - They do not support mathematical functions such as matrix and dot multiplications, etc.\n", " - Implementing such functions for Python lists would not be very efficient because of the dynamic typing.\n", "- Numpy arrays are\n", " - **statically typed**\n", " - **homogeneous**\n", " - The type of the elements is determined when the array is created.\n", "- Numpy arrays are memory efficient.\n", "- Because of the static typing, fast implementation of mathematical functions such as multiplication and addition of `numpy` arrays can be implemented in a compiled language.\n", "\n", "Using the `dtype` (data type) property of an `ndarray`, we can see what type the data of an array has:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You get an error if you try to assign a value of the wrong type to an element in a numpy array:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You can define an explicit type using the `dtype` keyword argument: " ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "c = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=complex)\n", "\n", "c" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Common data types that can be used with `dtype` are: `int`, `float`, `complex`, `bool`, `object`, etc.\n", "\n", "The bit size (multiple of 8) can be set: `int64`, `int16`, `float128`, `complex128`." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Using array-generating functions" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### arange" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Like range, but creates a numpy-array instead." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### linspace" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "``linspace`` creates equally distributed values from start to finish. Contrary to ``range`` the end is _included_" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Lets plot these values with ``matplotlib``." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x = np.linspace(0, 10, 25)\n", "\n", "plt.plot(x, x, 'o')\n", "\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### random data" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "These functions behave like the ``random`` module in Python. (We did not discuss this one yet)\n", "\n", "Numbers in the range ``[0, 1]``" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": 231, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "x = np.random.rand(10)\n", "y = np.random.rand(10)\n", "\n", "plt.plot(x, y, 'o')\n", "\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Use ``randn`` for standard normal distributed random numbers" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "n = np.random.randn(10000000)\n", "\n", "plt.hist(n, bins=50)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### diag\n", "\n", "Creates a diagonal matrix." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Diagonal with offset from the main diagonal" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### zeros and ones" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## More properties of the numpy arrays" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Bytes per element" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "m.itemsize" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Number of bytes" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "m.nbytes" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Dimensions" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "m.ndim" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Manipulating arrays" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Indexing" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Indexing into a vector works as usual." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A matrix (a 2D-array) takes two indices." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "When you omit the 2nd index it returns a row." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The same thing can be achieved with using `:` instead of an index: " ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You can assign new values to elements in an array using indexing:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This also works for rows and columns" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Index slicing" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Slicing can be used to extract a part of an array. You already know this from lists." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Array slices are *mutable*: if they are assigned a new value the original array from which the slice was extracted is modified:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You can omit any of the three parameters in `M[lower:upper:step]`:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Negative indices counts from the end of the array (positive index from the begining):" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Index slicing works exactly the same way for multidimensional arrays:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "a = np.array([[n + m*10 for n in range(5)] for m in range(5)])\n", "\n", "a" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Fancy indexing" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Fancy indexing is the name for when an array or list is used in-place of an index.\n", "\n", "It is a very powerful feature for selecting and filtering data." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You can also use an _index mask_: If the index mask is an Numpy array of data type `bool`, then an element is selected (``True``) or not (``False``) depending on the value of the index mask at the position of each element: " ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This feature is very useful to conditionally select elements from an array, using for example comparison operators:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "a = np.array(range(-10, 10))\n", "a" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Functions for extracting data from arrays and creating arrays" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### where" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The index mask can be converted to position index using the `where` function" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### take" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`take` is more general purpose because it provides fancy indexing for other datatypes:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### choose" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Constructs an array by picking elements from several arrays:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Linear algebra" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Vectorizing code is the key to writing efficient numerical calculation with Python/Numpy. That means that as much as possible of a program should be formulated in terms of matrix and vector operations, like matrix-matrix multiplication." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "v = np.array([1, 2, 3, 4])\n", "m = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Scalar-array operations" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Element-wise array-array operations" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The default behaviour is **element-wise** operations:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If you multiply arrays with compatible shapes, you get an element-wise multiplication of each row:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "m.shape, v.shape" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Matrix algebra" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "What about matrix mutiplication? There are two ways. You can either use the `dot` function, which applies a matrix-matrix, matrix-vector, or inner vector multiplication to its two arguments: " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "$$ c_{ik} = \\sum_{j=1}^m a_{ij} \\cdot b_{jk} $$" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "See also the related functions: `inner`, `outer`, `cross`, `kron`, `tensordot`." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Array/Matrix transformations" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You can use `.T` to transpose the matrix object." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "c = np.array([[1+1j, 1+2j], [3j, 4j]])\n", "c" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "c.T" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Using `real` and `imag` you can extract the real and the imaginary part." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Or the complex argument and absolute value" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Matrix computations" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "d = np.arange(1, 10)\n", "d" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Calculations with higher-dimensional data" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "When functions such as `min`, `max`, etc. are applied to a multidimensional arrays, it is sometimes useful to apply the calculation to the entire array, and sometimes only on a row or column basis. Using the `axis` argument you can specify how these functions should behave: " ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "m = np.random.rand(3,3)\n", "m" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "global max" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "max in each column" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "max in each row" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Many other functions and methods in the `array` and `matrix` classes accept the same (optional) `axis` keyword argument." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Reshaping, resizing and stacking arrays" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The shape of an Numpy array can be modified without copying the underlaying data, which makes it a fast operation even for large arrays." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "a" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "And the original variable is also changed. b is only a different view of the same data" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You can also use the function `flatten` to make a higher-dimensional array into a vector. But this function create a copy of the data." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Using arrays in conditions" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "When using arrays in conditions,for example `if` statements and other boolean expressions, one needs to use `any` or `all`, which requires that any or all elements in the array evalutes to `True`:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "m" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Further reading" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* http://numpy.scipy.org\n", "* http://scipy.org/Tentative_NumPy_Tutorial\n", "* http://scipy.org/NumPy_for_Matlab_Users - A Numpy guide for MATLAB users." ] } ], "metadata": { "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.9.3" } }, "nbformat": 4, "nbformat_minor": 4 }