{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Manipulating data in Python\n", "\n", "In Python, you can manipulate your data in various ways. There are many, different functions that you can use in order to manipulate your data.\n", "\n", "At the end of this module, we will be generating the __Planck__ spectrum, which describes the intensity of a [blackbody](https://en.wikipedia.org/wiki/Black_body).\n", "\n", "Before we generate it, we need to know how to read a file, and plot its content" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Reading in and manipulating data\n", "\n", "There are a lot of modules to read in data from a file:\n", "\n", "- Numpy\n", " - genfromtxt\n", " - loadfromtxt\n", "- Pandas\n", " - read_csv\n", " - read_table\n", "- ...\n", "\n", "We will use \"genfromtxt\" for this exercise" ] }, { "cell_type": "code", "execution_count": 74, "metadata": {}, "outputs": [], "source": [ "## First, you need to import your modules\n", "%matplotlib inline\n", "\n", "import matplotlib\n", "import numpy as np\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can also define the path to the directory that contains all of our files" ] }, { "cell_type": "code", "execution_count": 75, "metadata": {}, "outputs": [], "source": [ "data_path = '../data/'" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If you have questions about the function, you can add a \"?\" at the end of your function." ] }, { "cell_type": "code", "execution_count": 76, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Help on function genfromtxt in module numpy.lib.npyio:\n", "\n", "genfromtxt(fname, dtype=, comments='#', delimiter=None, skip_header=0, skip_footer=0, converters=None, missing_values=None, filling_values=None, usecols=None, names=None, excludelist=None, deletechars=None, replace_space='_', autostrip=False, case_sensitive=True, defaultfmt='f%i', unpack=None, usemask=False, loose=True, invalid_raise=True, max_rows=None, encoding='bytes')\n", " Load data from a text file, with missing values handled as specified.\n", " \n", " Each line past the first skip_header lines is split at the delimiter\n", " character, and characters following the comments character are discarded.\n", " \n", " Parameters\n", " ----------\n", " fname : file, str, pathlib.Path, list of str, generator\n", " File, filename, list, or generator to read. If the filename\n", " extension is .gz or .bz2, the file is first decompressed. Note\n", " that generators must return byte strings in Python 3k. The strings\n", " in a list or produced by a generator are treated as lines.\n", " dtype : dtype, optional\n", " Data type of the resulting array.\n", " If None, the dtypes will be determined by the contents of each\n", " column, individually.\n", " comments : str, optional\n", " The character used to indicate the start of a comment.\n", " All the characters occurring on a line after a comment are discarded\n", " delimiter : str, int, or sequence, optional\n", " The string used to separate values. By default, any consecutive\n", " whitespaces act as delimiter. An integer or sequence of integers\n", " can also be provided as width(s) of each field.\n", " skiprows : int, optional\n", " skiprows was removed in numpy 1.10. Please use skip_header instead.\n", " skip_header : int, optional\n", " The number of lines to skip at the beginning of the file.\n", " skip_footer : int, optional\n", " The number of lines to skip at the end of the file.\n", " converters : variable, optional\n", " The set of functions that convert the data of a column to a value.\n", " The converters can also be used to provide a default value\n", " for missing data: converters = {3: lambda s: float(s or 0)}.\n", " missing : variable, optional\n", " missing was removed in numpy 1.10. Please use missing_values\n", " instead.\n", " missing_values : variable, optional\n", " The set of strings corresponding to missing data.\n", " filling_values : variable, optional\n", " The set of values to be used as default when the data are missing.\n", " usecols : sequence, optional\n", " Which columns to read, with 0 being the first. For example,\n", " usecols = (1, 4, 5) will extract the 2nd, 5th and 6th columns.\n", " names : {None, True, str, sequence}, optional\n", " If names is True, the field names are read from the first line after\n", " the first skip_header lines. This line can optionally be proceeded\n", " by a comment delimeter. If names is a sequence or a single-string of\n", " comma-separated names, the names will be used to define the field names\n", " in a structured dtype. If names is None, the names of the dtype\n", " fields will be used, if any.\n", " excludelist : sequence, optional\n", " A list of names to exclude. This list is appended to the default list\n", " ['return','file','print']. Excluded names are appended an underscore:\n", " for example, file would become file_.\n", " deletechars : str, optional\n", " A string combining invalid characters that must be deleted from the\n", " names.\n", " defaultfmt : str, optional\n", " A format used to define default field names, such as \"f%i\" or \"f_%02i\".\n", " autostrip : bool, optional\n", " Whether to automatically strip white spaces from the variables.\n", " replace_space : char, optional\n", " Character(s) used in replacement of white spaces in the variables\n", " names. By default, use a '_'.\n", " case_sensitive : {True, False, 'upper', 'lower'}, optional\n", " If True, field names are case sensitive.\n", " If False or 'upper', field names are converted to upper case.\n", " If 'lower', field names are converted to lower case.\n", " unpack : bool, optional\n", " If True, the returned array is transposed, so that arguments may be\n", " unpacked using x, y, z = loadtxt(...)\n", " usemask : bool, optional\n", " If True, return a masked array.\n", " If False, return a regular array.\n", " loose : bool, optional\n", " If True, do not raise errors for invalid values.\n", " invalid_raise : bool, optional\n", " If True, an exception is raised if an inconsistency is detected in the\n", " number of columns.\n", " If False, a warning is emitted and the offending lines are skipped.\n", " max_rows : int, optional\n", " The maximum number of rows to read. Must not be used with skip_footer\n", " at the same time. If given, the value must be at least 1. Default is\n", " to read the entire file.\n", " \n", " .. versionadded:: 1.10.0\n", " encoding : str, optional\n", " Encoding used to decode the inputfile. Does not apply when fname is\n", " a file object. The special value 'bytes' enables backward compatibility\n", " workarounds that ensure that you receive byte arrays when possible\n", " and passes latin1 encoded strings to converters. Override this value to\n", " receive unicode arrays and pass strings as input to converters. If set\n", " to None the system default is used. The default value is 'bytes'.\n", " \n", " .. versionadded:: 1.14.0\n", " \n", " Returns\n", " -------\n", " out : ndarray\n", " Data read from the text file. If usemask is True, this is a\n", " masked array.\n", " \n", " See Also\n", " --------\n", " numpy.loadtxt : equivalent function when no data is missing.\n", " \n", " Notes\n", " -----\n", " * When spaces are used as delimiters, or when no delimiter has been given\n", " as input, there should not be any missing data between two fields.\n", " * When the variables are named (either by a flexible dtype or with names,\n", " there must not be any header in the file (else a ValueError\n", " exception is raised).\n", " * Individual values are not stripped of spaces by default.\n", " When using a custom converter, make sure the function does remove spaces.\n", " \n", " References\n", " ----------\n", " .. [1] NumPy User Guide, section I/O with NumPy\n", " _.\n", " \n", " Examples\n", " ---------\n", " >>> from io import StringIO\n", " >>> import numpy as np\n", " \n", " Comma delimited file with mixed dtype\n", " \n", " >>> s = StringIO(\"1,1.3,abcde\")\n", " >>> data = np.genfromtxt(s, dtype=[('myint','i8'),('myfloat','f8'),\n", " ... ('mystring','S5')], delimiter=\",\")\n", " >>> data\n", " array((1, 1.3, 'abcde'),\n", " dtype=[('myint', '>> s.seek(0) # needed for StringIO example only\n", " >>> data = np.genfromtxt(s, dtype=None,\n", " ... names = ['myint','myfloat','mystring'], delimiter=\",\")\n", " >>> data\n", " array((1, 1.3, 'abcde'),\n", " dtype=[('myint', '>> s.seek(0)\n", " >>> data = np.genfromtxt(s, dtype=\"i8,f8,S5\",\n", " ... names=['myint','myfloat','mystring'], delimiter=\",\")\n", " >>> data\n", " array((1, 1.3, 'abcde'),\n", " dtype=[('myint', '>> s = StringIO(\"11.3abcde\")\n", " >>> data = np.genfromtxt(s, dtype=None, names=['intvar','fltvar','strvar'],\n", " ... delimiter=[1,3,5])\n", " >>> data\n", " array((1, 1.3, 'abcde'),\n", " dtype=[('intvar', '>> import numpy as np\n", " >>> import matplotlib.pyplot as plt\n", " >>> from scipy.optimize import curve_fit\n", " \n", " >>> def func(x, a, b, c):\n", " ... return a * np.exp(-b * x) + c\n", " \n", " Define the data to be fit with some noise:\n", " \n", " >>> xdata = np.linspace(0, 4, 50)\n", " >>> y = func(xdata, 2.5, 1.3, 0.5)\n", " >>> np.random.seed(1729)\n", " >>> y_noise = 0.2 * np.random.normal(size=xdata.size)\n", " >>> ydata = y + y_noise\n", " >>> plt.plot(xdata, ydata, 'b-', label='data')\n", " \n", " Fit for the parameters a, b, c of the function func:\n", " \n", " >>> popt, pcov = curve_fit(func, xdata, ydata)\n", " >>> popt\n", " array([ 2.55423706, 1.35190947, 0.47450618])\n", " >>> plt.plot(xdata, func(xdata, *popt), 'r-',\n", " ... label='fit: a=%5.3f, b=%5.3f, c=%5.3f' % tuple(popt))\n", " \n", " Constrain the optimization to the region of 0 <= a <= 3,\n", " 0 <= b <= 1 and 0 <= c <= 0.5:\n", " \n", " >>> popt, pcov = curve_fit(func, xdata, ydata, bounds=(0, [3., 1., 0.5]))\n", " >>> popt\n", " array([ 2.43708906, 1. , 0.35015434])\n", " >>> plt.plot(xdata, func(xdata, *popt), 'g--',\n", " ... label='fit: a=%5.3f, b=%5.3f, c=%5.3f' % tuple(popt))\n", " \n", " >>> plt.xlabel('x')\n", " >>> plt.ylabel('y')\n", " >>> plt.legend()\n", " >>> plt.show()\n", "\n" ] } ], "source": [ "help(curve_fit)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can now overplot the best-fit line to the data:" ] }, { "cell_type": "code", "execution_count": 92, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 92, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "