P01.4_List_Tuple.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Computer Programming with Python\n",
    "\n",
    "#### Instructor : Dr. Aydin Demir\n",
    "\n",
    "www.aydindemir.com | GitHub & Instagram: @craxLab | Web: www.craxLab.com\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### _The topics of the week !_\n",
    "\n",
    "### Python Data Types\n",
    "- Python Collections:\n",
    "    - Lists     ----->  Ordered and changeable collection which allows duplicate members.\n",
    "    - Tuples    ----->  Ordered and unchangeble collection which allows duplicate members."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# 2) LIST\n",
    "\n",
    "Python offers a sequence of datatypes in order to group values. Lists are one of the most versatile and frequently used items. \n",
    "\n",
    "They created by comma-separated values (elements) between square brackets [ ] in any number and any different type such as integer, float, string etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_To create a list:_** list of integers "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "liste = [1,2,3,4,5,6]\n",
    "print(liste)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'd']\n"
     ]
    }
   ],
   "source": [
    "liste2 = list([\"a\", \"b\",\"c\",\"d\"])\n",
    "print(liste2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_list of different datatypes_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste3 = [3.14, \"pi\", 5, -15.5, \"Sakarya\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_nested list_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3.14, 'pi', 5, -15.5, 'Sakarya', [5, 6, 8]]\n"
     ]
    }
   ],
   "source": [
    "liste4 = [3.14, \"pi\", 5, -15.5, \"Sakarya\", [5,6,8]]\n",
    "print(liste4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_create an empty list_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "listebos=[]\n",
    "print(listebos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**To create a list from string**\n",
    "\n",
    "*list('string')*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['S', 'a', 'k', 'a', 'r', 'y', 'a']\n"
     ]
    }
   ],
   "source": [
    "sehir = \"Sakarya\"\n",
    "sehirliste = list(sehir)\n",
    "print(sehirliste)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Spliting string and creating a list**\n",
    "\n",
    "*.split()* : It makes items of string a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "summer is coming\n"
     ]
    }
   ],
   "source": [
    "str1 = \"summer is coming\"\n",
    "print(str1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['s', 'u', 'm', 'm', 'e', 'r', ' ', 'i', 's', ' ', 'c', 'o', 'm', 'i', 'n', 'g']\n"
     ]
    }
   ],
   "source": [
    "str2 = list(str1)\n",
    "print(str2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['summer', 'is', 'coming']\n"
     ]
    }
   ],
   "source": [
    "str3 =  str1.split()\n",
    "print(str3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Length of a list\n",
    "\n",
    "len()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "liste =  [\"week\", [1,2,5,8], [\"pazartesi\",\"salı\",5]]\n",
    "print(len(liste))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Length of a list in a nested list "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "print(len(liste[1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Access items of a list\n",
    "\n",
    "## 1) Index Operator\n",
    "\n",
    "* An index operator **[ ]** can be used to access the elements of a list. \n",
    "\n",
    "* Index starts with **0** and must be an <font color=red>integer</font>.\n",
    "\n",
    "* If you access the index number out of the range it will cause <font color=red>IndexError</font>; \n",
    "\n",
    "* if you use float or other types, it will cause <font color=red>TypeError</font> will occur.\n",
    "\n",
    "**Example:**\n",
    "\n",
    "<img src=\"./Figures/Examples/IPN_Profil.png\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_To create profile list:_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['IPN120', 'IPN140', 'IPN160', 'IPN180', 'IPN200', 'IPN220', 'IPN240']\n"
     ]
    }
   ],
   "source": [
    "profil = [\"IPN120\", \"IPN140\",\"IPN160\",\"IPN180\",\"IPN200\",\"IPN220\",\"IPN240\"]\n",
    "print(profil)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_access first item:_** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "IPN120\n"
     ]
    }
   ],
   "source": [
    "print(profil[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_access 5th item_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "IPN200\n"
     ]
    }
   ],
   "source": [
    "print(profil[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_access reversed 5th item_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "IPN160\n"
     ]
    }
   ],
   "source": [
    "print(profil[-5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_TypeError:_** only integer can be used"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "IPN200\n"
     ]
    }
   ],
   "source": [
    "print(profil[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_IndexError:_** index number out of the range "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_20440\\307598818.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mprofil\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m15\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "print(profil[15])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nested List\n",
    "\n",
    "**_To create a nested list_**  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Sakarya', 5.3, -100, [-2, 3, -6, 5]]\n"
     ]
    }
   ],
   "source": [
    "listem = [\"Sakarya\", 5.3, -100, [-2,3,-6,5]]\n",
    "print(listem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_To access the 4th item of first index of the nested list_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "print(listem[3][3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To access the 3rd item of first index of the nested list "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-6\n"
     ]
    }
   ],
   "source": [
    "print(listem[3][2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2) Slice Operator\n",
    "\n",
    "We can also access the elements of a list by slicing operator.\n",
    "\n",
    "Syntax: _[Start_index : Finish_index +1 : Increment]_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['IPN120', 'IPN140', 'IPN160', 'IPN180', 'IPN200', 'IPN220', 'IPN240']\n"
     ]
    }
   ],
   "source": [
    "profil = [\"IPN120\", \"IPN140\",\"IPN160\",\"IPN180\",\"IPN200\",\"IPN220\",\"IPN240\"]\n",
    "print(profil)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_elements beginning to end_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['IPN120', 'IPN140', 'IPN160', 'IPN180', 'IPN200', 'IPN220', 'IPN240']\n"
     ]
    }
   ],
   "source": [
    "print(profil[:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_elements 5th to end_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['IPN220', 'IPN240']\n"
     ]
    }
   ],
   "source": [
    "print(profil[5:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_elements beginning to 4th_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['IPN120', 'IPN140', 'IPN160', 'IPN180']\n"
     ]
    }
   ],
   "source": [
    "print(profil[:4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_elements 3rd to 5th_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['IPN180', 'IPN200', 'IPN220']\n"
     ]
    }
   ],
   "source": [
    "print(profil[3:6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_elements by increment_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['IPN120', 'IPN160', 'IPN200', 'IPN240']\n"
     ]
    }
   ],
   "source": [
    "print(profil[::2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_elements by increment_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['IPN140', 'IPN200']\n"
     ]
    }
   ],
   "source": [
    "print(profil[1::3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_reverse sorting_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['IPN240', 'IPN220', 'IPN200', 'IPN180', 'IPN160', 'IPN140', 'IPN120']\n"
     ]
    }
   ],
   "source": [
    "print(profil[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding new items into a list\n",
    "\n",
    "As differs from strings, the elements of lists can be changed which means they are mutable.\n",
    "\n",
    "ListName.append() ; takes exactly one argument\n",
    "\n",
    "ListName.extend() ; takes multiple argument\n",
    "\n",
    "ListName.insert() ; takes exactly one argument\n",
    "\n",
    "<img src=\"./Figures/Examples/IPN_Profil.png\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['IPN120', 'IPN140', 'IPN160', 'IPN180', 'IPN200', 'IPN220', 'IPN240']\n"
     ]
    }
   ],
   "source": [
    "profil = [\"IPN120\", \"IPN140\",\"IPN160\",\"IPN180\",\"IPN200\",\"IPN220\",\"IPN240\"]\n",
    "print(profil)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_Add new item to the end of the list_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['IPN120', 'IPN140', 'IPN160', 'IPN180', 'IPN200', 'IPN220', 'IPN240', 'IPN260']\n"
     ]
    }
   ],
   "source": [
    "profil.append(\"IPN260\")\n",
    "print(profil)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_adds new multiple items to the end of the list_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['IPN120', 'IPN140', 'IPN160', 'IPN180', 'IPN200', 'IPN220', 'IPN240', 'IPN260', 'IPN280', 'IPN300']\n"
     ]
    }
   ],
   "source": [
    "profil.extend([\"IPN280\",\"IPN300\"])\n",
    "print(profil)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_adds new item to a given index of the list_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['IPN120', 'IPN140', 'IPN160', 'IPN170', 'IPN180', 'IPN200', 'IPN220', 'IPN240', 'IPN260', 'IPN280', 'IPN300']\n"
     ]
    }
   ],
   "source": [
    "profil.insert(3,\"IPN170\")\n",
    "print(profil)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_adds new multiple items to a given index of the list_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['IPN120', 'IPN140', 'IPN160', 'IPN170', 'IPN180', 'IPN181', 'IPN182', 'IPN183', 'IPN200', 'IPN220', 'IPN240', 'IPN260', 'IPN280', 'IPN300']\n"
     ]
    }
   ],
   "source": [
    "profil[5:4] = [\"IPN181\",\"IPN182\",\"IPN183\"]\n",
    "print(profil)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Finding index number and number of an item in a list\n",
    "\n",
    "listName.index() | listName.count()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_Finding index number of an item in a list_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "print(profil.index(\"IPN200\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_Counting an item in a list_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(profil.count(\"IPN220\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_An item is not in the list_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "print(profil.count(\"IPN520\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modification of items of a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['IPN120', 'IPN140', 'IPN160', 'IPN180', 'IPN200', 'IPN220', 'IPN240']\n"
     ]
    }
   ],
   "source": [
    "profil = [\"IPN120\", \"IPN140\",\"IPN160\",\"IPN180\",\"IPN200\",\"IPN220\",\"IPN240\"]\n",
    "print(profil)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***change the 1st item***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['HEA120', 'IPN140', 'IPN160', 'IPN180', 'IPN200', 'IPN220', 'IPN240']\n"
     ]
    }
   ],
   "source": [
    "profil[0] = \"HEA120\"\n",
    "print(profil)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***change 3rd to 4th items***         "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['HEA120', 'IPN140', 'HEA160', 'HEA180', 'IPN200', 'IPN220', 'IPN240']\n"
     ]
    }
   ],
   "source": [
    "profil[2:4] = [\"HEA160\", \"HEA180\"]\n",
    "print(profil)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Delete items of a list\n",
    "\n",
    "### 1) By using index numbers\n",
    "\n",
    "del listName"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['IPN120', 'IPN140', 'IPN160', 'IPN180', 'IPN200', 'IPN220', 'IPN240']\n"
     ]
    }
   ],
   "source": [
    "profil = [\"IPN120\", \"IPN140\",\"IPN160\",\"IPN180\",\"IPN200\",\"IPN220\",\"IPN240\"]\n",
    "print(profil)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_delete one specific item_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['IPN120', 'IPN160', 'IPN180', 'IPN200', 'IPN220', 'IPN240']\n"
     ]
    }
   ],
   "source": [
    "del profil[1]\n",
    "print(profil)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***delete multiple items from the list***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['IPN120', 'IPN160', 'IPN180', 'IPN240']\n"
     ]
    }
   ],
   "source": [
    "del profil[3:5]\n",
    "print(profil)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***delete entire list***    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'profil' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_20440\\3838556300.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mdel\u001b[0m \u001b[0mprofil\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mprofil\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'profil' is not defined"
     ]
    }
   ],
   "source": [
    "del profil\n",
    "print(profil)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2) By using items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['IPN120', 'IPN140', 'IPN160', 'IPN180', 'IPN200', 'IPN220', 'IPN240']\n"
     ]
    }
   ],
   "source": [
    "profil = [\"IPN120\", \"IPN140\",\"IPN160\",\"IPN180\",\"IPN200\",\"IPN220\",\"IPN240\"]\n",
    "print(profil)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***remove the given item*** \n",
    "\n",
    "listName.remove()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['IPN120', 'IPN140', 'IPN180', 'IPN200', 'IPN220', 'IPN240']\n"
     ]
    }
   ],
   "source": [
    "profil.remove(\"IPN160\")\n",
    "print(profil)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***remove items in a given range***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['IPN120', 'IPN140', 'IPN220', 'IPN240']\n"
     ]
    }
   ],
   "source": [
    "profil[2:4] = []\n",
    "print(profil)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***empty list***\n",
    "\n",
    "listName.clear()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "profil.clear()\n",
    "print(profil)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Delete last item of a list\n",
    "\n",
    "**listName.pop()** : provides first in, last out data structure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['IPN120', 'IPN140', 'IPN160', 'IPN180', 'IPN200', 'IPN220', 'IPN240']\n"
     ]
    }
   ],
   "source": [
    "profil = [\"IPN120\", \"IPN140\",\"IPN160\",\"IPN180\",\"IPN200\",\"IPN220\",\"IPN240\"]\n",
    "print(profil)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***if index is not specified in pop(), it removes and returns the last item***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['IPN120', 'IPN140', 'IPN160', 'IPN180', 'IPN200', 'IPN220']\n"
     ]
    }
   ],
   "source": [
    "profil.pop()\n",
    "print(profil)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***remove an item at the given index***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['IPN120', 'IPN140', 'IPN160', 'IPN200', 'IPN220']\n"
     ]
    }
   ],
   "source": [
    "profil.pop(3)\n",
    "print(profil)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sorting elements of a list\n",
    "\n",
    "listName.sort(): sorts in ascending order ; 1,2,3,... or a,b,c,...\n",
    "\n",
    "listName.reverse(): sorts in descending order ; ...,3,2,1 or z,y,x,..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1) Sorting in numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "sayi = [5, 2, 3,-5,19] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Sorting elements of a list***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-5, 2, 3, 5, 19]\n"
     ]
    }
   ],
   "source": [
    "sayi.sort()\n",
    "print(sayi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Reverse sorting  elements of a list***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[19, 5, 3, 2, -5]\n"
     ]
    }
   ],
   "source": [
    "sayi.reverse()\n",
    "print(sayi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2) Sorting in string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "profil = [\"IPN300\", \"IPN200\", \"IPN250\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Sorting in string***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['IPN200', 'IPN250', 'IPN300']\n"
     ]
    }
   ],
   "source": [
    "profil.sort()\n",
    "print(profil)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Sorting reverse in string***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['IPN300', 'IPN250', 'IPN200']\n"
     ]
    }
   ],
   "source": [
    "profil.reverse()\n",
    "print(profil)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Check if an item is in the list or not\n",
    "\n",
    "_in & not in_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "profil = [\"IPN300\", \"IPN200\", \"IPN250\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Check if an existing-item is in the list***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(\"IPN200\" in profil)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Check if a nonexisting-item is in the list***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(\"IPN600\" in profil)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Check if an item is not in the list***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(\"IPN200\" in profil)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(\"IPN600\" not in profil)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# 3) TUPLE\n",
    "\n",
    "A tuple is a collection which is similar to a list. The elements of a tuple is ordered and unchangeable while, in a list, elements can be changed. \n",
    "\n",
    "A Tuple is written with round brackets \"( )\", separated by commas. A tuple item may be any type (float, string, integer, list etc.) and have any number.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Create a tuple having integers***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tpl = (1, 2, 3)\n",
    "print(tpl)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***tuple of different datatypes***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tpl = (3.14, \"pi\", (22/7))\n",
    "print(tpl)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***nested tuple***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tpl = (\"week\",[2,4,6],(1,2,3))\n",
    "print(tpl)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***create an empty tuple***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tpl = ()\n",
    "print(tpl)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***A tuple created without parenthesis called tuple packing***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tpl2 = 3.14, (22/7), \"pi\"\n",
    "print(tpl2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***unpacking tuple***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b, c = tpl2    \n",
    "print(a)      \n",
    "print(b)      \n",
    "print(c)      "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Access items of a tuple\n",
    "\n",
    "### 1) Index Operator\n",
    "\n",
    "An index operator ([ ]) can be used to access the elements of a tuple. Index starts with 0 and must be an integer. \n",
    "\n",
    "If you access the index number out of the range it will cause <font color=red>IndexError</font>; \n",
    "\n",
    "if you use float or other types, it will cause <font color=red>TypeError</font> will occur."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mytpl = ('E','n','g','i','n','e','e','r','i','n','g')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(mytpl[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(mytpl[5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(mytpl[-5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***TypeError ! only integer can be used***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mytpl[1.0] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nested Tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nested = (\"Squares\", [4,9,16,25]) \n",
    "print(nested[0][5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(nested[1][2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2) Slice Operator\n",
    "\n",
    "We can also access the elemts of a list by slicing operator.\n",
    "\n",
    "![](./Figures/canan.jpg)\n",
    "\n",
    "**Canan Dağdeviren**\n",
    "\n",
    "Hacettepe Üniversitesi Fizik Mühendisliği bölümünden mezun olan Canan Dağdeviren, yüksek lisansını da Sabancı Üniversitesi Malzeme Bilimi ve Mühendisliği programında yaptı. Forbes düzenlediği 30 Yaş Altı Bilim İnsanı listesinde de yer alıyor.\n",
    "\n",
    "Dağdeviren, Harvard Üniversitesi’nin Genç Akademi üyeliğine seçilen ilk Türk bilim kadını oldu. Giyilebilir teknolojiler üzerinde çalışmaları bulunuyor. Ayrıca, pilsiz çalışan ve giyilebilir bir kalp çipini de buldu. Son olarak, cilt kanserini teşhis eden bir cihaz geliştirdi."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mytpl = ('c','a','n','a','n','d','a','ğ','d','e','v','i','r','e','n')\n",
    "print(mytpl)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***elements beginning to end:***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(mytpl[:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***elements 5th to 11th:***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(mytpl[5:11])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***elements beginning to 4th:***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(mytpl[:-5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***elements 5th to end:***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(mytpl[4:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***A tuple can be assigned to a different item called reassignment:***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mytpl = (4, 9, 16, [64, 81])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***TypeError : 'tuple' object does not support item assignment***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mytpl[1] = 5 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***mutable element item can be changed***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mytpl[3][0] = 1\n",
    "print(mytpl)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***reassigned***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mytpl = ('s','p','i','d','e','r')\n",
    "print(mytpl)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***We can also use ' + ' operator to join two tuples***\n",
    "\n",
    "This is also called concatenation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print((1, 2, 3) + (4, 5, 6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.9.13"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}