{
"nbformat": 4,
"nbformat_minor": 0,
"metadata": {
"colab": {
"provenance": []
},
"kernelspec": {
"name": "python3",
"display_name": "Python 3"
},
"language_info": {
"name": "python"
}
},
"cells": [
{
"cell_type": "markdown",
"source": [
"# Lecture 2 - Python Review\n",
"\n",
"In this lecture, we will -\n",
"\n",
"\n",
"* Continue review of python basics\n",
"* Discuss functions, conditionals, loops, scope\n",
"* Introduce Recursion\n",
"\n",
"Learning Objectives -\n",
"\n",
"1. Debug python code\n",
"2. Write a few functions in python using conditionals and loops\n",
"\n"
],
"metadata": {
"id": "59De9HKEv0bv"
}
},
{
"cell_type": "markdown",
"source": [
"# Discovery clicker\n",
"\n",
"Scan and use join code 277\n",
"\n",
"OR Visit clicker.cs.illinois.edu and use join code 277\n",
"\n",
""
],
"metadata": {
"id": "LktxlwG4nuPs"
}
},
{
"cell_type": "markdown",
"source": [
"# Introduction to Python and Recursion\n",
"\n",
"A good source for an overview on Python is chapter 1 of the textbook \"Data Structures and Algorithms in Python\" by Goodrich, Tamassia, and Goldwasser. This lecture is based on material in that chapter.\n",
"\n",
"## Identifiers and Assignment\n",
"\n",
"*Identifiers* are \"names\" of memory locations that store values that are used by the program during the computation.\n",
"\n",
"The *assignment* statement assigns a value to an identifier.\n",
"\n",
"For example, temperature = 98.6 establishes temperature as an identifier and associates it with the object expressed on the right of the \"=\".\n",
"* Identifiers are case sensitive. temperature is a different identifier than Temperature.\n",
"\n",
"## Built-in Classes\n",
"\n",
"### bool class\n",
"\n",
"**Values:** True and False\n",
"\n",
"**Operations:**\n",
"* a and b evaluates to True exactly if **both** a and b evaluate to True\n",
"* a or b evaluates to True exactly if **at least** one of a or b evaluate to True\n",
"* not a evaluates to True exactly when a evaluates to False.\n",
"\n",
"### int class\n",
"\n",
"**Values:** -4, -2, 0, 1, 2, 5, ...\n",
"\n",
"**Operations:** + (addition), - (subtraction), * (multiplication), / (division), // (integer division), % (modulo), ** (exponentiation), ...\n",
"\n",
"### float class\n",
"\n",
"**Values:** 1.0, 0.5, -25.5, ...\n",
"\n",
"**Operations:** + (addition), - (subtraction), * (multiplication), / (division), ...\n",
"\n",
"### sequence classes\n",
"\n",
"**string:** any sequence of characters, \"hello\", `world'\n",
"\n",
"**list:** any sequence of objects, [0,1,100], [\"hello\", 1.5]\n",
"\n",
"**tuple:** immutable version of lists, (0,1,100), (\"hello\",1.5)\n",
"\n",
"**Other classes:** dict, set, ...\n",
"\n",
"**Operations:**\n",
"* s + t *concatenates* s and t\n",
"* k * s: concatenate s with itself k times\n",
"* s[i]: ith element of s\n",
"* s[i,j]: portion of s from ith element to jth element (not including the jth element)\n",
"* val in s: checks if val is in sequence s\n",
"* val not in s: checks if val is not in sequence s\n"
],
"metadata": {
"id": "Slv96BJU4G1n"
}
},
{
"cell_type": "markdown",
"source": [
"## Input and Output\n",
"\n",
"**print:** outputs a sequence of characters on the console\n",
"\n",
"**input:** way to get information from the user. prints an optional prompt and then waits for the user to enter information."
],
"metadata": {
"id": "lElT5lNk4iTG"
}
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "772NrW40vxMa"
},
"outputs": [],
"source": [
"# simple assignment and operations\n",
"a = 5\n",
"b = a\n",
"print(\"a =\", a, \"b =\", b)\n",
"\n",
"b = 2\n",
"print(\"a =\", a, \"b =\", b)\n",
"\n",
"a = 13\n",
"print(\"a =\", a, \"b =\", b)\n",
"\n",
"print(\"a/b =\", a/b, \"a//b =\", a//b)\n",
"print(\"a%b =\", a%b)\n",
"\n",
"s =\"cat\"\n",
"print(s+s)\n",
"print(3*s)\n",
"\n"
]
},
{
"cell_type": "code",
"source": [
"# understanding input\n",
"a = input(\"What is a? \")\n",
"b = input(\"What is b? \")\n",
"print(\"a+b is\", a+b)\n",
"\n",
"a = int(input(\"What is a? \"))\n",
"b = int(input(\"What is b? \"))\n",
"\n",
"print(\"a+b is\", a+b)"
],
"metadata": {
"id": "tlB0AIcZ4wN8"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"# swapping numbers - \"Tuple unpacking\"\n",
"a = 5\n",
"b = 6\n",
"print(a,b)\n",
"\n",
"a = 5\n",
"b = 6\n",
"a,b = b,a\n",
"print(a,b)"
],
"metadata": {
"id": "iSuoRPHwyH-W"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"## Control Flow\n",
"\n",
"Conditional constructs (also known as if statements) provide a way to execute a chosen block of code based on the run-time evaluation of one or more Boolean expressions. In Python, the most general form is\n",
"\n",
"```\n",
"if :\n",
" \n",
"elif :\n",
" \n",
"elif :\n",
" \n",
"else:\n",
" \n",
"```"
],
"metadata": {
"id": "RRegz_GA4_ex"
}
},
{
"cell_type": "code",
"source": [
"# find maximum of 3 numbers\n",
"a = int(input(\"What is a? \"))\n",
"b = int(input(\"What is b? \"))\n",
"c = int(input(\"What is c? \"))\n",
"if a > b:\n",
" # a is greater than b\n",
" if a > c:\n",
" print(\"maximum is a and is equal to\", a)\n",
" else:\n",
" print(\"maximum is c and is equal to\", c)\n",
"else:\n",
" # b >= a\n",
" if b > c:\n",
" print(\"maximum is b and is equal to\", b)\n",
" else:\n",
" print(\"maximum is c and is equal to\", c)"
],
"metadata": {
"id": "hnxSvzr85EBI"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"## Loops\n",
"\n",
"Loops allow one to execute a sequence of statements repeatedly. Python offers two forms of loops: ```while``` loops and ```for``` loops. General form of these loops is\n",
"\n",
"```\n",
"while :\n",
" \n",
"\n",
"for in :\n",
" \n"
],
"metadata": {
"id": "IPIJghr25Hd-"
}
},
{
"cell_type": "code",
"source": [
"# find the sum of the first 5 squares (while loop)\n",
"n = 0\n",
"sum = 0\n",
"while n < 100:\n",
" sum = sum + n*n\n",
" n = n+1\n",
"\n",
"print(sum)"
],
"metadata": {
"id": "Fm4sGjXc48eF"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"# find the sum of the first 5 squares (for loop)\n",
"l = [0,1,2,3,4]\n",
"\n",
"sum = 0\n",
"for i in l:\n",
" sum += i*i\n",
"print(sum)"
],
"metadata": {
"id": "Ly9RU1Jk5Rzs"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"# range\n",
"n = int(input(\"What is n? \"))\n",
"sum = 0\n",
"for i in range(n):\n",
" sum += i*i\n",
"print(sum)\n",
"\n",
"# range(n) = [0,1,2,3,...,(n-1)]"
],
"metadata": {
"id": "0qcukvaM5Xtx"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"## break and continue\n",
"\n",
"**break:** immediate termination of the loop when executed within its body\n",
"\n",
"**continue:** causes the current iteration of a loop body to stop, but with subsequent passes of the loop proceeding as expected\n"
],
"metadata": {
"id": "axDWDBWP5adk"
}
},
{
"cell_type": "code",
"source": [
"print(\"Running loop with break\")\n",
"for n in range(10):\n",
" if (n == 5):\n",
" break\n",
" print(n)\n",
"\n",
"print(\"Running loop with continue\")\n",
"for n in range(10):\n",
" if (n == 5):\n",
" continue\n",
" print(n)"
],
"metadata": {
"id": "Z18eynNw5ezc"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"## Mutable and Immutable Classes\n",
"\n",
"Assignments to variables with an immutable type, an assignment does not modify the existing object; instead it creates a new object and assigns the identifier to that value.\n",
"\n",
"In contrast, assignments to mutable types, modifies the existing object.\n",
"\n",
"**Immutable types:** bool, int, float, string, tuple\n",
"\n",
"**Mutable types:** list, dict, set"
],
"metadata": {
"id": "4scChOCb5hbq"
}
},
{
"cell_type": "code",
"source": [
"a = 5\n",
"b = a\n",
"print(\"a =\",a, \"b =\", b)\n",
"b += 1\n",
"print(\"a =\",a, \"b =\", b)\n",
"\n",
"#Mutable type list\n",
"l = list(\"hello\")\n",
"print(\"l =\", l)\n",
"\n",
"l[1] = \"a\"\n",
"print(\"l =\", l)\n",
"\n",
"#Immutable type string\n",
"#s = \"hello\"\n",
"#print(\"s =\", s)\n",
"\n",
"#s[1] = \"a\"\n",
"#print(\"s =\", s)\n",
"\n",
"m = l\n",
"print(\"m =\", m)\n",
"\n",
"m[3] = \"o\"\n",
"print(\"l =\", l)\n",
"\n",
"l[3] = \"l\"\n",
"l += \"o\"\n",
"print(\"m =\", m)"
],
"metadata": {
"id": "dilhWgUI5kBT"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"l = [0, \"hello\", 1.5]\n",
"print(\"l[1] = \",l[1])\n",
"l[1] = \"goodbye\"\n",
"print(\"updated value of l[1]- \",l[1])\n",
"\n",
"#tup = (0, \"hello\", 1.5)\n",
"#print(\"tup[1] = \",tup[1])\n",
"#tup[1] = \"goodbye\"\n",
"#print(\"updated value of tup[1]- \",tup[1])"
],
"metadata": {
"id": "1fLFpVxIJT1H"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"## Functions\n",
"\n",
"A *function* serves as a self-contained, reusable block of code designed to perform a specific, defined task. They take inputs and produce an output which is the result of the computation."
],
"metadata": {
"id": "CFW0LUQZ5mg8"
}
},
{
"cell_type": "code",
"source": [
"# Function to compute the sum of numbers\n",
"def sum_of_numbers(n):\n",
" sum = 0\n",
" for i in range(n):\n",
" sum += i*i\n",
" return sum\n",
"\n",
"print (sum_of_numbers(5))"
],
"metadata": {
"id": "aqA-neXv5pI6",
"colab": {
"base_uri": "https://localhost:8080/"
},
"outputId": "67471e44-2ce7-457c-d4d1-9cf323dcc000"
},
"execution_count": 22,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"30\n"
]
}
]
},
{
"cell_type": "markdown",
"source": [
"## Scope\n",
"\n",
"Scope refers to the region of the program where a variable is defined. Variables assignments within the body of a function, are local to that function call."
],
"metadata": {
"id": "DSC-2HNG5r-a"
}
},
{
"cell_type": "code",
"source": [
"g = 2\n",
"x = 2\n",
"\n",
"def foo (x):\n",
" print(\"g =\",g)\n",
" print(\"x =\", x)\n",
" y = x + 1\n",
" print(\"y =\", y)\n",
" return x\n",
"\n",
"def bar (x):\n",
" print(\"y =\", y)\n",
" return y\n",
"\n",
"foo(1)\n",
"#bar(0)"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "3VnEjhLl5vSZ",
"outputId": "3cef544e-5556-40f2-af33-2314f637722c"
},
"execution_count": 9,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"g = 2\n",
"x = 1\n",
"y = 2\n"
]
},
{
"output_type": "execute_result",
"data": {
"text/plain": [
"1"
]
},
"metadata": {},
"execution_count": 9
}
]
},
{
"cell_type": "markdown",
"source": [
"## Multiplication\n",
"\n",
"Recall that\n",
"$$a*b = \\stackrel{b \\text{ times}}{\\overline{a + a + \\cdots + a}}.$$\n",
"Thus, $a*b$ is the sum of $a$ with itself $b$ times.\n",
"\n",
"Write a function that multiplies two non-negative integers using only addition."
],
"metadata": {
"id": "wtdueZpl-_F-"
}
},
{
"cell_type": "code",
"source": [
"# multiplication using addition (while loop)\n",
"\n",
"def mult(a,b):\n",
" prod = 0\n",
" while b > 0:\n",
" prod += a\n",
" b -= 1\n",
" return prod\n",
"\n",
"x = 5\n",
"y = 3\n",
"z = mult(x,y)\n",
"print(z)"
],
"metadata": {
"id": "mKCfbncI_J3z"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"We could write the above iterative multiplication algorithm more concisely using for loops. Notice the use of _"
],
"metadata": {
"id": "McX13ILy_Prs"
}
},
{
"cell_type": "code",
"source": [
"# multiplication using addition (for loop)\n",
"\n",
"def mult(a,b):\n",
" prod = 0\n",
" for _ in range(b): # we could use _ since loop variable not used in body\n",
" prod += a\n",
" return prod"
],
"metadata": {
"id": "aW86M0Jl_YUD"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"Observe that $a*0 = 0$ and $a*b = a + a*(b-1)$ when $b > 0$. We will use this to write a recursive piece of code to compute mult."
],
"metadata": {
"id": "HoZRv7fF_jel"
}
},
{
"cell_type": "code",
"source": [
"# multiplication using addition: recursive version\n",
"# ignore the cnt variables: they are used to count the number of recursive calls\n",
"\n",
"def mult_rec(a,b):\n",
" #global cnt\n",
" #cnt += 1\n",
" if b == 0:\n",
" return 0\n",
" return a + mult_rec(a,b-1)\n",
"\n",
"#cnt = 0\n",
"x = 5\n",
"y = 3\n",
"z = mult_rec(x,y)\n",
"print(z)\n",
"#print(cnt)"
],
"metadata": {
"id": "9EAnhNkm_sth"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"The execution of ```mult_rec``` can be understood as follows.\n",
"```\n",
"executing z = mult_rec(x,y) results in a\n",
" call mult_rec with a = 5 and b = 3\n",
" b != 0 so executing return a + mult_rec(a,b-1) results in\n",
" call mult_rec with a = 5 and b = 2\n",
" b != 0 so executing return a + mult_rec(a,b-1) results in\n",
" call mult_rec with a = 5 and b = 1\n",
" b != 0 so executing return a + mult_rec(a,b-1) results in\n",
" call mult_rec with a = 5 and b = 0\n",
" b == 0 so return value 0\n",
" return a + mult_rec(a,0) = 5 + 0 = 5\n",
" return a + mult_rec(a,1) = 5 + 5 = 10\n",
" return a + mult_rec(a,2) = 5 + 10 = 15\n",
"z = mult_rec(5,3) = 15\n",
"```"
],
"metadata": {
"id": "DliMnYal_zI9"
}
}
]
}