{ "nbformat": 4, "nbformat_minor": 0, "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.5" }, "colab": { "provenance": [], "collapsed_sections": [ "wugqn01Eo6uK" ] } }, "cells": [ { "cell_type": "markdown", "metadata": { "id": "kon_YiKko6tH" }, "source": [ "# CS221 Python Review Tutorial\n", "\n", "Presenter: Dilara\n", "\n", "Hi! In this tutorial, we will review the basics of Python. This tutorial is largely based on the [CS224N Python Tutorial](http://web.stanford.edu/class/cs224n/readings/cs224n-python-review-code-updated.zip), prepared by Angelica Sun, as well as the [W3Schools Python Tutorial](https://www.w3schools.com/python/).\n", "\n", "## Contents\n", "\n", "* Fundamentals\n", "* Control Flows\n", "* Functions\n", "* Classes\n", "* Iterables\n", "* Q&A" ] }, { "cell_type": "markdown", "metadata": { "id": "g5MyzBMeo6tW" }, "source": [ "## Fundamentals\n", "\n", "### Syntax\n", "\n", "We can run a Python file through the command line as follows:\n", "\n", "```\n", "python example.py\n", "```\n", "\n", "This line of code will call the `Python` version that is bound to `python` alias in the command line environment. You would sometimes get `Module Not Found` errors. One of the first troubleshooting steps you can do is to actually check whether you are using the correct `Python` binary. To learn which `Python` is being called, you can run:\n", "\n", "```\n", "which python\n", "```\n", "\n", "Let's start with printing \"Hello World!\"" ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "bS-2lFSmRicu", "outputId": "ba75ed43-ae72-4982-ad58-ca454cba5697" }, "source": [ "# Printing Hello World!\n", "print(\"Hello World!\")" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "Hello World!\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "SKPRPmIJTWD0" }, "source": [ "Indentation is important in `Python`. Lines of code that are in the same block of code should be indented with the same number of spaces." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 132 }, "id": "Ly6ZxRUCTVbd", "outputId": "734a3e78-10ee-435e-bbbc-b0084dd08901" }, "source": [ "# Example of an Indentation Error\n", "print(\"Hello\")\n", " print(\"Hello World!\")" ], "execution_count": null, "outputs": [ { "output_type": "error", "ename": "IndentationError", "evalue": "ignored", "traceback": [ "\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m3\u001b[0m\n\u001b[0;31m print(\"Hello World!\")\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m unexpected indent\n" ] } ] }, { "cell_type": "markdown", "metadata": { "id": "9FsiH-Z4Ul3c" }, "source": [ "You can use line comments or block comments to comment code in `Python`." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "xbl9Q9ECUlTW", "outputId": "7903b8e5-08a7-437b-e408-5e0d8d7f63e8" }, "source": [ "# Line comment\n", "\n", "\"\"\"\n", "Block comment\n", "\"\"\"\n", "\n", "print(\"Hi!\")" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "Hi!\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "0ObB8VtCUEsP" }, "source": [ "### Variables\n", "\n", "In `Python`, variables are defined by assigning value to them. There is no need to explicitly declare the type of a variable." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "wZFgDcM4o6te", "outputId": "802cacd1-078a-44e1-ad6d-560adb168a78" }, "source": [ "# str, immutable\n", "var = \"hello\" # ''\n", "print(type(var))" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "PqdLmxccXCGa", "outputId": "ab83ac06-17dd-4ec6-ac11-822fe13fafe6" }, "source": [ "# int, immutable\n", "var = 10\n", "print(type(var))" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "ZmvDAvPbWzBg", "outputId": "0e27eafa-ef5c-4c9d-a4fe-a03e20dd0a4a" }, "source": [ "# float, immutable\n", "var = 10.0\n", "print(type(var))" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "ADVFU3l-XGW8", "outputId": "1d1af822-e407-4ae3-8bf9-ed289645c98d" }, "source": [ "# bool, immutable\n", "var = True # False\n", "print(type(var))" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "H3iFhJRlylvB", "outputId": "847101a5-35f6-4b8d-8cf3-8f6a42e73ca1" }, "source": [ "# tuple, immutable\n", "# collections of objects\n", "var = (8,9)\n", "print(type(var))" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "kQldl4vcXJl9", "outputId": "0e4f4179-8861-4552-f700-9554064bb118" }, "source": [ "# list\n", "var = [1,2,3]\n", "print(type(var))" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "e7rA5rhlW2Ua", "outputId": "7312dbe9-37b6-4284-89bd-874efea1bc7b" }, "source": [ "# None\n", "var = None\n", "print(type(var))" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "b5bFUVlGV2IH" }, "source": [ "We can re-assign a variable to a different type." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "zYyhlcEJV6RK", "outputId": "44ace863-6982-4335-84e3-61981787fe75" }, "source": [ "var = 10\n", "print(type(var))\n", "var = \"Hi 221!\"\n", "print(type(var))" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "\n", "\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "pXsTTdxhXczT" }, "source": [ "We can cast variables to different types." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "sDtG68Vqo6tf", "outputId": "d6a54576-fdcd-4b84-8c35-628c8c9155dc" }, "source": [ "a = 10\n", "print(a, type(a))\n", "\n", "b = str(a)\n", "print(b, type(b))\n", "\n", "c = int(b)\n", "print(c, type(c))\n", "\n", "d = float(c)\n", "print(d, type(d))" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "10 \n", "10 \n", "10 \n", "10.0 \n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "d88q8KFiYkU5" }, "source": [ "Variable names are sensitive to case." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "Z35h7buwYnkK", "outputId": "5eadd3bd-fb31-40ec-ca57-7bbcca27501f" }, "source": [ "a = 10\n", "A = \"221\"\n", "print(a == A)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "False\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "EQ9WzOLpY7D5" }, "source": [ "We can assign values to multiple variables in one line." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "CgTUIBXKY-K8", "outputId": "3201e9c7-d630-481a-e7ed-4a1de5774847" }, "source": [ "a, b, c = \"I\", \"love\", \"CS221\"\n", "print(a)\n", "print(b)\n", "print(c)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "I\n", "love\n", "CS221\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "AJjUP9Laac2E" }, "source": [ "We can also print multiple variables in one `print` statement by seperating them with a comma." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "_GZ7VQXEaelm", "outputId": "2fd59fc9-0bf7-4429-820d-34c9d7008bb1" }, "source": [ "a, b, c = \"I\", \"love\", \"CS221\"\n", "print(a, b, c)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "I love CS221\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "GeHeASLcZpcu" }, "source": [ "### Operations\n", "\n", "#### Number Operations\n", "\n", "You can use math operators on variables and literals." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "V5sP_1QQba1U", "outputId": "f68059e7-0bde-43e9-e59b-7d120f7def6d" }, "source": [ "var = 10\n", "print(var + 4)\n", "print(var - 4)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "14\n", "6\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "Wef3S0VdbofN", "outputId": "b603e23d-a790-4b58-f8ea-ca9374ea7d6d" }, "source": [ "# Multiply with *\n", "print(var * 4)\n", "\n", "# Raise power with **\n", "print(var ** 4)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "40\n", "10000\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "nr4ZbHlZbgTJ", "outputId": "7603c928-5570-4a3f-f637-e80a874148b9" }, "source": [ "# Float division with /\n", "print(var / 4)\n", "\n", "# Integer division with //\n", "print(var // 4)\n", "\n", "# Integer division is the same as dividing then casting\n", "print(int(var / 4))" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "2.5\n", "2\n", "2\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "wjSXnKMtcS1I" }, "source": [ "We can also use compounding operators for each." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "l304SQEdcSIn", "outputId": "17c253fa-486a-4ca5-a693-84aa588ee8cd" }, "source": [ "print(var)\n", "var **= 4\n", "print(var)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "10\n", "10000\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 167 }, "id": "4_d5vlWNiBke", "outputId": "284aa733-ea39-4d36-b5d6-dd4dbe27345b" }, "source": [ "--a" ], "execution_count": null, "outputs": [ { "output_type": "error", "ename": "TypeError", "evalue": "ignored", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ma\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str" ] } ] }, { "cell_type": "markdown", "metadata": { "id": "NTSog3DUco7f" }, "source": [ "#### Boolean Operations\n", "\n", "Boolean operations are `not`, `and`, and `or`." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "aP6-LpBIo6tj", "outputId": "9cee0dd9-a185-4339-989b-331ebb46909a" }, "source": [ "print(not True)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "False\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "6vYrzWqkc70o", "outputId": "792ba493-b264-4fba-f5af-7508920a21a1" }, "source": [ "print(True and False)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "False\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "cKIDh4cYdCct", "outputId": "45a78590-cbfe-4f22-eea3-24c287911476" }, "source": [ "var = True or False\n", "print(var)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "True\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "DjDQFW7bdclb" }, "source": [ "`==` checks value equality. `!=` checks inequality." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "iHCGui23difG", "outputId": "4e075454-60f0-4740-efe4-2d4faca6c171" }, "source": [ "a = \"221\"\n", "b = \"221\"\n", "print(a == b)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "True\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "9z0wa6SweCIO" }, "source": [ "Operations `>=` and `<=` are available when the order is defined. Refer to this [link](https://www.geeksforgeeks.org/sorting-objects-of-user-defined-class-in-python/) to learn how to define order for user defined classes." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "2LJGhoBQeHd0", "outputId": "a7a612c3-003c-4cd3-ff12-dc40a20d0878" }, "source": [ "a = 6\n", "b = 8\n", "print(b >= a)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "True\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "SZ6GfhgOdQz5" }, "source": [ "#### String Operations\n", "\n", "For strings, double quotes and single quotes are equivalent." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "i-EFzJA7XhKg", "outputId": "7050fbaf-5f19-44cb-e049-b46bdb5c5fab" }, "source": [ "a = \"221\"\n", "b = '221'\n", "print(a >= b)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "True\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "WL3TFqR5e-ux" }, "source": [ "We can get the length of a string. `len` function can be used on any `iterable`. Strings are iterables in `Python`, so they can just be treated as arrays." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "1W1ORPaLfDul", "outputId": "b0f41e82-8750-4b72-b7ba-a53a61af281b" }, "source": [ "a = \"I love CS221!\"\n", "print(len(a))" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "13\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "aL2NGVmHfLPs" }, "source": [ "We can access specific elements of a string through their indices." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "1f7zboZGfYOJ", "outputId": "3467d97e-5514-48a9-e120-c6c15b59098f" }, "source": [ "print(a[0])" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "I\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "ZguxFX8HffQT", "outputId": "228df4b1-de4e-4aa2-ee31-86de5cd498f9" }, "source": [ "# [start_index, end_index)\n", "print(a[2:6])" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "love\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "pr1qCjllhORU" }, "source": [ "We can lower all the charaters in a string." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "Kulr99AshNfA", "outputId": "6e8703b9-8a4c-460e-fc5c-abb41adf0d60" }, "source": [ "print(a.lower())" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "i love cs221!\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "VYznaNf0hZtX" }, "source": [ "We can multiply a string." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "SGaBRMZlhdYr", "outputId": "38405ae2-1eb4-42bc-e1af-80b96f5c1b7c" }, "source": [ "print(a * 4)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "I love CS221!I love CS221!I love CS221!I love CS221!\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "SsyUJxalhgKj" }, "source": [ "We can concatenate strings." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "-kNbX0ZOhsGz", "outputId": "2838a2c7-7e84-404f-a1cc-6777dde5d1d7" }, "source": [ "b = \"How about you?\"\n", "c = a + \" \" + b\n", "print(c)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "I love CS221! How about you?\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "1eWp-_bdh4xg" }, "source": [ "We can check if a substring exists in a string. We can also get the start index of the first occurence of a substring." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "z-KZ6PsVh5cc", "outputId": "713b0b71-c603-46a2-97c3-b9e395bc8dfd" }, "source": [ "print(\"love\" in a)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "True\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "id": "UYaExPmsi3M2" }, "source": [ "if \"love\" not in a:\n", " print(\"yeyyy\")" ], "execution_count": null, "outputs": [] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "b8Y9YInEkj8U", "outputId": "ea09a33a-c5f5-4177-808d-ed384315e82a" }, "source": [ "print(\"love\" not in a)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "False\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "bfB_vufGiHNE", "outputId": "113b4cc4-5300-4b6a-9a9b-45c61fd5de05" }, "source": [ "a.index(\"love\")" ], "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "2" ] }, "metadata": { "tags": [] }, "execution_count": 34 } ] }, { "cell_type": "markdown", "metadata": { "id": "lGD4FEI7iMM7" }, "source": [ "We can split a string." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "IlmNdwM1iN04", "outputId": "c8e2cc05-d4e7-41d0-eddd-f55bf2bf7c2b" }, "source": [ "# The default delimiter is a space, but we can pass a different delimiter\n", "a.split()\n" ], "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "['I', 'love', 'CS221!']" ] }, "metadata": { "tags": [] }, "execution_count": 35 } ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "l80WOUvBjt0G", "outputId": "7bb6ab9d-60ac-4057-d288-7ff218568541" }, "source": [ "a.split('2')" ], "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "['I love CS', '', '1!']" ] }, "metadata": { "tags": [] }, "execution_count": 36 } ] }, { "cell_type": "markdown", "metadata": { "id": "-r8JrMpLiz2g" }, "source": [ "We can combine a list." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "Vs7mynmvi5Mk", "outputId": "e2dc4469-f0c4-4bb2-c8c3-58a0efd6b0fa" }, "source": [ "a_splitted = a.split()\n", "print(a_splitted)\n", "\n", "a_joined = '-'.join(a_splitted)\n", "print(a_joined)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "['I', 'love', 'CS221!']\n", "I-love-CS221!\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "_eZIL5U6jJUj" }, "source": [ "We can format variables in strings." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "ftkUo2kho6tk", "outputId": "d03decbb-8110-4d19-ba38-d80432d26238" }, "source": [ "pi = 3.14159\n", "print(\"Pi is %.2f!\"%(pi))\n" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "Pi is 3.14!\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 35 }, "id": "VVZolJWRkJjR", "outputId": "c90054be-475f-42ad-da18-48105c9df6c2" }, "source": [ "f\"Pi is {pi}!\"" ], "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "application/vnd.google.colaboratory.intrinsic+json": { "type": "string" }, "text/plain": [ "'Pi is 3.14159!'" ] }, "metadata": { "tags": [] }, "execution_count": 42 } ] }, { "cell_type": "markdown", "metadata": { "id": "RMivqfyxkBVj" }, "source": [ "## Control Flows\n", "\n", "### For Loops\n", "\n", "We can use loops to iterate over iterables, such as strings or arrays." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "cHziqbEQkWab", "outputId": "b2d43fd1-c8ba-49ea-b70b-7a869159c6e9" }, "source": [ "s = \"I love 221!\"\n", "for character in s:\n", " print(character)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "I\n", " \n", "l\n", "o\n", "v\n", "e\n", " \n", "2\n", "2\n", "1\n", "!\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "bbuQrxDQkuaK", "outputId": "c958107a-6351-4c3e-d504-9b2cf1b1e4e0" }, "source": [ "arr = ['a','b','c','d','e','f']\n", "index = 0\n", "for char in arr:\n", " print(char)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "a\n", "b\n", "c\n", "d\n", "e\n", "f\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "1BmvK_0Nlmhr" }, "source": [ "If we also want to keep track of the iteration number, we can use the `enumerate` function." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "77WtGYRDlr4x", "outputId": "95d459e9-5247-4a39-bfac-df117527a840" }, "source": [ "for i, char in enumerate(a):\n", " print(i, char)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "0 I\n", "1 \n", "2 l\n", "3 o\n", "4 v\n", "5 e\n", "6 \n", "7 C\n", "8 S\n", "9 2\n", "10 2\n", "11 1\n", "12 !\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "l8C5T16Pk2sJ" }, "source": [ "We can iterate a set number of times using the `range` function." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "_m_pGCQfkdyZ", "outputId": "4c4a5861-2d09-40b4-a998-b3b318adf1b9" }, "source": [ "# Same as for (int i = 0; i < 4; i++)\n", "for i in range(4):\n", " print(i)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "0\n", "1\n", "2\n", "3\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "b4GtKTHnmKoF" }, "source": [ "We can use different ranges as well. `range` function can take 3 parameters:\n", "\n", "`range(start-inclusive, stop-exclusive, step)`" ] }, { "cell_type": "code", "metadata": { "id": "hm4pCCORmOR4", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "749a7f96-144f-42bd-bfbe-c195caf3ce9c" }, "source": [ "# Same as for (int = 2; i > -3, i =- 2)\n", "for i in range(2, -3, -2):\n", " print(i)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "2\n", "0\n", "-2\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "N9w2GNvtm7VA" }, "source": [ "### While Loops\n", "\n", "We can also use `while` loops.\n" ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "LnHP2aTYo6tm", "outputId": "7ee3f625-37e7-4b8c-c172-9e71cb5e60c0" }, "source": [ "ind = 0\n", "while ind < 5:\n", " print(ind)\n", " ind +=1\n", " break" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "0\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "z05_SKqQnPms" }, "source": [ "### If Condition\n", "\n", "We can execute a portion of code based on conditions." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "WCqQE7_To6tk", "outputId": "e3bc2173-c53f-4cc6-bb82-155fed8723bc" }, "source": [ "operation = \"add\"\n", "num = 6\n", "if operation == \"add\":\n", " print(\"Adding: \", num + num)\n", "elif operation == \"multiply\":\n", " print(\"Multiplying: \", num * num)\n", "\n", "elif\n", "\n", "elif ...\n", "else:\n", " print(\"Operation is not defined.\")" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "Adding: 12\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "xeDkzJBXoTZD" }, "source": [ "We can check for `None` objects with `if`." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "blav1CAeoZfS", "outputId": "96ebb6a8-d717-439b-c67b-8fcf09b7706a" }, "source": [ "a = None\n", "if a:\n", " print(\"not None\")\n", "else:\n", " print(\"None\")" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "None\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "1e29DwZ1leiE", "outputId": "1ad59c56-e3ca-466f-83e7-d0f6ad47e967" }, "source": [ "if a is None:\n", " print('yes')" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "yes\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "iWdhY8sRorom" }, "source": [ "We can check for empty arrays or strings of length 0 with `if`." ] }, { "cell_type": "code", "metadata": { "id": "MQxr8Gy-oqwT" }, "source": [ "arr = ''\n", "if arr:\n", " print(\"not empty\")" ], "execution_count": null, "outputs": [] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "XqWq5ddao4oX", "outputId": "87cbc6c2-52ad-4b48-d850-b834e5dfa264" }, "source": [ "s = ''\n", "if s:\n", " print(\"not empty\")\n", "else:\n", " print(\"empty\")" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "empty\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "TukPtGOppEhE" }, "source": [ "## Functions\n", "\n", "We can define functions as shown in the following code block. Make sure to define your functions before calling them!" ] }, { "cell_type": "code", "metadata": { "id": "l4LLGV4po6to" }, "source": [ "# Define the function\n", "def example_func(a, b):\n", " pass\n", "\n", "# Call the function\n", "example_func(5, 10)" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "8M_JaXHupamx" }, "source": [ "Functions may have optional parameters." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "0IdV7JXdo6to", "outputId": "3d6f610f-8172-4705-9f48-ef1d2fd1a569" }, "source": [ "# Function checking whether the variable is withing a range\n", "def check_range(a, min_val = 0, max_val=10):\n", " return min_val < a < max_val\n", "\n", "# Calling the function\n", "check_range(5, max_val=3)" ], "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "False" ] }, "metadata": { "tags": [] }, "execution_count": 60 } ] }, { "cell_type": "markdown", "metadata": { "id": "K3_NJKzJF813" }, "source": [ "Params of immutable types are passed by value. Mutable types are passed by reference." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "RFNeNP_cGGSt", "outputId": "5bb98afa-7b54-4f06-ff14-9cc96b79d5d3" }, "source": [ "def example_function(variable):\n", " variable = 10\n", " print(variable)\n", "\n", "a = 15\n", "print(a)\n", "example_function(a)\n", "print(a)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "15\n", "10\n", "15\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "duEddPKxGUBC", "outputId": "9ad4f58c-60eb-4203-d772-00b4b586b24a" }, "source": [ "def example_function(variable):\n", " variable[0] = 10\n", " print(variable)\n", "\n", "a = [0,1,2,3,4]\n", "print(a)\n", "example_function(a)\n", "print(a)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "[0, 1, 2, 3, 4]\n", "[10, 1, 2, 3, 4]\n", "[10, 1, 2, 3, 4]\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "1V2GEx-4G8-j" }, "source": [ "If you want to prevent your function from the original variables, you can make a deep copy inside your function before using your parameters." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "H8qXvx1zHJIV", "outputId": "5014ab82-4590-48ba-8d19-c18a67928b18" }, "source": [ "import copy\n", "\n", "def example_function(variable):\n", " # Alternative 1\n", " variable = variable[:]\n", "\n", " # Alternative 2\n", " variable = copy.deepcopy(variable)\n", "\n", " variable[0] = 10\n", " print(variable)\n", "\n", "a = [0,1,2,3,4]\n", "print(a)\n", "example_function(a)\n", "print(a)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "[0, 1, 2, 3, 4]\n", "[10, 1, 2, 3, 4]\n", "[0, 1, 2, 3, 4]\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "Au7--qehqJs-" }, "source": [ "Functions can access variables in their parent block's scope." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "A_ZbpCQYqQFO", "outputId": "f7c02e87-59d9-4e8c-8185-1048869c0582" }, "source": [ "outside_variable = \"This is an outside variable!\"\n", "\n", "def some_function():\n", " print(outside_variable)\n", "\n", "print(outside_variable)\n", "some_function()" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "This is an outside variable!\n", "This is an outside variable!\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "Cbl0hCogskjY" }, "source": [ "Functions can't change the values of the outside variables the same way." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 340 }, "id": "U7gZBMKgskCB", "outputId": "216999cf-c717-4c00-a3b6-96fce6a11d93" }, "source": [ "outside_variable = \"This is an outside variable!\"\n", "\n", "def some_function():\n", " print(outside_variable)\n", " outside_variable = \"Function changed the outside variable\"\n", "\n", "print(outside_variable)\n", "some_function()" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "This is an outside variable!\n" ], "name": "stdout" }, { "output_type": "error", "ename": "UnboundLocalError", "evalue": "ignored", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mUnboundLocalError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutside_variable\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0msome_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;32m\u001b[0m in \u001b[0;36msome_function\u001b[0;34m()\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0msome_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutside_variable\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0moutside_variable\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"Function changed the outside variable\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mUnboundLocalError\u001b[0m: local variable 'outside_variable' referenced before assignment" ] } ] }, { "cell_type": "markdown", "metadata": { "id": "ehsOEdqrs2jE" }, "source": [ "We can resolve this error using the `global` key." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "DYGLidivs9nC", "outputId": "d6096b55-3ade-4a53-fe8d-7dca850b3abc" }, "source": [ "outside_variable = \"This is an outside variable!\"\n", "\n", "def some_function():\n", " global outside_variable\n", " outside_variable = \"Function changed the outside variable!\"\n", "\n", "print(outside_variable)\n", "some_function()\n", "print(outside_variable)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "This is an outside variable!\n", "Function changed the outside variable!\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "ibT51hVsrhlj" }, "source": [ "If a variable of the same name is defined in a function, the later definition overwrites the former only in the function scope." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "JuZRURz4rgph", "outputId": "9fc8f387-55c4-410f-f75a-13af6486d1e8" }, "source": [ "variable = \"This is an outside variable!\"\n", "\n", "def some_function(variable=\"Function variable.\"):\n", " print(variable)\n", "\n", "print(variable)\n", "some_function()\n", "print(variable)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "This is an outside variable!\n", "Function variable.\n", "This is an outside variable!\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "AKxBN3tGrZut" }, "source": [ "Variables defined in a function can't be accessed outside." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 219 }, "id": "xqNHhmaAr8qx", "outputId": "39811601-8c0c-4bb0-c6b2-6857b43fd3df" }, "source": [ "def some_function():\n", " function_variable = \"This is a function variable!\"\n", " print(function_variable)\n", "\n", "some_function()\n", "function_variable" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "This is a function variable!\n" ], "name": "stdout" }, { "output_type": "error", "ename": "NameError", "evalue": "ignored", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0msome_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mfunction_variable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mNameError\u001b[0m: name 'function_variable' is not defined" ] } ] }, { "cell_type": "markdown", "metadata": { "id": "Qw-hVhH2qm37" }, "source": [ "Functions can also define variables to be used in the global scope, using the `global` key." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "uOIZC5K-qrYO", "outputId": "a9766d22-09a1-4969-8d1c-080f3e9a22de" }, "source": [ "def foo():\n", " global global_variable\n", " # If we try printing global_variable here, we would get a not defined error\n", " global_variable = \"This is a global variable!\"\n", " print(global_variable)\n", "\n", "def bar():\n", " print(global_variable)\n", "\n", "foo()\n", "bar()" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "This is a global variable!\n", "This is a global variable!\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "YL4llM39tyT8" }, "source": [ "We can define functions within functions." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "D4B3iAjMtxkB", "outputId": "bf6907d2-d5da-4249-eed7-567fca62244d" }, "source": [ "def main_function(a):\n", "\n", " def helper_function(a):\n", " return int(a)\n", "\n", " print(a)\n", " b = helper_function(a)\n", " print(b)\n", "\n", "# Calling the main function\n", "main_function(2.0)\n", "helper" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "2.0\n", "2\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "b-2jwYYrDfBk" }, "source": [ "Functions can take in functions as variables." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "i8spJVIcDh-q", "outputId": "62960e80-7965-485a-b33f-538e4cec4910" }, "source": [ "def function_taker(a, func):\n", " return func(a)\n", "\n", "function_taker(1.0, int)\n", "\n", "int(1.0)" ], "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "1" ] }, "metadata": { "tags": [] }, "execution_count": 70 } ] }, { "cell_type": "markdown", "metadata": { "id": "Esm5wFH7DtZY" }, "source": [ "We can seperately define the function we need to pass." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "bXQl4FYNDxkc", "outputId": "91215438-b79e-4292-9b20-5061e34a466a" }, "source": [ "def parameter_function(x):\n", " return x + 5\n", "\n", "def function_taker(a, func):\n", " return func(a)\n", "\n", "function_taker(1.0, parameter_function)" ], "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "6.0" ] }, "metadata": { "tags": [] }, "execution_count": 71 } ] }, { "cell_type": "markdown", "metadata": { "id": "c5Qy2L5MECoy" }, "source": [ "We can also use `lambda` functions." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "6fgwBmOPEExC", "outputId": "cc962a91-ed87-43bc-954d-acf91f100304" }, "source": [ "def function_taker(a, func):\n", " return func(a)\n", "\n", "function_taker(1.0, lambda x: x + 5)" ], "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "6.0" ] }, "metadata": { "tags": [] }, "execution_count": 72 } ] }, { "cell_type": "markdown", "metadata": { "id": "hQYjc2UOEPpX" }, "source": [ "`lambda` functions can use variables in their parent scope." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "m18mroJjEVWW", "outputId": "134166b8-cf52-4875-a13c-dd022bfb344d" }, "source": [ "num_to_add = 10\n", "\n", "def function_taker(a, func):\n", " return func(a)\n", "\n", "function_taker(1.0, lambda x: x + num_to_add)" ], "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "11.0" ] }, "metadata": { "tags": [] }, "execution_count": 73 } ] }, { "cell_type": "markdown", "metadata": { "id": "z2XL4mZrE5fO" }, "source": [ "We can also have recursive functions." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "7exW7ny2E8x5", "outputId": "f5aefd16-d3ee-49f7-91ba-75e50195b3eb" }, "source": [ "def print_positive_numbers(num):\n", " if num <= 0:\n", " print(\"Done!\")\n", " else:\n", " print(num)\n", " print_positive_numbers(num-1)\n", "\n", "print_positive_numbers(10)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "10\n", "9\n", "8\n", "7\n", "6\n", "5\n", "4\n", "3\n", "2\n", "1\n", "Done!\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "02E4_aVwAiAu" }, "source": [ "## Classes\n", "\n", "We can define classes ourselves as well." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "BeQle4jYo6tp", "outputId": "c9b68fb0-fc5c-4d25-933d-dd8dac0c5ca1" }, "source": [ "class Foo():\n", " # Alternative: class Foo(object) - all Python classes inherits 'object'\n", " class_variable = 'same' # class variable\n", "\n", " # Optional constructor\n", " def __init__(self, x):\n", " # first parameter \"self\" for instance reference, like \"this\" in JAVA\n", " self.x = x\n", "\n", " # instance method\n", " def print_x(self): # instance reference is required for all instance variables\n", " print(self.x)\n", "\n", " # class method\n", " @classmethod\n", " def modify_class_variable(cls):\n", " cls.class_variable = 'changed'\n", "\n", " # static method\n", " @staticmethod\n", " def print_hello():\n", " print(\"Hello!\")\n", "\n", "print(Foo.class_variable)\n", "\n", "obj1 = Foo(6)\n", "obj1.print_x()\n", "print(obj1.class_variable)\n", "\n", "obj2 = Foo(5)\n", "obj2.print_x()\n", "print(obj2.class_variable)\n", "\n", "obj1.modify_class_variable()\n", "print(obj1.class_variable)\n", "print(obj2.class_variable)\n", "print(Foo.class_variable)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "same\n", "6\n", "same\n", "5\n", "same\n", "changed\n", "changed\n", "changed\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "SHUx7oQLDBrb" }, "source": [ "We can also inherit classes." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "t36HuUmqo6tp", "outputId": "92b5170f-623a-4e7b-86d8-3ec5ee1b87f4" }, "source": [ "# Inherits variables and methods\n", "class Bar(Foo):\n", " pass\n", "\n", "obj = Bar(3)\n", "obj.print_x()" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "3\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "Qx7hqK-Co6tq" }, "source": [ "## Iterables\n", "\n", "There are several different built-in iterable objects in `Python`." ] }, { "cell_type": "code", "metadata": { "id": "V3gtHrbdzkJD" }, "source": [ "# immutable iterables, with fixed size\n", "astring = str()\n", "atuple = tuple()\n", "\n", "# mutable iterables, not fixed size\n", "alist = list() # linear\n", "adict = dict() # hash table, stores (key, value) pairs\n", "aset = set() # hash table, like dict but only stores keys" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "8DMKgRW_z6Vr" }, "source": [ "Size of any iterable can be obtained with `len`." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "JTJu6az0o6tq", "outputId": "771e1f1e-b717-4e31-ea2e-c7cca396db87" }, "source": [ "print(len(alist))" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "0\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "WfWoqlvG2rpR" }, "source": [ "### List\n", "\n", "Lists store an ordered list of elements." ] }, { "cell_type": "code", "metadata": { "id": "1BVNv_Clo6tr" }, "source": [ "\"\"\"\n", "List:\n", "\n", " mutable - not hashable: can't be used as dictionary keys\n", " dynamic size\n", " allows duplicates and inconsistent element types\n", " dynamic array implementation\n", "\"\"\"\n", "alist = [] # equivalent to list()\n", "alist = [1,2,3,4,5] # initialized list" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "Drqeatru3clX" }, "source": [ "We can access and modify list elements, similar to strings." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "YzP2qig73aip", "outputId": "4dfb5815-b940-45d8-aae7-2bc21a5a370e" }, "source": [ "print(alist[0])\n", "alist[0] = 5\n", "print(alist)\n", "\n", "print(\"-\"*10)\n", "# list indexing\n", "print(alist[0]) # get first element (at index 0)\n", "print(alist[-2]) # get 2nd to last element (at index len-1)\n", "print(alist[3:]) # get elements starting from index 3 (inclusive)\n", "print(alist[:3]) # get elements stopping at index 3 (exclusive)\n", "print(alist[2:4]) # get elements within index range [2,4)\n", "print(alist[6:]) # prints nothing because index is out of range" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "5\n", "[5, 2, 3, 4, 5]\n", "----------\n", "5\n", "4\n", "[4, 5]\n", "[5, 2, 3]\n", "[3, 4]\n", "[]\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "u5RQCObM3seH" }, "source": [ "We can reverse a list." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "NBDj-DxF30CT", "outputId": "a6550485-3a95-4177-cc93-a06fd065dec5" }, "source": [ "alist[::-1] # returns a reversed list" ], "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "[5, 4, 3, 2, 5]" ] }, "metadata": { "tags": [] }, "execution_count": 84 } ] }, { "cell_type": "markdown", "metadata": { "id": "QzpmPx0j32R-" }, "source": [ "We can call methods on a list." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "dyaIpKgW36bI", "outputId": "653230a9-b8ed-4102-bd8a-7c7a66b4fef7" }, "source": [ "alist.append(\"new item\") # insert at end\n", "alist.insert(0, \"new item\") # insert at index 0\n", "alist.extend([2,3,4]) # concatenate lists\n", "# above line is equivalent to alist += [2,3,4]\n", "alist.index(\"new item\") # search by content\n", "alist.remove(\"new item\") # remove by content\n", "popped = alist.pop(0) # remove by index\n", "print(alist)\n", "print(popped)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "[2, 3, 4, 5, 'new item', 2, 3, 4]\n", "5\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "0c8id4IG4jpB" }, "source": [ "We can check if an element is contained in a list." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "9IJJhB1y3s_r", "outputId": "3cd7e583-4fbc-4f56-f865-6b404abb469a" }, "source": [ "if \"new item\" in alist:\n", " print(\"found\")" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "found\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "6pinHv3t0B5B" }, "source": [ "### Tuples\n", "\n", "Tuples allow us to store immutable lists." ] }, { "cell_type": "code", "metadata": { "id": "_ec4BTva0eqw" }, "source": [ "\"\"\"\n", "Tuple:\n", "\n", " immutable - hashable: can be used as a dictionary key\n", " fixed size: no insertion or deletion\n", "\"\"\"\n", "atuple = (1,2,3,4,5)" ], "execution_count": null, "outputs": [] }, { "cell_type": "code", "metadata": { "id": "mOv1HOqlq00b" }, "source": [ "atuple = (1)" ], "execution_count": null, "outputs": [] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "PByClj1mrCCf", "outputId": "08538db3-c458-4831-85d2-38ef329f4835" }, "source": [ "type(atuple)" ], "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "int" ] }, "metadata": { "tags": [] }, "execution_count": 93 } ] }, { "cell_type": "markdown", "metadata": { "id": "6ZOInlx72J1Z" }, "source": [ "Indexing or traversal of a `tuple` is the same as that of a `list`." ] }, { "cell_type": "code", "metadata": { "id": "6AaRSa-82JMN" }, "source": [ "# Defining tuple from a list\n", "atuple = tuple([1,2,3])" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "xsscT5XJ2Jci" }, "source": [ "We can use tuples as dictionary keys.\n", "\n" ] }, { "cell_type": "code", "metadata": { "id": "4d0__BN6o6tq" }, "source": [ "ngram = (\"a\", \"cat\")\n", "d = dict()\n", "d[ngram] = 10\n", "d[ngram] += 1" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "U-a6t5xc4rG6" }, "source": [ "We can use named tuples to improve readability." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "rdRo7jvio6t4", "outputId": "f47d9aa0-3c66-48cc-9449-ee00b9466f6a" }, "source": [ "from collections import namedtuple\n", "Point = namedtuple('Point', 'x y')\n", "pt1 = Point(1.0, 5.0)\n", "pt2 = Point(2.5, 1.5)\n", "print(pt1.x, pt1.y)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "1.0 5.0\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "2MeHbcuu493p" }, "source": [ "### Dictionary\n", "\n", "Dictionaries are useful for storing key - value pairs." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "FgjMce7lo6t6", "outputId": "4af30c7b-f520-404b-cab0-32b650d13d07" }, "source": [ "\"\"\"\n", "Dict:\n", "\n", " not hashable\n", " dynamic size\n", " no duplicates allowed\n", " hash table implementation which is fast for searching\n", "\n", "\"\"\"\n", "adict = {} # same as dict()\n", "adict = {'dog': 10, 'bird': 5, 'lion': 8}\n", "print(adict)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "{'dog': 10, 'bird': 5, 'lion': 8}\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "qDbczIwk5Y_6" }, "source": [ "We can get keys, values or items in a dictionary." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "uaLYZomJ5f6s", "outputId": "e3d4fd76-b291-4e37-9fc5-5b0c3c5f782c" }, "source": [ "print(adict.keys())\n", "print(adict.values())\n", "print(adict.items())" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "dict_keys(['dog', 'bird', 'lion'])\n", "dict_values([10, 5, 8])\n", "dict_items([('dog', 10), ('bird', 5), ('lion', 8)])\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "bSvTjzwa5za7" }, "source": [ "We can access an item with a specific key." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "1DAetNu452bQ", "outputId": "7df7eb6b-ff2e-4773-e4ac-17d9e881ec8e" }, "source": [ "print(adict['lion'])" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "8\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "YYc3kd4L6NWA" }, "source": [ "We can check if a key exists in a dictionary. This is needed since accessing non-existent keys throws an error." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 167 }, "id": "FHM5P_3Q6aSr", "outputId": "2db8e3ce-7aff-462b-e60e-ca8ba41b3566" }, "source": [ "adict['tiger']" ], "execution_count": null, "outputs": [ { "output_type": "error", "ename": "KeyError", "evalue": "ignored", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0madict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'tiger'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mKeyError\u001b[0m: 'tiger'" ] } ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "tsgXho126QD5", "outputId": "da00a688-d2e6-40c0-b1ad-f338a019b47d" }, "source": [ "if 'tiger' in adict:\n", " print(adict[key])\n", "else:\n", " print('Key not found.')" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "Key not found.\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "UGE08yH96mp7" }, "source": [ "Insert new keys." ] }, { "cell_type": "code", "metadata": { "id": "JicEI5sj6oFb" }, "source": [ "adict['tiger'] = 1" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "h16DZ3uk6rec" }, "source": [ "Modify existing keys." ] }, { "cell_type": "code", "metadata": { "id": "_oCgyCAP6yQF" }, "source": [ "adict['lion'] = 20" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "79kmfD1L6tvR" }, "source": [ "Traversing dictionaries.\n" ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "0mShrqZI5Rco", "outputId": "924011d9-192e-4bb2-b6b0-71db73585535" }, "source": [ "for key in adict:\n", " print(key, adict[key])" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "dog 10\n", "bird 5\n", "lion 8\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "0Oarhwm87Bsf" }, "source": [ "Traversing key, value pairs together." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "asfYaluB7Ebn", "outputId": "978f1123-93ed-48e3-d8b8-57f8bebb31ee" }, "source": [ "for key, val in adict.items():\n", " print(key, val)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "dog 10\n", "bird 5\n", "lion 20\n", "tiger 1\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "f6wWiDFs7aPU" }, "source": [ "### DefaultDict\n", "\n", "`DefaultDict` is a special dictionary that returns a default value when a key queried isn't found." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "wm4eqxU67xJY", "outputId": "b739fdc0-8a73-4263-d588-f7f6c3e6f1fe" }, "source": [ "from collections import defaultdict\n", "\n", "adict = defaultdict(int)\n", "adict['cat'] = 5\n", "print(adict['cat'])\n", "print(adict['dog'])" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "5\n", "0\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "PlHxXbUg77XJ" }, "source": [ "It is also possible to pass a custom function." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "iPEZbjpn7ney", "outputId": "63deabcc-acad-4ede-d2dc-85461013ffa0" }, "source": [ "from collections import defaultdict\n", "adict = defaultdict(lambda: 'unknown')\n", "adict['cat'] = 'feline'\n", "print(adict['cat'])\n", "print(adict['dog'])" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "feline\n", "unknown\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "lYQI1E858MF2" }, "source": [ "### Counter\n", "\n", "`Counter` is a dictionary with default value of 0." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "Z14YHrWyo6t8", "outputId": "4fa122e0-6d45-4968-ff1e-ca4348bd68cb" }, "source": [ "from collections import Counter\n", "\n", "# initialize and modify empty counter\n", "counter1 = Counter()\n", "counter1['t'] = 10\n", "counter1['t'] += 1\n", "counter1['e'] += 1\n", "print(counter1)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "Counter({'t': 11, 'e': 1})\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "94SMZI9y8W_I" }, "source": [ "We can initialize counters from other iterables." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "7GltlZgl8acL", "outputId": "c699aede-d9bd-4a61-9e0e-7e1fe3ee72be" }, "source": [ "counter2 = Counter(\"letters to be counted\")\n", "print(counter2)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "Counter({'e': 4, 't': 4, ' ': 3, 'o': 2, 'l': 1, 'r': 1, 's': 1, 'b': 1, 'c': 1, 'u': 1, 'n': 1, 'd': 1})\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "TCajDMH98hIZ" }, "source": [ "We can perform operations between counters." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "HxGq9Ex18f3l", "outputId": "9540d335-9645-4bae-bf90-2f1896298ffa" }, "source": [ "print(\"1\", counter1 + counter2)\n", "print(\"2\", counter1 - counter2)\n", "print(\"3\", counter1 or counter2) # or for intersection, and for union" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "1 Counter({'t': 15, 'e': 5, ' ': 3, 'o': 2, 'l': 1, 'r': 1, 's': 1, 'b': 1, 'c': 1, 'u': 1, 'n': 1, 'd': 1})\n", "2 Counter({'t': 7})\n", "3 Counter({'t': 11, 'e': 1})\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "mdlqrgDF81yr" }, "source": [ "We can use other special methods on counters. Check out the docs for more!" ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "Fxgl9n7N86ic", "outputId": "61e41917-25ab-44bd-bdc2-964bd137e49a" }, "source": [ "counter2.most_common(5)" ], "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "[('e', 4), ('t', 4), (' ', 3), ('o', 2), ('l', 1)]" ] }, "metadata": { "tags": [] }, "execution_count": 107 } ] }, { "cell_type": "markdown", "metadata": { "id": "2s8_am1J9PwW" }, "source": [ "We can iterate list of tuples." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "xWANB8hj9UY0", "outputId": "2fbd266e-1c26-495b-87b1-d39301c14f0b" }, "source": [ "for k,v in counter2.most_common(5):\n", " print(k, v)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "e 4\n", "t 4\n", " 3\n", "o 2\n", "l 1\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "YTgf-Qwj7Kpw" }, "source": [ "### Set\n", "\n", "Set is a special dictionary without values." ] }, { "cell_type": "code", "metadata": { "id": "wmhE3Zmeo6t7", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "42b54c03-c921-439f-fcb9-e70cc932c742" }, "source": [ "aset = set()\n", "aset.add('a')\n", "aset" ], "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "{'a'}" ] }, "metadata": { "tags": [] }, "execution_count": 109 } ] }, { "cell_type": "markdown", "metadata": { "id": "oAVaGb2g7SLC" }, "source": [ "We can use sets to remove duplicates from a list." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "5qyT88U37VWR", "outputId": "697c6108-614f-455e-8245-040f388bb87f" }, "source": [ "alist = [5,2,3,3,3,4,3]\n", "alist = list(set(alist))\n", "print(alist)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "[2, 3, 4, 5]\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "mWuYLCwutwPN", "outputId": "e0dd8d5a-f04e-444f-f5cd-b16e3458ec71" }, "source": [ "set(alist)" ], "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "{2, 3, 4, 5}" ] }, "metadata": { "tags": [] }, "execution_count": 116 } ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "Sh6-iKkUtcv4", "outputId": "fe3824bc-5d83-494b-bd9c-824e7b0a0f0e" }, "source": [ "list(set(alist))" ], "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "[2, 3, 4, 5]" ] }, "metadata": { "tags": [] }, "execution_count": 115 } ] }, { "cell_type": "markdown", "metadata": { "id": "IEG17z-39dkT" }, "source": [ "### Sorting\n", "\n", "We can sort iterables." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "yr0Npa5do6t8", "outputId": "72da5b12-d851-49c5-be0b-fd7cd6385a7c" }, "source": [ "a = [4,6,1,7,0,5,1,8,9]\n", "a = sorted(a)\n", "print(a)\n", "a = sorted(a, reverse=True)\n", "print(a)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "[0, 1, 1, 4, 5, 6, 7, 8, 9]\n", "[9, 8, 7, 6, 5, 4, 1, 1, 0]\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "N6sPZZUV9k-X" }, "source": [ "We can sort iterables containing tuples." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "fvdUq_7Lo6t8", "outputId": "91e3ad57-3dce-4fac-e49c-55d03d88f81f" }, "source": [ "# sorting\n", "a = [(\"cat\",1), (\"dog\", 3), (\"bird\", 2)]\n", "a = sorted(a)\n", "print(a)\n", "b = sorted(a, key=lambda item: item[1])\n", "print(b)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "[('bird', 2), ('cat', 1), ('dog', 3)]\n", "[('cat', 1), ('bird', 2), ('dog', 3)]\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "Z88BCni79v-Q" }, "source": [ "We can pass a function we define outside instead of a lambda function." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "jCM6jPbv91xH", "outputId": "117216f7-2c49-412b-f866-269d3ef76e47" }, "source": [ "def sorting_key(item):\n", " return item[1]\n", "\n", "sorted(a, key=sorting_key)" ], "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "[('cat', 1), ('bird', 2), ('dog', 3)]" ] }, "metadata": { "tags": [] }, "execution_count": 167 } ] }, { "cell_type": "markdown", "metadata": { "id": "HDG7xi4M-U_t" }, "source": [ "We can sort dictionaries the same way." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "19oDadMwo6t-", "outputId": "14abc53b-d069-4a3c-dc41-9b0a9235c2ab" }, "source": [ "adict = {'cat':3, 'bird':1}\n", "print(sorted(adict.items(), key=lambda x:x[1]))" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "[('bird', 1), ('cat', 3)]\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "aQywFVev-ZzH" }, "source": [ "### List Comprehension\n", "\n", "Instead of using `for` loops every time, we can use list comprehensions to create new lists or other iterables." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "8eGjNjf2o6t_", "outputId": "3f774852-8a93-4bfa-df5c-a562fc64cf28" }, "source": [ "\"\"\"\n", "for i in range(len(sent)):\n", " sent[i] = sent[i].lower().split(\" \")\n", "\"\"\"\n", "\n", "sent = [\"i am good\", \"a beautiful day\", \"HELLO FRIEND\"]\n", "sent1 = [s.lower().split(\" \") for s in sent]\n", "print(sent1)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "[['i', 'am', 'good'], ['a', 'beautiful', 'day'], ['hello', 'friend']]\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "JL9NYWLg-1nx" }, "source": [ "We can have conditions." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "dNedRQmK-uG0", "outputId": "a1dfab90-c565-4115-f51e-46a59cf5a035" }, "source": [ "sent2 = [s.lower().split(\" \") for s in sent if len(s) > 10]\n", "print(sent2)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "[['a', 'beautiful', 'day'], ['hello', 'friend']]\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "y3nTEdUU--QQ" }, "source": [ "We can create other iterables the same way." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "0LMW-AFv_GPy", "outputId": "bb1da3f4-2e21-488e-a712-efa6c2896dde" }, "source": [ "keys = ['a', 'b', 'c']\n", "dict1 = {k: i for i, k in enumerate(keys)}\n", "print(dict1)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "{'a': 0, 'b': 1, 'c': 2}\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "Yio2kKK5_SQi" }, "source": [ "Another useful function we can use is `zip`." ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "_u3k-7Xr_eH0", "outputId": "9270494d-c9f2-4fc5-fa39-53fca8351bd6" }, "source": [ "keys = ['a', 'b', 'c']\n", "values = [10, 5, 30]\n", "zipped = zip(keys, values)\n", "print(zipped) # zip object\n", "print(list(zipped)) # pass to list to unzip\n", "\n", "for k, v in zip(keys, values):\n", " print(k, v)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "\n", "[('a', 10), ('b', 5), ('c', 30)]\n", "a 10\n", "b 5\n", "c 30\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "wugqn01Eo6uK" }, "source": [ "## Q&A\n", "\n", "Question time!" ] } ] }