🐍 Python Programming

What is Python?

Python is a high-level, interpreted, general-purpose programming language created by Guido van Rossum and first released in 1991. It emphasizes code readability with its notable use of significant whitespace and simple syntax that allows programmers to express concepts in fewer lines of code than would be possible in languages such as C++ or Java.

Key Characteristics:

• Interpreted: Python code is executed line by line by the Python interpreter, which means you don't need to compile your code before running it. This makes development faster and more interactive.
• High-level: Provides strong abstraction from machine details, allowing you to focus on solving problems rather than managing memory or dealing with low-level operations.
• Dynamic typing: Variable types are determined at runtime, meaning you don't need to declare the type of a variable when you create it. Python automatically infers the type based on the value you assign.
• Garbage collected: Automatic memory management means Python automatically handles memory allocation and deallocation, preventing memory leaks and making programming easier.
• Multi-paradigm: Supports procedural, object-oriented, and functional programming styles, giving you flexibility in how you approach problem-solving.
• Extensive Standard Library: Comes with a rich set of built-in modules and packages that provide ready-to-use functionality for common tasks.
• Cross-platform: Python code can run on Windows, macOS, Linux, and other operating systems without modification.

Python's Philosophy (The Zen of Python):

Python follows a set of guiding principles that emphasize:

• Readability: Code should be easy to read and understand
• Simplicity: Simple is better than complex
• Explicit: Explicit is better than implicit
• Practicality: Practicality beats purity
• Beautiful: Beautiful is better than ugly

Python Versions and History:

Python has evolved through several major versions:

• Python 1.x (1994-2000): Early versions with basic features
• Python 2.x (2000-2020): Major version with widespread adoption
• Python 3.x (2008-present): Current version with improved features and syntax

Note: Python 2 reached end-of-life in 2020. All new development should use Python 3.

# This is your first Python program
print("Hello, World!")

# Variables and basic operations
name = "Python Learner"
age = 25
print(f"My name is {name} and I am {age} years old")

Hello, World!
My name is Python Learner and I am 25 years old

Python Syntax Fundamentals

Python uses indentation to define code blocks, making it unique among programming languages. This enforced indentation makes Python code more readable and forces programmers to write clean, well-structured code.

Indentation and Code Blocks:

In Python, indentation is not just for readability—it's part of the syntax. Code blocks are defined by their indentation level:

• Consistent Indentation: Use 4 spaces for each indentation level (PEP 8 standard)
• Code Blocks: Functions, loops, conditionals, and classes use indentation to define their scope
• Nested Blocks: Each nested level adds another 4 spaces of indentation
• Mixed Indentation: Never mix tabs and spaces—use only spaces for consistency

Python Syntax Rules:

• Case Sensitivity: Python is case-sensitive. variable and Variable are different names.
• Naming Conventions: Use snake_case for variables and functions, PascalCase for classes, UPPER_CASE for constants.
• Line Continuation: Use backslash (\) or parentheses for long lines.
• Comments: Use # for single-line comments and triple quotes for multi-line comments.
• Statements: Each statement typically ends with a newline, but you can use semicolons to separate statements on the same line.

Python's Readability Features:

• Clear Keywords: Python uses descriptive keywords like if, else, for, while, def, class.
• Natural Language: Many Python constructs read like natural English.
• Consistent Structure: Similar operations follow consistent patterns throughout the language.

# Comments start with #
# Multi-line comments use triple quotes

"""This is a multi-line comment
that can span multiple lines
and is often used for documentation"""

# Variables don't need type declaration
x = 10
y = "Hello"
z = True

# Multiple assignment
a, b, c = 1, 2, 3

# Print function
print("Hello World")
print(x, y, z)  # Multiple values

Hello World
10 Hello True

Python Data Types

Python has several built-in data types that are used to define the operations possible on them and the storage method for each of them. Python's data types are classes, and variables are instances (objects) of these classes.

Understanding Data Types in Python:

Data types in Python are fundamental concepts that determine how data is stored, processed, and manipulated. Every value in Python has a data type, and understanding these types is crucial for effective programming.

Key Concepts:

• Dynamic Typing: Python automatically determines the type of a variable based on the value assigned to it. You don't need to declare the type explicitly.
• Type Checking: You can check the type of any object using the type() function or isinstance() function.
• Type Conversion: Python provides built-in functions to convert between different data types (e.g., int(), float(), str()).
• Mutable vs Immutable: Some data types can be changed after creation (mutable), while others cannot (immutable).

Data Type Categories:

• Numeric Types: int, float, complex - for mathematical operations
• Sequence Types: list, tuple, str - for ordered collections
• Mapping Types: dict - for key-value pairs
• Set Types: set, frozenset - for unordered collections of unique elements
• Boolean Type: bool - for logical operations
• None Type: None - represents absence of value

Memory Management:

Python automatically manages memory for all data types. When you create a variable, Python allocates memory for it. When the variable goes out of scope or is reassigned, Python's garbage collector frees the memory.

# Integer (int)
age = 25
year = 2024

# Float (floating point)
height = 5.9
pi = 3.14159

# Complex numbers
complex_num = 3 + 4j

# Type checking
print(type(age))      # <class 'int'>
print(type(height))    # <class 'float'>
print(type(complex_num)) # <class 'complex'>

<class 'int'>
<class 'float'>
<class 'complex'>

# String creation
name = "John Doe"
message = 'Hello World'
multi_line = """This is a
multi-line string"""

# String operations
print(name.upper())        # JOHN DOE
print(name.lower())        # john doe
print(name.split())        # ['John', 'Doe']
print(len(name))           # 8

# String formatting
age = 25
print(f"I am {age} years old")  # f-string (Python 3.6+)
print("I am {} years old".format(age))  # .format()
print("I am %d years old" % age)  # % formatting

JOHN DOE
john doe
['John', 'Doe']
8
I am 25 years old
I am 25 years old
I am 25 years old

# Boolean values
is_student = True
is_working = False

# Boolean operations
print(True and False)  # False
print(True or False)   # True
print(not True)           # False

# Truthy and Falsy values
print(bool(0))      # False
print(bool(""))     # False
print(bool([]))     # False
print(bool(1))      # True
print(bool("hello")) # True

False
True
False
False
False
False
True
True

Control Flow Statements

Control flow statements determine the order in which program statements are executed. Python provides several control flow statements including conditional statements (if, elif, else), loops (for, while), and control statements (break, continue, pass).

Understanding Control Flow:

Control flow is the order in which individual statements, instructions, or function calls are executed or evaluated in a program. It determines how your program responds to different conditions and how it repeats operations.

Types of Control Flow:

• Sequential Flow: Statements are executed in the order they appear in the code.
• Conditional Flow: Different code blocks are executed based on whether certain conditions are true or false.
• Iterative Flow: Code blocks are executed repeatedly while certain conditions remain true.
• Exception Flow: Special handling for errors and exceptional situations.

Control Flow Benefits:

• Decision Making: Allows programs to make decisions based on conditions.
• Repetition: Enables efficient execution of the same code multiple times.
• Error Handling: Provides mechanisms to handle unexpected situations gracefully.
• Code Organization: Helps structure code logically and make it more readable.

Python Control Flow Features:

• Indentation-based: Uses indentation to define code blocks, making the structure clear and readable.
• Expressive: Control flow statements are designed to be readable and intuitive.
• Flexible: Multiple ways to achieve the same control flow patterns.
• Safe: Built-in safeguards prevent common control flow errors.

# Basic if statement
age = 18

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

# if-elif-else chain
score = 85

if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
elif score >= 60:
    grade = "D"
else:
    grade = "F"

print(f"Your grade is {grade}")

You are an adult
Your grade is B

# Iterating over a range
for i in range(5):
    print(i)  # 0, 1, 2, 3, 4

# Iterating over a list
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

# Iterating with enumerate
for index, fruit in enumerate(fruits):
    print(f"{index}: {fruit}")

# Iterating over a dictionary
person = {"name": "John", "age": 30, "city": "New York"}

for key in person:
    print(f"{key}: {person[key]}")

for key, value in person.items():
    print(f"{key}: {value}")

0
1
2
3
4
apple
banana
cherry
0: apple
1: banana
2: cherry
name: John
age: 30
city: New York
name: John
age: 30
city: New York

# Basic while loop
count = 0
while count < 5:
    print(count)
    count += 1

# While loop with break
number = 0
while True:
    if number == 5:
        break
    print(number)
    number += 1

# While loop with continue
i = 0
while i < 10:
    i += 1
    if i % 2 == 0:
        continue  # Skip even numbers
    print(i)  # Print only odd numbers

0
1
2
3
4
0
1
2
3
4
1
3
5
7
9

Functions in Python

A function is a block of organized, reusable code that is used to perform a single, related action. Functions provide better modularity for your application and a high degree of code reusing. Python has many built-in functions, but you can also create your own functions.

Understanding Functions:

Functions are fundamental building blocks in Python programming. They allow you to encapsulate code into reusable units, making your programs more organized, maintainable, and efficient.

Function Benefits:

• Code Reusability: Write code once and use it multiple times throughout your program.
• Modularity: Break complex problems into smaller, manageable pieces.
• Maintainability: Easier to update and fix code when it's organized into functions.
• Readability: Functions with descriptive names make code self-documenting.
• Testing: Individual functions can be tested independently.
• Abstraction: Hide complex implementation details behind simple interfaces.

Function Components:

• Function Definition: The def keyword followed by the function name and parameters.
• Parameters: Input values that the function receives (also called arguments).
• Function Body: The code that performs the function's task.
• Return Statement: Specifies what value the function sends back to the caller.
• Function Call: How you invoke the function to execute its code.

Function Types in Python:

• Built-in Functions: Pre-defined functions that come with Python (e.g., print(), len(), type()).
• User-defined Functions: Functions that you create to solve specific problems.
• Lambda Functions: Small, anonymous functions defined with the lambda keyword.
• Methods: Functions that belong to objects or classes.

Function Design Principles:

• Single Responsibility: Each function should do one thing well.
• Descriptive Names: Function names should clearly indicate what the function does.
• Appropriate Size: Functions should be neither too long nor too short.
• Clear Parameters: Parameter names should be descriptive and meaningful.
• Documentation: Use docstrings to explain what the function does.

# Simple function
def greet():
    print("Hello, World!")

# Function call
greet()

# Function with parameters
def greet_person(name):
    print(f"Hello, {name}!")

greet_person("Alice")

# Function with multiple parameters
def add_numbers(a, b):
    return a + b

result = add_numbers(5, 3)
print(result)  # 8

# Function with default parameters
def greet_with_title(name, title="Mr."):
    return f"Hello, {title} {name}!"

print(greet_with_title("Smith"))  # Hello, Mr. Smith!
print(greet_with_title("Johnson", "Dr."))  # Hello, Dr. Johnson!

Hello, World!
Hello, Alice!
8
Hello, Mr. Smith!
Hello, Dr. Johnson!

# Lambda function syntax: lambda arguments: expression
square = lambda x: x ** 2
print(square(5))  # 25

# Lambda with multiple arguments
add = lambda x, y: x + y
print(add(3, 4))  # 7

# Lambda in built-in functions
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
print(squared)  # [1, 4, 9, 16, 25]

# Lambda with filter
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # [2, 4]

25
7
[1, 4, 9, 16, 25]
[2, 4]

Python Data Structures

Data structures are fundamental concepts in programming that help organize and store data efficiently. Python provides several built-in data structures including lists, tuples, dictionaries, and sets, each with their own characteristics and use cases.

Understanding Data Structures:

Data structures are specialized formats for organizing, processing, retrieving, and storing data. They provide a way to manage large amounts of data efficiently for uses such as large databases and internet indexing services.

Why Data Structures Matter:

• Efficiency: Different data structures are optimized for different types of operations.
• Organization: Help organize data in a logical and meaningful way.
• Performance: Choosing the right data structure can significantly impact program performance.
• Problem Solving: Many algorithms require specific data structures to work effectively.
• Memory Usage: Different structures use memory differently, affecting overall program efficiency.

Data Structure Categories:

• Linear Structures: Data elements are arranged in a sequential manner (lists, tuples, strings).
• Non-linear Structures: Data elements are not arranged in a sequential manner (trees, graphs).
• Homogeneous Structures: All elements are of the same type (arrays in some languages).
• Heterogeneous Structures: Elements can be of different types (Python lists, dictionaries).

Python's Built-in Data Structures:

• Lists: Mutable, ordered sequences of elements.
• Tuples: Immutable, ordered sequences of elements.
• Dictionaries: Mutable, unordered collections of key-value pairs.
• Sets: Mutable, unordered collections of unique elements.
• Strings: Immutable sequences of characters.

Choosing the Right Data Structure:

• Access Patterns: How frequently you need to access, insert, or delete elements.
• Data Relationships: Whether data has hierarchical, network, or simple relationships.
• Memory Constraints: How much memory your application can use.
• Performance Requirements: Speed requirements for different operations.
• Data Size: Whether you're working with small or large datasets.

Time Complexity Considerations:

Different operations on different data structures have varying time complexities:

• Access: How quickly you can retrieve an element.
• Search: How quickly you can find an element.
• Insertion: How quickly you can add new elements.
• Deletion: How quickly you can remove elements.
• Traversal: How quickly you can visit all elements.

# Creating lists
fruits = ["apple", "banana", "cherry"]
numbers = [1, 2, 3, 4, 5]
mixed = [1, "hello", True, 3.14]

# Accessing elements
print(fruits[0])  # apple
print(fruits[-1])  # cherry (last element)

# Slicing
print(numbers[1:4])  # [2, 3, 4]
print(numbers[:3])  # [1, 2, 3]
print(numbers[2:])  # [3, 4, 5]

# List methods
fruits.append("orange")  # Add to end
fruits.insert(1, "grape")  # Insert at index
fruits.remove("banana")  # Remove by value
popped = fruits.pop()  # Remove and return last element
fruits.sort()  # Sort in place
fruits.reverse()  # Reverse in place

# List comprehension
squares = [x**2 for x in range(5)]
print(squares)  # [0, 1, 4, 9, 16]

# Creating dictionaries
person = {
    "name": "John Doe",
    "age": 30,
    "city": "New York",
    "skills": ["Python", "JavaScript", "SQL"]
}

# Accessing values
print(person["name"])  # John Doe
print(person.get("age"))  # 30
print(person.get("email", "Not found"))  # Not found

# Adding/updating items
person["email"] = "john@example.com"
person.update({"phone": "123-456-7890"})

# Dictionary methods
print(person.keys())  # dict_keys(['name', 'age', 'city', 'skills', 'email', 'phone'])
print(person.values())  # dict_values(['John Doe', 30, 'New York', ...])
print(person.items())  # dict_items([('name', 'John Doe'), ('age', 30), ...])

# Dictionary comprehension
squares = {x: x**2 for x in range(5)}
print(squares)  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Object-Oriented Programming in Python

Object-Oriented Programming (OOP) is a programming paradigm that uses objects to design applications and computer programs. It provides a clear modular structure for programs which makes it good for defining abstract data types, implementing code reusability, and protecting information through encapsulation.

Understanding Object-Oriented Programming:

OOP is a programming paradigm based on the concept of "objects," which can contain data and code. Data in the form of fields (often known as attributes or properties), and code, in the form of procedures (often known as methods).

Core OOP Concepts:

• Objects: Instances of classes that contain both data and methods to work with that data.
• Classes: Blueprints or templates for creating objects. They define the structure and behavior of objects.
• Attributes: Data stored within objects (also called properties or fields).
• Methods: Functions that belong to objects and can access and modify the object's data.
• Encapsulation: Bundling data and methods that work on that data within a single unit (class).
• Inheritance: Mechanism that allows a class to inherit properties and methods from another class.
• Polymorphism: Ability to present the same interface for different underlying forms (data types or classes).
• Abstraction: Hiding complex implementation details and showing only necessary features.

Benefits of OOP:

• Modularity: Code can be organized into logical, reusable components.
• Reusability: Classes can be reused across different parts of an application.
• Maintainability: Changes to one part of the code don't affect other parts.
• Scalability: Easy to extend and modify existing code.
• Security: Data can be protected through encapsulation and access control.
• Code Organization: Related data and functions are grouped together.

OOP in Python:

• Everything is an Object: In Python, everything (numbers, strings, functions, modules) is an object.
• Dynamic Typing: Python's dynamic nature makes OOP very flexible.
• Multiple Inheritance: Python supports inheriting from multiple parent classes.
• Magic Methods: Special methods (like __init__, __str__) provide powerful customization.
• Property Decorators: Allow controlled access to class attributes.

Design Principles:

• Single Responsibility Principle: A class should have only one reason to change.
• Open/Closed Principle: Open for extension, closed for modification.
• Liskov Substitution Principle: Derived classes must be substitutable for their base classes.
• Interface Segregation Principle: Many specific interfaces are better than one general-purpose interface.
• Dependency Inversion Principle: Depend on abstractions, not on concretions.

# Defining a class
class Person:
    # Constructor method
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    # Instance method
    def introduce(self):
        return f"Hi, I'm {self.name} and I'm {self.age} years old"
    
    # Method to update age
    def have_birthday(self):
        self.age += 1
        return f"Happy birthday! I'm now {self.age} years old"

# Creating objects (instances)
person1 = Person("Alice", 25)
person2 = Person("Bob", 30)

# Accessing attributes and methods
print(person1.name)  # Alice
print(person1.introduce())  # Hi, I'm Alice and I'm 25 years old
print(person2.have_birthday())  # Happy birthday! I'm now 31 years old

Alice
Hi, I'm Alice and I'm 25 years old
Happy birthday! I'm now 31 years old

# Base class (parent class)
class Animal:
    def __init__(self, name, species):
        self.name = name
        self.species = species
    
    def make_sound(self):
        return "Some animal sound"
    
    def get_info(self):
        return f"{self.name} is a {self.species}"

# Derived class (child class)
class Dog(Animal):
    def __init__(self, name, breed):
        # Call parent constructor
        super().__init__(name, "Dog")
        self.breed = breed
    
    def make_sound(self):
        return "Woof! Woof!"
    
    def fetch(self):
        return f"{self.name} is fetching the ball"

# Creating instances
my_dog = Dog("Buddy", "Golden Retriever")
print(my_dog.get_info())  # Buddy is a Dog
print(my_dog.make_sound())  # Woof! Woof!
print(my_dog.fetch())  # Buddy is fetching the ball

Buddy is a Dog
Woof! Woof!
Buddy is fetching the ball

# Encapsulation example
class BankAccount:
    def __init__(self, account_holder, initial_balance):
        self.account_holder = account_holder
        self._balance = initial_balance  # Protected attribute
        self.__account_number = "ACC" + str(hash(account_holder))  # Private attribute
    
    def get_balance(self):
        return self._balance
    
    def deposit(self, amount):
        if amount > 0:
            self._balance += amount
            return f"Deposited ${amount}. New balance: ${self._balance}"
        else:
            return "Invalid amount"
    
    def withdraw(self, amount):
        if 0 < amount <= self._balance:
            self._balance -= amount
            return f"Withdrew ${amount}. New balance: ${self._balance}"
        else:
            return "Insufficient funds or invalid amount"

# Using the class
account = BankAccount("John Doe", 1000)
print(account.deposit(500))  # Deposited $500. New balance: $1500
print(account.withdraw(200))  # Withdrew $200. New balance: $1300
print(account.get_balance())  # 1300

Deposited $500. New balance: $1500
Withdrew $200. New balance: $1300
1300

Python Modules

A module is a file containing Python definitions and statements. The file name is the module name with the suffix .py appended. Modules can be imported and used in other Python files, allowing for code organization and reusability.

Understanding Modules:

Modules are a way to organize Python code into logical units. They help break down large programs into smaller, manageable pieces and promote code reuse across different projects.

Module Benefits:

• Code Organization: Group related functions, classes, and variables together.
• Reusability: Write code once and use it in multiple projects.
• Namespace Management: Avoid naming conflicts by organizing code into separate namespaces.
• Maintainability: Easier to maintain and update code when it's organized into modules.
• Collaboration: Multiple developers can work on different modules simultaneously.
• Testing: Individual modules can be tested independently.

Types of Modules:

• Built-in Modules: Pre-installed modules that come with Python (e.g., math, os, sys).
• Standard Library Modules: Additional modules included with Python installation (e.g., datetime, json, re).
• Third-party Modules: Modules created by the community and installed separately (e.g., numpy, pandas, requests).
• Custom Modules: Modules you create for your own projects.

Module Structure:

• Module Name: The filename without the .py extension becomes the module name.
• Module Content: Can contain functions, classes, variables, and executable code.
• Module Documentation: Docstrings at the beginning of the module describe its purpose.
• Module Variables: Variables defined at the module level are accessible when the module is imported.

Import Mechanisms:

• Import Statement: import module_name - imports the entire module.
• From Import: from module_name import item - imports specific items from a module.
• Import As: import module_name as alias - imports with an alias name.
• Import All: from module_name import * - imports all public items (not recommended).

Module Search Path:

Python searches for modules in the following order:

• Current Directory: The directory containing the script being executed.
• PYTHONPATH: Environment variable containing directories to search.
• Standard Library: Built-in modules and standard library modules.
• Site-packages: Third-party modules installed via pip or other package managers.

Packages vs Modules:

• Module: A single Python file containing code.
• Package: A directory containing multiple modules and an __init__.py file.
• Subpackages: Packages within packages, creating a hierarchical structure.
• Namespace Packages: Packages that can be split across multiple directories.

# math_operations.py (module file)
def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

def multiply(a, b):
    return a * b

def divide(a, b):
    if b != 0:
        return a / b
    else:
        raise ValueError("Cannot divide by zero")

# main.py (using the module)
import math_operations

print(math_operations.add(5, 3))  # 8
print(math_operations.multiply(4, 6))  # 24

# Import specific functions
from math_operations import add, subtract

print(add(10, 5))  # 15
print(subtract(10, 5))  # 5

# Import with alias
import math_operations as math_ops

print(math_ops.divide(15, 3))  # 5.0

8
24
15
5
5.0

# Math module
import math

print(math.pi)  # 3.141592653589793
print(math.sqrt(16))  # 4.0
print(math.ceil(3.7))  # 4
print(math.floor(3.7))  # 3

# Random module
import random

print(random.randint(1, 10))  # Random integer between 1 and 10
print(random.choice(["apple", "banana", "cherry"]))  # Random choice
random.shuffle([1, 2, 3, 4, 5])  # Shuffle list

# Datetime module
from datetime import datetime, timedelta

now = datetime.now()
print(now)  # Current date and time
print(now.strftime("%Y-%m-%d %H:%M:%S"))  # Formatted date

tomorrow = now + timedelta(days=1)
print(tomorrow)  # Tomorrow's date

3.141592653589793
4.0
4
3
7
banana
2024-01-15 14:30:25.123456
2024-01-15 14:30:25
2024-01-16 14:30:25.123456

File Operations in Python

Python provides built-in functions and methods to handle files. File handling is an important part of any web application. Python has several functions for creating, reading, updating, and deleting files.

Understanding File Handling:

File handling is the process of working with files stored on a computer's file system. Python provides a simple and efficient way to read from and write to files, making it easy to persist data and work with external files.

File Handling Benefits:

• Data Persistence: Store data permanently on disk for later use.
• Data Exchange: Share data between different programs and systems.
• Configuration Management: Store application settings and configurations.
• Logging: Record application events and debugging information.
• Data Processing: Read and process large datasets from files.
• Backup and Recovery: Create backups of important data.

File Operations:

• Opening Files: Use the open() function to create a file object.
• Reading Files: Extract data from existing files.
• Writing Files: Create new files or overwrite existing ones.
• Appending Files: Add data to the end of existing files.
• Closing Files: Properly close files to free system resources.
• File Positioning: Move the file pointer to specific positions.

File Access Modes:

• 'r' (Read): Default mode, opens file for reading only.
• 'w' (Write): Opens file for writing, truncates the file if it exists.
• 'a' (Append): Opens file for appending, creates file if it doesn't exist.
• 'x' (Exclusive): Opens file for exclusive creation, fails if file exists.
• 'b' (Binary): Opens file in binary mode (use with 'r', 'w', 'a').
• 't' (Text): Opens file in text mode (default).
• '+' (Read/Write): Opens file for both reading and writing.

File Handling Best Practices:

• Use Context Managers: Always use with statements to ensure proper file closure.
• Handle Exceptions: Use try-except blocks to handle file operation errors.
• Check File Existence: Verify files exist before attempting to read them.
• Use Appropriate Modes: Choose the right access mode for your operation.
• Close Files Properly: Always close files when done to free resources.
• Use Absolute Paths: Use absolute paths for production applications.

Common File Formats:

• Text Files: Plain text files (.txt, .csv, .json, .xml).
• Binary Files: Files containing non-text data (.jpg, .png, .pdf, .exe).
• Structured Files: Files with specific formats (.csv, .json, .xml).
• Configuration Files: Files containing settings (.ini, .cfg, .yaml).

File System Operations:

• Directory Operations: Create, list, and navigate directories.
• File Information: Get file size, modification time, and permissions.
• File Movement: Rename, move, and copy files.
• File Deletion: Remove files and directories.
• Path Operations: Work with file and directory paths.

# Reading a file
with open("sample.txt", "r") as file:
    content = file.read()
    print(content)

# Reading line by line
with open("sample.txt", "r") as file:
    for line in file:
        print(line.strip())

# Reading all lines into a list
with open("sample.txt", "r") as file:
    lines = file.readlines()
    print(lines)

# Reading with encoding
with open("sample.txt", "r", encoding="utf-8") as file:
    content = file.read()

Hello
World
Python
Hello
World
Python
['Hello\n', 'World\n', 'Python\n']

# Writing to a file (overwrites existing content)
with open("output.txt", "w") as file:
    file.write("Hello, World!\n")
    file.write("This is a new line.\n")

# Appending to a file
with open("output.txt", "a") as file:
    file.write("This line is appended.\n")

# Writing multiple lines
lines = ["Line 1\n", "Line 2\n", "Line 3\n"]
with open("output.txt", "w") as file:
    file.writelines(lines)

# Writing with context manager
try:
    with open("data.txt", "w") as file:
        file.write("Some data")
except IOError as e:
    print(f"Error writing file: {e}")

# After first write operation:
Hello, World!
This is a new line.

# After append operation:
Hello, World!
This is a new line.
This line is appended.

# After writelines operation:
Line 1
Line 2
Line 3

Exception Handling in Python

Exceptions are events that occur during the execution of a program that disrupt the normal flow of the program's instructions. Python provides a way to handle these exceptions using try-except blocks, allowing the program to continue running even when errors occur.

Understanding Exceptions:

Exceptions are Python's way of handling errors and exceptional situations that occur during program execution. They provide a mechanism to detect and respond to errors gracefully, preventing program crashes and allowing for proper error recovery.

Exception Handling Benefits:

• Program Stability: Prevents programs from crashing due to unexpected errors.
• Error Recovery: Allows programs to recover from errors and continue execution.
• User Experience: Provides meaningful error messages to users instead of crashes.
• Debugging: Helps identify and locate the source of problems.
• Resource Management: Ensures proper cleanup of resources even when errors occur.
• Robust Code: Makes code more reliable and maintainable.

Types of Exceptions:

• Built-in Exceptions: Pre-defined exceptions that Python raises for common errors.
• Custom Exceptions: User-defined exceptions for specific application needs.
• System Exceptions: Exceptions raised by the Python interpreter or system.
• Application Exceptions: Exceptions specific to your application's domain.

Common Built-in Exceptions:

• ValueError: Raised when a function receives an argument of the correct type but inappropriate value.
• TypeError: Raised when an operation is performed on an inappropriate type.
• IndexError: Raised when a sequence subscript is out of range.
• KeyError: Raised when a dictionary key is not found.
• FileNotFoundError: Raised when a file or directory is requested but cannot be found.
• ZeroDivisionError: Raised when division or modulo by zero is encountered.
• AttributeError: Raised when attribute reference or assignment fails.
• ImportError: Raised when an import statement fails.

Exception Handling Mechanisms:

• Try-Except Blocks: The primary mechanism for catching and handling exceptions.
• Try-Except-Else: Execute code only if no exception occurs.
• Try-Except-Finally: Execute cleanup code regardless of whether an exception occurs.
• Try-Except-Else-Finally: Combine all exception handling features.
• Raise Statement: Manually raise exceptions when needed.
• Assert Statement: Raise AssertionError if a condition is false.

Exception Handling Best Practices:

• Be Specific: Catch specific exceptions rather than using bare except clauses.
• Handle Locally: Handle exceptions at the appropriate level in your code.
• Clean Up Resources: Use finally blocks to ensure proper resource cleanup.
• Log Exceptions: Log exception details for debugging purposes.
• Don't Suppress: Avoid silently ignoring exceptions unless absolutely necessary.
• Provide Context: Include relevant information in error messages.
• Use Custom Exceptions: Create domain-specific exceptions for your application.

Exception Hierarchy:

Python exceptions form a hierarchy, with more specific exceptions inheriting from more general ones:

• BaseException: The root class for all exceptions.
• Exception: Base class for all built-in exceptions.
• SystemExit: Raised when sys.exit() is called.
• KeyboardInterrupt: Raised when the user interrupts the program.
• GeneratorExit: Raised when a generator is closed.

Context Managers and Exceptions:

• With Statement: Automatically handles exceptions and resource cleanup.
• Context Manager Protocol: Objects that support the with statement.
• Custom Context Managers: Create your own context managers for specific needs.

# Basic try-except block
try:
    number = int("abc")
except ValueError:
    print("Invalid number format")

# Multiple except blocks
try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero")
except TypeError:
    print("Invalid type for operation")

# Catching all exceptions
try:
    # Some risky operation
    pass
except Exception as e:
    print(f"An error occurred: {e}")

Invalid number format
Cannot divide by zero

# Try-except-else-finally
try:
    number = int("123")
except ValueError:
    print("Invalid number")
else:
    print(f"Successfully converted: {number}")
finally:
    print("This always executes")

# Raising exceptions
def divide_numbers(a, b):
    if b == 0:
        raise ValueError("Cannot divide by zero")
    return a / b

try:
    result = divide_numbers(10, 0)
except ValueError as e:
    print(e)  # Cannot divide by zero

# Custom exceptions
class CustomError(Exception):
    def __init__(self, message):
        self.message = message
        super().__init__(self.message)

try:
    raise CustomError("This is a custom error")
except CustomError as e:
    print(e.message)

Successfully converted: 123
This always executes
Cannot divide by zero
This is a custom error