008_Python_Literals.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<small><small><i>\n",
    "All the IPython Notebooks in **Python Introduction** lecture series by **[Dr. Milaan Parmar](https://www.linkedin.com/in/milaanparmar/)** are available @ **[GitHub](https://github.com/milaan9/01_Python_Introduction)**\n",
    "</i></small></small>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Literals\n",
    "\n",
    "**Literal** is a raw data given in a **variable** or **constant**. In Python, there are various types of literals they are as follows:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Numeric Literals\n",
    "\n",
    "Numeric Literals are **immutable (unchangeable)**. Numeric literals can belong to 3 different numerical types **`Integer`**, **`Float`** and **`Complex`**.\n",
    "\n",
    "<div>\n",
    "<img src=\"img/li0.png\" width=\"500\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Number data types in Python:\n",
    "\n",
    "1. Integers: Integer(negative, zero and positive) numbers\n",
    "   - Example:\n",
    "       - ... -3, -2, -1, 0, 1, 2, 3 ...\n",
    "\n",
    "\n",
    "2. Floating Point Numbers(Decimal numbers)\n",
    "   - Example:\n",
    "       - ... -3.5, -2.25, -1.0, 0.0, 1.1, 2.2, 3.5 ...\n",
    "\n",
    "\n",
    "3. Complex Numbers\n",
    "   - Example:\n",
    "       - 1 + j, 2 + 3j, 1 - 1j"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T07:56:41.965572Z",
     "start_time": "2021-10-02T07:56:41.949947Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 100 200 300\n",
      "10 99\n",
      "10.5 150.0\n",
      "3.14j 3.14 0.0\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "a = 0b1010 #Binary Literals\n",
    "b = 100 #Decimal Literal\n",
    "c = 0o310 #Octal Literal\n",
    "d = 0x12c #Hexadecimal Literal\n",
    "\n",
    "# Integer Literal\n",
    "int_1 = 10\n",
    "int_2 = 99\n",
    "\n",
    "\n",
    "# Float Literal\n",
    "float_1 = 10.5\n",
    "float_2 = 1.5e2\n",
    "\n",
    "\n",
    "# Complex Literal\n",
    "x = 3.14j\n",
    "\n",
    "print(a, b, c, d)\n",
    "print(int_1, int_2)\n",
    "print(float_1, float_2)\n",
    "print(x, x.imag, x.real)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above program\n",
    "\n",
    "* We assigned integer literals into different variables. Here, **`a`** is **binary** literal, **`b`** is a **decimal** literal,**`c`** is an **octal** literal and **`d`** is a **hexadecimal** literal.\n",
    "\n",
    "* When we print the variables, all the literals are converted into **decimal** values.\n",
    "\n",
    "* **`10.5`** and **`1.5e2`** are **floating point** literals. **`1.5e2`** is **expressed** with **exponential** and is **equivalent** to **`1.5 * 10^2`**.\n",
    "\n",
    "* We assigned a complex literal i.e **`3.14j`** in variable **`x`**. Then we use **imaginary** literal (x.imag) and **real** literal (x.real) to create imaginary and real part of **complex number**. \n",
    "\n",
    "To learn more about Numeric Literals, refer to **[Python Numbers](https://github.com/milaan9/02_Python_Datatypes/blob/main/001_Python_Numbers.ipynb)**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Type Conversion of Numbers in Python\n",
    "\n",
    "As a programmer, you can convert a variable of any data type to Number data types in Python using the below Python inbuilt functions. Also, using these functions, you can convert a number from one Number data type to another i.e from int to float, float to decimal, decimal to int and so on.\n",
    "\n",
    "* **`int ()`** : This function converts any data type to integer data type.\n",
    "* **`float ()`** : This function converts any data type to float data type.\n",
    "* **`complex (real, imaginary)`** or **`complex (real)`** : This function converts any data type to complex data type.\n",
    "\n",
    "> **Note**: There is no 'long' integer in Python 3, int and long are unified now. This means int behave more like long. Sample program showing type conversion of Numbers in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T07:56:41.980222Z",
     "start_time": "2021-10-02T07:56:41.968501Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "19\n",
      "3.7\n",
      "(3.7+0j)\n",
      "(19.16+0j)\n",
      "(3.7+19.16j)\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "a = 3.7\n",
    "b = 19.16\n",
    "c = 3 + 27j\n",
    "\n",
    "#converting float to int\n",
    "print (int(b))\n",
    "\n",
    "#converting int to float\n",
    "print (float(a))\n",
    "\n",
    "#converting int to complex\n",
    "print (complex(a))\n",
    "\n",
    "#converting float to complex\n",
    "print (complex(b))\n",
    "\n",
    "#converting to complex\n",
    "print (complex(a, b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. String literals (unicode character strings)\n",
    "\n",
    "A **string** literal is a **sequence of characters** surrounded by **quotes**. We can use both **single**, **double** or **triple** quotes for a string. And, a **character literal** is a single character surrounded by single or double quotes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T07:56:42.487053Z",
     "start_time": "2021-10-02T07:56:41.990964Z"
    }
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'Apple' 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<ipython-input-3-ee80ca1a52c8>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      9\u001b[0m \u001b[0md\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"Apple\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     10\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 11\u001b[1;33m \u001b[0me\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mApple\u001b[0m     \u001b[1;31m# cannot write string with out quotes ('', \" \", \"\"\" \"\"\", ''' ''')\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     12\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     13\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'Apple' is not defined"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "a = '''Apple'''\n",
    "\n",
    "b = \"\"\"Apple\"\"\"\n",
    "\n",
    "c = 'Apple'\n",
    "\n",
    "d = \"Apple\"\n",
    "\n",
    "e = Apple     # cannot write string with out quotes ('', \" \", \"\"\" \"\"\", ''' ''')\n",
    "\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)\n",
    "print(d)\n",
    "print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T07:56:53.085188Z",
     "start_time": "2021-10-02T07:56:53.065659Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is Python\n",
      "C\n",
      "This is a multiline string with more than one line code.\n",
      "Ünicöde\n",
      "raw \\n string\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "strings = \"This is Python\"\n",
    "char = \"C\"\n",
    "multiline_str = \"\"\"This is a multiline string with more than one line code.\"\"\"\n",
    "unicode = u\"\\u00dcnic\\u00f6de\"\n",
    "raw_str = r\"raw \\n string\"\n",
    "\n",
    "print(strings)\n",
    "print(char)\n",
    "print(multiline_str)\n",
    "print(unicode)\n",
    "print(raw_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above program, \n",
    "\n",
    "* **`This is Python`** is a string literal and **`C`** is a **character** literal. \n",
    "\n",
    "* The value with **triple-quote \"\"\"** assigned in the **`multiline_str`** is **multi-line** string literal.\n",
    "\n",
    "* The **`u\"\\u00dcnic\\u00f6de\"`** is a **unicode literal** which supports characters other than English. In this case, **`\\u00dc`** represents **`Ü`** and **`\\u00f6`** represents **`ö`**.\n",
    "\n",
    "* **`r\"raw \\n string\"`** is a raw string literal."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Boolean literals\n",
    "\n",
    "A Boolean literal can have any of the two values: **`True`** or **`False`**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T07:56:53.639879Z",
     "start_time": "2021-10-02T07:56:53.626204Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is True\n",
      "y is False\n",
      "a: 7\n",
      "b: 90\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "#REMEMBER  True == 1   False == 0\n",
    "\n",
    "x = (1 == True)\n",
    "y = (1 == False)\n",
    "a = True + 6\n",
    "b = False + 90\n",
    "\n",
    "print(\"x is\", x)\n",
    "print(\"y is\", y)\n",
    "print(\"a:\", a)\n",
    "print(\"b:\", b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above program, we use boolean literal **`True`** and **`False`**. In Python, **`True`** represents the value as **`1` and `False` as `0`**. The value of `x` is `True` because **`1` is equal to `True`**. And, the value of **`y`** is **`False`** because **`1` is not equal to `False`**.\n",
    "\n",
    "Similarly, we can use the **`True`** and **`False`** in numeric expressions as the value. The value of **`a`** is **`6`** because we add **`True`** which has value of **`1` with `6`**. Similarly, **`b`** is **`90`** because we add the **`False`** having value of **`0` with `90`**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T07:56:54.023664Z",
     "start_time": "2021-10-02T07:56:54.009994Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Triple quotes (also with '''), allow strings to break over multiple lines.\n",
      "Alternatively \n",
      " is a newline character (\t for tab, \\ is a single backslash)\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "9.0           # a simple floating point number\n",
    "1e100         # a googol as floating point number\n",
    "-1234567890   # an integer\n",
    "True or False # the two possible boolean values\n",
    "'This is a string'\n",
    "\"It's another string\"\n",
    "print(\"\"\"Triple quotes (also with '''), allow strings to break over multiple lines.\n",
    "Alternatively \\n is a newline character (\\t for tab, \\\\ is a single backslash)\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python also has complex numbers that can be written as follows. Note that the **`( )`** brackets or parentheses are required."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T07:56:54.425520Z",
     "start_time": "2021-10-02T07:56:54.416732Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1+2j)\n",
      "(1+2j)\n"
     ]
    }
   ],
   "source": [
    "complex_number1 = complex(1,2)\n",
    "print(complex_number1)\n",
    "\n",
    "complex_number2 = (1.0+2j) # the same number as above\n",
    "print(complex_number2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Special literals\n",
    "\n",
    "Python contains one **special** literal i.e., **`None`**. We use it to specify to that field that is not created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T07:56:54.823957Z",
     "start_time": "2021-10-02T07:56:54.812240Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Available\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "juice = \"Available\"\n",
    "soup = None\n",
    "def menu(x):\n",
    "    if x == juice:\n",
    "        print(juice)\n",
    "    else:\n",
    "        print(soup)\n",
    "menu(juice)\n",
    "menu(soup)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above program, we define a **`menu` function**. Inside **`menu`**, when we set parameter as **`drink`** then, it displays **`Available`**. And, when the parameter is **`food`**, it displays **`None`**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Literal Collections\n",
    "\n",
    "There are four different literal collections **List literals, Tuple literals, Dict literals**, and **Set literals**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T07:56:55.311263Z",
     "start_time": "2021-10-02T07:56:55.288834Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Banana', 'Apple', 'Strawberry')\n",
      "['Banana', 'Apple', 'Strawberry']\n",
      "{'Apple', 'Strawberry', 'Banana'}\n",
      "{'1': 'Banana', '2': 'Apple', '3': 'Strawberry'}\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "fruits1 = (\"Banana\", \"Apple\", \"Strawberry\")             # tuple ()\n",
    "fruits2 = [\"Banana\", \"Apple\", \"Strawberry\"]             # list []\n",
    "fruits3 = {\"Banana\", \"Apple\", \"Strawberry\"}             # set {}\n",
    "fruits4 = {\"1\":\"Banana\", \"2\":\"Apple\", \"3\":\"Strawberry\"} # dictionary {\"Key\":\"Value\"}\n",
    "\n",
    "print(fruits1)\n",
    "print(fruits2)\n",
    "print(fruits3)\n",
    "print(fruits4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T07:56:55.723859Z",
     "start_time": "2021-10-02T07:56:55.715559Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 'mango', 'orange']\n",
      "(1, 2, 3)\n",
      "{'a': 'apple', 'b': 'ball', 'c': 'cat'}\n",
      "{'u', 'e', 'o', 'a', 'i'}\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "fruits = [\"apple\", \"mango\", \"orange\"] #list\n",
    "numbers = (1, 2, 3) #tuple\n",
    "alphabets = {'a':'apple', 'b':'ball', 'c':'cat'} #dictionary\n",
    "vowels = {'a', 'e', 'i' , 'o', 'u'} #set\n",
    "\n",
    "print(fruits)\n",
    "print(numbers)\n",
    "print(alphabets)\n",
    "print(vowels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above program, we created a list of **`fruits`, tuple** of **`numbers`, `dictionary` dict** having values with **keys desginated** to each value and **set** of **`vowels`**.\n",
    "\n",
    ">**Note**: To learn more about literal collections, refer to **[Python Data Types](https://github.com/milaan9/01_Python_Introduction/blob/main/009_Python_Data_Types.ipynb)**."
   ]
  },
  {
   "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.10.9"
  },
  "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": false
  },
  "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": 2
}