01-Introduction to Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nZc1D_EimXy_"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/shaneahmed/StatswithPython/blob/main/01-Introduction%20to%20Python.ipynb\" target=\"_blank\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
    "\n",
    "<a href=\"https://kaggle.com/kernels/welcome?src=https://github.com/shaneahmed/StatswithPython/blob/main/01-Introduction%20to%20Python.ipynb\" target=\"_blank\"><img src=\"https://kaggle.com/static/images/open-in-kaggle.svg\" alt=\"Open In Colab\"/></a>\n",
    "\n",
    "\n",
    "# Introduction to Python\n",
    "\n",
    "### by Shan E Ahmed Raza\n",
    "---\n",
    "\n",
    "\n",
    "\n",
    "**Name: (Please write your name and ID here prior to submission)**\n",
    "\n",
    "\n",
    "\n",
    "---\n",
    "\n",
    "<b> Gabriele Pergola (gabriele.pergola@warwick.ac.uk) </b> <br> \n",
    "Credits to James Ravenscroft and [Python beginners guide](https://www.python.org/about/gettingstarted/).\n",
    "\n",
    "Python is simple to use, but it is a real programming language, offering much more structure and support for large programs\n",
    "than shell scripts or batch files can offer.\n",
    "If you do much work on computers, eventually you find that there’s some task you’d like to automate. Python can help you automate those tasks.\n",
    "\n",
    "It is a general purpose scripting language frequently used for data science and machine learning applications. It is open source and available on many different platforms (Windows, Mac OSX, Linux, Android and more)\n",
    "\n",
    "### Versions\n",
    "In [December 2019](https://pythonclock.org/) the Python foundation has stopped the support for the 2.X family. Therefore, we will be focussing on Python 3.X only.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "r_uWRX6emXzf"
   },
   "source": [
    "---------------------------------------------------------------------\n",
    "## Basic Syntax\n",
    "\n",
    " * Python 3 looks like many other modern programming languages such as C, Java, PHP and Perl. \n",
    " * There are no semi-colons at the end of lines\n",
    " \n",
    " <img src=\"https://pbs.twimg.com/media/DIU3U8gVoAE4wIQ.jpg\" width=\"250\" height=\"150\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BspH70P9mXzh"
   },
   "source": [
    "------------------------------------------------\n",
    "## Using Python as a Calculator\n",
    "Python interpreter acts as a simple calculator: you can type an expression at it and it will write the value. Expression syntax is straightforward: the operators +, -, * and / work just like in most other languages. Let’s try some simple Python commands."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "7-u8UGDkmXzi",
    "outputId": "c0c89ef1-cb6d-4a87-c730-50ab1f0c07e0"
   },
   "outputs": [],
   "source": [
    "2 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "f5vGSANomXzk",
    "outputId": "564294b7-15a0-437b-b6c7-c0ed5a4e1b02"
   },
   "outputs": [],
   "source": [
    "50 - 5*6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QktTX3ADmXzl"
   },
   "source": [
    "    Division always returns a floating point number. We will discuss python data types shortly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "B9HMWOV8mXzl",
    "outputId": "5189d0b5-31f7-49d3-cedb-78d97b8b13f7"
   },
   "outputs": [],
   "source": [
    "8 / 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JABamgPzmXzm"
   },
   "source": [
    "    Floor division using the operator // discards the fractional part"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "X3Nt63sVmXzm",
    "outputId": "af107513-9f62-45dd-fab8-b0a179400290"
   },
   "outputs": [],
   "source": [
    "8//5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "y_9wGWNImXzn"
   },
   "source": [
    "    The % operator returns the remainder of the division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Nhxu0YP3mXzn",
    "outputId": "cf63a4e5-8928-4c9b-d722-c832e9f3a0b8"
   },
   "outputs": [],
   "source": [
    "17 % 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "snqtVQ-hmXzo"
   },
   "source": [
    "    For power calculations use the ** operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ZCPFvkXOmXzo",
    "outputId": "26115629-6adc-49e3-a521-12a4d445370b"
   },
   "outputs": [],
   "source": [
    "5 ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "N9mMWoXKmXzo"
   },
   "source": [
    "    Parentheses (()) can be used for grouping."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "hkVmfn9wmXzp",
    "outputId": "55eb5b6a-20d2-422b-e059-61578b814ede"
   },
   "outputs": [],
   "source": [
    "(50 - 5*6) / 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "trU8hTe9mXzp"
   },
   "source": [
    "---------------------------------\n",
    "## Variables\n",
    "The equal sign (=) is used to assign a value to a variable. Afterwards, no result is displayed before the next interactive\n",
    "prompt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "y14cDEfLmXzp",
    "outputId": "4cb3534d-f52d-4316-e56e-18c04894169e"
   },
   "outputs": [],
   "source": [
    "tax = 12.5 / 100\n",
    "price = 100.50\n",
    "price * tax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jis7OqtdmXzq"
   },
   "source": [
    "    If a variable is not “defined” (assigned a value), trying to use it will give you an error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Qr2CM5-EmXzq",
    "outputId": "768d23e4-da55-4797-9c28-bb8728bb16fe"
   },
   "outputs": [],
   "source": [
    "n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uZ8y6zvJmXzr"
   },
   "source": [
    "    In interactive mode, the last printed expression is assigned to the variable _. This means that when you are using Python as a desk calculator, it is somewhat easier to continue calculations, for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "5KfnxLw2mXzr",
    "outputId": "aceb509c-97b4-4914-ed9a-02c0ef612aef"
   },
   "outputs": [],
   "source": [
    "_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "YqY9V6mOmXzs",
    "outputId": "0ffaceed-57cc-41d5-c808-d6ead1cb9743"
   },
   "outputs": [],
   "source": [
    "price + _"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "SHvZqAR6mXzs",
    "outputId": "bf5f0509-b3f2-43d1-ce26-22b01d1fd826"
   },
   "outputs": [],
   "source": [
    "round(_, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jbQWKxxHmXzt"
   },
   "source": [
    "--------------------------------------------\n",
    "## Basic Objects and Structures\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0Es96WZVmXzu"
   },
   "source": [
    "### Numbers\n",
    "There are four types: integers, floats, booleans and complex numbers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SvBkU3fomXzu"
   },
   "source": [
    "#### Integer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "zFFh80i5mXzv",
    "outputId": "f23a022b-5eb6-4eb6-c3e8-d3fe4df32741"
   },
   "outputs": [],
   "source": [
    "an_int = 1\n",
    "print(\"Int:\", an_int)\n",
    "print(type(an_int))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "l4svubjJmXzw"
   },
   "source": [
    "#### Float "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "AaauBSQBmXzx",
    "outputId": "82fa6cbe-5bdd-4e63-ca8e-3efa3403fb33"
   },
   "outputs": [],
   "source": [
    "a_float = 1.235\n",
    "print(\"Float:\", a_float)\n",
    "print(type(a_float))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zeZJ7RhcmXzy"
   },
   "source": [
    "#### Bool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "brdVE0_jmXzz",
    "outputId": "664e2bcf-f07c-4d4f-be80-45499b4d1397"
   },
   "outputs": [],
   "source": [
    "a_bool = False\n",
    "print(\"Bool:\",a_bool)\n",
    "print(type(a_bool))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3MaONax5mXzz"
   },
   "source": [
    "#### Complex Number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tiXayrvBmXz0",
    "outputId": "65ad39f5-abc1-4076-89ce-067f55409a8d"
   },
   "outputs": [],
   "source": [
    "a_complex = 2j\n",
    "print(\"Complex:\",a_complex)\n",
    "print(type(a_complex))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FTeYExPqmXz0"
   },
   "source": [
    "### Container Objects\n",
    "\n",
    "<img src=\"https://raw.githubusercontent.com/shaneahmed/StatswithPython/main/data/embedded_images/Containers.jpg\" width=\"500\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1oMVo1WImXz1"
   },
   "source": [
    "#### Strings\n",
    "Python can manipulate strings, which can be expressed in several ways. They can be enclosed in\n",
    "single quotes ('...') or double quotes (\"...\") with the same result. Comments can be added using the '#' key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "bPNq3jTymXz1",
    "outputId": "6c6a6a65-eeab-4f4a-fa87-916595c26af9"
   },
   "outputs": [],
   "source": [
    "\"hello world\" # Comments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jNWe7gjImXz2"
   },
   "source": [
    "    We can assign a string to a variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "1BmgTBEYmXz2",
    "outputId": "38c675aa-3638-4709-9d6b-53d63460a6f8"
   },
   "outputs": [],
   "source": [
    "a_string = \"hello world\"\n",
    "a_string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tOZ-YbTzmXz3",
    "outputId": "0c932ff1-1137-49bf-b86b-00c65c63fd19"
   },
   "outputs": [],
   "source": [
    "'python can't print this string'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TxpioR0omXz4"
   },
   "source": [
    "    use \\ to escape the single quote"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "md8usv_UmXz4",
    "outputId": "db201653-ac8a-416e-dbe0-7196b658fad6",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "'it didn\\'t work before with the quote'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-rUryKtdmXz5"
   },
   "source": [
    "    you can also use double quotes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "6-MqUBvRmXz5",
    "outputId": "e1b6f858-bb0a-4ded-b0e9-4ac211641ff5"
   },
   "outputs": [],
   "source": [
    "\"it didn't work before with the single quote\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "UIfq2TdGmXz6",
    "outputId": "e3d02dea-e560-4639-9d86-2900f20dbf88"
   },
   "outputs": [],
   "source": [
    "\"python can \" \"combine \" \"multiple\" \"strings\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ic5QulVEmXz6"
   },
   "source": [
    "    This feature is particularly useful when you want to break long strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "S_Yfg5KNmXz7",
    "outputId": "da8eefcf-759c-43ac-f808-a91c75da38bd"
   },
   "outputs": [],
   "source": [
    "text = ('Put several strings within parentheses '\n",
    "        'to have them joined together.')\n",
    "text"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Dyf3aL1KmXz7"
   },
   "source": [
    "    The print() function produces a more readable output, by omitting the enclosing quotes and by printing escaped and special characters. for example \\n to create a new line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ajjjFBNvmXz7",
    "outputId": "7c8b72e1-8c91-4629-be70-cf2322a7f964",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "'First line.\\nSecond line.'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "YrmI2S--mXz8",
    "outputId": "6093526f-b730-413e-ee42-48b4d69f072e"
   },
   "outputs": [],
   "source": [
    "print('First line.\\nSecond line.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Q7q8xas7mXz8"
   },
   "source": [
    "    String literals can span multiple lines. Another way is using triple-quotes: \"\"\"...\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "xeLLoOyHmXz9",
    "outputId": "d779e33f-bbed-4f74-bb73-894895820b96"
   },
   "outputs": [],
   "source": [
    "print(\"\"\"\n",
    "Usage: example [OPTIONS]\n",
    "       -h Display this usage message\n",
    "       -H hostname Hostname to connect to\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_ujzwU-RmXz-"
   },
   "source": [
    "    you can use raw strings by adding an r before the first quote"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "_JUbK42imXz-",
    "outputId": "6dfbe74f-dd94-4e32-c54f-2ef47de10f4f",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(r'First line.\\nSecond line.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "V5ZMipyOmXz_"
   },
   "source": [
    "    Integers can be combined with strings to display multiple characters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "d0OJ2CzbmX0A",
    "outputId": "732c714b-9e8d-4f8e-d2ce-cc366298bf31"
   },
   "outputs": [],
   "source": [
    "n = 5\n",
    "print(\"python is fu\" + n*\"n\" + \"!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    String literals prefixed with 'f' or 'F' are commonly called “f-strings” which is short for formatted string literals.\n",
    "    - Better Readability\n",
    "    - Concise\n",
    "    - Less prone to error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"Previous line printed 'n' {n} times\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    An optional format specifier can follow the expression. This allows greater control over how the value is formatted.\n",
    "    The following example rounds pi to three places after the decimal:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "print(f'The value of pi is approximately {math.pi:.3f}.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vwl-tlkamX0A"
   },
   "source": [
    "##### Indexing\n",
    "Strings can be indexed (subscripted), with the first character having index 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "T25KKFGSmX0B",
    "outputId": "fc6a0711-6812-49ba-a8c7-e3b6acaf7712"
   },
   "outputs": [],
   "source": [
    "word = 'Python'\n",
    "print(word[0]) # character in position 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "n2Md4o1vmX0C",
    "outputId": "d27984e0-29ba-436e-ab1d-ebb94d1a719e"
   },
   "outputs": [],
   "source": [
    "print(word[5]) # character in position 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lMYotTYVmX0C"
   },
   "source": [
    "    Indices may also be negative numbers, to start counting from the right:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "aiGfZ524mX0D",
    "outputId": "428228fc-fbf9-479d-fdf9-a9040639a635"
   },
   "outputs": [],
   "source": [
    "word[-1] # last character"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "vebRiyMimX0D",
    "outputId": "82c0ca8b-e129-4780-864e-5a8e02226bed"
   },
   "outputs": [],
   "source": [
    "word[-2] # second-last character"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "IqM42NSMmX0D",
    "outputId": "def98b56-d8b1-4761-f6ec-5963d68fa4c3"
   },
   "outputs": [],
   "source": [
    "word[-6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NN47ZnrgmX0E"
   },
   "source": [
    "    In addition to indexing, slicing is also supported. While indexing is used to obtain individual characters, slicing allows you to obtain substring"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "kIgPN6MVmX0F",
    "outputId": "be00ac06-6c0f-486c-95c4-65c683d9a7d8"
   },
   "outputs": [],
   "source": [
    "word[0:2] # characters from position 0 (included) to 2 (excluded)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "gZwgz8Z3mX0G",
    "outputId": "569280a6-df67-4041-f71a-5a66bd45ed3a"
   },
   "outputs": [],
   "source": [
    "word[2:5] # characters from position 2 (included) to 5 (excluded)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FBbuOebVmX0G"
   },
   "source": [
    "    Slice indices have useful defaults; an omitted first index defaults to zero, an omitted second index defaults to the size of the string being sliced."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "R_0OpQSMmX0H",
    "outputId": "e88adbe3-eb57-4294-8a5d-579c8c07eed5"
   },
   "outputs": [],
   "source": [
    "word[:2] # character from the beginning to position 2 (excluded)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "wnwyFf7bmX0H",
    "outputId": "f8706476-6d63-4916-b460-6210fd02c090"
   },
   "outputs": [],
   "source": [
    "word[4:] # characters from position 4 (included) to the end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "W3v7QfHPmX0I",
    "outputId": "782b4db5-42d6-44bb-988c-e4af0e5d0e0b"
   },
   "outputs": [],
   "source": [
    "word[-2:] # characters from the second-last (included) to the end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DJbHNBMYmX0J"
   },
   "source": [
    "    Attempting to use an index that is too large will result in an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "CGkqTiMZmX0J",
    "outputId": "69599f65-5d4d-480a-d225-d785a716389e"
   },
   "outputs": [],
   "source": [
    "word[42] # the word only has 6 characters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8gl-SU5vmX0K"
   },
   "source": [
    "    However, out of range slice indexes are handled gracefully when used for slicing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "vxgOrmnOmX0K",
    "outputId": "04298ddd-c8eb-4e26-a3ba-2774f9e52f36"
   },
   "outputs": [],
   "source": [
    "word[4:42]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "th5It5P5mX0L",
    "outputId": "63e65c72-9da8-4217-fb92-faee944b392a"
   },
   "outputs": [],
   "source": [
    "word[42:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Zb6BYWcEmX0M"
   },
   "source": [
    "    Python strings cannot be changed — they are immutable. Therefore, assigning to an indexed position in the string results in an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "KNIusOJbmX0M",
    "outputId": "6b715acb-281c-4460-cd80-945a2ac9318f"
   },
   "outputs": [],
   "source": [
    "word[0] = 'J'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "a45v069pmX0N"
   },
   "source": [
    "    If you need a different string, you should create a new one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "uifVd6YtmX0O",
    "outputId": "99c9e0d0-b4d9-47bd-ea1c-9d7ab8eef4cc"
   },
   "outputs": [],
   "source": [
    "'i' + 'P' + word[1:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ufv_gHndmX0O"
   },
   "source": [
    "#### List\n",
    "\n",
    "Lists can be written as a list of comma-separated values (items) between square brackets. Lists might contain items of different types, but usually the items all have the same type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Ou0HwqKwmX0P",
    "outputId": "1dc7d112-f1cc-4e25-a564-4b4de37ccda0"
   },
   "outputs": [],
   "source": [
    "squares = [1, 4, 9, 16, 25]\n",
    "squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "45t3smuXmX0P"
   },
   "source": [
    "    Like strings (and all other built-in sequence types), lists can be indexed and sliced:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "yClOiFfjmX0P",
    "outputId": "21fd9c98-9ca7-402a-bc56-03a787f21f44"
   },
   "outputs": [],
   "source": [
    "squares[0] # indexing returns the item"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "K2AITc2bmX0Q",
    "outputId": "d96b70bc-189e-4e43-8edd-b951a37519a6"
   },
   "outputs": [],
   "source": [
    "squares[-3:] # slicing returns a new list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "saAfI81emX0Q"
   },
   "source": [
    "    Strings and numbers can be mixed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "a0vA4coomX0R",
    "outputId": "a038870d-832a-4fdc-fb84-16cc57ee1041"
   },
   "outputs": [],
   "source": [
    "mixed = [\"sometext\", 1.234, 1, True, False]\n",
    "\n",
    "print(mixed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IKAHdVFmmX0S"
   },
   "source": [
    "    Unlike strings, which are immutable, lists are a mutable type, i.e. it is possible to change their content:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "OpinjKFAmX0T",
    "outputId": "d314353e-ef05-4d3b-ddda-2539a6bced84"
   },
   "outputs": [],
   "source": [
    "cubes = [1, 8, 27, 65, 125] # something's wrong here\n",
    "cubes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ISIxEDQMmX0T",
    "outputId": "e930737d-12c8-4309-a5b6-dc5dc99b6002"
   },
   "outputs": [],
   "source": [
    "4 ** 3 # the cube of 4 is 64, not 65!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "hO0ktcpjmX0U",
    "outputId": "0df56858-bef7-4c33-afda-745795350423"
   },
   "outputs": [],
   "source": [
    "cubes[3] = 64 # replace the wrong value\n",
    "cubes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "V3_ZuJlJmX0U"
   },
   "source": [
    "    You can also add new items at the end of the list, by using the append() method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "8PNQpkzUmX0V",
    "outputId": "c148c766-eec7-4a33-950e-456cce6e12fc"
   },
   "outputs": [],
   "source": [
    "cubes.append(7 ** 3)\n",
    "cubes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "J23a2R3_mX0V"
   },
   "source": [
    "It is possible to nest lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tnlnla0GmX0W",
    "outputId": "c0c27a56-1d07-4756-e96c-fd60168c7d0b"
   },
   "outputs": [],
   "source": [
    "a = ['a', 'b', 'c']\n",
    "n = [1, 2, 3]\n",
    "x = [a, n]\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "J_gltRqSmX0W"
   },
   "source": [
    "#### Tuples\n",
    "\n",
    "Tuples Like a list but immutable. It makes your code safer in protecting data that does not need to be changed. This also means that tuples are very efficient with regard to memory consumption and runtime. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "DisagBtQmX0W",
    "outputId": "f94bb436-09e9-481d-e8a2-0bce930c33f4"
   },
   "outputs": [],
   "source": [
    "atuple = (123, \"hello world\")\n",
    "\n",
    "print (atuple[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "jSik05XTmX0Y",
    "outputId": "98e57086-344b-4ecc-fd54-849732ff8d0f"
   },
   "outputs": [],
   "source": [
    "atuple[0] = 321 # Tuples are immutable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "V3cnNqt7mX0Y"
   },
   "source": [
    "#### Set\n",
    "\n",
    "Like a mathematical set - can be used to filter out duplicates in lists and check for membership.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "UdFmULc1mX0Z",
    "outputId": "23db502d-0f3c-4338-d507-9a752265ab94"
   },
   "outputs": [],
   "source": [
    "spamlist = [\"spam\",\"spam\",\"spam\",\"spam\",\"eggs\",\"eggs\",\"bacon\", \"spam\"]\n",
    "setA = set(spamlist)\n",
    "print(\"list:\", spamlist)\n",
    "print(\"set:\", setA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "H7n96eq7mX0Z",
    "outputId": "cc69a39c-751b-4b08-842a-7528ab7f7865"
   },
   "outputs": [],
   "source": [
    "setB = {'spaghetti', 'eggs', 'sausages', 'prosecco'}\n",
    "\n",
    "print(\"\\nSet operations: \")\n",
    "print(\"- Intersection A,B\",setA.intersection(setB)) #should print 'eggs' which is in both sets\n",
    "print(\"- Union A,B\",       setA.union(setB))        #should print all items in both sets\n",
    "print(\"- Difference A,B\",  setB.difference(setA))   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AFos5eo8mX0a"
   },
   "source": [
    "#### Dictionary or dict\n",
    "\n",
    "dicts are essentially like a HashMap in Java - a mutable set of key -> value pairs maintained in memory. Python allows you to access the items using the indexing syntax described above for lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "7zU3H23YmX0a",
    "outputId": "839c4ddd-b170-4093-8fc0-f91e2ce063cf"
   },
   "outputs": [],
   "source": [
    "mydict = {\"spam\" : \"eggs\", \"bacon\" : \"sausage\"}\n",
    "\n",
    "print(mydict['spam'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Fb0BVrQ7mX0a",
    "outputId": "2abd4bf8-9a20-46a8-ba0f-5323f9d3e3e8"
   },
   "outputs": [],
   "source": [
    "mydict['bacon'] = \"fried bread\"\n",
    "\n",
    "print(mydict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "p1BdBH5KmX0b"
   },
   "source": [
    "    It is possible to get a list of keys or a list of values or even a list of tuples describing keys and values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "JEM7a0H4mX0c",
    "outputId": "d0819a54-d1a1-4a14-c13a-9dd8af431a1a"
   },
   "outputs": [],
   "source": [
    "print(\"keys:\",    mydict.keys())\n",
    "print(\"values:\",  mydict.values())\n",
    "print(\"entries:\", mydict.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qzDDJU_UmX0c"
   },
   "source": [
    "---------------------------------\n",
    "\n",
    "## Loops and iteration\n",
    "\n",
    "for loops in Python are one of the most powerful features of the language - especially when combined with some of the more advanced concepts as described below.\n",
    "\n",
    "A basic for loop looks like this:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4zs8kQuBmX0d"
   },
   "source": [
    "### _For_ loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "lgkTI28UmX0d",
    "outputId": "f513fa52-526c-4882-b777-a33b3b0ebb8c"
   },
   "outputs": [],
   "source": [
    "iterable = [1,2,3,4,5]\n",
    "\n",
    "for item in iterable:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TNEU8SYqmX0e"
   },
   "source": [
    "    You can expand lists of tuples using for loops so that each part of the tuple is accessible. \n",
    " Remember how I said we could iterate over keys ***and*** values in a dict earlier?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ynMlcpyFmX0f",
    "outputId": "935ca8d5-6930-4b52-c89f-5b7b2bf32ee2"
   },
   "outputs": [],
   "source": [
    "print(mydict) # My dictionary\n",
    "\n",
    "for key,value in mydict.items():\n",
    "    print(\"key=\",key,\", value=\",value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mDJbA0JQmX0f"
   },
   "source": [
    "    We can also keep count of how many times we've been around the loop using the Python *enumerate* function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "uz3lppz4mX0g",
    "outputId": "5ea2f01b-e5f4-4b22-89c4-2c7b201d4c2c"
   },
   "outputs": [],
   "source": [
    "items = [\"spam\",\"eggs\",\"sausages\",\"bacon\"]\n",
    "\n",
    "for i, item in enumerate(items):\n",
    "    print (\"This is item\", i)\n",
    "    print(\"Item:\",item)\n",
    "    if i <1:\n",
    "        print (\"This is the first time around the loop\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yuKdDaovmX0h"
   },
   "source": [
    "    If you do need to iterate over a sequence of numbers, the built-in function range() comes in handy. It generates arithmetic progressions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Kxp_hjB2mX0i",
    "outputId": "a08f4c8a-c875-4f9b-bc07-b987addbc0a9"
   },
   "outputs": [],
   "source": [
    "for i in range(5):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oYDxa4JdmX0j"
   },
   "source": [
    "### _While_ Loop\n",
    "The while loop executes as long as the condition (here: a < 10) remains true."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "NdjQ4IsNmX0j",
    "outputId": "37d23f5d-edca-4ac4-eb92-ea5f6aaf9150"
   },
   "outputs": [],
   "source": [
    "# Fibonacci series:\n",
    "# the sum of two elements defines the next\n",
    "a, b = 0, 1\n",
    "while a < 10:\n",
    "    print(a)\n",
    "    a, b = b, a+b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iterators\n",
    "Behind the scenes, the for statement calls `iter()` on the container object. The function returns an iterator object that defines the method `__next__()` which accesses elements in the container one at a time. When there are no more elements, `__next__()` raises a `StopIteration` exception which tells the for loop to terminate. You can call the `__next__()` method using the `next()` built-in function; this example shows how it all works:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"123\"\n",
    "for char in s:  # For loop to print characters in a string\n",
    "    print(char)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "it = iter(s)\n",
    "print(next(it))\n",
    "print(next(it))\n",
    "print(next(it))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As there are no more elements left, `next(it)` will raise a `StopIteration` exception to tell the loop to terminate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "next(it)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ghQpan7smX0k"
   },
   "source": [
    "## _if_ statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "gwW7-EtxmX0k",
    "outputId": "3d06cfa7-ddf6-40ca-a12a-83fd95c848e0"
   },
   "outputs": [],
   "source": [
    "x = int(input(\"Please enter an integer: \"))\n",
    "\n",
    "if x < 0:\n",
    "    x = 0\n",
    "    print('Negative changed to zero')\n",
    "elif x == 0:\n",
    "    print('Zero')\n",
    "elif x == 1:\n",
    "    print('Single')\n",
    "else:\n",
    "    print('More')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rnr7jvmHmX0l"
   },
   "source": [
    "---------------------------------------\n",
    "\n",
    "## Functions\n",
    "\n",
    "Function definitions in Python are very simple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ir1NIaRxmX0r"
   },
   "outputs": [],
   "source": [
    "def square(x):\n",
    "    y = x * x\n",
    "    return y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "fXDwbK6kmX0s",
    "outputId": "73b49575-76d3-4f37-da47-26c48052b9e8"
   },
   "outputs": [],
   "source": [
    "#what is the square of 2? should print 4\n",
    "print(\"2 x 2 = \", square(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "F9tpQ--lmX0s"
   },
   "source": [
    "    Functions can have many parameters and default values can be specified too"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "5W-tgIydmX0t",
    "outputId": "db08477c-d97e-4d09-ea4e-67581b4dce3e"
   },
   "outputs": [],
   "source": [
    "def square(x=0):\n",
    "    y = x * x\n",
    "    return y\n",
    "\n",
    "def cube(x=0):\n",
    "    return x * x * x\n",
    "\n",
    "def domaths(number, operation):\n",
    "    return operation(number)\n",
    "\n",
    "print(\"Square default behavior: \", square())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "JSvrZhMImX0u",
    "outputId": "1341b605-fcaf-4b52-b8e2-5315dcb746a9"
   },
   "outputs": [],
   "source": [
    "print(\"Square function is now the argument: \", domaths(2, square))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "u2QmrwS8mX0v",
    "outputId": "67b8ae26-7466-4ae8-84a6-325f0647b778"
   },
   "outputs": [],
   "source": [
    "print(\"Now lets cube: \", domaths(2,cube))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "vND3-cD-mX0w",
    "outputId": "d2fcb63f-ba72-4424-b80b-7846edbc7bd6"
   },
   "outputs": [],
   "source": [
    "# Fibonacci series function\n",
    "def fib(n): # write Fibonacci series up to n\n",
    "    \"\"\"Print a Fibonacci series up to n.\"\"\"\n",
    "    a, b = 0, 1\n",
    "    while a < n:\n",
    "        print(a, end=' ')\n",
    "        a, b = b, a+b\n",
    "\n",
    "\n",
    "fib(2000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2BaWO3iimX0w"
   },
   "source": [
    "## Conclusion\n",
    "\n",
    "That's the end of basic syntax.\n",
    "But before:\n",
    "<img src=\"https://raw.githubusercontent.com/shaneahmed/StatswithPython/main/data/embedded_images/eagleson_law.jpg\" width=\"600\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "C_g95zSrmX0x"
   },
   "source": [
    "## Exercises\n",
    "- Write a python function \n",
    "    - which takes a string as an input and returns the first two letters of the string. [10]\n",
    "    - to calculate cube of input value. [15]\n",
    "    - to calculate cube root of input value. [15]\n",
    "    - which can identify odd values in a list of integers and prints the odd values. [20]\n",
    "    - to add `VAT` to the actual price of a product. (You can choose VAT to be 20% of purchase price). [20]\n",
    "    - `isPrime` to test if the input value is a prime number. [20]\n"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "name": "01-Introduction to Python.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3.8.12 ('base')",
   "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.8.12"
  },
  "vscode": {
   "interpreter": {
    "hash": "f49206fcf84a9145e7e21228cbafa911d1ac18292303b01e865d8267a9c448f7"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}