• Python Features
• Python Installation
• PyCharm Configuration
• Python Variables
• Python Data Types
• Python If Else
• Python Loops
• Python Strings
• Python Lists
• Python Tuples
• Python List Vs Tuple
• Python Sets
• Python Dictionary
• Python Functions
• Python Files I/O
• Read Write Excel
• Read Write JSON
• Read Write CSV
• Python OS Module
• Python Exceptions
• Python Datetime
  • Modules MCQs
• Python Collection Module
• Python Sys Module
• Python Decorator
• Python Generators
• Python OOPS
• Python Numpy Module
• Python Pandas Module
• Python Sqlite Module

Introduction

Welcome to our comprehensive guide on Python’s datetime module! In the world of programming, handling dates and times is a common requirement.

Features

The datetime module in Python boasts a range of features that make it an indispensable tool for working with date and time data:

• Precise date and time representation.
• Time zone awareness for handling time differences.
• Arithmetic operations on dates and times.
• Formatting and parsing of date and time strings.
• Support for both Gregorian and Julian calendar systems.

Different Functions of the datetime Module

1. datetime.now() – Current Date and Time:

Returns the current date and time.

				
import datetime
current_datetime = datetime.datetime.now()
print(current_datetime)

# Output
2023-08-14 10:15:30.123456

         2. datetime.combine() – Combine Date and Time:

Combines a date and a time into a single datetime object.

				
import datetime
date = datetime.date(2023, 8, 14)
time = datetime.time(10, 30)
combined_datetime = datetime.datetime.combine(date, time)
print(combined_datetime)

# Output
2023-08-14 10:30:00

        3. datetime.strptime() – String to Datetime:

Converts a string to a datetime object based on a specified format.

				
import datetime
date_string = '2023-08-14'
formatted_date = datetime.datetime.strptime(date_string, '%Y-%m-%d')
print(formatted_date)

# Output
2023-08-14 00:00:00

Common Format Codes

        4. datetime.strftime() – Datetime to String:

Formats a datetime object as a string according to a given format.

				
import datetime
current_datetime = datetime.datetime.now()
formatted_datetime = current_datetime.strftime('%Y-%m-%d %H:%M:%S')
print(formatted_datetime)

# Output
2023-08-14 10:15:30

        5. timedelta() – Time Interval:

Represents a duration of time, supporting arithmetic operations with datetime objects.

				
import datetime
delta = datetime.timedelta(days=5, hours=3)
future_date = datetime.datetime.now() + delta
print(future_date)
# Output
2023-08-19 13:15:30.123456

        6. datetime.date() – Extract Date:

Extracts the date portion from a datetime object.

				
import datetime
current_datetime = datetime.datetime.now()
date_part = current_datetime.date()
print(date_part)

# Output
2023-08-14

        7. datetime.time() – Extract Time:

Extracts the time portion from a datetime object.

				
import datetime
current_datetime = datetime.datetime.now()
time_part = current_datetime.time()
print(time_part)

# Output
10:15:30.123456

        8. datetime.replace() – Replace Components:

Creates a new datetime object by replacing specific components.

				
import datetime
current_datetime = datetime.datetime.now()
modified_datetime = current_datetime.replace(hour=12, minute=0)
print(modified_datetime)

# Output
2023-08-14 12:00:30.123456

        9. datetime.weekday() – Weekday Index:

Returns the index of the weekday (0 for Monday, 6 for Sunday).

				
import datetime
current_datetime = datetime.datetime.now()
weekday_index = current_datetime.weekday()
print(weekday_index)

# Output
6

       10. datetime.isoweekday() – ISO Weekday:

Returns the ISO weekday (1 for Monday, 7 for Sunday).

				
import datetime
current_datetime = datetime.datetime.now()
iso_weekday = current_datetime.isoweekday()
print(iso_weekday)

# Output
7

       11. datetime.timestamp() – Unix Timestamp:

Returns the Unix timestamp (the number of seconds since January 1, 1970).

				
import datetime
current_datetime = datetime.datetime.now()
timestamp = current_datetime.timestamp()
print(timestamp)

# Output
1673256930.123456

       12. datetime.astimezone() – Timezone Conversion:

Converts a datetime object to a different timezone.

				
import datetime, pytz
current_datetime = datetime.datetime.now()
timezone = pytz.timezone('America/New_York')
converted_datetime = current_datetime.astimezone(timezone)
print(converted_datetime)

# Output
2023-08-14 06:15:30.123456-04:00

       13. datetime.utcoffset() – UTC Offset:

Returns the UTC offset of a datetime object.

				
import datetime, pytz
current_datetime = datetime.datetime.now()
utc_offset = current_datetime.utcoffset()
print(utc_offset)

# Output
3:00:00

       14. datetime.timedelta.total_seconds() – Total Seconds:

Returns the total number of seconds in a timedelta object.

				
import datetime
delta = datetime.timedelta(days=2, hours=5)
total_seconds = delta.total_seconds()
print(total_seconds)

# Output
189600.0

       15. datetime.fromtimestamp() – Datetime from Timestamp:

Creates a datetime object from a Unix timestamp.

				
import datetime
timestamp = 1673256930.123456
converted_datetime = datetime.datetime.fromtimestamp(timestamp)
print(converted_datetime)

# Output
2023-08-09 10:15:30.123456
				

• Python Features
• Python Installation
• PyCharm Configuration
• Python Variables
• Python Data Types
• Python If Else
• Python Loops
• Python Strings
• Python Lists
• Python Tuples
• Python List Vs Tuple
• Python Sets
• Python Dictionary
• Python Functions
• Python Files I/O
• Read Write Excel
• Read Write JSON
• Read Write CSV
• Python OS Module
• Python Exceptions
• Python Datetime
• Python Collection Module
• Python Sys Module
  • Modules MCQs
• Python Decorator
• Python Generators
• Python OOPS
• Python Numpy Module
• Python Pandas Module
• Python Sqlite Module

Functions/Methods of the sys Module

1. sys.argv – Command-Line Arguments:

The argv list contains command-line arguments passed to the script.

import sys
print("Script name:", sys.argv[0])
print("Arguments:", sys.argv[1:])

2. sys.path – Module Search Path:

The path list contains directories where Python searches for modules.

import sys
print("Module search paths:")
for path in sys.path:
    print(path)

3. sys.version – Python Version Information:

The version string provides information about the Python interpreter.

import sys
print("Python version:", sys.version)

4. sys.platform – Operating System Platform:

The platform string indicates the operating system platform.

import sys
print("Operating system platform:", sys.platform)

5. sys.getsizeof() – Object Size in Memory:

The getsizeof() function returns the size of an object in bytes.

import sys
size = sys.getsizeof("Hello, world!")
print("Size of the string:", size, "bytes")

6. sys.exit() – Graceful Exit:

The exit() function terminates the program with an optional exit code.

import sys
print("Exiting the program")
sys.exit(0)

7. sys.maxsize – Maximum Integer Value:

The maxsize integer represents the maximum size of a list or range.

import sys
print("Maximum list size:", sys.maxsize)

8. sys.modules – Loaded Modules:

The modules dictionary contains information about loaded modules.

import sys
print("Loaded modules:")
for module in sys.modules:
    print(module)

9. sys.exc_info() – Exception Information:

The exc_info() function returns information about the current exception.

import sys
try:
    result = 1 / 0
except:
    exc_type, exc_value, exc_traceback = sys.exc_info()
    print("Exception type:", exc_type)
    print("Exception value:", exc_value)

• Python Features
• Python Installation
• PyCharm Configuration
• Python Variables
• Python Data Types
• Python If Else
• Python Loops
• Python Strings
• Python Lists
• Python Tuples
• Python List Vs Tuple
• Python Sets
• Python Dictionary
• Python Functions
• Python Files I/O
• Read Write Excel
• Read Write JSON
• Read Write CSV
• Python OS Module
• Python Exceptions
• Python Datetime
• Python Collection Module
• Python Sys Module
• Python Decorator
• Python Generators
• Python OOPS
• Python Numpy Module
• Python Pandas Module
• Python Sqlite Module

Collections Methods with Examples

1. namedtuple() – Create Named Tuples:

The namedtuple() function creates a new subclass of tuple with named fields, enhancing code clarity.

from collections import namedtuple
Person = namedtuple('Person', ['name', 'age'])
person = Person('Alice', 30)
print(person.name, person.age)

2. Counter() – Count Elements in an Iterable:

The Counter() function creates a dictionary-like object to count occurrences of elements in an iterable.

from collections import Counter
colors = ['red', 'blue', 'red', 'green', 'blue', 'blue']
color_counter = Counter(colors)
print(color_counter['red'])  # Output: 2

3. deque() – Double-Ended Queue:

The deque() function creates a double-ended queue, useful for fast appends and pops from both ends.

from collections import deque
queue = deque([1, 2, 3])
queue.append(4)
queue.popleft()
print(queue)  # Output: deque([2, 3, 4])

4. defaultdict() – Default Values for Missing Keys:

The defaultdict() function creates dictionaries with default values for missing keys.

from collections import defaultdict
grades = defaultdict(lambda: 'Not Available')
grades['Alice'] = 95
print(grades['Bob'])  # Output: Not Available

5. OrderedDict() – Ordered Dictionary:

The OrderedDict() function creates dictionaries that remember the order of insertion.

from collections import OrderedDict
ordered_dict = OrderedDict()
ordered_dict['a'] = 1
ordered_dict['b'] = 2
print(list(ordered_dict.keys()))  # Output: ['a', 'b']

6. ChainMap() – Chain Multiple Dictionaries:

The ChainMap() function combines multiple dictionaries into a single view.

from collections import ChainMap
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
combined = ChainMap(dict1, dict2)
print(combined['b'])  # Output: 2

• Python Features
• Python Installation
• PyCharm Configuration
• Python Variables
• Python Data Types
• Python If Else
• Python Loops
• Python Strings
• Python Lists
• Python Tuples
• Python List Vs Tuple
• Python Sets
• Python Dictionary
• Python Functions
• Python Files I/O
• Read Write Excel
• Read Write JSON
• Read Write CSV
• Python OS Module
• Python Exceptions
  • Exceptions MCQs
• Python Datetime
• Python Collection Module
• Python Sys Module
• Python Decorator
• Python Generators
• Python OOPS
• Python Numpy Module
• Python Pandas Module
• Python Sqlite Module

Exception Handling

Exception Handling is used to manage runtime errors and prevent programs from crashing.

Exceptions occur when:

• User enters invalid input
• File not found
• Network connection fails
• Wrong operations (divide by zero)

Basic Structure

try:
    # Code that may throw error
except:
    # Code to run if error occurs

Basic Example

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

Catching Specific Exceptions

try:
    a = int("abc")
except ValueError:
    print("Value Error occurred: Invalid conversion to integer")

Multiple Except Blocks

try:
    num = int(input("Enter a number: "))
    result = 10 / num
except ZeroDivisionError:
    print("You cannot divide by zero.")
except ValueError:
    print("Only numbers are allowed.")

Using else Block

Runs only when no exception occurs.

try:
    x = int(input("Enter age: "))
except ValueError:
    print("Invalid input.")
else:
    print("Valid age:", x)

Using finally Block

Always runs — even if an error occurs.

try:
    f = open("data.txt")
except FileNotFoundError:
    print("File not found!")
finally:
    print("Program finished.")

Raise an Exception Yourself

Use raise for rules/validation.

age = -5
if age < 0:
    raise ValueError("Age cannot be negative")

Custom Exception

class InvalidAgeError(Exception):
    pass

age = 15
if age < 18:
    raise InvalidAgeError("You must be 18+ to sign up")

File Handling with Exception

try:
    f = open("notes.txt", "r")
    print(f.read())
except FileNotFoundError:
    print("File does not exist.")
finally:
    print("Closing file if opened.")

Multiple Exceptions in One Line

try:
    x = 10 / int("a")
except (ZeroDivisionError, ValueError):
    print("Error: Invalid operation")

Catch All Exceptions

try:
    a = 10 / 0
except Exception as e:
    print("Error occurred:", e)

Common Built-in Exceptions

Real-Time Examples

User Input Validation

while True:
    try:
        amount = float(input("Enter amount: "))
        break
    except ValueError:
        print("Enter a valid number!")

Retry File Opening Automatically

for _ in range(3):
    try:
        f = open("config.json")
        print("File opened!")
        break
    except FileNotFoundError:
        print("File missing, retrying...")

API Request Error Handling (Concept)

try:
    data = fetch_api_data()
except ConnectionError:
    print("Network issue!")

• Python Features
• Python Installation
• PyCharm Configuration
• Python Variables
• Python Data Types
• Python If Else
• Python Loops
• Python Strings
• Python Lists
• Python Tuples
• Python List Vs Tuple
• Python Sets
• Python Dictionary
• Python Functions
• Python Files I/O
• Read Write Excel
• Read Write JSON
• Read Write CSV
• Python OS Module
• Python Exceptions
• Python Datetime
• Python Collection Module
• Python Sys Module
• Python Decorator
• Python Generators
• Python OOPS
  • Python Inheritance
  • Python Polymorphism
  • Python OOPS MCQs
  • OOPS Programs
• Python Numpy Module
• Python Pandas Module
• Python Sqlite Module

Python OOP – Fundamentals

Object-Oriented Programming (OOP) is a programming style organized around objects instead of functions.
It helps structure code that is scalable, reusable, and modular.

Four Pillars of OOP

Basic Terminology

Creating a Class & Object

class Person:
    def __init__(self, name, age):
        self.name = name    # Instance attribute
        self.age = age

    def greet(self):
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")

p1 = Person("Amit", 25)
p1.greet()

Description

• Person is a class (blueprint).
• p1 is an object/instance of the class.
• __init__ is a constructor that initializes object attributes when created.
• self refers to the current object.
• greet() is an instance method, accessible using the object.

Class Variables vs Instance Variables

class Employee:
    company = "Google"  # Class variable (shared by all objects)

    def __init__(self, name):
        self.name = name  # Instance variable (unique to each object)

e1 = Employee("Sam")
e2 = Employee("Riya")
print(e1.company, e2.company)
print(e1.name, e2.name)

Description

• company belongs to the class, so every Employee object uses “Google”.
• name is an instance variable — each object has a different value.
• Helps differentiate data shared across objects and unique to each.

Encapsulation (Data Hiding)

Encapsulation refers to the concept of bundling data and methods that operate on that data into a single unit, i.e., a class. It prevents direct access to data from outside the class and promotes data hiding.

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance  # Private variable

    def get_balance(self):
        return self.__balance  # Getter method

    def deposit(self, amount):
        self.__balance += amount  # Setter method

account = BankAccount(1000)
account.deposit(500)
print(account.get_balance())

Description

• The variable __balance is private and cannot be accessed directly using object.
• Encapsulation protects data from accidental modification.
• We control access through getter & setter functions.

Abstraction (Hiding Complex Details)

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass  # Abstract method (must be implemented)

class Circle(Shape):
    def __init__(self, r):
        self.r = r

    def area(self):
        return 3.14 * self.r * self.r

c = Circle(5)
print(c.area())

Description

• Shape is an abstract class — cannot be instantiated.
• Contains an abstract method that forces subclasses to implement it.
• The Circle must provide its own area method → ensuring a standard structure.

Constructor & Destructor

class Sample:
    def __init__(self):
        print("Constructor executed")

    def __del__(self):
        print("Destructor executed")

obj = Sample()
del obj

Description

• __init__ runs automatically when the object is created.
• __del__ runs when the object is destroyed or the program ends.
• Used for resource management (like closing files, DB connections, etc.)

Static & Class Methods

1. Class Method

• In Python, a class method is a type of method that is bound to the class itself rather than to instances of the class.
• It can access and modify class-level attributes and perform actions related to the class as a whole.
• Class methods are defined using the @classmethod decorator and take the class itself as the first parameter, conventionally named cls.
• This makes them different from instance methods, which take the instance itself (self) as the first parameter.

2. Static Method

• A static method is a method that is defined within a class but is not bound to the class instance or class-level attributes.
• It doesn’t receive any implicit reference to the class or its instances as parameters. Static methods are defined using the @staticmethod decorator.
• Static methods are often used to create utility functions that are logically related to the class but don’t require access to instance-specific or class-level data.

class Student:
    school = "DAV School"

    @staticmethod
    def welcome():
        print("Welcome to the School!")  # No object needed

    @classmethod
    def get_school_name(cls):
        return cls.school

Student.welcome()
print(Student.get_school_name())

Description

• @staticmethod → Does not access class or object data. Used as helper logic.
• @classmethod → Access class variables using cls.

Real-World Example

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

    def details(self):
        print(f"{self.brand} {self.model} costs ₹{self.price}")

c1 = Car("Toyota", "Fortuner", 3500000)
c1.details()

Description

• Represents real-world entities as Python objects.
• Helps in designing software similar to real systems.