Cheatsheet.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python cheat sheet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Single-line comments in Python are denoted by a hash character. You can also make longer comments which can span multiple lines by encasing text in triple quotation marks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This is also a comment\\n\\n\\nBut it is over several lines\\n'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This is a comment\n",
    "\n",
    "\"\"\"This is also a comment\n",
    "\n",
    "\n",
    "But it is over several lines\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Printing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Printing in Python is done with the `print()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `print()` can print multiple things at once by separating them with commas. Strings can include escape characters such as `\\t` (tab) and `\\n` (newline)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\tThis is a bigger print statement over 2 lines.\n",
      "Isn't it great?\n"
     ]
    }
   ],
   "source": [
    "print(\"\\tThis is a bigger print statement over\",\n",
    "      2, \"lines.\\nIsn't it great?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variables and operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variables are defined as you would expect, but note that unlike Fortran and other low-level languages, you do not need to declare variables before defining them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Define an integer\n",
    "x = 1\n",
    "\n",
    "# Define a float\n",
    "x = 3.14\n",
    "\n",
    "# Define a string in different ways\n",
    "x = 'This is a string'\n",
    "y = \"This is also a string\"\n",
    "z = \"\"\"This is a long string.\n",
    "Just like the comment earlier.\"\"\"\n",
    "\n",
    "# Define some booleans\n",
    "x = True\n",
    "y = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Basic operators are also as you would expect (`+`, `-`, `*`, `/`, `**`). When performing an operation with variables of different types, Python will try to cast one to the other's type if appropriate. Otherwise it will fail and raise an `Exception` (a runtime error)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "4.140000000000001\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-5-c4afba7f1571>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m3.14\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'3'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "print(1 + 3)\n",
    "print(1 + 3.14)\n",
    "print(1 + '3')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sequences"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The basic sequence type is the _list_, which is defined with square brackets around comma-separated items. Each item in a list can have any type - they don't all need to be the same. As well as allowing you to group different types together in a sequence, this also allows you to nest another sequence within your list.\n",
    "\n",
    "Lists are _mutable_, which is to say that once defined, the list is not fixed forever - you can add or remove items as you please."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['string', 1, [4.2, 'another string']]\n",
      "['string', 1, [4.2, 'another string'], 'new item']\n",
      "[1, [4.2, 'another string'], 'new item']\n",
      "[1, 2, 3, 'one', 'two', 'three']\n"
     ]
    }
   ],
   "source": [
    "# Define some lists\n",
    "x = [1, 2, 3]\n",
    "y = ['one', 'two', 'three']\n",
    "z = ['string', 1, [4.2, 'another string']]\n",
    "\n",
    "# Add to a list\n",
    "print(z)\n",
    "z.append('new item')\n",
    "print(z)\n",
    "\n",
    "# Remove from a list\n",
    "z.remove('string')\n",
    "print(z)\n",
    "\n",
    "# Concatenate two lists\n",
    "print(x + y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indices and slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sequences are indexed with square brackets, and indices start at 0. Nested sequences are indexed with separate brackets.\n",
    "\n",
    "You can slice from one index position to another by putting a colon between indices. Note that when doing this, the result is not inclusive of the end index. Putting another integer after a second colon will specify the increment between items in the slice. With this syntax, you can omit the start index, which will then default to 0, or the end index, which will default to the end of the sequence.\n",
    "\n",
    "You can also index sequences backwards with negative indices. Note that in this case the last element is at index -1, not 0. Similarly, increments in slices can be negative, causing the items in the resulting slice to be backwards compared to the original list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "# Get the first item of a list\n",
    "print(x[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "another string\n"
     ]
    }
   ],
   "source": [
    "# Reference a list in a list\n",
    "a = z[-2][1]\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['two', 'three']\n",
      "['two', 'three']\n"
     ]
    }
   ],
   "source": [
    "# Slice a list from the second element to the last\n",
    "print(y[1:3])\n",
    "# Or, equivalently\n",
    "print(y[1:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[4.2, 'another string'], 'new item']\n"
     ]
    }
   ],
   "source": [
    "# Slice a list from the second-to-last element to the last\n",
    "print(z[-2:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1]\n",
      "[1, 'new item']\n"
     ]
    }
   ],
   "source": [
    "# Index with an increment\n",
    "print(z[0:-1:2])\n",
    "# Or, equivalently\n",
    "print(z[::2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['new item', [4.2, 'another string'], 1]\n"
     ]
    }
   ],
   "source": [
    "# Index backwards\n",
    "print(z[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Other sequences"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python treats strings as a kind of sequence and as such they are indexed in the same way as lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "another string\n",
      "r\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "# Index a string\n",
    "print(a[6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another useful type of sequence in Python is the _dictionary_, or _dict_. This is an unordered grouping of (_key_, _value_) pairs. Both the key and the value can be any type. Values are accessed similarly to items in lists, but by specifying the key rather than an index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'second number': 42, 'first number': 3.14, 'third number': 'something else'}\n",
      "42\n"
     ]
    }
   ],
   "source": [
    "# Define a dict\n",
    "x = {'first number': 3.14, 'second number': 42,\n",
    "     'third number': 'something else'}\n",
    "\n",
    "# Print the dict to note that the entries\n",
    "# are not stored in the order we specified\n",
    "print(x)\n",
    "\n",
    "# Get the value associated with the key 'second number'\n",
    "print(x['second number'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comparison operators work in the same way as in most other languages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n",
      "False\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Compare some variables\n",
    "x = 3\n",
    "y = 5\n",
    "\n",
    "print(x < y) # Less than\n",
    "print(x > y) # Greater than\n",
    "print(x <= y) # Less than or equal to\n",
    "print(x >= y) # Greater than or equal to\n",
    "print(x == y) # Equal to\n",
    "print(x != y) # Not equal to"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`if` statements consist of the `if` keyword followed by a condition and a colon, then an indented block of code to run if the condition is met. Note that the indentation is not just aesthetic - it is part of the syntax and an improperly indented if statement will raise an `IndentationError`.\n",
    "\n",
    "Blocks can be indented by any amount, as long as it is the same for every line within any one block, but the convention is four spaces (in a Jupyter notebook, the tab key will insert four spaces rather than a tab character). Since the extent of the `if` block is defined by the indentation, there is no 'end if' in Python.\n",
    "\n",
    "Optionally, `if` blocks can include one or more `elif` (short for 'else if') clause and/or an `else` clause."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y is smaller\n"
     ]
    }
   ],
   "source": [
    "# A basic if block with multiple clauses\n",
    "if x > y:\n",
    "    print('x is larger')\n",
    "elif x < y:\n",
    "    print('y is smaller')\n",
    "else:\n",
    "    print('x and y are equal')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `for` loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To loop over a sequence in Python, we use the `for` keyword. The syntax for this is similar to that for `if` statements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# For loop syntax\n",
    "for item in sequence:\n",
    "    do some things\n",
    "    in an indented block"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember that the indentation is \n",
    "\n",
    "Note that what Python is actually doing here is not quite the same as loops in most other languages. Rather than iterating over a range of numbers that you use to index a sequence (although you can do this) it is actually iterating directly over the items in the specified sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "one\n",
      "2.0\n",
      "[3, '.14']\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# Loop over a list\n",
    "for x in [0, 'one', 2.0, [3, '.14'], 4]:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `while` loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python also has a `while` loop for repeating code until a condition is met. Again, the syntax for this is similar to what we've seen already."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "\n",
    "while x < 5:\n",
    "    print(x)\n",
    "    x = x + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Syntax for function definitions is again similar - statement, colon, indented block. The definition is specified by a `def` keyword, followed by the name of the function, then the arguments to the function in brackets and separated by commas.\n",
    "\n",
    "The `return` statement allows you to specify the output of the function. Without a `return` statement, the default output of a function is `None`, which is a null variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "# Define a function with an argument\n",
    "def times(x, y):\n",
    "    \"\"\"Multiply two numbers, x and y.\"\"\"\n",
    "    return x * y\n",
    "\n",
    "# Call the function\n",
    "x = times(3, 3)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's important to notice here that there are different definitions of x inside and outside the function. This is because Python separates variables into _namespaces_, to reduce the risk of variables being accidentally overwritten. The function has its own namespace, and only knows about the variables defined there or passed in from outside.\n",
    "\n",
    "As well as normal arguments, functions can take _keyword arguments_, or _kwargs_. These define default values for the argument and can be passed to a function in any order using the keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "81 729 729\n"
     ]
    }
   ],
   "source": [
    "# Define a new function with a kwarg\n",
    "def topower(x, power=2):\n",
    "    \"\"\"Raise a number x to power.\"\"\"\n",
    "    return x ** power\n",
    "\n",
    "# Three ways of calling the function\n",
    "print(topower(x), topower(x, 3), topower(x, power=3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "81 2.080083823051904 2.080083823051904 3.0\n"
     ]
    }
   ],
   "source": [
    "# Define a function with multiple kwargs\n",
    "def topower(x, power=2, root=False):\n",
    "    \"\"\"Raise a number x to a power, or find the power-th root.\"\"\"\n",
    "    if root:\n",
    "        y = x ** (1 / power)\n",
    "    else:\n",
    "        y = x ** power\n",
    "    \n",
    "    return y\n",
    "\n",
    "# Kwargs can be used individually or together,\n",
    "# and in any order (as long as the keyword is used)\n",
    "print(topower(9),\n",
    "      topower(9, 3, True),\n",
    "      topower(9, root=True, power=3),\n",
    "      topower(x, root=True))"
   ]
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}