1. Python_Introduction/.ipynb_checkpoints/2. Variables_and_Constants-checkpoint.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Variables and Constants\n",
    "A variable is a named location used to store data in the memory.\n",
    "It is helpful to think of variables as a container that holds data that can be changed later in the program. For example,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "#Here, we have created a variable named number. We have assigned the value 10 to the variable.\n",
    "#You can think of variables as a bag to store books in it and that book can be replaced at any time.\n",
    "\n",
    "number = 10\n",
    "print(number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.1\n"
     ]
    }
   ],
   "source": [
    "#Initially, the value of the number was 10. Later, it was changed to 1.1.\n",
    "number = 10\n",
    "number = 1.1\n",
    "print(number)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "--------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Assigning values to Variables in Python\n",
    "As you can see from the above example, you can use the assignment operator `=` to assign a value to a variable    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple.com\n"
     ]
    }
   ],
   "source": [
    "#In the above program, we assigned a value apple.com to the variable website. \n",
    "#Then, we printed out the value assigned to website i.e. apple.com\n",
    "#Python is a type-inferred language, so you don't have to explicitly define the variable type. \n",
    "#It automatically knows that apple.com is a string and declares the website variable as a string.\n",
    "\n",
    "website = \"apple.com\"\n",
    "print(website)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Example: Changing the value of a variable\n",
    "Changing value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple.com\n",
      "programiz.com\n"
     ]
    }
   ],
   "source": [
    "website = \"apple.com\"\n",
    "print(website)\n",
    "    \n",
    "# assigning a new value to website\n",
    "website = \"programiz.com\"\n",
    "    \n",
    "print(website)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#In the above program, we have assigned apple.com to the website variable initially. \n",
    "#Then, the value is changed to programiz.com."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Example: Assigning multiple values to multiple variables\n",
    "Assigning multiple values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "3.2\n",
      "Hello\n"
     ]
    }
   ],
   "source": [
    "a, b, c = 5, 3.2, \"Hello\"\n",
    "    \n",
    "print (a)\n",
    "print (b)\n",
    "print (c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "same\n",
      "same\n",
      "same\n"
     ]
    }
   ],
   "source": [
    "#If we want to assign the same value to multiple variables at once, we can do this as:\n",
    "x = y = z = \"same\"    \n",
    "print (x)\n",
    "print (y)\n",
    "print (z)\n",
    "    \n",
    "#The second program assigns the same string to all the three variables x, y, and z."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-----------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Constants\n",
    "A constant is a type of variable whose value cannot be changed.\n",
    "It is helpful to think of constants as containers that hold information which cannot be changed later.\n",
    "    \n",
    "You can think of constants as a bag to store some books which cannot be replaced once placed inside the bag."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#Assigning value to constant in Python\n",
    "#In Python, constants are usually declared and assigned in a module. \n",
    "#Here, the module is a new file containing variables, functions, etc which is imported to the main file. \n",
    "#Inside the module, constants are written in all capital letters and underscores separating the words.\n",
    "\n",
    "**Example 3: Declaring and assigning value to a constant**\n",
    "\n",
    "Create a **constant.py**:\n",
    "\n",
    "```python\n",
    "PI = 3.14\n",
    "GRAVITY = 9.8\n",
    "```\n",
    "\n",
    "Create a **main.py**:\n",
    "\n",
    "```python\n",
    "import constant\n",
    "\n",
    "print(constant.PI)\n",
    "print(constant.GRAVITY)\n",
    "```\n",
    "\n",
    "**Output**\n",
    "\n",
    "```python\n",
    "3.14\n",
    "9.8\n",
    "```\n",
    "    \n",
    "    \n",
    "    \n",
    "In the above program, we create a **constant.py** module file. Then, we assign the constant value to PI and GRAVITY. After that, we create a **main.py** file and import the `constant` module. Finally, we print the constant value.\n",
    "    \n",
    "**Note**: In reality, we don't use constants in Python. Naming them in all capital letters is a convention to separate them from variables, however, it does not actually prevent reassignment."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Literals\n",
    "Literal is raw data given in a variable or constant.\n",
    "In Python, there are various types of literals they are as follows:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------\n",
    "\n",
    "### 6.1 Numeric Literals\n",
    "\n",
    "Numeric Literals are immutable (unchangeable). \n",
    "Numeric literals can belong to 3 different numerical types: `Integer`, `Float`, and `Complex`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 100 200 300\n",
      "10.5 150.0\n",
      "3.14j 3.14 0.0\n"
     ]
    }
   ],
   "source": [
    "#How to use Numeric literals in Python?\n",
    "\n",
    "a = 0b1010 #Binary Literals\n",
    "b = 100 #Decimal Literal\n",
    "c = 0o310 #Octal Literal\n",
    "d = 0x12c #Hexadecimal Literal\n",
    "\n",
    "#Float Literal\n",
    "float_1 = 10.5\n",
    "float_2 = 1.5e2\n",
    "\n",
    "#Complex Literal\n",
    "x = 3.14j\n",
    "\n",
    "print(a, b, c, d)\n",
    "print(float_1, float_2)\n",
    "print(x, x.imag, x.real)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "--------\n",
    "### 6.2 String Literals\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.\n",
    "\n",
    "Example: How to use string literals in Python?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "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": [
    "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": [
    "--------\n",
    "\n",
    "### 6.3 Boolean Literals\n",
    "A Boolean literal can have any of the two values: `True` or `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is True\n",
      "y is False\n",
      "a: 5\n",
      "b: 10\n"
     ]
    }
   ],
   "source": [
    "#Example 8: How to use boolean literals in Python?\n",
    "\n",
    "x = (1 == True)\n",
    "y = (1 == False)\n",
    "a = True + 4\n",
    "b = False + 10\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`. \n",
    "In Python, `True` represents the value as 1 and `False` as 0. \n",
    "The value of x is `True` because 1 is equal to `True`. \n",
    "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. \n",
    "The value of a is 5 because we add `True` which has a value of 1 with 4. \n",
    "Similarly, b is 10 because we add the `False` having value of 0 with 10.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----------\n",
    "\n",
    "### 6.4 Special Literals\n",
    "Python contains one special literal i.e. `None`. We use it to specify that the field has not been created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Available\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "#Example 9: How to use special literals in Python?\n",
    "\n",
    "\n",
    "drink = \"Available\"\n",
    "food = None\n",
    "\n",
    "def menu(x):\n",
    "    if x == drink:\n",
    "        print(drink)\n",
    "    else:\n",
    "        print(food)\n",
    "\n",
    "menu(drink)\n",
    "menu(food)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above program, we define a `menu` function. Inside `menu`, when we set the argument as `drink` then, it displays `Available`. And, when the argument is `food`, it displays `None`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------\n",
    "\n",
    "### 6.5 Literal Collections\n",
    "There are four different literal collections List literals, Tuple literals, Dict literals, and Set literals."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 'mango', 'orange']\n",
      "(1, 2, 3)\n",
      "{'a': 'apple', 'b': 'ball', 'c': 'cat'}\n",
      "{'o', 'u', 'a', 'i', 'e'}\n"
     ]
    }
   ],
   "source": [
    "#Example 10: How to use literals collections in Python?\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)\n",
    "\n",
    "#In the above program, we created a list of fruits, a tuple of numbers, \n",
    "#a dictionary dict having values with keys designated to each value and a set of vowels."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**End of Document**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}