{ "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": 1, "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": 2, "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": 3, "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": 4, "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": 5, "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": 6, "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": 8, "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": 9, "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": 10, "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": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'Jocelyn': 21, 'Newton': 84}\n", "21\n", "{'Jocelyn': 21, 'Newton': 84, 'Einstein': 76, 5: 'hi'}\n" ] } ], "source": [ "# dicts (maps)\n", "ages = {'Jocelyn': 21, 'Newton': 84}\n", "print(ages)\n", "print(ages['Jocelyn'])\n", "ages['Einstein'] = 76\n", "ages[5] = 'hi'\n", "print(ages)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Loops" ] }, { "cell_type": "code", "execution_count": 12, "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": 13, "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", "# can join the iterators together\n", "for f, pi, e in zip(fruit, a, b):\n", " print(f, pi, e)" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Jocelyn 20 20 20 20 20\n" ] } ], "source": [ "# while loops\n", "my_str = \"Jocelyn\"\n", "\n", "while len(my_str) < 20:\n", " my_str += ' 20'\n", "\n", "print(my_str)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Functions + Classes" ] }, { "cell_type": "code", "execution_count": 15, "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": 16, "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": 17, "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": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "A:\n", " [[1 2]\n", " [3 4]]\n", "[1 2]\n", "operations:\n", " [2 4]\n", "2\n", "[2 4]\n", "(2,)\n", "matrix transpose:\n", " [[1 3]\n", " [2 4]]\n", "matrix inverse:\n", " [[-2. 1. ]\n", " [ 1.5 -0.5]]\n" ] } ], "source": [ "A = np.array([[1,2], [3,4]]) # can create multidimensional arrays\n", "print(\"A:\\n\", A)\n", "print(A[0]) # indexing into rows\n", "print(\"operations:\\n\", A[:,1]) # indexing into columns\n", "print(A[0,1]) # indexing into rows and columns\n", "print(A[:,1].T) # transposing a column \n", "print(np.shape(A[:,1])) # shape of the matrix\n", "print(\"matrix transpose:\\n\", A.T)\n", "print(\"matrix inverse:\\n\", np.linalg.pinv(A))\n" ] }, { "cell_type": "code", "execution_count": 19, "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.90038264 0.86421204 0.8201528 0.2103761 0.71113902]\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": 21, "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": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "time: 0.0008039474487304688\n", "time: 0.07655882835388184\n", "speedup x: 95.22864768683274\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": 23, "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0, 0.5, '$x^2$')" ] }, "execution_count": 24, "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": [ "You can also plot multiple items in one graph" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0, 0.5, '$f(x)$')" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "xs = np.arange(5)\n", "linear = xs\n", "linear2 = 2 * xs\n", "linear3 = 5 - 3 * xs\n", "quadratic = xs ** 2 - 5\n", "\n", "plt.plot(xs, linear, 'o-', label=\"$f(x)=x$\")\n", "plt.plot(xs, linear2, 'o-', label=\"$f(x)=2x$\")\n", "plt.plot(xs, linear3, 'o-', label=\"$f(x)=5 - 3x$\")\n", "plt.plot(xs, quadratic, 'o-', label=\"$f(x)= x^2 - 5$\") # you can format the labels using latex syntax\n", "\n", "plt.legend()\n", "plt.title('function plots')\n", "plt.xlabel('$x$')\n", "plt.ylabel('$f(x)$')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Seaborn\n", "Seaborn is another libary that can be used to visualize data which is based on matplotlib. Seaborn provides a high-level interface for drawing attrative and informative statistical graphs.\n", "\n", "Lets plot the same functions as above but using seaborn instead." ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
$f(x)=x$$f(x)=2x$$f(x)=5 - 3x$$f(x)= x^2 - 5$
0005-5
1122-4
224-1-1
336-44
448-711
\n", "
" ], "text/plain": [ " $f(x)=x$ $f(x)=2x$ $f(x)=5 - 3x$ $f(x)= x^2 - 5$\n", "0 0 0 5 -5\n", "1 1 2 2 -4\n", "2 2 4 -1 -1\n", "3 3 6 -4 4\n", "4 4 8 -7 11" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import pandas as pd\n", "\n", "d = {'$f(x)=x$': linear, '$f(x)=2x$': linear2, '$f(x)=5 - 3x$': linear3, '$f(x)= x^2 - 5$': quadratic}\n", "df = pd.DataFrame(data=d)\n", "df" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[Text(0, 0.5, 'f(x)'), Text(0.5, 0, 'x')]" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import seaborn as sns\n", "\n", "ax = sns.lineplot(data=df)\n", "ax.set(xlabel=\"x\", ylabel=\"f(x)\")" ] }, { "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": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " 1\r\n" ] } ], "source": [ "!find . -name \"*.ipynb\" | wc -l" ] }, { "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.8.3" } }, "nbformat": 4, "nbformat_minor": 2 }