<!-- Steps to run a Python project -->

1. <!-- Make sure Python is installed. Check with: -->
   <code>python --version</code>

2. <!-- Create a Python file, e.g., app.py -->
   <code>
   # app.py
   print("Hello, Python Project!")
   </code>

3. <!-- Open your terminal or command prompt -->
   <!-- Navigate to the folder where your script is saved -->

4. <!-- Run the script using the command: -->
   <code>python app.py</code>

<!-- Output: -->
Hello, Python Project!
      

# Variables store data in memory for later use.
# Python is dynamically typed, so no type declaration needed.

name = "Alice"              # String variable
age = 25                    # Integer variable
is_student = True           # Boolean variable

print(name)                 # Output: Alice
print(age)                  # Output: 25
print(is_student)           # Output: True
      

# A function is a reusable block of code that performs a task.
# Use the 'def' keyword to define a function.

def greet(name):                         # Define function with one parameter
    print("Hello, " + name + "!")        # Function body

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

# A list is an ordered collection of items.
# Lists are mutable and can contain mixed data types.

fruits = ["apple", "banana", "cherry"]   # Define a list

print(fruits[0])                         # Output: apple
fruits.append("orange")                  # Add item to list
print(fruits)                            # Output: ['apple', 'banana', 'cherry', 'orange']
      

# A for loop is used to iterate over sequences (like lists, strings, etc.)

numbers = [1, 2, 3]

for num in numbers:                  # Loop over list
    print(num)                       # Output: 1 2 3 (one per line)
      

# A dictionary holds key-value pairs.
# It is unordered, mutable, and indexed by keys.

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

print(student["name"])         # Output: John
student["age"] = 21            # Update value
print(student["age"])          # Output: 21
      

# Use try-except blocks to catch and handle exceptions.

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

# Use the input() function to get input from the user.

name = input("Enter your name: ")         # Prompt user
print("Hello, " + name + "!")             # Output: Hello, <user_input>!
      

# Use open() function with write ('w') mode to write to files.

with open("sample.txt", "w") as file:        # Open file in write mode
    file.write("This is a test.")            # Write to file

# The 'with' block automatically closes the file
      

# Classes define blueprints for objects.
# Objects are instances of classes.

class Person:
    def __init__(self, name):               # Constructor method
        self.name = name                    # Instance variable

    def greet(self):                        # Method
        print("Hi, I am " + self.name)

p = Person("Alice")                         # Create object
p.greet()                                   # Output: Hi, I am Alice
      

# List comprehensions provide a concise way to create lists.

numbers = [1, 2, 3, 4, 5]
squares = [x**2 for x in numbers]         # Square each number

print(squares)                            # Output: [1, 4, 9, 16, 25]
      

# A lambda function is a small anonymous function.
# It can have any number of arguments but only one expression.

square = lambda x: x * x                  # Define lambda function
print(square(5))                          # Output: 25
      

# == compares values. 'is' compares identities (memory addresses).

a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)         # True: values are equal
print(a is b)         # False: different objects
print(a is c)         # True: same object
      

# Slicing extracts a portion of a list, string, or tuple.

my_list = [0, 1, 2, 3, 4, 5]

print(my_list[1:4])        # Output: [1, 2, 3]
print(my_list[:3])         # Output: [0, 1, 2]
print(my_list[::2])        # Output: [0, 2, 4]
      

# Lists are mutable; tuples are immutable.

my_list = [1, 2, 3]               # Can change values
my_tuple = (1, 2, 3)              # Cannot change values

my_list[0] = 10                   # Works
# my_tuple[0] = 10                # Error
      

# *args allows variable number of positional arguments
# **kwargs allows variable number of keyword arguments

def show_args(*args, **kwargs):
    print(args)           # Tuple of positional arguments
    print(kwargs)         # Dictionary of keyword arguments

show_args(1, 2, 3, a=10, b=20)
# Output: (1, 2, 3)
#         {'a': 10, 'b': 20}
      

# You can reverse a list in multiple ways

my_list = [1, 2, 3, 4]

reversed1 = my_list[::-1]       # Slicing
my_list.reverse()               # In-place reverse
reversed2 = list(reversed(my_list))  # Using reversed()

print(reversed1)                # Output: [4, 3, 2, 1]
      

# Use 'import' to include modules

import math                      # Import entire module
print(math.sqrt(16))            # Output: 4.0

from math import pi             # Import specific object
print(pi)                       # Output: 3.14159...
      

# Sets are unordered collections of unique items

my_set = {1, 2, 2, 3, 4}
print(my_set)                   # Output: {1, 2, 3, 4}

my_set.add(5)                   # Add item
my_set.remove(1)                # Remove item
      

# Generators yield values one at a time using 'yield'

def count_up_to(max):
    count = 1
    while count <= max:
        yield count
        count += 1

for num in count_up_to(3):
    print(num)                  # Output: 1 2 3
      

# Decorators modify the behavior of functions.

def decorator_func(func):
    def wrapper():
        print("Before function call")
        func()
        print("After function call")
    return wrapper

@decorator_func
def say_hello():
    print("Hello!")

say_hello()
# Output:
# Before function call
# Hello!
# After function call
      

# Use try-except blocks to handle exceptions gracefully

try:
    x = 10 / 0                    # Will raise ZeroDivisionError
except ZeroDivisionError:
    print("Cannot divide by zero!")  # Handle error
finally:
    print("Execution finished.")     # Always runs
      

# 'with' ensures proper resource management (e.g., closing files)

with open("example.txt", "w") as file:
    file.write("Hello, world!")    # File is automatically closed
      

# Use type() function

x = 5
print(type(x))            # Output: <class 'int'>

y = "hello"
print(type(y))            # Output: <class 'str'>
      

# A dictionary is a collection of key-value pairs

person = {
    "name": "Alice",
    "age": 25,
    "city": "New York"
}

print(person["name"])       # Output: Alice
      

# List comprehension provides a concise way to create lists

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

# append() adds a single element
# extend() adds elements from another iterable

a = [1, 2]
a.append([3, 4])
print(a)                  # Output: [1, 2, [3, 4]]

b = [1, 2]
b.extend([3, 4])
print(b)                  # Output: [1, 2, 3, 4]
      

# Use '#' for single-line comments
# Use triple quotes ''' or """ for multiline docstrings

# This is a single-line comment

"""
This is a
multiline comment
or docstring
"""
      

# 'pass' is a placeholder for future code

def function_to_implement_later():
    pass     # No operation, just a placeholder

class EmptyClass:
    pass
      

x = 5              # Global variable

def my_func():
    x = 10         # Local variable
    print(x)       # Output: 10

my_func()
print(x)           # Output: 5
      

# Use built-in functions: int(), float(), str(), list(), etc.

x = "123"
print(int(x))          # Output: 123

y = 3.14
print(str(y))          # Output: "3.14"

z = [1, 2, 3]
print(tuple(z))        # Output: (1, 2, 3)
      

# 'is' checks for identity (whether two variables refer to the same object)

a = [1, 2]
b = a
c = [1, 2]

print(a is b)    # True (same object)
print(a is c)    # False (same value, different object)
      

# Slicing is used to get a part of a list, string, or tuple

numbers = [0, 1, 2, 3, 4, 5]
print(numbers[1:4])   # Output: [1, 2, 3]
print(numbers[:3])    # Output: [0, 1, 2]
print(numbers[::2])   # Output: [0, 2, 4]
      

# *args allows variable number of positional arguments
# **kwargs allows variable number of keyword arguments

def show_info(*args, **kwargs):
    print(args)
    print(kwargs)

show_info(1, 2, 3, name="Alice", age=30)
# Output: (1, 2, 3)
# Output: {'name': 'Alice', 'age': 30}
      

# Open a file to write
with open("sample.txt", "w") as f:
    f.write("Hello Python!")

# Open a file to read
with open("sample.txt", "r") as f:
    content = f.read()
    print(content)    # Output: Hello Python!
      

# Lambda functions are anonymous functions defined using the lambda keyword

add = lambda x, y: x + y
print(add(2, 3))      # Output: 5
      

from functools import reduce

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

# map - apply function to all elements
squares = list(map(lambda x: x*x, nums))
print(squares)             # Output: [1, 4, 9, 16, 25]

# filter - filter based on condition
even = list(filter(lambda x: x%2 == 0, nums))
print(even)                # Output: [2, 4]

# reduce - apply function cumulatively
sum_all = reduce(lambda x, y: x + y, nums)
print(sum_all)             # Output: 15
      

# 'in' checks membership in iterables

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

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}

# Python 3.9+
merged = dict1 | dict2
print(merged)              # Output: {'a': 1, 'b': 3, 'c': 4}

# For older versions
merged = {**dict1, **dict2}
print(merged)              # Output: {'a': 1, 'b': 3, 'c': 4}
      

# Module: a file with Python code (.py)
# Package: a directory with __init__.py and modules

# example.py
def greet():
    print("Hello from module!")

# main.py
import example
example.greet()           # Output: Hello from module!
      

# Virtual environment isolates dependencies for each project

# Create virtual environment
python -m venv env

# Activate on Windows
env\Scripts\activate

# Activate on Unix/macOS
source env/bin/activate

# Install packages locally
pip install requests
      

import datetime

# Current date and time
now = datetime.datetime.now()
print("Now:", now)

# Create a specific date
d = datetime.date(2025, 5, 19)
print("Date:", d)

# Format date
print("Formatted:", now.strftime("%Y-%m-%d"))
      

# Generators use yield to produce items one by one

def countdown(n):
    while n > 0:
        yield n
        n -= 1

for i in countdown(3):
    print(i)     # Output: 3 2 1
      

import sys

# Prints the list of command-line arguments
print("Arguments:", sys.argv)

# Example:
# python script.py hello world
# Output: ['script.py', 'hello', 'world']
      

# Defining a class
class Dog:
    def __init__(self, name):
        self.name = name

    def bark(self):
        print(self.name + " says woof!")

# Creating object
d = Dog("Buddy")
d.bark()     # Output: Buddy says woof!
      

# Inheritance allows a class to use methods and properties of another

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

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

d = Dog()
d.speak()   # Output: Animal speaks
d.bark()    # Output: Dog barks
      

# Decorator adds functionality to an existing function

def my_decorator(func):
    def wrapper():
        print("Before function")
        func()
        print("After function")
    return wrapper

@my_decorator
def greet():
    print("Hello!")

greet()
# Output:
# Before function
# Hello!
# After function
      

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

# Dictionary comprehension
d = {x: x*x for x in range(3)}
print(d)           # Output: {0: 0, 1: 1, 2: 4}
      

numbers = [4, 2, 9, 1]

# Sort ascending
numbers.sort()
print(numbers)      # Output: [1, 2, 4, 9]

# Sort descending
numbers.sort(reverse=True)
print(numbers)      # Output: [9, 4, 2, 1]
      

names = ["Alice", "Bob"]
scores = [85, 90]

# Combine elements from both lists
combined = list(zip(names, scores))
print(combined)    # Output: [('Alice', 85), ('Bob', 90)]
      

# Reverse a string
s = "hello"
print(s[::-1])       # Output: "olleh"

# Reverse a list
nums = [1, 2, 3]
nums.reverse()
print(nums)          # Output: [3, 2, 1]
      

# Context managers manage resources like files

with open("file.txt", "w") as f:
    f.write("Hello, world!")  # File auto-closes after this block
      

# Lambda creates anonymous functions

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

import sys

x = [1, 2, 3, 4]
print(sys.getsizeof(x))  # Output: memory size in bytes
      

# Create virtual environment
python -m venv myenv

# Activate (Windows)
myenv\Scripts\activate

# Activate (Mac/Linux)
source myenv/bin/activate
      

# *args: variable number of positional arguments
# **kwargs: variable number of keyword arguments

def demo(*args, **kwargs):
    print("args:", args)
    print("kwargs:", kwargs)

demo(1, 2, a=3, b=4)
# Output: args: (1, 2), kwargs: {'a': 3, 'b': 4}
      

a = {'x': 1}
b = {'y': 2}

# Merge using unpacking
merged = {**a, **b}
print(merged)  # Output: {'x': 1, 'y': 2}
      

# Magic methods start and end with __

class Book:
    def __init__(self, title):
        self.title = title

    def __str__(self):
        return f"Book: {self.title}"

b = Book("Python")
print(b)  # Output: Book: Python
      

my_dict = {"a": 1}

# Use get() with default value
print(my_dict.get("b", "Not found"))  # Output: Not found
      

# == checks value equality
# is checks identity (same memory location)

a = [1, 2]
b = [1, 2]
print(a == b)  # True
print(a is b)  # False
      

# map() applies a function to every item in a list

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