lists.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "005d129b",
   "metadata": {},
   "source": [
    "\n",
    "### Lists and Tuples\n",
    "---\n",
    "\n",
    "**Learning Objective**\n",
    "\n",
    "- Use lists and tuples to store, reference, and manipulate data\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "815e5af7",
   "metadata": {},
   "source": [
    "\n",
    "In Python, `lists` are defined using square brackets and can contain multiple elements separated by commas. For instance, a list of words can be defined as:\n",
    " \n",
    "            list1 = [\"This\", \"is\", \"a\", \"list\"]. \n",
    " \n",
    " The `len()` function can be used to determine the number of elements in a list, as in:\n",
    " \n",
    "            len(list1) = 4. \n",
    " \n",
    " \n",
    " Similarly, the `in` keyword can be used to check if an element is present in the list. If the element is found, it returns `True`, and `False` otherwise. For example:\n",
    " \n",
    "            \"This\" in list1 would return `True`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "470200ec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List: ['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']\n",
      "\n",
      "Length: 7\n",
      "\n"
     ]
    }
   ],
   "source": [
    "days = [\"monday\",\"tuesday\",\"wednesday\",\"thursday\",\"friday\",\"saturday\",\"sunday\"]\n",
    "\n",
    "print(\"List: {}\".format(days),end=\"\\n\\n\")\n",
    "\n",
    "print(\"Length: {}\".format(len(days)),end=\"\\n\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b21c1dd",
   "metadata": {},
   "source": [
    "### List Operations\n",
    "\n",
    "- The `append` method is used to add an element to the end of a list. This method is called using dot notation, and the element to be added is passed as a parameter.\n",
    "\n",
    "\n",
    "**For instance**, `list1.append(\"New data\")` adds \"New data\" to the end of the list called list1.\n",
    "\n",
    "\n",
    "- To add an element to a specific position in a list, we use the `insert` method. This method takes two parameters: the **index** at which the element is to be inserted and the **element** to be inserted. If the index specified is larger than the length of the list, the element will be added to the end of the list.\n",
    "\n",
    "\n",
    "**For example**, `list1.insert(0, \"New data\")` inserts \"New data\" at the front of the list, without overwriting the existing element.\n",
    "\n",
    "\n",
    "- The `remove` method removes elements from the list. This method takes an `element` as a parameter and removes the first occurrence of that element from the list. If the element isn't found in the list, a `ValueError` error is raised.\n",
    "\n",
    "\n",
    "- Alternatively, elements can also be removed from a list using the `pop` method. This method takes an `index` as a parameter and returns the element that was removed.\n",
    "\n",
    "\n",
    "- Finally, you can change the value of an element in a list by using `indexing` to access the specified index and overwrite the value stored there.\n",
    "\n",
    "\n",
    "**For example**, `list1[0] = \"Old data\"` would replace the first element in the list with \"Old data\".\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ceb5e887",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial list: ['Pizza', 'Pasta', 'Caesar Salad', 'Burger']\n",
      "\n",
      "List after appending: ['Pizza', 'Pasta', 'Caesar Salad', 'Burger', 'Tacos']\n",
      "\n",
      "Chicken Wings added: ['Chicken Wings', 'Pizza', 'Pasta', 'Caesar Salad', 'Burger', 'Tacos']\n",
      "\n",
      "Pasta has been removed: ['Chicken Wings', 'Pizza', 'Caesar Salad', 'Burger', 'Tacos']\n",
      "\n",
      "Caesar Salad removed: ['Chicken Wings', 'Pizza', 'Burger', 'Tacos']\n",
      "\n",
      "Our final menu: ['Chicken Wings', 'Pizza', 'Burger & Fries', 'Tacos']\n",
      "\n"
     ]
    }
   ],
   "source": [
    "food_menu = [\"Pizza\",\"Pasta\",\"Caesar Salad\",\"Burger\"]\n",
    "print(\"Initial list: {}\".format(food_menu),end=\"\\n\\n\")\n",
    "\n",
    "# Using `.append()` to add 'Tacos'\n",
    "food_menu.append(\"Tacos\")\n",
    "print(\"List after appending: {}\".format(food_menu),end=\"\\n\\n\")\n",
    "\n",
    "# Using `.insert()` to add 'Chicken Wings' at index 0\n",
    "food_menu.insert(0,\"Chicken Wings\")\n",
    "print(\"Chicken Wings added: {}\".format(food_menu),end=\"\\n\\n\")\n",
    "\n",
    "# Using `.remove()` to remove 'Pasta' \n",
    "food_menu.remove(\"Pasta\")\n",
    "print(\"Pasta has been removed: {}\".format(food_menu),end=\"\\n\\n\")\n",
    "\n",
    "# Using `.pop()` to remove 'Caesar Salad'\n",
    "food_menu.pop(-3)\n",
    "print(\"Caesar Salad removed: {}\".format(food_menu),end=\"\\n\\n\")\n",
    "\n",
    "# Using indexing to change 'Burger' to 'Burger & Fries' \n",
    "food_menu[-2] = \"Burger & Fries\"\n",
    "print(\"Our final menu: {}\".format(food_menu),end=\"\\n\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a399134f",
   "metadata": {},
   "source": [
    "### Tuples\n",
    "---\n",
    "\n",
    "In Python, tuples are similar to lists in that they can store multiple values in a single variable, but they have an important difference: **tuples are immutable**, meaning they cannot be changed once created. This makes tuples useful when we need to ensure that an element remains in a certain position and will not be changed by other parts of the program.\n",
    "\n",
    "One common use case for tuples is when a function returns multiple values. In this case, the values are often packed into a tuple, with each value being an element in the tuple. Since the order of the returned values is important, using a tuple ensures that the order will not change unexpectedly.\n",
    "\n",
    "To access the values in a tuple, we can use `indexing` just like with lists. However, Python also allows us to unpack the values of a tuple into separate variables. This can be useful when we want to use the individual values in different parts of our program. To do this, we simply assign the tuple to multiple variables, with one variable for each element in the tuple.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b6e0a75a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First Name: Aldous\n",
      "Middle Name: Marx\n",
      "Last Name: Fleischman\n",
      "\n",
      "Initials: AMF\n"
     ]
    }
   ],
   "source": [
    "name = (\"Aldous\",\"Marx\",\"Fleischman\")\n",
    "\n",
    "first_name, middle_name, last_name = name \n",
    "\n",
    "print(\"First Name: {}\\nMiddle Name: {}\\nLast Name: {}\".format(first_name,middle_name,last_name),end=\"\\n\\n\")\n",
    "\n",
    "print(\"Initials: {}{}{}\".format(first_name[0],middle_name[0],last_name[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92f4f084",
   "metadata": {},
   "source": [
    "### `Enumerate()` - List labeling service\n",
    "\n",
    "The `enumerate()` function is a built-in Python function that allows you to loop over an iterable (e.g., a list, tuple, or string) and get both the index and the value of each element. \n",
    "\n",
    "It returns a tuple for each element in the list. The first value in the tuple (`index 0`) is the index of the element in the list, while the second value is the element itself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c4d54b0f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 - Arsenal\n",
      "2 - Man City\n",
      "3 - Spurs\n",
      "4 - Newcastle\n",
      "5 - Man Utd\n"
     ]
    }
   ],
   "source": [
    "team_list = [\"Arsenal\",\"Man City\", \"Spurs\", \"Newcastle\",\"Man Utd\"]\n",
    "\n",
    "for pos, team in enumerate(team_list):\n",
    "    print(\"{} - {}\".format(pos+1,team))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "683d4d7b",
   "metadata": {},
   "source": [
    "### List Comprehension\n",
    "\n",
    "List comprehensions allows us to create new lists based on a sequence or range of values.\n",
    "\n",
    "**For example** - `[x**2 for x in range(1,11)]` is a simple list comprehension. This expression generates a new list by iterating over the range of integers from 1 to 10, raising each of them to an exponent of 2 and storing the result in the new list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "43314142",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Square of integers from 1 to 10: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n",
      "\n",
      "Cube of integers from 1 to 10: [1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "square_list = [x**2 for x in range(1,11)]\n",
    "\n",
    "print(\"Square of integers from 1 to 10: {}\".format(square_list),end=\"\\n\\n\")\n",
    "\n",
    "cube_list = [x**3 for x in range(1,11)]\n",
    "\n",
    "print(\"Cube of integers from 1 to 10: {}\".format(cube_list),end=\"\\n\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc6ed850",
   "metadata": {},
   "source": [
    "`Conditionals` can also be used to create more sophisticated and powerful list comprehensions. This is done by simply adding an `if statement` to the end of the comprehension.\n",
    "\n",
    "**For instance** - `[x for x in range(1,101) if x % 7 == 0]` produces a list containing all integers from 1 to 100 that are divisible by 7. In this case, the if statement evaluates each value in the range to determine if it is divisible by 7. If the result is `True`, then it adds the value to the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a0b6fea2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Multiples of 7 from 1 to 100: [7, 14, 21, 28, 35, 42, 49, 56, 63, 70, 77, 84, 91, 98]\n"
     ]
    }
   ],
   "source": [
    "# List Comprehension with Conditionals\n",
    "\n",
    "div_by_7 = [x for x in range(1,101) if x % 7 == 0]\n",
    "\n",
    "print(\"Multiples of 7 from 1 to 100: {}\".format(div_by_7))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c04b73f",
   "metadata": {},
   "source": [
    "### Program 15\n",
    "---\n",
    "\n",
    "You are given a list of filenames. Your task is to rename all the files with extension hpp to the extension h. You should generate a new list called newfilenames, which will consist of the new filenames.\n",
    "\n",
    "            filenames = [\"program.cpp\", \"data.hpp\", \"output.hpp\", \"file.hpp\"]\n",
    "            newfilenames = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "1065983f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Run 1\n",
      "Input list: ['program.c', 'stdio.hpp', 'sample.hpp', 'a.out', 'math.hpp', 'hpp.out']\n",
      "Output list: ['program.c', 'stdio.h', 'sample.h', 'a.out', 'math.h', 'hpp.out']\n"
     ]
    }
   ],
   "source": [
    "def change_filename(filenames):\n",
    "    \"\"\"\n",
    "    Changes the file extension from '.hpp' to '.h'\n",
    "    in the given list of filenames.\n",
    "    \n",
    "    Parameters:\n",
    "        filenames (list): A list of filenames.\n",
    "    \n",
    "    Returns:\n",
    "        list: A new list of filenames with \n",
    "        the extension changed from '.hpp' to '.h'.\n",
    "    \"\"\"\n",
    "    x = 0\n",
    "    to_check = '.hpp'\n",
    "    newfilenames = []\n",
    "    \n",
    "    for file in filenames:\n",
    "        \n",
    "        if to_check in file:\n",
    "            x = file.split(\".\")\n",
    "            y = x[0] + \".h\"\n",
    "            newfilenames.append(y)\n",
    "        \n",
    "        else:\n",
    "            newfilenames.append(file)\n",
    "    \n",
    "    return newfilenames\n",
    "\n",
    "\n",
    "filenames = [\"program.c\", \"stdio.hpp\", \"sample.hpp\", \"a.out\", \"math.hpp\", \"hpp.out\"]\n",
    "\n",
    "# Should be [\"program.c\", \"stdio.h\", \"sample.h\", \"a.out\", \"math.h\", \"hpp.out\"]\n",
    "print(\"Run 1\")\n",
    "print(\"Input list: {}\".format(filenames))\n",
    "print(\"Output list: {}\".format(change_filename(filenames)))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfceb1b5",
   "metadata": {},
   "source": [
    "### Program 16\n",
    "---\n",
    "\n",
    "Write a function called `pig_latin()` that takes a string as input and returns the pig latin version of the string. The function should perform the following steps:\n",
    "\n",
    "- Convert the string to a list of words using the split() method.\n",
    "- For each word in the list, move the first letter to the end of the word and append \"ay\" to the end.\n",
    "- Join the list of words back into a single string using the join() method, with a space between each word.\n",
    "- Return the resulting pig latin string.\n",
    "\n",
    "**For example**, the input string \"Let's create pig latin\" should produce the output string \"et'sLay reatecay igpay atinlay\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "688a16fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "def pig_latin(text):\n",
    "    \n",
    "    \"\"\" \n",
    "    A function that converts texts into pig latin by moving the\n",
    "    first character of each word to the end and appending 'ay' to it.\n",
    "\n",
    "    Parameters:\n",
    "        text(str): The text to be converted into pig latin.\n",
    "\n",
    "    Returns:\n",
    "        str: The converted text in pig latin.\n",
    "    \"\"\"\n",
    "    \n",
    "    words = text.split(\" \")\n",
    "    say = []\n",
    "    \n",
    "    for word in words:\n",
    "        \n",
    "        first_char = word[0]\n",
    "        word_to_add = word[1:]\n",
    "        new_word = word_to_add + first_char + \"ay\"\n",
    "        say.append(new_word)\n",
    "    \n",
    "    saying = \" \".join(say)\n",
    "    return saying\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "2c667998",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Run 1\n",
      "Input: hello how are you\n",
      "Output: ellohay owhay reaay ouyay\n",
      "\n",
      "\n",
      "Run 2\n",
      "Input: programming in python is fun\n",
      "Output: rogrammingpay niay ythonpay siay unfay\n"
     ]
    }
   ],
   "source": [
    "# Should be \"ellohay owhay reaay ouyay\"\n",
    "print(\"Run 1\")\n",
    "print(\"Input: {}\".format(\"hello how are you\"))\n",
    "print(\"Output: {}\".format(pig_latin(\"hello how are you\")),end=\"\\n\\n\\n\")\n",
    "\n",
    "# Should be \"rogrammingpay niay ythonpay siay unfay\"\n",
    "print(\"Run 2\")\n",
    "print(\"Input: {}\".format(\"programming in python is fun\"))\n",
    "print(\"Output: {}\".format(pig_latin(\"programming in python is fun\")))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "659ab289",
   "metadata": {},
   "source": [
    "### Program 17\n",
    "---\n",
    "\n",
    "Write a Python function `group_list` that accepts two parameters:\n",
    "\n",
    "    group_name: A string representing the name of the group.\n",
    "    members: A list containing the members of the group.\n",
    "\n",
    "The function should return a string in the format `\"group_name: member1, member2, ...\"` where each member is separated by a comma and a space.\n",
    "\n",
    "     For example, calling group_list(\"g\", [\"a\", \"b\", \"c\"]) should return the string \"g: a, b, c\".\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "780aed18",
   "metadata": {},
   "outputs": [],
   "source": [
    "def group_list(group, users):\n",
    "    \"\"\"\n",
    "    Returns a string with the format \"group_name: member1, member2, ...\"\n",
    "    \n",
    "    Parameters:\n",
    "        group (str): The name of the group\n",
    "        users (list): A list of members\n",
    "    \n",
    "    Returns:\n",
    "        str: A string with the format \"group_name: member1, member2, ...\"\n",
    "    \"\"\"\n",
    "    \n",
    "    members = users\n",
    "    member_list = []\n",
    "    x = len(members)\n",
    "    group_stat = group + \": \"\n",
    "    \n",
    "    for y in range(x):\n",
    "        j = members[y]\n",
    "        member_list.append(j)\n",
    "    \n",
    "    out_str = \", \".join(member_list)\n",
    "    final_list = group_stat + out_str\n",
    "    return final_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "77f7a8fc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Run 1\n",
      "Output: Marketing: Mike, Karen, Jake, Tasha\n",
      "\n",
      "Run 2\n",
      "Engineering: Kim, Jay, Tom\n",
      "\n",
      "Run 3\n",
      "Users: \n"
     ]
    }
   ],
   "source": [
    "# Should be \"Marketing: Mike, Karen, Jake, Tasha\"\n",
    "print(\"Run 1\")\n",
    "print(\"Output: {}\".format(group_list(\"Marketing\", [\"Mike\", \"Karen\", \"Jake\", \"Tasha\"])),end=\"\\n\\n\")\n",
    "\n",
    "# Should be \"Engineering: Kim, Jay, Tom\"\n",
    "print(\"Run 2\")\n",
    "print(group_list(\"Engineering\", [\"Kim\", \"Jay\", \"Tom\"]),end=\"\\n\\n\")\n",
    "\n",
    "# Should be \"Users:\"\n",
    "print(\"Run 3\")\n",
    "print(group_list(\"Users\", \"\")) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03cf47c7",
   "metadata": {},
   "source": [
    "### Program 18\n",
    "---\n",
    "\n",
    "Write a function that reads in a list of tuples representing party guests, where each tuple contains the guest's name, age, and profession. The function should then print out a sentence for each guest in the format `\"Guest is X years old and works as __.\"` with the appropriate values inserted for name, age, and profession.\n",
    "\n",
    "For example, if the input list is `[('Ken', 30, \"Chef\"), (\"Pat\", 35, 'Lawyer'), ('Amanda', 25, \"Engineer\")]`, the function should output:\n",
    "\n",
    "    Ken is 30 years old and works as Chef.\n",
    "    Pat is 35 years old and works as Lawyer.\n",
    "    Amanda is 25 years old and works as Engineer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c6343517",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ken is 30 years old and works as Chef\n",
      "Pat is 35 years old and works as Lawyer\n",
      "Amanda is 25 years old and works as Engineer\n"
     ]
    }
   ],
   "source": [
    "def guest_list(guests):\n",
    "    \n",
    "    \"\"\" \n",
    "    Parameters:\n",
    "        guests: a list of tuples where each tuple contains the name,\n",
    "        age, and profession of a guest.\n",
    "\n",
    "    Returns:\n",
    "        None\n",
    "    \"\"\"\n",
    "    \n",
    "    for i in range(len(guests)):\n",
    "        \n",
    "        name, age, profession = guests[i]\n",
    "        print(\"{} is {} years old and works as {}\".format(name,age,profession))\n",
    "    \n",
    "    return None \n",
    "\n",
    "\n",
    "#Output should match:\n",
    "\n",
    "#Ken is 30 years old and works as Chef\n",
    "#Pat is 35 years old and works as Lawyer\n",
    "#Amanda is 25 years old and works as Engineer\n",
    "\n",
    "guest_list([('Ken', 30, \"Chef\"), (\"Pat\", 35, 'Lawyer'), ('Amanda', 25, \"Engineer\")])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8255eac8",
   "metadata": {},
   "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}