advanced-python/01-Lists.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lists\n",
    "\n",
    "List is a collection data type which is ordered and mutable. Unlike Sets, Lists allow duplicate elements.\n",
    "They are useful for preserving a sequence of data and further iterating over it. Lists are created with square brackets.\n",
    "\n",
    "`my_list = [\"banana\", \"cherry\", \"apple\"]`\n",
    "\n",
    "#### Comparison of basic built-in collection data types in Python:\n",
    "\n",
    "- List is a collection which is ordered and mutable. Allows duplicate members.\n",
    "- Tuple is a collection which is ordered and immutable. Allows duplicate members.\n",
    "- Set is a collection which is unordered and unindexed. No duplicate members.\n",
    "- Dictionary is a collection which is unordered, mutable and indexed. No duplicate members.\n",
    "- Strings are immutable sequences of Unicode code points."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Creating a list\n",
    "Lists are created with square brackets or the built-in list function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['banana', 'cherry', 'apple']\n",
      "[]\n",
      "[5, True, 'apple']\n",
      "[0, 0, 1, 1]\n"
     ]
    }
   ],
   "source": [
    "list_1 = [\"banana\", \"cherry\", \"apple\"]\n",
    "print(list_1)\n",
    "\n",
    "# Or create an empty list with the list function\n",
    "list_2 = list()\n",
    "print(list_2)\n",
    "\n",
    "# Lists allow different data types\n",
    "list_3 = [5, True, \"apple\"]\n",
    "print(list_3)\n",
    "\n",
    "# Lists allow duplicates\n",
    "list_4 = [0, 0, 1, 1]\n",
    "print(list_4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Access elements\n",
    "You access the list items by referring to the index number. Note that the indices start at 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "banana\n",
      "apple\n"
     ]
    }
   ],
   "source": [
    "item = list_1[0]\n",
    "print(item)\n",
    "\n",
    "# You can also use negative indexing, e.g -1 refers to the last item,\n",
    "# -2 to the second last item, and so on\n",
    "item = list_1[-1]\n",
    "print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Change items\n",
    "Just refer to the index number and assign a new value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['banana', 'cherry', 'lemon']\n"
     ]
    }
   ],
   "source": [
    "# Lists can be altered after their creation\n",
    "list_1[2] = \"lemon\"\n",
    "print(list_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Useful methods\n",
    "Have a look at the Python Documentation to see all list methods: \n",
    "https://docs.python.org/3/tutorial/datastructures.html "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length: 3\n",
      "['banana', 'blueberry', 'cherry', 'apple', 'orange']\n",
      "Popped item:  orange\n",
      "['banana', 'blueberry', 'apple']\n",
      "[]\n",
      "Reversed:  ['apple', 'cherry', 'banana']\n",
      "Sorted:  ['apple', 'banana', 'cherry']\n",
      "[0, 0, 0, 0, 0]\n",
      "[0, 0, 0, 0, 0, 'banana', 'cherry', 'apple']\n",
      "['H', 'e', 'l', 'l', 'o']\n"
     ]
    }
   ],
   "source": [
    "my_list = [\"banana\", \"cherry\", \"apple\"]\n",
    "\n",
    "# len() : get the number of elements in a list\n",
    "print(\"Length:\", len(my_list))\n",
    "\n",
    "# append() : adds an element to the end of the list\n",
    "my_list.append(\"orange\")\n",
    "\n",
    "# insert() : adds an element at the specified position\n",
    "my_list.insert(1, \"blueberry\")\n",
    "print(my_list)\n",
    "\n",
    "# pop() : removes and returns the item at the given position, default is the last item\n",
    "item = my_list.pop()\n",
    "print(\"Popped item: \", item)\n",
    "\n",
    "# remove() : removes an item from the list\n",
    "my_list.remove(\"cherry\") # Value error if not in the list\n",
    "print(my_list)\n",
    "\n",
    "# clear() : removes all items from the list\n",
    "my_list.clear()\n",
    "print(my_list)\n",
    "\n",
    "# reverse() : reverse the items\n",
    "my_list = [\"banana\", \"cherry\", \"apple\"]\n",
    "my_list.reverse()\n",
    "print('Reversed: ', my_list)\n",
    "\n",
    "# sort() : sort items in ascending order\n",
    "my_list.sort()\n",
    "print('Sorted: ', my_list)\n",
    "\n",
    "# use sorted() to get a new list, and leave the original unaffected.\n",
    "# sorted() works on any iterable type, not just lists\n",
    "my_list = [\"banana\", \"cherry\", \"apple\"]\n",
    "new_list = sorted(my_list)\n",
    "\n",
    "# create list with repeated elements\n",
    "list_with_zeros = [0] * 5\n",
    "print(list_with_zeros)\n",
    "\n",
    "# concatenation\n",
    "list_concat = list_with_zeros + my_list\n",
    "print(list_concat)\n",
    "\n",
    "# convert string to list\n",
    "string_to_list = list('Hello')\n",
    "print(string_to_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Copy a list\n",
    "Be careful when copying references."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['banana', 'cherry', 'apple', True]\n",
      "['banana', 'cherry', 'apple', True]\n",
      "['banana', 'cherry', 'apple', True]\n",
      "['banana', 'cherry', 'apple']\n"
     ]
    }
   ],
   "source": [
    "list_org = [\"banana\", \"cherry\", \"apple\"]\n",
    "\n",
    "# this just copies the reference to the list, so be careful\n",
    "list_copy = list_org\n",
    "\n",
    "# now modifying the copy also affects the original\n",
    "list_copy.append(True)\n",
    "print(list_copy)\n",
    "print(list_org)\n",
    "\n",
    "# use copy(), or list(x) to actually copy the list\n",
    "# slicing also works: list_copy = list_org[:]\n",
    "list_org = [\"banana\", \"cherry\", \"apple\"]\n",
    "\n",
    "list_copy = list_org.copy()\n",
    "# list_copy = list(list_org)\n",
    "# list_copy = list_org[:]\n",
    "\n",
    "# now modifying the copy does not affect the original\n",
    "list_copy.append(True)\n",
    "print(list_copy)\n",
    "print(list_org)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Iterating"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "banana\n",
      "cherry\n",
      "lemon\n"
     ]
    }
   ],
   "source": [
    "# Iterating over a list by using a for in loop\n",
    "for i in list_1:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Check if an item exists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "yes\n"
     ]
    }
   ],
   "source": [
    "if \"banana\" in list_1:\n",
    "    print(\"yes\")\n",
    "else:\n",
    "    print(\"no\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Slicing\n",
    "Access sub parts of the list wih the use of colon (:), just as with strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3]\n",
      "[3, 4, 5, 6, 7, 8, 9, 10]\n",
      "[1, 2, 3]\n",
      "[0, 4, 5, 6, 7, 8, 9, 10]\n",
      "[0, 5, 7, 9]\n",
      "[10, 9, 8, 7, 6, 5, 4, 0]\n",
      "[10, 9, 8, 7, 6, 5, 4, 0]\n"
     ]
    }
   ],
   "source": [
    "# a[start:stop:step], default step is 1\n",
    "a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "b = a[1:3] # Note that the last index is not included\n",
    "print(b)\n",
    "b = a[2:] # until the end\n",
    "print(b)\n",
    "b = a[:3] # from beginning\n",
    "print(b)\n",
    "a[0:3] = [0] # replace sub-parts, you need an iterable here\n",
    "print(a)\n",
    "b = a[::2] # start to end with every second item\n",
    "print(b)\n",
    "a = a[::-1] # reverse the list with a negative step:\n",
    "print(a)\n",
    "b = a[:] # copy a list with slicing\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List comprehension\n",
    "A elegant and fast way to create a new list from an existing list.\n",
    "\n",
    "List comprehension consists of an expression followed by a for statement inside square brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25, 36, 49, 64]\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3, 4, 5, 6, 7, 8]\n",
    "b = [i * i for i in a] # squares each element\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Nested lists\n",
    "Lists can contain other lists (or other container types)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2], [3, 4]]\n",
      "[1, 2]\n"
     ]
    }
   ],
   "source": [
    "a = [[1, 2], [3, 4]]\n",
    "print(a)\n",
    "print(a[0])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:pythonengineer_env]",
   "language": "python",
   "name": "conda-env-pythonengineer_env-py"
  },
  "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}