session_4.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('changeable', 'fluctuating', 'inconstant', 'variable')"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mutable_synonyms = ( 'changeable','fluctuating', 'inconstant', 'variable')\n",
    "mutable_synonyms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "empty = () # convention\n",
    "type(empty)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "also_empty = tuple()\n",
    "type(also_empty)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(mutable_synonyms)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['changeable', 'fluctuating', 'inconstant', 'variable']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(mutable_synonyms)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('changeable',\n",
       " 'fluctuating',\n",
       " 'inconstant',\n",
       " 'variable',\n",
       " 'modifiable',\n",
       " 'shifting')"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mutable_synonyms + ('modifiable', 'shifting')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('changeable', 'fluctuating', 'inconstant', 'variable')"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mutable_synonyms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'apple', 'book', 'box', 'coat', 'hair', 'lock', 'xylophone'}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "things = {'coat', 'lock', 'box', 'book', 'apple', 'hair', 'xylophone', 'lock', 'book'}\n",
    "things"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'M1M', 'M1T', 'M5R', 'M5V'}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "visitor_post_codes = ['M5R', 'M5V', 'M1M', 'M1M', 'M1T']\n",
    "set(visitor_post_codes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "empty_set = set()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'lock' in things"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "things.add('lock')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'apple', 'book', 'box', 'coat', 'hair', 'lock', 'xylophone'}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "things"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'box', 'coat', 'hair', 'xylophone', 'mirror', 'lock', 'apple', 'book'}\n"
     ]
    }
   ],
   "source": [
    "things.add('mirror')\n",
    "print(things)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "rainbow = {'red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet'}\n",
    "olympic_flag = {'red', 'green', 'yellow', 'blue', 'black'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'indigo', 'orange', 'violet'}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rainbow.difference(olympic_flag)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'black'}"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "olympic_flag.difference(rainbow)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'blue', 'green', 'indigo', 'orange', 'red', 'violet', 'yellow'}"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rainbow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'black', 'indigo', 'orange', 'violet'}"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rainbow.symmetric_difference(olympic_flag)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'blue', 'green', 'red', 'yellow'}"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rainbow.intersection(olympic_flag)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'black', 'blue', 'green', 'indigo', 'orange', 'red', 'violet', 'yellow'}"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rainbow.union(olympic_flag)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Canada': 'Ottawa',\n",
       " 'United States': 'Washington, D.C.',\n",
       " 'Mexico': 'Mexico City'}"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Dictionaries\n",
    "\n",
    "capitals = {'Canada': 'Ottawa',\n",
    "            'United States': 'Washington, D.C.',\n",
    "            'Mexico': 'Mexico City'}\n",
    "capitals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2020: 'Tokyo', 2016: 'Rio de Janiero', 2012: 'London'}"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "olympic_cities = {2020: 'Tokyo',\n",
    "                  2016: 'Rio de Janiero',\n",
    "                  2012: 'London'}\n",
    "olympic_cities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'summer': {2020: 'Tokyo', 2016: 'Rio de Janiero', 2012: 'London'},\n",
       " 'winter': {2022: 'Beijing', 2018: 'Pyeongchang'}}"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_oplympics_host = {'summer': olympic_cities,\n",
    "                      'winter': {2022: 'Beijing', 2018: 'Pyeongchang'}}\n",
    "all_oplympics_host"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "empty_dictionery = {}\n",
    "type(empty_dictionery)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "still_empty = dict()\n",
    "type(still_empty)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2020: 'Tokyo', 2016: 'Rio de Janiero', 2012: 'London'}"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "olympic_cities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'London'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "olympic_cities[2012]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'summer': {2020: 'Tokyo', 2016: 'Rio de Janiero', 2012: 'London'},\n",
       " 'winter': {2022: 'Beijing', 2018: 'Pyeongchang'}}"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_oplympics_host"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Beijing'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_oplympics_host['winter'][2022]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Tokyo'"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_oplympics_host['summer'][2020]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2020: 'Tokyo', 2016: 'Rio de Janiero', 2012: 'London'}"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "olympic_cities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "2014",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[53], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43molympic_cities\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m2014\u001b[39;49m\u001b[43m]\u001b[49m\n",
      "\u001b[0;31mKeyError\u001b[0m: 2014"
     ]
    }
   ],
   "source": [
    "olympic_cities[2014]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Toronto'"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "olympic_cities.get(2004, 'Toronto')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2016 in olympic_cities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2020: 'Tokyo', 2016: 'Rio de Janiero', 2012: 'London', 2008: 'Barcelona'}"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "olympic_cities[2008] = 'Barcelona'\n",
    "olympic_cities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2020: 'Tokyo', 2016: 'Rio de Janiero', 2012: 'London', 2008: 'Beijing'}"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "olympic_cities[2008] = 'Beijing'\n",
    "olympic_cities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'not valid season'"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_oplympics_host.get('spring', 'not valid season')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2020: 'Tokyo', 2016: 'Rio de Janiero', 2012: 'London', 2008: 'Beijing'}"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "olympic_cities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'summer': {2020: 'Tokyo',\n",
       "  2016: 'Rio de Janiero',\n",
       "  2012: 'London',\n",
       "  2008: 'Beijing'},\n",
       " 'winter': {2022: 'Beijing', 2018: 'Pyeongchang'}}"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_oplympics_host"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2016: 'Rio de Janiero', 2012: 'London', 2008: 'Beijing'}"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "olympic_cities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['summer', 'winter'])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_oplympics_host.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values(['Rio de Janiero', 'London', 'Beijing'])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "olympic_cities.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "London has a host city\n"
     ]
    }
   ],
   "source": [
    "if 'London' in olympic_cities.values():\n",
    "    print('London has a host city')\n",
    "else:\n",
    "    print('London was not a host city')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([(2016, 'Rio de Janiero'), (2012, 'London'), (2008, 'Beijing')])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "olympic_cities.items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "e\n",
      "i\n",
      "o\n",
      "u\n"
     ]
    }
   ],
   "source": [
    "#for loops\n",
    "\n",
    "vowels = ['a', 'e', 'i', 'o', 'u']\n",
    "for i in vowels:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0\n",
      "1 2\n",
      "2 4\n",
      "3 6\n",
      "4 8\n",
      "5 10\n",
      "6 12\n",
      "7 14\n",
      "8 16\n"
     ]
    }
   ],
   "source": [
    "for i in range(9):\n",
    "    print(i, i*2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['processed_data_01.xlsx']\n",
      "['processed_data_01.xlsx', 'processed_data_02.xlsx']\n",
      "['processed_data_01.xlsx', 'processed_data_02.xlsx', 'processed_data_03.xlsx']\n",
      "['processed_data_01.xlsx', 'processed_data_02.xlsx', 'processed_data_03.xlsx', 'processed_data_04.xlsx']\n"
     ]
    }
   ],
   "source": [
    "input_files = ['data_01.csv', 'data_02.csv', 'data_03.csv', 'data_04.csv']\n",
    "output_files = []\n",
    "\n",
    "for i in input_files:\n",
    "    output_file_name = 'processed_' + i.replace('.csv', '.xlsx')# processed_data_03.xlsx\n",
    "    output_files.append(output_file_name)\n",
    "    print(output_files)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['data_01.csv']\n",
      "['data_01.csv', 'data_02.csv']\n",
      "['data_01.csv', 'data_02.csv', 'data_03.csv']\n",
      "['data_01.csv', 'data_02.csv', 'data_03.csv', 'data_04.csv']\n"
     ]
    }
   ],
   "source": [
    "input_files = ['data_01.csv', 'data_02.csv', 'data_03.csv', 'data_04.csv']\n",
    "output_files = []\n",
    "\n",
    "for i in input_files:\n",
    "    output_files.append(i)\n",
    "    print(output_files)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple\n",
      "blueberries\n",
      "strawberries\n",
      "jackfruit\n"
     ]
    }
   ],
   "source": [
    "fruits = ['apple', 'blueberries', 'strawberries', 'jackfruit']\n",
    "\n",
    "for snack in fruits:\n",
    "    print(snack)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "veggies = {'potatoes', 'carrots', 'celery', 'tomatoes', 'potatoes'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'carrots', 'celery', 'potatoes', 'tomatoes'}"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "veggies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I love tomatoes\n",
      "I love potatoes\n",
      "I love carrots\n",
      "I love celery\n"
     ]
    }
   ],
   "source": [
    "for j in veggies:\n",
    "    print(f'I love {j}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stop 1 is Islington\n",
      "Stop 2 is Royal York\n",
      "Stop 3 is Keele\n",
      "Stop 4 is Jane\n",
      "Stop 5 is Union\n"
     ]
    }
   ],
   "source": [
    "ttc_stops = ['Islington', 'Royal York', 'Keele', 'Jane', 'Union']\n",
    "\n",
    "for idx, stop in enumerate(ttc_stops):\n",
    "    print(f'Stop {idx + 1} is {stop}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 20, 200, 2000]"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers = [1, 10, 100, 1000]\n",
    "\n",
    "for idx, val in enumerate(numbers):\n",
    "    numbers[idx]= val * 2 #idx = 2; val = 100\n",
    "numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "43.12 3.555\n",
      "24.5363 6.5\n",
      "596.789 8.7689\n"
     ]
    }
   ],
   "source": [
    "lats = [43.12, 24.5363, 596.7890]\n",
    "lons = [3.555, 6.5, 8.7689]\n",
    "\n",
    "for i, j in zip(lats, lons):\n",
    "    print(i,j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([(2016, 'Rio de Janiero'), (2012, 'London'), (2008, 'Beijing')])"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "olympic_cities.items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2016 Rio de Janiero\n",
      "2012 London\n",
      "2008 Beijing\n"
     ]
    }
   ],
   "source": [
    "for key, value in olympic_cities.items():\n",
    "    print(key, value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My birthday is on april 12!\n",
      "My birthday is on may 12!\n",
      "My birthday is on june 12!\n",
      "My birthday is on january 12!\n",
      "My birthday is on february 12!\n",
      "My birthday is on april 30!\n",
      "My birthday is on may 30!\n",
      "My birthday is on june 30!\n",
      "My birthday is on january 30!\n",
      "My birthday is on february 30!\n",
      "My birthday is on april 17!\n",
      "My birthday is on may 17!\n",
      "My birthday is on june 17!\n",
      "My birthday is on january 17!\n",
      "My birthday is on february 17!\n",
      "My birthday is on april 6!\n",
      "My birthday is on may 6!\n",
      "My birthday is on june 6!\n",
      "My birthday is on january 6!\n",
      "My birthday is on february 6!\n",
      "My birthday is on april 7!\n",
      "My birthday is on may 7!\n",
      "My birthday is on june 7!\n",
      "My birthday is on january 7!\n",
      "My birthday is on february 7!\n"
     ]
    }
   ],
   "source": [
    "days = [12, 30, 17, 6, 7]\n",
    "months = ['april', 'may', 'june', 'january', 'february']\n",
    "\n",
    "for i in days:\n",
    "    for j in months:\n",
    "        print(f\"My birthday is on {j} {i}!\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "dsi_participant",
   "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.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}