{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "Accessing functions beyond the built-in functions\n", "--------------------------------------------------------------------------------------------------------\n", "\n", "[[back to top](#top)]\n", "\n", " If we want to use libraries and modules not defined within the built-in functionality of python we have to import them. There are a number of ways to do this." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy,scipy" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " Imports the module numpy and the module scipy, and creates a reference to that modules in the current namespace. Or in other words, after you’ve run this statement, you can use numpy.name and scipy.name to refer to things defined in module numpy and scipy respectively." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "from numpy import * " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " Imports the module numpy, and creates references in the current namespace to all public objects defined by that module (that is, everything that doesn’t have a name starting with “\\_”). Or in other words, after you’ve run this statement, you can simply use a plain name to refer to things defined in module numpy. Here, numpy itself is not defined, so numpy.name doesn’t work. If name was already defined, it is replaced by the new version. Also, if name in numpy is changed to point to some other object, your module won’t notice.\n", " \n", " This method is not recommended as it tends to clutter the current namespace if the package you import contains many objects. If you import many packages like this, it also becomes unclear where the functions you use come from and hampers the ability of others to read your code." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "from numpy import array, mean, std" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " Imports the module numpy, and creates references in the current namespace to the given objects. Or in other words, you can now use array and mean and std in your program.\n", "\n", " More information on the numpy package will follow later in the tutorials." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Making and running python scripts\n", "------------------------------------------------------------------------\n", "\n", "[[back to top](#top)]\n", "\n", " Thus far we have been entering lines into the Ipython terminal or in a Jupter notebook one or a few lines at a time. This is a great way to prototype an idea you have and want to implement but no way to write a full program! For writing programs we turn to writing scripts and for that we need to exit Ipython and open your favorite text editor. To exit Ipython you can enter the command exit() into the terminal and enter y if prompted.\n", "\n", " When writing scripts, one should always keep coding style and coding conventions in mind. More information on coding style and conventions for Python ([PEP](https://www.python.org/dev/peps/pep-0008/)) can be found in the tutorial section on [Coding Style](#Coding-Style).\n", "\n", " Let's move on to writing our first python script and then talk more about things we can use in python. For our first program let's keep it simple and use some ideas we already have worked with. How about we find all the prime numbers up to 100? To do this we need to tests if each number between 2 and 100 is divisible by any number smaller then itself. We can do this pretty easily with a list, a few loops, and an if statement.\n", "\n", " " ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2 is prime\n", "3 is prime\n", "5 is prime\n", "7 is prime\n", "11 is prime\n", "13 is prime\n", "17 is prime\n", "19 is prime\n", "23 is prime\n", "29 is prime\n", "31 is prime\n", "37 is prime\n", "41 is prime\n", "43 is prime\n", "47 is prime\n", "53 is prime\n", "59 is prime\n", "61 is prime\n", "67 is prime\n", "71 is prime\n", "73 is prime\n", "79 is prime\n", "83 is prime\n", "89 is prime\n", "97 is prime\n" ] } ], "source": [ "#!/usr/bin/env python3\n", "\n", "numbers0to100=range(2,101)\n", "for num in numbers0to100:\n", " prime=True\n", " for chknum in range(2,num):\n", " if num%chknum==0:\n", " prime=False\n", " if prime==True:\n", " print(num,\"is prime\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " We can copy this script into our text editor and then save it with a descriptive name in a directory we will use for these script examples. Let's name it primenumbers.py, where the .py extension identifies what kind of file it is. Now we have a script and need to run it." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Running a python script\n", "\n", "There are two main ways to run a python script. Firstly, we can give the path to our script as the argument of the python command on the command line in a shell by typing\n", "\n", " python3 primenumbers.py\n", "\n", " Secondly, we can include the so-called shebang line\n", "\n", "!/usr/bin/env python3\n", "==============================================\n", "\n", "as the first line of our script, which if the file is executable will figure out which python on your system to use and then run the script by typing on the command line\n", "\n", " ./primenumbers.py\n", "\n", " Both methods will produce the same result so it's really just a matter of preference. Let's run our program by the first method for now by making sure our shell is in the same directory as our script the then running\n", "\n", " python3 primenumbers.py.\n", "\n", " You should see the same result as when running it in the Jupyter notebook." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Getting command line arguments\n", "\n", "One thing that we do not want to do with a script is be frequently editing and re-saving the file to alter parameters and files which it is reading or writing to. For things like this we want to specify arguments after the script name on the command line. This functionality is not built into python natively so we need to import a different module to do this. For simple things we will use the sys module, for more complex things we will use the argparse module. Let's start with a simple example and discuss what it does and how to run it. Save the following code as simpleargv.py in your running directory." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Number of arguments: 3 arguments.\n", "Argument List: ['/usr/lib/python3/dist-packages/ipykernel_launcher.py', '-f', '/run/user/1000/jupyter/kernel-45064d4a-228d-4472-89ad-7a3e4e2e9ae3.json']\n" ] } ], "source": [ "#!/usr/bin/env python3\n", "\n", "import sys\n", "\n", "print('Number of arguments:', len(sys.argv), 'arguments.')\n", "print('Argument List:', sys.argv)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " sys takes every word in your shell command after python (if you're using that invocation) and places it in a list whose elements were seperated by spaces in the command. This list is called sys.argv. Thus the length of sys.argv is the number of arguments you have plus 1 (the name of the script is also put in) and you can get the arguments you are feeding into the program by indexing into the list. Try running the program in the shell as follows and see if the output makes sense.\n", "\n", " python3 simpleargv.py one two three\n", "\n", " For more advanced input we might want to allow the program to be more robust then just taking a list of words from the command line. This is where argparse comes in. With argparse we can designate specific options to be valid and set variables in our script based on the options which are specified. Lets say that we would like our python script to support a --name option. We could define this alone but we could also allow --name to have a shorter sibling –n. –-name and -n should have the same meaning, but one is shorter and the other longer and more verbose. To do this we again will look to a simple example and discuss how to run it. You can save the following code to your running directory and name it simpleargparse.py." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#!/usr/bin/env python3\n", "\n", "import argparse\n", "\n", "parser = argparse.ArgumentParser()\n", "parser.add_argument('-n', '--name')\n", "parser.add_argument('-v', '--verbose')\n", "\n", "args = parser.parse_args()\n", "\n", "print(args.name,args.verbose)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " After the shebang we import the module argparse and then instantiate a ArgumentParser instance in our variable parser. Then we add a new option and parse the arguments. Finally we invoke and print the stored options by calling args.name and args.verbose. To run this program we could use\n", "\n", " python3 simpleoptparse.py -n James -v True\n", "\n", " which should just result in James and True being printed.\n", "\n", " Let's say we want our variable to be stored to a name we choose ourselves, define a default value, and also define beforehand what kind of variable we want the incoming variables to be. To do that, we have to add the dest, type, and default options respectively to our add\\_argument lines. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#!/usr/bin/env python3\n", "\n", "import argparse\n", "\n", "parser = argparse.ArgumentParser()\n", "parser.add_argument('-n','--name',dest='my_name',type=str,default='KillRoy')\n", "parser.add_argument('-v','--verbose',dest='v',type=bool,default=False)\n", "\n", "args = parser.parse_args()\n", "\n", "print(args.my_name,args.v)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " If we run the program with the same options as before the results will be the same. However we don't have to specify them, and the result will be the defaults being used.\n", "\n", " Another thing that argparse is great for is documentation. By running the program and specifying the -h option we can see the help information specified in the add\\_argument lines and a program banner specified in the ArgumentParser." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#!/usr/bin/env python3\n", "\n", "import argparse\n", "desc=\"Just a test program to demonstrate some argparse basics\"parser = argparse.ArgumentParser(description=desc)\n", "parser.add_argument('-n','--name',dest='my_name',\n", " type=str,default='KillRoy',\n", " help=\"Give your name so I can print it.\")\n", "parser.add_argument('-v','--verbose',dest='v',\n", " type=bool,default=False,\n", " help=\"Do you want me to be verbose?\")\n", "\n", "args = parser.parse_args()\n", "\n", "print(args.my_name,args.v)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " Now running the program with the -h option gives you a description of the program and the options it uses." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " The ArgumentParser adds a lot of great functionality and all the options can be found at the Python documentation pages online. In addition, have a look [here](https://docs.python.org/3/howto/argparse.html) for a tutorial on argparse in Python 3." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Coding Style\n", "------------------------------\n", "\n", "[[back to top](#top)]\n", "\n", " Before we get too far along for anyone to develop bad habits let's stop and talk about some style guidelines you should follow as they are layed out in the [Python Enhancement Proposal (PEP)](https://www.python.org/dev/peps/pep-0008/).\n", "\n", "### Indentation\n", "\n", "Python is different then other languages in that it uses white space to determine what control statement it is inside of. Use 4 spaces for indentation. This is enough space to give your code some visual structure, while leaving room for multiple indentation levels. When using text editors to write scripts most times you can change your settings so that a tab inserts 4 spaces.\n", "\n", "### Line Length\n", "\n", "Use up to 79 characters per line of code, and 72 characters for comments. This is a style guideline that some people adhere to and others completely ignore. This used to relate to a limit on the display size of most monitors. Now almost every monitor is capable of showing much more than 80 characters per line. But we often work in terminals, which are not always high-resolution. We also like to have multiple code files open, next to each other. It turns out this is still a useful guideline to follow in most cases. When using functions whose arguments get long one can simply break after the completion of an argument with a return, python will keep reading in the arguments until it finds a matching ')'. If a string or equation runs too long a backslash ('\\') can be used to break it into more then one line.\n", "\n", "### Blank Lines\n", "\n", "Use single blank lines to break up your code into meaningful blocks.\n", "\n", "### Comments\n", "\n", "Use a single space after the pound sign (#) at the beginning of a line. If you are writing more than one paragraph, use an empty line with a pound sign between paragraphs.\n", "\n", "### Naming Variable\n", "\n", "Name variables and program files using only lowercase letters, underscores, and numbers. Python won't complain or throw errors if you use capitalization, but you will mislead other programmers if you use capital letters in variables at this point. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A word of caution\n", "----------------------------------------\n", "\n", "[[back to top](#top)]\n", "\n", " * Python is designed to be readable and easy to use. Optimal speed performance and memory allocation are not it's forte. If you are going to be using large arrays or preforming calculations that need to be fast, python is probably not what you want. Use python for prototyping and then port to C++ if you want better performance.\n", " * Ipython notebooks are great for quick calculations but not for long running jobs. If you lose connection to the notebook server, you may lose all the work you have preformed. Prototype in the notebook and then move to a script which you can run safely on your machine, the cobalts (you will understand what that means after bootcamp :)), or a cluster." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Additional Python Packages\n", "==========================================================" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "NumPy\n", "----------------\n", "\n", "[[back to top](#top)]\n", "\n", " The [NumPy](http://www.numpy.org) (Numeric Python) package provides efficient routines for manipulating large arrays and matrices of numeric data. It contains among other things:\n", "\n", " * A powerful N-dimensional array object (numpy.ndarray)\n", " * Broadcasting functions\n", " * Useful linear algebra, Fourier transform, and random number capabilities\n", " By convention, NumPy is usually imported via" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "import numpy as np" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " The fundamental datastructure that NumPy gives us the the ndarray (usually just called \"array\"). According to the [NumPy documentation](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.html)\n", "\n", " \n", "> An array object represents a multidimensional, homogeneous array of fixed-size items. An associated data-type object describes the format of each element in the array (its byte-order, how many bytes it occupies in memory, whether it is an integer, a floating point number, or something else, etc.)\n", "> \n", "> Generally, think of an array as an (efficient) Python list with additional functionality. BUT keep in mind that there are a few important differences to be aware of. For instance, array object are homogenous—the values in an array must all be of the same type. Because arrays are stored in an unbroken block of memory, they need to be fixed size. While NumPy does support appending to arrays, this can become problematic for very large arrays.\n", "\n", " " ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1 2 3 4 5 6]\n", "\n" ] } ], "source": [ "array = np.array([1, 2, 3, 4, 5, 6])\n", "print(array)\n", "print(type(array))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " The datatype of an array can be found using the dtype array attribute" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "int64\n" ] } ], "source": [ "print(array.dtype)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " If not specified, NumPy will try to determine what dtype you wanted, based on the context. However, you can also manually specify the dtype yourself." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1. 2. 3. 4. 5. 6.]\n", "float64\n" ] } ], "source": [ "array = np.array([1, 2, 3, 4, 5, 6], dtype=float)\n", "print(array)\n", "print(array.dtype)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " Array attributes reflect information that is intrinsic to the array itself. For example, it's shape, the number of items in the array, or (as we've already seen) the item data types" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[1. 2. 3.]\n", " [4. 5. 6.]]\n" ] } ], "source": [ "array = np.array([[1, 2, 3],[4, 5, 6]], dtype=float)\n", "print(array)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(2, 3)\n", "6\n", "float64\n" ] } ], "source": [ "print(array.shape)\n", "print(array.size)\n", "print(array.dtype)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " In addition to array attributes, ndarrays also have many methods that can be used to operate on an array." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "21.0\n", "1.0\n", "6.0\n", "3.5\n", "[ 1. 3. 6. 10. 15. 21.]\n", "1.707825127659933\n" ] } ], "source": [ "print(array.sum()) # Sum of the values in the array\n", "print(array.min()) # Minimum value in the array\n", "print(array.max()) # Maximum value in the array\n", "print(array.mean()) # Mean of the values in the array\n", "print(array.cumsum()) # Cumulative sum at each index in the array\n", "print(array.std()) # Standard deviation of the values in array" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " NumPy naturally supports various matrix operations:" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[1 2 3]\n", " [4 5 6]\n", " [7 8 9]]\n" ] } ], "source": [ "M = np.array([[1, 2, 3],\n", " [4, 5, 6],\n", " [7, 8, 9]])\n", "print(M)" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1, 4, 7],\n", " [2, 5, 8],\n", " [3, 6, 9]])" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "M.T" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([1, 5, 9])" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "M.diagonal()" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([14, 32, 50])" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "M.dot([1, 2, 3])" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "15" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "M.trace()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " To learn more about the motivation and need for something like Numpy, check out this great blog post [Why Python is Slow: Looking Under the Hood](https://jakevdp.github.io/blog/2014/05/09/why-python-is-slow/)." ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ 6 8 10 12]\n" ] } ], "source": [ "array1 = np.array([1, 2, 3, 4])\n", "array2 = np.array([5, 6, 7, 8])\n", "print(array1 + array2)" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([2, 4, 6, 8])" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "2*array1" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([ 1, 4, 9, 16])" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "array1**2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " Let's get an idea of how much NumPy speeds things up." ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from IPython.display import Image\n", "Image('img/squares-list-creation.png')" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Image('img/sum-range.png')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " NumPy Exercises[¶](#NumPy-Exercises)\n", "------------------------------------\n", "\n", "[[back to top](#top)]\n", "\n", " 1. Find the dot product of these matrices [[1,2,3],[4,5,6]] [[7,8],[9,10],[11,12]]\n", "\t * Answer is [[58,64],[139,154]]\n", "\t \n", " + Find the cross product of the first matrix from 4 with [[7,7,7],[7,7,7]]\n", "\t * Answer is [[-7,14,-7],[-7,14,-7]]\n", "\t \n", " + Find the Eigen values of [[1,2,3],[4,5,6],[7,8,9]]\n", "\t * Answer is [1.61168440e+01,-1.11684397e+00,-1.30367773e-15]\n", "\t \n", " " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "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.6.7" } }, "nbformat": 4, "nbformat_minor": 1 }