Functions in Python – NIELIT O Level (M3-R5)

📘 Introduction

जब किसी बड़े program को छोटे-छोटे manageable parts (modules) में तोड़ा जाता है, तो उसे Modular Programming कहा जाता है। Python modular programming को support करता है ताकि code को पढ़ना, debug करना और reuse करना आसान हो।

Top-Down Programming approach में सबसे पहले पूरे program की structure को high-level पर design किया जाता है (यानि main logic पहले लिखा जाता है), फिर उसे छोटे sub-parts में divide किया जाता है जिन्हें functions कहा जाता है।

🧱 Advantages of Modular / Top-Down Programming

• ✅ Code को समझना और maintain करना आसान होता है।
• ✅ Code reuse किया जा सकता है।
• ✅ Debugging और testing आसान होती है।
• ✅ Large projects को team में efficiently divide किया जा सकता है।

🧩 Structure of Top-Down Approach

Main Problem
   ↳ Divide into Sub-Problems
         ↳ Implement Sub-Modules / Functions
               ↳ Integrate All Modules
  

💻 Example 1: Top-Down Design for Area Calculation

# Main module
def main():
    print("Area Calculation Program")
    rectangle_area()
    circle_area()

# Sub-module 1
def rectangle_area():
    l = float(input("Enter length: "))
    b = float(input("Enter breadth: "))
    area = l * b
    print("Area of Rectangle =", area)

# Sub-module 2
def circle_area():
    r = float(input("Enter radius: "))
    area = 3.1416 * r * r
    print("Area of Circle =", area)

# Program execution starts here
main()
  

Output:
Area Calculation Program
Enter length: 5
Enter breadth: 4
Area of Rectangle = 20.0
Enter radius: 3
Area of Circle = 28.2744

⚙️ Explanation

• main() function program का entry point है।
• यह छोटे sub-functions (rectangle_area() और circle_area()) को call करता है।
• हर function केवल एक specific काम करता है — यही modularity है।

🧮 Example 2: Modular Program to Perform Calculator Operations

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

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

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

def divide(a, b):
    if b != 0:
        return a / b
    else:
        return "Division by zero not allowed"

def main():
    print("Simple Calculator")
    a = float(input("Enter first number: "))
    b = float(input("Enter second number: "))
    print("Addition:", add(a, b))
    print("Subtraction:", subtract(a, b))
    print("Multiplication:", multiply(a, b))
    print("Division:", divide(a, b))

main()
  

Output:
Simple Calculator
Enter first number: 8
Enter second number: 4
Addition: 12.0
Subtraction: 4.0
Multiplication: 32.0
Division: 2.0

📊 Example 3: Modular Program – Student Grade System

def input_marks():
    marks = []
    for i in range(3):
        mark = int(input(f"Enter marks of subject {i+1}: "))
        marks.append(mark)
    return marks

def calculate_average(marks):
    return sum(marks) / len(marks)

def find_grade(avg):
    if avg >= 90:
        return "A"
    elif avg >= 75:
        return "B"
    elif avg >= 60:
        return "C"
    else:
        return "D"

def main():
    print("Student Grade Calculator")
    marks = input_marks()
    avg = calculate_average(marks)
    grade = find_grade(avg)
    print(f"Average Marks = {avg}")
    print(f"Grade = {grade}")

main()
  

Output:
Student Grade Calculator
Enter marks of subject 1: 85
Enter marks of subject 2: 90
Enter marks of subject 3: 80
Average Marks = 85.0
Grade = B

💬 Interview FAQs

• Q: What is Top-Down Programming?
  A: It is a design approach where a problem is divided into smaller sub-problems, each handled by separate functions.
• Q: What is Modular Programming?
  A: Dividing the program into independent, reusable modules or functions for better structure and readability.
• Q: What are the benefits of modular programming?
  A: Code reusability, easier debugging, team collaboration, and improved readability.
• Q: How is a function related to modularity?
  A: Each function is a module that performs a single task, making the overall program modular.
• Q: What is the main difference between Top-Down and Bottom-Up approach?
  A: In Top-Down, main logic is designed first; in Bottom-Up, individual components are built first and then integrated.

📘 Introduction

Python में functions program को छोटे reusable parts में divide करने के लिए use किए जाते हैं। Function एक block of code होता है जो किसी specific task को perform करता है। Functions को define किया जाता है और फिर call किया जाता है जब उनकी जरूरत होती है।

🧩 Function Definition Syntax

def function_name(parameters):
    """optional docstring"""
    # function body
    statement(s)
    return [expression]
  

• def → Function define करने के लिए keyword।
• function_name → Function का नाम (identifier)।
• parameters → Optional values जो function को input के रूप में मिलते हैं।
• return → Result को वापस करने के लिए keyword (optional)।

💡 Example 1: Simple Function

def greet():
    print("Hello, Welcome to Python Programming!")

# Function call
greet()
  

Output:
Hello, Welcome to Python Programming!

📥 Example 2: Function with Parameters

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

# Function call
add(5, 10)
  

Output:
Sum = 15

🔁 Example 3: Function with Return Statement

return statement function को terminate करता है और एक value caller को वापस भेजता है। यह value को program के अन्य हिस्सों में use किया जा सकता है।

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

result = multiply(4, 5)
print("Multiplication =", result)
  

Output:
Multiplication = 20

📊 Example 4: Returning Multiple Values

Python में function एक साथ multiple values return कर सकता है — tuple के रूप में।

def calculate(a, b):
    sum_ = a + b
    diff = a - b
    prod = a * b
    return sum_, diff, prod

x, y, z = calculate(10, 5)
print("Sum =", x)
print("Difference =", y)
print("Product =", z)
  

Output:
Sum = 15
Difference = 5
Product = 50

🧠 Example 5: Function Calling Another Function (Nested)

def square(n):
    return n * n

def cube(n):
    return n * square(n)

print("Square =", square(3))
print("Cube =", cube(3))
  

Output:
Square = 9
Cube = 27

🧮 Example 6: Function Returning Boolean Value

def is_even(num):
    return num % 2 == 0

n = int(input("Enter a number: "))
if is_even(n):
    print("Even Number")
else:
    print("Odd Number")
  

Output:
Enter a number: 8
Even Number

⚙️ Example 7: Function without Return (None)

def display():
    print("This function has no return value.")

result = display()
print("Returned Value:", result)
  

Output:
This function has no return value.
Returned Value: None

📈 Example 8: Function Using Expression in Return

def average(a, b, c):
    return (a + b + c) / 3

print("Average =", average(10, 20, 30))
  

Output:
Average = 20.0

🔢 Example 9: Recursive Return Example (Factorial)

Function खुद को call करे तो उसे recursive function कहते हैं।

def factorial(n):
    if n == 0 or n == 1:
        return 1
    else:
        return n * factorial(n - 1)

print("Factorial =", factorial(5))
  

Output:
Factorial = 120

📘 Key Points

• 🔹 Function को define करने के लिए def keyword का use होता है।
• 🔹 Function को call करने के लिए उसका नाम और parentheses लगाना जरूरी है।
• 🔹 return statement optional है — अगर use नहीं करते तो function None return करता है।
• 🔹 Multiple values return करने के लिए tuple का इस्तेमाल होता है।

💬 Interview FAQs

• Q: What is a function?
  A: A reusable block of code that performs a specific task.
• Q: What is the purpose of the return statement?
  A: It sends a value back to the caller and ends the function execution.
• Q: Can a function return multiple values?
  A: Yes, it can return multiple values as a tuple.
• Q: What happens if no return statement is used?
  A: The function returns None by default.
• Q: What is a recursive function?
  A: A function that calls itself directly or indirectly.

📘 Introduction

Python में variables data को store करने के लिए use किए जाते हैं। जब variables functions के अंदर या बाहर define किए जाते हैं, तो उनकी scope और lifetime अलग-अलग होती है। इस concept को समझना programs में data handling के लिए बहुत जरूरी है।

🧩 Parameters in Functions

Function के अंदर values pass करने के लिए parameters या arguments का उपयोग किया जाता है। ये temporary variables होते हैं जो function के अंदर काम करते हैं।

📥 Example 1: Using Parameters

def greet(name):
    print("Hello,", name)

greet("Rahul")
greet("Aisha")
  

Output:
Hello, Rahul
Hello, Aisha

⚙️ Explanation:

• name एक parameter है।
• Function call के समय value pass करने पर उसे argument कहते हैं।

📌 Types of Parameters

• ✅ Positional Parameters
• ✅ Default Parameters
• ✅ Keyword Parameters
• ✅ Variable-length Parameters (VarArgs)

📘 Example 2: Positional Parameters

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

add(10, 20)
  

Output:
Sum = 30

📘 Example 3: Default Parameters

def greet(name="Guest"):
    print("Welcome,", name)

greet("Anita")
greet()
  

Output:
Welcome, Anita
Welcome, Guest

📘 Example 4: Keyword Parameters

def student_info(name, age):
    print("Name:", name)
    print("Age:", age)

student_info(age=18, name="Ravi")
  

Output:
Name: Ravi
Age: 18

📘 Example 5: Variable-Length Parameters (*args)

def show(*args):
    print("Arguments:", args)

show(10, 20, 30, 40)
  

Output:
Arguments: (10, 20, 30, 40)

🔹 Local Variables

Local variables वो होते हैं जो function के अंदर define किए जाते हैं और उनका scope केवल उसी function तक सीमित होता है।

💻 Example 6: Local Variable Example

def show():
    message = "Hello from inside function"
    print(message)

show()
# print(message)  # Error: message is not defined
  

Output:
Hello from inside function

⚙️ Explanation:

• message एक local variable है।
• Function के बाहर यह accessible नहीं है।

🌍 Global Variables

Global variables वो होते हैं जो function के बाहर define किए जाते हैं और पूरे program में accessible रहते हैं।

💻 Example 7: Global Variable Example

x = 10  # Global variable

def display():
    print("Inside function, x =", x)

display()
print("Outside function, x =", x)
  

Output:
Inside function, x = 10
Outside function, x = 10

🧠 Local vs Global with Same Name

अगर function के अंदर और बाहर एक ही नाम का variable define किया गया हो, तो function के अंदर local variable को प्राथमिकता दी जाती है।

💻 Example 8: Local Overrides Global

x = 100  # Global variable

def test():
    x = 50   # Local variable
    print("Inside function, x =", x)

test()
print("Outside function, x =", x)
  

Output:
Inside function, x = 50
Outside function, x = 100

🌐 Using global Keyword

अगर हमें function के अंदर global variable को modify करना है, तो global keyword का use किया जाता है।

💻 Example 9: Using global Keyword

count = 0

def increment():
    global count
    count += 1
    print("Inside function, count =", count)

increment()
increment()
print("Outside function, count =", count)
  

Output:
Inside function, count = 1
Inside function, count = 2
Outside function, count = 2

📘 Key Points

• 🔹 Local variables का scope function तक limited होता है।
• 🔹 Global variables पूरे program में accessible होते हैं।
• 🔹 Same name होने पर local variable global को override करता है।
• 🔹 global keyword का use करके function से global variable modify किया जा सकता है।

💬 Interview FAQs

• Q: What is the difference between parameter and argument?
  A: Parameter is defined in function definition, argument is passed during function call.
• Q: What is the scope of a local variable?
  A: It exists only inside the function where it is defined.
• Q: How do you access a global variable inside a function?
  A: Using the global keyword.
• Q: Can local and global variables have the same name?
  A: Yes, but the local variable will shadow the global one inside the function.
• Q: What is the default value of a variable in Python?
  A: Variables do not have a default value; they must be initialized before use.

📘 Introduction

Python में functions को values पास करने के कई तरीके होते हैं। उनमें से सबसे commonly used तरीके हैं — Default Parameters, Keyword Parameters, और Variable-Length (VarArgs) Parameters। ये features function को flexible और dynamic बनाते हैं।

🧩 1️⃣ Default Parameters

जब किसी parameter को function define करते समय ही value दी जाती है, तो उसे default parameter कहते हैं। अगर function call में argument नहीं दिया जाए, तो default value use होती है।

💻 Example 1: Using Default Parameters

def greet(name="Guest"):
    print("Hello,", name, "Welcome to Python!")

greet("Anita")
greet()
  

Output:
Hello, Anita Welcome to Python!
Hello, Guest Welcome to Python!

⚙️ Explanation:

• अगर argument दिया गया है — वह default को override करता है।
• अगर argument नहीं दिया गया — default value use होती है।

🧩 2️⃣ Keyword Parameters

Keyword arguments का use तब किया जाता है जब हम parameter को उसके नाम से value assign करते हैं। इससे function call में arguments का order important नहीं रहता।

💻 Example 2: Using Keyword Parameters

def student_info(name, age, course):
    print("Name:", name)
    print("Age:", age)
    print("Course:", course)

student_info(age=20, name="Rahul", course="Python Programming")
  

Output:
Name: Rahul
Age: 20
Course: Python Programming

⚙️ Explanation:

• Arguments को name से pass करने पर उनका order irrelevant हो जाता है।
• Keyword arguments readability को बढ़ाते हैं।

🧩 3️⃣ Variable-Length Parameters

जब हमें नहीं पता कि कितने arguments function को pass होंगे, तो हम *args या **kwargs का use करते हैं। ये parameters multiple values को handle करने की flexibility देते हैं।

💻 Example 3: Using *args (Non-Keyword Variable Arguments)

def add_numbers(*args):
    print("Received arguments:", args)
    total = sum(args)
    print("Sum =", total)

add_numbers(10, 20, 30)
add_numbers(5, 15, 25, 35)
  

Output:
Received arguments: (10, 20, 30)
Sum = 60

Received arguments: (5, 15, 25, 35)
Sum = 80

⚙️ Explanation:

• *args function में multiple positional arguments को tuple के रूप में store करता है।
• इनका use तब होता है जब arguments की संख्या fix नहीं होती।

💻 Example 4: Using **kwargs (Keyword Variable Arguments)

def display_info(**kwargs):
    print("Keyword arguments received:")
    for key, value in kwargs.items():
        print(key, "=", value)

display_info(name="Ravi", age=25, city="Delhi")
  

Output:
Keyword arguments received:
name = Ravi
age = 25
city = Delhi

⚙️ Explanation:

• **kwargs keyword arguments को dictionary के रूप में store करता है।
• इसका use तब होता है जब parameter names और values dynamic हों।

🧠 Example 5: Mixing Positional, Default, and Variable Arguments

def full_info(name, age=18, *skills, **details):
    print("Name:", name)
    print("Age:", age)
    print("Skills:", skills)
    print("Details:", details)

full_info("Aman", 22, "Python", "C++", city="Mumbai", college="IIT")
  

Output:
Name: Aman
Age: 22
Skills: ('Python', 'C++')
Details: {'city': 'Mumbai', 'college': 'IIT'}

🔢 Example 6: Default and Keyword Combined

def power(base, exponent=2):
    return base ** exponent

print("Square of 5 =", power(5))
print("Cube of 3 =", power(3, exponent=3))
  

Output:
Square of 5 = 25
Cube of 3 = 27

🧩 Example 7: Practical Program — Student Report Generator

def student_report(name, course="Python", *marks, **info):
    print("Student Name:", name)
    print("Course:", course)
    print("Marks:", marks)
    print("Other Info:", info)
    if marks:
        print("Average Marks =", sum(marks)/len(marks))

student_report("Neha", "Data Science", 85, 90, 80, city="Delhi", year=2025)
  

Output:
Student Name: Neha
Course: Data Science
Marks: (85, 90, 80)
Other Info: {'city': 'Delhi', 'year': 2025}
Average Marks = 85.0

📘 Key Points

• 🔹 Default parameters provide fallback values.
• 🔹 Keyword parameters allow passing arguments by name.
• 🔹 *args handles variable number of positional arguments.
• 🔹 **kwargs handles variable number of keyword arguments.
• 🔹 Argument order should be → Positional → Default → *args → **kwargs.

💬 Interview FAQs

• Q: What is the difference between *args and **kwargs?
  A: *args stores positional arguments as tuple; **kwargs stores keyword arguments as dictionary.
• Q: Can we use default and keyword parameters together?
  A: Yes, keyword parameters can override default values.
• Q: Why are *args and **kwargs useful?
  A: They make functions more flexible by allowing variable number of arguments.
• Q: What happens if we don’t provide a default parameter value?
  A: The function will raise an error if no argument is passed.
• Q: Can *args and **kwargs be used together?
  A: Yes, both can be used together but *args must appear before **kwargs.

📘 Introduction

Python में DocStrings और global statement दो बहुत महत्वपूर्ण concepts हैं। DocStrings का उपयोग documentation या function/class/module के explanation देने के लिए होता है, जबकि global statement का उपयोग function के अंदर global variable को modify करने के लिए किया जाता है।

📜 DocStrings (Documentation Strings)

DocString एक multi-line string होती है जो किसी function, class या module के शुरू में लिखी जाती है। इसका मुख्य उद्देश्य होता है — उस function या class के purpose और usage को explain करना। DocString को triple quotes (""" """ या ''' ''') में लिखा जाता है।

💡 Syntax:

def function_name(parameters):
    """This is a docstring."""
    statements
  

💻 Example 1: Simple Function DocString

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

print(add.__doc__)
  

Output:
This function adds two numbers and returns the result.

⚙️ Explanation:

• __doc__ attribute DocString को access करने के लिए use किया जाता है।
• यह function का documentation part return करता है।

💻 Example 2: Multi-line DocString

def factorial(n):
    """
    This function calculates the factorial of a number.
    Formula: n! = n × (n-1) × (n-2) × ... × 1
    Example: factorial(5) = 120
    """
    result = 1
    for i in range(1, n + 1):
        result *= i
    return result

print(factorial.__doc__)
  

Output:
This function calculates the factorial of a number.
Formula: n! = n × (n-1) × (n-2) × ... × 1
Example: factorial(5) = 120

💻 Example 3: DocString for Class

class Student:
    """This class stores student information."""
    def __init__(self, name, age):
        self.name = name
        self.age = age

print(Student.__doc__)
  

Output:
This class stores student information.

💡 Tip:

आप किसी भी object (function, class, module) की documentation देखने के लिए help() function का use कर सकते हैं।

help(add)
  

🌍 global Statement

Python में global statement का use तब किया जाता है जब हमें function के अंदर किसी global variable को modify या access करना हो। Normal variables function के अंदर local scope में आते हैं। लेकिन global keyword से हम outer variable को refer कर सकते हैं।

💻 Example 4: Without global Keyword (Local Variable)

count = 10

def increment():
    count = count + 1   # Error! local variable referenced before assignment
    print(count)

increment()
  

Output:
UnboundLocalError: local variable 'count' referenced before assignment

💻 Example 5: Using global Keyword

count = 10

def increment():
    global count
    count = count + 1
    print("Inside function:", count)

increment()
print("Outside function:", count)
  

Output:
Inside function: 11
Outside function: 11

⚙️ Explanation:

• जब global keyword use करते हैं, तो Python variable को outer/global scope में refer करता है।
• अब function के अंदर की change globally reflect होगी।

💻 Example 6: Multiple Global Variables

x, y = 5, 10

def modify():
    global x, y
    x = x + 2
    y = y * 3

modify()
print("x =", x)
print("y =", y)
  

Output:
x = 7
y = 30

💻 Example 7: global + local variable in same function

count = 100

def demo():
    global count
    count += 10
    local_var = 5
    print("Global count:", count)
    print("Local variable:", local_var)

demo()
  

Output:
Global count: 110
Local variable: 5

💻 Example 8: Function Without global (local shadow)

num = 20

def test():
    num = 50  # Local variable shadows global
    print("Inside:", num)

test()
print("Outside:", num)
  

Output:
Inside: 50
Outside: 20

📘 Key Points

• 🔹 DocStrings help in documenting code for better readability.
• 🔹 Use __doc__ or help() to read a function’s DocString.
• 🔹 global keyword allows modifying a global variable inside a function.
• 🔹 Without global, same-named variable inside a function is treated as local.

💬 Interview FAQs

• Q: What is a DocString in Python?
  A: A DocString is a string literal used for documenting a function, class, or module.
• Q: How can you access a function’s DocString?
  A: Using the attribute function_name.__doc__ or help(function_name).
• Q: What is the purpose of the global keyword?
  A: It allows a function to modify a variable defined in the global scope.
• Q: What happens if we don’t use the global keyword?
  A: The variable will be treated as local, and changes won’t affect the global variable.
• Q: Can a DocString be multi-line?
  A: Yes, triple quotes (""" """) are used for multi-line DocStrings.

📘 Introduction

Python में कई Built-in Functions पहले से मौजूद होते हैं जिनका उपयोग सीधे किया जा सकता है। ये functions हमें basic operations जैसे type conversion, mathematical calculation, string handling, input/output processing आदि में मदद करते हैं। हमें इन्हें define करने की जरूरत नहीं होती — ये हमेशा उपलब्ध रहते हैं।

🔹 What are Built-in Functions?

Built-in functions वो होते हैं जो Python interpreter के साथ पहले से defined होते हैं। इन्हें किसी भी module को import किए बिना use किया जा सकता है।

💡 Example:

print(len("Python"))
print(max(10, 25, 5))
print(abs(-8))
print(type(45))
  

Output:
6
25
8
<class 'int'>

📚 Common Categories of Built-in Functions

• 🔹 Mathematical Functions
• 🔹 Type Conversion Functions
• 🔹 Input/Output Functions
• 🔹 String Functions
• 🔹 Utility Functions

🧮 Mathematical Functions

Python के कुछ important math related built-in functions:

print(abs(-12))       # Absolute value
print(pow(3, 4))      # 3⁴ = 81
print(round(3.765, 2))# Round off to 2 decimals
print(min(10, 5, 20)) # Smallest number
print(max(10, 5, 20)) # Largest number
  

Output:
12
81
3.77
5
20

🔤 Type Conversion Functions

ये functions एक datatype को दूसरे में convert करते हैं। Python में commonly used type conversion functions हैं:

x = "25"
print(int(x))       # Convert string to integer
print(float(x))     # Convert to float
print(str(1234))    # Convert number to string
print(list("Python"))
print(tuple([1, 2, 3]))
  

Output:
25
25.0
1234
['P', 'y', 't', 'h', 'o', 'n']
(1, 2, 3)

💻 Input/Output Functions

name = input("Enter your name: ")
print("Hello,", name)
  

Output:
Enter your name: Aman
Hello, Aman

📊 Utility Functions

कुछ built-in utility functions everyday tasks simplify करते हैं:

data = [10, 20, 30, 40]

print(sum(data))       # Add all items
print(sorted(data))    # Sort the list
print(reversed(data))  # Returns iterator (use list())
print(all([True, 1, 5])) # True if all elements are True
print(any([0, False, 3])) # True if any one element is True
  

Output:
100
[10, 20, 30, 40]
<reversed object>
True
True

🧩 Example Program: Student Grade Evaluator

marks = [80, 75, 90, 85, 88]
average = sum(marks) / len(marks)

print("Average Marks =", round(average, 2))

if all(m > 33 for m in marks):
    print("Result: PASS")
else:
    print("Result: FAIL")
  

Output:
Average Marks = 83.6
Result: PASS

🧠 Advanced Examples

# Using eval() to evaluate string expression
expression = "10 + 20 * 3"
print("Result of expression:", eval(expression))

# Using isinstance() and id()
x = 50
print(isinstance(x, int))
print("Memory ID:", id(x))
  

Output:
Result of expression: 70
True
Memory ID: (some unique number)

📘 Commonly Used Built-in Functions Table

💬 Interview FAQs

• Q: What are built-in functions in Python?
  A: Predefined functions available for use without importing any module.
• Q: Give examples of mathematical built-in functions.
  A: abs(), round(), pow(), min(), max().
• Q: What is the use of eval()?
  A: It evaluates a string as a Python expression and returns the result.
• Q: How do you find the length of a list?
  A: Using len() function.
• Q: What is the purpose of isinstance()?
  A: It checks whether an object belongs to a specific type or not.

📘 Introduction

Python में Standard Library एक विशाल collection है pre-written modules का, जो हमें अलग-अलग tasks जैसे mathematics, random numbers, date-time handling, file operations, JSON processing, system control, statistics, आदि करने में मदद करते हैं। हमें इन्हें खुद से लिखने की जरूरत नहीं होती — बस import करके use किया जा सकता है।

📦 What is a Module?

Python module एक file होती है जिसमें related functions, classes, और variables defined होते हैं। इसे किसी दूसरे program में import करके use किया जा सकता है।

💡 Syntax:

import module_name
# OR
from module_name import function_name
  

📚 Commonly Used Standard Library Modules

• 🔹 math – Mathematical operations
• 🔹 random – Random number generation
• 🔹 datetime – Date and time handling
• 🔹 os – Operating system related operations
• 🔹 sys – System-level functions
• 🔹 statistics – Statistical calculations
• 🔹 json – Working with JSON data
• 🔹 time – Time-related operations
• 🔹 math – Trigonometric and power functions

🧮 1️⃣ math Module

यह module mathematical functions provide करता है जैसे sqrt, factorial, sin, cos आदि।

import math

print("Square root of 25:", math.sqrt(25))
print("Factorial of 5:", math.factorial(5))
print("Value of Pi:", math.pi)
print("Power (2^5):", math.pow(2, 5))
  

Output:
Square root of 25: 5.0
Factorial of 5: 120
Value of Pi: 3.141592653589793
Power (2^5): 32.0

🎲 2️⃣ random Module

यह module random number generation के लिए use होता है। इसका उपयोग game development, simulation और sampling में किया जाता है।

import random

print("Random number (1-10):", random.randint(1, 10))
print("Random choice:", random.choice(['Red', 'Green', 'Blue']))
print("Random float (0-1):", random.random())
  

Output:
Random number (1-10): 7
Random choice: Blue
Random float (0-1): 0.5648

🕒 3️⃣ datetime Module

यह module date और time से related functions provide करता है।

import datetime

now = datetime.datetime.now()
print("Current Date & Time:", now)
print("Year:", now.year)
print("Month:", now.month)
print("Date:", now.day)

# Creating custom date
d = datetime.date(2025, 11, 8)
print("Custom Date:", d)
  

Output:
Current Date & Time: 2025-11-08 14:22:10.123456
Year: 2025
Month: 11
Date: 8
Custom Date: 2025-11-08

💻 4️⃣ os Module

यह module operating system से interaction के लिए उपयोग होता है। इससे directories, files और environment variables को manage किया जा सकता है।

import os

print("Current Working Directory:", os.getcwd())
print("List of files:", os.listdir())
  

Output:
Current Working Directory: C:\Users\Admin\Desktop
List of files: ['program.py', 'data.txt', 'notes.docx']

🧠 5️⃣ sys Module

यह module system-level information और control के लिए उपयोग किया जाता है।

import sys

print("Python Version:", sys.version)
print("Executable Path:", sys.executable)
  

Output:
Python Version: 3.12.1 (main, Oct 2025, ...)
Executable Path: C:\Python312\python.exe

📊 6️⃣ statistics Module

यह module data analysis और average, median, mode जैसे calculations के लिए use होता है।

import statistics

data = [10, 20, 30, 40, 50]
print("Mean:", statistics.mean(data))
print("Median:", statistics.median(data))
print("Mode:", statistics.mode(data))
  

Output:
Mean: 30
Median: 30
Mode: 10

🔢 7️⃣ json Module

यह module JSON (JavaScript Object Notation) data को handle करने के लिए use होता है। JSON data web APIs और file storage में काफी common होता है।

import json

person = {"name": "Amit", "age": 25, "city": "Delhi"}
json_data = json.dumps(person)
print("JSON String:", json_data)

python_data = json.loads(json_data)
print("Converted back to Python:", python_data)
  

Output:
JSON String: {"name": "Amit", "age": 25, "city": "Delhi"}
Converted back to Python: {'name': 'Amit', 'age': 25, 'city': 'Delhi'}

⏰ 8️⃣ time Module

यह module time-related functions जैसे delays, sleep, और timestamps के लिए उपयोग किया जाता है।

import time

print("Start Time:", time.ctime())
time.sleep(2)  # Wait for 2 seconds
print("End Time:", time.ctime())
  

Output:
Start Time: Sat Nov 8 14:25:01 2025
End Time: Sat Nov 8 14:25:03 2025

📘 Key Points

• 🔹 Python की standard library 200+ modules provide करती है।
• 🔹 Modules को import करके use किया जाता है।
• 🔹 कुछ modules built-in हैं (math, sys, os), जबकि कुछ external हैं (numpy, pandas)।
• 🔹 import method से हम किसी specific function को भी import कर सकते हैं।

💬 Interview FAQs

• Q: What is a Python module?
  A: A module is a file that contains Python code (functions, classes, or variables).
• Q: What is the difference between a module and a package?
  A: A module is a single file; a package is a collection of modules in a directory with an __init__.py file.
• Q: How to import a specific function from a module?
  A: from math import sqrt imports only the sqrt function.
• Q: What is the purpose of json module?
  A: It is used to encode (serialize) and decode (deserialize) JSON data.
• Q: How to check available functions inside a module?
  A: Use the dir(module_name) command.

📘 Introduction

Python में modules को use करने के लिए हमें उन्हें import करना पड़ता है। Importing का मतलब है — किसी दूसरे file या library में लिखे गए code को अपने current program में लाना। इससे हम built-in या custom modules के functions, variables और classes को आसानी से use कर सकते हैं।

📦 Importing Modules

Python में modules import करने के कई तरीके हैं। चलिए step-by-step देखते हैं:

💡 1️⃣ Import the Whole Module

पूरे module को import करने के लिए import keyword का use किया जाता है।

import math

print("Square root of 16 =", math.sqrt(16))
print("Pi =", math.pi)
  

Output:
Square root of 16 = 4.0
Pi = 3.141592653589793

• यह पूरे math module को import करता है।
• Function call करने के लिए module का नाम prefix में लगाना जरूरी है।

💡 2️⃣ Import Specific Functions

अगर आपको module से सिर्फ एक या दो functions चाहिए, तो आप from ... import ... syntax का use कर सकते हैं।

from math import sqrt, factorial

print("Square Root:", sqrt(25))
print("Factorial:", factorial(5))
  

Output:
Square Root: 5.0
Factorial: 120

• अब functions को directly use किया जा सकता है।
• Prefix (जैसे math.) लगाने की जरूरत नहीं।

💡 3️⃣ Import All Functions from Module

आप * symbol से पूरे module के सारे functions import कर सकते हैं।

from math import *

print(sin(0))
print(cos(0))
print(pow(2, 5))
  

Output:
0.0
1.0
32.0

⚠️ Note:

यह तरीका convenient तो है, लेकिन large projects में avoid करना चाहिए क्योंकि इससे variable/function name conflicts हो सकते हैं।

👤 Using Aliases

Python में हम किसी module या function को छोटा नाम (nickname) देने के लिए as keyword का use कर सकते हैं। इसे aliasing कहते हैं।

💻 Example 1: Module Alias

import math as m

print("Square Root:", m.sqrt(81))
print("Value of Pi:", m.pi)
  

Output:
Square Root: 9.0
Value of Pi: 3.141592653589793

💻 Example 2: Function Alias

from math import factorial as fact

print("Factorial of 6 =", fact(6))
  

Output:
Factorial of 6 = 720

📦 Importing Custom Modules

हम अपने खुद के Python files को भी module की तरह import कर सकते हैं। Example — अगर आपके पास mymath.py file है जिसमें function लिखा है:

# File: mymath.py
def square(n):
    return n * n
  

अब आप इसे दूसरे file में import कर सकते हैं:

import mymath

print("Square of 5 =", mymath.square(5))
  

Output:
Square of 5 = 25

💡 Explanation:

• mymath user-defined module है।
• Import करने से उस file के सारे functions available हो जाते हैं।

🧠 Example 3: Combining Multiple Imports

import math, random

print("Random number:", random.randint(1, 10))
print("Square root:", math.sqrt(36))
  

Output:
Random number: 4
Square root: 6.0

🔢 Example 4: Module with Aliases and Specific Functions

from math import sqrt as s, pow as p

print("Square Root:", s(49))
print("Power:", p(2, 4))
  

Output:
Square Root: 7.0
Power: 16.0

📘 Key Points

• 🔹 import keyword से module को import किया जाता है।
• 🔹 from ... import ... से specific functions import किए जा सकते हैं।
• 🔹 as keyword alias बनाने के लिए use किया जाता है।
• 🔹 एक program में multiple modules import किए जा सकते हैं।
• 🔹 Avoid using from module import * in large projects.

💬 Interview FAQs

• Q: What is a Python module?
  A: A file that contains Python definitions, functions, or classes which can be reused by importing.
• Q: What is the use of as keyword?
  A: It is used to assign an alias (short name) to a module or function.
• Q: How do you import only a specific function from a module?
  A: Using from module import function.
• Q: What is the advantage of using alias?
  A: It makes code shorter and cleaner, especially for long module names.
• Q: How can you import multiple modules in one line?
  A: import math, random, os

📘 Introduction

Python में Numeric Functions का उपयोग numbers पर mathematical calculations करने के लिए किया जाता है। ये functions built-in होते हैं और integers, floats, complex numbers आदि पर operate करते हैं। कुछ functions basic हैं (जैसे abs(), round()) और कुछ advanced होते हैं जो math module में defined हैं (जैसे sqrt(), pow(), factorial())।

📗 Types of Numeric Functions

• 🔹 Basic Numeric Functions (built-in)
• 🔹 Mathematical Functions (from math module)
• 🔹 Rounding & Absolute Functions

🔹 1️⃣ Basic Built-in Numeric Functions

💻 Example 1: abs(), pow(), divmod()

x = -15
y = 5

print("Absolute value of x:", abs(x))
print("Power (y³):", pow(y, 3))
print("Divmod (y divides x):", divmod(20, 3))
  

Output:
Absolute value of x: 15
Power (y³): 125
Divmod (y divides x): (6, 2)

⚙️ Explanation:

• abs(x) → Returns absolute (positive) value of x.
• pow(a, b) → Returns a raised to the power of b (same as a ** b).
• divmod(a, b) → Returns tuple (quotient, remainder).

🔹 2️⃣ Math Module Functions

Advanced numeric functions math module में available हैं। इसका उपयोग scientific और trigonometric operations के लिए किया जाता है।

import math

print("Square Root:", math.sqrt(49))
print("Factorial:", math.factorial(6))
print("Power:", math.pow(2, 4))
print("Ceil:", math.ceil(3.4))
print("Floor:", math.floor(3.9))
  

Output:
Square Root: 7.0
Factorial: 720
Power: 16.0
Ceil: 4
Floor: 3

⚙️ Explanation:

• math.sqrt(x) → Returns square root of x.
• math.factorial(x) → Returns factorial (x!).
• math.ceil(x) → Rounds number upward to nearest integer.
• math.floor(x) → Rounds number downward to nearest integer.

🔹 3️⃣ Trigonometric & Logarithmic Functions

Python का math module trigonometric (sin, cos, tan) और logarithmic functions भी provide करता है।

import math

angle = math.radians(30)  # Convert degrees to radians
print("sin(30):", math.sin(angle))
print("cos(30):", math.cos(angle))
print("tan(30):", math.tan(angle))

print("Log (base e):", math.log(10))
print("Log (base 10):", math.log10(100))
  

Output:
sin(30): 0.49999999999999994
cos(30): 0.8660254037844387
tan(30): 0.5773502691896257
Log (base e): 2.302585092994046
Log (base 10): 2.0

⚙️ Explanation:

• math.radians(x) → Converts degrees to radians.
• math.sin(), math.cos(), math.tan() → Return trigonometric values.
• math.log(x) → Natural logarithm (base e).
• math.log10(x) → Logarithm base 10.

🔹 4️⃣ Rounding Functions

Numbers को round करने के लिए Python में round(), math.ceil(), और math.floor() functions available हैं।

import math

x = 12.5678
print("Round (2 decimals):", round(x, 2))
print("Ceil:", math.ceil(x))
print("Floor:", math.floor(x))
  

Output:
Round (2 decimals): 12.57
Ceil: 13
Floor: 12

🧩 5️⃣ Constants in math Module

Python के math module में कुछ predefined constants भी होते हैं:

import math

print("Pi:", math.pi)
print("Euler’s Number (e):", math.e)
print("Tau:", math.tau)
  

Output:
Pi: 3.141592653589793
Euler’s Number (e): 2.718281828459045
Tau: 6.283185307179586

🧮 Example Program: Area of Circle

import math

r = float(input("Enter radius: "))
area = math.pi * math.pow(r, 2)
print("Area of Circle =", round(area, 2))
  

Output:
Enter radius: 5
Area of Circle = 78.54

📘 Common Numeric Functions Summary

💬 Interview FAQs

• Q: What is the difference between pow() and math.pow()?
  A: pow() is built-in and supports integers; math.pow() returns float value always.
• Q: What is the output of round(3.756, 1)?
  A: 3.8
• Q: Which function returns both quotient and remainder?
  A: divmod(a, b)
• Q: How can you calculate area of a circle in Python?
  A: area = math.pi * r ** 2
• Q: What are math constants in Python?
  A: math.pi, math.e, and math.tau.

📘 Introduction

Python में date और time को manage करने के लिए datetime module का उपयोग किया जाता है। यह module हमें date, time, timedelta (time differences), और formatting operations perform करने की सुविधा देता है। Real-world programs जैसे attendance system, billing system, logging, या event scheduler में date-time functions बहुत उपयोगी होते हैं।

🕒 Importing datetime Module

import datetime
  

यह Python के built-in datetime module को import करता है जो date और time classes provide करता है।

📅 1️⃣ Get Current Date and Time

import datetime

current = datetime.datetime.now()
print("Current Date & Time:", current)

print("Year:", current.year)
print("Month:", current.month)
print("Day:", current.day)
print("Hour:", current.hour)
print("Minute:", current.minute)
print("Second:", current.second)
  

Output:
Current Date & Time: 2025-11-08 16:32:21.451789
Year: 2025
Month: 11
Day: 8
Hour: 16
Minute: 32
Second: 21

📆 2️⃣ Get Current Date Only

from datetime import date

today = date.today()
print("Today's Date:", today)
print("Year:", today.year)
print("Month:", today.month)
print("Day:", today.day)
  

Output:
Today's Date: 2025-11-08
Year: 2025
Month: 11
Day: 8

🧮 3️⃣ Create a Specific Date or Time

import datetime

d = datetime.date(2025, 12, 25)
t = datetime.time(10, 30, 0)

print("Custom Date:", d)
print("Custom Time:", t)
  

Output:
Custom Date: 2025-12-25
Custom Time: 10:30:00

• datetime.date(year, month, day) → Date object बनाता है।
• datetime.time(hour, minute, second) → Time object बनाता है।

📅 4️⃣ Formatting Dates and Times (strftime)

Python में हम strftime() method का use करके date-time को formatted string में बदल सकते हैं।

import datetime

now = datetime.datetime.now()
print("Default format:", now)

formatted = now.strftime("%d-%m-%Y %I:%M:%S %p")
print("Formatted Date & Time:", formatted)
  

Output:
Default format: 2025-11-08 16:45:18.872134
Formatted Date & Time: 08-11-2025 04:45:18 PM

🧠 Common Format Codes:

⏰ 5️⃣ Calculating Date and Time Differences

Python में timedelta class का उपयोग दो dates या times के बीच difference निकालने के लिए किया जाता है।

from datetime import date

d1 = date(2025, 11, 8)
d2 = date(2026, 1, 1)

delta = d2 - d1
print("Days between:", delta.days)
  

Output:
Days between: 54

⚙️ Explanation:

• date1 - date2 का result एक timedelta object होता है।
• timedelta.days से हम difference in days निकाल सकते हैं।

⏳ 6️⃣ Adding or Subtracting Time

timedelta का use future या past date calculate करने के लिए भी किया जा सकता है।

from datetime import date, timedelta

today = date.today()
future = today + timedelta(days=10)
past = today - timedelta(days=10)

print("Today:", today)
print("10 days after:", future)
print("10 days before:", past)
  

Output:
Today: 2025-11-08
10 days after: 2025-11-18
10 days before: 2025-10-29

⌛ 7️⃣ Working with time Module

Python में time module low-level time functions provide करता है, जैसे sleep(), ctime(), और time() (timestamp)।

import time

print("Current Time:", time.ctime())
print("Timestamp:", time.time())

print("Waiting for 2 seconds...")
time.sleep(2)
print("Done!")
  

Output:
Current Time: Sat Nov 8 16:50:00 2025
Timestamp: 1731084600.578
Waiting for 2 seconds...
Done!

• time.ctime() → Current time as string
• time.time() → Returns timestamp (seconds since Jan 1, 1970)
• time.sleep(n) → Pauses program for n seconds

🧩 Example Program: Calculate Age

from datetime import date

birth_year = int(input("Enter your birth year: "))
current_year = date.today().year
age = current_year - birth_year
print("You are", age, "years old.")
  

Output:
Enter your birth year: 2000
You are 25 years old.

💬 Interview FAQs

• Q: Which module is used to work with date and time in Python?
  A: datetime module.
• Q: How to get today’s date?
  A: date.today()
• Q: What is the use of strftime()?
  A: It is used to format date/time into human-readable string format.
• Q: What is the use of timedelta()?
  A: It is used to represent difference or duration between two dates or times.
• Q: How to make program wait for few seconds?
  A: Using time.sleep(seconds).