LUNAR
🌙
Dashboard
Browse
SW08_Theorie_en
ipynb
See Source
{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# SW08 - Flipped Classroom \n", "\n", "*This JupyterNotebook is intended to practice the theory alongside the slides and is used as a \"practical check of the theory input\". There are no sample solutions and the file will not be corrected and does not have to be submitted.*" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Mathematics in Python \n", "\n", "You can calculate directly in Python using the **standard operators:**" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "20" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "10 + 10" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "19.0" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "5 * 3 + (20 / 5)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "But how can we use more complex mathematical functions?\n", "\n", "by using **libraries**: for example ``numpy``" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2.8284271247461903" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# import with nickname\n", "import numpy as np\n", "np.sqrt(8)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Without `import ... as` we have **3** letters more: " ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2.8284271247461903" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import numpy\n", "numpy.sqrt(8)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Common maths functions " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Square Root:\n", " $\\sqrt{x}$" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3.1622776601683795" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.sqrt(10)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Absolut - Function: $|{x}|$" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "4" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.abs(-4)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Power function: $x^y$" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "25" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x = 5\n", "y = 2\n", "np.power(x,y)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Constants" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2.718281828459045" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.e" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3.141592653589793" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.pi" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "nan" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.nan" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "What are `np.nan` and `np.inf` ?" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "inf" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.inf" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.0" ] }, "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ "1 / np.inf " ] }, { "attachments": { "image.png": { "image/png": "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" } }, "cell_type": "markdown", "metadata": {}, "source": [ "### nan\n", "\n", "" ] }, { "cell_type": "code", "execution_count": 46, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "nan" ] }, "execution_count": 46, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.nan + 10" ] }, { "cell_type": "code", "execution_count": 47, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "nan" ] }, "execution_count": 47, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.sqrt(np.nan)" ] }, { "cell_type": "code", "execution_count": 53, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 53, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.isnan(np.nan)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Other maths functions\n", "\n", "**Logarithm**" ] }, { "cell_type": "code", "execution_count": 59, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "4.0\n", "3.0\n", "2.0\n" ] } ], "source": [ "print(np.log(np.e**4)) # log basis e\n", "print(np.log2(8)) # log basis 2\n", "print(np.log10(100)) # log basis 10" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Trigonometry**" ] }, { "cell_type": "code", "execution_count": 63, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.7071067811865476\n", "0.7071067811865476\n", "0.9999999999999999\n", "1.0\n" ] } ], "source": [ "x = np.pi / 4\n", "print(np.sin(x))\n", "print(np.cos(x))\n", "print(np.tan(x))\n", "print(np.cos(x)/np.sin(x)) # cotangent" ] }, { "cell_type": "code", "execution_count": 68, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1.5707963267948966\n", "0.0\n", "0.7853981633974483\n", "0.7853981633974483\n", "3.9269908169872414\n" ] } ], "source": [ "x = 1\n", "print(np.arcsin(x))\n", "print(np.arccos(x))\n", "print(np.arctan(x))\n", "print(np.arctan(1/x)) # für x > 0\n", "print(np.arctan(1/x)+ np.pi) # für x < 0" ] }, { "cell_type": "code", "execution_count": 66, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.7853981633974483" ] }, "execution_count": 66, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.pi / 4" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Implementation of a formula\n", "\n", "" ] }, { "cell_type": "code", "execution_count": 74, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "x_1,2 = -0.23,-1.43\n" ] } ], "source": [ "a = 6\n", "b = 10\n", "c = 2\n", "\n", "x_1 = (-b + np.sqrt(np.power(b,2) - (4 * a * c))) / (2 * a)\n", "x_2 = (-b - np.sqrt(np.power(b,2) - (4 * a * c))) / (2 * a)\n", "\n", "print(f\"x_1,2 = {x_1:.2f},{x_2:.2f}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Arrays\n", "\n", "Numpy also supports arrays. But what exactly are *arrays*?\n", "\n", "\n", "\n", "\n", "**In a nutshell**: Arrays are nothing more than ``lists``, but you can do **calculations** with them." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Numpy arrays support all **standard arithmetic operators** (`+`,`-`,`%`, etc.)." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([5, 6, 7, 8])" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "my_array = np.array([1,2,3,4])\n", "my_array + 4" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "But not ``lists``!" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "can only concatenate list (not \"int\") to list", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", "Cell \u001b[1;32mIn[5], line 2\u001b[0m\n\u001b[0;32m 1\u001b[0m my_list \u001b[38;5;241m=\u001b[39m [\u001b[38;5;241m1\u001b[39m,\u001b[38;5;241m2\u001b[39m,\u001b[38;5;241m3\u001b[39m,\u001b[38;5;241m4\u001b[39m]\n\u001b[1;32m----> 2\u001b[0m \u001b[43mmy_list\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m4\u001b[39;49m\n", "\u001b[1;31mTypeError\u001b[0m: can only concatenate list (not \"int\") to list" ] } ], "source": [ "my_list = [1,2,3,4]\n", "my_list + 4" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**All ``numpy`` functions** also work with arrays!" ] }, { "cell_type": "code", "execution_count": 57, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([ 1, 4, 9, 16], dtype=int32)" ] }, "execution_count": 57, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.power(my_array,2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "And this is how you can access (read) elements in an array:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# first element\n", "my_array[0]" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([2, 3, 4])" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "my_array[1:4]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "even with multiple dimensions!" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[0],\n", " [3],\n", " [6]])" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 3d array\n", "my_array_3d = np.arange(9).reshape((3,3,1))\n", "my_array_3d[0:3,0,:]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Numpy also offers many pre-implemented functions" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Help on ndarray object:\n", "\n", "class ndarray(builtins.object)\n", " | ndarray(shape, dtype=float, buffer=None, offset=0,\n", " | strides=None, order=None)\n", " | \n", " | An array object represents a multidimensional, homogeneous array\n", " | of fixed-size items. An associated data-type object describes the\n", " | format of each element in the array (its byte-order, how many bytes it\n", " | occupies in memory, whether it is an integer, a floating point number,\n", " | or something else, etc.)\n", " | \n", " | Arrays should be constructed using `array`, `zeros` or `empty` (refer\n", " | to the See Also section below). The parameters given here refer to\n", " | a low-level method (`ndarray(...)`) for instantiating an array.\n", " | \n", " | For more information, refer to the `numpy` module and examine the\n", " | methods and attributes of an array.\n", " | \n", " | Parameters\n", " | ----------\n", " | (for the __new__ method; see Notes below)\n", " | \n", " | shape : tuple of ints\n", " | Shape of created array.\n", " | dtype : data-type, optional\n", " | Any object that can be interpreted as a numpy data type.\n", " | buffer : object exposing buffer interface, optional\n", " | Used to fill the array with data.\n", " | offset : int, optional\n", " | Offset of array data in buffer.\n", " | strides : tuple of ints, optional\n", " | Strides of data in memory.\n", " | order : {'C', 'F'}, optional\n", " | Row-major (C-style) or column-major (Fortran-style) order.\n", " | \n", " | Attributes\n", " | ----------\n", " | T : ndarray\n", " | Transpose of the array.\n", " | data : buffer\n", " | The array's elements, in memory.\n", " | dtype : dtype object\n", " | Describes the format of the elements in the array.\n", " | flags : dict\n", " | Dictionary containing information related to memory use, e.g.,\n", " | 'C_CONTIGUOUS', 'OWNDATA', 'WRITEABLE', etc.\n", " | flat : numpy.flatiter object\n", " | Flattened version of the array as an iterator. The iterator\n", " | allows assignments, e.g., ``x.flat = 3`` (See `ndarray.flat` for\n", " | assignment examples; TODO).\n", " | imag : ndarray\n", " | Imaginary part of the array.\n", " | real : ndarray\n", " | Real part of the array.\n", " | size : int\n", " | Number of elements in the array.\n", " | itemsize : int\n", " | The memory use of each array element in bytes.\n", " | nbytes : int\n", " | The total number of bytes required to store the array data,\n", " | i.e., ``itemsize * size``.\n", " | ndim : int\n", " | The array's number of dimensions.\n", " | shape : tuple of ints\n", " | Shape of the array.\n", " | strides : tuple of ints\n", " | The step-size required to move from one element to the next in\n", " | memory. For example, a contiguous ``(3, 4)`` array of type\n", " | ``int16`` in C-order has strides ``(8, 2)``. This implies that\n", " | to move from element to element in memory requires jumps of 2 bytes.\n", " | To move from row-to-row, one needs to jump 8 bytes at a time\n", " | (``2 * 4``).\n", " | ctypes : ctypes object\n", " | Class containing properties of the array needed for interaction\n", " | with ctypes.\n", " | base : ndarray\n", " | If the array is a view into another array, that array is its `base`\n", " | (unless that array is also a view). The `base` array is where the\n", " | array data is actually stored.\n", " | \n", " | See Also\n", " | --------\n", " | array : Construct an array.\n", " | zeros : Create an array, each element of which is zero.\n", " | empty : Create an array, but leave its allocated memory unchanged (i.e.,\n", " | it contains \"garbage\").\n", " | dtype : Create a data-type.\n", " | numpy.typing.NDArray : An ndarray alias :term:`generic <generic type>`\n", " | w.r.t. its `dtype.type <numpy.dtype.type>`.\n", " | \n", " | Notes\n", " | -----\n", " | There are two modes of creating an array using ``__new__``:\n", " | \n", " | 1. If `buffer` is None, then only `shape`, `dtype`, and `order`\n", " | are used.\n", " | 2. If `buffer` is an object exposing the buffer interface, then\n", " | all keywords are interpreted.\n", " | \n", " | No ``__init__`` method is needed because the array is fully initialized\n", " | after the ``__new__`` method.\n", " | \n", " | Examples\n", " | --------\n", " | These examples illustrate the low-level `ndarray` constructor. Refer\n", " | to the `See Also` section above for easier ways of constructing an\n", " | ndarray.\n", " | \n", " | First mode, `buffer` is None:\n", " | \n", " | >>> np.ndarray(shape=(2,2), dtype=float, order='F')\n", " | array([[0.0e+000, 0.0e+000], # random\n", " | [ nan, 2.5e-323]])\n", " | \n", " | Second mode:\n", " | \n", " | >>> np.ndarray((2,), buffer=np.array([1,2,3]),\n", " | ... offset=np.int_().itemsize,\n", " | ... dtype=int) # offset = 1*itemsize, i.e. skip first element\n", " | array([2, 3])\n", " | \n", " | Methods defined here:\n", " | \n", " | __abs__(self, /)\n", " | abs(self)\n", " | \n", " | __add__(self, value, /)\n", " | Return self+value.\n", " | \n", " | __and__(self, value, /)\n", " | Return self&value.\n", " | \n", " | __array__(...)\n", " | a.__array__([dtype], /)\n", " | \n", " | Returns either a new reference to self if dtype is not given or a new array\n", " | of provided data type if dtype is different from the current dtype of the\n", " | array.\n", " | \n", " | __array_finalize__(...)\n", " | a.__array_finalize__(obj, /)\n", " | \n", " | Present so subclasses can call super. Does nothing.\n", " | \n", " | __array_function__(...)\n", " | \n", " | __array_prepare__(...)\n", " | a.__array_prepare__(array[, context], /)\n", " | \n", " | Returns a view of `array` with the same type as self.\n", " | \n", " | __array_ufunc__(...)\n", " | \n", " | __array_wrap__(...)\n", " | a.__array_wrap__(array[, context], /)\n", " | \n", " | Returns a view of `array` with the same type as self.\n", " | \n", " | __bool__(self, /)\n", " | True if self else False\n", " | \n", " | __complex__(...)\n", " | \n", " | __contains__(self, key, /)\n", " | Return key in self.\n", " | \n", " | __copy__(...)\n", " | a.__copy__()\n", " | \n", " | Used if :func:`copy.copy` is called on an array. Returns a copy of the array.\n", " | \n", " | Equivalent to ``a.copy(order='K')``.\n", " | \n", " | __deepcopy__(...)\n", " | a.__deepcopy__(memo, /)\n", " | \n", " | Used if :func:`copy.deepcopy` is called on an array.\n", " | \n", " | __delitem__(self, key, /)\n", " | Delete self[key].\n", " | \n", " | __divmod__(self, value, /)\n", " | Return divmod(self, value).\n", " | \n", " | __dlpack__(...)\n", " | a.__dlpack__(*, stream=None)\n", " | \n", " | DLPack Protocol: Part of the Array API.\n", " | \n", " | __dlpack_device__(...)\n", " | a.__dlpack_device__()\n", " | \n", " | DLPack Protocol: Part of the Array API.\n", " | \n", " | __eq__(self, value, /)\n", " | Return self==value.\n", " | \n", " | __float__(self, /)\n", " | float(self)\n", " | \n", " | __floordiv__(self, value, /)\n", " | Return self//value.\n", " | \n", " | __format__(...)\n", " | Default object formatter.\n", " | \n", " | __ge__(self, value, /)\n", " | Return self>=value.\n", " | \n", " | __getitem__(self, key, /)\n", " | Return self[key].\n", " | \n", " | __gt__(self, value, /)\n", " | Return self>value.\n", " | \n", " | __iadd__(self, value, /)\n", " | Return self+=value.\n", " | \n", " | __iand__(self, value, /)\n", " | Return self&=value.\n", " | \n", " | __ifloordiv__(self, value, /)\n", " | Return self//=value.\n", " | \n", " | __ilshift__(self, value, /)\n", " | Return self<<=value.\n", " | \n", " | __imatmul__(self, value, /)\n", " | Return self@=value.\n", " | \n", " | __imod__(self, value, /)\n", " | Return self%=value.\n", " | \n", " | __imul__(self, value, /)\n", " | Return self*=value.\n", " | \n", " | __index__(self, /)\n", " | Return self converted to an integer, if self is suitable for use as an index into a list.\n", " | \n", " | __int__(self, /)\n", " | int(self)\n", " | \n", " | __invert__(self, /)\n", " | ~self\n", " | \n", " | __ior__(self, value, /)\n", " | Return self|=value.\n", " | \n", " | __ipow__(self, value, /)\n", " | Return self**=value.\n", " | \n", " | __irshift__(self, value, /)\n", " | Return self>>=value.\n", " | \n", " | __isub__(self, value, /)\n", " | Return self-=value.\n", " | \n", " | __iter__(self, /)\n", " | Implement iter(self).\n", " | \n", " | __itruediv__(self, value, /)\n", " | Return self/=value.\n", " | \n", " | __ixor__(self, value, /)\n", " | Return self^=value.\n", " | \n", " | __le__(self, value, /)\n", " | Return self<=value.\n", " | \n", " | __len__(self, /)\n", " | Return len(self).\n", " | \n", " | __lshift__(self, value, /)\n", " | Return self<<value.\n", " | \n", " | __lt__(self, value, /)\n", " | Return self<value.\n", " | \n", " | __matmul__(self, value, /)\n", " | Return self@value.\n", " | \n", " | __mod__(self, value, /)\n", " | Return self%value.\n", " | \n", " | __mul__(self, value, /)\n", " | Return self*value.\n", " | \n", " | __ne__(self, value, /)\n", " | Return self!=value.\n", " | \n", " | __neg__(self, /)\n", " | -self\n", " | \n", " | __or__(self, value, /)\n", " | Return self|value.\n", " | \n", " | __pos__(self, /)\n", " | +self\n", " | \n", " | __pow__(self, value, mod=None, /)\n", " | Return pow(self, value, mod).\n", " | \n", " | __radd__(self, value, /)\n", " | Return value+self.\n", " | \n", " | __rand__(self, value, /)\n", " | Return value&self.\n", " | \n", " | __rdivmod__(self, value, /)\n", " | Return divmod(value, self).\n", " | \n", " | __reduce__(...)\n", " | a.__reduce__()\n", " | \n", " | For pickling.\n", " | \n", " | __reduce_ex__(...)\n", " | Helper for pickle.\n", " | \n", " | __repr__(self, /)\n", " | Return repr(self).\n", " | \n", " | __rfloordiv__(self, value, /)\n", " | Return value//self.\n", " | \n", " | __rlshift__(self, value, /)\n", " | Return value<<self.\n", " | \n", " | __rmatmul__(self, value, /)\n", " | Return value@self.\n", " | \n", " | __rmod__(self, value, /)\n", " | Return value%self.\n", " | \n", " | __rmul__(self, value, /)\n", " | Return value*self.\n", " | \n", " | __ror__(self, value, /)\n", " | Return value|self.\n", " | \n", " | __rpow__(self, value, mod=None, /)\n", " | Return pow(value, self, mod).\n", " | \n", " | __rrshift__(self, value, /)\n", " | Return value>>self.\n", " | \n", " | __rshift__(self, value, /)\n", " | Return self>>value.\n", " | \n", " | __rsub__(self, value, /)\n", " | Return value-self.\n", " | \n", " | __rtruediv__(self, value, /)\n", " | Return value/self.\n", " | \n", " | __rxor__(self, value, /)\n", " | Return value^self.\n", " | \n", " | __setitem__(self, key, value, /)\n", " | Set self[key] to value.\n", " | \n", " | __setstate__(...)\n", " | a.__setstate__(state, /)\n", " | \n", " | For unpickling.\n", " | \n", " | The `state` argument must be a sequence that contains the following\n", " | elements:\n", " | \n", " | Parameters\n", " | ----------\n", " | version : int\n", " | optional pickle version. If omitted defaults to 0.\n", " | shape : tuple\n", " | dtype : data-type\n", " | isFortran : bool\n", " | rawdata : string or list\n", " | a binary string with the data (or a list if 'a' is an object array)\n", " | \n", " | __sizeof__(...)\n", " | Size of object in memory, in bytes.\n", " | \n", " | __str__(self, /)\n", " | Return str(self).\n", " | \n", " | __sub__(self, value, /)\n", " | Return self-value.\n", " | \n", " | __truediv__(self, value, /)\n", " | Return self/value.\n", " | \n", " | __xor__(self, value, /)\n", " | Return self^value.\n", " | \n", " | all(...)\n", " | a.all(axis=None, out=None, keepdims=False, *, where=True)\n", " | \n", " | Returns True if all elements evaluate to True.\n", " | \n", " | Refer to `numpy.all` for full documentation.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.all : equivalent function\n", " | \n", " | any(...)\n", " | a.any(axis=None, out=None, keepdims=False, *, where=True)\n", " | \n", " | Returns True if any of the elements of `a` evaluate to True.\n", " | \n", " | Refer to `numpy.any` for full documentation.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.any : equivalent function\n", " | \n", " | argmax(...)\n", " | a.argmax(axis=None, out=None, *, keepdims=False)\n", " | \n", " | Return indices of the maximum values along the given axis.\n", " | \n", " | Refer to `numpy.argmax` for full documentation.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.argmax : equivalent function\n", " | \n", " | argmin(...)\n", " | a.argmin(axis=None, out=None, *, keepdims=False)\n", " | \n", " | Return indices of the minimum values along the given axis.\n", " | \n", " | Refer to `numpy.argmin` for detailed documentation.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.argmin : equivalent function\n", " | \n", " | argpartition(...)\n", " | a.argpartition(kth, axis=-1, kind='introselect', order=None)\n", " | \n", " | Returns the indices that would partition this array.\n", " | \n", " | Refer to `numpy.argpartition` for full documentation.\n", " | \n", " | .. versionadded:: 1.8.0\n", " | \n", " | See Also\n", " | --------\n", " | numpy.argpartition : equivalent function\n", " | \n", " | argsort(...)\n", " | a.argsort(axis=-1, kind=None, order=None)\n", " | \n", " | Returns the indices that would sort this array.\n", " | \n", " | Refer to `numpy.argsort` for full documentation.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.argsort : equivalent function\n", " | \n", " | astype(...)\n", " | a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True)\n", " | \n", " | Copy of the array, cast to a specified type.\n", " | \n", " | Parameters\n", " | ----------\n", " | dtype : str or dtype\n", " | Typecode or data-type to which the array is cast.\n", " | order : {'C', 'F', 'A', 'K'}, optional\n", " | Controls the memory layout order of the result.\n", " | 'C' means C order, 'F' means Fortran order, 'A'\n", " | means 'F' order if all the arrays are Fortran contiguous,\n", " | 'C' order otherwise, and 'K' means as close to the\n", " | order the array elements appear in memory as possible.\n", " | Default is 'K'.\n", " | casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional\n", " | Controls what kind of data casting may occur. Defaults to 'unsafe'\n", " | for backwards compatibility.\n", " | \n", " | * 'no' means the data types should not be cast at all.\n", " | * 'equiv' means only byte-order changes are allowed.\n", " | * 'safe' means only casts which can preserve values are allowed.\n", " | * 'same_kind' means only safe casts or casts within a kind,\n", " | like float64 to float32, are allowed.\n", " | * 'unsafe' means any data conversions may be done.\n", " | subok : bool, optional\n", " | If True, then sub-classes will be passed-through (default), otherwise\n", " | the returned array will be forced to be a base-class array.\n", " | copy : bool, optional\n", " | By default, astype always returns a newly allocated array. If this\n", " | is set to false, and the `dtype`, `order`, and `subok`\n", " | requirements are satisfied, the input array is returned instead\n", " | of a copy.\n", " | \n", " | Returns\n", " | -------\n", " | arr_t : ndarray\n", " | Unless `copy` is False and the other conditions for returning the input\n", " | array are satisfied (see description for `copy` input parameter), `arr_t`\n", " | is a new array of the same shape as the input array, with dtype, order\n", " | given by `dtype`, `order`.\n", " | \n", " | Notes\n", " | -----\n", " | .. versionchanged:: 1.17.0\n", " | Casting between a simple data type and a structured one is possible only\n", " | for \"unsafe\" casting. Casting to multiple fields is allowed, but\n", " | casting from multiple fields is not.\n", " | \n", " | .. versionchanged:: 1.9.0\n", " | Casting from numeric to string types in 'safe' casting mode requires\n", " | that the string dtype length is long enough to store the max\n", " | integer/float value converted.\n", " | \n", " | Raises\n", " | ------\n", " | ComplexWarning\n", " | When casting from complex to float or int. To avoid this,\n", " | one should use ``a.real.astype(t)``.\n", " | \n", " | Examples\n", " | --------\n", " | >>> x = np.array([1, 2, 2.5])\n", " | >>> x\n", " | array([1. , 2. , 2.5])\n", " | \n", " | >>> x.astype(int)\n", " | array([1, 2, 2])\n", " | \n", " | byteswap(...)\n", " | a.byteswap(inplace=False)\n", " | \n", " | Swap the bytes of the array elements\n", " | \n", " | Toggle between low-endian and big-endian data representation by\n", " | returning a byteswapped array, optionally swapped in-place.\n", " | Arrays of byte-strings are not swapped. The real and imaginary\n", " | parts of a complex number are swapped individually.\n", " | \n", " | Parameters\n", " | ----------\n", " | inplace : bool, optional\n", " | If ``True``, swap bytes in-place, default is ``False``.\n", " | \n", " | Returns\n", " | -------\n", " | out : ndarray\n", " | The byteswapped array. If `inplace` is ``True``, this is\n", " | a view to self.\n", " | \n", " | Examples\n", " | --------\n", " | >>> A = np.array([1, 256, 8755], dtype=np.int16)\n", " | >>> list(map(hex, A))\n", " | ['0x1', '0x100', '0x2233']\n", " | >>> A.byteswap(inplace=True)\n", " | array([ 256, 1, 13090], dtype=int16)\n", " | >>> list(map(hex, A))\n", " | ['0x100', '0x1', '0x3322']\n", " | \n", " | Arrays of byte-strings are not swapped\n", " | \n", " | >>> A = np.array([b'ceg', b'fac'])\n", " | >>> A.byteswap()\n", " | array([b'ceg', b'fac'], dtype='|S3')\n", " | \n", " | ``A.newbyteorder().byteswap()`` produces an array with the same values\n", " | but different representation in memory\n", " | \n", " | >>> A = np.array([1, 2, 3])\n", " | >>> A.view(np.uint8)\n", " | array([1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0,\n", " | 0, 0], dtype=uint8)\n", " | >>> A.newbyteorder().byteswap(inplace=True)\n", " | array([1, 2, 3])\n", " | >>> A.view(np.uint8)\n", " | array([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,\n", " | 0, 3], dtype=uint8)\n", " | \n", " | choose(...)\n", " | a.choose(choices, out=None, mode='raise')\n", " | \n", " | Use an index array to construct a new array from a set of choices.\n", " | \n", " | Refer to `numpy.choose` for full documentation.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.choose : equivalent function\n", " | \n", " | clip(...)\n", " | a.clip(min=None, max=None, out=None, **kwargs)\n", " | \n", " | Return an array whose values are limited to ``[min, max]``.\n", " | One of max or min must be given.\n", " | \n", " | Refer to `numpy.clip` for full documentation.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.clip : equivalent function\n", " | \n", " | compress(...)\n", " | a.compress(condition, axis=None, out=None)\n", " | \n", " | Return selected slices of this array along given axis.\n", " | \n", " | Refer to `numpy.compress` for full documentation.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.compress : equivalent function\n", " | \n", " | conj(...)\n", " | a.conj()\n", " | \n", " | Complex-conjugate all elements.\n", " | \n", " | Refer to `numpy.conjugate` for full documentation.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.conjugate : equivalent function\n", " | \n", " | conjugate(...)\n", " | a.conjugate()\n", " | \n", " | Return the complex conjugate, element-wise.\n", " | \n", " | Refer to `numpy.conjugate` for full documentation.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.conjugate : equivalent function\n", " | \n", " | copy(...)\n", " | a.copy(order='C')\n", " | \n", " | Return a copy of the array.\n", " | \n", " | Parameters\n", " | ----------\n", " | order : {'C', 'F', 'A', 'K'}, optional\n", " | Controls the memory layout of the copy. 'C' means C-order,\n", " | 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,\n", " | 'C' otherwise. 'K' means match the layout of `a` as closely\n", " | as possible. (Note that this function and :func:`numpy.copy` are very\n", " | similar but have different default values for their order=\n", " | arguments, and this function always passes sub-classes through.)\n", " | \n", " | See also\n", " | --------\n", " | numpy.copy : Similar function with different default behavior\n", " | numpy.copyto\n", " | \n", " | Notes\n", " | -----\n", " | This function is the preferred method for creating an array copy. The\n", " | function :func:`numpy.copy` is similar, but it defaults to using order 'K',\n", " | and will not pass sub-classes through by default.\n", " | \n", " | Examples\n", " | --------\n", " | >>> x = np.array([[1,2,3],[4,5,6]], order='F')\n", " | \n", " | >>> y = x.copy()\n", " | \n", " | >>> x.fill(0)\n", " | \n", " | >>> x\n", " | array([[0, 0, 0],\n", " | [0, 0, 0]])\n", " | \n", " | >>> y\n", " | array([[1, 2, 3],\n", " | [4, 5, 6]])\n", " | \n", " | >>> y.flags['C_CONTIGUOUS']\n", " | True\n", " | \n", " | cumprod(...)\n", " | a.cumprod(axis=None, dtype=None, out=None)\n", " | \n", " | Return the cumulative product of the elements along the given axis.\n", " | \n", " | Refer to `numpy.cumprod` for full documentation.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.cumprod : equivalent function\n", " | \n", " | cumsum(...)\n", " | a.cumsum(axis=None, dtype=None, out=None)\n", " | \n", " | Return the cumulative sum of the elements along the given axis.\n", " | \n", " | Refer to `numpy.cumsum` for full documentation.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.cumsum : equivalent function\n", " | \n", " | diagonal(...)\n", " | a.diagonal(offset=0, axis1=0, axis2=1)\n", " | \n", " | Return specified diagonals. In NumPy 1.9 the returned array is a\n", " | read-only view instead of a copy as in previous NumPy versions. In\n", " | a future version the read-only restriction will be removed.\n", " | \n", " | Refer to :func:`numpy.diagonal` for full documentation.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.diagonal : equivalent function\n", " | \n", " | dot(...)\n", " | \n", " | dump(...)\n", " | a.dump(file)\n", " | \n", " | Dump a pickle of the array to the specified file.\n", " | The array can be read back with pickle.load or numpy.load.\n", " | \n", " | Parameters\n", " | ----------\n", " | file : str or Path\n", " | A string naming the dump file.\n", " | \n", " | .. versionchanged:: 1.17.0\n", " | `pathlib.Path` objects are now accepted.\n", " | \n", " | dumps(...)\n", " | a.dumps()\n", " | \n", " | Returns the pickle of the array as a string.\n", " | pickle.loads will convert the string back to an array.\n", " | \n", " | Parameters\n", " | ----------\n", " | None\n", " | \n", " | fill(...)\n", " | a.fill(value)\n", " | \n", " | Fill the array with a scalar value.\n", " | \n", " | Parameters\n", " | ----------\n", " | value : scalar\n", " | All elements of `a` will be assigned this value.\n", " | \n", " | Examples\n", " | --------\n", " | >>> a = np.array([1, 2])\n", " | >>> a.fill(0)\n", " | >>> a\n", " | array([0, 0])\n", " | >>> a = np.empty(2)\n", " | >>> a.fill(1)\n", " | >>> a\n", " | array([1., 1.])\n", " | \n", " | Fill expects a scalar value and always behaves the same as assigning\n", " | to a single array element. The following is a rare example where this\n", " | distinction is important:\n", " | \n", " | >>> a = np.array([None, None], dtype=object)\n", " | >>> a[0] = np.array(3)\n", " | >>> a\n", " | array([array(3), None], dtype=object)\n", " | >>> a.fill(np.array(3))\n", " | >>> a\n", " | array([array(3), array(3)], dtype=object)\n", " | \n", " | Where other forms of assignments will unpack the array being assigned:\n", " | \n", " | >>> a[...] = np.array(3)\n", " | >>> a\n", " | array([3, 3], dtype=object)\n", " | \n", " | flatten(...)\n", " | a.flatten(order='C')\n", " | \n", " | Return a copy of the array collapsed into one dimension.\n", " | \n", " | Parameters\n", " | ----------\n", " | order : {'C', 'F', 'A', 'K'}, optional\n", " | 'C' means to flatten in row-major (C-style) order.\n", " | 'F' means to flatten in column-major (Fortran-\n", " | style) order. 'A' means to flatten in column-major\n", " | order if `a` is Fortran *contiguous* in memory,\n", " | row-major order otherwise. 'K' means to flatten\n", " | `a` in the order the elements occur in memory.\n", " | The default is 'C'.\n", " | \n", " | Returns\n", " | -------\n", " | y : ndarray\n", " | A copy of the input array, flattened to one dimension.\n", " | \n", " | See Also\n", " | --------\n", " | ravel : Return a flattened array.\n", " | flat : A 1-D flat iterator over the array.\n", " | \n", " | Examples\n", " | --------\n", " | >>> a = np.array([[1,2], [3,4]])\n", " | >>> a.flatten()\n", " | array([1, 2, 3, 4])\n", " | >>> a.flatten('F')\n", " | array([1, 3, 2, 4])\n", " | \n", " | getfield(...)\n", " | a.getfield(dtype, offset=0)\n", " | \n", " | Returns a field of the given array as a certain type.\n", " | \n", " | A field is a view of the array data with a given data-type. The values in\n", " | the view are determined by the given type and the offset into the current\n", " | array in bytes. The offset needs to be such that the view dtype fits in the\n", " | array dtype; for example an array of dtype complex128 has 16-byte elements.\n", " | If taking a view with a 32-bit integer (4 bytes), the offset needs to be\n", " | between 0 and 12 bytes.\n", " | \n", " | Parameters\n", " | ----------\n", " | dtype : str or dtype\n", " | The data type of the view. The dtype size of the view can not be larger\n", " | than that of the array itself.\n", " | offset : int\n", " | Number of bytes to skip before beginning the element view.\n", " | \n", " | Examples\n", " | --------\n", " | >>> x = np.diag([1.+1.j]*2)\n", " | >>> x[1, 1] = 2 + 4.j\n", " | >>> x\n", " | array([[1.+1.j, 0.+0.j],\n", " | [0.+0.j, 2.+4.j]])\n", " | >>> x.getfield(np.float64)\n", " | array([[1., 0.],\n", " | [0., 2.]])\n", " | \n", " | By choosing an offset of 8 bytes we can select the complex part of the\n", " | array for our view:\n", " | \n", " | >>> x.getfield(np.float64, offset=8)\n", " | array([[1., 0.],\n", " | [0., 4.]])\n", " | \n", " | item(...)\n", " | a.item(*args)\n", " | \n", " | Copy an element of an array to a standard Python scalar and return it.\n", " | \n", " | Parameters\n", " | ----------\n", " | \\*args : Arguments (variable number and type)\n", " | \n", " | * none: in this case, the method only works for arrays\n", " | with one element (`a.size == 1`), which element is\n", " | copied into a standard Python scalar object and returned.\n", " | \n", " | * int_type: this argument is interpreted as a flat index into\n", " | the array, specifying which element to copy and return.\n", " | \n", " | * tuple of int_types: functions as does a single int_type argument,\n", " | except that the argument is interpreted as an nd-index into the\n", " | array.\n", " | \n", " | Returns\n", " | -------\n", " | z : Standard Python scalar object\n", " | A copy of the specified element of the array as a suitable\n", " | Python scalar\n", " | \n", " | Notes\n", " | -----\n", " | When the data type of `a` is longdouble or clongdouble, item() returns\n", " | a scalar array object because there is no available Python scalar that\n", " | would not lose information. Void arrays return a buffer object for item(),\n", " | unless fields are defined, in which case a tuple is returned.\n", " | \n", " | `item` is very similar to a[args], except, instead of an array scalar,\n", " | a standard Python scalar is returned. This can be useful for speeding up\n", " | access to elements of the array and doing arithmetic on elements of the\n", " | array using Python's optimized math.\n", " | \n", " | Examples\n", " | --------\n", " | >>> np.random.seed(123)\n", " | >>> x = np.random.randint(9, size=(3, 3))\n", " | >>> x\n", " | array([[2, 2, 6],\n", " | [1, 3, 6],\n", " | [1, 0, 1]])\n", " | >>> x.item(3)\n", " | 1\n", " | >>> x.item(7)\n", " | 0\n", " | >>> x.item((0, 1))\n", " | 2\n", " | >>> x.item((2, 2))\n", " | 1\n", " | \n", " | itemset(...)\n", " | a.itemset(*args)\n", " | \n", " | Insert scalar into an array (scalar is cast to array's dtype, if possible)\n", " | \n", " | There must be at least 1 argument, and define the last argument\n", " | as *item*. Then, ``a.itemset(*args)`` is equivalent to but faster\n", " | than ``a[args] = item``. The item should be a scalar value and `args`\n", " | must select a single item in the array `a`.\n", " | \n", " | Parameters\n", " | ----------\n", " | \\*args : Arguments\n", " | If one argument: a scalar, only used in case `a` is of size 1.\n", " | If two arguments: the last argument is the value to be set\n", " | and must be a scalar, the first argument specifies a single array\n", " | element location. It is either an int or a tuple.\n", " | \n", " | Notes\n", " | -----\n", " | Compared to indexing syntax, `itemset` provides some speed increase\n", " | for placing a scalar into a particular location in an `ndarray`,\n", " | if you must do this. However, generally this is discouraged:\n", " | among other problems, it complicates the appearance of the code.\n", " | Also, when using `itemset` (and `item`) inside a loop, be sure\n", " | to assign the methods to a local variable to avoid the attribute\n", " | look-up at each loop iteration.\n", " | \n", " | Examples\n", " | --------\n", " | >>> np.random.seed(123)\n", " | >>> x = np.random.randint(9, size=(3, 3))\n", " | >>> x\n", " | array([[2, 2, 6],\n", " | [1, 3, 6],\n", " | [1, 0, 1]])\n", " | >>> x.itemset(4, 0)\n", " | >>> x.itemset((2, 2), 9)\n", " | >>> x\n", " | array([[2, 2, 6],\n", " | [1, 0, 6],\n", " | [1, 0, 9]])\n", " | \n", " | max(...)\n", " | a.max(axis=None, out=None, keepdims=False, initial=<no value>, where=True)\n", " | \n", " | Return the maximum along a given axis.\n", " | \n", " | Refer to `numpy.amax` for full documentation.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.amax : equivalent function\n", " | \n", " | mean(...)\n", " | a.mean(axis=None, dtype=None, out=None, keepdims=False, *, where=True)\n", " | \n", " | Returns the average of the array elements along given axis.\n", " | \n", " | Refer to `numpy.mean` for full documentation.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.mean : equivalent function\n", " | \n", " | min(...)\n", " | a.min(axis=None, out=None, keepdims=False, initial=<no value>, where=True)\n", " | \n", " | Return the minimum along a given axis.\n", " | \n", " | Refer to `numpy.amin` for full documentation.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.amin : equivalent function\n", " | \n", " | newbyteorder(...)\n", " | arr.newbyteorder(new_order='S', /)\n", " | \n", " | Return the array with the same data viewed with a different byte order.\n", " | \n", " | Equivalent to::\n", " | \n", " | arr.view(arr.dtype.newbytorder(new_order))\n", " | \n", " | Changes are also made in all fields and sub-arrays of the array data\n", " | type.\n", " | \n", " | \n", " | \n", " | Parameters\n", " | ----------\n", " | new_order : string, optional\n", " | Byte order to force; a value from the byte order specifications\n", " | below. `new_order` codes can be any of:\n", " | \n", " | * 'S' - swap dtype from current to opposite endian\n", " | * {'<', 'little'} - little endian\n", " | * {'>', 'big'} - big endian\n", " | * {'=', 'native'} - native order, equivalent to `sys.byteorder`\n", " | * {'|', 'I'} - ignore (no change to byte order)\n", " | \n", " | The default value ('S') results in swapping the current\n", " | byte order.\n", " | \n", " | \n", " | Returns\n", " | -------\n", " | new_arr : array\n", " | New array object with the dtype reflecting given change to the\n", " | byte order.\n", " | \n", " | nonzero(...)\n", " | a.nonzero()\n", " | \n", " | Return the indices of the elements that are non-zero.\n", " | \n", " | Refer to `numpy.nonzero` for full documentation.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.nonzero : equivalent function\n", " | \n", " | partition(...)\n", " | a.partition(kth, axis=-1, kind='introselect', order=None)\n", " | \n", " | Rearranges the elements in the array in such a way that the value of the\n", " | element in kth position is in the position it would be in a sorted array.\n", " | All elements smaller than the kth element are moved before this element and\n", " | all equal or greater are moved behind it. The ordering of the elements in\n", " | the two partitions is undefined.\n", " | \n", " | .. versionadded:: 1.8.0\n", " | \n", " | Parameters\n", " | ----------\n", " | kth : int or sequence of ints\n", " | Element index to partition by. The kth element value will be in its\n", " | final sorted position and all smaller elements will be moved before it\n", " | and all equal or greater elements behind it.\n", " | The order of all elements in the partitions is undefined.\n", " | If provided with a sequence of kth it will partition all elements\n", " | indexed by kth of them into their sorted position at once.\n", " | \n", " | .. deprecated:: 1.22.0\n", " | Passing booleans as index is deprecated.\n", " | axis : int, optional\n", " | Axis along which to sort. Default is -1, which means sort along the\n", " | last axis.\n", " | kind : {'introselect'}, optional\n", " | Selection algorithm. Default is 'introselect'.\n", " | order : str or list of str, optional\n", " | When `a` is an array with fields defined, this argument specifies\n", " | which fields to compare first, second, etc. A single field can\n", " | be specified as a string, and not all fields need to be specified,\n", " | but unspecified fields will still be used, in the order in which\n", " | they come up in the dtype, to break ties.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.partition : Return a partitioned copy of an array.\n", " | argpartition : Indirect partition.\n", " | sort : Full sort.\n", " | \n", " | Notes\n", " | -----\n", " | See ``np.partition`` for notes on the different algorithms.\n", " | \n", " | Examples\n", " | --------\n", " | >>> a = np.array([3, 4, 2, 1])\n", " | >>> a.partition(3)\n", " | >>> a\n", " | array([2, 1, 3, 4])\n", " | \n", " | >>> a.partition((1, 3))\n", " | >>> a\n", " | array([1, 2, 3, 4])\n", " | \n", " | prod(...)\n", " | a.prod(axis=None, dtype=None, out=None, keepdims=False, initial=1, where=True)\n", " | \n", " | Return the product of the array elements over the given axis\n", " | \n", " | Refer to `numpy.prod` for full documentation.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.prod : equivalent function\n", " | \n", " | ptp(...)\n", " | a.ptp(axis=None, out=None, keepdims=False)\n", " | \n", " | Peak to peak (maximum - minimum) value along a given axis.\n", " | \n", " | Refer to `numpy.ptp` for full documentation.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.ptp : equivalent function\n", " | \n", " | put(...)\n", " | a.put(indices, values, mode='raise')\n", " | \n", " | Set ``a.flat[n] = values[n]`` for all `n` in indices.\n", " | \n", " | Refer to `numpy.put` for full documentation.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.put : equivalent function\n", " | \n", " | ravel(...)\n", " | a.ravel([order])\n", " | \n", " | Return a flattened array.\n", " | \n", " | Refer to `numpy.ravel` for full documentation.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.ravel : equivalent function\n", " | \n", " | ndarray.flat : a flat iterator on the array.\n", " | \n", " | repeat(...)\n", " | a.repeat(repeats, axis=None)\n", " | \n", " | Repeat elements of an array.\n", " | \n", " | Refer to `numpy.repeat` for full documentation.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.repeat : equivalent function\n", " | \n", " | reshape(...)\n", " | a.reshape(shape, order='C')\n", " | \n", " | Returns an array containing the same data with a new shape.\n", " | \n", " | Refer to `numpy.reshape` for full documentation.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.reshape : equivalent function\n", " | \n", " | Notes\n", " | -----\n", " | Unlike the free function `numpy.reshape`, this method on `ndarray` allows\n", " | the elements of the shape parameter to be passed in as separate arguments.\n", " | For example, ``a.reshape(10, 11)`` is equivalent to\n", " | ``a.reshape((10, 11))``.\n", " | \n", " | resize(...)\n", " | a.resize(new_shape, refcheck=True)\n", " | \n", " | Change shape and size of array in-place.\n", " | \n", " | Parameters\n", " | ----------\n", " | new_shape : tuple of ints, or `n` ints\n", " | Shape of resized array.\n", " | refcheck : bool, optional\n", " | If False, reference count will not be checked. Default is True.\n", " | \n", " | Returns\n", " | -------\n", " | None\n", " | \n", " | Raises\n", " | ------\n", " | ValueError\n", " | If `a` does not own its own data or references or views to it exist,\n", " | and the data memory must be changed.\n", " | PyPy only: will always raise if the data memory must be changed, since\n", " | there is no reliable way to determine if references or views to it\n", " | exist.\n", " | \n", " | SystemError\n", " | If the `order` keyword argument is specified. This behaviour is a\n", " | bug in NumPy.\n", " | \n", " | See Also\n", " | --------\n", " | resize : Return a new array with the specified shape.\n", " | \n", " | Notes\n", " | -----\n", " | This reallocates space for the data area if necessary.\n", " | \n", " | Only contiguous arrays (data elements consecutive in memory) can be\n", " | resized.\n", " | \n", " | The purpose of the reference count check is to make sure you\n", " | do not use this array as a buffer for another Python object and then\n", " | reallocate the memory. However, reference counts can increase in\n", " | other ways so if you are sure that you have not shared the memory\n", " | for this array with another Python object, then you may safely set\n", " | `refcheck` to False.\n", " | \n", " | Examples\n", " | --------\n", " | Shrinking an array: array is flattened (in the order that the data are\n", " | stored in memory), resized, and reshaped:\n", " | \n", " | >>> a = np.array([[0, 1], [2, 3]], order='C')\n", " | >>> a.resize((2, 1))\n", " | >>> a\n", " | array([[0],\n", " | [1]])\n", " | \n", " | >>> a = np.array([[0, 1], [2, 3]], order='F')\n", " | >>> a.resize((2, 1))\n", " | >>> a\n", " | array([[0],\n", " | [2]])\n", " | \n", " | Enlarging an array: as above, but missing entries are filled with zeros:\n", " | \n", " | >>> b = np.array([[0, 1], [2, 3]])\n", " | >>> b.resize(2, 3) # new_shape parameter doesn't have to be a tuple\n", " | >>> b\n", " | array([[0, 1, 2],\n", " | [3, 0, 0]])\n", " | \n", " | Referencing an array prevents resizing...\n", " | \n", " | >>> c = a\n", " | >>> a.resize((1, 1))\n", " | Traceback (most recent call last):\n", " | ...\n", " | ValueError: cannot resize an array that references or is referenced ...\n", " | \n", " | Unless `refcheck` is False:\n", " | \n", " | >>> a.resize((1, 1), refcheck=False)\n", " | >>> a\n", " | array([[0]])\n", " | >>> c\n", " | array([[0]])\n", " | \n", " | round(...)\n", " | a.round(decimals=0, out=None)\n", " | \n", " | Return `a` with each element rounded to the given number of decimals.\n", " | \n", " | Refer to `numpy.around` for full documentation.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.around : equivalent function\n", " | \n", " | searchsorted(...)\n", " | a.searchsorted(v, side='left', sorter=None)\n", " | \n", " | Find indices where elements of v should be inserted in a to maintain order.\n", " | \n", " | For full documentation, see `numpy.searchsorted`\n", " | \n", " | See Also\n", " | --------\n", " | numpy.searchsorted : equivalent function\n", " | \n", " | setfield(...)\n", " | a.setfield(val, dtype, offset=0)\n", " | \n", " | Put a value into a specified place in a field defined by a data-type.\n", " | \n", " | Place `val` into `a`'s field defined by `dtype` and beginning `offset`\n", " | bytes into the field.\n", " | \n", " | Parameters\n", " | ----------\n", " | val : object\n", " | Value to be placed in field.\n", " | dtype : dtype object\n", " | Data-type of the field in which to place `val`.\n", " | offset : int, optional\n", " | The number of bytes into the field at which to place `val`.\n", " | \n", " | Returns\n", " | -------\n", " | None\n", " | \n", " | See Also\n", " | --------\n", " | getfield\n", " | \n", " | Examples\n", " | --------\n", " | >>> x = np.eye(3)\n", " | >>> x.getfield(np.float64)\n", " | array([[1., 0., 0.],\n", " | [0., 1., 0.],\n", " | [0., 0., 1.]])\n", " | >>> x.setfield(3, np.int32)\n", " | >>> x.getfield(np.int32)\n", " | array([[3, 3, 3],\n", " | [3, 3, 3],\n", " | [3, 3, 3]], dtype=int32)\n", " | >>> x\n", " | array([[1.0e+000, 1.5e-323, 1.5e-323],\n", " | [1.5e-323, 1.0e+000, 1.5e-323],\n", " | [1.5e-323, 1.5e-323, 1.0e+000]])\n", " | >>> x.setfield(np.eye(3), np.int32)\n", " | >>> x\n", " | array([[1., 0., 0.],\n", " | [0., 1., 0.],\n", " | [0., 0., 1.]])\n", " | \n", " | setflags(...)\n", " | a.setflags(write=None, align=None, uic=None)\n", " | \n", " | Set array flags WRITEABLE, ALIGNED, WRITEBACKIFCOPY,\n", " | respectively.\n", " | \n", " | These Boolean-valued flags affect how numpy interprets the memory\n", " | area used by `a` (see Notes below). The ALIGNED flag can only\n", " | be set to True if the data is actually aligned according to the type.\n", " | The WRITEBACKIFCOPY and flag can never be set\n", " | to True. The flag WRITEABLE can only be set to True if the array owns its\n", " | own memory, or the ultimate owner of the memory exposes a writeable buffer\n", " | interface, or is a string. (The exception for string is made so that\n", " | unpickling can be done without copying memory.)\n", " | \n", " | Parameters\n", " | ----------\n", " | write : bool, optional\n", " | Describes whether or not `a` can be written to.\n", " | align : bool, optional\n", " | Describes whether or not `a` is aligned properly for its type.\n", " | uic : bool, optional\n", " | Describes whether or not `a` is a copy of another \"base\" array.\n", " | \n", " | Notes\n", " | -----\n", " | Array flags provide information about how the memory area used\n", " | for the array is to be interpreted. There are 7 Boolean flags\n", " | in use, only four of which can be changed by the user:\n", " | WRITEBACKIFCOPY, WRITEABLE, and ALIGNED.\n", " | \n", " | WRITEABLE (W) the data area can be written to;\n", " | \n", " | ALIGNED (A) the data and strides are aligned appropriately for the hardware\n", " | (as determined by the compiler);\n", " | \n", " | WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced\n", " | by .base). When the C-API function PyArray_ResolveWritebackIfCopy is\n", " | called, the base array will be updated with the contents of this array.\n", " | \n", " | All flags can be accessed using the single (upper case) letter as well\n", " | as the full name.\n", " | \n", " | Examples\n", " | --------\n", " | >>> y = np.array([[3, 1, 7],\n", " | ... [2, 0, 0],\n", " | ... [8, 5, 9]])\n", " | >>> y\n", " | array([[3, 1, 7],\n", " | [2, 0, 0],\n", " | [8, 5, 9]])\n", " | >>> y.flags\n", " | C_CONTIGUOUS : True\n", " | F_CONTIGUOUS : False\n", " | OWNDATA : True\n", " | WRITEABLE : True\n", " | ALIGNED : True\n", " | WRITEBACKIFCOPY : False\n", " | >>> y.setflags(write=0, align=0)\n", " | >>> y.flags\n", " | C_CONTIGUOUS : True\n", " | F_CONTIGUOUS : False\n", " | OWNDATA : True\n", " | WRITEABLE : False\n", " | ALIGNED : False\n", " | WRITEBACKIFCOPY : False\n", " | >>> y.setflags(uic=1)\n", " | Traceback (most recent call last):\n", " | File \"<stdin>\", line 1, in <module>\n", " | ValueError: cannot set WRITEBACKIFCOPY flag to True\n", " | \n", " | sort(...)\n", " | a.sort(axis=-1, kind=None, order=None)\n", " | \n", " | Sort an array in-place. Refer to `numpy.sort` for full documentation.\n", " | \n", " | Parameters\n", " | ----------\n", " | axis : int, optional\n", " | Axis along which to sort. Default is -1, which means sort along the\n", " | last axis.\n", " | kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional\n", " | Sorting algorithm. The default is 'quicksort'. Note that both 'stable'\n", " | and 'mergesort' use timsort under the covers and, in general, the\n", " | actual implementation will vary with datatype. The 'mergesort' option\n", " | is retained for backwards compatibility.\n", " | \n", " | .. versionchanged:: 1.15.0\n", " | The 'stable' option was added.\n", " | \n", " | order : str or list of str, optional\n", " | When `a` is an array with fields defined, this argument specifies\n", " | which fields to compare first, second, etc. A single field can\n", " | be specified as a string, and not all fields need be specified,\n", " | but unspecified fields will still be used, in the order in which\n", " | they come up in the dtype, to break ties.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.sort : Return a sorted copy of an array.\n", " | numpy.argsort : Indirect sort.\n", " | numpy.lexsort : Indirect stable sort on multiple keys.\n", " | numpy.searchsorted : Find elements in sorted array.\n", " | numpy.partition: Partial sort.\n", " | \n", " | Notes\n", " | -----\n", " | See `numpy.sort` for notes on the different sorting algorithms.\n", " | \n", " | Examples\n", " | --------\n", " | >>> a = np.array([[1,4], [3,1]])\n", " | >>> a.sort(axis=1)\n", " | >>> a\n", " | array([[1, 4],\n", " | [1, 3]])\n", " | >>> a.sort(axis=0)\n", " | >>> a\n", " | array([[1, 3],\n", " | [1, 4]])\n", " | \n", " | Use the `order` keyword to specify a field to use when sorting a\n", " | structured array:\n", " | \n", " | >>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)])\n", " | >>> a.sort(order='y')\n", " | >>> a\n", " | array([(b'c', 1), (b'a', 2)],\n", " | dtype=[('x', 'S1'), ('y', '<i8')])\n", " | \n", " | squeeze(...)\n", " | a.squeeze(axis=None)\n", " | \n", " | Remove axes of length one from `a`.\n", " | \n", " | Refer to `numpy.squeeze` for full documentation.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.squeeze : equivalent function\n", " | \n", " | std(...)\n", " | a.std(axis=None, dtype=None, out=None, ddof=0, keepdims=False, *, where=True)\n", " | \n", " | Returns the standard deviation of the array elements along given axis.\n", " | \n", " | Refer to `numpy.std` for full documentation.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.std : equivalent function\n", " | \n", " | sum(...)\n", " | a.sum(axis=None, dtype=None, out=None, keepdims=False, initial=0, where=True)\n", " | \n", " | Return the sum of the array elements over the given axis.\n", " | \n", " | Refer to `numpy.sum` for full documentation.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.sum : equivalent function\n", " | \n", " | swapaxes(...)\n", " | a.swapaxes(axis1, axis2)\n", " | \n", " | Return a view of the array with `axis1` and `axis2` interchanged.\n", " | \n", " | Refer to `numpy.swapaxes` for full documentation.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.swapaxes : equivalent function\n", " | \n", " | take(...)\n", " | a.take(indices, axis=None, out=None, mode='raise')\n", " | \n", " | Return an array formed from the elements of `a` at the given indices.\n", " | \n", " | Refer to `numpy.take` for full documentation.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.take : equivalent function\n", " | \n", " | tobytes(...)\n", " | a.tobytes(order='C')\n", " | \n", " | Construct Python bytes containing the raw data bytes in the array.\n", " | \n", " | Constructs Python bytes showing a copy of the raw contents of\n", " | data memory. The bytes object is produced in C-order by default.\n", " | This behavior is controlled by the ``order`` parameter.\n", " | \n", " | .. versionadded:: 1.9.0\n", " | \n", " | Parameters\n", " | ----------\n", " | order : {'C', 'F', 'A'}, optional\n", " | Controls the memory layout of the bytes object. 'C' means C-order,\n", " | 'F' means F-order, 'A' (short for *Any*) means 'F' if `a` is\n", " | Fortran contiguous, 'C' otherwise. Default is 'C'.\n", " | \n", " | Returns\n", " | -------\n", " | s : bytes\n", " | Python bytes exhibiting a copy of `a`'s raw data.\n", " | \n", " | See also\n", " | --------\n", " | frombuffer\n", " | Inverse of this operation, construct a 1-dimensional array from Python\n", " | bytes.\n", " | \n", " | Examples\n", " | --------\n", " | >>> x = np.array([[0, 1], [2, 3]], dtype='<u2')\n", " | >>> x.tobytes()\n", " | b'\\x00\\x00\\x01\\x00\\x02\\x00\\x03\\x00'\n", " | >>> x.tobytes('C') == x.tobytes()\n", " | True\n", " | >>> x.tobytes('F')\n", " | b'\\x00\\x00\\x02\\x00\\x01\\x00\\x03\\x00'\n", " | \n", " | tofile(...)\n", " | a.tofile(fid, sep=\"\", format=\"%s\")\n", " | \n", " | Write array to a file as text or binary (default).\n", " | \n", " | Data is always written in 'C' order, independent of the order of `a`.\n", " | The data produced by this method can be recovered using the function\n", " | fromfile().\n", " | \n", " | Parameters\n", " | ----------\n", " | fid : file or str or Path\n", " | An open file object, or a string containing a filename.\n", " | \n", " | .. versionchanged:: 1.17.0\n", " | `pathlib.Path` objects are now accepted.\n", " | \n", " | sep : str\n", " | Separator between array items for text output.\n", " | If \"\" (empty), a binary file is written, equivalent to\n", " | ``file.write(a.tobytes())``.\n", " | format : str\n", " | Format string for text file output.\n", " | Each entry in the array is formatted to text by first converting\n", " | it to the closest Python type, and then using \"format\" % item.\n", " | \n", " | Notes\n", " | -----\n", " | This is a convenience function for quick storage of array data.\n", " | Information on endianness and precision is lost, so this method is not a\n", " | good choice for files intended to archive data or transport data between\n", " | machines with different endianness. Some of these problems can be overcome\n", " | by outputting the data as text files, at the expense of speed and file\n", " | size.\n", " | \n", " | When fid is a file object, array contents are directly written to the\n", " | file, bypassing the file object's ``write`` method. As a result, tofile\n", " | cannot be used with files objects supporting compression (e.g., GzipFile)\n", " | or file-like objects that do not support ``fileno()`` (e.g., BytesIO).\n", " | \n", " | tolist(...)\n", " | a.tolist()\n", " | \n", " | Return the array as an ``a.ndim``-levels deep nested list of Python scalars.\n", " | \n", " | Return a copy of the array data as a (nested) Python list.\n", " | Data items are converted to the nearest compatible builtin Python type, via\n", " | the `~numpy.ndarray.item` function.\n", " | \n", " | If ``a.ndim`` is 0, then since the depth of the nested list is 0, it will\n", " | not be a list at all, but a simple Python scalar.\n", " | \n", " | Parameters\n", " | ----------\n", " | none\n", " | \n", " | Returns\n", " | -------\n", " | y : object, or list of object, or list of list of object, or ...\n", " | The possibly nested list of array elements.\n", " | \n", " | Notes\n", " | -----\n", " | The array may be recreated via ``a = np.array(a.tolist())``, although this\n", " | may sometimes lose precision.\n", " | \n", " | Examples\n", " | --------\n", " | For a 1D array, ``a.tolist()`` is almost the same as ``list(a)``,\n", " | except that ``tolist`` changes numpy scalars to Python scalars:\n", " | \n", " | >>> a = np.uint32([1, 2])\n", " | >>> a_list = list(a)\n", " | >>> a_list\n", " | [1, 2]\n", " | >>> type(a_list[0])\n", " | <class 'numpy.uint32'>\n", " | >>> a_tolist = a.tolist()\n", " | >>> a_tolist\n", " | [1, 2]\n", " | >>> type(a_tolist[0])\n", " | <class 'int'>\n", " | \n", " | Additionally, for a 2D array, ``tolist`` applies recursively:\n", " | \n", " | >>> a = np.array([[1, 2], [3, 4]])\n", " | >>> list(a)\n", " | [array([1, 2]), array([3, 4])]\n", " | >>> a.tolist()\n", " | [[1, 2], [3, 4]]\n", " | \n", " | The base case for this recursion is a 0D array:\n", " | \n", " | >>> a = np.array(1)\n", " | >>> list(a)\n", " | Traceback (most recent call last):\n", " | ...\n", " | TypeError: iteration over a 0-d array\n", " | >>> a.tolist()\n", " | 1\n", " | \n", " | tostring(...)\n", " | a.tostring(order='C')\n", " | \n", " | A compatibility alias for `tobytes`, with exactly the same behavior.\n", " | \n", " | Despite its name, it returns `bytes` not `str`\\ s.\n", " | \n", " | .. deprecated:: 1.19.0\n", " | \n", " | trace(...)\n", " | a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)\n", " | \n", " | Return the sum along diagonals of the array.\n", " | \n", " | Refer to `numpy.trace` for full documentation.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.trace : equivalent function\n", " | \n", " | transpose(...)\n", " | a.transpose(*axes)\n", " | \n", " | Returns a view of the array with axes transposed.\n", " | \n", " | Refer to `numpy.transpose` for full documentation.\n", " | \n", " | Parameters\n", " | ----------\n", " | axes : None, tuple of ints, or `n` ints\n", " | \n", " | * None or no argument: reverses the order of the axes.\n", " | \n", " | * tuple of ints: `i` in the `j`-th place in the tuple means that the\n", " | array's `i`-th axis becomes the transposed array's `j`-th axis.\n", " | \n", " | * `n` ints: same as an n-tuple of the same ints (this form is\n", " | intended simply as a \"convenience\" alternative to the tuple form).\n", " | \n", " | Returns\n", " | -------\n", " | p : ndarray\n", " | View of the array with its axes suitably permuted.\n", " | \n", " | See Also\n", " | --------\n", " | transpose : Equivalent function.\n", " | ndarray.T : Array property returning the array transposed.\n", " | ndarray.reshape : Give a new shape to an array without changing its data.\n", " | \n", " | Examples\n", " | --------\n", " | >>> a = np.array([[1, 2], [3, 4]])\n", " | >>> a\n", " | array([[1, 2],\n", " | [3, 4]])\n", " | >>> a.transpose()\n", " | array([[1, 3],\n", " | [2, 4]])\n", " | >>> a.transpose((1, 0))\n", " | array([[1, 3],\n", " | [2, 4]])\n", " | >>> a.transpose(1, 0)\n", " | array([[1, 3],\n", " | [2, 4]])\n", " | \n", " | >>> a = np.array([1, 2, 3, 4])\n", " | >>> a\n", " | array([1, 2, 3, 4])\n", " | >>> a.transpose()\n", " | array([1, 2, 3, 4])\n", " | \n", " | var(...)\n", " | a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False, *, where=True)\n", " | \n", " | Returns the variance of the array elements, along given axis.\n", " | \n", " | Refer to `numpy.var` for full documentation.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.var : equivalent function\n", " | \n", " | view(...)\n", " | a.view([dtype][, type])\n", " | \n", " | New view of array with the same data.\n", " | \n", " | .. note::\n", " | Passing None for ``dtype`` is different from omitting the parameter,\n", " | since the former invokes ``dtype(None)`` which is an alias for\n", " | ``dtype('float_')``.\n", " | \n", " | Parameters\n", " | ----------\n", " | dtype : data-type or ndarray sub-class, optional\n", " | Data-type descriptor of the returned view, e.g., float32 or int16.\n", " | Omitting it results in the view having the same data-type as `a`.\n", " | This argument can also be specified as an ndarray sub-class, which\n", " | then specifies the type of the returned object (this is equivalent to\n", " | setting the ``type`` parameter).\n", " | type : Python type, optional\n", " | Type of the returned view, e.g., ndarray or matrix. Again, omission\n", " | of the parameter results in type preservation.\n", " | \n", " | Notes\n", " | -----\n", " | ``a.view()`` is used two different ways:\n", " | \n", " | ``a.view(some_dtype)`` or ``a.view(dtype=some_dtype)`` constructs a view\n", " | of the array's memory with a different data-type. This can cause a\n", " | reinterpretation of the bytes of memory.\n", " | \n", " | ``a.view(ndarray_subclass)`` or ``a.view(type=ndarray_subclass)`` just\n", " | returns an instance of `ndarray_subclass` that looks at the same array\n", " | (same shape, dtype, etc.) This does not cause a reinterpretation of the\n", " | memory.\n", " | \n", " | For ``a.view(some_dtype)``, if ``some_dtype`` has a different number of\n", " | bytes per entry than the previous dtype (for example, converting a regular\n", " | array to a structured array), then the last axis of ``a`` must be\n", " | contiguous. This axis will be resized in the result.\n", " | \n", " | .. versionchanged:: 1.23.0\n", " | Only the last axis needs to be contiguous. Previously, the entire array\n", " | had to be C-contiguous.\n", " | \n", " | Examples\n", " | --------\n", " | >>> x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)])\n", " | \n", " | Viewing array data using a different type and dtype:\n", " | \n", " | >>> y = x.view(dtype=np.int16, type=np.matrix)\n", " | >>> y\n", " | matrix([[513]], dtype=int16)\n", " | >>> print(type(y))\n", " | <class 'numpy.matrix'>\n", " | \n", " | Creating a view on a structured array so it can be used in calculations\n", " | \n", " | >>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)])\n", " | >>> xv = x.view(dtype=np.int8).reshape(-1,2)\n", " | >>> xv\n", " | array([[1, 2],\n", " | [3, 4]], dtype=int8)\n", " | >>> xv.mean(0)\n", " | array([2., 3.])\n", " | \n", " | Making changes to the view changes the underlying array\n", " | \n", " | >>> xv[0,1] = 20\n", " | >>> x\n", " | array([(1, 20), (3, 4)], dtype=[('a', 'i1'), ('b', 'i1')])\n", " | \n", " | Using a view to convert an array to a recarray:\n", " | \n", " | >>> z = x.view(np.recarray)\n", " | >>> z.a\n", " | array([1, 3], dtype=int8)\n", " | \n", " | Views share data:\n", " | \n", " | >>> x[0] = (9, 10)\n", " | >>> z[0]\n", " | (9, 10)\n", " | \n", " | Views that change the dtype size (bytes per entry) should normally be\n", " | avoided on arrays defined by slices, transposes, fortran-ordering, etc.:\n", " | \n", " | >>> x = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.int16)\n", " | >>> y = x[:, ::2]\n", " | >>> y\n", " | array([[1, 3],\n", " | [4, 6]], dtype=int16)\n", " | >>> y.view(dtype=[('width', np.int16), ('length', np.int16)])\n", " | Traceback (most recent call last):\n", " | ...\n", " | ValueError: To change to a dtype of a different size, the last axis must be contiguous\n", " | >>> z = y.copy()\n", " | >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])\n", " | array([[(1, 3)],\n", " | [(4, 6)]], dtype=[('width', '<i2'), ('length', '<i2')])\n", " | \n", " | However, views that change dtype are totally fine for arrays with a\n", " | contiguous last axis, even if the rest of the axes are not C-contiguous:\n", " | \n", " | >>> x = np.arange(2 * 3 * 4, dtype=np.int8).reshape(2, 3, 4)\n", " | >>> x.transpose(1, 0, 2).view(np.int16)\n", " | array([[[ 256, 770],\n", " | [3340, 3854]],\n", " | <BLANKLINE>\n", " | [[1284, 1798],\n", " | [4368, 4882]],\n", " | <BLANKLINE>\n", " | [[2312, 2826],\n", " | [5396, 5910]]], dtype=int16)\n", " | \n", " | ----------------------------------------------------------------------\n", " | Class methods defined here:\n", " | \n", " | __class_getitem__(...) from builtins.type\n", " | a.__class_getitem__(item, /)\n", " | \n", " | Return a parametrized wrapper around the `~numpy.ndarray` type.\n", " | \n", " | .. versionadded:: 1.22\n", " | \n", " | Returns\n", " | -------\n", " | alias : types.GenericAlias\n", " | A parametrized `~numpy.ndarray` type.\n", " | \n", " | Examples\n", " | --------\n", " | >>> from typing import Any\n", " | >>> import numpy as np\n", " | \n", " | >>> np.ndarray[Any, np.dtype[Any]]\n", " | numpy.ndarray[typing.Any, numpy.dtype[typing.Any]]\n", " | \n", " | See Also\n", " | --------\n", " | :pep:`585` : Type hinting generics in standard collections.\n", " | numpy.typing.NDArray : An ndarray alias :term:`generic <generic type>`\n", " | w.r.t. its `dtype.type <numpy.dtype.type>`.\n", " | \n", " | ----------------------------------------------------------------------\n", " | Static methods defined here:\n", " | \n", " | __new__(*args, **kwargs) from builtins.type\n", " | Create and return a new object. See help(type) for accurate signature.\n", " | \n", " | ----------------------------------------------------------------------\n", " | Data descriptors defined here:\n", " | \n", " | T\n", " | View of the transposed array.\n", " | \n", " | Same as ``self.transpose()``.\n", " | \n", " | Examples\n", " | --------\n", " | >>> a = np.array([[1, 2], [3, 4]])\n", " | >>> a\n", " | array([[1, 2],\n", " | [3, 4]])\n", " | >>> a.T\n", " | array([[1, 3],\n", " | [2, 4]])\n", " | \n", " | >>> a = np.array([1, 2, 3, 4])\n", " | >>> a\n", " | array([1, 2, 3, 4])\n", " | >>> a.T\n", " | array([1, 2, 3, 4])\n", " | \n", " | See Also\n", " | --------\n", " | transpose\n", " | \n", " | __array_interface__\n", " | Array protocol: Python side.\n", " | \n", " | __array_priority__\n", " | Array priority.\n", " | \n", " | __array_struct__\n", " | Array protocol: C-struct side.\n", " | \n", " | base\n", " | Base object if memory is from some other object.\n", " | \n", " | Examples\n", " | --------\n", " | The base of an array that owns its memory is None:\n", " | \n", " | >>> x = np.array([1,2,3,4])\n", " | >>> x.base is None\n", " | True\n", " | \n", " | Slicing creates a view, whose memory is shared with x:\n", " | \n", " | >>> y = x[2:]\n", " | >>> y.base is x\n", " | True\n", " | \n", " | ctypes\n", " | An object to simplify the interaction of the array with the ctypes\n", " | module.\n", " | \n", " | This attribute creates an object that makes it easier to use arrays\n", " | when calling shared libraries with the ctypes module. The returned\n", " | object has, among others, data, shape, and strides attributes (see\n", " | Notes below) which themselves return ctypes objects that can be used\n", " | as arguments to a shared library.\n", " | \n", " | Parameters\n", " | ----------\n", " | None\n", " | \n", " | Returns\n", " | -------\n", " | c : Python object\n", " | Possessing attributes data, shape, strides, etc.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.ctypeslib\n", " | \n", " | Notes\n", " | -----\n", " | Below are the public attributes of this object which were documented\n", " | in \"Guide to NumPy\" (we have omitted undocumented public attributes,\n", " | as well as documented private attributes):\n", " | \n", " | .. autoattribute:: numpy.core._internal._ctypes.data\n", " | :noindex:\n", " | \n", " | .. autoattribute:: numpy.core._internal._ctypes.shape\n", " | :noindex:\n", " | \n", " | .. autoattribute:: numpy.core._internal._ctypes.strides\n", " | :noindex:\n", " | \n", " | .. automethod:: numpy.core._internal._ctypes.data_as\n", " | :noindex:\n", " | \n", " | .. automethod:: numpy.core._internal._ctypes.shape_as\n", " | :noindex:\n", " | \n", " | .. automethod:: numpy.core._internal._ctypes.strides_as\n", " | :noindex:\n", " | \n", " | If the ctypes module is not available, then the ctypes attribute\n", " | of array objects still returns something useful, but ctypes objects\n", " | are not returned and errors may be raised instead. In particular,\n", " | the object will still have the ``as_parameter`` attribute which will\n", " | return an integer equal to the data attribute.\n", " | \n", " | Examples\n", " | --------\n", " | >>> import ctypes\n", " | >>> x = np.array([[0, 1], [2, 3]], dtype=np.int32)\n", " | >>> x\n", " | array([[0, 1],\n", " | [2, 3]], dtype=int32)\n", " | >>> x.ctypes.data\n", " | 31962608 # may vary\n", " | >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32))\n", " | <__main__.LP_c_uint object at 0x7ff2fc1fc200> # may vary\n", " | >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32)).contents\n", " | c_uint(0)\n", " | >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint64)).contents\n", " | c_ulong(4294967296)\n", " | >>> x.ctypes.shape\n", " | <numpy.core._internal.c_long_Array_2 object at 0x7ff2fc1fce60> # may vary\n", " | >>> x.ctypes.strides\n", " | <numpy.core._internal.c_long_Array_2 object at 0x7ff2fc1ff320> # may vary\n", " | \n", " | data\n", " | Python buffer object pointing to the start of the array's data.\n", " | \n", " | dtype\n", " | Data-type of the array's elements.\n", " | \n", " | .. warning::\n", " | \n", " | Setting ``arr.dtype`` is discouraged and may be deprecated in the\n", " | future. Setting will replace the ``dtype`` without modifying the\n", " | memory (see also `ndarray.view` and `ndarray.astype`).\n", " | \n", " | Parameters\n", " | ----------\n", " | None\n", " | \n", " | Returns\n", " | -------\n", " | d : numpy dtype object\n", " | \n", " | See Also\n", " | --------\n", " | ndarray.astype : Cast the values contained in the array to a new data-type.\n", " | ndarray.view : Create a view of the same data but a different data-type.\n", " | numpy.dtype\n", " | \n", " | Examples\n", " | --------\n", " | >>> x\n", " | array([[0, 1],\n", " | [2, 3]])\n", " | >>> x.dtype\n", " | dtype('int32')\n", " | >>> type(x.dtype)\n", " | <type 'numpy.dtype'>\n", " | \n", " | flags\n", " | Information about the memory layout of the array.\n", " | \n", " | Attributes\n", " | ----------\n", " | C_CONTIGUOUS (C)\n", " | The data is in a single, C-style contiguous segment.\n", " | F_CONTIGUOUS (F)\n", " | The data is in a single, Fortran-style contiguous segment.\n", " | OWNDATA (O)\n", " | The array owns the memory it uses or borrows it from another object.\n", " | WRITEABLE (W)\n", " | The data area can be written to. Setting this to False locks\n", " | the data, making it read-only. A view (slice, etc.) inherits WRITEABLE\n", " | from its base array at creation time, but a view of a writeable\n", " | array may be subsequently locked while the base array remains writeable.\n", " | (The opposite is not true, in that a view of a locked array may not\n", " | be made writeable. However, currently, locking a base object does not\n", " | lock any views that already reference it, so under that circumstance it\n", " | is possible to alter the contents of a locked array via a previously\n", " | created writeable view onto it.) Attempting to change a non-writeable\n", " | array raises a RuntimeError exception.\n", " | ALIGNED (A)\n", " | The data and all elements are aligned appropriately for the hardware.\n", " | WRITEBACKIFCOPY (X)\n", " | This array is a copy of some other array. The C-API function\n", " | PyArray_ResolveWritebackIfCopy must be called before deallocating\n", " | to the base array will be updated with the contents of this array.\n", " | FNC\n", " | F_CONTIGUOUS and not C_CONTIGUOUS.\n", " | FORC\n", " | F_CONTIGUOUS or C_CONTIGUOUS (one-segment test).\n", " | BEHAVED (B)\n", " | ALIGNED and WRITEABLE.\n", " | CARRAY (CA)\n", " | BEHAVED and C_CONTIGUOUS.\n", " | FARRAY (FA)\n", " | BEHAVED and F_CONTIGUOUS and not C_CONTIGUOUS.\n", " | \n", " | Notes\n", " | -----\n", " | The `flags` object can be accessed dictionary-like (as in ``a.flags['WRITEABLE']``),\n", " | or by using lowercased attribute names (as in ``a.flags.writeable``). Short flag\n", " | names are only supported in dictionary access.\n", " | \n", " | Only the WRITEBACKIFCOPY, WRITEABLE, and ALIGNED flags can be\n", " | changed by the user, via direct assignment to the attribute or dictionary\n", " | entry, or by calling `ndarray.setflags`.\n", " | \n", " | The array flags cannot be set arbitrarily:\n", " | \n", " | - WRITEBACKIFCOPY can only be set ``False``.\n", " | - ALIGNED can only be set ``True`` if the data is truly aligned.\n", " | - WRITEABLE can only be set ``True`` if the array owns its own memory\n", " | or the ultimate owner of the memory exposes a writeable buffer\n", " | interface or is a string.\n", " | \n", " | Arrays can be both C-style and Fortran-style contiguous simultaneously.\n", " | This is clear for 1-dimensional arrays, but can also be true for higher\n", " | dimensional arrays.\n", " | \n", " | Even for contiguous arrays a stride for a given dimension\n", " | ``arr.strides[dim]`` may be *arbitrary* if ``arr.shape[dim] == 1``\n", " | or the array has no elements.\n", " | It does *not* generally hold that ``self.strides[-1] == self.itemsize``\n", " | for C-style contiguous arrays or ``self.strides[0] == self.itemsize`` for\n", " | Fortran-style contiguous arrays is true.\n", " | \n", " | flat\n", " | A 1-D iterator over the array.\n", " | \n", " | This is a `numpy.flatiter` instance, which acts similarly to, but is not\n", " | a subclass of, Python's built-in iterator object.\n", " | \n", " | See Also\n", " | --------\n", " | flatten : Return a copy of the array collapsed into one dimension.\n", " | \n", " | flatiter\n", " | \n", " | Examples\n", " | --------\n", " | >>> x = np.arange(1, 7).reshape(2, 3)\n", " | >>> x\n", " | array([[1, 2, 3],\n", " | [4, 5, 6]])\n", " | >>> x.flat[3]\n", " | 4\n", " | >>> x.T\n", " | array([[1, 4],\n", " | [2, 5],\n", " | [3, 6]])\n", " | >>> x.T.flat[3]\n", " | 5\n", " | >>> type(x.flat)\n", " | <class 'numpy.flatiter'>\n", " | \n", " | An assignment example:\n", " | \n", " | >>> x.flat = 3; x\n", " | array([[3, 3, 3],\n", " | [3, 3, 3]])\n", " | >>> x.flat[[1,4]] = 1; x\n", " | array([[3, 1, 3],\n", " | [3, 1, 3]])\n", " | \n", " | imag\n", " | The imaginary part of the array.\n", " | \n", " | Examples\n", " | --------\n", " | >>> x = np.sqrt([1+0j, 0+1j])\n", " | >>> x.imag\n", " | array([ 0. , 0.70710678])\n", " | >>> x.imag.dtype\n", " | dtype('float64')\n", " | \n", " | itemsize\n", " | Length of one array element in bytes.\n", " | \n", " | Examples\n", " | --------\n", " | >>> x = np.array([1,2,3], dtype=np.float64)\n", " | >>> x.itemsize\n", " | 8\n", " | >>> x = np.array([1,2,3], dtype=np.complex128)\n", " | >>> x.itemsize\n", " | 16\n", " | \n", " | nbytes\n", " | Total bytes consumed by the elements of the array.\n", " | \n", " | Notes\n", " | -----\n", " | Does not include memory consumed by non-element attributes of the\n", " | array object.\n", " | \n", " | See Also\n", " | --------\n", " | sys.getsizeof\n", " | Memory consumed by the object itself without parents in case view.\n", " | This does include memory consumed by non-element attributes.\n", " | \n", " | Examples\n", " | --------\n", " | >>> x = np.zeros((3,5,2), dtype=np.complex128)\n", " | >>> x.nbytes\n", " | 480\n", " | >>> np.prod(x.shape) * x.itemsize\n", " | 480\n", " | \n", " | ndim\n", " | Number of array dimensions.\n", " | \n", " | Examples\n", " | --------\n", " | >>> x = np.array([1, 2, 3])\n", " | >>> x.ndim\n", " | 1\n", " | >>> y = np.zeros((2, 3, 4))\n", " | >>> y.ndim\n", " | 3\n", " | \n", " | real\n", " | The real part of the array.\n", " | \n", " | Examples\n", " | --------\n", " | >>> x = np.sqrt([1+0j, 0+1j])\n", " | >>> x.real\n", " | array([ 1. , 0.70710678])\n", " | >>> x.real.dtype\n", " | dtype('float64')\n", " | \n", " | See Also\n", " | --------\n", " | numpy.real : equivalent function\n", " | \n", " | shape\n", " | Tuple of array dimensions.\n", " | \n", " | The shape property is usually used to get the current shape of an array,\n", " | but may also be used to reshape the array in-place by assigning a tuple of\n", " | array dimensions to it. As with `numpy.reshape`, one of the new shape\n", " | dimensions can be -1, in which case its value is inferred from the size of\n", " | the array and the remaining dimensions. Reshaping an array in-place will\n", " | fail if a copy is required.\n", " | \n", " | .. warning::\n", " | \n", " | Setting ``arr.shape`` is discouraged and may be deprecated in the\n", " | future. Using `ndarray.reshape` is the preferred approach.\n", " | \n", " | Examples\n", " | --------\n", " | >>> x = np.array([1, 2, 3, 4])\n", " | >>> x.shape\n", " | (4,)\n", " | >>> y = np.zeros((2, 3, 4))\n", " | >>> y.shape\n", " | (2, 3, 4)\n", " | >>> y.shape = (3, 8)\n", " | >>> y\n", " | array([[ 0., 0., 0., 0., 0., 0., 0., 0.],\n", " | [ 0., 0., 0., 0., 0., 0., 0., 0.],\n", " | [ 0., 0., 0., 0., 0., 0., 0., 0.]])\n", " | >>> y.shape = (3, 6)\n", " | Traceback (most recent call last):\n", " | File \"<stdin>\", line 1, in <module>\n", " | ValueError: total size of new array must be unchanged\n", " | >>> np.zeros((4,2))[::2].shape = (-1,)\n", " | Traceback (most recent call last):\n", " | File \"<stdin>\", line 1, in <module>\n", " | AttributeError: Incompatible shape for in-place modification. Use\n", " | `.reshape()` to make a copy with the desired shape.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.shape : Equivalent getter function.\n", " | numpy.reshape : Function similar to setting ``shape``.\n", " | ndarray.reshape : Method similar to setting ``shape``.\n", " | \n", " | size\n", " | Number of elements in the array.\n", " | \n", " | Equal to ``np.prod(a.shape)``, i.e., the product of the array's\n", " | dimensions.\n", " | \n", " | Notes\n", " | -----\n", " | `a.size` returns a standard arbitrary precision Python integer. This\n", " | may not be the case with other methods of obtaining the same value\n", " | (like the suggested ``np.prod(a.shape)``, which returns an instance\n", " | of ``np.int_``), and may be relevant if the value is used further in\n", " | calculations that may overflow a fixed size integer type.\n", " | \n", " | Examples\n", " | --------\n", " | >>> x = np.zeros((3, 5, 2), dtype=np.complex128)\n", " | >>> x.size\n", " | 30\n", " | >>> np.prod(x.shape)\n", " | 30\n", " | \n", " | strides\n", " | Tuple of bytes to step in each dimension when traversing an array.\n", " | \n", " | The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a`\n", " | is::\n", " | \n", " | offset = sum(np.array(i) * a.strides)\n", " | \n", " | A more detailed explanation of strides can be found in the\n", " | \"ndarray.rst\" file in the NumPy reference guide.\n", " | \n", " | .. warning::\n", " | \n", " | Setting ``arr.strides`` is discouraged and may be deprecated in the\n", " | future. `numpy.lib.stride_tricks.as_strided` should be preferred\n", " | to create a new view of the same data in a safer way.\n", " | \n", " | Notes\n", " | -----\n", " | Imagine an array of 32-bit integers (each 4 bytes)::\n", " | \n", " | x = np.array([[0, 1, 2, 3, 4],\n", " | [5, 6, 7, 8, 9]], dtype=np.int32)\n", " | \n", " | This array is stored in memory as 40 bytes, one after the other\n", " | (known as a contiguous block of memory). The strides of an array tell\n", " | us how many bytes we have to skip in memory to move to the next position\n", " | along a certain axis. For example, we have to skip 4 bytes (1 value) to\n", " | move to the next column, but 20 bytes (5 values) to get to the same\n", " | position in the next row. As such, the strides for the array `x` will be\n", " | ``(20, 4)``.\n", " | \n", " | See Also\n", " | --------\n", " | numpy.lib.stride_tricks.as_strided\n", " | \n", " | Examples\n", " | --------\n", " | >>> y = np.reshape(np.arange(2*3*4), (2,3,4))\n", " | >>> y\n", " | array([[[ 0, 1, 2, 3],\n", " | [ 4, 5, 6, 7],\n", " | [ 8, 9, 10, 11]],\n", " | [[12, 13, 14, 15],\n", " | [16, 17, 18, 19],\n", " | [20, 21, 22, 23]]])\n", " | >>> y.strides\n", " | (48, 16, 4)\n", " | >>> y[1,1,1]\n", " | 17\n", " | >>> offset=sum(y.strides * np.array((1,1,1)))\n", " | >>> offset/y.itemsize\n", " | 17\n", " | \n", " | >>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0)\n", " | >>> x.strides\n", " | (32, 4, 224, 1344)\n", " | >>> i = np.array([3,5,2,2])\n", " | >>> offset = sum(i * x.strides)\n", " | >>> x[3,5,2,2]\n", " | 813\n", " | >>> offset / x.itemsize\n", " | 813\n", " | \n", " | ----------------------------------------------------------------------\n", " | Data and other attributes defined here:\n", " | \n", " | __hash__ = None\n", "\n" ] } ], "source": [ "help(my_array)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Creating arrays \n", "\n", "What ways are there to create a ``numpy array``?\n", "\n", "So far we know ``lists``:" ] }, { "cell_type": "code", "execution_count": 84, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[4, 5, 6, 7, 8, 9]" ] }, "execution_count": 84, "metadata": {}, "output_type": "execute_result" } ], "source": [ "my_list = list(range(4,10))\n", "my_list" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "these `lists` can simply be **converted** into an array if you wish" ] }, { "cell_type": "code", "execution_count": 85, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([4, 5, 6, 7, 8, 9])" ] }, "execution_count": 85, "metadata": {}, "output_type": "execute_result" } ], "source": [ "my_arr = np.array(my_list)\n", "my_arr" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "it also works with a nested 2D List:" ] }, { "cell_type": "code", "execution_count": 87, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1, 2, 3],\n", " [4, 5, 6]])" ] }, "execution_count": 87, "metadata": {}, "output_type": "execute_result" } ], "source": [ "my_list_2D = [[1,2,3],[4,5,6]]\n", "np.array(my_list_2D)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Arange\n", "Generates a **sequene** of numbers:" ] }, { "cell_type": "code", "execution_count": 90, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([4, 6, 8])" ] }, "execution_count": 90, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.arange(4,10,2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This works the same as the **`range()` Command**\n", "\n", "**Arguments:**\n", "\n", "- ``start``\n", "- ``stop``\n", "- ``step``" ] }, { "cell_type": "code", "execution_count": 91, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[4, 6, 8]" ] }, "execution_count": 91, "metadata": {}, "output_type": "execute_result" } ], "source": [ "list(range(4,10,2))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0, 2, 4, 6, 8])" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "np.arange(0,10,2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "but it also works with `Floats`" ] }, { "cell_type": "code", "execution_count": 93, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])" ] }, "execution_count": 93, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.arange(0,1,0.1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## zeros, ones und eye\n", "\n", "Generating filled arrays:" ] }, { "cell_type": "code", "execution_count": 95, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[0., 0.],\n", " [0., 0.],\n", " [0., 0.]])" ] }, "execution_count": 95, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.zeros((3,2))" ] }, { "cell_type": "code", "execution_count": 96, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1., 1.],\n", " [1., 1.],\n", " [1., 1.]])" ] }, "execution_count": 96, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.ones(shape = (3,2))" ] }, { "cell_type": "code", "execution_count": 98, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1., 0., 0.],\n", " [0., 1., 0.],\n", " [0., 0., 1.]])" ] }, "execution_count": 98, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.eye(3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Linspace\n", "\n", "\n", "" ] }, { "cell_type": "code", "execution_count": 102, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([ 5., 10., 15., 20., 25., 30., 35., 40., 45., 50.])" ] }, "execution_count": 102, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.linspace(5,50,10)" ] }, { "cell_type": "code", "execution_count": 101, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([ 5., 10., 15., 20., 25., 30., 35., 40., 45., 50.])" ] }, "execution_count": 101, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.linspace(start = 5, stop=50, num=10)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Sizes, shape, Number of Dimensions" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "my_arr = np.ones((3,4,5))\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Read the **number of dimensions**" ] }, { "cell_type": "code", "execution_count": 108, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3" ] }, "execution_count": 108, "metadata": {}, "output_type": "execute_result" } ], "source": [ "my_arr.ndim" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Read the **number of elements**" ] }, { "cell_type": "code", "execution_count": 106, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "60" ] }, "execution_count": 106, "metadata": {}, "output_type": "execute_result" } ], "source": [ "my_arr.size" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Read the **Shape** of the Array:" ] }, { "cell_type": "code", "execution_count": 111, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(3, 4, 5)" ] }, "execution_count": 111, "metadata": {}, "output_type": "execute_result" } ], "source": [ "my_arr.shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Attention: ``len()`` is the **length of the outermost dimension**!" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "len(my_arr)" ] }, { "cell_type": "code", "execution_count": 112, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 112, "metadata": {}, "output_type": "execute_result" } ], "source": [ "len(np.ones((1,2,3)))" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "len(np.ones((2,3)))" ] }, { "cell_type": "code", "execution_count": 113, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 113, "metadata": {}, "output_type": "execute_result" } ], "source": [ "len(my_arr) == my_arr.shape[0]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Array slicing\n", "\n", "Reading array values" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr_1 = np.arange(10)\n", "arr_1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**First element**" ] }, { "cell_type": "code", "execution_count": 115, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0" ] }, "execution_count": 115, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr_1[0]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Second Element**" ] }, { "cell_type": "code", "execution_count": 117, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2" ] }, "execution_count": 117, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr_1[2]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Last Element**" ] }, { "cell_type": "code", "execution_count": 118, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "9" ] }, "execution_count": 118, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr_1[-1]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**All elements**" ] }, { "cell_type": "code", "execution_count": 119, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])" ] }, "execution_count": 119, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr_1[:]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The **first four** elements:" ] }, { "cell_type": "code", "execution_count": 120, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3])" ] }, "execution_count": 120, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr_1[:4]" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3])" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# is the same as\n", "arr_1[0:4]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Slicing II\n", "\n", "Advanced accedd to **multiple** elements" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Access Rules:**\n", "\n", "```python\n", "[start : stop: step]\n", "```" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([1, 3, 5])" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr_1[1:7:2]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Default values:**\n", "- Start = ``0``\n", "- Stop = ``End``\n", "- Step = ``1``" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0, 2, 4])" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr_1[:5:2]" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr_1" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([4, 6, 8])" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr_1[4::2]" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0, 1])" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr_1[0:2:]" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([9, 7, 5, 3, 1])" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr_1[::-2]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Multidimensional slicing**\n", "\n", "These slicing rules can be applied to **all dimensions of the array** by separating the different ``slices`` with a **’, ’**.\n" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[[0, 1, 2],\n", " [3, 4, 5],\n", " [6, 7, 8]]])" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr_3d = np.arange(9).reshape((1,3,3))\n", "arr_3d" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[[0, 1, 2],\n", " [3, 4, 5]]])" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr_3d[:,0:2,:]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[2, 5, 8]])" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr_3d[:,:,-1]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Calculations with Arrays\n", "\n", "Numpy Arrays unterstützen alle **Standard - Operatoren**:" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[11 12 13 14]\n", "[-9 -8 -7 -6]\n", "[10 20 30 40]\n", "[0.1 0.2 0.3 0.4]\n", "[0 0 0 0]\n", "[1 2 3 4]\n" ] } ], "source": [ "import numpy as np\n", "\n", "my_arr = np.array([1,2,3,4])\n", "print(my_arr+10)\n", "print(my_arr-10)\n", "print(my_arr*10)\n", "print(my_arr/10)\n", "print(my_arr//10) # Floor Division\n", "print(my_arr%10) # Modulo" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Diese **Standard - Operatoren** können nicht nur mit Arrays und Skalar-Werten (einzelnen Zahlen) angewendet werden, sondern auch mit **mehreren Arrays!**" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[2. 3.]\n", "[0. 1.]\n", "[1. 2.]\n", "[1. 2.]\n", "[1. 2.]\n", "[0. 0.]\n" ] } ], "source": [ "data = np.array([1, 2])\n", "ones = np.ones(2)\n", "\n", "\n", "print(data + ones)\n", "print(data - ones)\n", "print(data / ones)\n", "print(data * ones)\n", "print(data // ones)\n", "print(data % ones)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Dies funktioniert auch mit höher dimensionalen Arrays!" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "data2 = np.array([[1, 2], [3, 4]])\n", "ones2 = np.array([[1, 1], [1, 1]])\n", "\n", "data2 + ones2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Mathematik mit Arrays 2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Zudem haben wir gesehen, dass `Numpy` verschiedene **Mathematik - Funktionen** offeriert.\n", "Diese funktionieren nicht nur mit Zahlen (Skalar), sondern auch mit **Arrays**!" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1.73205081 2. ]\n", "[ 9 16]\n", "[ 8. 16.]\n", "[0.47712125 0.60205999]\n" ] } ], "source": [ "data = np.array([3,4])\n", "print(np.sqrt(data))\n", "print(np.power(data,2))\n", "print(np.exp2(data))\n", "print(np.log10(data))\n" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ 27 256]\n" ] } ], "source": [ "print(np.power(data,data))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Edit arrays\n", "\n", "## Overwriting values\n", "\n", "Individual values of arrays can also be changed.\n", "This is possible by **overwriting** individual values (via **indexing**):" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([10, 2, 3, 4, 5, 6, 8])" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "my_arr = np.array([1,2,3,4,5,6,8])\n", "\n", "# overriding of first element\n", "my_arr[0] = 10\n", "\n", "my_arr\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Overwrite several **values**" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([20, 20, 20, 4, 5, 6, 8])" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# overriding (changeing) first 3 values\n", "my_arr[0:3] = 20\n", "my_arr\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Relative value changes\n", "\n", "We can also **read and write values simultaneously** to make the** changes relative** to the underlying value:\n" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([30, 20, 20, 4, 5, 6, 8])" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "my_arr[0] += 10\t\t# Adds 10 to the first value\n", "my_arr\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This is possible not only with **Plus**, but with **all standard operators**:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([30, 20, 18, 8, 5, 1, 2])" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "my_arr[2] -= 2\n", "my_arr[3] *= 2\n", "my_arr[4] /= 1.0\n", "my_arr[5] //= 4\n", "my_arr[6] %= 3\n", "my_arr" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Simultaneous reading & writing can also be applied to **several cells** at once via **slicing**:\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([11, 12, 13, 14, 15, 6, 8])" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "my_arr = np.array([1,2,3,4,5,6,8])\n", "my_arr[:5] += 10\t # Change all Values between Idx 0 and 4 by adding 10\n", "my_arr\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This is even possible with **multi-dimensional arrays**:\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[0., 2., 0.],\n", " [1., 3., 1.],\n", " [0., 2., 0.]])" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "my_array_2d = np.zeros((3,3))\n", "my_array_2d[1,:] = 1 # overriding (horizontal)\n", "my_array_2d[:,1] += 2 # relative change (vertical)\n", "\n", "my_array_2d" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Array Manipulation\n", "\n", "Numpy arrays offer many methods that allow you to **manipulate / modify** an array in certain ways. \n", "\n", "\n", "## Reshape" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "x = np.arange(10)\n", "x" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[0, 1],\n", " [2, 3],\n", " [4, 5],\n", " [6, 7],\n", " [8, 9]])" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "x.reshape((5,2))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "x" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**But be careful**: The changes must be reassigned to the **original array**! Otherwise the **changes are not permanent**: " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[0, 1],\n", " [2, 3],\n", " [4, 5],\n", " [6, 7],\n", " [8, 9]])" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "x = x.reshape((5,2))\n", "x" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Types - Conversion\n", "\n", "You can also convert the **datatype** of the contents of an array by using the ``astype`` method." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "x = np.arange(10)\n", "x" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "x.astype(float)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**But be careful**: Here too, the **changes must be reassigned to the original array**, otherwise they will not be retained:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "x" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "x = x.astype(float)\n", "x" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The data type of an element can be queried with the ``dtype`` attribute:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "dtype('float64')" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "x.dtype" ] }, { "attachments": { "image.png": { "image/png": "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" } }, "cell_type": "markdown", "metadata": {}, "source": [ "# Matrix - Multiplication with Numpy:\n", "\n", "- with `matmul`\n", "- or with `@`\n", "\n", "" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "data: \n", " [[1 2 3]\n", " [4 5 6]] \n", "\n", "data2: \n", "[[ 7 8]\n", " [ 9 10]\n", " [11 12]]\n", "--------------------\n", "matmul: \n", "[[ 58 64]\n", " [139 154]]\n", "\n", " @: \n", "[[ 58 64]\n", " [139 154]]\n" ] } ], "source": [ "data = np.arange(1,7).reshape((2,3))\n", "data2 = np.arange(7,13).reshape((3,2))\n", "\n", "\n", "print(f\"data: \\n {data} \\n\")\n", "print(f\"data2: \\n{data2}\")\n", "print(f\"{'--'*10}\")\n", "\n", "print(f\"matmul: \\n{np.matmul(data,data2)}\\n\")\n", "print(f\" @: \\n{data@data2}\")\n" ] }, { "attachments": { "image-2.png": { "image/png": "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" } }, "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(2, 3)\n", "(3, 2)\n", "(2, 2)\n" ] } ], "source": [ "print(data.shape)\n", "print(data2.shape)\n", "print((data@data2).shape)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Manual calculation of the matrix multiplication (of top left value):" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "(1 * 7) + (2 * 9) + (3 * 11)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Transpose arrays\n", "Transposing a matrix is the mirroring of the matrix around its main diagonal. \n" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[1 2 3]\n", " [4 5 6]]\n", "[[1 4]\n", " [2 5]\n", " [3 6]]\n" ] } ], "source": [ "arr_2d = np.arange(1,7).reshape((2,3))\n", "print(arr_2d)\n", "\n", "print(arr_2d.transpose())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Option 1:**" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1, 4],\n", " [2, 5],\n", " [3, 6]])" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "np.transpose(arr_2d)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Option 2:**" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1, 4],\n", " [2, 5],\n", " [3, 6]])" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "arr_2d.T" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In addition, applying a transposition twice leads to the original arrayy\n", "\n", "$\n", "(A^T)^T = A\n", "$" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1, 2, 3],\n", " [4, 5, 6]])" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr_2d\n" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1, 2, 3],\n", " [4, 5, 6]])" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr_2d.T.T" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Comparison of transposing rows and column matrix:**" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1, 2, 3, 4]])" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "row = np.array([1,2,3,4]).reshape((1,4))\n", "row" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1],\n", " [2],\n", " [3],\n", " [4]])" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "row.T" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1],\n", " [2],\n", " [3],\n", " [4]])" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "col = np.array([[1],[2],[3],[4]])\n", "col" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1, 2, 3, 4]])" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "col.T" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" } }, "nbformat": 4, "nbformat_minor": 2 }
LUNAR