\n",
""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Recitation 2"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We tested if a positive integer (or a range of integers) satisfies the Collatz conjecture (using \"while\" and \"for\" loops). \n",
"We discussed the basics of lists, the efficiency of list operations and how to efficiently concatenate a list to another. We also demonstrated list comprehension. \n",
"Finally, we discussed functions, short circuit evaluation and analyzed the efficiency of the functions we saw.\n",
"\n",
"#### Takeaways:\n",
"\n",
"\n",
"
Lists can be a highly modular and useful data structure. Make sure that you understand their functionality and also their limits (figuratively and literally).
\n",
"
Avoid using the + operator for extending a given list. Use += or list.extend() instead.\n",
"
Functions can be used in one another (max2 in max3_v3) and can be composed together.
\n",
"
When analyzing a function's performance, think about the input that will cause the largest amount of work and then measure how many operations the function does.
\n",
"
Using short circuit evaluation, if e.g. you have a long \"and\" condition, place the part that is most easy to compute first since if it is false, all other parts of the condition will not be computed.
\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Code for printing several outputs in one cell (not part of the recitation):"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [],
"source": [
"from IPython.core.interactiveshell import InteractiveShell\n",
"InteractiveShell.ast_node_interactivity = \"all\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Collatz Conjecture\n",
"\n",
"The Collatz Conjecture, from Wikipedia:\n",
"\n",
"Start with any positive integer $n$. Each term in the Collatz sequence is obtained from the previous term as follows: \n",
"* If the previous term is even, the next term is one half the previous term: $n \\to n // 2$ \n",
"* If the previous term is odd, the next term is 3 times the previous term plus 1: $n \\to 3\\cdot n + 1$ \n",
"* If we reach $1$, we stop\n",
"\n",
"The Collatz conjecture is the following statement: for any $n \\geq 1$, the sequence above reaches $1$ in a finite amount of steps."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"32 -> 16 -> 8 -> 4 -> 2 -> 1\n",
"\n",
"\n",
"7 -> 22 -> 11 -> 34 -> 17 - > 52 -> 26-> 13 -> 40 -> 20 -> 10 -> 5 -> 16 -> 8-> 4 -> 2 -> 1 "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Check conjecture for a single number:"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Enter a positive integer to apply Collatz algorithm: 7\n",
"7 22 11 34 17 52 26 13 40 20 10 5 16 8 4 2 1\n",
"7 is OK!\n"
]
}
],
"source": [
"orig_num = int(input(\"Enter a positive integer to apply Collatz algorithm: \"))\n",
"num = orig_num\n",
"\n",
"while num != 1:\n",
" print(num, end = \" \")\n",
" if num % 2 == 0:\n",
" num = num // 2\n",
" else:\n",
" num = 3*num + 1\n",
"\n",
"print(num)\n",
"print(orig_num, \"is OK!\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Check conjecture for a range of numbers:"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Check Collatz algorithm for 1 ... 10\n",
"1\n",
"1 is OK!\n",
"2 1\n",
"2 is OK!\n",
"3 10 5 16 8 4 2 1\n",
"3 is OK!\n",
"4 2 1\n",
"4 is OK!\n",
"5 16 8 4 2 1\n",
"5 is OK!\n",
"6 3 10 5 16 8 4 2 1\n",
"6 is OK!\n",
"7 22 11 34 17 52 26 13 40 20 10 5 16 8 4 2 1\n",
"7 is OK!\n",
"8 4 2 1\n",
"8 is OK!\n",
"9 28 14 7 22 11 34 17 52 26 13 40 20 10 5 16 8 4 2 1\n",
"9 is OK!\n",
"10 5 16 8 4 2 1\n",
"10 is OK!\n"
]
}
],
"source": [
"limit = int(input(\"Check Collatz algorithm for 1 ... \"))\n",
"\n",
"orig_num = 1\n",
"while orig_num <= limit:\n",
" num = orig_num\n",
"\n",
" while num > 1:\n",
" print(num, end=\" \")\n",
" if num % 2 == 0:\n",
" num = num // 2\n",
" else:\n",
" num = 3*num + 1\n",
"\n",
" print(num)\n",
" print(orig_num, \"is OK!\")\n",
" \n",
" orig_num += 1\n",
" \n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### The type $range$\n",
"\n",
"We've met the python type $range$ in the lecture. Given integers $a,b,c$, $range(a,b,c)$ represents the range of indices from $a$, up to (and excluding) $b$, in intervals of size $c$.\n",
"\n",
"We can also declare simpler range variables by the following logic:\n",
"* $range(a) = range(0,a,1)$\n",
"* $range(a,b) = range(a,b,1)$\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0\n",
"1\n",
"2\n",
"3\n",
"4\n",
"5\n",
"6\n",
"7\n",
"8\n",
"9\n"
]
}
],
"source": [
"for i in range(10):\n",
" print(i)\n",
" "
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n",
"3\n",
"5\n"
]
}
],
"source": [
"for i in range(1, 7, 2):\n",
" print(i)\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"7\n",
"5\n",
"3\n"
]
}
],
"source": [
"for i in range(7, 1, -2):\n",
" print(i)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Check conjecture for a range of numbers (using \"for\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"limit = int(input(\"Check Collatz algorithm for 1 ... \"))\n",
"\n",
"\n",
"for orig_num in range(1, limit + 1):\n",
" num = orig_num\n",
"\n",
" while num > 1:\n",
" print(num, end=\" \")\n",
" if num % 2 == 0:\n",
" num = num // 2\n",
" else:\n",
" num = 3*num + 1\n",
"\n",
" print(num)\n",
" print(orig_num, \"is OK!\")\n",
" \n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Lists - Basics\n",
"\n",
"A Python list is a collection of **ordered** elements. The elements can be of different types, they can include repetitions and they can even include lists.\n",
"\n",
"Python allows us to check how many elements a list contains using the $len(lst)$ function, and access an element at index $i$ using the command $lst[i]$"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
""
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {
"scrolled": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n"
]
},
{
"data": {
"text/plain": [
"8"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"[10, 1, 2, 3, 'name', , True, [3.14, 2.5]]\n"
]
}
],
"source": [
"x = 10\n",
"lst = [x, 1, 2, 3, \"name\", print, True, [3.14, 2.5]]\n",
"print(type(lst))\n",
"len(lst)\n",
"print(lst)\n",
"\n"
]
},
{
"attachments": {
"image.png": {
"image/png": "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"
}
},
"cell_type": "markdown",
"metadata": {},
"source": [
"![image.png](attachment:image.png)"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"10"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"text/plain": [
"'name'"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"hi my name is michal\n"
]
}
],
"source": [
"lst[0]\n",
"\n",
"lst[4]\n",
"print(type(lst[5]))\n",
"\n",
"lst[5](\"hi\", \"my name is\", \"michal\")\n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[3.14, 2.5]"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
},
{
"ename": "IndexError",
"evalue": "list index out of range",
"output_type": "error",
"traceback": [
"\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[1;31mIndexError\u001b[0m Traceback (most recent call last)",
"\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[0mlst\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m7\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mlst\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m8\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
"\u001b[1;31mIndexError\u001b[0m: list index out of range"
]
}
],
"source": [
"lst[7]\n",
"lst[8]\n",
"\n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[10, 1, 2, 3, 'name', , True, [3.14, 2.5]]"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"text/plain": [
"[3.14, 2.5]"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"text/plain": [
"3.14"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"\n",
"lst\n",
"\n",
"lst[-1]\n",
"\n",
"\n",
"\n",
"lst[-1][0]\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[10, 1, 2, 3, 'name', , True, [3.14, 2.5]]\n",
"[10, 1000, 2, 3, 'name', , True, [3.14, 2.5]]\n"
]
},
{
"ename": "IndexError",
"evalue": "list assignment index out of range",
"output_type": "error",
"traceback": [
"\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[1;31mIndexError\u001b[0m Traceback (most recent call last)",
"\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlst\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 6\u001b[1;33m \u001b[0mlst\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m8\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m40\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[1;31mIndexError\u001b[0m: list assignment index out of range"
]
}
],
"source": [
"print(lst)\n",
"lst[1] = 1000\n",
"\n",
"print(lst)\n",
"\n",
"lst[8] = 40\n"
]
},
{
"attachments": {
"image.png": {
"image/png": "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"
}
},
"cell_type": "markdown",
"metadata": {},
"source": [
"![image.png](attachment:image.png)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## The empty list\n",
"\n",
"Just like we've seen the important empty string (''), there is an important list in python - the empty list (that is - the list containing no items).\n",
"\n",
"What would we expect the length of the empty list to be? What can we expect will happen if we try to access to first element in that list?"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {
"scrolled": true
},
"outputs": [
{
"data": {
"text/plain": [
"0"
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
},
{
"ename": "IndexError",
"evalue": "list index out of range",
"output_type": "error",
"traceback": [
"\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[1;31mIndexError\u001b[0m Traceback (most recent call last)",
"\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[0mempty_lst\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mempty_lst\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mempty_lst\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[1;31mIndexError\u001b[0m: list index out of range"
]
}
],
"source": [
"empty_lst = []\n",
"len(empty_lst)\n",
"empty_lst[0]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## List slicing\n",
"\n",
"List slicing is a method of extracting a sublist from an existing one. The syntax should be familiar, it is the same as the syntax for range. Specifically, $lst[a:b:c]$ will give us the sublist of $lst$, starting from index $a$, up to (and exclusive of) $b$, in intervals of size $c$."
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {
"scrolled": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[3, , [3.14, 2.5]]\n",
"[10, 1, 2, 3, 'name', , True, [3.14, 2.5]]\n"
]
}
],
"source": [
"x = 10\n",
"lst = [x, 1, 2, 3, \"name\", print, True, [3.14, 2.5]]\n",
"lst_new = lst[3: 8: 2]\n",
"print(lst_new)\n",
"print(lst)\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## List concatenation\n",
"\n",
"Again, similar to what we've seen last week with strings, a natural action to take given two lists $l1, l2$ is concatenation: a list containing $len(l1)+len(l2)$ items, where the first $len(l1)$ items are those of $l1$ and the rest are those of $l2$.\n",
"\n",
"There are various methods of concatenating lists in python, let's look at them and discuss their pros and cons."
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[1, 2, 3, 10, 20, 30]"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"text/plain": [
"[1, 2, 3]"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"text/plain": [
"[10, 20, 30]"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"lst1 = [1, 2, 3]\n",
"lst2 = [10, 20, 30]\n",
"\n",
"# Creating a new concatenated list\n",
"lst_new = lst1 + lst2\n",
"lst_new\n",
"lst1\n",
"lst2\n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Bad coding:\n"
]
},
{
"data": {
"text/plain": [
"[1, 2, 3, 10, 20, 30]"
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Adding the elements of lst2 to lst1\n",
"print(\"Bad coding:\")\n",
"lst1 = lst1 + lst2\n",
"lst1\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(\"Good coding:\")\n",
"lst1 = [1, 2, 3]\n",
"lst2 = [10, 20, 30]\n",
"lst1.extend(lst2)\n",
"lst1\n",
"\n",
"lst1.append(10)\n",
"lst1\n",
"\n",
"lst1.append(lst2)\n",
"lst1\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"\n",
"lst1 = [1,2,3]\n",
"lst2 = [10,20,30]\n",
"\n",
"lst1 += lst2 #invokes extend!! \n",
"lst1.extend(lst2)\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Common List functions\n",
"\n",
"We've seen the $len(\\cdot)$ function, and in a sense, the indexing call $lst[i]$ is also a function. What other builtin functions does Python supply for lists?"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"-24.5"
]
},
"execution_count": 23,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"lst = [10, -40.5, 6]\n",
"sum(lst)"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[-40.5, 6, 10]"
]
},
"execution_count": 24,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"text/plain": [
"[10, -40.5, 6]"
]
},
"execution_count": 24,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"text/plain": [
"[-40.5, 6, 10]"
]
},
"execution_count": 24,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"lst = [10, -40.5, 6]\n",
"slst = sorted(lst)\n",
"slst\n",
"lst\n",
"\n",
"lst.sort()\n",
"lst"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Iterating over lists\n",
"\n",
"Let's combine two things we've seen today: loops and lists.\n",
"\n",
"Given a list, it is easy to iterate over the list elements. One way of doing that is to initialize an index $i=0$ and use a $while$ loop to iterate over $i < len(lst)$ where in each iteration we can access the $i$-th element in the list via the command $lst[i]$"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n",
"2\n",
"3\n",
"4\n",
"hi\n",
"bye\n",
"100\n"
]
}
],
"source": [
"lst = [1, 2, 3, 4, \"hi\", \"bye\", 100]\n",
"i = 0\n",
"while i < len(lst):\n",
" print(lst[i])\n",
" i += 1"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"But wait, this is a very structured loop! Given $lst$, we know exactly how many iterations it will run and so it makes much more sense to do a similar iteration with a for loop iterating over the $range$ of the length of the list:"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n",
"2\n",
"3\n",
"4\n",
"hi\n",
"bye\n",
"100\n"
]
}
],
"source": [
"lst = [1, 2, 3, 4, \"hi\", \"bye\", 100]\n",
"for i in range(len(lst)):\n",
" print(lst[i])\n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"Finally, we have another option. A list is what we call an \"iterable\" type in python, meaning there is a natural way for python to iterate over the elements of the list.\n",
"We can use this natural iteration by iteration over the **elements** of the list using a for loop:"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n",
"\n",
"2\n",
"\n",
"3\n",
"\n",
"4\n",
"\n",
"hi\n",
"\n",
"bye\n",
"\n",
"100\n",
"\n",
"[1, 2, 3, 4, 'hi', 'bye', 100]\n"
]
}
],
"source": [
"lst = [1, 2, 3, 4, \"hi\", \"bye\", 100]\n",
"for item in lst:\n",
" print(item)\n",
" print(type(item))\n",
" \n",
"print(lst)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Think? When would it make sense to loop over the list using the $range$ of the length of the list and when would it make sense to simply loop over the elements themselves?\n",
"\n",
"## Exercise: given grades, how many are there above average?"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"#### solution 1: using loops"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"How many grades? 4\n",
"enter a grade: 86\n",
"enter a grade: 75\n",
"enter a grade: 46\n",
"enter a grade: 99\n",
"2 grades are above the average 76.5\n"
]
}
],
"source": [
"count = int(input(\"How many grades? \"))\n",
"above = 0\n",
"\n",
"grades = []\n",
"for i in range(count):\n",
" grade = float(input(\"enter a grade: \"))\n",
" #grades[i] = grade #wrong\n",
" #grades.append(grade)\n",
" #grades.extend([grade])\n",
" grades += [grade] #invokes extend\n",
" #grades = grades + [grade] #bad coding!\n",
" \n",
"s = sum(grades)\n",
"avg = s/count\n",
"\n",
"for grade in grades:\n",
" if grade > avg:\n",
" above += 1\n",
"\n",
"print(above, \"grades are above the average\", avg)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### list comprehension:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"A list comprehension command has the following structure:\n",
"\n",
" lst = [x for y in object if cond]\n",
"\n",
"And is equivalent to the following piece of code:\n",
"\n",
" lst = []\n",
" for y in object:\n",
" if cond:\n",
" lst.append(x)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### list comprehension example:"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[0, 3, 6, 9]"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"lst = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
"\n",
"lst1 = [x for x in lst if x % 3 == 0]\n",
"lst1\n"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[0, 9, 36, 81]"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"lst2 = [x**2 for x in lst if x % 3 == 0]\n",
"lst2\n"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['hi', 'hi', 'hi', 'hi']"
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"lst3 = [\"hi\" for x in lst if 2*x > 10]\n",
"lst3\n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"lst4 = [1 for x in lst]\n",
"lst4"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Solution 2: using list comprehension"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"count = int(input(\"How many grades? \"))\n",
"above = 0\n",
"\n",
"grades = []\n",
"#try to replace this loop by list comprehension exp\n",
"for i in range(count):\n",
" grade = float(input(\"enter a grade: \"))\n",
" #grades[i] = grade #wrong\n",
" #grades.append(grade)\n",
" #grades.extend([grade])\n",
" grades += [grade] #invokes extend\n",
" #grades = grades + [grade] #bad coding!\n",
" \n",
"s = sum(grades)\n",
"avg = s/count\n",
"\n",
"\n",
"above = len([grade for grade in grades if grade > avg])\n",
"\n",
"print(above, \"grades are above the average\", avg)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Functions: max2, max3\n",
"\n",
"In the code we've seen so far we made use of various built-in python functions (print, len, etc). \n",
"\n",
"Each call to such a function is actually a call to a sequence of commands encapsulated within it \n",
"\n",
"For example, printing a string encapsulates an iteration over the characters of the string, printing each one in turn. Had we needed to call this sequence of command each time we wanted to print a string, our code would look a lot more messy.\n",
"\n",
"Similarly, we would like to have the option of defining a complex operation that is easily callable, and for that we use functions:"
]
},
{
"attachments": {
"image.png": {
"image/png": "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"
}
},
"cell_type": "markdown",
"metadata": {},
"source": [
"![image.png](attachment:image.png)"
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"30\n"
]
},
{
"ename": "TypeError",
"evalue": "max2() missing 1 required positional argument: 'b'",
"output_type": "error",
"traceback": [
"\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)",
"\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 12\u001b[0m \u001b[0mx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmax2\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m30\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 13\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 14\u001b[1;33m \u001b[0my\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmax2\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[1;31mTypeError\u001b[0m: max2() missing 1 required positional argument: 'b'"
]
}
],
"source": [
"def max2(a,b):\n",
" '''\n",
" max2(float,float) ---> float\n",
" return the maximum of a and b\n",
" '''\n",
" if a>=b:\n",
" return a\n",
" #else:\n",
" # return b\n",
" return b\n",
"\n",
"x = max2(10,30)\n",
"print(x)\n",
"y = max2(10)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### max3"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"So we know how to find the maximum between two numbers. What do we do if we're given 3 numbers?\n",
"\n",
"Given $a,b,c$, we can check whether $a$ is the largest (i.e., $a \\geq b$ and $a \\geq c$). If this is not the case we can check if $b$ is the largest similarly ($b \\geq a$ and $b \\geq c$). If this is also False, we must have that $c$ is the largest.\n",
"\n",
"Let's see the code:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def max3_v1(a,b,c):\n",
" if a >= b and a >= c:\n",
" return a\n",
" elif b >= a and b >= c:\n",
" return b\n",
" else:\n",
" return c"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"But...\n",
"\n",
"Come to think of it, we already know how to find the maximum between two numbers. How can we use the function $max2$ in order to solve $max3$ without \"reinventing the wheel\"?"
]
},
{
"attachments": {
"image.png": {
"image/png": "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"
}
},
"cell_type": "markdown",
"metadata": {},
"source": [
"![image.png](attachment:image.png)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def max3_v2(a,b,c):\n",
"# max_ab = max2(a,b)\n",
"# total_max = max2(max_ab,c)\n",
"# return total_max\n",
" return max2(max2(a,b), c)\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Collatz over range, with functions"
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n",
"1 is OK!\n",
"2 1\n",
"2 is OK!\n",
"3 10 5 16 8 4 2 1\n",
"3 is OK!\n",
"4 2 1\n",
"4 is OK!\n",
"5 16 8 4 2 1\n",
"5 is OK!\n",
"6 3 10 5 16 8 4 2 1\n",
"6 is OK!\n"
]
}
],
"source": [
"\n",
"def collatz(orig_num):\n",
" num = orig_num\n",
" \n",
" while num > 1:\n",
" print(num, end=\" \")\n",
" if num%2 == 0:\n",
" num = num//2\n",
" else:\n",
" num = 3*num+1\n",
" \n",
" print(num)\n",
" print(orig_num, \"is OK!\")\n",
" \n",
" \n",
"def collatz_range(limit):\n",
" for num in range(1, limit + 1):\n",
" collatz(num)\n",
"\n",
" \n",
"collatz_range(6)\n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Short circuit evaluation\n",
"\n",
"When python evaluates logical expressions, there are certain cases where the evaluation can be \"cut short\" in the middle of the expression. Consider the following example: given the predicate $a \\textrm{ or } b$ and prior knowledge that $a = True$, do we really need to evaluate $b$?\n",
"\n",
"The answer is no, since $True \\textrm{ or } b = True$ for any $b$.\n",
"\n",
"And since python is smart and efficient, given such a predicate, after evaluating $a = True$ python will immediately interpret the whole predicate as $True$ without evaluating $b$:"
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {
"scrolled": true
},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 38,
"metadata": {},
"output_type": "execute_result"
},
{
"ename": "ZeroDivisionError",
"evalue": "division by zero",
"output_type": "error",
"traceback": [
"\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[1;31mZeroDivisionError\u001b[0m Traceback (most recent call last)",
"\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m/\u001b[0m\u001b[1;36m0\u001b[0m \u001b[1;32mor\u001b[0m \u001b[1;32mTrue\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 5\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
"\u001b[1;31mZeroDivisionError\u001b[0m: division by zero"
]
}
],
"source": [
"x = True or 3/0\n",
"x\n",
"\n",
"x = 3/0 or True\n",
"x\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"What do we expect will happen on the other hand, given a predicate of the form $a \\textrm{ and } b$?"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 39,
"metadata": {},
"output_type": "execute_result"
},
{
"ename": "ZeroDivisionError",
"evalue": "division by zero",
"output_type": "error",
"traceback": [
"\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[1;31mZeroDivisionError\u001b[0m Traceback (most recent call last)",
"\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mTrue\u001b[0m \u001b[1;32mand\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m/\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 5\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
"\u001b[1;31mZeroDivisionError\u001b[0m: division by zero"
]
}
],
"source": [
"x = False and 3/0\n",
"x\n",
"\n",
"x = True and 3/0\n",
"x"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.2"
}
},
"nbformat": 4,
"nbformat_minor": 1
}