5 Lists.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Lists\n",
    "\n",
    "\n",
    "The variables that were discussed in the previous tutorials were all assigned single values, such as strings, integers or floating point numbers. Alternatively, it is also possible to work with variables that contain collections of values. \n",
    "\n",
    "One example of a variable type that can hold multiple values is the list. Lists can be created by surrounding all the values that you want to gather by square brackets. The individual values within such lists need to be separated by commas. The statement below creates a list containing the five days of the working week:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "week = [ \"Monday\" , \"Tuesday\" , \"Wednesday\" , \"Thursday\" , \"Friday\" ]  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The elements in the list above are all strings. The elements do not all have to be of the same type, however. It is also allowed to mix strings with integers, for instance. \n",
    "\n",
    "## Accessing individual items\n",
    "\n",
    "When lists are created in this manner, the items in this list are given a certain order. Python numbers the elements in the array automatically, following the order in which these values given. These numbers will function as indices that can be used to access the individual items in the array. Bear in mind that Python starts counting at 0. In the example above, the element “Monday” is assigned the index “0”, and the element “Thursday” will have the index “3”. As is the case for strings and their individual characters, the separate elements in the list can be accessed using the bracket operator. \n",
    "\n",
    "Another similarity between lists and strings is that the lengths of both types of variables can be found using the `len()` function. In the case of lists, `len()` returns the number of elements in the list. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "week = [ \"Monday\" , \"Tuesday\" , \"Wednesday\" , \"Thursday\" , \"Friday\" ]\n",
    "\n",
    "print( week[3] )\n",
    "# This prints \"Thursday\"\n",
    "\n",
    "print( week[-1] )\n",
    "# This prints \"Friday\"\n",
    "\n",
    "print( len(week) )\n",
    "# This prints 5\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List slicing\n",
    "\n",
    "Like strings, lists can also be sliced. To do this, you need to type in a set of square brackets directly following the name of the list. Within these brackets, you need to give a pair of indices, specifying the first and the last item you want to retrieve. These two numbers need to be separated by a colon. The item identified via the index that follows the column is not included in the selection. If you state that the selection should stop at index 3, for instance, the last item in the selection will be the item with index 2. \n",
    "\n",
    "If you leave out the first number, Python will simply start at the beginning of the list. If you omit the second number, the selection will continue until the very last item in the list.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "week_part = week[1:3]\n",
    "## Selects Tuesday' and 'Wednesday'\n",
    "print(week_part)\n",
    "\n",
    "week_part = week[:2]\n",
    "## Selects 'Monday' and 'Tuesday'\n",
    "print(week_part)\n",
    "\n",
    "week_part = week[3:]\n",
    "## Selects 'Thursday'and 'Friday'\n",
    "print(week_part)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding items to a list\n",
    "\n",
    "The `append()` method can be used to add items to an existing list. Note that methods, in contrast to functions, need to be pasted onto variables using the period. See the code below for an illustration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "week.append(\"Saturday\")\n",
    "week.append(\"Sunday\")\n",
    "\n",
    "print( f\"The list now contains {len(week)} items.\" )\n",
    "# This prints the following sentence:\n",
    "# 'The list now contains 7 items.'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sorting\n",
    "\n",
    "Finally, the items in a list can be arranged alphabetically or numerically by making use of the `sorted()` function. \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "unsorted_list = [ 5 , 8 , 2 , 9 , 1 , 8 ]\n",
    "print( sorted( unsorted_list ) )\n",
    "\n",
    "## The output is as follows:\n",
    "## [1, 2, 5, 8, 8, 9]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Navigating a list\n",
    "\n",
    "To move through all the elements in a list, you can use the `for` keyword. As can be seen in the code below, `for` needs to be used in combination with `in`. After `in`, you need to mention the name of the list whose elements you want to retrieve. After `for`, you need to supply the name of a new variable. \n",
    "\n",
    "In the example below, this new variable is named ‘day’. During each cycle, the value of the variable ‘day’ will be different; it will\n",
    "consecutively be assigned the various elements in the list named ‘week’. The loop will continue as long as there are items in the list. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for day in week:\n",
    "    print( day )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Presence in a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to know whether a list contains a given item, you can work with the `in` operator. This operator takes two parameters. To the left of `in`, you mention the item you want to search for. The second parameter must mention the list in which you want to search. Using `in`, you can create a Boolean expression, an expression which can be either true of false.     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if 'Monday' in week:\n",
    "    print('This item is indeed in the list!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Counting items\n",
    "\n",
    "You can count the number of times an item occurs in a list by making use of the `count` method. This method needs to be appended after the name of the list, using a dot. As a parameter to this method, you provide the item that you want to count. The code below gives an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "animals = [ 'cat' , 'dog' , 'rabbit' , 'elephant' , 'cat' , 'cat' , 'giraffe']\n",
    "\n",
    "print( f\"The word 'cat' occurs {animals.count('cat')} times in this list.\" )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 5.1.\n",
    "\n",
    "Create the following list:\n",
    "\n",
    "``\n",
    "colours = ['green','blue','red']\n",
    "``\n",
    "\n",
    "Add the colours 'orange', 'yellow' to this list. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 5.2.\n",
    "\n",
    "Create two lists:\n",
    "\n",
    "`\n",
    "first = [4, 9, 1, 17, 11, 26, 28, 54, 63] \n",
    "second = [8, 9, 74, 21, 45, 11, 63, 28, 26] \n",
    "`\n",
    "\n",
    "Write code which can extract those numbers from the first list which are NOT in the second list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "first = [4, 9, 1, 17, 11, 26, 28, 54, 63] \n",
    "second = [8, 9, 74, 21, 45, 11, 63, 28, 26]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 5.3.\n",
    "\n",
    "The list below contains the titles of first twelve plays written by William Shakespeare.\n",
    "\n",
    "```\n",
    "plays = [ 'Comedy of Errors' ,\n",
    "'Henry VI, Part I' ,\n",
    "'Henry VI, Part II' ,\n",
    "'Henry VI, Part III' ,\n",
    "'Richard III' ,\n",
    "'Taming of the Shrew' ,\n",
    "'Titus Andronicus' ,\n",
    "'Romeo and Juliet' ,\n",
    "'Two Gentlemen of Verona' ,\n",
    "'Love\\'s Labour\\'s Lost' ,\n",
    "'Richard II' ,\n",
    "'Midsummer Night\\'s Dream' ]\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add the following two titles to this list:\n",
    " \n",
    "* Macbeth\n",
    "* Othello\n",
    "\n",
    "Next, count the number of plays in this list and print the titles of the first and the last plays in the list, using the index of these items. \n",
    "Print the full list in alphabetical order using the ‘for’ keyword.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 5.4.\n",
    "\n",
    "Copy the code below.\n",
    "\n",
    "``\n",
    "sites = [ 'https://www.universiteitleiden.nl' , 'https://www.stanford.edu' , 'https://www.uu.nl' , 'http://www.ox.ac.uk' , 'https://www.rug.nl' , 'https://www.hu-berlin.de' , 'https://www.uva.nl' ]\n",
    "``\n",
    "\n",
    "Write some additional code which can select the Dutch websites from this list.\n",
    "Tip: You may want to reuse some of the code developed for  exercise 3.4.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sites = [ 'https://www.universiteitleiden.nl' , 'https://www.stanford.edu' , 'https://www.uu.nl' , 'http://www.ox.ac.uk' , 'https://www.rug.nl' , 'https://www.hu-berlin.de' , 'https://www.uva.nl' ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 5.5\n",
    "\n",
    "Define a Python list named `years`, containing the following values:\n",
    "\n",
    "`\n",
    "years = [ 1756, 1575, 2002, 1984 ,1626 ,1791, 1714, 1873, 1991 ]\n",
    "`\n",
    "\n",
    "Use the keywords `for` and `if` to select years that are in the 18th century. \n",
    "Note that, after `if`, you can combine multiple Boolean expressions using `and`.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "years = [ 1756, 1575, 2002, 1984 ,1626 ,1791, 1714, 1873, 1991 ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 5.6.\n",
    "\n",
    "Convert the following quotation from E.M. Forster’s *A Room with a View* to a list of words, using the `split()` method. This function can convert a string into a list, based on the spaces that occur in this string. This `split()` method must be added after the the string variable, using a dot, as follows:\n",
    "\n",
    "``\n",
    "quote.split()\n",
    "``\n",
    "\n",
    "Use this `split()` function to give information about the total number of words in this quote. Print the last word in the quote, and count the number of occurrences of the word “place”.\n",
    "\n",
    "```quote = \"We cast a shadow on something wherever we stand, and it is no good moving from place to place to save things; because the shadow always follows. Choose a place where you won’t do harm - yes, choose a place where you won’t do very much harm, and stand in it for all you are worth, facing the sunshine.\"\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "quote = '''We cast a shadow on something wherever we stand, and it is no good \n",
    "moving from place to place to save things; because the shadow always follows. Choose \n",
    "a place where you won’t do harm - yes, choose a place where you won’t do very much \n",
    "harm, and stand in it for all you are worth, facing the sunshine.'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}