INTRODUCTION TO PYTHON

What is Python?

Python is a high-level, interpreted, and dynamically typed programming language known for its simplicity and powerful capabilities. It allows developers to write less code while achieving more, making it a preferred language in many domains like:
• Artificial Intelligence (AI)
• Machine Learning (ML)
• Data Science
• Cybersecurity
• Automation
Python does not require declaring variable data types, making it very developer-friendly and versatile.

Who Invented Python?

Python was created by Guido van Rossum and was first released on February 20, 1991, in the Netherlands. His goal was to create a language that emphasizes code readability and simplicity.

Key Features of Python

• ✅ Easy to Learn and Use: Simple, English-like syntax. Beginner-friendly.
• ✅ Interpreted Language: Code runs line-by-line. Easier to debug.
• ✅ Dynamically Typed: No need to declare variable types.
• ✅ Object-Oriented Programming: Supports OOP concepts as well as procedural and functional styles.
• ✅ Extensive Standard Library: Built-in modules for file handling, web services, regular expressions, databases.
• ✅ Cross-Platform Support: Write once, run anywhere (Windows, macOS, Linux).
• ✅ Large Community and Ecosystem: Support from libraries like Django, Flask, NumPy, Pandas, etc.

Understanding Interpreted and Typed Languages

- Interpreted Language: Executes code line by line, converts it to machine code dynamically (e.g., Python).
- Dynamically Typed: Variables don’t need a predefined type (e.g., x = 5).
- Statically Typed: Variables must be declared with data types (like in Java or C).

Why Python is Robust and Platform-Independent

• Robust: Python handles errors gracefully using Exception Handling.
• Platform-Independent: Python code runs on all OS platforms without modification.

Applications of Python (2025)

• 🔹 Web Development – Using Django, Flask
• 🔹 Data Science & Analytics – NumPy, Pandas, Matplotlib
• 🔹 Machine Learning & AI – Scikit-learn, TensorFlow
• 🔹 Automation/Scripting – Automate tasks, file handling, testing
• 🔹 Game Development – Using PyGame
• 🔹 Cybersecurity & Hacking – Pentesting, packet sniffing
• 🔹 Embedded Systems & IoT – MicroPython, Raspberry Pi

Popular Python Versions (2014–2025)

Version    Release Year    Highlights
3.4    2014    Introduced asyncio
3.5    2015    async/await syntax
3.6    2016    f-strings, underscores in numeric literals
3.7    2018    dataclasses, dictionary order preserved
3.8    2019    Walrus operator :=, positional-only parameters
3.9    2020    Dictionary merge, new string methods
3.10    2021    Structural Pattern Matching (match/case)
3.11    2022    Speed boost (up to 60%)
3.12    2023    Enhanced error messages, performance improvements

Conclusion

Python is an easy-to-learn, powerful language used in many areas like web development, data analysis, automation, and more. Its clean syntax and wide support make it a great choice for beginners and professionals alike. Keep practicing to unlock its full potential!

Happy Learning Continue the Next Lessions 🙂

INSTALLING AND SETUP PYTHON

Setting Up Python on Your System (Windows / macOS / Linux)

Windows

1. Go to https://www.python.org
2. Download the latest Windows installer
3. Run the installer and check 'Add Python to PATH'
4. Click 'Install Now'
5. Open CMD and type: python --version

macOS

1. Download the .pkg installer from https://www.python.org/downloads/mac-osx/
2. Run the installer
3. Open Terminal and type: python3 --version

Linux (Ubuntu/Debian)

1. Open Terminal
2. Run:
   sudo apt update
   sudo apt install python3
3. Check version: python3 --version

Note: pip is usually installed by default with Python 3.x

Writing and Running Your First Python Program

Choose an IDE or Text Editor:
• VS Code (recommended)
• IDLE (comes with Python)
• PyCharm
• Sublime Text / Notepad

Sample Program (hello.py):

print("Hello, Python!")

How to Run:

Using Command Line:

cd path-to-your-file
python hello.py

Using IDLE:

Open hello.py
Press F5 to run

Using VS Code:

Right-click the file
Click “Run Python File in Terminal”

Expected Output:

Hello, Python!

Final Tips for Beginners

- Practice writing small programs daily.
- Learn variables, loops, functions, classes.
- Try real-world projects like To-Do apps or web scrapers.
- Use platforms like LeetCode, HackerRank, and Codecademy.

Conclusion

Python is one of the most powerful and versatile languages you can learn in 2025. Whether you're building websites, analyzing data, or creating intelligent apps—Python has tools and libraries ready for you.

Happy Learning Continue the Next Lessons 🙂

PYTHON VARIABLES

Python Variables

What are Variables?
Variables are used to store values in Python.
To create a variable, use the equal sign (=).

Example:

name = "Anvay Rucha"

Using a Variable

Once a variable is created, you can use it like this:

name = "Anvay Rucha"
print(name)

Another Example

name = "Anvay Rucha"
print("Hello " + name)

Changing a Variable's Value

To change the value of a variable, assign a new value using =:

name = "Anvay Rucha"
name = "Bantu"
print("Hello " + name)

Assigning a New Data Type

A variable can be reassigned to a different data type:

name = " Anvay Rucha "  # String
name = 25      # Integer
print(name)

Rules for Naming Variables

• A variable name should start with a letter or underscore (_)
• A variable name cannot start with a number
• A variable is case-sensitive.
• A variable name should only contain underscores (_) and alphanumeric characters

✅Legal variable names:
myname = "Anvay Rucha"
my_name = "Juan"
_myname = "Juan"
myname1 = "Juan"
myName = "Juan"

❌ Illegal variable names:
# $myname = "Juan"   # Starts with special character
# my name = "Juan"   # Contains space
# 1myname = "Juan"   # Starts with a number
# my-name = "Juan"   # Contains hyphen

Naming Conventions

1. Snake Case (Recommended for Python):
Use underscores _ to separate words:
my_favorite_fruit = "mangos"
print(my_favorite_fruit)

2. Camel Case:
Capitalize each word after the first:
myFavoriteFruit = "mangos"
print(myFavoriteFruit)

3. PascalCase
Each word starts with a capital letter, including the first:
MyFavoriteFruit = "mangos"
print(MyFavoriteFruit)

✅ Conclusion on Python Variables

Python variables are fundamental building blocks used to store data. With simple syntax and dynamic typing, they allow flexible and powerful data handling.

Happy Learning Continue the Next Lessons 🙂

PYTHON DATA TYPES

DATA TYPES
A data type in Python is a classification that specifies which kind of value a variable can hold and what operations can be performed on that value. Each data type defines the nature of the data, such as numbers, text, sequences, or collections, and determines how the data is stored and manipulated in memory.

Feature:
Python is a dynamically typed language, meaning you don’t need to explicitly declare the data type of a variable — the interpreter infers it automatically at runtime based on the assigned value. This flexibility allows for rapid development and easy code modification.

🔷 1. Fundamental Data Types
✅ int (Integer)  
Definition: Represents whole numbers without any fractional or decimal component. It supports both positive and negative values as well as zero.
  
Example: x = 10, y = -5  

✅ float (Floating Point)

Definition: Represents real numbers that contain a decimal point. Used for representing continuous numerical values.
  
Example: pi = 3.14, rate = -0.5  

✅ bool (Boolean)

Definition: Represents one of two possible values: True or False, commonly used for conditional expressions and logical operations.  
Example: is_valid = True, is_logged_in = False  

✅ complex (Complex Number)

Definition: Represents numbers in the form a + bj, where a is the real part and b is the imaginary part. Used in scientific computing.
  
Example: z = 2 + 3j 

🔷 2. Sequence Data Types
✅ str (String)

Definition: Represents a sequence of Unicode characters used to store textual data. Strings are immutable. 
 
Example: name = "Anvay"  

✅ bytes

Definition: Represents an immutable sequence of bytes (integers in the range 0 to 255), often used for binary data such as files, images, or network communication. 
 
Example: data = b'hello'  

✅ bytearray

Definition: A mutable counterpart of bytes that allows modification of individual bytes. Useful for byte-level operations. 
 
Example: arr = bytearray(b'hello'); arr[0] = 72  

✅ range

Definition: Represents a sequence of integers and is commonly used for iteration in loops. It is memory-efficient and lazily evaluated.  
Example: range(5) → [0, 1, 2, 3, 4]  

🔷 3. List Category
✅ list

Definition: An ordered, mutable collection of items. Lists can store elements of mixed data types and support indexing and slicing.  

Example: numbers = [1, 2, 3, "four"]  

✅ tuple

Definition: An ordered, immutable collection of items. Once created, the elements of a tuple cannot be changed.  
Example: point = (10, 20)  

🔷 4. Set Category
✅ set

Definition: An unordered collection of unique elements. Sets are used for membership testing and eliminating duplicates.  
Example: unique_vals = {1, 2, 3, 4}  

✅ frozenset

Definition: An immutable version of a set. Once created, elements cannot be added or removed, making it hashable and usable as dictionary keys.  
Example: fs = frozenset([1, 2, 3])  

🔷 5. Mapping Type
✅ dict (Dictionary)

Definition: An unordered collection of key-value pairs. Keys must be unique and immutable. Dictionaries are highly optimized for retrieving data based on custom keys. 
 
Example: employee = {"name": "Anvay", "role": "Developer"}  

🔷 6. None Type
✅ NoneType

Definition: Represents the absence of a value or a null object. Used to indicate default, uninitialized, or missing values in variables or function returns.  
Example: result = None  

✅ Summary Table:
Category        Data Type      Description  
Fundamental     int            Whole numbers  
                float          Decimal numbers  
                bool           Logical values (True/False)  
                complex        Complex numbers with real and imaginary parts  
Sequence        str            Text strings  
                bytes          Immutable byte sequences  
                bytearray      Mutable byte sequences  
                range          Range of numbers  
List Category   list           Mutable ordered collection  
                tuple          Immutable ordered collection  
Set Category    set            Unordered unique collection  
                frozenset      Immutable version of a set  
Mapping         dict           Key-value pair collection  
Special         NoneType       Represents no value  

Conclusion on Python Data Types
Python provides a rich variety of built-in data types that allow developers to store and manipulate different kinds of data effectively. Understanding these data types is fundamental to writing clean, efficient, and error-free programs.

• Fundamental types such as int, float, bool, and complex allow handling of numbers and logical values.

• Sequence types like str, list, and tuple enable ordered data storage, with flexibility for mutability.

• Set types (set, frozenset) help manage collections of unique items and support powerful mathematical operations.

• Mapping type (dict) is crucial for associating keys with values, facilitating fast data retrieval.

• The NoneType serves as a special placeholder for missing or undefined data  
Happy Learning Continue the Next Lessons 🙂

PYTHON NUMBER

🔢 Python Numbers (Enhanced)

Python provides three primary numeric data types:

• Integer (int)
• Floating Point (float)
• Complex (complex)

1️⃣ Integer (int)

Integers are whole numbers without decimals. They can be positive, negative, or zero.

a = 10
b = -25
c = 0
print(type(a))  # Output: <class 'int'>

✅ Examples:

age = 21
year = 2025
apples = 5
print(age + apples)  # Output: 26

2️⃣ Floating Point (float)

Floats are numbers with decimal points. Used for more precise values, such as measurements.

height = 5.9
price = 99.99
temperature = -3.14
print(type(price))  # Output: <class 'float'>

✅ Examples:

length = 15.75
width = 2.5
area = length * width
print(area)  # Output: 39.375

3️⃣ Complex (complex)

Complex numbers have a real and imaginary part. Imaginary part is written with a j.

x = 2 + 3j
y = 4j
z = -1 + 0.5j
print(type(x))  # Output: <class 'complex'>

✅ Examples:

a = complex(3, 4)
b = complex(1, -2)
c = a + b
print(c)  # Output: (4+2j)

🔍 Checking Data Types with type()

print(type(100))       # int
print(type(45.67))     # float
print(type(5 + 6j))    # complex

➕ Arithmetic Operations in Python

➕ Addition

x = 15
y = 10
print(x + y)  # Output: 25

➖ Subtraction

x = 20
y = 8
print(x - y)  # Output: 12

✖️ Multiplication

x = 6
y = 7
print(x * y)  # Output: 42

➗ Division

x = 20
y = 4
print(x / y)  # Output: 5.0

Modulus % (Remainder)

x = 10
y = 3
print(x % y)  # Output: 1

Floor Division //

x = 10
y = 3
print(x // y)  # Output: 3

Exponentiation **

x = 2
y = 3
print(x ** y)  # Output: 8

✅ Conclusion

Python supports three numeric types: int, float, and complex.
You can dynamically assign and operate on any number type.
The type() function is useful for checking the data type.
Python supports full arithmetic functionality with clean syntax.
Understanding numeric types is essential for calculations, loops, and data processing.

Happy Learning Continue the Next Lessons 🙂

PYTHON COMMENTS

Python Comments

Comments are lines in the code that are not executed by Python. They are used to explain the code, making it easier to understand for yourself and others who read your code later.

Types of Comments in Python

• Single-line Comments
  Start with the hash symbol #. Everything after # on the same line is a comment.
• Multiline Comments
  Python doesn’t have a dedicated multiline comment syntax, but you can create multiline comments by either:

• Writing multiple single-line comments starting with #
• Using triple quotes ''' ''' or """ """ (technically string literals that are ignored if not assigned)

Why Use Comments?

• To explain what the code does for future reference
• To make the code easier to read and maintain
• To temporarily disable some code during debugging
• To provide documentation for complex logic

Examples of Comments

Example 1: Single-line comment explaining a variable

# This variable stores the user's name
username = "Anvay"

Example 2: Single-line comment to disable code

# print("This line is commented out and won't run")
print("This line will run")

Example 3: Multiline comment using multiple #

# This function adds two numbers
# and returns the result.
def add(a, b):
    return a + b

Example 4: Multiline comment using triple quotes

"""
This is a multiline comment.
It can span multiple lines.
Useful for longer explanations.
"""
print("Hello World")

Example: Factorial Program with Comments

# This program calculates the factorial of a number using a loop

number = 5  # Number to calculate factorial for
factorial = 1  # Initialize factorial variable

"""
The factorial of a number n is the product of all positive integers less than or equal to n.
For example, factorial of 5 is 5 * 4 * 3 * 2 * 1 = 120
"""

for i in range(1, number + 1):
    factorial *= i  # Multiply factorial by the current number i

print(f"The factorial of {number} is {factorial}")  # Display the result

Conclusion

Comments are essential in Python programming as they improve code readability and maintainability.
Use single-line comments (#) for brief explanations and triple quotes (''' ''' or """ """) for longer notes or docstrings. Proper commenting helps both you and others understand the code more easily.

Happy Learning Continue the Next Lessons 🙂

PYTHON STRINGS

What is a String?

A string is a sequence of characters used to store text data. Strings are enclosed within single quotes ('...'), double quotes ("..."), or triple quotes ('''...''' or """...""") for multiline strings. Strings represent words, sentences, or any textual information.

Why are Strings Immutable?

Strings in Python are immutable, meaning once created, their contents cannot be changed. Any modification creates a new string object instead.
Reasons for immutability:

• Ensures program safety and data integrity
• Allows strings to be used as dictionary keys (hashable)
• Enables Python optimizations like string interning

Creating Strings

# Using single quotes
text1 = 'Hello World!'
print(text1)

# Using double quotes
text2 = "Hello World!"
print(text2)

Single-Quoted String

text = 'Hello, this is a single-quoted string.'
print(text)

Double-Quoted String

text = "Hello, this is a double-quoted string."
print(text)

Note:

Both are treated the same by Python. Use single quotes if your string contains double quotes inside it, and vice versa, to avoid the need for escaping characters.
Example:

text = 'He said, "Python is awesome!"'
print(text)

text2 = "It's a great day to learn Python."
print(text2)

single quotes (''') for multiline strings as well:

a = """This is a multiline string
using triple double quotes."""

b = '''This is another multiline string
using triple single quotes.'''

print(a)
print()
print(b)

Output:

This is a multiline string
using triple double quotes.

This is another multiline string
using triple single quotes.

Multiline Strings

You can create strings that span multiple lines using triple quotes (''' ''' or """ """):

# Using triple single quotes
text = '''Python is fun to learn,
for sure you are having fun learning Python too.'''
print(text)

# Using triple double quotes
text = """Python is fun to learn,
for sure you are having fun learning Python too."""
print(text)

String Operations and Definitions

1. String Repetition

Definition: String repetition duplicates the string a specified number of times using the * operator.

print("Hi! " * 3)  
# Output: Hi! Hi! Hi! 

2. String Concatenation

Definition: Concatenation joins two or more strings end-to-end using the + operator.

print("Hello" + " " + "World")  
# Output: Hello World

3. Indexing

Definition: Indexing accesses individual characters in a string by their position, starting at 0.

word = "Python"
print(word[0])  # Output: P
print(word[3])  # Output: h

4. Length

Definition: The length of a string is the total number of characters it contains, including spaces and punctuation. Use len() function to find length.

print(len("Hello Python"))  
# Output: 12

5. Slicing

Definition: Slicing extracts a substring from a string by specifying a range of indexes [start:end].

text = "Hello Python"
print(text[0:5])  # Output: Hello
print(text[6:])   # Output: Python

Additional Examples

# Repetition
print("Python! " * 2)  # Python! Python! 

# Concatenation
greeting = "Good" + " " + "Morning"
print(greeting)  # Good Morning

# Indexing
language = "Python"
print(language[1])  # y

# Length
print(len("Data Science"))  # 12

# Slicing
msg = "Artificial Intelligence"
print(msg[0:10])   # Artificial
print(msg[11:])    # Intelligence

Conclusion

Strings are essential data types in Python for representing text.
They are immutable, which means they cannot be changed once created, ensuring safer and more efficient code.
Mastering string operations like repetition, concatenation, indexing, length calculation, and slicing empowers you to manipulate text effectively in your programs.

Happy Learning Continue the Next Lessons 🙂

String Methods

String methods

Python String Methods

Strings in Python come with many useful methods to perform various operations like changing case, searching, replacing, splitting, and more.
Here are some commonly used string methods with examples:

Capitalize String

The capitalize() method in Python returns a copy of the string with its first character converted to uppercase and the rest of the characters converted to lowercase.

Example 1:
text1 = "hello world"
print(text1.capitalize())  
# Output: Hello world

Example 2:
text2 = "PYTHON programming"
print(text2.capitalize())  
# Output: Python programming

Example 3:
text3 = "mY naME is Anvay"
print(text3.capitalize())
# Output: My name is anvay

Convert to Uppercase:

The upper() method in Python converts all the characters in a string to uppercase letters. It returns a new string with all letters capitalized, leaving the original string unchanged.

Example1:
text1 = "hello world"
print(text1.upper())  # Output: HELLO WORLD

Example2:
text2 = "Python Programming"
print(text2.upper())  # Output: PYTHON PROGRAMMING

Example3:
text3 = "123abc!@#"
print(text3.upper())  # Output: 123ABC!@#

Convert to Lowercase:

The lower() method in Python converts all the characters in a string to lowercase letters. It returns a new string with all letters converted to lowercase, leaving the original string unchanged.

Example1:
text1 = "HELLO WORLD"
print(text1.lower())  # Output: hello world

Example2:
text2 = "Python Programming"
print(text2.lower())  # Output: python programming

Example3:
text3 = "123ABC!@#"
print(text3.lower())  # Output: 123abc!@#

Replacing Parts of a String:

The replace() method in Python is used to replace occurrences of a specified substring within a string with another substring. It returns a new string with the replacements made and does not modify the original string.

Syntax:
string.replace(old, new, count)
• old: The substring you want to replace.
• new: The substring to replace with.
• count (optional): The maximum number of occurrences to replace. If omitted, all occurrences will be replaced.

Example1:
text = "I love apples"
new_text = text.replace("apples", "oranges")
print(new_text)  # Output: I love oranges

Example2:
text2 = "banana banana banana"
new_text2 = text2.replace("banana", "grape", 2)
print(new_text2)  # Output: grape grape banana

Example3:
text3 = "hello world"
new_text3 = text3.replace("world", "Python")
print(new_text3)  # Output: hello Python

Example4:
sentence = "Python is a great programming language. Many developers love Python because Python is versatile and powerful."
updated_sentence = sentence.replace("Python", "JavaScript", 2)
print(updated_sentence)

Output:
JavaScript is a great programming language. Many developers love JavaScript because Python is versatile

The replace() method is useful when you want to modify parts of a string without changing the entire content.

Checking if a Value is Present in a String

In Python, you can check whether a specific substring or character is present within a string using the keyword in. This is a simple and efficient way to verify if a value exists in a string.

Explanation:
• The in operator returns a Boolean value (True or False).
• It checks if the specified substring or character is part of the given string.
• If found, it returns True; otherwise, it returns False.

Examples:
 Example 1
text = "Hello, welcome to Python programming."
print("Python" in text)  # Output: True

 Example 2
text = "Data Science is fun."
print("data" in text)  # Output: False (case-sensitive)

# Example 3
text = "I love coffee."
print("tea" in text)  # Output: False

Note : The in operator is a powerful and straightforward way to check for the presence of a substring within a string in Python. Remember, this check is case-sensitive. If you want a case-insensitive search, convert both strings to the same case (e.g., using .lower()).

Conclusion

Python string methods provide a versatile and powerful toolkit for working with text data. They allow you to easily manipulate, analyze, and transform strings without having to write complex code. From changing case with methods like .upper() and .lower(), to checking contents with in or .find(), and modifying strings using .replace() or .strip(), these built-in functions make string handling intuitive and efficient.
Understanding and mastering these string methods is essential for any Python programmer, as strings are a fundamental data type used in nearly every application, from data processing to web development. By leveraging these methods, you can write cleaner, more readable, and more efficient code.

Happy Learning Continue the Next Lessons 🙂

INDENTATION

1. What Is Indentation in Python?

In Python, indentation refers to the spaces or tabs used at the beginning of a line of code to define the level of nesting within structures like loops, functions, and conditionals. It indicates the start and end of a code block, such as a block of code inside an if statement or a for loop.

Unlike other programming languages that rely on braces or parentheses to group statements, Python uses indentation to establish scope. Python uses indentation to indicate which statements belong to the same block.

2. How Indentation Works in Python

Python requires consistent indentation within the same block of code. This means that all lines in a block should have the same amount of space or tab at the beginning. If the indentation is inconsistent, Python will raise an IndentationError.

Example:

x = 5
if x > 3:
    print("x is greater than 3")
    x = x - 1
print("x after modification:", x)

In this example, the statements inside the if block are indented with four spaces, which tells Python they are part of the same block.

3. Why Indentation Is Important in Python

Readability: Indentation makes Python code more readable and easy to follow. It clearly shows the structure and relationships between different parts of the program.

Syntax Enforcement: In Python, indentation is mandatory for defining code blocks. A failure to use proper indentation will lead to syntax errors, preventing the code from running.

Error Prevention: Indentation helps prevent logical errors in your code by visually representing the code structure.

4. Common Indentation Errors in Python

While Python’s indentation rules help with clarity, they can also lead to errors if not followed properly. Some common indentation mistakes include:

• Inconsistent indentation: Mixing tabs and spaces in the same block.
• Incorrect level of indentation: Using too many or too few spaces for nested blocks.

Example of an error due to inconsistent indentation:

x = 10
if x > 5:
    print("x is greater than 5")
  print("This line has incorrect indentation")  # This will raise an IndentationError

In this example, the second print statement has an inconsistent indentation level, which results in an IndentationError.

5. Best Practices for Indentation in Python

To ensure your Python code is error-free and readable, follow these best practices:

• Use 4 spaces per indentation level: This is the convention recommended by the Python community and defined in PEP 8 (Python's style guide).
• Avoid mixing tabs and spaces: Always use spaces for indentation. Mixing tabs and spaces leads to errors and confusion.
• Be consistent: Ensure that all lines in a block are indented at the same level. For nested blocks, use additional indentation.
• Use an IDE or code editor that supports automatic indentation: Most modern code editors and IDEs automatically handle indentation for you, reducing the risk of errors.

6. Indentation with Loops and Conditional Statements

Indentation is essential in defining the body of loops and conditional statements. Without proper indentation, Python will not be able to distinguish the start and end of the block.

Example:

x = 10
if x > 5:
    print("x is greater than 5")
    for i in range(x):
        print(i)

Here, the print(i) statement is part of the for loop and is indented accordingly.

7. Indentation in Functions and Classes

Functions and classes in Python also rely on indentation to define their body. When defining a function or class, the code inside them must be indented to indicate it belongs to that block.

Example:

def greet(name):
    print(f"Hello, {name}!")
    
greet("Alice")  # Output: Hello, Alice!

In this example, the print statement is part of the function greet because it is indented under the function definition.

Conclusion: Mastering Indentation in Python

Indentation is crucial for writing clean, readable, and error-free Python code. Unlike many other programming languages, Python uses indentation to define the structure of the code, making it an integral part of the language. By understanding the importance of indentation, adhering to best practices, and avoiding common errors, you can improve the readability and maintainability of your Python code.

Key Takeaways:

• Indentation defines code blocks in Python and is essential for proper program structure.
• Use 4 spaces per indentation level, and avoid mixing tabs and spaces.
• Consistent indentation ensures the correctness of your code and prevents errors.
• Python's strict indentation rules enforce readability and clarity, making your code easier to understand and debug.

By mastering indentation in Python, you can avoid common mistakes and write clean, efficient code that follows industry best practices.

Happy Learning Continue the Next Lessons 🙂

CONDITIONAL STATEMENTS

Understanding Conditional Statements in Python: A Comprehensive Guide

Conditional statements are a fundamental concept in Python programming, allowing you to execute different code based on certain conditions. By using conditional statements, you can control the flow of your Python programs, making them more dynamic and responsive to various inputs. In this guide, we’ll explore how conditional statements work in Python and provide examples for practical use.

1. What Are Conditional Statements in Python?

Conditional statements are used to make decisions in your Python code. They allow you to execute a block of code if a certain condition is met and execute a different block if the condition is not met. Python provides several ways to handle conditional logic, such as if, elif, and else statements.

2. Basic if Statement in Python

The if statement in Python is the simplest form of a conditional statement. It checks if a given condition evaluates to True. If the condition is True, the block of code under the if statement is executed.

Example:

age = 18
if age >= 18:
    print("You are eligible to vote.")  # Output: You are eligible to vote.

In this example, the if statement checks whether the value of age is greater than or equal to 18. Since the condition is True, the message is printed.

3. Using else with if Statements

The else statement is used to define a block of code that should be executed if the condition in the if statement evaluates to False. It's useful for handling the alternative case.

Example:

age = 16
if age >= 18:
    print("You are eligible to vote.")
else:
    print("You are not eligible to vote.")  # Output: You are not eligible to vote.

In this case, since the age is less than 18, the else block is executed.

4. Using elif for Multiple Conditions

The elif (short for "else if") statement allows you to check multiple conditions in sequence. If the condition for if is False, Python checks the elif condition, and so on. This is useful when you need to test more than two conditions.

Example:

age = 20
if age < 18: print("You are a minor.") elif age >= 18 and age < 65:
    print("You are an adult.")  # Output: You are an adult.
else:
    print("You are a senior citizen.")

In this example, Python first checks if the age is less than 18, and if it's not, it checks if the age is between 18 and 65. If both conditions are False, the else block is executed.

5. Nested Conditional Statements

You can also nest conditional statements, meaning you can have if statements inside other if, elif, or else blocks. This allows for more complex decision-making logic.

Example:

age = 25
if age >= 18:
    if age < 30:
        print("You are a young adult.")  # Output: You are a young adult.
    else:
        print("You are an adult.")
else:
    print("You are a minor.")

Here, the program first checks if the person is 18 or older, and if so, checks if they are younger than 30.

6. Short-Circuiting with and and or

In Python, you can combine multiple conditions using logical operators like and and or to make your conditional checks more powerful.

and ensures that all conditions must be True for the block of code to execute.

or ensures that at least one of the conditions must be True for the block of code to execute.

Example:

age = 30
is_student = False

if age >= 18 and is_student:
    print("You are an adult student.")
else:
    print("You are either not an adult or not a student.")  # Output: You are either not an adult or not a student.

In this example, both conditions need to be True for the message "You are an adult student" to be printed.

7. The Ternary Operator (Conditional Expression)

Python also supports a shorthand way to write conditional statements using the ternary operator, which allows you to assign a value based on a condition.

Example:

age = 20
status = "Adult" if age >= 18 else "Minor"
print(status)  # Output: Adult

The ternary operator simplifies conditional logic by writing a simple if-else statement in a single line.

Conclusion: Mastering Conditional Statements in Python

Conditional statements in Python are essential for building dynamic programs that respond to different conditions. By using if, elif, else, and logical operators, you can control the flow of your program and make decisions based on the data. Understanding how to use conditional statements efficiently is crucial for solving problems and building more complex Python applications.

Key Takeaways:

• if allows you to execute code based on a condition.
• else handles the alternative case when the condition is false.
• elif is useful when checking multiple conditions.
• You can use logical operators like and and or to combine multiple conditions.
• Nested conditionals and the ternary operator provide more advanced ways to handle decisions in Python.

By mastering these conditional statements and their variations, you'll be able to write flexible and robust Python code. Conditional statements are a cornerstone of programming logic, making them an essential concept in Python development.

Happy Learning Continue the Next Lessons 🙂

Operators

Python Operators Introduction

In Python, operators are special symbols or keywords used to perform operations on variables and values. They are the building blocks for performing computations, comparisons, logical operations, and more.

What Are Operators?

Operators are used to manipulate data and variables. For example, + adds two numbers, == checks for equality, etc.

Types of Operators in Python (some main ones):

 	
Arithmetic Operators: +, -, *, /, //, %, **
 	
Comparison (Relational) Operators: ==, !=, >, <, >=, <=
 	
Logical Operators: and, or, not
 	
Assignment Operators: =, +=, -=, *=, /=
 	
Bitwise Operators: &, |, ^, ~, <<, >>
 	
Membership Operators: in, not in
 	
Identity Operators: is, is not

Four Examples in Python

1. Arithmetic Operator

a = 10
b = 5
print(a + b)  # Output: 15

2. Comparison Operator

print(a > b)  # Output: True

3. Logical Operator

print(a > 5 and b < 10)  # Output: True

4. Assignment Operator

x = 7
x += 3
print(x)  # Output: 10

Happy Learning Continue the Lessons 🙂

ARITHEMATIC OPERATORS

Python Arithmetic Operators

1. What are Arithmetic Operators in Python?
Arithmetic operators in Python are used to perform mathematical operations such as addition, subtraction, multiplication, division, and more between numeric values.

2. The 7 Basic Arithmetic Operators

Operator      Name                 Description
+              Addition                    Adds two values
-               Subtraction             Subtracts right value from left
*               Multiplication       Multiplies two values
/               Division               Divides left value by right, returns float
**            Exponentiation      Raises left value to the power of the right
%               Remainder (Modulus)    Returns the remainder after division
//             Floor Division           Returns the integer part of the division result

3. Operator Definitions and Examples

1. Addition Operators (+)

The addition operator (+) in Python is used to add two numeric values or variables together. It combines the values and returns their sum.

It can also be used to concatenate strings, but in arithmetic, it strictly means mathematical addition.

print(5 + 3)        # 8
print(10 + 20)      # 30
print(-5 + 7)       # 2
print(2.5 + 4.5)    # 7.0
  

2. Subtraction (-)

The subtraction operator (-) in Python is used to subtract the right-hand operand from the left-hand operand. It returns the difference between two numeric values or variables.

print(10 - 4)       # 6
print(20 - 30)      # -10
print(-5 - (-3))    # -2
print(7.5 - 2.5)    # 5.0
  

3. Multiplication (*)

The multiplication operator (*) in Python is used to multiply two numeric values or variables. It returns the product of the operands.

print(4 * 3)        # 12
print(-5 * 6)       # -30
print(2.5 * 2)      # 5.0
print(0 * 100)      # 0
  

4. Division (/)

The division operator (/) in Python divides the left-hand operand by the right-hand operand and returns the result as a floating-point number (decimal).

print(10 / 2)       # 5.0
print(7 / 2)        # 3.5
print(-9 / 3)       # -3.0
print(5 / 4)        # 1.25
  

5. Exponentiation (**)

The exponentiation operator (**) in Python raises the left-hand operand to the power of the right-hand operand. It performs power calculations (e.g., squares, cubes, etc.).

print(2 ** 3)       # 8
print(5 ** 2)       # 25
print(9 ** 0.5)     # 3.0
print(4 ** -1)      # 0.25
  

6. Remainder (%)

The remainder operator (%) in Python returns the remainder left over after dividing the left-hand operand by the right-hand operand. It is also called the modulus operator.

print(10 % 3)       # 1
print(15 % 4)       # 3
print(9 % 2)        # 1
print(5 % 5)        # 0
  

Floor Division (//)

The floor division operator (//) in Python divides the left-hand operand by the right-hand operand and returns the largest integer less than or equal to the result (i.e., it rounds down to the nearest whole number).

print(10 // 3)      # 3
print(7 // 2)        # 3
print(9.5 // 2)      # 4.0
print(-10 // 3)      # -4
  

Operator Precedence (Evaluation Order)

Operator precedence determines the order in which operators are evaluated in an expression. Operators with higher precedence are evaluated before operators with lower precedence.

In Python, the precedence of arithmetic operators from highest to lowest is:

Order of Precedence:
** (Exponentiation)
*, /, //, % (Multiplication, Division, Floor Division, Modulus)
+, - (Addition, Subtraction)

📌 Example:

result = 5 + 2 * 3 ** 2 // 4 - 1
# 3 ** 2 = 9
# 2 * 9 = 18
# 18 // 4 = 4
# 5 + 4 = 9
# 9 - 1 = 8
print(result)  # Output: 8
  

📝 Conclusion

Python provides 7 basic arithmetic operators to perform common mathematical operations. Understanding how each operator works, along with operator precedence, is essential for writing accurate and efficient mathematical expressions in Python. Mastery of these operators builds the foundation for more complex logic and programming tasks.

Happy Learning Continue the Lessons 🙂

ASSIGNMENT OPERATORS IN PYTHON

1. What are Assignment Operators?

Assignment operators are used to assign values to variables. They can also perform an operation and assign the result to the variable in one step.

2. Basic Assignment Operator (=)

Assigns the value on the right to the variable on the left.

x = 5
y = 10
z = x + y
print(z)   # Output: 15
  

3. Compound Assignment Operators

These operators combine an arithmetic operation with assignment:

x = 10

x += 5    # Equivalent to x = x + 5
print(x)  # Output: 15

x -= 3    # Equivalent to x = x - 3
print(x)  # Output: 12

x *= 2    # Equivalent to x = x * 2
print(x)  # Output: 24

x /= 4    # Equivalent to x = x / 4
print(x)  # Output: 6.0

x %= 4    # Equivalent to x = x % 4
print(x)  # Output: 2.0

x //= 2   # Equivalent to x = x // 2 (floor division)
print(x)  # Output: 1.0

x **= 3   # Equivalent to x = x ** 3 (exponentiation)
print(x)  # Output: 1.0
  

4. Summary of Compound Assignment Operators

Operator | Meaning

+=    Add and assign
-=    Subtract and assign
*=    Multiply and assign
/=    Divide and assign
%=    Modulus and assign
//=   Floor divide and assign
**=   Exponentiate and assign
  

📝 Example in one snippet:

a = 8
a += 2      # a = 10
a *= 3      # a = 30
a -= 5      # a = 25
a /= 5      # a = 5.0

print(a)    # Output: 5.0
  

Happy Coding! Keep practicing assignment operators 🙂

COMPARISON OPERATORS IN PYTHON

1. What are Comparison Operators?

Comparison operators compare two values and return a Boolean result: True or False.

2. List of Python Comparison Operators

Operator    Description
==          Equal to
!=          Not equal to
>          Greater than
<          Less than
>=         Greater than or equal to
<=         Less than or equal to
  

3. Examples of Comparison Operators

x = 10
y = 20
z = 10
  

print(x == y)    # False, because 10 is not equal to 20
  

print(x == z)    # True, because 10 is equal to 10
  

print(x != y)    # True, because 10 is not equal to 20
  

print(x > y)   # False, because 10 is not greater than 20
  

print(x < y)   # True, because 10 is less than 20
  

print(x >= z)  # True, because 10 is equal to 10
  

print(y <= 15) # False, because 20 is not less than or equal to 15
  

Comparison between strings

print("apple" == "apple")      # True
  

print("apple" != "banana")     # True
  

print("apple" < "banana")   # True, because 'a' comes before 'b' alphabetically
  

Comparison between boolean values

print(True == 1)   # True, because True is equivalent to 1 in Python
  

print(False < 1) # True, because False is equivalent to 0
  

4. Using Comparison Operators in Conditional Statements

age = 18
if age >= 18:
    print("You are eligible to vote.")
else:
    print("You are not eligible to vote.")
  

score = 75
if score >= 90:
    print("Grade: A")
elif score >= 75:
    print("Grade: B")
elif score >= 60:
    print("Grade: C")
else:
    print("Grade: F")
  

5. Combining Comparison Operators with Logical Operators

temperature = 25
humidity = 80

if temperature > 20 and humidity > 70:
    print("It's hot and humid.")
else:
    print("Weather is comfortable.")
  

score = 85
if score >= 90 or score < 70:
    print("Special attention needed.")
else:
    print("Score is normal.")
  

📝 Summary

Comparison operators allow you to compare values and control program flow based on those comparisons. They work with numbers, strings, booleans, and other comparable data types.

Happy Learning continue the next lesson 🙂

LOGICAL OPERATORS IN PYTHON

1. What are Logical Operators?

Logical operators combine conditional statements and return True or False based on the logic applied.

2. List of Logical Operators in Python

and     Returns True if both statements are true
or      Returns True if one of the statements is true
not     Reverse the result, returns False if the result is true
  

3. Examples of Logical Operators

a = True
b = False
  

print(a and b)    # False, because both are not True
  

print(a or b)     # True, because at least one is True (a)
  

print(not a)      # False, reverses True to False
  

print(not b)      # True, reverses False to True
  

Using Logical Operators with Comparison Operators

x = 10
y = 20

print(x < 15 and y > 15)   # True (10 < 15 is True and 20 > 15 is True)
  

print(x < 15 or y < 15)    # True (x < 15 is True, y < 15 is False, True or False = True)
  

print(not(x < y))             # False, because x < y is True, not True = False
  

Using Logical Operators in Conditional Statements

age = 25
income = 50000

if age >= 18 and income >= 30000:
    print("Eligible for loan")
else:
    print("Not eligible for loan")
  

username = "admin"
password = "1234"

if username == "admin" or password == "admin":
    print("Access granted")
else:
    print("Access denied")
  

Combining multiple logical operators

x = 5
y = 10
z = 15

if (x < y and y < z) or not(x == 5):
    print("Condition met")
else:
    print("Condition not met")
  

📝 Summary

Logical operators help in combining multiple conditions and control the flow of the program based on multiple criteria.

Happy Learning continue the next lesson 🙂

IDENTITY OPERATORS IN PYTHON

1. What are Identity Operators?

Identity operators compare the memory locations of two objects, i.e., they check whether two variables point to the same object in memory.

2. Identity Operators in Python

is       Returns True if both variables refer to the same object
is not   Returns True if both variables do NOT refer to the same object
  

3. Examples of Identity Operators

x = [1, 2, 3]
y = x
print(x is y)        # True, both point to the same list object
  

x = [1, 2, 3]
y = [1, 2, 3]
print(x is y)        # False, different objects with same content
  

print(x == y)        # True, because values inside the lists are equal
  

a = 10
b = 10
print(a is b)        # True, small integers are cached by Python (same object)
  

a = 500
b = 500
print(a is b)        # Usually False, larger integers may not be cached
  

x = "hello"
y = "hello"
print(x is y)        # True, string literals may refer to the same object (interning)
  

print(x is not y)    # False, because x and y refer to the same object
  

📝 Summary

The is and is not operators are useful when you want to check if two variables refer to the exact same object, not just if they have the same value.

Happy Learning continue the lesson 🙂

MEMBERSHIP OPERATORS IN PYTHON

1. What are Membership Operators?

Membership operators test if a value or variable exists in a sequence (like strings, lists, tuples, sets, or dictionaries).

2. Membership Operators in Python

in      Returns True if value is found in the sequence
not in  Returns True if value is NOT found in the sequence
  

3. Examples of Membership Operators

fruits = ["apple", "banana", "cherry"]

print("banana" in fruits)      # True
print("grape" in fruits)       # False
print("grape" not in fruits)   # True
  

text = "Hello, world!"

print("Hello" in text)         # True
print("hello" in text)         # False (case-sensitive)
print("Hi" not in text)        # True
  

numbers = (1, 2, 3, 4, 5)

print(3 in numbers)            # True
print(6 not in numbers)        # True
  

my_set = {10, 20, 30, 40}

print(20 in my_set)            # True
print(50 not in my_set)        # True
  

my_dict = {"name": "Alice", "age": 25}

print("name" in my_dict)       # True (checks keys)
print("Alice" in my_dict)      # False (values not checked)
  

📝 Summary

Use in and not in to check whether an element exists in a sequence or not. These operators are very useful for searching or condition checks.

Happy Learning continue the next lesson 🙂 🙂

Python Lists: Complete Guide with Examples

1. What is a Python List?

A list in Python is an ordered collection of items which can be of different types (numbers, strings, objects, etc.). Lists are mutable, meaning you can change their contents after creation.

# Example of a list
fruits = ["apple", "banana", "cherry"]
print(fruits) # Output: ['apple', 'banana', 'cherry']

2. Indexing

You can access individual elements in a list using their index. Indexing starts at 0 for the first element.

fruits = ["apple", "banana", "cherry"]
print(fruits[0]) # apple
print(fruits[1]) # banana
print(fruits[2]) # cherry

3. Negative Indexing

Negative indexing lets you access elements from the end of the list, starting at -1 for the last element.

fruits = ["apple", "banana", "cherry"]
print(fruits[-1]) # cherry (last item)
print(fruits[-2]) # banana
print(fruits[-3]) # apple

4. Range of Index (Slicing)

You can access a range (slice) of items using start:end notation. It returns elements from start up to but not including end.

fruits = ["apple", "banana", "cherry", "date", "elderberry"]
print(fruits[1:4]) # ['banana', 'cherry', 'date']
print(fruits[:3]) # ['apple', 'banana', 'cherry']
print(fruits[2:]) # ['cherry', 'date', 'elderberry']

5. Adding Items to a List

Use append() to add a single item at the end, or insert() to add at a specific index.

fruits = ["apple", "banana"]
fruits.append("cherry")
print(fruits) # ['apple', 'banana', 'cherry']
fruits.insert(1, "blueberry")
print(fruits) # ['apple', 'blueberry', 'banana', 'cherry']

6. Deleting Items from a List

Use del, remove(), or pop() to delete items.

fruits = ["apple", "banana", "cherry"]
del fruits[1] # deletes item at index 1
print(fruits) # ['apple', 'cherry']
fruits.remove("apple") # removes first occurrence of "apple"
print(fruits) # ['cherry']
popped_item = fruits.pop() # removes and returns last item
print(popped_item) # cherry
print(fruits) # []

7. Getting the Length of a List

fruits = ["apple", "banana", "cherry"]
print(len(fruits)) # 3

8. Changing an Item’s Value

fruits = ["apple", "banana", "cherry"]
fruits[1] = "blueberry"
print(fruits) # ['apple', 'blueberry', 'cherry']

9. Checking if an Item Exists

fruits = ["apple", "banana", "cherry"]
print("banana" in fruits) # True
print("grape" not in fruits) # True

10. Extending a List

Use extend() to add all elements of another list.

fruits = ["apple", "banana"]
tropical = ["mango", "pineapple"]
fruits.extend(tropical)
print(fruits) # ['apple', 'banana', 'mango', 'pineapple']

11. Loop Through a List

fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit) # Output:
                 # apple
                 # banana
                 # cherry

12. Another Way to Create a List (Using list() Constructor)

numbers = list((1, 2, 3, 4))
print(numbers) # [1, 2, 3, 4]
chars = list("hello")
print(chars) # ['h', 'e', 'l', 'l', 'o']

More Examples

# Combining lists with + operator
a = [1, 2, 3]
b = [4, 5, 6]
c = a + b
print(c) # [1, 2, 3, 4, 5, 6]

# Repeating lists
print(a * 3) # [1, 2, 3, 1, 2, 3, 1, 2, 3]

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

Conclusion

Python lists are a powerful and flexible way to store and manipulate collections of items. Understanding how to use lists effectively will greatly enhance your programming skills.

Happy Learning Continue the next lesson 🙂

Python Tuples

1. What is a Tuple?

A tuple in Python is an ordered collection of items, similar to a list. However, tuples are immutable, meaning once created, their contents cannot be changed.

# Example of a tuple with strings
fruits = ("apple", "banana", "cherry")
print(fruits) # Output: ('apple', 'banana', 'cherry')

# Example of a tuple with mixed data types
person = ("Alice", 30, True)
print(person) # Output: ('Alice', 30, True)
  

2. Creating a Tuple

Tuples are created by placing items inside parentheses (), separated by commas.

# Creating a tuple with integers
numbers = (1, 2, 3, 4)
print(numbers) # (1, 2, 3, 4)

# Single item tuple requires a comma
single = (5,)
print(single) # (5,)

# Creating a tuple without parentheses (tuple packing)
colors = "red", "green", "blue"
print(colors) # ('red', 'green', 'blue')
  

3. Indexing

You can access tuple elements using their index, starting at 0.

fruits = ("apple", "banana", "cherry")
print(fruits[0]) # apple
print(fruits[1]) # banana
print(fruits[2]) # cherry

# Accessing nested tuple elements
nested = (1, 2, ("a", "b", "c"))
print(nested[2][1])  # b
  

4. Negative Indexing

Negative indexes start from the end, with -1 being the last element.

fruits = ("apple", "banana", "cherry")
print(fruits[-1]) # cherry
print(fruits[-2]) # banana
print(fruits[-3]) # apple

# Negative index in nested tuples
nested = (1, 2, ("a", "b", "c"))
print(nested[-1][-1])  # c
  

5. Range of Indexes (Slicing)

You can slice a tuple using start:end notation, which returns a new tuple with elements from start up to (but not including) end.

fruits = ("apple", "banana", "cherry", "date", "elderberry")
print(fruits[1:4]) # ('banana', 'cherry', 'date')
print(fruits[:3])  # ('apple', 'banana', 'cherry')
print(fruits[2:])  # ('cherry', 'date', 'elderberry')

# Using step in slicing
print(fruits[::2]) # ('apple', 'cherry', 'elderberry')
print(fruits[1:5:2]) # ('banana', 'date')
  

6. Getting the Length of a Tuple

fruits = ("apple", "banana", "cherry")
print(len(fruits)) # 3

empty = ()
print(len(empty))  # 0
  

7. Looping Through a Tuple

fruits = ("apple", "banana", "cherry")
for fruit in fruits:
    print(fruit)

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

8. Checking if an Item Exists

fruits = ("apple", "banana", "cherry")
print("banana" in fruits)  # True
print("grape" not in fruits)  # True

# Using conditional statement
if "apple" in fruits:
    print("Apple is in the tuple!")
else:
    print("Apple not found.")
  

9. Another Way to Create a Tuple (Using tuple() Constructor)

numbers = tuple([1, 2, 3, 4])
print(numbers)  # (1, 2, 3, 4)

chars = tuple("hello")
print(chars)  # ('h', 'e', 'l', 'l', 'o')

# Converting list to tuple
list_data = [10, 20, 30]
tuple_data = tuple(list_data)
print(tuple_data)  # (10, 20, 30)
  

10. Combining Tuples

You can concatenate tuples with the + operator to create a new tuple.

a = (1, 2, 3)
b = (4, 5, 6)
c = a + b
print(c)  # (1, 2, 3, 4, 5, 6)

# Repeating a tuple multiple times
d = ("repeat",) * 3
print(d)  # ('repeat', 'repeat', 'repeat')
  

11. Tuples are Immutable

Once created, tuple elements cannot be changed, added, or removed. Attempting to modify a tuple will raise an error.

fruits = ("apple", "banana", "cherry")
# This will raise an error:
# fruits[1] = "blueberry"  # TypeError: 'tuple' object does not support item assignment

# You can reassign the whole tuple variable
fruits = ("blueberry", "kiwi", "mango")
print(fruits)  # ('blueberry', 'kiwi', 'mango')
  

Conclusion

Tuples are ideal for storing fixed collections of data that should not be changed accidentally. Their immutability makes them faster and safer in many cases compared to lists. You can use tuples wherever you want ordered, immutable sequences.

Happy Learning Continue the next Lesson 🙂

Python Sets

1. What is a Set?

A set is an unordered collection of unique items in Python. Sets do not allow duplicate elements and are mutable, but their elements must be immutable.

# Example of a set with unique items
fruits = {"apple", "banana", "cherry"}
print(fruits)  # Output order may vary, e.g. {'banana', 'apple', 'cherry'}

# Duplicate items are ignored
numbers = {1, 2, 2, 3, 4, 4}
print(numbers)  # Output: {1, 2, 3, 4}
  

2. Creating a Set

Use curly braces {} or the set() constructor to create sets.

# Using curly braces
my_set = {10, 20, 30}
print(my_set)  # {10, 20, 30}

# Using the set() constructor from a list
my_set2 = set([1, 2, 3, 4])
print(my_set2)  # {1, 2, 3, 4}

# Empty set must be created with set(), {} creates an empty dict
empty_set = set()
print(empty_set)  # set()
  

3. Accessing Items in a Set

Since sets are unordered, you cannot access items by index. Instead, you can loop through the set to access each item.

colors = {"red", "green", "blue"}

for color in colors:
    print(color)  # Prints items in any order

# Convert set to list to access by index
colors_list = list(colors)
print(colors_list[0])  # Access first item (order not guaranteed)
  

4. Adding Items to a Set

Use add() to add a single item and update() to add multiple items.

fruits = {"apple", "banana"}

fruits.add("cherry")
print(fruits)  # {'banana', 'apple', 'cherry'}

fruits.update(["orange", "mango"])
print(fruits)  # {'banana', 'apple', 'orange', 'mango', 'cherry'}
  

5. Changing an Item in a Set?

Sets are mutable, but you cannot change an individual item directly because items are unordered and unique.

To "change" an item, remove the old item and add a new one.

fruits = {"apple", "banana", "cherry"}

# Remove 'banana' and add 'blueberry'
fruits.remove("banana")
fruits.add("blueberry")
print(fruits)  # {'apple', 'blueberry', 'cherry'}
  

6. Getting the Length of a Set

fruits = {"apple", "banana", "cherry"}
print(len(fruits))  # 3

empty_set = set()
print(len(empty_set))  # 0
  

7. Check if an Item Exists in a Set

fruits = {"apple", "banana", "cherry"}

print("banana" in fruits)  # True
print("grape" in fruits)   # False

# Using if-else
if "cherry" in fruits:
    print("Cherry is present!")
else:
    print("Cherry is not present.")
  

8. Combine Two Sets

Use union() or the | operator to combine sets.

set1 = {1, 2, 3}
set2 = {3, 4, 5}

combined = set1.union(set2)
print(combined)  # {1, 2, 3, 4, 5}

# Using | operator
combined2 = set1 | set2
print(combined2)  # {1, 2, 3, 4, 5}
  

9. Difference of Two Sets

Find items in one set but not in another using difference() or - operator.

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

diff = set1.difference(set2)
print(diff)  # {1, 2}

# Using - operator
diff2 = set1 - set2
print(diff2)  # {1, 2}
  

10. Another Way to Create a Set

You can create a set from any iterable like lists, strings, or tuples using the set() constructor.

# From a string
letters = set("hello")
print(letters)  # {'e', 'h', 'l', 'o'} - order may vary, duplicates removed

# From a tuple
tuple_data = (1, 2, 3, 2, 4)
set_from_tuple = set(tuple_data)
print(set_from_tuple)  # {1, 2, 3, 4}
  

Conclusion

Sets are a powerful Python data structure perfect for storing unique items, performing mathematical set operations, and working with unordered collections. They are mutable but do not allow duplicates and cannot be indexed.

Happy Learning Continue to the next lesson 🙂

Python Dictionaries

1. What is a Dictionary

A dictionary in Python is a collection of key-value pairs. Each key must be unique and immutable (e.g., string, number, or tuple). Dictionaries are unordered in versions below Python 3.7, but ordered from Python 3.7 onwards.

# Example of a dictionary
student = {
    "name": "Alice",
    "age": 20,
    "grade": "A"
}
print(student)
  

2. Accessing Items

Access dictionary items using square brackets or the get() method.

student = {"name": "Alice", "age": 20}

print(student["name"])        # Output: Alice
print(student.get("age"))     # Output: 20
  

3. Adding Items

Add a new key-value pair by assigning a value to a new key.

student = {"name": "Alice"}

student["grade"] = "A"
print(student)  # {'name': 'Alice', 'grade': 'A'}
  

4. Changing an Item Value

To change a value, reassign the key with a new value.

student = {"name": "Alice", "grade": "B"}

student["grade"] = "A+"
print(student)  # {'name': 'Alice', 'grade': 'A+'}
  

5. Removing an Item

Use pop(), del, or popitem() to remove dictionary items.

student = {"name": "Alice", "age": 20}

student.pop("age")
print(student)  # {'name': 'Alice'}

# Using del
del student["name"]
print(student)  # {}
  

6. Getting the Length of the Dictionary

student = {"name": "Alice", "age": 20, "grade": "A"}

print(len(student))  # Output: 3
  

7. Checking if a Key Exists

student = {"name": "Alice", "grade": "A"}

if "name" in student:
    print("Name key exists.")

print("age" in student)  # Output: False
  

8. Looping Through a Dictionary

student = {"name": "Alice", "grade": "A", "age": 20}

# Loop through keys
for key in student:
    print(key)

# Loop through values
for value in student.values():
    print(value)

# Loop through key-value pairs
for key, value in student.items():
    print(key, ":", value)
  

9. Nested Dictionary

You can have dictionaries inside dictionaries.

students = {
    "student1": {"name": "Alice", "age": 20},
    "student2": {"name": "Bob", "age": 22}
}

print(students["student1"]["name"])  # Output: Alice

# Loop through nested dictionary
for key, info in students.items():
    print(key, "=>", info)
  

Conclusion

Dictionaries in Python are a powerful data type used to store data in key-value pairs. They're ideal for fast lookups, dynamic item modification, and organizing nested information. With various methods for adding, accessing, and removing data, dictionaries are widely used in real-world Python programming.

Happy Learning Continue the next Lesson 🙂

While Loop

WHILE LOOP

Loops :
A loop in programming is a control structure that allows you to repeat a block of code multiple times, either a specific number of times or until a certain condition is met.

Types of loops

1. While loop
2. For loop

While loop:

A while loop in Python is used to execute a block of code repeatedly as long as a given condition is True.
Python while Loop Syntax:

🔹 1. Initialization

control_variable = starting_value

🔸 2. while loop with condition

while condition:
    Code block to execute
    (Statements inside the loop)

🔹 3. Updation

control_variable = control_variable + step  # or control_variable += step

Example:

# Initialization
i = 1

# Condition
while i <= 5:
    print("i =", i)

    # Updation
    i += 1

Output:
i = 1
i = 2
i = 3
i = 4
i = 5

✅ Example: Print numbers from 1 to 5 using a while loop

# Step 1: Initialization
i = 1

# Step 2: while loop with condition
while i <= 5:
    print("Number:", i)  # Step 3: Code block

    # Step 4: Updation
    i += 1

🧠 Explanation:

🔄 How it runs:

✅ Final Output:

Number: 1
Number: 2
Number: 3
Number: 4
Number: 5

Let me know if you'd like:
• an example with even numbers
• a sum calculator
• or a user input loop using while!

Example: Print this right angle pattern using a while loop

*
**
***
****
*****

Code:

i = 1                # Initialization: start with 1 star
while i <= 5:        # Condition: loop runs while i <= 5
    print("*" * i)   # Print i stars
    i += 1           # Updation: increase i by 1 each iteration

Explanation:

• Start with i = 1.
• In each iteration, print i stars (* repeated i times).
• Increase i by 1 after each print.
• When i becomes 6, the loop stops.

Output:

*
**
***
****
*****

Print natural numbers from 1 to 10

i = 1          # Initialization
while i <= 10: # Condition (prints numbers until 10)
    print(i)
    i += 1     # Updation (increment i by 1)

Output:

1
2
3
4
5
6
7
8
9
10

Conclusion on while loop in Python

• The while loop is used to repeat a block of code as long as a specified condition is true.
• It requires three main parts:
  1. Initialization — setting up the starting value before the loop.
  2. Condition/Termination — the loop continues while this condition is true and stops when it becomes false.
  3. Updation — updating the loop variable to eventually end the loop and avoid infinite looping.
• While loops are very useful for tasks where the number of iterations is not known in advance and depends on dynamic conditions.
• Always make sure your loop has a termination condition that will be met, to prevent infinite loops.

If you practice with examples like counting numbers, printing patterns, or processing user input, you’ll quickly master while loops!

Happy Learning Continue to the next lesson 🙂

for Loop

For Loop in Python: Definition

A for loop in Python is used to iterate over a sequence (such as a list, tuple, string, or range) and execute a block of code repeatedly for each item in that sequence.

Syntax

for variable in sequence:
    # block of code to execute

`variable` is a temporary name assigned to the current item of the sequence during each iteration.
`sequence` can be any iterable object (list, tuple, string, range, etc.).
The indented block of code inside the loop runs once for each item.

Explanation

When Python encounters a for loop, it starts with the first element in the sequence and assigns it to the variable. Then it runs the block of code inside the loop. After that, it moves to the next element in the sequence and repeats the process until it reaches the end.

Simple Example

fruits = ["apple", "banana", "cherry"]

for fruit in fruits:
    print(fruit)

Output:
apple
banana
cherry
Explanation:
The loop runs 3 times, once for each fruit in the list.
Each time, `fruit` takes the value of the current item, which gets printed.

Example 1: Looping through a list of numbers and printing their squares

numbers = [1, 2, 3, 4, 5]

for num in numbers:
    print(num, "squared is", num**2)

Output:
1 squared is 1
2 squared is 4
3 squared is 9
4 squared is 16
5 squared is 25

Example 2: Using range() to loop a specific number of times

for i in range(5):
    print("Iteration", i)

Output:
Iteration 0
Iteration 1
Iteration 2
Iteration 3
Iteration 4

Example 3: Looping through characters in a string

for char in "hello":
    print(char)

Output:
h
e
l
l
o

Example 4: Nested for loops (loop inside another loop)

for i in range(1, 4):
    for j in range(1, 4):
        print(i, "*", j, "=", i*j)
    print("-----")

Output:
1 * 1 = 1
1 * 2 = 2
1 * 3 = 3
-----
2 * 1 = 2
2 * 2 = 4
2 * 3 = 6
-----
3 * 1 = 3
3 * 2 = 6
3 * 3 = 9
-----

Example 5: Loop with else clause

for i in range(3):
    print(i)
else:
    print("Loop finished!")

Output:
0
1
2
Loop finished!

Example 6: Loop through a dictionary to print keys and values

student = {
    "name": "Alice",
    "age": 22,
    "major": "Computer Science"
}

for key in student:
    print(key, ":", student[key])

Output:
name : Alice
age : 22
major : Computer Science
Explanation:
Here, the for loop iterates over the keys of the dictionary `student`.
For each key, it prints the key and its corresponding value.

Conclusion

A `for` loop in Python is a control flow statement for iterating over sequences like lists, tuples, strings, or ranges.
It repeats the block of code for each item in the sequence.
It is simple and powerful for performing repetitive tasks.
Use `range()` to loop a specific number of times.
Nested loops can be used to handle multidimensional data.
The optional `else` block runs after the loop finishes normally (no break).

Happy Learning Continue to the next lesson 🙂

LOOP CONTROL STATEMENTS

Loop Control Statements in Python

Loop control statements are used to control the execution flow of loops (for and while). These allow you to either skip an iteration, exit the loop early, or write a placeholder for code to be implemented later.

1. break Statement

Definition:
The break statement is used to terminate the loop immediately, regardless of the loop’s condition. The control moves to the first statement after the loop.

Example 1: break in a for loop with list

fruits = ["apple", "banana", "cherry", "mango"]
for fruit in fruits:
    if fruit == "cherry":
        break
    print(fruit)

Output:
apple
banana

Example 2: break in a while loop

i = 1
while i <= 5:
    if i == 4:
        break
    print(i)
    i += 1

Output:
1
2
3

2. continue Statement

Definition:
The continue statement is used to skip the current iteration of the loop and continue with the next iteration.

Example 1: continue in a for loop with string

word = "python"
for letter in word:
    if letter == "h":
        continue
    print(letter)

Output:
p
y
t
o
n

Example 2: continue in a while loop

i = 0
while i < 5:
    i += 1
    if i == 3:
        continue
    print(i)

Output:
1
2
4
5

3. pass Statement

Definition:
The pass statement is used as a placeholder when the code is syntactically required but no action is to be performed. It does nothing and is often used during code development.

Example 1: pass in a for loop

colors = ["red", "green", "blue"]
for color in colors:
    if color == "green":
        pass  # Placeholder for future logic
    print(color)

Output:
red
green
blue

Example 2: pass in a function

def future_function():
    pass  # Will implement later

print("Program is running...")

Output:
Program is running...

Additional Examples with Lists, Strings, and Loops

Example: break with numbers list

numbers = [1, 2, 3, 4, 5, 6]
for num in numbers:
    if num == 4:
        break
    print(num)

Output:
1
2
3

Example: continue with string

name = "jabili"
for ch in name:
    if ch == 'i':
        continue
    print(ch)

Output:
j
a
b
l

Example: pass inside loop with condition

languages = ["Python", "Java", "C++"]
for lang in languages:
    if lang == "Java":
        pass
    print("Current language:", lang)

Output:
Current language: Python
Current language: Java
Current language: C++

break – More Examples

Example 3: Break when finding a number in a list

numbers = [10, 20, 30, 40, 50]
for num in numbers:
    print("Checking:", num)
    if num == 30:
        print("Found 30, stopping the loop!")
        break

Output:
Checking: 10
Checking: 20
Checking: 30
Found 30, stopping the loop!

Example 4: Break in nested loop

for i in range(3):
    for j in range(5):
        if j == 3:
            break
        print(f"i={i}, j={j}")

Output:
i=0, j=0
i=0, j=1
i=0, j=2
i=1, j=0
i=1, j=1
i=1, j=2
i=2, j=0
i=2, j=1
i=2, j=2

continue – More Examples

Example 3: Skip vowels in a word

word = "education"
vowels = "aeiou"
for letter in word:
    if letter in vowels:
        continue
    print(letter)

Output:
d
c
t
n

Example 4: Continue in nested loop (skip even numbers)

for i in range(1, 4):
    for j in range(1, 6):
        if j % 2 == 0:
            continue
        print(f"i={i}, j={j}")

Output:
i=1, j=1
i=1, j=3
i=1, j=5
i=2, j=1
i=2, j=3
i=2, j=5
i=3, j=1
i=3, j=3
i=3, j=5

pass – More Examples

Example 3: Pass in class definition (used as placeholder)

class MyClass:
    pass

obj = MyClass()
print("Class created successfully")

Output:
Class created successfully

Example 4: Pass in loop to skip implementation temporarily

tasks = ["read", "write", "delete"]

for task in tasks:
    if task == "delete":
        pass  # implementation not ready yet
    else:
        print("Doing task:", task)

Output:
Doing task: read
Doing task: write

Conclusion

  

    

      
Statement
      
Description
      
Use Case
    
    

      
break
      
Exits the loop immediately
      
Stop loop when a condition is met
    
    

      
continue
      
Skips current iteration, continues loop
      
Skip unwanted values
    
    

      
pass
      
Does nothing; acts as a placeholder
      
Useful during development
    
  

Happy Learning Continue the Lessons 🙂

Functions

Python Functions: Function in Python?

A function is a named block of code that performs a specific task. It can take inputs (parameters), process them, and return an output.

Benefits of Functions:

• Code reusability
• Better modularity
• Easier debugging
• Logical structure

Creating a Function

Use the def keyword followed by the function name and parentheses.

def say_hello():
    print("Hello, Python!")

Calling a Function

You call (or invoke) a function by using its name followed by parentheses.

say_hello()  # Output: Hello, Python!

Function Parameters / Arguments

Functions can receive data through parameters.

def greet(name):
    print(f"Hello, {name}!")

greet("Alice")  # Output: Hello, Alice!

Multiple Parameters / Arguments

You can define multiple parameters in a function.

def add(a, b):
    print("Sum:", a + b)

add(5, 3)  # Output: Sum: 8

Default Arguments

You can assign default values to parameters. If the argument is not provided, the default is used.

def greet(name="Guest"):
    print(f"Hello, {name}!")

greet()         # Output: Hello, Guest!
greet("Bob")    # Output: Hello, Bob!

Keyword Arguments

Pass arguments using parameter names. Useful when there are many parameters.

def describe_pet(animal, name):
    print(f"I have a {animal} named {name}.")

describe_pet(name="Milo", animal="cat")

The Return Statement

Functions can return results using the return keyword.

def multiply(x, y):
    return x * y

result = multiply(4, 5)
print(result)  # Output: 20

More Function Types and Examples

a. Function with List Parameter

def print_items(items):
    for item in items:
        print(item)

print_items(["apple", "banana", "cherry"])

b. Returning Multiple Values

def math_ops(a, b):
    return a + b, a - b, a * b, a / b

add, sub, mul, div = math_ops(10, 2)
print(add, sub, mul, div)

c. Variable-Length Arguments (*args)

Used when you don’t know how many arguments will be passed.

def total_sum(*numbers):
    print(sum(numbers))

total_sum(1, 2, 3)      # Output: 6
total_sum(5, 10, 15, 20)  # Output: 50

d. Keyword Variable-Length Arguments (**kwargs)

Used when you want to handle named arguments that are not predefined.

def print_user_info(**info):
    for key, value in info.items():
        print(f"{key}: {value}")

print_user_info(name="John", age=30, country="USA")

e. Function Calling Another Function

def square(x):
    return x * x

def display_square(n):
    result = square(n)
    print("Square is:", result)

display_square(5)

1. Basic Example with For Loop in a Function

🔹 Description: Print even numbers from a list.

python
def print_even_numbers(numbers):
    for num in numbers:
        if num % 2 == 0:
            print(num)

# Calling the function
print_even_numbers([1, 2, 3, 4, 5, 6])

🖨 Output:

2
4
6

2. Using If-Else Conditions in a Function

🔹 Description: Check if a number is positive, negative, or zero.

python
def check_number(n):
    if n > 0:
        print("Positive")
    elif n < 0:
        print("Negative")
    else:
        print("Zero")

check_number(5)   # Output: Positive
check_number(-3)  # Output: Negative
check_number(0)   # Output: Zero

Conclusion

Python functions are one of the most powerful tools for organizing and simplifying code. Mastering functions allows you to:

• Write clean, efficient programs
• Build modular applications
• Reduce code repetition
• Improve readability and debugging

Whether you're writing simple scripts or large applications, understanding functions is essential for becoming proficient in Python.

Happy Learning Continue to the next lesson 🙂

LOOP CONTROL STATEMENTS

1. lambda Function

Definition:
A lambda function is a small anonymous function used for simple one-line operations.
It can take any number of arguments but has only one expression, which is implicitly returned.

Syntax:

lambda arguments: expression

Examples:

Add Two Numbers

add = lambda a, b: a + b
print(add(2, 3))  # Output: 5

Square a Number

square = lambda x: x ** 2
print(square(4))  # Output: 16

Maximum of Two Numbers

maximum = lambda a, b: a if a > b else b
print(maximum(5, 9))  # Output: 9

Even/Odd Checker

check = lambda x: "Even" if x % 2 == 0 else "Odd"
print(check(7))  # Output: Odd

Concatenate Strings

concat = lambda s1, s2: s1 + " " + s2
print(concat("Hello", "World"))  # Output: Hello World

Cube of a Number

cube = lambda x: x**3
print(cube(3))  # Output: 27

2. map() Function

Definition:
The map() function applies a given function to each element in an iterable (like a list) and returns a new map object (an iterator).

Syntax:

map(function, iterable)

Examples:

Square Elements in List

nums = [1, 2, 3]
squares = list(map(lambda x: x**2, nums))
print(squares)  # Output: [1, 4, 9]

Uppercase Strings

words = ["hello", "world"]
result = list(map(lambda word: word.upper(), words))
print(result)  # Output: ['HELLO', 'WORLD']

Convert Temperatures Celsius to Fahrenheit

celsius = [0, 10, 20, 30]
fahrenheit = list(map(lambda c: (9/5)*c + 32, celsius))
print(fahrenheit)  # Output: [32.0, 50.0, 68.0, 86.0]

Add Corresponding Elements of Two Lists

a = [1, 2, 3]
b = [4, 5, 6]
added = list(map(lambda x, y: x + y, a, b))
print(added)  # Output: [5, 7, 9]

3. filter() Function

Definition:
The filter() function filters elements from an iterable based on a function that returns True or False. It returns only those elements where the function returns True.

Syntax:

filter(function, iterable)

Examples:

Filter Even Numbers

nums = [1, 2, 3, 4]
even = list(filter(lambda x: x % 2 == 0, nums))
print(even)  # Output: [2, 4]

Filter Long Words

words = ["hi", "hello", "world", "yo"]
long_words = list(filter(lambda w: len(w) > 3, words))
print(long_words)  # Output: ['hello', 'world']

Filter Positive Numbers

nums = [-5, 3, -1, 7, 0]
positive = list(filter(lambda x: x > 0, nums))
print(positive)  # Output: [3, 7]

Filter Non-Empty Strings

strings = ["", "apple", "", "banana", " "]
non_empty = list(filter(lambda s: s.strip() != "", strings))
print(non_empty)  # Output: ['apple', 'banana']

4. reduce() Function

Definition:
The reduce() function applies a function cumulatively to the items of an iterable, reducing it to a single cumulative value.

Note: You need to import reduce from the functools module.

Syntax:

from functools import reduce
reduce(function, iterable)

Examples:

Multiply All Numbers

from functools import reduce
nums = [1, 2, 3, 4]
product = reduce(lambda x, y: x * y, nums)
print(product)  # Output: 24

Find Maximum in a List

from functools import reduce
nums = [3, 7, 2, 9, 5]
max_val = reduce(lambda a, b: a if a > b else b, nums)
print(max_val)  # Output: 9

Sum of All Numbers

from functools import reduce
nums = [10, 20, 30, 40]
total = reduce(lambda x, y: x + y, nums)
print(total)  # Output: 100

Flatten a List of Lists

from functools import reduce
lists = [[1, 2], [3, 4], [5, 6]]
flattened = reduce(lambda a, b: a + b, lists)
print(flattened)  # Output: [1, 2, 3, 4, 5, 6]

5. Compare Normal Function vs Lambda Function

Examples:

Normal Function

def add(a, b):
    return a + b

print(add(3, 4))  # Output: 7

Equivalent Lambda Function

add = lambda a, b: a + b
print(add(3, 4))  # Output: 7

Normal Function with Multiple Statements

def process(x):
    print("Processing", x)
    return x * 2

print(process(5))  # Output: Processing 5 \n 10

Note: Lambda cannot have multiple statements or print.

Final Comparison Summary

Conclusion

Use lambda when you need short, anonymous functions for quick one-line operations.

Use normal functions for complex logic, multi-line processing, and when function reuse is needed.

Use map() to apply transformations to all elements in an iterable.

Use filter() to select items from an iterable that satisfy a condition.

Use reduce() to combine all elements in an iterable into a single cumulative result.

Happy Learning Continue the Lessons 🙂

REGULAR EXPRESSIONS

Regular Expressions in Python: A Complete Guide for Beginners

Introduction

Regular expressions (regex) are a powerful tool for text processing and pattern matching. In Python, regular expressions allow developers to search for, match, and manipulate text strings efficiently. Whether you're validating input, extracting information from documents, or cleaning data, mastering regular expressions in Python is essential. This comprehensive guide will help you understand the basics of regular expressions, how to use them effectively in Python, and provide examples to get you started.

What are Regular Expressions in Python?

A regular expression is a sequence of characters that defines a search pattern. It is commonly used for string matching within texts, such as searching for specific patterns, replacing substrings, or splitting strings into meaningful chunks. Python provides the re module to work with regular expressions.

Why Use Regular Expressions in Python?

Regular expressions are extremely useful for several reasons:

• Efficient Searching: Quickly find patterns or substrings in large text files.
• Data Validation: Validate email addresses, phone numbers, and other formatted inputs.
• Data Extraction: Extract useful data like URLs, dates, or specific terms from text.
• Text Processing: Clean and format data in automated scripts.

How to Use Regular Expressions in Python?

1. Importing the re Module

Python provides the re module to handle regular expressions. To begin using regular expressions, you first need to import this module.

import re

2. Basic Regular Expression Syntax

The syntax for regular expressions in Python includes a variety of special characters that define the pattern.

• .: Matches any single character (except newline).
• ^: Matches the start of a string.
• $: Matches the end of a string.
• *: Matches zero or more repetitions of the preceding pattern.
• +: Matches one or more repetitions of the preceding pattern.
• ?: Matches zero or one repetition of the preceding pattern.
• []: Matches any single character within the brackets.
• |: Acts as a logical OR between patterns.

Example:

import re

# Search for any word starting with 'P'
pattern = r"P\w+"
text = "Python is a powerful programming language."
matches = re.findall(pattern, text)
print(matches)  # Output: ['Python', 'powerful', 'programming']

3. Common Functions in Python’s re Module

re.match(): Searches for a pattern at the beginning of a string.

import re

pattern = r"^Python"
text = "Python is great"
match = re.match(pattern, text)
if match:
    print("Pattern found!")
else:
    print("Pattern not found.")

re.search(): Searches for a pattern throughout the string.

import re

pattern = r"great"
text = "Python is great"
search = re.search(pattern, text)
if search:
    print("Pattern found!")

re.findall(): Returns all occurrences of a pattern in a string.

import re

pattern = r"\d+"  # Match digits
text = "There are 12 apples and 25 bananas."
numbers = re.findall(pattern, text)
print(numbers)  # Output: ['12', '25']

re.sub(): Replaces occurrences of a pattern with a new string.

import re

pattern = r"apple"
replacement = "orange"
text = "I like apple pie."
new_text = re.sub(pattern, replacement, text)
print(new_text)  # Output: I like orange pie.

re.split(): Splits a string by the occurrences of a pattern.

import re

pattern = r"\s+"  # Match one or more spaces
text = "This is a sample text."
words = re.split(pattern, text)
print(words)  # Output: ['This', 'is', 'a', 'sample', 'text.']

4. Special Characters in Regular Expressions

Regular expressions include special characters that enhance their functionality:

• \d: Matches any digit (0-9).
• \D: Matches any non-digit.
• \w: Matches any alphanumeric character (a-z, A-Z, 0-9, and underscore).
• \W: Matches any non-word character.
• \s: Matches any whitespace character (spaces, tabs, newlines).
• \S: Matches any non-whitespace character.

Example:

import re

# Match a phone number format (123-456-7890)
pattern = r"\d{3}-\d{3}-\d{4}"
text = "Call me at 123-456-7890."
match = re.search(pattern, text)
if match:
    print("Phone number found:", match.group())

5. Grouping and Capturing with Parentheses

Parentheses () allow you to create groups in regular expressions, making it easier to capture and extract specific parts of the matched string.

import re

# Extracting area code from a phone number
pattern = r"(\d{3})-(\d{3})-(\d{4})"
text = "My number is 123-456-7890."
match = re.search(pattern, text)
if match:
    print("Area code:", match.group(1))  # Output: 123

Common Use Cases of Regular Expressions in Python

Validating Email Addresses

import re

email_pattern = r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$"
email = "test@example.com"

if re.match(email_pattern, email):
    print("Valid email")
else:
    print("Invalid email")

Extracting Dates from Text

import re

text = "The event is on 2025-04-30 and the deadline is 2025-05-15."
date_pattern = r"\d{4}-\d{2}-\d{2}"
dates = re.findall(date_pattern, text)
print("Dates found:", dates)  # Output: ['2025-04-30', '2025-05-15']

Replacing Whitespace in Strings

import re

text = "This  is  a  test."
new_text = re.sub(r"\s+", " ", text)
print(new_text)  # Output: "This is a test."

Best Practices for Using Regular Expressions in Python

• Keep it simple: Regular expressions can be complex, but it's always best to keep them as simple and readable as possible.
• Use raw strings (r""): This prevents issues with escape sequences and makes your regex patterns more readable.
• Test patterns: Use online regex testers (like regex101) to validate your regular expressions before using them in your code.
• Handle exceptions: Be sure to handle cases where regex operations might fail or not return matches, such as using try-except blocks.

Conclusion

Regular expressions are a powerful tool for pattern matching and text processing in Python. Whether you're validating user input, extracting information from data, or transforming text, mastering regular expressions can save you time and effort. By leveraging the re module, you can automate many tedious text-based tasks in Python efficiently and accurately.

Happy Learning Continue the Lessons

GARBAGE COLLECTORS

Garbage Collectors in Python

Introduction

In Python, memory management is crucial for ensuring that your programs run efficiently. One key feature of Python's memory management is the garbage collector, which automatically handles memory deallocation and prevents memory leaks. This guide explains how garbage collection works in Python, why it's important, and how you can work with it to optimize your Python code.

What is Garbage Collection in Python?

Garbage collection in Python refers to the automatic process of reclaiming memory by deleting objects that are no longer in use or referenced. When objects are no longer needed by the program, the garbage collector frees up that memory for reuse. This is critical in preventing memory leaks and maintaining the performance of Python applications.

In Python, garbage collection is handled mainly by two components:

• Reference Counting: Every object in Python has an associated reference count. When an object's reference count drops to zero, it means the object is no longer in use, and its memory can be safely reclaimed.
• Generational Garbage Collection: Python also uses a more sophisticated garbage collection algorithm that works based on object generations.

Why is Garbage Collection Important?

Garbage collection ensures that Python applications are memory-efficient, preventing unnecessary memory usage and avoiding crashes due to memory exhaustion. Without garbage collection, developers would have to manually manage memory, which could lead to errors, increased complexity, and memory leaks.

How Does Python’s Garbage Collection Work?

1. Reference Counting

Every object in Python has a reference count, which tracks how many references point to that object. When an object is created, its reference count is set to 1. Whenever a reference to the object is made, the reference count increases. When a reference is deleted, the count decreases. Once the reference count drops to zero, the object is eligible for garbage collection.

Example of reference counting:

import sys

# Create an object
obj = [1, 2, 3]
print(sys.getrefcount(obj))  # Output: 2 (1 reference from 'obj' and 1 from getrefcount)
  

In this example, sys.getrefcount returns the reference count for the object obj.

2. Generational Garbage Collection

Python's garbage collector divides objects into three generations:

• Generation 0: New objects.
• Generation 1: Objects that survived the first collection.
• Generation 2: Long-lived objects that survived multiple garbage collection cycles.

The idea behind generational collection is that objects that have lived longer are less likely to become garbage soon, so they are collected less frequently. Newer objects are more likely to be garbage, so they are collected more often.

Python’s garbage collector runs periodically, checking for objects that are no longer in use and reclaiming their memory. It does this by performing cyclic garbage collection and checking objects in each generation.

3. The Cycle Problem

In addition to reference counting, Python uses a cyclic garbage collector to handle objects involved in reference cycles. A reference cycle occurs when two or more objects reference each other, creating a cycle. Even if there are no external references to these objects, their reference count will never drop to zero, so they won’t be automatically collected.

Python's cyclic garbage collector detects and handles these reference cycles. The collector can break the cycle by freeing objects that are no longer reachable from the program, ensuring that memory is properly managed.

Example of a reference cycle:

import gc

class MyClass:
    def __init__(self):
        self.circular_ref = None

# Create a cyclic reference
obj1 = MyClass()
obj2 = MyClass()
obj1.circular_ref = obj2
obj2.circular_ref = obj1

# Delete the references
del obj1
del obj2

# Force garbage collection
gc.collect()
  

In this example, the objects obj1 and obj2 reference each other, forming a reference cycle. Even though both objects are deleted, they cannot be immediately garbage collected due to the cycle. However, by calling gc.collect(), Python's garbage collector can identify and clean up this cycle.

How to Work with the Garbage Collector in Python

1. Using the gc Module

Python provides the gc (garbage collection) module to interact with and control the garbage collector. Some useful functions in the gc module include:

• gc.collect(): This function forces a garbage collection cycle to run, manually collecting all unreachable objects.
• gc.get_count(): Returns the current collection counts for each generation.
• gc.get_objects(): Returns a list of all objects tracked by the garbage collector.
• gc.set_debug(): Sets the garbage collector's debugging flags to provide more detailed information about the collection process.

Example:

import gc

# Enable garbage collection debugging
gc.set_debug(gc.DEBUG_LEAK)

# Force garbage collection
gc.collect()

# Get the collection count
print(gc.get_count())
  

2. Disabling Garbage Collection

In some cases, you may want to temporarily disable garbage collection (e.g., in performance-sensitive applications). This can be done using gc.disable().

Example:

import gc

# Disable garbage collection
gc.disable()

# Perform some operations without garbage collection
# (Garbage collection will not happen during this period)

# Enable garbage collection again
gc.enable()
  

3. Monitoring and Fine-Tuning Garbage Collection

The gc module allows you to monitor and fine-tune the behavior of the garbage collector. You can adjust the thresholds for when garbage collection occurs in each generation by using gc.set_threshold(). This allows you to balance the tradeoff between the frequency of garbage collection and the performance of your program.

import gc

# Set the garbage collection thresholds for generations 0, 1, and 2
gc.set_threshold(700, 10, 10)
  

This will adjust the garbage collection behavior to run more or less frequently, depending on the needs of your program.

Best Practices for Garbage Collection in Python

• Let Python manage memory: In most cases, Python's garbage collector will efficiently manage memory without any intervention. Avoid trying to manually manage memory unless you have a specific performance need.
• Avoid reference cycles: While Python handles cyclic references, it’s still good practice to avoid creating reference cycles when possible, as they can affect performance.
• Use weak references: If you need to reference objects without preventing their garbage collection, consider using weak references via the weakref module.
• Monitor memory usage: If you’re working with large datasets or memory-intensive applications, use tools like gc.collect() and gc.get_count() to monitor and optimize garbage collection behavior.

Common Issues with Garbage Collection

• Memory Leaks: Sometimes, objects may not be properly garbage collected due to reference cycles or improperly managed references.
• Performance Overhead: Garbage collection adds some performance overhead. For real-time or performance-critical applications, you may need to fine-tune when garbage collection occurs.

Conclusion

Garbage collection in Python is an essential feature that helps developers manage memory automatically, reducing the risk of memory leaks and improving the performance of applications. By understanding how Python’s garbage collector works, you can make more informed decisions about memory management, optimize your code, and ensure the efficient use of resources.

Happy Learning Continue the Lessons 🙂

MEMORY MANAGEMENT

Introduction

Memory management is a critical aspect of programming languages, and Python is no exception. Proper memory management ensures the efficient use of system resources, leading to optimized performance of Python applications. This article provides an in-depth guide to memory management in Python, explaining how Python handles memory, its key components, and best practices to follow.

What is Memory Management in Python?

Memory management in Python refers to the process of efficiently allocating and deallocating memory for data storage during the execution of a program. Python handles memory management automatically using its built-in garbage collection mechanism, which helps prevent memory leaks and optimizes the overall performance of Python applications.

How Does Python Manage Memory?

In Python, memory management is handled by the Python memory manager, which is responsible for allocating memory to Python objects. The memory manager is integrated with the following components:

1. Private Heap Space
   Python uses a private heap space to manage memory. This is where all Python objects and data structures are stored. The heap is managed by the Python memory manager, which automatically allocates memory when objects are created and deallocates memory when objects are no longer needed.
2. Memory Pools and Blocks
   Python uses an efficient memory management system based on memory pools and blocks. The memory is divided into blocks of different sizes. When an object is created, it is assigned to a memory pool based on its size. This reduces fragmentation and speeds up memory allocation.
3. Reference Counting
   Python uses reference counting to keep track of the number of references pointing to an object. Each time an object is referenced, the reference count is incremented. When the reference count reaches zero, meaning no references to the object exist, the memory is deallocated.
4. Garbage Collection
   While reference counting is effective for most cases, it can't handle circular references (when two or more objects reference each other). To deal with this, Python uses garbage collection, which periodically checks for and cleans up objects involved in circular references. Python’s built-in gc (garbage collector) module manages this process.

Key Concepts of Memory Management in Python

• Memory Allocation
  Memory allocation in Python involves dynamically allocating memory for Python objects. Python's memory manager decides the best way to allocate memory based on the object size and available memory. This allows for efficient memory usage and prevents excessive memory consumption.
• Object Creation and Destruction
  When a new object is created, Python automatically allocates the required memory. When an object is no longer needed, Python’s garbage collector ensures that the memory is freed and available for reuse.
• Memory Deallocation
  Python uses reference counting and garbage collection to handle memory deallocation. Once an object’s reference count reaches zero, Python deallocates the object’s memory, preventing memory leaks.
• Memory Leaks
  A memory leak in Python occurs when an object is no longer used but is still referenced, preventing it from being deallocated. Although Python's garbage collector handles most cases, memory leaks can still occur, especially with circular references. It is important to track object references and optimize the code to avoid such issues.

Why is Memory Management Important in Python?

• Improved Performance: Proper memory management allows Python applications to run faster and use resources efficiently, improving performance.
• Prevents Memory Leaks: Python’s garbage collection mechanism helps prevent memory leaks, which can lead to increased memory consumption and slow program execution.
• Optimized Resource Usage: Proper memory handling ensures that memory is used optimally, avoiding resource wastage and reducing the need for manual memory management.

Best Practices for Efficient Memory Management in Python

To optimize memory management in Python, follow these best practices:

1. Use Generators
   Generators in Python are a memory-efficient alternative to using lists or other data structures. They generate items one at a time and are not stored in memory, reducing memory usage.

  # Example of a generator
  def my_generator():
      for i in range(100000):
          yield i
  

2. Use Built-in Data Structures
   Python’s built-in data structures, such as lists, sets, and dictionaries, are highly optimized for memory management. Whenever possible, use these instead of manually managing memory with custom data structures.
3. Use del to Delete Unused Objects
   When an object is no longer needed, you can explicitly delete it using the del statement. This reduces the reference count and allows the garbage collector to reclaim the memory.

  # Example of using `del`
  my_list = [1, 2, 3]
  del my_list
  

4. Avoid Circular References
   Be mindful of circular references, as they can prevent Python’s reference counting from working properly. Although Python’s garbage collector can clean up circular references, it is still a good practice to avoid them when possible.
5. Profile Memory Usage
   You can use the sys and memory_profiler modules to profile your Python application and understand how much memory your program is using. This helps identify memory bottlenecks and optimize resource usage.

  import sys

  # Checking memory usage of an object
  my_list = [1, 2, 3]
  print(sys.getsizeof(my_list)) # Returns the size of the object in bytes
  

Conclusion

Memory management in Python is a crucial aspect of efficient programming. By understanding how Python manages memory through reference counting and garbage collection, developers can write more efficient code that uses system resources optimally. By following best practices like using generators, built-in data structures, and avoiding circular references, Python developers can further enhance the performance of their applications while preventing memory leaks.

Happy Learning! Continue the Lessons 🙂

OOPS

What is Object-Oriented Programming (OOP)?

Object-Oriented Programming (OOP) is a programming paradigm that organizes software design around objects rather than functions and logic. An object is an instance of a class, and a class serves as a blueprint for creating objects. OOP aims to improve code modularity, reusability, and maintainability.

Key concepts of OOP include:

• Encapsulation: Bundling data (variables) and methods (functions) into a single unit or class.
• Abstraction: Hiding the complex reality while exposing only the necessary parts.
• Inheritance: The ability to create a new class from an existing class, allowing reuse of methods and attributes.
• Polymorphism: The ability to use the same method name for different implementations.

OOP is widely used in many programming languages, including Python, Java, and C++. It allows developers to create reusable, scalable, and modular code.

Defining a Class in Python

In Python, a class is defined using the class keyword, followed by the class name (usually in CamelCase) and a colon. A class acts as a template for creating objects. It encapsulates data and the methods that operate on that data.

Syntax to Define a Class:

class ClassName:
    # constructor (initializer)
    def __init__(self, attribute1, attribute2):
        self.attribute1 = attribute1
        self.attribute2 = attribute2

    # method
    def display(self):
        print(f"{self.attribute1} and {self.attribute2}")
    

What is an Object in Python?

An object is an instance of a class. When a class is defined, no memory is allocated until an object is created. Each object can have different values for the attributes defined in its class, making each object unique.

In simpler terms, a class is like a blueprint, while an object is a concrete instance of that blueprint.

For example, consider a class Car. Each specific car, like a Honda or Toyota, would be an object created from the Car class.

Creating a Class in Python

To create a class in Python, you define it using the class keyword, and then you can instantiate objects using the class. Each object will have its own set of attributes and methods.

Example of Creating a Class:

class Car:
    # Constructor method to initialize the object
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year

    # Method to display car details
    def display_car(self):
        print(f"{self.year} {self.make} {self.model}")

# Creating objects of the Car class
car1 = Car("Toyota", "Camry", 2020)
car2 = Car("Honda", "Civic", 2021)

# Calling the method on objects
car1.display_car()  # Output: 2020 Toyota Camry
car2.display_car()  # Output: 2021 Honda Civic
    

Creating an Object in Python

To create an object in Python, you use the class name followed by parentheses. You can pass values for the class attributes (e.g., make, model, year) to the constructor method __init__().

# Creating an object
my_car = Car("Ford", "Mustang", 2022)

# Accessing object attributes
print(my_car.make)  # Output: Ford
print(my_car.year)  # Output: 2022

# Calling a method on the object
my_car.display_car()  # Output: 2022 Ford Mustang
    

Here, my_car is an object of the Car class. The constructor __init__() is automatically called to initialize the object with attributes.

Conclusion

In Python, Object-Oriented Programming (OOP) helps organize and structure code around objects and classes. Classes serve as blueprints, and objects are instances of those classes. Understanding the concepts of classes and objects is crucial for building scalable, reusable, and maintainable software.

Why OOP Matters:

• Reusability: You can reuse classes and objects across your program.
• Modularity: OOP allows you to break down complex problems into smaller, manageable parts.
• Maintainability: Updating or fixing one part of the program (a class or method) doesn't necessarily impact other parts.

By leveraging the power of OOP in Python, you can write cleaner, more organized code that is easier to maintain and extend as your project grows.

Happy Learning! Continue the Lessons 🙂

MEMORY MANAGEMENT

What is Encapsulation in Python?

Encapsulation is one of the fundamental principles of Object-Oriented Programming (OOP). It refers to the concept of bundling data (attributes) and methods (functions) that operate on that data within a single unit or class. This process allows for restricting access to certain components of the object and controlling how the data is accessed and modified.

In simple terms, encapsulation helps hide the internal workings of a class from the outside world, exposing only what is necessary. By doing so, it helps to protect the integrity of the object's data, preventing it from being modified directly.

Encapsulation is typically achieved using access modifiers, which define the visibility and accessibility of the class's attributes and methods.

What are Access Modifiers in Python?

Access modifiers are keywords that control the visibility and accessibility of attributes and methods in a class. In Python, we primarily use the following three access modifiers:

• Public: Attributes and methods are accessible from outside the class. These are the default access level in Python.
• Private: Attributes and methods are not accessible directly from outside the class. They are intended for internal use only within the class.
• Protected: Attributes and methods are accessible within the class and its subclasses. They are not meant to be accessed directly from outside the class but can be inherited by child classes.

Although Python does not have strict access control like languages such as Java or C++, it follows naming conventions to implement these access levels.

Public Access Modifier

The public access modifier allows access to class attributes and methods from anywhere in the program. By default, all attributes and methods in Python are public unless specified otherwise.

Example of Public Access:

class Car:
    def __init__(self, make, model):
        self.make = make  # Public attribute
        self.model = model  # Public attribute
    
    def display_car(self):
        print(f"Car: {self.make} {self.model}")

# Creating an object
car = Car("Toyota", "Camry")
print(car.make)  # Accessing public attribute
car.display_car()  # Calling public method
    

In this example, both the make and model attributes, as well as the display_car() method, are public and can be accessed directly from outside the class.

Private Access Modifier

The private access modifier restricts access to the class's attributes and methods. In Python, private attributes and methods are indicated by prefixing the name with double underscores (__).

Private attributes and methods are only accessible within the class and cannot be accessed directly from outside the class.

Example of Private Access:

class Car:
    def __init__(self, make, model):
        self.__make = make  # Private attribute
        self.__model = model  # Private attribute
    
    def __display_car(self):  # Private method
        print(f"Car: {self.__make} {self.__model}")

    def get_car_info(self):  # Public method to access private data
        print(f"Car Info: {self.__make} {self.__model}")

# Creating an object
car = Car("Toyota", "Camry")
# print(car.__make)  # This will raise an error because __make is private
car.get_car_info()  # Accessing private attribute through public method
    

In this example, the __make and __model attributes, as well as the __display_car() method, are private. They cannot be accessed directly from outside the class. However, you can use a public method (like get_car_info()) to access or modify the private attributes.

Protected Access Modifier

The protected access modifier is somewhat of a middle ground between public and private. In Python, protected attributes are denoted by a single underscore (_). This indicates that the attribute or method is intended for internal use within the class and its subclasses, but it can still be accessed from outside the class, though it is not recommended.

Example of Protected Access:

class Car:
    def __init__(self, make, model):
        self._make = make  # Protected attribute
        self._model = model  # Protected attribute
    
    def _display_car(self):  # Protected method
        print(f"Car: {self._make} {self._model}")

# Creating an object
car = Car("Toyota", "Camry")
print(car._make)  # Accessing protected attribute (not recommended)
car._display_car()  # Accessing protected method (not recommended)
    

While the _make and _model attributes are protected and can technically be accessed from outside the class, doing so goes against the intended encapsulation practice.

Why is Encapsulation Important?

Encapsulation offers several benefits in programming:

• Data Protection: It ensures that an object's data is safe from accidental or malicious modification by restricting access to its internal states.
• Modular Code: By hiding the internal details and exposing only necessary information, encapsulation makes the code easier to maintain and extend.
• Improved Readability: The use of access modifiers helps clarify the intended use of class attributes and methods, making the code more readable.
• Simplified Debugging: When you control access to the class's internal data, it’s easier to identify and fix issues without affecting the rest of the program.

Conclusion

Encapsulation is a core principle of Object-Oriented Programming (OOP) that helps in bundling the data and methods that work on the data into a single unit (class). By using access modifiers (public, private, and protected), developers can control how the data within a class is accessed and modified, thus improving security, modularity, and maintainability.

In Python:

• Public attributes and methods are accessible from anywhere.
• Private attributes and methods are restricted to the class itself.
• Protected attributes and methods are intended for internal use and inheritance.

By following the principles of encapsulation and using access modifiers appropriately, you can write clean, maintainable, and secure code in Python.

Happy Learning Continue the Lessons 🙂

INHERITANCE

Inheritance in Python

Inheritance is one of the key features of Object-Oriented Programming (OOP) in Python. It allows a class (called the child class or subclass) to inherit the attributes and methods of another class (called the parent class or superclass).

This helps in code reusability, modularity, and scalability, making your Python programs easier to maintain and extend.

What is Inheritance in Python?

In Python, inheritance enables a new class to use the functionality of an existing class without rewriting the code.

Syntax:

class Parent:
    # parent class code

class Child(Parent):
    # child class code (inherits from Parent)
  

Types of Inheritance in Python

• Single Inheritance – One child class inherits from one parent class.
• Multiple Inheritance – One child class inherits from multiple parent classes.
• Multilevel Inheritance – A class is derived from a class which is also derived from another class.
• Hierarchical Inheritance – Multiple child classes inherit from a single parent class.
• Hybrid Inheritance – A combination of two or more types of inheritance.

Python Inheritance Example (Simple)

# Parent Class
class Animal:
    def speak(self):
        print("Animals make sound")

# Child Class
class Dog(Animal):
    def bark(self):
        print("Dog barks")

# Creating an object of Dog
d = Dog()
d.speak()  # Inherited from Animal
d.bark()   # Defined in Dog
  

Output:

Animals make sound
Dog barks
  

Benefits of Using Inheritance in Python

• Reduces code duplication
• Promotes reusability
• Enhances maintainability
• Supports polymorphism and code extensibility

Conclusion

Inheritance in Python is a powerful concept that helps developers build cleaner and more efficient code by reusing existing logic. Whether you're working on a simple script or a complex application, understanding and using inheritance correctly can save time and improve your codebase.

Happy Learning Continue the Lessons 🙂

TYPES OF INHERITANCE

Types of Inheritance in Python

Inheritance is a core concept of Object-Oriented Programming (OOP) in Python that allows one class to derive features from another class. This article explains the 5 types of inheritance in Python with definitions, examples, and a conclusion to help you understand the concept clearly.

1. Single Inheritance

Definition:
Single inheritance is when a child class inherits from one parent class.

Example:

class Parent:
    def display(self):
        print("This is the Parent class.")

class Child(Parent):
    def show(self):
        print("This is the Child class.")

obj = Child()
obj.display()
obj.show()

2. Multiple Inheritance

Definition:
Multiple inheritance is when a child class inherits from more than one parent class.

Example:

class Father:
    def skills(self):
        print("Father: Gardening")

class Mother:
    def hobbies(self):
        print("Mother: Cooking")

class Child(Father, Mother):
    def talents(self):
        print("Child: Drawing")

obj = Child()
obj.skills()
obj.hobbies()
obj.talents()

3. Multilevel Inheritance

Definition:
Multilevel inheritance is when a class is derived from a child class, which is itself derived from another parent class.

Example:

class Grandparent:
    def home(self):
        print("Grandparent's house")

class Parent(Grandparent):
    def car(self):
        print("Parent's car")

class Child(Parent):
    def bike(self):
        print("Child's bike")

obj = Child()
obj.home()
obj.car()
obj.bike()

4. Hierarchical Inheritance

Definition:
Hierarchical inheritance occurs when multiple child classes inherit from a single parent class.

Example:

class Parent:
    def property(self):
        print("Parent's property")

class Child1(Parent):
    def own1(self):
        print("Child1's feature")

class Child2(Parent):
    def own2(self):
        print("Child2's feature")

obj1 = Child1()
obj2 = Child2()
obj1.property()
obj1.own1()
obj2.property()
obj2.own2()

5. Hybrid Inheritance

Definition:
Hybrid inheritance is a combination of two or more types of inheritance, like multiple + multilevel.

Example:

class A:
    def featureA(self):
        print("Feature A")

class B(A):
    def featureB(self):
        print("Feature B")

class C:
    def featureC(self):
        print("Feature C")

class D(B, C):
    def featureD(self):
        print("Feature D")

obj = D()
obj.featureA()
obj.featureB()
obj.featureC()
obj.featureD()

Conclusion

Understanding the types of inheritance in Python is essential for mastering Object-Oriented Programming. It allows you to build scalable, maintainable, and reusable code. Whether you're working with single, multiple, or hybrid inheritance, Python provides the flexibility to design clean and efficient class hierarchies.

Happy Learning Continue the Lessons 🙂

POLYMORPHISM

Polymorphism in Python and Its Types (2025 Guide)

Polymorphism is a fundamental concept in Object-Oriented Programming (OOP) that means "many forms." In Python, polymorphism allows the same function or method name to operate differently based on the object or context.

It enhances code flexibility, reusability, and supports dynamic method resolution during runtime.

What is Polymorphism?

Definition:
Polymorphism in Python allows objects of different classes to be treated as if they were instances of the same class, particularly through shared interfaces or methods.

Types of Polymorphism in Python

Python supports two main types of polymorphism:

Compile-Time Polymorphism (Method Overloading)

Definition:
This occurs when multiple methods have the same name but different parameters. Python doesn't support strict method overloading like Java or C++, but similar behavior can be achieved using default arguments or *args.

Example:

class Calculator:
    def add(self, a=None, b=None, c=None):
        if a and b and c:
            return a + b + c
        elif a and b:
            return a + b
        else:
            return a

obj = Calculator()
print(obj.add(2, 3))      # 5
print(obj.add(1, 2, 3))   # 6

Run-Time Polymorphism (Method Overriding)

Definition:
This occurs when a child class overrides a method defined in its parent class. Python decides which version of the method to run at runtime.

Example:

class Animal:
    def speak(self):
        print("Animal speaks")

class Dog(Animal):
    def speak(self):
        print("Dog barks")

class Cat(Animal):
    def speak(self):
        print("Cat meows")

# Polymorphic behavior
def make_sound(animal):
    animal.speak()

make_sound(Dog())  # Dog barks
make_sound(Cat())  # Cat meows

Polymorphism Through Built-In Functions

Python functions like len(), max(), sum() are polymorphic:

print(len("hello"))     # 5 (string)
print(len([1, 2, 3]))   # 3 (list)

Conclusion

Polymorphism in Python is a powerful feature that allows the same interface or method name to behave differently across different objects. By using method overloading (compile-time) and method overriding (runtime), Python supports clean, efficient, and modular code design.

Happy Learning Continue the Lessons 🙂

ABSTRACTION

Abstraction in Python (2025 Guide with Examples)

Abstraction is one of the four fundamental pillars of Object-Oriented Programming (OOP) — along with encapsulation, inheritance, and polymorphism. In Python, abstraction is used to hide implementation details and show only the essential features of an object to the user.

What is Abstraction in Python?

Definition:
Abstraction in Python means hiding complex implementation logic and exposing only the necessary parts of an object or class. It allows developers to manage complexity by working with simplified interfaces.

Think of abstraction as using a TV remote: you don’t need to know how it works internally — you just press buttons to perform tasks.

How is Abstraction Implemented in Python?

Python provides abstraction using the abc module (Abstract Base Class).

You use:

• ABC (Abstract Base Class)
• @abstractmethod decorator

Example of Abstraction in Python

from abc import ABC, abstractmethod

# Abstract Class
class Vehicle(ABC):
    
    @abstractmethod
    def start_engine(self):
        pass

# Concrete Class
class Car(Vehicle):
    
    def start_engine(self):
        print("Car engine started.")

class Bike(Vehicle):

    def start_engine(self):
        print("Bike engine started.")

# Using the classes
v1 = Car()
v2 = Bike()

v1.start_engine()  # Output: Car engine started.
v2.start_engine()  # Output: Bike engine started.

Here:

• Vehicle is an abstract class.
• start_engine() is an abstract method.
• Car and Bike are concrete classes that implement the abstract method.

Why Use Abstraction?

• Hides complexity
• Increases modularity
• Enhances code maintainability
• Enforces method implementation in child classes
• Helps in defining blueprints for future classes

Key Points on Python Abstraction

  

    

      
Feature
      
Description
    
    

      
Module
      
abc
    
    

      
Abstract Class
      
Inherits from ABC
    
    

      
Abstract Method
      
Uses @abstractmethod
    
    

      
Cannot Instantiate
      
You cannot create objects of an abstract class
    
    

      
Forces Implementation
      
Child classes must override abstract methods
    
  

Conclusion

Abstraction in Python helps you design cleaner, more efficient, and modular code by focusing only on relevant data and operations while hiding the underlying complexity. It’s especially useful when designing frameworks, APIs, or large-scale applications with multiple layers.

Happy Learning Continue the Lessons 🙂

POLYMORPHISM

Constructors in Python and Their Types (2025 Guide)

In Object-Oriented Programming (OOP), a constructor is a special method used to initialize new objects. In Python, the __init__() method serves as the constructor. This article will explain constructors in Python, their types, and how they are used with practical examples.

What is a Constructor in Python?

A constructor is a special method that gets called automatically when an object of a class is created. It is used to initialize the object's state (i.e., setting initial values for instance variables).

In Python, the constructor is always named __init__().

Syntax of Constructor in Python

class ClassName:
    def __init__(self, parameters):
        # Constructor method
        self.attribute = value

Here:

• __init__() is the constructor method.
• It typically takes at least one argument, self, which represents the instance of the class.
• You can add additional parameters for initializing attributes of the object.

Types of Constructors in Python

Python supports two types of constructors:

• Default Constructor
• Parameterized Constructor

Default Constructor

A default constructor doesn’t take any parameters (other than self). It initializes an object with default values.

Example:

class Car:
    def __init__(self):
        self.model = "Toyota"
        self.year = 2020

# Creating an object
car1 = Car()
print(car1.model)  # Output: Toyota
print(car1.year)   # Output: 2020

In this example, the default constructor initializes the model and year attributes with default values.

Parameterized Constructor

A parameterized constructor takes arguments (other than self) when creating an object. This allows you to initialize the object with specific values at the time of creation.

Example:

class Car:
    def __init__(self, model, year):
        self.model = model
        self.year = year

# Creating objects with parameters
car1 = Car("Toyota", 2020)
car2 = Car("Honda", 2022)

print(car1.model)  # Output: Toyota
print(car2.year)   # Output: 2022

Here, the constructor takes model and year as parameters, allowing each object to be created with unique values.

Constructor Overloading in Python

Unlike languages like Java, Python does not support constructor overloading (i.e., having multiple constructors with different parameters). However, you can achieve similar functionality using default arguments or variable-length arguments (*args or **kwargs).

Example with default arguments:

class Car:
    def __init__(self, model="Toyota", year=2020):
        self.model = model
        self.year = year

car1 = Car()               # Uses default values
car2 = Car("Honda", 2022)  # Custom values

print(car1.model)  # Output: Toyota
print(car2.year)   # Output: 2022

Why Are Constructors Important?

• They allow automatic initialization of objects when they are created.
• Provide an easy way to pass parameters during object creation.
• Help in setting default values or configurations.
• Constructors promote code reusability and maintainability.

Conclusion

Constructors are essential in Python OOP as they allow you to control the initialization of objects. Using default or parameterized constructors, you can ensure that your objects are properly configured from the moment they are created.

Happy Learning Continue the Lessons 🙂

Exception Handling

🔹 Exception Handling in Python

Definition:
Exception Handling in Python is a mechanism to handle runtime errors gracefully without crashing the program.

Why Use Exception Handling?

• Prevent program crashes
• Provide user-friendly error messages
• Handle unexpected situations like missing files, division by zero, etc.
• Debug efficiently and write robust code

📌 Basic Syntax

try:
    # Code that might raise an exception
except ExceptionType:
    # Code to handle the exception

🔸 Example 1: ZeroDivisionError

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero!")

Output: Cannot divide by zero!

🔸 Example 2: Handling Multiple Exceptions

try:
    a = int("abc")
    b = 10 / 0
except ValueError:
    print("Invalid conversion to int.")
except ZeroDivisionError:
    print("Division by zero error.")

Output: Invalid conversion to int.

🔸 Example 3: Using else and finally

try:
    num = int(input("Enter a number: "))
except ValueError:
    print("That's not a valid number!")
else:
    print("You entered:", num)
finally:
    print("Execution complete.")

🔸 Example 4: File Not Found

try:
    file = open("data.txt", "r")
    content = file.read()
    print(content)
except FileNotFoundError:
    print("The file does not exist.")

🔸 Example 5: IndexError

try:
    lst = [1, 2, 3]
    print(lst[5])
except IndexError as e:
    print("Index Error:", e)

🔸 Example 6: Raising Custom Exception

age = -5
try:
    if age < 0:
        raise ValueError("Age cannot be negative.")
except ValueError as e:
    print("Custom Error:", e)

🔸 Example 7: Catching All Exceptions

try:
    x = int("abc")
except Exception as e:
    print("An error occurred:", e)

🔸 Example 8: Nested Try-Except

try:
    a = 10
    try:
        b = int("text")
    except ValueError:
        print("Inner block error")
except:
    print("Outer block error")

📚 Common Built-in Exceptions

🔁 Try-Except-Else-Finally Flow

try:
    # Try block: run risky code
except:
    # Except block: handle exception
else:
    # Else block: runs if no exception occurs
finally:
    # Finally block: always runs

✅ Conclusion

• Exception Handling improves code reliability and prevents crashes.
• Use try-except to catch and handle known errors.
• Use else to execute code when no exception occurs.
• Use finally to always run cleanup or final steps.
• Create custom exceptions for specific cases.
• Avoid using bare except: without specifying the exception type unless absolutely necessary.

Happy Learning – Continue the Lessons! 😊

Exception handling

File Handling in Python

File Handling in Python allows you to work with files (read, write, update, delete).

Python provides built-in functions to handle files and perform operations like:

• Reading data from a file
• Writing data to a file
• Appending data
• Closing files properly

Why is File Handling Important?

• Store and retrieve data permanently
• Log information and results
• Read/write configuration and user data
• Work with external datasets (CSV, TXT, etc.)

open() Function

Definition: The open() function is used to open a file in a specified mode (read, write, append, etc.).

Syntax:

open(file, mode)

Parameters:

• file: Name (or path) of the file
• mode: File access mode ('r', 'w', 'a', 'b', 'x', '+')

File Access Modes

Examples

1. Reading from a file (r)

f = open("example.txt", "r")
content = f.read()
print(content)
f.close()

2. Writing to a file (w)

f = open("example.txt", "w")
f.write("Hello, this is a write example.")
f.close()

Note: This will overwrite the file if it already exists.

3. Appending to a file (a)

f = open("example.txt", "a")
f.write("\nThis is an appended line.")
f.close()

4. Reading line by line

f = open("example.txt", "r")
for line in f:
    print(line.strip())
f.close()

5. Using with statement (Auto file closing)

with open("example.txt", "r") as file:
    data = file.read()
    print(data)
# File automatically closed here

6. Writing Binary File

with open("binaryfile.bin", "wb") as f:
    f.write(b"This is binary content")

7. Checking if File Exists (Safely)

import os

if os.path.exists("example.txt"):
    with open("example.txt", "r") as f:
        print(f.read())
else:
    print("File not found.")

File Object Methods

Conclusion

• File handling lets you store, retrieve, and manipulate data stored in files.
• Use the open() function to specify which file to access and how (read/write/append).
• Always close files after use using file.close() or use the with statement for automatic handling.
• Proper file handling is essential for building applications that need to persist or exchange data.

Happy Learning Continue the Lessons 🙂

FILE READING

Definition:

File reading in Python is the process of opening a file and retrieving its content for use in your program.

Python provides built-in methods to read the contents of a text or binary file using different techniques like:

• Reading the entire file at once
• Reading line by line
• Reading a specified number of characters

To read a file, the file must be opened in read mode ('r').

Syntax:

file = open("filename.txt", "r")
data = file.read()
file.close()

Or using with (preferred method):

with open("filename.txt", "r") as file:
    data = file.read()

Methods for Reading a File

Examples

1. Reading Entire File Using read()

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

Reads and prints all content in sample.txt.

2. Reading Line by Line Using readline()

with open("sample.txt", "r") as file:
    line1 = file.readline()
    line2 = file.readline()
    print("Line 1:", line1)
    print("Line 2:", line2)

3. Reading All Lines as a List Using readlines()

with open("sample.txt", "r") as file:
    lines = file.readlines()
    for line in lines:
        print(line.strip())

Reads all lines and iterates through them one by one.

4. Reading Using a Loop (Best for Large Files)

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

5. Reading First N Characters

with open("sample.txt", "r") as file:
    part = file.read(10)
    print("First 10 characters:", part)

Conclusion:

• Reading a file in Python is essential for accessing and processing external data.
• Always open the file in 'r' (read) mode or use the with statement for automatic file handling.
• Use read() to get the whole file, readline() to read line-by-line, and readlines() for a list of lines.
• Always close the file using close() or use with to ensure it's properly managed.

Happy Learning Continue the Lessons 🙂

FILE WRITING AND CREATING

Definition:

File writing in Python refers to the process of saving data to a file.

When writing to a file:

• If the file does not exist, Python will create it.
• If the file exists, behavior depends on the mode:
• 'w' mode will overwrite the file.
• 'a' mode will append data to the end of the file.
• 'x' mode will create a new file and raise an error if it already exists.

Syntax:

file = open("filename.txt", "w")  # or "a", "x"
file.write("Text to write")
file.close()
  

Or using with (recommended for automatic closing):

with open("filename.txt", "w") as file:
    file.write("Text to write")
  

File Modes Used for Writing

Examples

1. Writing to a File (Overwriting with 'w')

with open("myfile.txt", "w") as f:
    f.write("Hello, this is a write operation.\n")
    f.write("This is line 2.\n")

Creates myfile.txt and writes text (overwrites if file exists).

2. Appending to a File ('a')

with open("myfile.txt", "a") as f:
    f.write("This line will be added to the file.\n")

Adds content to the end of the file without overwriting.

3. Creating a New File ('x')

with open("newfile.txt", "x") as f:
    f.write("This file was created using 'x' mode.\n")

Creates newfile.txt. If the file already exists, it raises a FileExistsError.

4. Writing Multiple Lines

lines = ["Line 1\n", "Line 2\n", "Line 3\n"]
with open("lines.txt", "w") as f:
    f.writelines(lines)

Writes a list of strings to the file using writelines().

5. Writing User Input to a File

with open("inputfile.txt", "w") as f:
    name = input("Enter your name: ")
    f.write(f"Name: {name}\n")

Conclusion:

• Python provides simple and powerful tools to write and create files.
• Use 'w' mode to overwrite files or create new ones.
• Use 'a' mode to add to existing files without erasing content.
• Use 'x' to safely create new files without risk of overwriting.
• Always close the file after writing, or use the with statement for better resource management.
• File writing is essential for saving user data, logging, and generating reports.

Happy Learning Continue the next Lessons 🙂

FILE DELETING IN PYTHON

Definition:

File deleting in Python refers to the process of removing a file from the file system.

Python provides functions in the os and pathlib modules to delete files safely and efficiently.

Methods to Delete a File

1. Using os.remove()
   • Deletes the specified file.
   • Requires the file path.
   • Raises FileNotFoundError if file doesn’t exist.
2. Using pathlib.Path.unlink()
   • Modern object-oriented method to delete files.
   • Part of the pathlib module.

Example 1: Deleting a File Using os.remove()

import os

# Check if file exists before deleting
if os.path.exists("sample.txt"):
    os.remove("sample.txt")
    print("File deleted successfully.")
else:
    print("File not found.")

Example 2: Deleting a File Using pathlib.Path

from pathlib import Path

file = Path("example.txt")

if file.exists():
    file.unlink()
    print("File deleted.")
else:
    print("File does not exist.")

Example 3: Try-Except Block (Safe Deletion)

import os

try:
    os.remove("data.txt")
    print("File deleted.")
except FileNotFoundError:
    print("The file was not found.")
except PermissionError:
    print("Permission denied to delete the file.")

When You Should Delete Files:

• To remove temporary or unnecessary files.
• To clean up after file processing (like logs or cache).
• When managing user data, logs, or session files.

Conclusion:

• Python allows easy file deletion using os.remove() or pathlib.Path.unlink().
• Always check if the file exists before deleting to avoid exceptions.
• Use try-except blocks to handle deletion errors safely.
• File deletion is useful in automation, cleanup scripts, and file-based data management.

Happy Learning Continue the next Lessons 🙂

PYTHON VARIABLE SCOPES

Definition:

In Python, variable scope refers to the part of a program where a variable is accessible or visible.

There are two main types of scopes:

• Global Scope – accessible throughout the entire file.
• Local Scope – accessible only within the function or block where it is defined.

1. Global Scope

Definition: A global variable is a variable that is defined outside of all functions. It can be accessed and used anywhere in the code after it is declared.

x = 10  # Global variable

def show():
    print("Inside function:", x)

show()
print("Outside function:", x)

Output:

Inside function: 10
Outside function: 10

2. Local Scope

Definition: A local variable is a variable declared inside a function. It can be used only within that function and is not accessible outside.

def display():
    y = 5  # Local variable
    print("Inside function:", y)

display()
# print(y)  # This would raise an error: NameError

Output:

Inside function: 5

3. The global Keyword

Definition: The global keyword allows you to modify a global variable from within a function.

count = 0  # Global variable

def increment():
    global count
    count += 1

increment()
print("Updated count:", count)

Output:

Updated count: 1

More Examples

Example 4: Local vs Global (without global)

num = 100

def change():
    num = 50  # This creates a new local variable
    print("Inside function:", num)

change()
print("Outside function:", num)

Output:

Inside function: 50
Outside function: 100

Example 5: Using global to Modify Global Variable

value = 20

def modify():
    global value
    value += 30

modify()
print("Modified value:", value)

Output:

Modified value: 50

Example 6: Nested Function Scope

def outer():
    a = 5
    def inner():
        print("Inner value:", a)
    inner()

outer()

Output:

Inner value: 5

Conclusion:

• Variables declared outside of functions have global scope and can be accessed anywhere.
• Variables declared inside functions have local scope and cannot be accessed outside the function.
• Use the global keyword to modify a global variable inside a function.
• Understanding scope helps avoid unexpected behaviors and errors in large programs.

Happy Learning Continue the next Lessons 🙂

MODULE IN PYTHON?

Definition:

A module in Python is simply a file containing Python code (functions, classes, or variables) that you can reuse in other programs by importing it.

Why Use Modules?

Advantages of Using Modules:

• Organize code into reusable components
• Keep code clean and maintainable
• Split a large program into multiple files
• Use built-in modules to simplify tasks (like math, random, etc.)
• Avoid code duplication

Creating a Module

Steps:

1. Create a new .py file and define functions, variables, or classes.
2. Save it with a name (e.g., mymodule.py).

Example – mymodule.py:

# mymodule.py
def greet(name):
    return f"Hello, {name}!"

pi = 3.1416

Using the Module in Another Python File

Example – main.py:

import mymodule

print(mymodule.greet("Alice"))    # Output: Hello, Alice!
print(mymodule.pi)                # Output: 3.1416

Note: Ensure both .py files are in the same folder or the module is in the Python path.

Using Aliases for Modules

You can rename a module while importing it using as.

import mymodule as mm

print(mm.greet("John"))   # Output: Hello, John!

Importing Parts of a Module

Instead of importing everything, import only what you need.

from mymodule import greet

print(greet("Mike"))   # Output: Hello, Mike!

You can also import multiple items:

from mymodule import greet, pi

The dir() Function

Definition: The dir() function returns a list of all functions, variables, and objects defined in a module.

import math
print(dir(math))

Output will be a list like:

['__doc__', '__name__', 'acos', 'asin', 'atan', 'ceil', 'cos', 'degrees', ...]

Built-in Modules

Python includes many built-in modules that you can import and use without needing to install them.

Examples of Built-in Modules:

Example – Using math module:

import math
print(math.sqrt(16))  # Output: 4.0

Example – Using random module:

import random
print(random.randint(1, 10))  # Output: Random number between 1 and 10

How to Demonstrate This on a PC

Step-by-Step Instructions:

1. Open a folder on your computer.
2. Create two files:
   • mymodule.py (for custom functions or variables)
   • main.py (where you’ll import and use the module)
3. In mymodule.py, define a function or constant.
4. In main.py, write import mymodule and use the defined items.
5. Run main.py using a terminal or Python IDE like VS Code or IDLE.

Conclusion

• A module is a .py file containing reusable Python code.
• Use modules to organize code, avoid repetition, and simplify large programs.
• You can import entire modules, specific functions/variables, or assign aliases.
• Built-in modules (like math, os, and random) help solve common problems without writing everything from scratch.
• Use the dir() function to explore what’s inside a module.

Best Practice:
Create custom modules for reusable code across multiple projects to improve maintainability and readability.

Happy Learning Continue the next Lessons 🙂

Python Built-in Modules Explained

1. math Module

Definition: The math module provides mathematical functions and constants. It includes functions for advanced math operations like square roots, trigonometry, logarithms, factorials, and more.

Commonly used functions and constants:

• math.sqrt(x) — square root
• math.factorial(n) — factorial of n
• math.pow(x, y) — x raised to the power y
• math.pi — the constant π
• math.e — Euler’s number
• math.sin(x), math.cos(x), math.tan(x) — trigonometric functions

Examples:

import math

print(math.sqrt(25))           # Output: 5.0
print(math.factorial(5))       # Output: 120
print(math.pow(2, 3))          # Output: 8.0
print(math.pi)                 # Output: 3.141592653589793
print(math.sin(math.pi / 2))   # Output: 1.0

2. random Module

Definition: The random module is used to generate pseudo-random numbers and perform random selections. It supports generating random integers, floats, shuffling sequences, and choosing random elements.

Common functions:

• random.randint(a, b) — random integer between a and b (inclusive)
• random.random() — random float between 0 and 1
• random.choice(seq) — randomly selects an element from a sequence
• random.shuffle(seq) — shuffles a sequence in place
• random.sample(population, k) — select k unique elements

Examples:

import random

print(random.randint(1, 10))         # Output: random integer between 1 and 10
print(random.random())               # Output: random float between 0.0 and 1.0

items = ['apple', 'banana', 'cherry']
print(random.choice(items))          # Output: randomly picks an item

random.shuffle(items)
print(items)                        # Output: items shuffled randomly

print(random.sample(items, 2))      # Output: list of 2 unique random items

3. datetime Module

Definition: The datetime module supplies classes to manipulate dates and times. It helps with retrieving the current date/time, formatting, parsing, arithmetic on dates, and more.

Common classes and functions:

• datetime.datetime — represents date and time
• datetime.date — represents a date (year, month, day)
• datetime.time — represents time (hour, minute, second)
• datetime.timedelta — represents time duration
• datetime.now() — current local date and time
• datetime.strftime(format) — convert datetime to string format
• datetime.strptime(string, format) — parse string to datetime

Examples:

from datetime import datetime, date, timedelta

now = datetime.now()
print(now)                        # Output: current date and time

today = date.today()
print(today)                      # Output: current date

# Formatting datetime to string
formatted = now.strftime("%Y-%m-%d %H:%M:%S")
print(formatted)                  # Output: e.g., '2025-06-05 10:15:30'

# Parsing string to datetime
parsed_date = datetime.strptime("2023-01-01", "%Y-%m-%d")
print(parsed_date)                # Output: 2023-01-01 00:00:00

# Date arithmetic
tomorrow = today + timedelta(days=1)
print(tomorrow)                  # Output: date for tomorrow

4. json Module

Definition: The json module provides functionality to encode and decode data in JSON (JavaScript Object Notation) format. It is useful for working with web data or storing data in a standard readable format.

Common functions:

• json.dumps(obj) — convert Python object to JSON string
• json.dump(obj, file) — write JSON to a file
• json.loads(json_string) — parse JSON string to Python object
• json.load(file) — read JSON data from a file and parse

Examples:

import json

data = {
    "name": "Alice",
    "age": 30,
    "is_student": False,
    "courses": ["Math", "Science"]
}

# Convert Python dict to JSON string
json_str = json.dumps(data)
print(json_str)

# Convert JSON string back to Python dict
python_data = json.loads(json_str)
print(python_data["name"])   # Output: Alice

# Writing JSON to a file
with open('data.json', 'w') as f:
    json.dump(data, f)

# Reading JSON from a file
with open('data.json', 'r') as f:
    read_data = json.load(f)
print(read_data)

Conclusion

• The math module is essential for performing mathematical operations and using constants.
• The random module allows for random number generation and random selections, useful in simulations and games.
• The datetime module is powerful for handling dates, times, and performing date/time arithmetic and formatting.
• The json module facilitates easy data exchange by encoding and decoding JSON data, commonly used in web applications and APIs.
• Each of these modules is part of Python’s standard library and helps you write efficient and concise code for common tasks without extra installation.

Happy Learning Continue the next Lessons 🙂

Python Numpy

Python NumPy Introduction

What is NumPy?

NumPy (Numerical Python) is an open-source Python library used for numerical and scientific computing. It provides:

• A powerful N-dimensional array object (ndarray)
• Functions for performing operations on these arrays
• Tools for integrating with C/C++ and Fortran code
• Linear algebra, Fourier transform, and random number capabilities

Why Use NumPy?

• Efficient Data Storage: NumPy arrays consume less memory compared to standard Python lists.
• Fast Computation: Vectorized operations allow fast element-wise calculations without explicit loops.
• Convenient Array Operations: Enables easy manipulation of arrays (reshaping, slicing, broadcasting).
• Mathematical Functions: Rich library of mathematical functions including linear algebra, statistics, and more.
• Compatibility: Works seamlessly with other scientific libraries like SciPy, pandas, Matplotlib, and machine learning frameworks.
• Community and Support: Extensive documentation and large user base.

Key Concepts in NumPy

1. ndarray (N-dimensional array)

An ndarray is a multidimensional, homogeneous data structure (all elements have the same data type).

import numpy as np

arr = np.array([1, 2, 3, 4])  # 1D array
print(arr)
# Output: [1 2 3 4]

2. Shape

The shape is a tuple indicating the size of each dimension.

matrix = np.array([[1, 2], [3, 4]])
print(matrix.shape)
# Output: (2, 2)  # 2 rows, 2 columns

3. Data Type (dtype)

The type of elements stored in the array, e.g., int32, float64.

arr = np.array([1, 2, 3], dtype=float)
print(arr.dtype)
# Output: float64

4. Broadcasting

Ability to perform arithmetic operations on arrays of different shapes by "broadcasting" smaller arrays across larger ones.

a = np.array([1, 2, 3])
b = 2
print(a + b)  # b is broadcast to [2, 2, 2]
# Output: [3 4 5]

How to Install NumPy

pip install numpy
# Or with Anaconda:
conda install numpy

Common NumPy Functions and Examples

Creating Arrays

import numpy as np

# Array from list
arr1 = np.array([1, 2, 3])

# Array of zeros
zeros = np.zeros((2, 3))
print(zeros)
# [[0. 0. 0.]
#  [0. 0. 0.]]

# Array of ones
ones = np.ones((3, 2))
print(ones)
# [[1. 1.]
#  [1. 1.]
#  [1. 1.]]

# Array with a range of numbers
range_arr = np.arange(0, 10, 2)  # start, stop, step
print(range_arr)
# [0 2 4 6 8]

# Array of evenly spaced numbers
linspace_arr = np.linspace(0, 1, 5)  # start, stop, number of samples
print(linspace_arr)
# [0.   0.25 0.5  0.75 1.  ]

Array Operations

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

# Element-wise addition
print(a + b)  # [5 7 9]

# Element-wise multiplication
print(a * b)  # [4 10 18]

# Dot product
print(np.dot(a, b))  # 32

# Sum all elements
print(np.sum(a))  # 6

# Mean
print(np.mean(b))  # 5.0

Reshaping Arrays

arr = np.arange(6)
print(arr)
# [0 1 2 3 4 5]

# Reshape into 2x3 matrix
reshaped = arr.reshape(2, 3)
print(reshaped)
# [[0 1 2]
#  [3 4 5]]

Indexing and Slicing

arr = np.array([10, 20, 30, 40, 50])

# Access element at index 2
print(arr[2])  # 30

# Slice from index 1 to 3
print(arr[1:4])  # [20 30 40]

Conclusion

NumPy is a fundamental package for scientific computing and data manipulation in Python. It provides efficient multi-dimensional array objects and tools for working with them. Whether you’re doing simple calculations, complex linear algebra, or data analysis, NumPy speeds up computation and makes your code cleaner and more readable.

To summarize:

• Use NumPy arrays instead of Python lists for numerical data.
• Utilize NumPy’s fast, vectorized operations to write efficient code.
• Leverage NumPy’s rich set of mathematical and statistical functions.
• Reshape, slice, and manipulate large datasets easily with NumPy.
• Install NumPy with pip or conda and import it using import numpy as np.

Happy Learning Continue the next Lessons 🙂

Python NumPy Arrays

Definition

A NumPy array is a powerful, multidimensional, homogeneous data structure provided by the NumPy library in Python. It is used to store elements of the same data type efficiently and allows for fast mathematical and logical operations on large datasets.

Unlike Python’s built-in lists, NumPy arrays are optimized for numerical computations and can handle large datasets with better performance and less memory consumption.

Key Features of NumPy Arrays

• Homogeneous: All elements in the array have the same data type.
• Fixed Size: The size of a NumPy array is fixed at creation time.
• Multidimensional: Can create 1D, 2D, 3D, or higher-dimensional arrays.
• Vectorized Operations: Support element-wise operations without explicit loops.
• Efficient Storage: Uses less memory compared to Python lists for numeric data.

Creating NumPy Arrays

import numpy as np

# 1D array from list
arr1 = np.array([10, 20, 30, 40])
print(arr1)
# Output: [10 20 30 40]

# 2D array (matrix) from nested lists
arr2 = np.array([[1, 2, 3], [4, 5, 6]])
print(arr2)
# Output:
# [[1 2 3]
#  [4 5 6]]

# Array of zeros
zeros = np.zeros((3, 4))
print(zeros)
# Output:
# [[0. 0. 0. 0.]
#  [0. 0. 0. 0.]
#  [0. 0. 0. 0.]]

# Array of ones
ones = np.ones((2, 3))
print(ones)
# Output:
# [[1. 1. 1.]
#  [1. 1. 1.]]

# Array with evenly spaced values (arange)
range_arr = np.arange(0, 10, 2)
print(range_arr)
# Output: [0 2 4 6 8]

Important Attributes of NumPy Arrays

arr = np.array([[1, 2, 3], [4, 5, 6]])

# Shape of the array (rows, columns)
print(arr.shape)  # Output: (2, 3)

# Number of dimensions
print(arr.ndim)   # Output: 2

# Data type of elements
print(arr.dtype)  # Output: int64 (or int32 depending on system)

# Total number of elements
print(arr.size)   # Output: 6

Basic Operations on NumPy Arrays

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

# Element-wise addition
print(a + b)  # Output: [5 7 9]

# Element-wise multiplication
print(a * b)  # Output: [4 10 18]

# Scalar multiplication
print(a * 3)  # Output: [3 6 9]

# Dot product
print(np.dot(a, b))  # Output: 32

# Sum all elements
print(np.sum(a))  # Output: 6

# Mean of elements
print(np.mean(b))  # Output: 5.0

Indexing and Slicing

arr = np.array([10, 20, 30, 40, 50])

# Access single element
print(arr[2])  # Output: 30

# Slice (sub-array)
print(arr[1:4])  # Output: [20 30 40]

# 2D array slicing
matrix = np.array([[1, 2, 3], [4, 5, 6]])
print(matrix[1, 2])   # Output: 6 (row 1, column 2)
print(matrix[:, 1])   # Output: [2 5] (all rows, column 1)

Reshaping Arrays

arr = np.arange(12)
print(arr)
# Output: [0 1 2 3 4 5 6 7 8 9 10 11]

# Reshape to 3 rows, 4 columns
reshaped = arr.reshape(3, 4)
print(reshaped)
# Output:
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]

Broadcasting Example

Broadcasting allows NumPy to perform arithmetic operations on arrays of different shapes.

a = np.array([1, 2, 3])
b = 10

print(a + b)  # Output: [11 12 13]

Here, b (a scalar) is broadcasted to match the shape of a.

Conclusion

NumPy arrays are central to scientific computing in Python.

• They offer efficient storage and fast operations for numerical data.
• Arrays support multidimensional data and vectorized computations.
• NumPy arrays have many useful attributes and methods for easy data manipulation.
• Using NumPy arrays over Python lists results in cleaner, faster, and more readable numerical code.

Happy Learning Continue the next Lessons 🙂