Exercises/EN/Basic/02_Variables_and_Data_Types_Solutions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## About This Notebook\n",
    "\n",
    "Probably the most useful concept within programming is understanding of **variables**. We will therefore focus on those within this notebook. We will begin by exploring why do we need those and how are they created. Later on, we will move onto **data types**. These mean that variables can be of different type depending on what they store.\n",
    "\n",
    "Alongside, we will learn some useful tricks, such as *conversion* betweeen data types.\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Saving Values\n",
    "We have learned the basics of Python programming and performed a couple of arithmetical operations in Python. However, how do we actually save values and work with numerical and text data. Take for example, if we want to save the result of an arithmetical operation for other execution. Let's say (20-10)*2 = 20, and we want to save 20 as our result. We can therefore write:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "result = 20"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we print the result, the output is: 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    }
   ],
   "source": [
    "result = 20\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also directly save (20-10)*2 instead of saving 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    }
   ],
   "source": [
    "result = (20-10)*2\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pay attention that, when we print(result), the output is the value of calculation and not (20-10) * 2. **The computer first calculates (20-10) * 2 and then saves the result 20 to variable name \"result\".**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 1.2.1:\n",
    "1. Save the result of (50 + 6)*32 to variable name `result`.\n",
    "2. Print result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1792\n"
     ]
    }
   ],
   "source": [
    "# Start your code below:\n",
    "\n",
    "result = (50 + 6)*32\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Variables\n",
    "When we run the code result = 20, the value 20 is saved in the computer memory. The computer memory has many storage locations, and the value 20 is saved to one particular location.\n",
    "\n",
    "The value we just saved, which is 20, has a unique identifier in the storage location which we can use it to access 20. We can use the identifier *result* to access 20 in our program. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n",
      "40\n",
      "21\n"
     ]
    }
   ],
   "source": [
    "result = 20\n",
    "print(result)\n",
    "print(result * 2)\n",
    "print(result + 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This unique identifier is commonly known as a **variable**. \n",
    "*result = 20* is ran after we hit the Run button, the computer stored 20 in a variable or a storage location named *result* based on our command --- therefore \"result\" is a **variable name**.\n",
    "Notice that the order of the variable naming is very important. The variable name is to the left of the = sign and the value we want to store to this variable name is located to the right.\n",
    "Therefore if we want to store the value 20 to a variable named result, result = 20 must be written and not 20 = result."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's do some practice declaring some variable names.\n",
    "\n",
    "### Task 1.2.2:\n",
    "1. Store the value 10 in a variable named some_value.\n",
    "2. Store the result of (38+6-2)*23 to a variable named some_result.\n",
    "3. Using the `print()` command to display the following:\n",
    "  * The value stored in the some_value variable.\n",
    "  * The result of adding 8 to the variable some_result.\n",
    "  * The result of adding some_value to some_result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "974\n",
      "976\n"
     ]
    }
   ],
   "source": [
    "# Start your code below:\n",
    "\n",
    "some_value = 10\n",
    "some_result = (38+6-2)*23\n",
    "print(some_value)\n",
    "print(some_result + 8)\n",
    "print(some_value + some_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Variable Names\n",
    "In the previous task, we have declared some variable names. We also learned that we can choose names for our variables. However, the names we choose must comply with a number of syntax rules. For example, if we try to name a variable a result, a syntax error will occur because we're not allowed to use space in variable names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-8-1435c92e22df>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-8-1435c92e22df>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    a result = 20\u001b[0m\n\u001b[1;37m           ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "a result = 20"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are two syntax rules we must follow when we declare our variables: <br>\n",
    "1). Only letters, numbers, or underscores (we can't use apostrophes, hyphens, whitespace characters, etc.) can be used. <br>\n",
    "2). Variable names cannot start with a number.<br>\n",
    "\n",
    "For example, errors will occur if we name our variables like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid token (<ipython-input-9-81fe90c7b287>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-9-81fe90c7b287>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    1_result = 2\u001b[0m\n\u001b[1;37m     ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid token\n"
     ]
    }
   ],
   "source": [
    "1_result = 2\n",
    "new result = 3\n",
    "sister's_vacation_day = 23\n",
    "old-result = 20\n",
    "price_in_$ = 20\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All variable names are case sensitive, notice that result is different from a variable named Result:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n",
      "30\n"
     ]
    }
   ],
   "source": [
    "result = 20\n",
    "Result = 30\n",
    "print(result)\n",
    "print(Result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Updating Variables\n",
    "\n",
    "The value saved in a variable can be changed or updated.\n",
    "For example, in the code below we have first stored 2 in the variable result and then we update result to store 20 instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "20\n",
      "30\n"
     ]
    }
   ],
   "source": [
    "result = 2\n",
    "print(result)\n",
    "print(result + 1)\n",
    "\n",
    "result = 20\n",
    "print(result)\n",
    "\n",
    "result = result + 10\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pay attention to the code above:\n",
    "- The variable result initially only stores a value of 2\n",
    "- result + 1 equals to 3 because result restores a value of 2 --- so result + 1 becomes 2 + 1\n",
    "- when we run result = result + 10, result is updated to store of value of result + 10, which is 30. It is the same as running result = 20 + 10 because result has a value of 20.\n",
    "print(result) outputs 30 after we executed result = result + 10.\n",
    "Now let's have a little practice with variables.\n",
    "income = 2000\n",
    "\n",
    "### Task 1.2.4:\n",
    "1.  Update the variable income by adding 5000 to its current value.\n",
    "2.  Print income"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7000\n"
     ]
    }
   ],
   "source": [
    "income = 2000\n",
    "\n",
    "# Start your code below:\n",
    "income = income + 5000\n",
    "print(income)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Pay attention to how we updated the variable, for example, by using x = x + 1. It is different than what we normally follows in mathematics. x = x +1 would be a false statement because x can never be equal to x + 1.** This means that the = operator sign in python or in any programming language in general doesn't have the same meaning as it does in mathematics.\n",
    "\n",
    "**In Python, the = operator means assignment**: the value on the right is assigned to the variable on the left, just like how we name our variable. It doesn't mean equality. We call = an assignment operator, and we read code like x = 2 as \"two is assigned to x\" or \"x is assigned two,\" but not \"x equals two.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By the way, Python offers a shortcut for inplace operations +=, -=, /= and *="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "11\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "print(x)\n",
    "\n",
    "x += 1    # is equivalent to x = x + 1\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Types of Values\n",
    "We have only worked with integers so far, of course we can also work with decimal numbers in Python. To understand what type of numbers or even values you are working with in Python, we can simply use the `type()` command to see the type of a value. For example:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'float'>\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "print(type(10))\n",
    "print(type(10.))\n",
    "print(type(10.0))\n",
    "print(type(2.5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that Python makes distinguishment between integers and decimal numbers. Take for example that the integer 10 has the <b> int </b> type and the decimal number 10., 10.0, and 2.5 has the <b> float</b> type. All integers have the <b> int </b> type, and numbers that has a decimal point have the <b> float </b>type. \n",
    "\n",
    "Even though these numbers are classified into different <b> types</b> or have different <b> data types </b>, we can still peform arithmetical operations with them. For example, we can still add an <b> int </b> data type to a <b> float </b> data type.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20.0\n",
      "12.5\n"
     ]
    }
   ],
   "source": [
    "print(10 + 10.0)\n",
    "print(2.5 * 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 1.2.5:\n",
    "1. Assign a value of 10 to a variable named value_1 <br>\n",
    "2. Assign a value of 20.5 to a variable named value_2 <br>\n",
    "3. Update the value of value_1 by adding 2.5 to its current value. Try to use the syntax shortcut like += operator. <br>\n",
    "4. Update the value of value_2 by multiplying its current value by 5 Try to use the syntax shorcut like *= operator. <br>\n",
    "5. Print the result of value_1 and value_2 by using `print()` command. <br>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12.5\n",
      "102.5\n"
     ]
    }
   ],
   "source": [
    "#Start your code below:\n",
    "\n",
    "value_1 = 10\n",
    "value_2 = 20.5\n",
    "value_1 += 2.5\n",
    "value_2 *= 5\n",
    "print(value_1)\n",
    "print(value_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Conversion\n",
    "\n",
    "Is it possible to convert one type of value to another type of value? Totally! For example, <b> float()</b> command is used to convert an integer to a float and  <b>int()  </b>command is to convert a float to an integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.0"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(2.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pay attention to the <b>int()  </b>command and notice that 2.6 is rounded down to a 2. <b>int() </b> command will always round a float value down, even if the number after the decimal point is greater than five.\n",
    "\n",
    "However, we can also use `round() `command to properly round off a number, which follows the normal rounding rule."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(2.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(2.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(2.99)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Do you know it is possible and often encouraged to combine commands. For example, we can use `round()` inside a `print()` command. Notice the different output printed on the screen between a simple<b> round()</b> command and <b>print(round())</b>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "print(round(2.3))\n",
    "print(round(2.5))\n",
    "print(round(2.99))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(2.3)\n",
    "round(2.5)\n",
    "round(2.99)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another detail to pay attention to is that <b> round()</b> command doesn't change the value stored by a variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "variable_1 = 2.5\n",
    "print(round(2.5))\n",
    "round(2.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, if we assign the rounded value back to the variable, we are able to change the value stored in the variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "variable_1 =round(2.5)\n",
    "print(variable_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 1.2.6:\n",
    "1. Assign a value of 11.2 to a variable named value_1 <br>\n",
    "2. Assign a value of 2.5 to a variable named value_2 <br>\n",
    "3. Round the value of value_1 by using the `round()` command and try to assign the rounded value back to value_1 <br>\n",
    "4.Convert the value of value_2 from a float to an integer value using the `int()` command and assign the value back to value_2 <br>\n",
    "5. Print the result of value_1 and value_2 by using `print()` command. <br>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "# Start your code below:\n",
    "value_1 = 11.2\n",
    "value_2 = 2.5\n",
    "value_1 = round(value_1)\n",
    "value_2 = int(value_2)\n",
    "print(value_1)\n",
    "print(value_2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. Strings\n",
    "\n",
    "Up till now, we have only worked with <b> int </b> and <b> float</b> values. But in computer programming, there are many more types of values. \n",
    "Take a look at the table down below:\n",
    "\n",
    "\n",
    "| Track_name |  Price |  Currency |  Rating_count_total | User_rating|\n",
    "|------------|:------:|----------:|---------------------:|-----------:|\n",
    "| Facebook | 0.0 | USD | 2974676 | 3.5|\n",
    "| Instagram |    0.0  |   USD |2161558 |4.5|\n",
    "| Clash of Clans | 0.0|    USD | 2130805 |4.5|\n",
    "| Temple Run |    0.0  |   USD |1724546 |4.5|\n",
    "| Pandora - Music & Radio | 0.0|    USD | 1126879 |4.5|\n",
    "\n",
    "Data Source:  [Mobile App Store Data Set (Ramanathan Perumal)](https://www.kaggle.com/ramamet4/app-store-apple-data-set-10k-apps)</p>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see in the columns  <b> track_name </b> and <b> currency </b> for example, are consists of texts and not numbers. In Python, we can create text by using the quotation marks (\" \"):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Instagram\n",
      "USD\n"
     ]
    }
   ],
   "source": [
    "app_name = \"Instagram\"\n",
    "currency = \"USD\"\n",
    "\n",
    "print(app_name)\n",
    "print(currency)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Both double quotation marks (\" \") and single quotation mark (' ') are allowed in the Python syntax.\n",
    "To create the word \"Instagram\", we can use either \"Instagram\", or 'Instagram'. The values surrounded by quotation marks are called strings and in Python it is presented as the <b> str </b> type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type('Instagram')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, strings are not only limited to letters. It is also possible to use numbers, space, or other characters. See example below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My Bank\n",
      "number is 123456789\n"
     ]
    }
   ],
   "source": [
    "bank = 'My Bank'\n",
    "number = 'number is 123456789'\n",
    "\n",
    "print(bank)\n",
    "print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 1.2.7:\n",
    "1. Assign the string <b> Instagram </b> to a variable named  <b>app_name </b>. <br>\n",
    "2. Assign  the string  <b> 4.5 </b>to a variable named <b> average_rating </b>. <br>\n",
    "3. Assign the string <b> 2161158  </b>to a variable named  <b>total_ratings </b>. <br>\n",
    "4. Assign the string  <b>data  </b>to a variable named  <b>value </b>. <br>\n",
    "5. Display the <b> app_name </b> variable using <b> print() </b> command. <br>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Instagram\n"
     ]
    }
   ],
   "source": [
    "# Start your code below:\n",
    "\n",
    "app_name = \"Instagram\"\n",
    "average_rating = \"4.5\"\n",
    "total_ratings = \"2161158\"\n",
    "value = \"data\"\n",
    "print(app_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}