Introduction of python

Introduction to Python

Python is a high-level interpreted programming language created by Guido van Rossum and first released in 1991. Python's syntax is designed to be straightforward and human-readable as well as more flexible than other programming languages, making it an ideal language for beginners. However, Python will generally run more slowly than compiled programming languages because of its interpreted nature.

What is a Programming Language?

A programming language is like a set of instructions or rules that humans can use to tell a computer what to do. It is a way to communicate with the computer, using a special language that both you and the computer can understand.

Compiled vs. Interpreted Languages

A compiled language translates the source code all at once by a compiler into a language that the computer can understand. On the other hand, an interpreted language translates the source code on the fly, line by line, as the program runs using an interpreter.

General-Purpose Language

General-purpose languages, like Python, are crafted to handle a wide range of applications across diverse domains. In contrast, domain-specific languages (DSLs) such as SQL and HTML are honed for particular tasks, like database queries and web content structuring, respectively. This specialization allows DSLs to offer a steeper learning curve, letting individuals grasp their intricacies quickly. However, while you could mold Python to suit various needs, from web development to scientific computing, a DSL remains confined to its core purpose; one wouldn't, for instance, turn to SQL to craft a mobile application.

Introduction to Python 6

Introduction

Python's clear syntax and extensive standard libraries make it adaptable for a wide range of tasks without being specialized for any single one.

Versatility

Python can be combined with other languages (e.g., C, C++, Java) to enhance its capabilities. This ensures that Python can harness the strengths of specialized languages when needed.

Extensibility

Python's emphasis on simplicity, with its clear syntax, promotes good coding practices. This readability fosters easier collaboration among developers from diverse backgrounds.

Readability

Python's interpreted nature and high-level constructs enable quick iteration and prototyping, which is invaluable in research and development phases.

Versions of Python

Python's Versions

Introduction to Python 10

Introduction

Python 1.0 (1991)

Python 1 marked the beginning of a language designed for readability, simplicity, and ease of use, aiming to strike a balance between low-level languages (like C) and shell scripting.

Python 2.0 (2000)

Python 2 made programming in Python smoother and more efficient. It vastly expanded and enriched its toolkit, making a wider range of tasks achievable right out of the box.

Python 3.0

Python 3 aimed to correct inconsistencies and design flaws, even if it meant breaking backward compatibility. It eliminated outdated ways of doing things, promoting more modern and intuitive methods.

Python 3.11

Python 3's subsequent versions have consistently refined the language. This period has seen Python embrace modern programming paradigms, expand its library, enhance performance, and adapt to user needs and global tech trends.

Variables and Types

Variables and Types in Python

Introduction

In Python, a variable acts as a symbolic name referencing an object. Variables are utilized to store data that can be accessed and modified throughout a program's execution. Python is dynamically typed, meaning the type of a variable is inferred at runtime, eliminating the need for explicit type declaration upon assignment.

Variable Naming Rules

• Start with a Letter or Underscore: Variable names must begin with a letter (a-z, A-Z) or an underscore (_). For example, name and _private_var are valid, while 1name is not.


• No Spaces: Variable names cannot contain spaces. Instead of user name, use user_name.


• Case Sensitivity: Variable names are case-sensitive, meaning Username and username are treated as different variables.


• Avoid Reserved Keywords: Do not use reserved keywords (e.g., if, else, for, etc.) as variable names since they have special meanings in Python.

Data Types

Python includes several built-in data types that can be categorized into the following classes:

• Numeric Types: Comprising int (integer), float (floating-point number), and complex (complex numbers).


• Sequence Types: Including list, tuple, and range.


• Text Type: Represented by str (string).


• Mapping Type: Represented by dict (dictionary).


• Set Types: Including set and frozenset.


• Boolean Type: Represented by bool (True or False).


• Binary Types: Including bytes, bytearray, and memoryview.

Examples

1. Numeric Types

my_integer = 10                # Integer
my_float = 10.5                  # Float
my_complex = 1 + 2j              # Complex Number

print(type(my_integer))  # Output: 
print(type(my_float))    # Output: 
print(type(my_complex))  # Output: 

2. String Type

my_string = "Hello, Python!"
print(type(my_string))  # Output: 

3. List Type

my_list = [1, 2, 3, 4, 5]
print(type(my_list))    # Output: 

4. Dictionary Type

my_dict = {"name": "Alice", "age": 30}
print(type(my_dict))    # Output: 

5. Boolean Type

is_active = True
print(type(is_active))   # Output: 

Dynamic Typing and Built-in Functions in Python

Dynamic Typing

Python is a dynamically typed language, which means that the type of a variable is determined at runtime and can change as the program executes. You do not need to declare the variable's type explicitly when you assign a value to it. This allows for more flexibility, but it can also lead to runtime errors if you attempt to perform operations on incompatible types.

Example of Dynamic Typing

my_var = 10          # Initially an integer
print(type(my_var))    # Output: 

my_var = "Hello"       # Now it's a string
print(type(my_var))    # Output: 

Built-in Functions in Python

Python provides a variety of built-in functions that are readily available for use. These functions perform common tasks, helping to reduce the amount of code you need to write. Some essential built-in functions include print(), type(), conversion functions, and input().

1. Print Function

The print() function outputs data to the console. It can take multiple arguments and has several parameters for formatting the output.

Example of Print Function

name = "Alice"
age = 30
print("Name:", name, "| Age:", age)  # Output: Name: Alice | Age: 30

2. Type Function

The type() function returns the type of an object. This is useful for debugging and understanding the data types being used in your program.

Example of Type Function

my_var = 10.5
print(type(my_var))  # Output: 

3. Conversion Functions

Python provides several built-in functions for converting data from one type to another. Common conversion functions include:

• int(): Converts a value to an integer.


• float(): Converts a value to a floating-point number.


• str(): Converts a value to a string.

Example of Conversion Functions

num = "5.5"
int_num = int(float(num))  # Convert string to float, then to integer
print(int_num)              # Output: 5

float_num = float("3.14")
print(float_num)            # Output: 3.14

string_num = str(100)
print(string_num)           # Output: '100'

4. Input Function

The input() function allows users to enter data. The input is returned as a string, and you can convert it to other types if needed.

Example of Input Function

user_name = input("Enter your name: ")
print("Hello,", user_name)  # If the user inputs "Bob", the output will be: Hello, Bob

Numerical Operators and Variables

1. Numerical Operators

Numerical operators in Python are used to perform arithmetic operations. The basic operators include:

• Addition (+): Adds two numbers.


• Subtraction (-): Subtracts the second number from the first.


• Multiplication (*): Multiplies two numbers.


• Division (/): Divides the first number by the second (result is a float).


• Floor Division (//): Divides and returns the largest integer less than or equal to the result.


• Modulus (%): Returns the remainder of a division operation.


• Exponentiation (**): Raises the first number to the power of the second.

Example of Numerical Operators

a = 10
b = 3

# Performing operations
addition = a + b               # 13
subtraction = a - b            # 7
multiplication = a * b         # 30
division = a / b               # 3.333...
floor_division = a // b        # 3
modulus = a % b                # 1
exponentiation = a ** b       # 1000

print(addition, subtraction, multiplication, division, floor_division, modulus, exponentiation)

2. Variables from Operations - Numbers

Variables can be created and assigned values based on the results of numerical operations. This allows for dynamic calculations and easy manipulation of numerical data.

Example of Variables from Operations - Numbers

x = 5
y = 10

result = x * y                # Multiply x and y
total = result + 15           # Add 15 to the result

print("Result:", result)      # Output: Result: 50
print("Total:", total)        # Output: Total: 65

3. Variables from Operations - Strings

In Python, strings can also be manipulated using operators. The common operations for strings include concatenation and repetition.

Example of Variables from Operations - Strings

first_name = "John"
last_name = "Doe"

full_name = first_name + " " + last_name   # Concatenation
repeated_name = first_name * 3               # Repeating the string

print("Full Name:", full_name)               # Output: Full Name: John Doe
print("Repeated Name:", repeated_name)       # Output: Repeated Name: JohnJohnJohn

4. Multiple & Chained Assignments

In Python, you can assign a single value to multiple variables in one line. This is called multiple assignment. Chained assignment allows you to assign the same value to multiple variables in a single statement.

Example of Multiple Assignment

a, b, c = 1, 2, 3
print(a, b, c)  # Output: 1 2 3

Example of Chained Assignment

x = y = z = 5
print(x, y, z)  # Output: 5 5 5

5. Math Functions for Numbers

Python provides a variety of built-in math functions in the math module that allow for advanced mathematical operations. Some common functions include:

• math.sqrt(x): Returns the square root of x.


• math.pow(x, y): Returns x raised to the power of y.


• math.ceil(x): Returns the smallest integer greater than or equal to x.


• math.floor(x): Returns the largest integer less than or equal to x.


• math.fabs(x): Returns the absolute value of x.

Example of Math Functions for Numbers

import math

number = 16
square_root = math.sqrt(number)               # Square root
power = math.pow(2, 3)                         # Exponentiation
ceil_value = math.ceil(4.2)                    # Ceiling value
floor_value = math.floor(4.7)                  # Floor value
absolute_value = math.fabs(-10)                # Absolute value

print("Square Root:", square_root)             # Output: Square Root: 4.0
print("Power:", power)                          # Output: Power: 8.0
print("Ceiling Value:", ceil_value)             # Output: Ceiling Value: 5
print("Floor Value:", floor_value)               # Output: Floor Value: 4
print("Absolute Value:", absolute_value)         # Output: Absolute Value: 10.0

Conclusion

Understanding numerical operators, string operations, variable assignments, and mathematical functions is essential for effective programming in Python. These features provide a foundation for performing calculations, manipulating data, and developing robust applications.

Python Interpreter and Its Modes

Introduction

The Python interpreter is the program that reads and executes Python code. It allows you to write and execute Python scripts and commands, making it possible to test and debug your code. Python interpreter has two components. The translator checks the statement for syntax. If found correct, it generates an intermediate byte code. There is a Python virtual machine which then converts the byte code in native binary and executes it. The above diagram illustrates the mechanism: Python provides two main modes for interacting with the interpreter

• Interactive Mode


• Script Mode

1. Interactive Mode

Interactive mode is a quick and convenient way to execute Python commands line by line. It is often used for testing, debugging, and exploring the features of the Python language. When you run Python without specifying a script file, you enter the interactive mode. The interpreter waits for each command, executes it, and displays the result immediately.

How to Access Interactive Mode

To enter the interactive mode:

• Open your command prompt or terminal.


• Type python or python3 (depending on your system setup) and press Enter.

Example in Interactive Mode

# Interactive mode example
>>> print("Hello, Python!")
Hello, Python!

>>> 5 + 7
12

>>> name = "Alice"
>>> name
'Alice'

In the example above, you can see how each command is executed immediately after pressing Enter, and the output is shown directly.

2. Script Mode

Script mode allows you to write Python code in a file (with a .py extension) and execute the entire file at once. This mode is used for writing longer programs or when you want to save your code for future use.

How to Use Script Mode

To use script mode:

1. Create a file with a .py extension (e.g., example.py).


2. Write your Python code in the file.


3. Save the file and execute it from the command prompt or terminal by typing python example.py.

Example in Script Mode

# Save the following code in a file named example.py

# example.py
print("This is Script Mode!")
x = 10
y = 20
result = x + y
print("The result is:", result)

To run the script, open the terminal or command prompt and type:

python example.py

The output will be:

This is Script Mode!
The result is: 30

Key Differences Between Interactive and Script Modes

Aspect	Interactive Mode	Script Mode
Usage	For quick testing and debugging	For writing and running entire programs
Execution	Executes commands line by line	Executes the entire script at once
Code Storage	Commands are not saved	Code is saved in a file with a .py extension
Error Handling	Shows errors immediately after command execution	Displays errors after the script execution

Conditional Logic in Python

Conditional logic in Python allows you to execute different code blocks based on certain conditions using if, elif, and else statements. Here’s an overview of how these statements work and examples to illustrate them.

1. Basic if Statement

The if statement is the most basic form of conditional. It checks if a condition is True, and if so, runs the code inside the block.

age = 18

if age >= 18:
    print("You are an adult.")

In this example, if age is 18 or more, Python will print "You are an adult."

2. Adding else

An else statement provides an alternative path if the if condition is not True.

age = 16

if age >= 18:
    print("You are an adult.")
else:
    print("You are a minor.")

Here, because age is less than 18, the output will be "You are a minor."

3. Using elif for Multiple Conditions

elif (short for "else if") allows you to check multiple conditions.

age = 65

if age < 18:
    print("You are a minor.")
elif age < 65:
    print("You are an adult.")
else:
    print("You are a senior.")

In this example:

• If age is less than 18, it prints "You are a minor."


• If age is between 18 and 64, it prints "You are an adult."


• Otherwise, it prints "You are a senior."

4. Nested Conditions

You can nest if statements within each other for more complex conditions.

age = 20
is_student = True

if age >= 18:
    if is_student:
        print("You are an adult student.")
    else:
        print("You are an adult non-student.")
else:
    print("You are a minor.")

5. Logical Test – Stacked elif Statements

In Python, using stacked elif statements allows you to test multiple conditions in sequence. If the first if condition is False, Python will move to the next elif condition and check if it’s True. If none of the if or elif conditions are true, an optional else block can be used as a final fallback. This structure is useful for creating complex decision-making processes in your code.

Syntax

if condition1:
    # Code to execute if condition1 is True
	elif condition2:
    # Code to execute if condition2 is True
	elif condition3:
    # Code to execute if condition3 is True
	else:
    # Code to execute if none of the above conditions are True

Example of Stacked elif

Consider a scenario where we want to determine a person’s life stage based on their age:

age = 25

if age < 13:
    print("You are a child.")
elif age < 20:
    print("You are a teenager.")
elif age < 65:
    print("You are an adult.")
else:
    print("You are a senior.")

Explanation:

• First condition (if age < 13): Checks if the age is less than 13. If true, it will print "You are a child."


• Second condition (elif age < 20): If the first condition is false, Python moves here and checks if age is less than 20. If true, it will print "You are a teenager."


• Third condition (elif age < 65): If neither of the first two conditions is true, this checks if age is less than 65. If true, it will print "You are an adult."


• Else block: If none of the previous conditions are true, the code falls back to this block, which will print "You are a senior."

Example Output:

You are an adult.

Key Points

• Only one block will execute even if multiple conditions are true; Python stops checking once it finds a True condition.


• Order matters: Place conditions from most specific to least specific to get accurate results.


• The else block is optional and is only executed if none of the preceding conditions are true.

Using stacked elif statements gives you the flexibility to handle multiple conditions efficiently without writing separate if statements for each case.

6. Using and and or for Compound Conditions

You can combine multiple conditions using and or or.

• and requires both conditions to be True.


• or requires at least one condition to be True.

age = 20
is_student = True

if age >= 18 and is_student:
    print("You are an adult student.")

In this case, both conditions need to be true to print "You are an adult student."

age = 16
has_permission = True

if age >= 18 or has_permission:
    print("You can enter.")

Here, because has_permission is True, the condition is satisfied even though age is less than 18.

6. The == and != Operators

The == operator checks if two values are equal, and != checks if they are not equal.

name = "Alice"

if name == "Alice":
    print("Hello, Alice!")
else:
    print("Hello, stranger!")

7. Ternary Conditional Operator

Python also supports a shorthand for if-else, called the ternary conditional operator.

age = 20
status = "adult" if age >= 18 else "minor"
print(status)

In this example, status will be set to "adult" if age is 18 or more, otherwise to "minor."

---

Syntax Statement

Understanding the if Statement Syntax in Python

The if statement in Python is fundamental for conditional logic, allowing a program to execute certain parts of the code based on whether a given condition is True or False. Here's a breakdown of each part of the if statement syntax to understand how it works in Python:

1. if Keyword

The if keyword is the core of the conditional statement. It tells Python to evaluate a specific condition immediately after it. If this condition is true, Python will run the code in the associated block. It’s important to remember that if must always be written in lowercase.

2. Condition

The condition is a logical test that follows the if keyword. This part of the statement is an expression—usually a comparison, such as a == b (a is equal to b) or a > b (a is greater than b). The condition will evaluate to either True or False.

if age >= 18:
    print("You are an adult.")

In this example:

• The condition is age >= 18.


• If this evaluates to True, Python will print "You are an adult."

3. Colon (:)

The colon (:) is a small but essential part of the syntax. It tells Python that the condition is complete and that the following code block (after the colon and indentation) will be executed if the condition is true. Without the colon, Python won’t understand where the condition ends, leading to an error.

4. Indentation

Python uses indentation to define blocks of code, unlike some languages that use braces { }. Any code indented under the if statement (usually by four spaces) is considered part of that block and will only execute if the if condition is true. If the condition is false, this indented block is skipped.

age = 20
if age >= 18:
    print("You are an adult.")
    print("You can vote.")

In this example:

• Both print statements are indented under the if condition.


• If age >= 18 is True, both statements will execute.

Common comparators in python

In programming, a condition is like a yes-or-no question that helps decide which part of your code to execute. The answer to this question is either True or False, which we call booleans in Python. Conditions often use comparators to compare values and evaluate if a statement is true or false.

Common Comparators in Python

Comparators in Python allow you to compare two values or objects. Here are some of the most commonly used comparators:

1. Equal to (==): Checks if two values are equal.
   

   5 == 5  # True

   
   


2. Not equal to (!=): Checks if two values are not equal.
   

   5 != 3  # True

   
   


3. Greater than (>): Checks if the left value is greater than the right value.
   

   10 > 7  # True

   
   


4. Less than (<): Checks if the left value is less than the right value.
   

   3 < 8  # True

   
   


5. Greater than or equal to (>=): Checks if the left value is greater than or equal to the right value.
   

   5 >= 5  # True

   
   


6. Less than or equal to (<=): Checks if the left value is less than or equal to the right value.
   

   4 <= 5  # True

   
   

Example of Using Conditions

Let’s look at a simple example. Suppose we want to check if someone is old enough to drive:

age = 18

if age >= 16:
    print("You are old enough to drive.")
else:
    print("You are not old enough to drive.")

Here’s what happens:

• The condition age >= 16 asks, "Is age greater than or equal to 16?"


• If the answer is True, Python will print "You are old enough to drive."


• If the answer is False, it will print "You are not old enough to drive."

Compound Conditions

You can combine multiple conditions using logical operators:

• and: All conditions must be True.


• or: At least one condition must be True.

Example:

age = 20
has_license = True

if age >= 18 and has_license:
    print("You are allowed to drive.")

In this example, the condition checks if age is at least 18 and if has_license is True. Both must be true for the message to print.

Summary

In Python, conditions are simply questions that check for True or False answers. Comparators are the tools that make these checks possible, helping you write logical statements that guide the flow of your program.

Logical & Identity Operators

Logical & Identity Operators in Python

Logical and identity operators allow you to form complex conditions by combining simple ones. These operators are extremely useful when you need your program to make decisions based on multiple criteria or when you want to check relationships between various data objects.

Logical Operators

• and: Returns True if both conditions being tested are true.


• or: Returns True if at least one of the conditions being tested is true.


• ^ (xor): Returns True if only one condition being tested is true.


• not: Negates the result of the condition it precedes.

Identity Operator

• is: Returns True if both variables point to the same data object.