Python_Syntax.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img style=\"float: right;\" src=\"http://www2.le.ac.uk/liscb1.jpg\">\n",
    "\n",
    "# Python Syntax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modified by T.J. Ragan and T. Forey  \n",
    "Originally by: Sofware Carpentry (Cindee Madison and Thomas Kluyver, with thanks to Justin Kitzes and Matt Davis)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python is an easy to write, very easy to read general programming language.  Like any language, however, it's only as beautiful as the people who use it make it.  Please remember that your code is not only meant to do something, it's meant to be read.  In fact, most programmers spend more than half their time (in fact, most of their time,) reading the code they've written - so be good to yourself."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables\n",
    "\n",
    "The basic objects/data types in Python are integers, floats, strings and booleans. \n",
    "\n",
    "* **Integer:** A whole number\n",
    "* **Float:** A number with a decimal point\n",
    "* **String:** Text contained within quotation marks (can be single or double)\n",
    "* **Boolean:** True or False\n",
    "\n",
    "These can be pointed to using a variable. There are no $ signs to mark variables in Python, they must simply start with a letter or underscore (not a number!). Furthermore, variables are dynamic, they can change type within a script. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 2\n",
    "print(a)\n",
    "print(type(a))\n",
    "a = \"2b\"\n",
    "print(a, type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Variable names are case-sensitive\n",
    "age = 24\n",
    "Age = 26\n",
    "print(age, Age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# What happens when a new variable points to a previous variable?\n",
    "a = 1\n",
    "b = a\n",
    "a = 2\n",
    "## What is b?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operators\n",
    "All of the basic math operators work like you think they should for numbers. They can also do some useful operations on other things, like strings. There are also boolean operators that compare quantities and give back a bool variable as a result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Standard math operators work as expected on numbers\n",
    "a = 2\n",
    "b = 3\n",
    "print(a + b)\n",
    "print(a * b)\n",
    "print(a ** b)  # a to the power of b (a^b does something completely different!)\n",
    "print(a / b)   # Careful with dividing integers if you use Python 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# There are also operators for strings\n",
    "print('hello' + 'world')\n",
    "print('hello' * 3)\n",
    "#print('hello' / 3)  # You can't do this!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Boolean operators compare two things\n",
    "a = (1 > 3)\n",
    "b = (3 == 3)\n",
    "print(a)\n",
    "print(b)\n",
    "print(a or b)\n",
    "print(a and b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "\n",
    "Using a function is very easily, the syntax is simply `function_name(argument)`, we've already been using the functions `print()` and `type()`. Function names are usually lower-case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# There are thousands of functions that operate on things\n",
    "print(type(3))\n",
    "print(len('hello'))\n",
    "print(round(3.3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**TIP:** To find out what a function does, you can type it's name and then a question mark to get a pop up help window. Or, to see what arguments it takes, you can type its name, an open parenthesis, and hit tab."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "round?\n",
    "#round(\n",
    "round(3.14159, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__TIP:__ Many useful functions are not in the Python built in library, but are in external\n",
    "scientific packages. These need to be imported into your Python notebook (or program) before\n",
    "they can be used. Probably the most important of these are numpy and matplotlib."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Many useful functions are in external packages\n",
    "# Let's meet numpy\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To see what's in a package, type the name, a period, then hit tab\n",
    "#np?\n",
    "np."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Some examples of numpy functions and \"things\"\n",
    "print(np.sqrt(4))\n",
    "print(np.pi)  # Not a function, just a variable\n",
    "print(np.sin(np.pi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Methods\n",
    "\n",
    "Python is an object-orientated language, and so although we won't go into detail here about creating objects, you have already been using objects. Even simple things like ints and strings are objects in Python.\n",
    "\n",
    "In the simplest terms, you can think of an object as a small bundled \"thing\" that contains within\n",
    "itself both data and functions that operate on that data. For example, strings in Python are\n",
    "objects that contain a bunch of characters in order, and also various functions that operate on those\n",
    "characters. When bundled in an object, these functions are called \"methods\".\n",
    "\n",
    "Instead of the \"normal\" `function(arguments)` syntax, methods are called using the\n",
    "syntax `variable.method(arguments)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A string is actually an object\n",
    "a = 'hello, world'\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Objects have bundled methods\n",
    "#a.\n",
    "print(a.capitalize())\n",
    "print(a.replace('l', 'X'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists\n",
    "\n",
    "Python lists are ordered collections of things, each element of which is assigned an index (position). Lists can contain any type of object and are declared using square brackets `[]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lists are created with square bracket syntax\n",
    "a = ['blueberry', 'strawberry', 'pineapple']\n",
    "print(a, type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lists (and all collections) are also indexed with square brackets\n",
    "# NOTE: The first index is zero, not one\n",
    "print(a[0])\n",
    "print(a[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can access multiple items from a list by slicing, using a colon between indexes\n",
    "# NOTE: The end value is not inclusive\n",
    "print('a =', a)\n",
    "print('get first two:', a[0:2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can leave off the start or end if desired\n",
    "print(a[:2])\n",
    "print(a[2:])\n",
    "print(a[:])\n",
    "print(a[:-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lists are objects, like everything else, and have methods such as append\n",
    "a = ['blueberry', 'strawberry', 'pineapple']\n",
    "\n",
    "a.append('banana')\n",
    "print(a)\n",
    "\n",
    "a.append([1,2])\n",
    "print(a)\n",
    "\n",
    "a.pop()\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples\n",
    "\n",
    "Tuples are similar to lists, only:\n",
    "\n",
    "1. You declare tuples using ( ) instead of [ ]\n",
    "1. Once you make a tuple, you can't change what's in it (referred to as immutable)\n",
    "\n",
    "You'll see tuples come up throughout the Python language, and over time you'll develop a feel for when\n",
    "to use them. \n",
    "\n",
    "In general, they're often used instead of lists:\n",
    "\n",
    "1. To group items when the position in the collection is critical, such as coord = (x,y)\n",
    "1. When you want to make prevent accidental modification of the items, e.g. shape = (12, 23)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xy = (23, 45)\n",
    "print(xy[0])\n",
    "xy[0] = \"this won't work with a tuple\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries\n",
    "Dictionaries are the collection to use when you want to store and retrieve things by their names\n",
    "(or some other kind of key) instead of by their position in the collection. A good example is a set\n",
    "of model parameters, each of which has a name and a value. Dictionaries are declared using `{}`.  Unlike lists or tuples, dictionaries are not guaranteed to be in any particular order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make a dictionary of model parameters\n",
    "convertors = {'inches_in_feet' : 12,\n",
    "              'inches_in_metre' : 39}\n",
    "\n",
    "print(convertors)\n",
    "print(convertors['inches_in_feet'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Add a new key:value pair\n",
    "convertors['metres_in_mile'] = 1609.34\n",
    "print(convertors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Raise a KEY error\n",
    "print(convertors['blueberry'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can directly access the keys in your dictionary by using a dictionary method, note that these are then returned as a list. You can also use `items()` to retrieve a list of tuples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print the dictionary keys\n",
    "print(convertors.keys())\n",
    "\n",
    "# print a list of key:value pairs\n",
    "print(convertors.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy arrays (ndarrays)\n",
    "Even though numpy arrays (often written as ndarrays, for n-dimensional arrays) are not part of the core Python libraries, they are so useful in scientific Python that we'll include them here in the core lesson. Numpy arrays are collections of things, all of which must be the same type, that work similarly to lists (as we've described them so far). The most important are:\n",
    "\n",
    "You can easily perform elementwise operations (and matrix algebra) on arrays\n",
    "Arrays can be n-dimensional\n",
    "There is no equivalent to append, although arrays can be concatenated\n",
    "Arrays can be created from existing collections such as lists, or instantiated \"from scratch\" in a few useful ways.\n",
    "\n",
    "When getting started with scientific Python, you will probably want to try to use ndarrays whenever you're doing math or dealing with numerical data, saving the other types of collections for those cases when you have a specific reason to use them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We need to import the numpy library to have access to it \n",
    "# We can also create an alias for a library, this is something you will commonly see with numpy\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make an array from a list\n",
    "alist = [2, 3, 4]\n",
    "blist = [5, 6, 7]\n",
    "a = np.array(alist)\n",
    "b = np.array(blist)\n",
    "print(a, type(a))\n",
    "print(b, type(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Do element-wise arithmetic on arrays\n",
    "print(a**2)\n",
    "print(np.sin(a))\n",
    "print(a * b)\n",
    "\n",
    "# Do linear algegra on arrays\n",
    "print(a.dot(b), np.dot(a, b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Boolean operators work on arrays too, and they return boolean arrays\n",
    "print(a > 2)\n",
    "print(b == 6)\n",
    "\n",
    "c = a > 2\n",
    "print(c)\n",
    "print(type(c))\n",
    "print(c.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Indexing arrays\n",
    "print(a[0:2])\n",
    "\n",
    "c = np.random.rand(3,3)\n",
    "print(c)\n",
    "print('\\n')\n",
    "print(c[1:3,0:2])\n",
    "\n",
    "c[0,:] = a\n",
    "print('\\n')\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Arrays can also be indexed with other boolean arrays\n",
    "print(a)\n",
    "print(b)\n",
    "print(a > 2)\n",
    "print(a[a > 2])\n",
    "print(b[a > 2])\n",
    "\n",
    "b[a == 3] = 77\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ndarrays have attributes in addition to methods\n",
    "#c.\n",
    "print(c.shape)\n",
    "print(c.prod())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# There are handy ways to make arrays full of ones and zeros\n",
    "print(np.zeros(5), '\\n')\n",
    "print(np.ones(5), '\\n')\n",
    "print(np.identity(5), '\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can also easily make arrays of number sequences\n",
    "print(np.arange(0, 10, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## For loops\n",
    "\n",
    "To iterate through a list, range or any sequence you can use a python for loop. Unlike many other languages, python loops aren't inclosed within brackets or 'do; done;' notations. Instead loops are all defined by the indentation, this is one of the reasons that Python is such an easy to read language. \n",
    "\n",
    "**NOTE** In Python the default is to use four (4) spaces for each indentation, most editors can be configured to follow this guide."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A basic for loop - don't forget the white space!\n",
    "wordlist = ['hi', 'hello', 'bye']\n",
    "for word in wordlist:\n",
    "    print(word + '!')\n",
    "    \n",
    "print(\"No indentation so now we're outside the loop\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Indentation error: Fix it!\n",
    "for word in wordlist:\n",
    "    new_word = word.capitalize()\n",
    "   print(new_word + '!') # Bad indent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Often we want to loop over the indexes of a collection, not just the items\n",
    "print(wordlist)\n",
    "\n",
    "for i, word in enumerate(wordlist):\n",
    "    print(i, word, wordlist[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# While loops are useful when you don't know how many steps you will need,\n",
    "# and want to stop once a certain condition is met.\n",
    "step = 0\n",
    "prod = 1\n",
    "while prod < 100:\n",
    "    step = step + 1\n",
    "    prod = prod * 2\n",
    "    print(step, prod)\n",
    "    \n",
    "print('Reached a product of', prod, 'at step number', step)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## If conditionals\n",
    "\n",
    "To query whether a condition is True or False, we can use an if loop. These are very similar in syntax to other languages but do not require being inclosed in brackets. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A simple if statement\n",
    "x = 3\n",
    "if x > 0:\n",
    "    print('x is positive')\n",
    "elif x < 0:\n",
    "    print('x is negative')\n",
    "else:\n",
    "    print('x is zero')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# If statements can rely on boolean variables\n",
    "x = -1\n",
    "test = (x > 0)\n",
    "print(type(test))\n",
    "print(test)\n",
    "\n",
    "if test:\n",
    "    print('Test was true')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating functions\n",
    "\n",
    "It's very simple to create your own python functions, making pieces of your code easy to reuse."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# It's very easy to define your own functions, this one will take in two arguments\n",
    "def add2andmultiply(x, y):\n",
    "    # All the work goes here\n",
    "    addedx = x + 2\n",
    "    addedy = y + 2\n",
    "    return addedx * addedy # At the end we return something"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Once a function is \"run\" and saved in memory, it's available just like any other function\n",
    "print(type(add2andmultiply))\n",
    "print(add2andmultiply(x=5, y=10))\n",
    "\n",
    "myresult = add2andmultiply(4, 3)\n",
    "print(myresult)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# It's useful to include docstrings to describe what your function does\n",
    "def say_hello(time, people):\n",
    "    '''\n",
    "    Function says a greeting. Useful for engendering goodwill\n",
    "    '''\n",
    "    return 'Good ' + time + ', ' + people"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Docstrings**: A docstring is a special type of comment that tells you what a function does.  You can see them when you ask for help about a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "say_hello('afternoon', 'friends')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# All arguments must be present, or the function will return an error\n",
    "say_hello('afternoon')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Keyword arguments can be used to make some arguments optional by giving them a default value\n",
    "# All mandatory arguments must come first, in order\n",
    "def say_hello(time, people='friends'):\n",
    "    return 'Good ' + time + ', ' + people"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "say_hello('afternoon')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "say_hello('afternoon', 'students')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modules\n",
    "\n",
    "We can make our functions more easily reusable by placing them into modules that we can import, just\n",
    "like we have been doing with `numpy`. It's pretty simple to do this.\n",
    "\n",
    "1. Copy your function(s) into a new text file, make sure it has a '.py' extention\n",
    "1. You can then import it, like any other package (if the file is in the same directory). For subdirectory imports look up how to create a python package."
   ]
  },
  {
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}