# Internal working of python program

# What is *Variable* ?

In Python, a variable is a named reference to a value. It's like a container that holds information, and you can change what's stored in it throughout your program. For example, you can have a variable named "x" and assign it a value like 5: `x = 5`. Later in the program, you can change the value of "x" to something else, like `x = 10`.

## What is keywords ?

In Python, keywords are reserved words that have special meanings and purposes. These keywords cannot be used as identifiers (such as variable names or function names) because they are part of the language syntax. Examples of Python keywords include `if`, `else`, `while`, `for`, `def`, `class`, `import`, `and`, `or`, `not`, etc.

### What is operator?

In programming, operators are symbols or keywords that perform operations on one or more operands. Operators are used to perform mathematical, logical, or comparison operations in a program. Examples of operators in Python include arithmetic operators like `+`, `-`, `*`, `/`, logical operators like `and`, `or`, `not`, and comparison operators like `==`, `!=`, `<`, `>`, etc.

### How many types of operator?

Operators in Python can be categorized into several types based on their functionality:

1. Arithmetic Operators: These operators are used to perform mathematical operations like addition, subtraction, multiplication, division, etc. Example: `+`, `-`, `*`, `/`, `%`, `//`
    
2. Assignment Operators: These operators are used to assign values to variables. Example: `=`, `+=`, `-=`, `*=`, `/=`, `%=`, `//=`
    
3. Comparison Operators: These operators are used to compare two values and return a Boolean result. Example: `==`, `!=`, `<`, `>`, `<=`, `>=`
    
4. Logical Operators: These operators are used to perform logical operations on Boolean values. Example: `and`, `or`, `not`
    
5. Identity Operators: These operators are used to check if two variables refer to the same object. Example: `is`, `is not`
    
6. Membership Operators: These operators are used to test if a value is present in a sequence (like a list, tuple, or string). Example: `in`, `not in`
    
7. Bitwise Operators: These operators are used to perform bitwise operations on integers. Example: `&`, `|`, `^`, `<<`, `>>`, `~`
    

These are the main types of operators in Python, each serving different purposes in programming.

### *What is control flow in Phython?*

### Sure, here's a brief explanation of control flow in Python with a diagram presented in point form:

1. **Sequential Execution**:
    
    * Code executes line by line, from top to bottom.
        
2. **Conditional Statements** (if, elif, else):
    
    * Decision-making structures based on conditions.
        
    * If condition is true, corresponding block of code executes.
        
    * If condition is false, optional else block may execute.
        
    * Diagram:
        
        ```plaintext
        if condition:
            # Code block A
        elif condition:
            # Code block B
        else:
            # Code block C
        ```
        
3. **Looping Statements** (for, while):
    
    * Repeated execution of a block of code.
        
    * `for` loop iterates over a sequence.
        
    * `while` loop repeats as long as a condition is true.
        
    * Diagram:
        
        ```plaintext
        for item in sequence:
            # Code block
            
        while condition:
            # Code block
        ```
        
4. **Break and Continue**:
    
    * `break` statement exits the loop prematurely.
        
    * `continue` statement skips the rest of the loop and continues with the next iteration.
        
    * Diagram:
        
        ```plaintext
        for item in sequence:
            if condition:
                break  # Exits loop
            if condition:
                continue  # Skips rest of loop iteration
        ```
        
5. **Exception Handling** (try, except, finally):
    
    * Handles errors gracefully.
        
    * `try` block contains code that might raise an exception.
        
    * `except` block catches and handles exceptions.
        
    * `finally` block executes regardless of whether an exception occurred.
        
    * Diagram:
        
        ```plaintext
        try:
            # Code that might raise an exception
        except ExceptionType:
            # Handle exception
        finally:
            # Optional cleanup code
        ```
        

Would you like me to elaborate on any specific point or provide a visual diagram?