{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Functions\n", "\n", "## Definition" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "def my_function(arg1, arg2):\n", " '''Here I can say what my function does.\n", " I can use several lines\n", " arg1: It is a good idea to define the arguments as well\n", " arg2: Another one'''\n", " \n", " print(f'I am going to add {arg1} and {arg2} together')\n", " total = arg1 + arg2\n", " return total" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "I am going to add 1 and 2 together\n", "3\n" ] } ], "source": [ "add=my_function(1,2)\n", "print(add)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Type of arguments" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You can specify arguments in different ways. You can have required and optional arguments, you can give arguments by position (like above) or by name." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Give arguments per name (keyword argument)\n", "add=my_function(arg2=1, arg1=2)\n", "print(add)\n", "\n", "# This is illegal. Positional arguments need to be first listed.\n", "#add=my_function(arg2=1,2)\n", "# If mixing positional and keyword arguments, positional arguments are attributed in order so the following\n", "# does not work\n", "#add=my_function(2,arg1=1)" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1\n", "4\n" ] } ], "source": [ "# Optional arguments:\n", "def my_function(arg1, opt=None):\n", " if opt is not None:\n", " return(arg1*opt)\n", " else:\n", " return(arg1)\n", "\n", "print(my_function(1))\n", "print(my_function(1,4))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "What is going on with the following?\n", "\n", "
\n", "
\n", "
\n", "
\n", " \n", "
\n", "
\n", "
\n", "
\n", "
\n", " What happens is that for Python, 0 is False. So `if 0:` is False and the `else:` section is executed. Remember that Python consider None, 0 and False as False.\n", "
\n", "
\n", "
\n", "
" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1\n" ] } ], "source": [ "def my_function(arg1, opt=None):\n", " if opt:\n", " return(arg1*opt)\n", " else:\n", " return(arg1)\n", " \n", "print(my_function(1,0))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Optional arguments can also be used to define default values instead of nothing:\n", "def add_5_or(arg1, opt=5):\n", " return(arg1+opt)\n", "\n", "print(add_5_or(1))\n", "print(add_5_or(1,6))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Use lists/tuples or dictionaries to specify arguments\n", "t=(1,4)\n", "print(add_5_or(*t))\n", "\n", "dic={'arg1':1, 'opt':4}\n", "print(add_5_or(**dic))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If you remember, we saw the `**` operator last week with the `str.format()` method. It's exactly the same as here. \n", "\n", "Specifying arguments via a dictionary can be useful for specifying options for plot routines. When tailoring plots, one usually ends up using a lot of options. Defining a dictionary for those can allow for a more readable code and for easier reuse of the options between plots." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# An example for plots:\n", "import matplotlib.pyplot as plt\n", "plt.plot([0,1],[0,1])" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plot_opt={\"linewidth\":5,\n", " \"color\":\"pink\",\n", " \"marker\":\"o\",\n", " \"markersize\":15,\n", " \"fillstyle\":\"none\"}\n", "plt.plot([0,1],[0,1],**plot_opt)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Global vs local scope\n", "Variables defined in function are local, unknown from the outside of the function. On the other hand, variables defined outside a function are known to the functions as they are in a scope comprising the function.\n", "\n", "Run the following code. Do you understand what is going on?\n", "\n", "
\n", "
\n", "
\n", "
\n", " \n", "
\n", "
\n", "
\n", "
\n", "
\n", "

The function defines a local object called total. This object only exists within the function. It is independent from the object define outside the function. `total` defined outside the function is in global scope. This means it can be used throughout the body program including the functions body.

\n", "

If you define a local variable with the same name as a global variable in a function, you can not use the global variable in that function.

\n", "
\n", "
\n", "
\n", "
" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "After the function: 0\n", "Final add: 9\n" ] } ], "source": [ "total=0\n", "def summing(arg1, arg2):\n", " total = arg1+arg2\n", " return total\n", "\n", "add = summing(1,2)\n", "print(\"After the function:\", total)\n", "\n", "total=2\n", "def sum2(arg1, arg2):\n", " tt = arg1+arg2+total\n", " return tt\n", "add = sum2(3,4)\n", "print(\"Final add:\",add)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Pass by Reference vs Value\n", "Python passes arguments per reference. That means they still point to the same location in memory outside and within a function.\n", "\n", "Do you understand what is going on in the following example?\n", "\n", "
\n", "
\n", "
\n", "
\n", " \n", "
\n", "
\n", "
\n", "
\n", "
\n", "

In changeme(), since li is a global object, it's values get modified despite the function not returning anything.

\n", "

In changeme2(), li becomes a local variable. The function completely forgets about the argument.

\n", "

Note the behaviour would be the same without passing li as an argument since li is a global object.

\n", "

What would happen if li was a tuple instead of a list?

\n", "
\n", "
\n", "
\n", "
" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "List at the start: [1, 2]\n", "List after changeme: [3, 2]\n", "List after changeme2: [3, 2]\n" ] } ], "source": [ "def changeme(li):\n", " li[0] = 3\n", " return\n", "\n", "def changeme2(li):\n", " li = [5,4]\n", " return\n", "\n", "li=[1,2]\n", "print(f\"List at the start: {li}\")\n", "\n", "changeme(li)\n", "print(f\"List after changeme: {li}\")\n", "\n", "changeme2(li)\n", "print(f\"List after changeme2: {li}\")" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[3, 2] [3, 2]\n" ] } ], "source": [ "def local_copy(li):\n", " loc=li\n", " loc[0]=3\n", " return loc\n", "\n", "li=[1,2]\n", "print(local_copy(li), li)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Read in files, Write to files" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Open and close files" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To open a text file, there is the `open()` function. It accepts 2 arguments: name of the file and the opening mode for the file.\n", "\n", "| Modes | Meaning |\n", "|:------:|--------|\n", "| r | read-only mode |\n", "| w | write-only mode |\n", "| a | append to existing file |\n", "| r+ | read and write mode |\n", "\n", "For binary files, you need to append `b` to the mode so Python knows to read or write byte objects.\n", "To read in data, there are 3 methods: `read()`, `readline()`, `readlines()`. The only difference is the amount of data they read from the file. `read()` will only read the given number of charaters (or whole file), `readline()` reads the file line by line, `readlines()` reads in the entire file or a maximum number of bytes/characters.\n", "Also, Python handily manages the conversion of end of line markers (`\\n` on Unix, `\\r\\n` on Windows) so you don't have to worry about it.\n", "\n", "To close a file, use the `close()` method." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Read from file" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "# f.seek(0) allows to rewind the file to the start of the file after each read.\n", "# Check what each output looks like. What is the difference between `f.read()` and `f.readlines()`?\n", "f = open('test.txt','r')\n", "whole_file = f.read()\n", "f.seek(0)\n", "first_line = f.readline()\n", "f.seek(0)\n", "whole2 = f.readlines()\n", "f.close()" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "This is an example text file.\n", "Let's see what happens with csv-type files\n", "50, 30, 40\n", "70, 20, 30\n", " This is an example text file.\n", " ['This is an example text file.\\n', \"Let's see what happens with csv-type files\\n\", '50, 30, 40\\n', '70, 20, 30\\n']\n" ] } ], "source": [ "print(whole_file, first_line, whole2)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"This is an example text file.\\nLet's see what happens with csv-type files\\n50, 30, 40\\n70, 20, 30\\n\"" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "whole_file" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Write to file" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Writing to a file is pretty symetrical to reading it in:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "f = open('my_file.txt','w')\n", "f.write('Hello!')\n", "lines=['Other line', 'One more']\n", "f.writelines(lines)\n", "f.close()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To check what's in the file, we use the iPython magic commands to call the `cat` bash command:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Hello!Other lineOne more" ] } ], "source": [ "!cat my_file.txt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Hmm, something went wrong. Python needs you to specify those are separate lines by adding a newline symbol: `\\n`" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "f = open('my_file.txt','w')\n", "f.write('Hello!\\n')\n", "lines=['Other line\\n', 'One more\\n']\n", "f.writelines(lines)\n", "f.close()" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Hello!\r\n", "Other line\r\n", "One more\r\n" ] } ], "source": [ "!cat my_file.txt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### With statement" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "It is also possible to use the `with` statement to work with files. This is commonly used as it provides better error handling and closes the file for you." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "with open('test.txt','r') as f:\n", " first_line = f.readline()\n", "\n", "print(first_line)\n", "second_line = f.readline()\n", "print(second_line)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exercise\n", "Create a list of the numerical tabular values in test.txt. Make sure the values are of a numeric type (hint: check the Python builtin functions [here](https://docs.python.org/3/library/functions.html#built-in-functions)).\n", "\n", "Format the list as you wish:\n", "\n", "`[50,30,40,70,20,30]`\n", "\n", "`[[50,30,40],[70,20,30]]`\n", "\n", "`[[50,70],[30,20],[40,30]]`\n", "\n", "
\n", "
\n", "
\n", "
\n", " \n", "
\n", "
\n", "
\n", "
\n", "
\n", "
\n",
    "with open('test.txt','r') as f:\n",
    "    # skip the header\n",
    "    head_length=2 # number of lines in the reader\n",
    "    for i in range(head_length):\n",
    "        f.readline()\n",
    "    \n",
    "    # Create a list to store the data\n",
    "    li = []\n",
    "    li2 = []\n",
    "    li3 = []\n",
    "    # Read each line and parse as needed.\n",
    "    for line in f.readlines():\n",
    "        tt = line.split(',')\n",
    "        tmp = [int(numb) for numb in tt]\n",
    "        li.extend(tmp)\n",
    "        li2.append(tmp)\n",
    "        if li3 == []:\n",
    "            li3=[[n] for n in tmp]\n",
    "        else:\n",
    "            for ind in range(len(tmp)):\n",
    "                li3[ind].append(tmp[ind])\n",
    "
\n", "
\n", "
\n", "
\n", "
\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "--------\n", "# Additional packages" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "When you start Python very little gets loaded by default. This is to ensure a quick start of the interpreter and a lower memory usage. Obviously, you will need more than the default.\n", "\n", "Additionally, Python is open-sourced and as such lots of additional packages have been contributed over the years. These packages need to be installed before being able to use them.\n", "\n", "There are several ways to install packages. A simple one for individuals is Anaconda or Miniconda. That is what you used to prepare for this training (remember the instructions sent before the first training?). One advantage is that it handles dependencies on other packages and non-Python libraries for you. One disadvantage is that not all packages are shared via conda. It also creates a lot of files, which is not good for NCI.\n", "\n", "For working at NCI, the CMS maintain several Python environments to avoid duplications. These are quite extensive and we are open to installing more packages (as long as they are compatible with the existing environment). Please try those environments before installing your own. They are publicly opened, so not just for the Centre's folk.\n", "\n", "```\n", "module use /g/data/hh5/public/modules\n", "module load conda\n", "```\n", "\n", "This will load the stable environment for Python 3, which is most likely the one you want to use. A list of the packages under this environment can be found with: `conda list`" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Load packages for use in your scripts or notebooks\n", "You can load new packages at any point in your script. It's usually done at the top but it doesn't have to." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import numpy # Most basic form. Imports the whole package\n", "import numpy as np # Imports the whole package but give an alias to save on typing in your code\n", "from matplotlib import pyplot as plt # Import just one part of the package.\n", "import matplotlib.pyplot as plt # Does the same as above." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# To use a package:\n", "a = np.arange(20)\n", "a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Some useful packages\n", "\n", "From basic Python install:\n", " - os: operating system, e.g. environment variables, working directory, change permissions on files and directories.\n", " - pathlib: pathname manipulations, e.g. separate or join basename and file name, check file existence.\n", " - shutil: file operations, e.g. copy, move, delete files\n", " - glob: pathname pattern expansion, e.g. list of files matching: './[0-9].*'\n", " - argparse: parser for command-line options.\n", " - subprocess: to run a separate program.\n", " \n", "Additional packages:\n", " - numpy: arrays in Python\n", " - scipy: more maths functions (FFT, ODE, linear algebra, interpolation etc.)\n", " - pandas: the ultimate to work with time series\n", " - xarray: better arrays in Python (labelled arrays)\n", " - matplotlib: plotting in Python\n", " - cartopy: map projection and plotting in Python\n", " - dask: parallelisation " ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.6" } }, "nbformat": 4, "nbformat_minor": 2 }