{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Python Introduction" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Variables\n", "In Python, types of variables are automatically inferred by the interpreter" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "department: Paul G. Allen School\n", "number: 446\n", "pi: 3.141\n", " \n" ] } ], "source": [ "school = \"Paul G. Allen School\" # creates a variable of type str\n", "number = 446 # int\n", "pi = 3.141 # float\n", "\n", "print(\"department:\", school)\n", "print(\"number:\", number)\n", "print(\"pi:\", pi)\n", "\n", "print(type(school), type(number), type(pi))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Math operations" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "17\n", "3.25\n", "3\n", "16\n" ] } ], "source": [ "a = 13\n", "b = 4\n", "\n", "print(a + b)\n", "print(a / b) # floating point division\n", "print(a // b) # integer division\n", "print(b**2) # powers are built-in" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Conditionals\n", "Python cares about whitespace! There are no brackets or end statements\n", "\n", "Instead of &&, ||, !, we use 'and', 'or', and 'not'.\n", "\n", "Boolean values are written as 'True' and 'False'" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "hello there!\n", "this always prints\n" ] } ], "source": [ "a = 9.1\n", "b = 7\n", "\n", "# basic if else syntax\n", "if a < 10:\n", " print('hello there!')\n", "else:\n", " print('general kenobi')\n", "\n", "print('this always prints')" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "and\n", "or\n" ] } ], "source": [ "# and syntax\n", "if a < 10 and b > 5:\n", " print('and')\n", "\n", "# or syntax\n", "if a > 10 or b > 5:\n", " print('or')" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "a != b\n" ] } ], "source": [ "# else, else if syntax\n", "if False:\n", " print('this never prints')\n", "elif a != b:\n", " print('a != b')\n", "else:\n", " print('else!')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Data Structures" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['apple', 'pear', 'tomato', 'avocado']\n", "apple\n", "tomato\n", "['pear', 'tomato']\n", "['apple', 'pear', 'tomato', 'salmon']\n" ] } ], "source": [ "# Lists\n", "fruit = ['apple', 'pear', 'tomato', 'avocado']\n", "print(fruit)\n", "print(fruit[0])\n", "print(fruit[-2]) # can use reverse indexing\n", "print(fruit[1:3]) # can index multiple items [inclusive, exclusive)\n", "fruit[3] = 'salmon' # can assign items in list\n", "\n", "print(fruit)" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "4\n", "True\n" ] } ], "source": [ "print(len(fruit))\n", "print('pear' in fruit) # can check for existence in a list (\"contains()\")" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['apple', 'pear', 'tomato', 'salmon', 'trout']\n", "5\n" ] } ], "source": [ "fruit.append('trout') # lists are mutable\n", "\n", "print(fruit)\n", "print(len(fruit))" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(1, 2, 3)\n", "2\n", "3\n", "2\n" ] } ], "source": [ "# tuples\n", "tupperware = (1,2,3)\n", "print(tupperware)\n", "print(tupperware[1])\n", "a, b, c = tupperware # can unpack tuples\n", "_, d, _ = tupperware # ignore the elements you don't care about\n", "print(c)\n", "print(d)" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "'tuple' object does not support item assignment\n" ] } ], "source": [ "try:\n", " tupperware[1] = 4 # cannot modify tuples\n", "except Exception as e:\n", " print(e)" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'Ben': 21, 'Newton': 84}\n", "21\n", "{'Ben': 21, 'Newton': 84, 'Einstein': 76, 5: 'hi'}\n" ] } ], "source": [ "# dicts (maps)\n", "ages = {'Ben': 21, 'Newton': 84}\n", "print(ages)\n", "print(ages['Ben'])\n", "ages['Einstein'] = 76\n", "ages[5] = 'hi'\n", "print(ages)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Loops" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "1\n", "2\n", "3\n", "4\n", "\n", "apple\n", "pear\n", "tomato\n", "salmon\n", "trout\n" ] } ], "source": [ "# basic for loops\n", "for i in range(5):\n", " print(i)\n", " \n", "print()\n", "\n", "# can loop over any iterable\n", "for f in fruit:\n", " print(f)" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0 apple\n", "1 pear\n", "2 tomato\n", "3 salmon\n", "4 trout\n", "\n", "apple 3 2\n", "pear 1 7\n", "tomato 4 1\n", "salmon 1 8\n", "trout 5 2\n" ] } ], "source": [ "# advanced for loops\n", "for idx, item in enumerate(fruit):\n", " print(idx, item)\n", " \n", "print()\n", "\n", "a = [3, 1, 4, 1, 5]\n", "b = [2, 7, 1, 8, 2]\n", "\n", "for f, pi, e in zip(fruit, a, b):\n", " print(f, pi, e)" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Ben 10 10 10\n" ] } ], "source": [ "# while loops\n", "my_str = \"Ben\"\n", "\n", "while len(my_str) < 10:\n", " my_str += ' 10'\n", "\n", "print(my_str)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Functions + Classes" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "16\n" ] } ], "source": [ "# this is a function\n", "def square_this(x):\n", " return x * x\n", "\n", "print(square_this(4))\n" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "method: 9\n", "static method: 125\n", "a: 3\n", "b: 4\n" ] } ], "source": [ "class Squaring:\n", " \n", " # this is the constructor\n", " def __init__(self, a, b=4):\n", " self._a = a\n", " self._b = b\n", " \n", " # this is a method\n", " def square(self, x):\n", " return x * x\n", " \n", " # this is a static method\n", " @staticmethod\n", " def mymethod(x):\n", " return x**3\n", "\n", "sq = Squaring(3)\n", "print('method:', sq.square(3))\n", "print('static method:', Squaring.mymethod(5))\n", "print('a:', sq._a)\n", "print('b:', sq._b)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Numpy\n", "Numpy is a powerful scientific computing library for Python. It uses C/C++ in the background to speed up computation" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[6 6 6 6 6]\n", "[5 8 9 8 5]\n", "[4 5]\n", "\n" ] } ], "source": [ "import numpy as np\n", "\n", "a = np.array([1,2,3,4,5])\n", "b = np.array([5,4,3,2,1])\n", "c = a + b # can do elementwise operations\n", "print(c)\n", "print(a*b)\n", "print(a[3:5]) # can use same indexing as lists\n", "print(type(a))" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[1 2]\n", " [3 4]]\n", "[1 2]\n", "[2 4]\n", "4 4\n", "[2 4]\n", "(2,)\n" ] } ], "source": [ "A = np.array([[1,2], [3,4]]) # can create multidimensional arrays\n", "print(A)\n", "print(A[0]) # indexing into rows\n", "print(A[:,1]) # indexing into columns\n", "print(A[1,1], A[1][1]) # indexing into rows and columns\n", "print(A[:,1].T) \n", "print(np.shape(A[:,1]))\n" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[0. 0. 0. 0.]\n", " [0. 0. 0. 0.]\n", " [0. 0. 0. 0.]\n", " [0. 0. 0. 0.]]\n", "[1. 1. 1.]\n", "[0.83552593 0.57607911 0.06048051 0.43451815 0.85622641]\n" ] } ], "source": [ "# can create special types of arrays\n", "a = np.zeros((4,4))\n", "b = np.ones(3)\n", "c = np.random.random(5)\n", "print(a)\n", "print(b)\n", "print(c)" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[2 2]\n", " [3 5]]\n", "\n", "[[1 2]\n", " [3 4]]\n", "[[1 0]\n", " [0 4]]\n" ] } ], "source": [ "# matrices\n", "A = np.array([[1,2],[3,4]])\n", "B = np.array([[1, 0],[0, 1]]) # identity matrix (same as np.eye(2))\n", "\n", "print(A + B)\n", "print()\n", "print(A @ B)#@ is matrix multiplication \n", "print(A * B)#* is elementwise multiplication. You probably don't mean this" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[1 1]\n", " [2 2]\n", " [3 3]]\n", "12\n", "[6 6]\n", "[2 4 6]\n" ] } ], "source": [ "# numpy functions (see documentation for more)\n", "A = np.array([[1,1],[2,2],[3,3]])\n", "print(A)\n", "print(np.sum(A)) # can sum all elements\n", "print(np.sum(A, axis=0)) # can also sum along a dimension (0)\n", "print(np.sum(A, axis=1)) # can also sum along a dimension (1)\n" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "time: 0.0007281303405761719\n", "time: 0.051100969314575195\n", "speedup x: 70.18107400130975\n" ] } ], "source": [ "# use numpy to speedup computation\n", "# as a rule, use numpy operations to calculate things, not for loops.\n", "# e.g. call np.dot don't sum over a for loop of the elements.\n", "import time\n", "n = 100000\n", "a = np.ones(n)\n", "b = np.ones(n)\n", "start = time.time()\n", "\n", "res = a + b\n", "\n", "numpy_time = time.time() - start\n", "print(\"time:\", numpy_time)\n", "\n", "res = []\n", "start = time.time()\n", "\n", "for i in range(n):\n", " res.append(a[i] + b[i])\n", " \n", "loop_time = time.time() - start\n", "print(\"time:\", loop_time)\n", "\n", "print(\"speedup x:\", loop_time / numpy_time)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Matplotlib\n", "Matplotlib is a library used to visualize data. A useful technique when generating matplotlib plots in a notebook is that we can use the \"magic\" command `%matplotlib inline` to have the generated plots automatically shown in a cell; this saves some additional Python code which would be required to show the plots (e.g. `plt.show()`)." ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0, 0.5, '$x^2$')" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "%matplotlib inline\n", "# basic plotting (show scatter and plot)\n", "xs = np.arange(10)\n", "ys = xs ** 2\n", "plt.scatter(xs, ys)\n", "plt.plot(xs, ys)\n", "\n", "# ALWAYS label your plots!\n", "plt.title('plot of $x^2$ vs $x$')\n", "plt.xlabel('$x$')\n", "plt.ylabel('$x^2$')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Shell commands in IPython notebooks" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "IPython notebooks support the use of shell commands directly in a notebook; simply prepend the command with `!` and the IPython kernel will execute the code from the shell, not the Python interpreter." ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " 2\r\n" ] } ], "source": [ "!find . -name \"*.ipynb\" | wc -l" ] } ], "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": 2 }