{ "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": 75, "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": 76, "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": 79, "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": 42, "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": 43, "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": 82, "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": 7, "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": 80, "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": 50, "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": 83, "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "'tuple' object does not support item assignment", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mtupperware\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m4\u001b[0m \u001b[1;31m# cannot modify tuples\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment" ] } ], "source": [ "tupperware[1] = 4 # cannot modify tuples" ] }, { "cell_type": "code", "execution_count": 53, "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": 54, "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" ] } ], "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": 77, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0 apple\n", "1 pear\n", "2 tomato\n", "3 salmon\n", "\n", "apple 3 2\n", "pear 1 7\n", "tomato 4 1\n", "salmon 1 8\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": 59, "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": 84, "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": 87, "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.2267819 0.28742187 0.8448848 0.54121545 0.71823732]\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": 20, "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": 89, "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", "(3,)\n", "(2,)\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": 90, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "time: 0.0049974918365478516\n", "time: 0.06496334075927734\n", "speedup x: 12.99918896999189\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" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", "execution_count": 93, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# 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$')\n", "plt.show()" ] }, { "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.7.2" } }, "nbformat": 4, "nbformat_minor": 2 }