1_variables_data-types.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "1MjzmO4uoHh9",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Variables and Data Types\n",
    "\n",
    "- prepared by [Katarina Nastou](https://www.cpr.ku.dk/staff/?pure=en/persons/672471)\n",
    "\n",
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pythontsunami/teaching/blob/intro/1_variables_data-types.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Colab \n",
    "\n",
    "In this course we use [Google Colab](https://colab.research.google.com/) to execute notebooks. Notebooks are documents allowing\n",
    "the combination of text, code and the output of code. Colab offers an extended set of\n",
    "pre-installed tools. See the [tutorial series](https://www.youtube.com/playlist?list=PLQY2H8rRoyvyK5aEDAI3wUUqC_F0oEroL)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Saving the notebook in Drive\n",
    "Save a copy in your drive if you want to save your changes: `File` -> `Save a copy in Drive`\n",
    "\n",
    "\n",
    "![Save Colab Notebook in Google Drive](figures/colab_save_in_drive.png)\n",
    "\n",
    "or \n",
    "\n",
    "![Save Colab Notebook in Google Drive](figures/colab_save_in_drive_2.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Table of Contents in Colab**\n",
    "> Allows easier navigation\n",
    "\n",
    "![Table of content in Colab](figures/colab_toc.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "CiX8enO1uJ65",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "## Objectives\n",
    "\n",
    "*   Understand how to assign and use variables\n",
    "*   Learn Python variable naming restrictions and conventions\n",
    "*   Learn and use some of the different data types available in Python\n",
    "*   Learn why Python is called a dynamically-typed language\n",
    "*   Understand how to convert data types\n",
    "*   Learn about strings!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "GXxxR4dDuunK",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Variable Assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Nx4q1VSyuzOA",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "A variable in Python is like a variable in mathematics: it is a named symbol that holds a value. \n",
    "\n",
    "> A variable holds a reference to an object, which represents the value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 555,
     "status": "ok",
     "timestamp": 1583692499662,
     "user": {
      "displayName": "Catherine Nst",
      "photoUrl": "",
      "userId": "00118750132604534762"
     },
     "user_tz": -60
    },
    "id": "-IoOMUOnuD6f",
    "outputId": "243cf484-7518-48ad-9770-9c2d6ff4166b",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = 100\n",
    "another_variable = 1\n",
    "print(another_variable + x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "fR1SGXUSvCKA",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Variables are always **assigned** with the variable name on the left and the value on the right of the ***equals*** sign.\n",
    "\n",
    "\n",
    "Variables must be assigned before they can be used.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "1XGwtNywvW83",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "\n",
    "\n",
    "Variables can be:\n",
    "        \n",
    "- `a_variable = 100`\n",
    "\n",
    "assigned to other variables\n",
    "\n",
    "- `another_variable = a_variable`\n",
    "\n",
    "reassigned at any time\n",
    "\n",
    "- `a_variable = 435` \n",
    "\n",
    "assigned at the same time as other variables\n",
    "        \n",
    "- `all, at, once = 1, 130, 43`\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "l5SuTYIGvuB_",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Naming Restrictions\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "M23lgzTcwMXn",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "In Python, you can name your variables whatever you want, with some restrictions:\n",
    "\n",
    "1. Variables must start with a letter or underscore\n",
    "\n",
    "    `_yes`: Yes \n",
    "\n",
    "    `2no`: NO!\n",
    "\n",
    "2. The rest of the name must consist of letters, numbers, or underscores\n",
    "\n",
    "    `yes2`: Yes \n",
    "\n",
    "    `hey@no`: NO!\n",
    "\n",
    "3. Names are case-sensitive\n",
    "\n",
    "    `Yes != YES` (`!=` means *not equal to*)\n",
    "\n",
    "    `Yes != yes`\n",
    "\n",
    "\n",
    "\n",
    "Most Python programmers prefer to use standard style conventions when naming things:\n",
    "\n",
    "- Most variables should be **snake_case** (underscores between words)\n",
    "\n",
    "- Most variables should be also be **lowercase**, with some exceptions:\n",
    "\n",
    "        UpperCamelCase usually refers to a class (advanced)\n",
    "\n",
    "        CAPITAL_SNAKE_CASE usually refers to constants (e.g. PI = 3.14)\n",
    "\n",
    "- Variables that start and end with two underscores (called \"dunder\" for double underscore) are supposed to be private or left alone:\n",
    "\n",
    "        __no_touchy__\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "pVF6YjlgGtKX",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Data Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "J3kix56wGxEB",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "In any assignment, the assigned value must always be a valid data type.\n",
    "\n",
    "Python data types include (among others):\n",
    "- bool: `True` or `False` values\n",
    "- int: an integer (1, 2, 3)\n",
    "- str: (string) a sequence of Unicode characters, e.g. \"Kate\" or \"程序设计\"\n",
    "- list: a sequence of values of other data types, e.g. `[1, 2, 3]` or `[\"a\", \"b\", \"c\"]`\n",
    "- dict: a collection of key-value pairs, e.g. `{ \"first_name\": \"John\", \"last_name\": \"Doe\" }`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UAnUqmtKICUK",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Dynamic Typing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "tL8FZFytIeIX",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "In Python variables can change types readily, something called **dynamic typing**! Test it with the 4 code blocks below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "mJWRieehIRFs",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "variable1 = True\n",
    "print(variable1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "EzKLZ1t3IVNw",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "variable1 = \"Hello!\"\n",
    "print(variable1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "atpEaIWyIYCy",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "variable1 = None\n",
    "print(variable1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "kymQ8oseIZ70",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "variable1 = 22 / 7\n",
    "print(variable1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "eISd5oPIJDaA",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Other languages, such as C++, are **statically-typed**, and variables are stuck with their originally-assigned type."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "2Fxr9nvvNelH",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Question: Is the following valid Python code?\n",
    "\n",
    "```    \n",
    "    i_am_string = \"hello world\"\n",
    "    \n",
    "    i_am_string = 73 \n",
    "    \n",
    "    i_am_string = True\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "id_C8gtAJH0H",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Declaring strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "5ld4357nJwPO",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "String literals in Python can be declared with either single or double quotes.\n",
    "    \n",
    "    my_other_str = 'a hat'\n",
    "    my_str = \"a cat\"\n",
    "\n",
    "\n",
    "Either one is perfectly fine; but make sure you stick to the same convention throughout the same file.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "L1dWUnXgKP-V",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### String Escape Characters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "hbJoXKY3KTZU",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "In Python there are also \"escape characters\", which are \"metacharacters\" - they get interpreted by Python to do something special:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Dwsi4tHLKW2_",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "new_line = \"hello \\n world\"\n",
    "print(new_line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "raptl5PbKdSy",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "All escape characters start with a backslash `\\`. \n",
    "\n",
    "You can do advanced things like include [hexadecimal unicode character encoding](https://www.utf8-chartable.de/unicode-utf8-table.pl?unicodeinhtml=hex) with `\\x`, but normally every symbol should be recognized.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 589,
     "status": "ok",
     "timestamp": 1583688076193,
     "user": {
      "displayName": "Catherine Nst",
      "photoUrl": "",
      "userId": "00118750132604534762"
     },
     "user_tz": -60
    },
    "id": "MlFGlNTWKgs-",
    "outputId": "7a58c8a4-8129-4da1-e868-f4cb6861076f",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "hexadecimal = \"\\x41\\x42\\x43\" \n",
    "print(hexadecimal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "8zvHzDf9ObSF",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Question: What will happen in the following cases?\n",
    "```\n",
    "names = \"Megan\\nTrevor\"\n",
    "names2 = 'Megan\\nTrevor'\n",
    "greeting = \"hello \"Megan\"\"\n",
    "greeting2 = \"hello 'Megan'\"\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "cWYyiUYwPIzK",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Exercise on strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "GZ50HbUOPGgy",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    " # Set the message variable equal to any string containing a new-line escape sequence\n",
    "message = \"\"\n",
    "\n",
    "# Add a string to the mountains variable that when printed results in: /\\/\\/\\\n",
    "# You will need to use an escape sequence more than once!\n",
    "mountains = \"\"\n",
    "\n",
    "\n",
    "# Set the quotation variable to any string that contains an escaped double quotation mark\n",
    "quotation = \"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "wdl3Mr56KobD",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### String Concatenation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "2TrbxJSoKqzZ",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Concatenation is combining multiple strings together. In Python you can do this simply with the \"+\" operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 531,
     "status": "ok",
     "timestamp": 1583688136965,
     "user": {
      "displayName": "Catherine Nst",
      "photoUrl": "",
      "userId": "00118750132604534762"
     },
     "user_tz": -60
    },
    "id": "TES-Z6EOKtJO",
    "outputId": "0be577ce-aecc-442c-c3a6-1c4bdae35586",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "str_one = \"your\"\n",
    "str_two = \"face\"\n",
    "str_three = str_one + \" \" + str_two \n",
    "print(str_three)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "5ARprsTjK1rf",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "You can also use the \"+=\" operator!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "v-YdMCywK3eU",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "str_one = \"ice\"\n",
    "str_one += \" cream\"\n",
    "str_one\n",
    "print(str_one)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "4Ux6Hu0HPa9J",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Exercise on string concatenation\n",
    "- Set the variable called greeting  to some greeting, e.g. \"hello\".\n",
    "- Set the variable called name  to some name, e.g. \"Moto\". \n",
    "- Then set the variable called greet_name  that concatenates greeting , name , and a space \" \" between them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "9g4l_bmSPd8G",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "greeting = \"\"\n",
    "\n",
    "name = \"\"\n",
    "\n",
    "space = \"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "TUWlmr5jLMSS",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Formatting strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "gAKONDNDLQPM",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "There are also several ways to format strings in Python to interpolate variables.\n",
    "\n",
    "The new way (new in Python 3.6+) => **F-Strings**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "waOcpL6ALVyg",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = 10\n",
    "formatted = f\"I've told you {x} times already!\"\n",
    "print(formatted)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "omNJP7uBLXhA",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The tried-and-true way (Python 2 -> 3.5) => **.format method**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "YnJOx33ALeGX",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = 10\n",
    "formatted = \"I've told you {} times already!\".format(x)\n",
    "print(formatted)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3RaEzZ7dLg1w",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The old way => **% operator** (deprecated)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "-XvA_3IJLkvE",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = 10\n",
    "formatted = \"I've told you %d times already!\" % (x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ZCImv_NnRde8",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Exercise on string formatting\n",
    "- Set the variable first to your first name\n",
    "- Set the variable last to your last name\n",
    "- Set the varible name that interpolates both using the .format() method, and the variable name2 using the f-string.\n",
    "Follow this pattern:\n",
    "```\n",
    "First Name: Mary, Last Name: Poppins\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 52
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 575,
     "status": "ok",
     "timestamp": 1583690141610,
     "user": {
      "displayName": "Catherine Nst",
      "photoUrl": "",
      "userId": "00118750132604534762"
     },
     "user_tz": -60
    },
    "id": "Ptyqkjh3RiUb",
    "outputId": "ceec6784-cb73-4f8e-f267-4c100874b41d",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "first = \"\"\n",
    "last = \"\"\n",
    "\n",
    "name = \"\"\n",
    "print(name)\n",
    "name2 = \"\"\n",
    "print(name2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "GDBodXOJLnja",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Converting Data Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "RskoInewL1yZ",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "In string interpolation, data types are implicitly converted into string form.\n",
    "\n",
    "You can also explicitly convert variables by using the name of the builtin type as a function (more on functions later):\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1100,
     "status": "ok",
     "timestamp": 1583688471452,
     "user": {
      "displayName": "Catherine Nst",
      "photoUrl": "",
      "userId": "00118750132604534762"
     },
     "user_tz": -60
    },
    "id": "bOaRRZ2dL8Um",
    "outputId": "cb3a6074-1162-4d40-b3f6-4b4b53c31ac5",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "decimal = 12.56345634534\n",
    "integer = int(decimal) \n",
    "print(integer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 52
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 534,
     "status": "ok",
     "timestamp": 1583688489921,
     "user": {
      "displayName": "Catherine Nst",
      "photoUrl": "",
      "userId": "00118750132604534762"
     },
     "user_tz": -60
    },
    "id": "UH8WhR5IMAwZ",
    "outputId": "99224d78-453b-4933-c229-426f6aef2ec6",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "my_list = [1, 2, 3]\n",
    "my_list_as_a_string = str(my_list)\n",
    "my_list_as_a_string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3vUm-Di3Sxaj",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Quiz on Variables and Data Types\n",
    "\n",
    "##### Question 1\n",
    "True or False: Variables must be assigned before they can be used."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3vUm-Di3Sxaj",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "##### Question 2\n",
    "Variables can be: \n",
    "\n",
    "    1. assigned to other variables,\n",
    "    \n",
    "    2. reassigned at any time,\n",
    "    \n",
    "    3. assigned at the same time as other variables, \n",
    "    \n",
    "    4. all of the above"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3vUm-Di3Sxaj",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "##### Question 3\n",
    "Is `24hrs`  a valid variable name?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3vUm-Di3Sxaj",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "##### Question 4\n",
    "Is `my_1st_variable`  a valid variable name?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3vUm-Di3Sxaj",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "##### Question 5\n",
    "What values can the `Boolean` data type hold?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3vUm-Di3Sxaj",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "##### Question 6\n",
    "True or False. The following is a valid string in Python 3: `الثعبان`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3vUm-Di3Sxaj",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "##### Question 7\n",
    "What does it mean that Python is a dynamically-typed language?\n",
    "\n",
    "   1. Variables in Python can implicitly change to other types when comparing. For example you can compare string  `\"2\" ` and the number 2 using `==`\n",
    "\n",
    "   2. Python variables can be assigned to different types and change types at will\n",
    "\n",
    "   3. Python is more efficient that C++\n",
    "\n",
    "   4. All of the above"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "tC204P7HMVRi",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Recap"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "qLztR6OZMW3m",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "-    Python is a dynamically-typed language with more than half a dozen types\n",
    "\n",
    "-    Python lets you assign and reassign variables at will to any of the types\n",
    "\n",
    "-    There are some variable naming restrictions which are required and some naming guidelines which are recommended\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "THMUNuzm3jtb",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "*Note: This notebook's contents have been adapted from Colt Steele's slides used in \"[Modern Python 3 Bootcamp Course](https://www.udemy.com/course/the-modern-python3-bootcamp/)\" on Udemy*"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "colab": {
   "authorship_tag": "ABX9TyOaxw8MyUHqh2yH8My6xJgL",
   "collapsed_sections": [],
   "name": "variables_data-types.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "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.7"
  },
  "rise": {
   "scroll": true
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}