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

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Variables and Constants\n",
    "\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,\n",
    "\n",
    "```python\n",
    "number = 10\n",
    "```\n",
    "\n",
    "- 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",
    "```python\n",
    "number = 10\n",
    "number = 1.1\n",
    "```\n",
    "\n",
    "- Initially, the value of the number was 10. Later, it was changed to 1.1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "--------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Assigning values to Variables in Python\n",
    "\n",
    "- As you can see from the above example, you can use the assignment operator `=` to assign a value to a variable\n",
    "    \n",
    "    ```python\n",
    "    website = \"apple.com\"\n",
    "    print(website)\n",
    "    ```\n",
    "    \n",
    "    **Output**\n",
    "    \n",
    "    ```python\n",
    "    apple.com\n",
    "    ```\n",
    "    \n",
    "    In the above program, we assigned a value apple.com to the variable website. Then, we printed out the value assigned to website i.e. apple.com\n",
    "    \n",
    "    **Note**: Python is a type-inferred language, so you don't have to explicitly define the variable type. It automatically knows that apple.com is a string and declares the website variable as a string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Example: Changing the value of a variable\n",
    "\n",
    "- Changing value\n",
    "    \n",
    "    ```python\n",
    "    website = \"apple.com\"\n",
    "    print(website)\n",
    "    \n",
    "    # assigning a new value to website\n",
    "    website = \"programiz.com\"\n",
    "    \n",
    "    print(website)\n",
    "    \n",
    "    ```\n",
    "    \n",
    "    **Output**\n",
    "    \n",
    "    ```python\n",
    "    apple.com\n",
    "    programiz.com\n",
    "    \n",
    "    ```\n",
    "    \n",
    "    In the above program, we have assigned apple.com to the website variable initially. 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",
    "\n",
    "- Assigning multiple values\n",
    "    \n",
    "    ```python\n",
    "    a, b, c = 5, 3.2, \"Hello\"\n",
    "    \n",
    "    print (a)\n",
    "    print (b)\n",
    "    print (c)\n",
    "    ```\n",
    "    \n",
    "    If we want to assign the same value to multiple variables at once, we can do this as:\n",
    "    \n",
    "    ```python\n",
    "    x = y = z = \"same\"\n",
    "    \n",
    "    print (x)\n",
    "    print (y)\n",
    "    print (z)\n",
    "    ```\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",
    "\n",
    "- A constant is a type of variable whose value cannot be changed.\n",
    "    \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.\n",
    "    \n",
    "    ---\n",
    "    \n",
    "    **Assigning value to constant in Python**\n",
    "    \n",
    "    In Python, constants are usually declared and assigned in a module. Here, the module is a new file containing variables, functions, etc which is imported to the main file. 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",
    "    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",
    "\n",
    "- Literal is raw data given in a variable or constant.\n",
    "    \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). Numeric literals can belong to 3 different numerical types: `Integer`, `Float`, and `Complex`.\n",
    "\n",
    "**How to use Numeric literals in Python?**\n",
    "\n",
    "```python\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)\n",
    "\n",
    "```\n",
    "\n",
    "**Output**\n",
    "\n",
    "```python\n",
    "10 100 200 300\n",
    "10.5 150.0\n",
    "3.14j 3.14 0.0\n",
    "```"
   ]
  },
  {
   "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?\n",
    "\n",
    "```python\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)\n",
    "\n",
    "```\n",
    "\n",
    "**Output**\n",
    "\n",
    "```python\n",
    "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",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "--------\n",
    "\n",
    "### 6.3 Boolean Literals\n",
    "\n",
    "A Boolean literal can have any of the two values: `True` or `False`.\n",
    "\n",
    "**Example 8: How to use boolean literals in Python?**\n",
    "\n",
    "```python\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)\n",
    "\n",
    "```\n",
    "\n",
    "**Output**\n",
    "\n",
    "```python\n",
    "x is True\n",
    "y is False\n",
    "a: 5\n",
    "b: 10\n",
    "```\n",
    "\n",
    "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 5 because we add `True` which has a value of 1 with 4. Similarly, b is 10 because we add the `False` having value of 0 with 10."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----------\n",
    "\n",
    "### 6.4 Special Literals\n",
    "\n",
    "Python contains one special literal i.e. `None`. We use it to specify that the field has not been created.\n",
    "\n",
    "**Example 9: How to use special literals in Python?**\n",
    "\n",
    "```python\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)\n",
    "\n",
    "```\n",
    "\n",
    "**Output**\n",
    "\n",
    "```python\n",
    "Available\n",
    "None\n",
    "\n",
    "```\n",
    "\n",
    "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",
    "\n",
    "There are four different literal collections List literals, Tuple literals, Dict literals, and Set literals.\n",
    "\n",
    "Example 10: How to use literals collections in Python?\n",
    "\n",
    "```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",
    "\n",
    "Output\n",
    "\n",
    "```python\n",
    "['apple', 'mango', 'orange']\n",
    "(1, 2, 3)\n",
    "{'a': 'apple', 'b': 'ball', 'c': 'cat'}\n",
    "{'e', 'a', 'o', 'i', 'u'}\n",
    "```\n",
    "\n",
    "In the above program, we created a list of fruits, a tuple of numbers, 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
}