Lesson_2_jupyterhub.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "8d2a337c-6540-4546-bda6-475b80eebf62",
   "metadata": {},
   "source": [
    "# Some string methods.\n",
    "\n",
    "## We already talked a lot about strings, let's see some specific useful functions/methods (even though we still have to define what a function is)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "40e5bfe4-d1d5-4e87-9e25-029f9a19f58f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# the join method\n",
    "word = ['apple', 'pear', 'orange']\n",
    "sep = '::'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "7c10875a-fce5-497b-be71-eeaf7bdb7d70",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'apple::pear::orange'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sep.join(word)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "ef1dfe6d-d1fd-4bfe-af5c-081c41367238",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apple', 'pear', 'orange']"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = 'apple||pear||orange'\n",
    "sep = '||'\n",
    "\n",
    "s.split(sep)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "6e5c8c08-6aa8-4f61-beda-fcc3a9e80b48",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = 'apple||pear||orange'\n",
    "s.find('z')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "3856256d-c8ec-427f-9b81-6228fff20a57",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'apple||pear||orange'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "b10faa1c-e7e7-4786-ac8d-455b718f4807",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'banana||pear||orange'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.replace('apple', 'banana')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f0f4c99-3d6b-48ff-9a51-b4b4d46beab8",
   "metadata": {},
   "source": [
    "# Regular Expression\n",
    "\n",
    "RegEx is a *language* (a sequence of symbols and characters) used to express a **pattern** to be searched for within a string.\n",
    "\n",
    "```\n",
    "PN12W_bio1_tech1\n",
    "PN12W_bio1_tech2\n",
    "PN24NW_bio2_tech1\n",
    "PN24NWW_bio2_tech2\n",
    "PN48W_bio3_tech1\n",
    "```\n",
    "\n",
    "RegEx is a very versitile and powerful tool that can be used anytime the normal `string` functions/methods are not enough. RegEx is a language indipendent from Python and exists in pretty much any programming language.\n",
    "\n",
    "Online tool [RegEx101](https://regex101.com/)\n",
    "\n",
    "To use RegEx in Python you will need to import the package `re`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "ce5e0a6f-251a-436b-a66f-1ddca17184b8",
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "pattern = '_bio\\d_'\n",
    "my_strings = 'PN12W_bio1_tech1 PN12W_bio1_tech2 PN24NW_bio2_tech1 PN24NW_bio2_tech2 PN48W_bio3_tech1'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "23ccbd4a-bb7c-4f8c-a0b4-d9e4e3d4c03e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['_bio1_', '_bio1_', '_bio2_', '_bio2_', '_bio3_']"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.findall(pattern, my_strings)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "12343823-17ff-472e-b84f-b219a4038b2d",
   "metadata": {},
   "outputs": [],
   "source": [
    "pattern = '_bio(\\d)_'\n",
    "my_strings = 'PN12W_bio1_tech1 PN12W_bio1_tech2 PN24NW_bio2_tech1 PN24NW_bio2_tech2 PN48W_bio3_tech1'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "a1255079-5967-4e8e-8ef0-ffd835f1a055",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['1', '1', '2', '2', '3']"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.findall(pattern, my_strings)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "5c0017f1-3a7b-4aad-81da-eaa8b34bd60d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'PN12W_tech1 PN12W_tech2 PN24NW_tech1 PN24NW_tech2 PN48W_tech1'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pattern = '_bio\\d_'\n",
    "my_strings = 'PN12W_bio1_tech1 PN12W_bio1_tech2 PN24NW_bio2_tech1 PN24NW_bio2_tech2 PN48W_bio3_tech1'\n",
    "\n",
    "re.sub(pattern, '_', my_strings)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "fa0747c3-9d33-4417-8549-3b6d982a63ef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['PN12W',\n",
       " 'tech1 PN12W',\n",
       " 'tech2 PN24NW',\n",
       " 'tech1 PN24NW',\n",
       " 'tech2 PN48W',\n",
       " 'tech1']"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pattern = '_bio\\d_'\n",
    "my_strings = 'PN12W_bio1_tech1 PN12W_bio1_tech2 PN24NW_bio2_tech1 PN24NW_bio2_tech2 PN48W_bio3_tech1'\n",
    "\n",
    "re.split(pattern, my_strings)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "978e42ab-457d-43c1-8158-c170ab6bcad7",
   "metadata": {},
   "source": [
    "# Control Structures\n",
    "\n",
    "With variable assignment and Control Structure you have essentially everything you need to build a real program (implement algorithms).\n",
    "\n",
    "Let's start with the `IF` statement\n",
    "\n",
    "The syntax is the following\n",
    "\n",
    "```\n",
    "if <condition>:\n",
    "  <True block of code>\n",
    "else:\n",
    "  <False block of code>\n",
    "```\n",
    "\n",
    "The `condition` is **always** considered a `boolean` value. If it is `True`, the **True block** gets executed otherwise (`False`) the **False block** gets executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "cb80f02a-f282-4c5c-91c1-b307dc561ddf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is bigger than b\n"
     ]
    }
   ],
   "source": [
    "a = 5\n",
    "b = 1\n",
    "\n",
    "if a > b:\n",
    "    print('a is bigger than b')\n",
    "else:\n",
    "    print('b is bigger or equal than a')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "9c66fd64-ad67-451f-ae7f-21986762b21f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a > b"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6588f09a-7214-4f3c-aa41-1712f596c793",
   "metadata": {},
   "source": [
    "`a > b` returns a `boolean` value, but we are not forced to have an expression that return a `boolean` value because **anything** in the *guard* (*condition*) will be **casted** (evaluated) as `boolean`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "9b4d0039-fb6e-4a40-9041-b317a9614617",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the string a is non empty\n",
      "here is anothe message\n"
     ]
    }
   ],
   "source": [
    "a = 'hello world'\n",
    "\n",
    "if a:\n",
    "    print('the string a is non empty')\n",
    "    print('here is anothe message')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "d33f6ec2-4b3d-4e5d-add5-80c45404769f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is empty\n"
     ]
    }
   ],
   "source": [
    "a = []\n",
    "if a:\n",
    "    print('a is not empty')\n",
    "else:\n",
    "    print('a is empty')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "adc99a8d-d786-46c7-9a4b-bfe0f10bcc5a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "994eaebb-28d1-461d-a2d3-67e84456359d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cold and snow\n"
     ]
    }
   ],
   "source": [
    "season = 'winter'\n",
    "\n",
    "if season == 'spring':\n",
    "    print('blooming flowers')\n",
    "elif season == 'summer':\n",
    "    print('hot and sunny')\n",
    "elif season == 'autumn':\n",
    "    print('falling leaves')\n",
    "elif season == 'winter':\n",
    "    print('cold and snow')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "8ce558fb-20c4-41cf-a9ca-4984886ae11e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cold\n"
     ]
    }
   ],
   "source": [
    "if season == 'spring':\n",
    "    print('blooming flowers')\n",
    "elif season == 'summer':\n",
    "    print('hot and sunny')\n",
    "else:\n",
    "    print('cold')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "02b869de-c502-40dd-842b-c290140ffed2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cold\n"
     ]
    }
   ],
   "source": [
    "if season == 'spring' or season == 'summer':\n",
    "    print('hot')\n",
    "else:\n",
    "    print('cold')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "ba3fa3e1-1e72-462d-9ae9-8b2469a1aca5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# and -> &&\n",
    "# or -> ||\n",
    "# not -> !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "3c605257-1dbc-47a2-96e9-9837d5af6364",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "f8ebcfda-2a2d-445c-a9eb-e2ac63537787",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "2fb2607c-61fc-475d-9687-93c513803e6a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "False or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "df22a568-45e3-40c0-8aa1-31d311eeeb19",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "51d22551-e2a9-45c0-b914-015a0422ce4b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "blooming flowers\n",
      "hello\n"
     ]
    }
   ],
   "source": [
    "season = 'spring'\n",
    "if season == 'spring':\n",
    "    print('blooming flowers')\n",
    "else:\n",
    "    print('else branch')\n",
    "\n",
    "print('hello')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3e3e538-1580-4ac1-b227-6fb7c6edb32b",
   "metadata": {},
   "source": [
    "# The FOR statement is by far, together with the IF statement, the control structures you are going to use the most. Let's see the syntax:\n",
    "\n",
    "```\n",
    "for <cycle variable> in <iterator or generator>:\n",
    "  <block of code>\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "eda2b404-ae3b-4487-9d1c-c23f2564c0b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello a\n",
      "hello 1\n",
      "hello 2\n",
      "hello 3\n",
      "hello 4.0\n",
      "hello True\n",
      "hello hello\n"
     ]
    }
   ],
   "source": [
    "lst_a = ['a', 1, 2, 3, 4.0, True, 'hello']\n",
    "\n",
    "for x in lst_a:\n",
    "    print('hello', x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "eb0f8b0e-fdc1-447b-9904-f9a21cd003af",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello a\n",
      "hello 1\n",
      "hello 2\n",
      "hello 3\n",
      "hello 4.0\n",
      "hello True\n",
      "hello hello\n"
     ]
    }
   ],
   "source": [
    "print('hello', 'a')\n",
    "print('hello', 1)\n",
    "print('hello', 2)\n",
    "print('hello', 3)\n",
    "print('hello', 4.0)\n",
    "print('hello', True)\n",
    "print('hello', 'hello')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "b257b7ea-0ce0-41ac-aa2d-74fe3a075d4c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# for (int i=0; i < n; i++) {\n",
    "#  lst_a[i]\n",
    "# }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "6ebbb470-922a-42d0-84a6-a2838868d0cc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "hello\n",
      "hello\n",
      "hello\n",
      "hello\n",
      "hello\n",
      "hello\n",
      "hello\n"
     ]
    }
   ],
   "source": [
    "a = [0,0,0,0,0,0,0,0]\n",
    "for x in a:\n",
    "    print('hello')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "f6928ff5-f1c6-4e98-a772-af66870106c4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "2e7d38ae-0f76-456f-9619-a964d43b586f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 10)"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "1add409c-4c4f-419d-8349-281556b35a60",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "hello\n",
      "hello\n",
      "hello\n",
      "hello\n",
      "hello\n",
      "hello\n",
      "hello\n"
     ]
    }
   ],
   "source": [
    "for x in range(8):\n",
    "    print('hello')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "b5d56232-54ed-4666-890f-75c2d3a492b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 is even\n",
      "1 is odd\n",
      "2 is even\n",
      "3 is odd\n",
      "4 is even\n",
      "5 is odd\n",
      "6 is even\n",
      "7 is odd\n",
      "8 is even\n",
      "9 is odd\n"
     ]
    }
   ],
   "source": [
    "# print the first ten numbers and print who is odd and who is even\n",
    "for i in range(10):\n",
    "    if i % 2 == 0:\n",
    "        print(i, 'is even')\n",
    "    else:\n",
    "        print(i, 'is odd')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "46e08083-ed46-48a5-8268-f84995ea35e8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "daniel\n",
      "denise\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Ciao'"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# given the following list\n",
    "names = ['anne', 'chris', 'daniel', 'denise', 'jacob', 'lisa', 'maria']\n",
    "\n",
    "# print all names that starts with the letter 'd'\n",
    "for name in names:\n",
    "    if \"d\" == name[0]:\n",
    "        print(name)\n",
    "\n",
    "# the string method capitalize() will return a string with the first capital letter, i.e. 'ciao'.capitalize() will get Ciao\n",
    "# create a new list where all names are capitalized\n",
    "\n",
    "# how many times is the letter 'i' present in the names list (use a loop statement this time)? Can you think of a way to count all unique letters?\n",
    "# --> your code here <--\n",
    "\n",
    "# create a list of strings that represent even numbers from 100 to 150 included\n",
    "# --> your code here <--"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "8dc408cc-286a-4b0a-9711-f45b2e57a15a",
   "metadata": {},
   "outputs": [],
   "source": [
    "names = ['anne', 'chris', 'daniel', 'denise', 'jacob', 'lisa', 'maria']\n",
    "names2 = names.copy()\n",
    "for x in range(len(names)):\n",
    "    names2[x] = names[x].capitalize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "d698f24f-1f4a-4b3b-977d-08e0635a5ecd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Anne', 'Chris', 'Daniel', 'Denise', 'Jacob', 'Lisa', 'Maria']"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "2fef2dce-0039-4207-a82b-7afb0b106f20",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['anne', 'chris', 'daniel', 'denise', 'jacob', 'lisa', 'maria']"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "89f9beb4-8235-4ec3-8481-a50a3a8b852b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Anne\n",
      "Chris\n",
      "Daniel\n",
      "Denise\n",
      "Jacob\n",
      "Lisa\n",
      "Maria\n"
     ]
    }
   ],
   "source": [
    "for i in names:\n",
    "    new_names = i.capitalize() \n",
    "    print(new_names) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "fcf2d41e-88f6-4f60-bd32-f03f2f2a9869",
   "metadata": {},
   "outputs": [],
   "source": [
    "names = ['anne', 'chris', 'daniel', 'denise', 'jacob', 'lisa', 'maria']\n",
    "Names = []\n",
    "for name in names:\n",
    "    Names.append(name.capitalize()) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "d933ad25-3f1c-49f6-9530-a8b1688eba22",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Anne', 'Chris', 'Daniel', 'Denise', 'Jacob', 'Lisa', 'Maria']"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "fec7688d-edf2-457e-8cff-7fdd809401d7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['anne', 'chris', 'daniel', 'denise', 'jacob', 'lisa', 'maria']"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "2543b51c-aa74-4da2-a7c7-ce9bb38bee78",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "count = 0\n",
    "for name in names:\n",
    "    count += name.count('i') # count = count + name.count('i')\n",
    "print(count) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "343949ea-0b2d-492b-80ee-ac07cf623ef7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'daniel'.count('i')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "18da7890-3738-4759-8f81-ff0fd4b671a8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['anne', 'chris', 'daniel', 'denise', 'jacob', 'lisa', 'maria']"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "fc88d4df-fe45-4e7b-a369-761b32420ba9",
   "metadata": {},
   "outputs": [],
   "source": [
    "letters = []\n",
    "for name in names:\n",
    "    for letter in list(name):\n",
    "        letters.append(letter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "c5a9409f-6c9b-4bdb-8928-f7df0733d51e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a', 'b', 'c', 'd', 'e', 'h', 'i', 'j', 'l', 'm', 'n', 'o', 'r', 's'}"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set(letters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "b5139bfd-8f9e-45f5-ae29-943c58aafd88",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a', 'b', 'c', 'd', 'e', 'h', 'i', 'j', 'l', 'm', 'n', 'o', 'r', 's'}"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set(''.join(names))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "d43b02b0-fb38-478f-b4f9-80257a72ee3e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(10, 20))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "81d9eb46-de93-42e9-b40d-348f1f9cc358",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['100', '102', '104', '106', '108', '110', '112', '114', '116', '118', '120', '122', '124', '126', '128', '130', '132', '134', '136', '138', '140', '142', '144', '146', '148', '150']\n"
     ]
    }
   ],
   "source": [
    "numbers = [] \n",
    "for number in range(100,151): \n",
    "    if number % 2 == 0: \n",
    "        numbers.append(str(number)) \n",
    "print(numbers) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "2ffb3125-1356-4dac-8c3e-9a3c8dc01ddc",
   "metadata": {},
   "outputs": [],
   "source": [
    "even_num = list(range(100, 151, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "952ef714-2fbe-4776-b0e0-4c3b987be8c9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150]\n"
     ]
    }
   ],
   "source": [
    "print(even_num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "id": "da948fe9-1fc1-4ec7-8bd6-34947969f9ca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import re\n",
    "name_string = \"\\n\".join(names)\n",
    "pattern = r\"^d\"\n",
    "re.findall(pattern, name_string) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "id": "403486be-bdcc-404f-a0aa-ba5d715ca4f8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['d', 'd']"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import re\n",
    "name_string = \" \".join(names)\n",
    "pattern = \"\\s(d)\"\n",
    "re.findall(pattern, name_string) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "id": "6a0f4a49-1646-438e-93f8-93fa50a48f7f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'marco\\nchris\\ndaniel\\njacob\\nlisa\\nanne\\ndenise'"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name_string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "b663e6c8-91b5-4f8b-b307-84311b46b102",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<enumerate object at 0x7fa4e5602100>\n"
     ]
    }
   ],
   "source": [
    "# let's introduce the enumerate function that takes an iterator and return a generator of tuple, the first element of the tuple is the index of the element in the iterator while the second is the element itself\n",
    "names = ['marco', 'chris', 'daniel', 'jacob', 'lisa', 'anne', 'denise']\n",
    "\n",
    "print(enumerate(names))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "fd332e0a-4f3d-475c-b267-41a9a6e0b541",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 'marco'),\n",
       " (1, 'chris'),\n",
       " (2, 'daniel'),\n",
       " (3, 'jacob'),\n",
       " (4, 'lisa'),\n",
       " (5, 'anne'),\n",
       " (6, 'denise')]"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(enumerate(names))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "13367c98-c957-4579-9d5e-3ff139352c6c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "marco 0\n",
      "chris 1\n",
      "daniel 2\n",
      "jacob 3\n",
      "lisa 4\n",
      "anne 5\n",
      "denise 6\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "for name in names:\n",
    "    print(name, i)\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "52284b04-6abc-42a6-9ae8-99b6ea83ffc7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "index 0 value marco\n",
      "index 1 value chris\n",
      "index 2 value daniel\n",
      "index 3 value jacob\n",
      "index 4 value lisa\n",
      "index 5 value anne\n",
      "index 6 value denise\n"
     ]
    }
   ],
   "source": [
    "for i in enumerate(names):\n",
    "    print('index', i[0], 'value', i[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "15501ad9-0cf0-4241-a598-d4ffaa8d244a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "index 0 value marco\n",
      "index 1 value chris\n",
      "index 2 value daniel\n",
      "index 3 value jacob\n",
      "index 4 value lisa\n",
      "index 5 value anne\n",
      "index 6 value denise\n"
     ]
    }
   ],
   "source": [
    "for i, j in enumerate(names):\n",
    "    print('index', i, 'value', j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "dd97969a-cd44-49f2-949f-1c4c25319e52",
   "metadata": {},
   "outputs": [],
   "source": [
    "names = ['marco', 'chris', 'daniel', 'jacob', 'lisa', 'anne', 'denise']\n",
    "numbers = ['333123456', '344561233', '33367409390', '3339386722', '344896725', '3339386345', '3449344766']\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "5cb29db9-bf21-496b-bc00-ce910907bb48",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('marco', '333123456'),\n",
       " ('chris', '344561233'),\n",
       " ('daniel', '33367409390'),\n",
       " ('jacob', '3339386722'),\n",
       " ('lisa', '344896725'),\n",
       " ('anne', '3339386345'),\n",
       " ('denise', '3449344766')]"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(zip(names, numbers))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "22730c9d-0a21-44b9-9965-34c137f62d90",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name marco Number 333123456\n",
      "Name chris Number 344561233\n",
      "Name daniel Number 33367409390\n",
      "Name jacob Number 3339386722\n",
      "Name lisa Number 344896725\n",
      "Name anne Number 3339386345\n",
      "Name denise Number 3449344766\n"
     ]
    }
   ],
   "source": [
    "for name, number in zip(names, numbers):\n",
    "    print('Name', name, 'Number', number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "2ef3d0fa-dfe8-4948-a98d-f64b809994c6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'marco': '333123456',\n",
       " 'chris': '344561233',\n",
       " 'daniel': '33367409390',\n",
       " 'jacob': '3339386722',\n",
       " 'lisa': '344896725',\n",
       " 'anne': '3339386345',\n",
       " 'denise': '3449344766'}"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = dict(zip(names, numbers))\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "bf14c611-3de4-4a5e-9c83-3d6cc0e803d3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "marco\n",
      "chris\n",
      "daniel\n",
      "jacob\n",
      "lisa\n",
      "anne\n",
      "denise\n"
     ]
    }
   ],
   "source": [
    "for i in d:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "a7f7b7fa-c27f-4fc2-bfe0-8ff9757cc7ea",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('marco', '333123456'), ('chris', '344561233'), ('daniel', '33367409390'), ('jacob', '3339386722'), ('lisa', '344896725'), ('anne', '3339386345'), ('denise', '3449344766')])"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "id": "76b1aa41-1336-4c9e-a68a-830712ad7fc4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "key marco value 333123456\n",
      "key chris value 344561233\n",
      "key daniel value 33367409390\n",
      "key jacob value 3339386722\n",
      "key lisa value 344896725\n",
      "key anne value 3339386345\n",
      "key denise value 3449344766\n"
     ]
    }
   ],
   "source": [
    "for k, v in d.items():\n",
    "    print('key', k, 'value', v)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bacd75c9-d128-4701-ada8-576bc7d818e0",
   "metadata": {},
   "source": [
    "# The `WHILE` statement, despite being the first and most powerful iteration statement, I think about it as a combination of `FOR` and `IF` and rarely use it (only for infinite loop).\n",
    "\n",
    "```\n",
    "while <condition>:\n",
    "    <block of code>\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "id": "ca694fb0-5623-4c35-a997-a2779863f2bf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "a = 0\n",
    "while a < 5:\n",
    "    print(a)\n",
    "    a += 1 # <- this one is really important"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "id": "ae30580d-eaaf-401f-9d90-58e83ada3871",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 < 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "id": "9ee2449d-3849-42cf-a959-b4b390278df4",
   "metadata": {},
   "outputs": [],
   "source": [
    "letters = [chr(i) for i in range(97, 123)] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "id": "82307fac-6452-4795-a46d-1506b4e2216e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']\n"
     ]
    }
   ],
   "source": [
    "print(letters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "id": "4d0e42ca-a5c7-4b2b-9ab9-c8e66fba98cb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a inside the loop\n",
      "b inside the loop\n",
      "c inside the loop\n",
      "d inside the loop\n",
      "e inside the loop\n",
      "outside the for loop\n"
     ]
    }
   ],
   "source": [
    "for l in letters:\n",
    "    if l == 'f':\n",
    "        break\n",
    "    print(l, 'inside the loop')\n",
    "print('outside the for loop')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "id": "2d082c59-2546-4f95-b77c-16914a0274b8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a inside the loop\n",
      "b inside the loop\n",
      "c inside the loop\n",
      "d inside the loop\n",
      "e inside the loop\n",
      "g inside the loop\n",
      "h inside the loop\n",
      "i inside the loop\n",
      "j inside the loop\n",
      "k inside the loop\n",
      "l inside the loop\n",
      "m inside the loop\n",
      "n inside the loop\n",
      "o inside the loop\n",
      "p inside the loop\n",
      "q inside the loop\n",
      "r inside the loop\n",
      "s inside the loop\n",
      "t inside the loop\n",
      "u inside the loop\n",
      "v inside the loop\n",
      "w inside the loop\n",
      "x inside the loop\n",
      "y inside the loop\n",
      "z inside the loop\n",
      "outside the for loop\n"
     ]
    }
   ],
   "source": [
    "for l in letters:\n",
    "    if l == 'f':\n",
    "        continue # instead of break\n",
    "    print(l, 'inside the loop')\n",
    "print('outside the for loop')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "id": "86e2ae8d-3e3b-42f2-a528-e0c1326ba06f",
   "metadata": {},
   "outputs": [],
   "source": [
    "names = ['anne', 'chris', 'daniel', 'denise', 'jacob', 'lisa', 'maria', 'jack', 'rose', 'adele', 'max', 'sue']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "id": "de46f309-6b92-4c8f-9a6b-e555706ddc07",
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a list of all the possible couples\n",
    "couples = []\n",
    "for name1 in names:\n",
    "    for name2 in names:\n",
    "        if name1 != name2:\n",
    "            couple = sorted([name1, name2])\n",
    "            if not couple in couples:\n",
    "                couples.append(couple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "id": "7f07e529-ea8f-4266-8af4-9e7713bec851",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 201,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "id": "ccd18610-25ba-4fdf-8842-26c4851b7816",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "66"
      ]
     },
     "execution_count": 202,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(couples)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "id": "540edaba-b3df-4029-b73d-7b6b5b7be968",
   "metadata": {},
   "outputs": [],
   "source": [
    "couples = []\n",
    "for name1 in names:\n",
    "    for name2 in names:\n",
    "        if name1 == name2:\n",
    "            continue\n",
    "        couple = tuple(sorted([name1, name2]))\n",
    "        couples.append(couple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "id": "64f8f719-7439-4937-8b40-c2662e3f804f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "70"
      ]
     },
     "execution_count": 216,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(set(couples))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b2293701-6628-4dd4-8e37-538d52c11979",
   "metadata": {},
   "outputs": [],
   "source": [
    "names = ['anne', 'chris', 'daniel', 'denise', 'jacob', 'lisa', 'maria','jack', 'rose', 'adele', 'max', 'sue']\n",
    "# create all possible couples\n",
    "\n",
    "couples = []\n",
    "for i in names[:-1]:\n",
    "    for j in names[names.index(i)+1:]:\n",
    "        couple = [i,j]\n",
    "        couples.append(couple)\n",
    "        \n",
    "print(couples)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "id": "762f0ae2-8bea-469b-91c7-16c98779b737",
   "metadata": {},
   "outputs": [],
   "source": [
    "couples = []\n",
    "for i, e1 in enumerate(names):\n",
    "    for e2 in names[i + 1:]:\n",
    "        couples.append((e1, e2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "id": "5bcd2fb9-80b9-47bd-993a-017f6f1380b9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "66"
      ]
     },
     "execution_count": 233,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(couples)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "id": "c6cef00d-a0d8-4b78-9096-ad2d09f5ff68",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "66"
      ]
     },
     "execution_count": 236,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import itertools\n",
    "\n",
    "len(list(itertools.combinations(names, 2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "id": "4c5c0d56-5de9-4bce-9a1e-de64d7cb4f83",
   "metadata": {},
   "outputs": [],
   "source": [
    "# given the two following lists\n",
    "names = ['anne', 'chris', 'daniel', 'denise', 'jacob', 'lisa', 'maria', 'jack', 'rose', 'adele', 'max', 'sue']\n",
    "letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']\n",
    "\n",
    "# create a dictionary where the keys are letters and values are lists of names starting with that letter\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "id": "9c4ad962-ee6a-4119-86f0-4042e67c0de4",
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {}\n",
    "for letter in letters:\n",
    "    d[letter] = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "id": "a719efb6-0027-437a-88f1-00e561319718",
   "metadata": {},
   "outputs": [],
   "source": [
    "for name in names:\n",
    "    d[name[0]].append(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "id": "54a7bb50-12d0-48c5-80dc-29cbd5551888",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 'adele', 'c': 'chris', 'd': 'denise', 'j': 'jack', 'l': 'lisa', 'm': 'max', 'r': 'rose', 's': 'sue'}\n"
     ]
    }
   ],
   "source": [
    "didid={}\n",
    "for letter in letters:\n",
    "    for name in names:\n",
    "        if letter == name[0]:\n",
    "            didid[letter] = name\n",
    "            #didid.append(letter)\n",
    "            #didid.append(name)\n",
    "print(didid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "id": "b361bd78-ffbb-4db3-b6b4-34f2aaeeee02",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': ['anne', 'adele'],\n",
       " 'c': ['chris'],\n",
       " 'd': ['daniel', 'denise'],\n",
       " 'j': ['jacob', 'jack'],\n",
       " 'l': ['lisa'],\n",
       " 'm': ['maria', 'max'],\n",
       " 'r': ['rose'],\n",
       " 's': ['sue']}"
      ]
     },
     "execution_count": 245,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "letters = [chr(i) for i in range(97,123)]\n",
    "names = ['anne', 'chris', 'daniel', 'denise', 'jacob', 'lisa', 'maria','jack', 'rose', 'adele', 'max', 'sue'] \n",
    "name_dict = {} # create a dictionary with letters as keys and names starting in that letter as values \n",
    "for name in names: \n",
    "    first_letter = name[0] \n",
    "    if not first_letter in name_dict: \n",
    "        name_dict[first_letter]=[name] \n",
    "    else: \n",
    "        name_dict[first_letter].append(name) \n",
    "name_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b59694c2-77b3-4be5-93d8-464309cdd29e",
   "metadata": {},
   "source": [
    "# List and Dictionary Comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "id": "2d790024-3f23-41a0-b006-7c01c4ad66b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = []\n",
    "for i in range(10):\n",
    "    a.append(i**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "id": "02a82fa7-c329-4a89-a1c3-aa15882c3c03",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 247,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "id": "bd23a5ca-83a1-4a0d-86c4-00da63842d27",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [i**2 for i in range(10)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "id": "46304f92-0fba-448f-96df-af0fa72c3f6b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 249,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "id": "91a10715-4c69-4e0f-9a53-e2494e169c97",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(97, 122, 65)"
      ]
     },
     "execution_count": 253,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord('a'), ord('z'), ord('A')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "id": "75cdfdc5-5cba-4825-8986-82968c2857b3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 251,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chr(97)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "id": "1a3df9e5-ba6b-473b-be27-17df00ee96ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "letters = [chr(i) for i in range(97, 123)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "id": "5794fb89-48d3-46d3-8b04-ab3443b48c7b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']\n"
     ]
    }
   ],
   "source": [
    "print(letters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "id": "f8bff045-1635-403c-88a0-396fae8587fc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 9, 25, 49, 81, 121, 169, 225, 289, 361]\n"
     ]
    }
   ],
   "source": [
    "print([i**2 for i in range(20) if i % 2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "id": "e3bf7d9a-a51b-4fcc-8bc4-84614641de91",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, -2, 9, -4, 25, -6, 49, -8, 81, -10, 121, -12, 169, -14, 225, -16, 289, -18, 361]\n"
     ]
    }
   ],
   "source": [
    "print([i**2 if i % 2 else -1 * i for i in range(20)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "id": "11bc54d3-fb20-40ff-8b57-6f9e4031cba2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['anne', 'chris', 'daniel', 'denise', 'jacob', 'lisa', 'maria', 'jack', 'rose', 'adele', 'max', 'sue']\n"
     ]
    }
   ],
   "source": [
    "print(names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "id": "3911f7b8-ac5c-4cb3-9e35-20c581b7c245",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 'adele',\n",
       " 'c': 'chris',\n",
       " 'd': 'denise',\n",
       " 'j': 'jack',\n",
       " 'l': 'lisa',\n",
       " 'm': 'max',\n",
       " 'r': 'rose',\n",
       " 's': 'sue'}"
      ]
     },
     "execution_count": 265,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{x[0]:x for x in names}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "id": "083c73db-fa5c-4e32-8405-80dc8c8b9ff2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([0, 1, 4, 9, 16, 25, 36, 49, 64, 81], list)"
      ]
     },
     "execution_count": 267,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a, type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 268,
   "id": "0fe18702-278f-49d2-a23c-f9d3c8790d8a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 268,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'a'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 272,
   "id": "3b6c6928-6b5b-43d6-ab9a-1bcd1394a239",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "97"
      ]
     },
     "execution_count": 272,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord('a') # ASCII code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 273,
   "id": "9fb886c1-2f7f-4fb6-ae3f-91040e35156d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# given the two following lists\n",
    "names = ['anne', 'chris', 'daniel', 'denise', 'jacob', 'lisa', 'maria', 'jack', 'rose', 'adele', 'max', 'sue']\n",
    "#letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']\n",
    "\n",
    "# create a dictionary where keys are items' names and value is its length\n",
    "# --> your code here <--\n",
    "\n",
    "# consider the following list\n",
    "idx = [2, 1, 11, 7, 0, 3, 4, 8, 5, 10, 9, 6]\n",
    "\n",
    "# reorder names using idx as the index order, that is anne should be moved to third position, index 2 instead of first position, index 0\n",
    "# --> your code here <--\n",
    "\n",
    "# create a dictionary with two keys 'even' and 'odd' an put as values the first 25 even and the first 50 odd numbers respectively\n",
    "# --> your code here <--"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 274,
   "id": "4c9ccf6d-97d9-4023-b18b-02170b084663",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'anne': 4,\n",
       " 'chris': 5,\n",
       " 'daniel': 6,\n",
       " 'denise': 6,\n",
       " 'jacob': 5,\n",
       " 'lisa': 4,\n",
       " 'maria': 5,\n",
       " 'jack': 4,\n",
       " 'rose': 4,\n",
       " 'adele': 5,\n",
       " 'max': 3,\n",
       " 'sue': 3}"
      ]
     },
     "execution_count": 274,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{n:len(n) for n in names} "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 280,
   "id": "1fb1d00c-3db8-4e74-9bb5-54e8f34bf99a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['jacob',\n",
       " 'chris',\n",
       " 'anne',\n",
       " 'lisa',\n",
       " 'maria',\n",
       " 'rose',\n",
       " 'sue',\n",
       " 'denise',\n",
       " 'jack',\n",
       " 'max',\n",
       " 'adele',\n",
       " 'daniel']"
      ]
     },
     "execution_count": 280,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x[1] for x in sorted(list(zip(idx, names)))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 283,
   "id": "c3e18748-b2c4-4194-8b22-72cc174ab344",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'odd': [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24], 'even': []}"
      ]
     },
     "execution_count": 283,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{'odd': [i for i in range(25) if i % 2 == 0], 'even': []}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 284,
   "id": "039a8159-ae49-47ca-871f-e6b0b97b0035",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'odd': [], 'even': []}"
      ]
     },
     "execution_count": 284,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{   'odd': [],\n",
    "    'even': []\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "09733bc1-10c8-4e85-8f22-80f161c3b5ab",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}