Python Basics

Variables are the building blocks of any program. They store data that your program can use and manipulate. Let's master Python's variable system and core data types.

What is a Variable?

Imagine you're organizing a warehouse. You have boxes, and each box has a label so you know what's inside. In programming, variables work exactly the same way. They're labeled containers that hold data.

In Python, creating a variable is simple. You just assign a value using the = operator:

# Creating variables
name = "Priya"           # A string variable
age = 25                 # An integer variable
height = 5.7             # A float variable
is_student = True        # A boolean variable

# Python figures out the type automatically!
print(name)              # Output: Priya
print(age)               # Output: 25

Variable Naming Rules & Conventions

# Python naming conventions (PEP 8)
user_name = "priya"           # snake_case for variables
MAX_CONNECTIONS = 100         # UPPER_CASE for constants
_internal_value = 42          # Leading underscore = "private"
__name__ = "special"          # Dunder = Python special methods

# Reserved keywords (35 total in Python 3.11)
# False, None, True, and, as, assert, async, await,
# break, class, continue, def, del, elif, else, except,
# finally, for, from, global, if, import, in, is, lambda,
# nonlocal, not, or, pass, raise, return, try, while, with, yield

Core Data Types

In the real world, we deal with different types of information: numbers, text, yes/no answers, etc. Programming languages also need to distinguish between these different types of data. In Python, we call these data types.

Why does it matter? Different data types have different behaviors. For example, you can add two numbers together (5 + 3 = 8), but "adding" two pieces of text joins them together ("Hello" + "World" = "HelloWorld"). Understanding data types helps you write correct code.

Let's explore each one in detail:

age = 25
year = 2025
negative = -100
print(type(age))  # 

big_number = 1_000_000_000
print(big_number)  # 1000000000

binary = 0b1010        # Binary (base 2) = 10
octal = 0o17           # Octal (base 8) = 15  
hexadecimal = 0xFF     # Hex (base 16) = 255

huge = 10 ** 100  # 1 followed by 100 zeros
print(huge)       # Works perfectly!

price = 19.99
temperature = -40.5
pi = 3.14159265359
print(type(price))  # 

avogadro = 6.022e23  # 6.022 × 10²³
tiny = 1.6e-19       # 1.6 × 10⁻¹⁹

result = 0.1 + 0.2
print(result)         # 0.30000000000000004 (not 0.3!)
print(result == 0.3)  # False!

import math
print(round(result, 1))           # 0.3
print(math.isclose(result, 0.3))  # True

name = 'Alice'
greeting = "Hello, World!"
multiline = """This spans
multiple lines."""

tab = "Col1\tCol2"        # \t = tab
newline = "Line1\nLine2"  # \n = newline
path = "C:\\Users\\Data"  # \\ = backslash

raw_path = r"C:\Users\Data"
print(raw_path)  # C:\Users\Data

text = "Python"
print(text[0])     # 'P' (first character)
print(text[-1])    # 'n' (last character)
print(text[0:3])   # 'Pyt' (slice)
print(text[::-1])  # 'nohtyP' (reverse)

name = "Priya"
age = 25
message = f"My name is {name} and I'm {age} years old."
print(message)  # My name is Priya and I'm 25 years old.

print(f"Next year I'll be {age + 1}")  # Next year I'll be 26

price = 1234.5678
print(f"Price: ${price:.2f}")      # Price: $1234.57 (2 decimals)
print(f"Price: ${price:,.2f}")     # Price: $1,234.57 (with commas)
print(f"Percentage: {0.856:.1%}")  # Percentage: 85.6%

print(f"{'left':<10}|")    # left      | (left align)
print(f"{'right':>10}|")   #      right| (right align)
print(f"{'center':^10}|")  #  center   | (center)

is_active = True
is_admin = False
print(type(is_active))  # 

print(5 > 3)           # True
print(10 == 20)        # False
print("a" in "apple")  # True

# Truthy values
print(bool(1))          # True (non-zero number)
print(bool("hello"))    # True (non-empty string)
print(bool([1, 2, 3]))  # True (non-empty list)

# Falsy values
print(bool(0))    # False
print(bool(""))   # False (empty string)
print(bool([]))   # False (empty list)
print(bool(None)) # False

name = ""
if name:
    print(f"Hello, {name}")
else:
    print("Name is empty!")  # This runs

# None represents "no value" or "nothing"
result = None
print(result)                 # None
print(type(result))           # 

# Common use cases for None
def find_user(user_id):
    """Returns user if found, None otherwise"""
    users = {1: "Priya", 2: "Rahul"}
    return users.get(user_id)  # Returns None if not found

user = find_user(999)
if user is None:              # Use 'is' to check for None, not ==
    print("User not found!")

# Functions without return statement return None
def greet(name):
    print(f"Hello, {name}!")
    # No return statement

result = greet("Priya")       # Prints: Hello, Priya!
print(result)                 # None

# Default parameter values
def connect(host, port=None):
    if port is None:
        port = 8080           # Use default if not provided
    print(f"Connecting to {host}:{port}")

Checking & Converting Types

Python provides built-in functions to check and convert between types.

Checking types with type() and isinstance():

# Checking types with type() and isinstance()
x = 42
print(type(x))                # 
print(type(x) == int)         # True
print(isinstance(x, int))     # True (preferred method)

# isinstance() can check multiple types
value = 3.14
print(isinstance(value, (int, float)))  # True (is int OR float)

Type conversion (casting) - converting between types:

# String to number
age_str = "25"
age_int = int(age_str)        # 25 (integer)
price_float = float("19.99")  # 19.99 (float)

# Number to string
num = 42
num_str = str(num)            # "42" (string)

Boolean conversion to numbers:

# Boolean conversion
print(int(True))              # 1
print(int(False))             # 0
print(float(True))            # 1.0

Warning: Invalid conversions raise errors:

# WARNING: Invalid conversions raise errors
# int("hello")                # ValueError: invalid literal
# int("3.14")                 # ValueError: can't convert float string to int
# float("abc")                # ValueError: could not convert string to float

Safe conversion using try/except:

# Safe conversion with try/except
def safe_int(value):
    try:
        return int(value)
    except ValueError:
        return None

print(safe_int("42"))         # 42
print(safe_int("hello"))      # None

Quick Reference: Python Data Types

celsius = 37.5

celsius = 37.5
fahrenheit = (celsius * 9/5) + 32
print(fahrenheit)  # 99.5

price_str = "49.99"
quantity_str = "3"

price_str = "49.99"
quantity_str = "3"

price = float(price_str)
quantity = int(quantity_str)
total = price * quantity

print(total)  # 149.97

weight_kg = 68.5
height_m = 1.75

weight_kg = 68.5
height_m = 1.75

bmi = weight_kg / (height_m ** 2)
print(f"BMI: {bmi:.2f}")  # BMI: 22.37

a = 10
b = 25

a = 10
b = 25

a, b = b, a  # Python's tuple unpacking

print(a)  # 25
print(b)  # 10

amount = 1234567.891

amount = 1234567.891
formatted = f"${amount:,.2f}"
print(formatted)  # $1,234,567.89

Operators are symbols that perform operations on values and variables. Python has arithmetic, comparison, logical, assignment, and special operators. Let's master them all!

Arithmetic Operators

These operators perform mathematical calculations, the same math you learned in school. Python supports all standard math operations plus some extras like floor division and exponentiation that are especially useful in data science.

# Arithmetic operators in action
a, b = 17, 5

print(f"Addition: {a} + {b} = {a + b}")           # 22
print(f"Subtraction: {a} - {b} = {a - b}")        # 12
print(f"Multiplication: {a} * {b} = {a * b}")     # 85
print(f"Division: {a} / {b} = {a / b}")           # 3.4 (always float!)
print(f"Floor Division: {a} // {b} = {a // b}")   # 3 (rounded down)
print(f"Modulo: {a} % {b} = {a % b}")             # 2 (remainder)
print(f"Power: {a} ** 2 = {a ** 2}")              # 289

Common use cases for arithmetic operators:

# Check if number is even or odd
num = 42
is_even = num % 2 == 0        # True (no remainder when divided by 2)

# Get digits of a number
number = 12345
last_digit = number % 10      # 5
remove_last = number // 10    # 1234

Calculating percentages and roots:

# Calculate percentage
part = 75
whole = 200
percentage = (part / whole) * 100  # 37.5%

# Square root using exponent
sqrt_16 = 16 ** 0.5           # 4.0
cube_root = 27 ** (1/3)       # 3.0

Comparison Operators

Comparison operators compare values and return a boolean (True or False). They're essential for conditions and filtering data.

# Comparison operators
x, y = 10, 20

print(x == y)                 # False
print(x != y)                 # True
print(x > y)                  # False
print(x < y)                  # True
print(x >= 10)                # True
print(y <= 15)                # False

Chained comparisons are one of Python's superpowers:

# Chained comparisons (Python's superpower!)
age = 25
print(18 <= age <= 65)        # True (is age between 18 and 65?)
# Same as: age >= 18 and age <= 65

score = 85
print(80 <= score < 90)       # True (B grade range)

String comparisons work lexicographically (alphabetically):

# String comparisons (lexicographic/alphabetical)
print("apple" < "banana")     # True (a comes before b)
print("Apple" < "apple")      # True (uppercase < lowercase in ASCII)
print("10" < "9")             # True (string comparison, not numeric!)

# NOTE: Be careful with types!
print(10 == "10")             # False (int vs string)
print(10 == 10.0)             # True (int and float can be equal)

Logical Operators

Logical operators combine boolean expressions. They're the building blocks of complex conditions.

# Logical operators
age = 25
has_license = True
is_insured = False

# and - both conditions must be True
can_drive = age >= 18 and has_license
print(can_drive)              # True

# or - at least one condition must be True
needs_attention = not has_license or not is_insured
print(needs_attention)        # True (not insured)

# not - inverts the boolean
print(not True)               # False
print(not False)              # True

Combine operators for complex conditions:

# Complex conditions
income = 50000
credit_score = 720
has_job = True

# Can get a loan if: (good credit AND has job) OR (high income)
can_get_loan = (credit_score >= 700 and has_job) or income > 100000
print(can_get_loan)           # True

Short-circuit evaluation: Python stops evaluating as soon as the result is determined:

# Short-circuit evaluation
x = 5
# In "False and ...", the second part is never evaluated
result = False and (x / 0)    # No ZeroDivisionError!

# In "True or ...", the second part is never evaluated  
result = True or (x / 0)      # No ZeroDivisionError!

# Practical use: safe access
user = None
# Only access .name if user is not None
name = user and user.name     # Returns None (doesn't crash)

Assignment Operators

Assignment operators assign values to variables. Python has shorthand operators that combine assignment with arithmetic.

# Assignment operators
score = 100

score += 10        # score = 110
score -= 5         # score = 105
score *= 2         # score = 210
score //= 3        # score = 70

print(score)       # 70

# Multiple assignment
a = b = c = 0      # All set to 0

# Unpacking assignment
x, y, z = 1, 2, 3  # x=1, y=2, z=3

# Swap values (Python magic!)
a, b = 10, 20
a, b = b, a        # Now a=20, b=10 (no temp variable needed!)

# Extended unpacking (Python 3+)
first, *rest = [1, 2, 3, 4, 5]
print(first)       # 1
print(rest)        # [2, 3, 4, 5]

head, *middle, tail = [1, 2, 3, 4, 5]
print(head)        # 1
print(middle)      # [2, 3, 4]
print(tail)        # 5

Identity & Membership Operators

These special operators check object identity and membership in sequences.

# Identity operators
a = [1, 2, 3]
b = [1, 2, 3]
c = a

# == checks value equality
print(a == b)       # True (same values)

# is checks identity (same object)
print(a is b)       # False (different objects)
print(a is c)       # True (same object)

# Use 'is' for None, True, False
x = None
print(x is None)    # True (correct way)
print(x == None)    # True (works but not recommended)

# Membership operators
fruits = ["apple", "banana", "cherry"]

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

# Works with strings
text = "Hello, World!"
print("World" in text)         # True
print("world" in text)         # False (case-sensitive)

# Works with dictionaries (checks keys)
person = {"name": "Priya", "age": 25}
print("name" in person)        # True (key exists)
print("Priya" in person)       # False (checks keys, not values)

total_minutes = 185

total_minutes = 185
hours = total_minutes // 60
remaining_minutes = total_minutes % 60
print(f"{hours} hours and {remaining_minutes} minutes")  # 3 hours and 5 minutes

number = 47

number = 47
is_odd = number % 2 != 0
print(is_odd)  # True

score = 85
min_pass = 60
max_score = 100

score = 85
min_pass = 60
max_score = 100

# Method 1: Using chained comparison (Python special)
in_range = min_pass <= score <= max_score
print(in_range)  # True

# Method 2: Using logical and
in_range_v2 = score >= min_pass and score <= max_score
print(in_range_v2)  # True

base_price = 120.00
discount_percent = 15
tax_percent = 8

base_price = 120.00
discount_percent = 15
tax_percent = 8

discounted = base_price * (1 - discount_percent / 100)
final = discounted * (1 + tax_percent / 100)
print(round(final, 2))  # 110.16

a = 12  # binary: 1100
b = 10  # binary: 1010

a = 12  # binary: 1100
b = 10  # binary: 1010

# AND: bits that are 1 in BOTH
print(a & b)  # 8 (binary: 1000)

# OR: bits that are 1 in EITHER
print(a | b)  # 14 (binary: 1110)

# XOR: bits that are different
print(a ^ b)  # 6 (binary: 0110)

Control flow determines the order in which code executes. With conditional statements and loops, you can make decisions and repeat actions. This is the foundation of all programming logic.

Conditional Statements: if, elif, else

Conditional statements let your program make decisions based on conditions. Think of them like a flowchart: "Is this true? If yes, go this way. If no, go that way." Python uses if, elif (short for "else if"), and else.

The condition after if must evaluate to either True or False. If True, the indented code block runs. If False, Python skips to the next elif or else.

# Basic if statement
age = 20

if age >= 18:
    print("You are an adult")
    print("You can vote!")
# Output: You are an adult
#         You can vote!

# if-else statement
temperature = 15

if temperature >= 25:
    print("It's warm outside")
else:
    print("It's cold outside")
# Output: It's cold outside

# if-elif-else chain (multiple conditions)
score = 85

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

print(f"Your grade is: {grade}")  # Your grade is: B

Nested & Combined Conditions

You can place if statements inside other if statements. This is called nesting:

# Nested if statements
age = 25
has_ticket = True

if age >= 18:
    if has_ticket:
        print("Welcome to the movie!")
    else:
        print("Please buy a ticket first")
else:
    print("Sorry, this movie is for adults only")

Better approach: Use logical operators (and, or) to combine conditions instead of deep nesting:

# Better: combined with logical operators
if age >= 18 and has_ticket:
    print("Welcome to the movie!")
elif age >= 18:
    print("Please buy a ticket first")
else:
    print("Sorry, this movie is for adults only")

Complex conditions: Use parentheses for clarity when mixing and and or:

# Complex condition example
income = 60000
credit_score = 750
has_collateral = True

if (income >= 50000 and credit_score >= 700) or has_collateral:
    print("Loan approved!")
else:
    print("Loan denied")

Ternary Operator (Conditional Expression)

Python's ternary operator lets you write simple if-else in one line:

# Ternary operator syntax: value_if_true if condition else value_if_false

age = 20
status = "adult" if age >= 18 else "minor"
print(status)  # adult

Compare this to the traditional multi-line approach:

# Traditional way (3 lines):
if age >= 18:
    status = "adult"
else:
    status = "minor"

More ternary examples - great for simple conditions:

# More examples
x = 10
result = "positive" if x > 0 else "non-positive"

# Great for default values
user_name = input_name if input_name else "Anonymous"

For Loops

for loops iterate over sequences (lists, strings, ranges, etc.). They're the most common loop type in Python, especially for data processing. The basic idea: "for each item in this collection, do something."

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

You can also loop through strings character by character:

# Iterating over a string (character by character)
for char in "Python":
    print(char, end=" ")
# Output: P y t h o n

The range() function generates numeric sequences:

# Using range() for numeric sequences
# range(stop) generates numbers from 0 to stop-1
for i in range(5):           # 0, 1, 2, 3, 4
    print(i, end=" ")
# Output: 0 1 2 3 4

Use range(start, stop, step) for more control:

# range(start, stop, step) - more control
for i in range(1, 10, 2):    # 1, 3, 5, 7, 9 (start at 1, go up to 10, step by 2)
    print(i, end=" ")
# Output: 1 3 5 7 9

# Counting backwards
for i in range(10, 0, -1):   # 10, 9, 8, ... 1
    print(i, end=" ")
# Output: 10 9 8 7 6 5 4 3 2 1

enumerate() and zip()

These built-in functions make loops more powerful and Pythonic.

enumerate() gives you both the index and value:

# enumerate() - get index AND value
fruits = ["apple", "banana", "cherry"]

# Without enumerate (not recommended)
for i in range(len(fruits)):
    print(f"{i}: {fruits[i]}")

# With enumerate (Pythonic!)
for index, fruit in enumerate(fruits):
    print(f"{index}: {fruit}")
# Output: 0: apple
#         1: banana
#         2: cherry

You can start the index from any number:

# Start index from 1
for index, fruit in enumerate(fruits, start=1):
    print(f"{index}. {fruit}")
# Output: 1. apple
#         2. banana
#         3. cherry

zip() iterates over multiple sequences together:

# zip() - iterate over multiple sequences together
names = ["Priya", "Rahul", "Ankit"]
ages = [25, 30, 35]
cities = ["Mumbai", "Delhi", "Bangalore"]

for name, age, city in zip(names, ages, cities):
    print(f"{name} is {age} years old and lives in {city}")
# Output: Priya is 25 years old and lives in Mumbai
#         Rahul is 30 years old and lives in Delhi
#         Ankit is 35 years old and lives in Bangalore

Combine enumerate() and zip() for even more control:

# Combine enumerate and zip
for i, (name, age) in enumerate(zip(names, ages)):
    print(f"{i}: {name} - {age}")

While Loops

while loops repeat as long as a condition is True. Be careful: if the condition never becomes False, you'll create an infinite loop!

# Basic while loop
count = 0
while count < 5:
    print(count)
    count += 1      # Don't forget to update the condition!
# Output: 0 1 2 3 4

While loop with user input:

# While loop with user input
password = ""
while password != "secret123":
    password = input("Enter password: ")
print("Access granted!")

Infinite loop with break: Use while True with a break condition:

# Infinite loop with break
while True:
    user_input = input("Type 'quit' to exit: ")
    if user_input.lower() == "quit":
        break
    print(f"You typed: {user_input}")

Common pattern: Read data until a sentinel value:

# Common pattern: read until end of data
data = []
while True:
    value = input("Enter value (or 'done'): ")
    if value == "done":
        break
    data.append(value)
print(f"Collected: {data}")

Loop Control: break, continue, pass

# Find first even number
for num in [1, 3, 5, 4, 7]:
    if num % 2 == 0:
        print(f"Found: {num}")
        break
# Output: Found: 4

# Skip negative numbers
for num in [1, -2, 3, -4, 5]:
    if num < 0:
        continue
    print(num)
# Output: 1 3 5

# Placeholder for future logic
for item in items:
    if condition:
        pass  # TODO: implement
    else:
        process(item)

# Practical example: processing data with break and continue
scores = [85, 92, -1, 78, 95, 88]  # -1 indicates end of valid data

valid_scores = []
for score in scores:
    # Skip invalid scores
    if score < 0:
        break  # Stop processing when we hit -1
    
    # Skip scores below threshold
    if score < 80:
        continue
    
    valid_scores.append(score)

print(f"Valid high scores: {valid_scores}")  # [85, 92]

The else Clause with Loops

Python has a unique feature: loops can have an else clause that runs only if the loop completes without hitting break.

# else runs if loop completes normally (no break)
for num in [1, 3, 5, 7, 9]:
    if num % 2 == 0:
        print(f"Found even: {num}")
        break
else:
    print("No even numbers found!")
# Output: No even numbers found!

# Practical use: search with else
def find_user(users, target_id):
    for user in users:
        if user["id"] == target_id:
            print(f"Found: {user['name']}")
            break
    else:
        print("User not found!")

users = [{"id": 1, "name": "Priya"}, {"id": 2, "name": "Rahul"}]
find_user(users, 3)  # User not found!

List Comprehensions

List comprehensions are a concise, Pythonic way to create lists. They combine a loop and optional condition into a single line.

# Basic syntax: [expression for item in iterable]

# Traditional way
squares = []
for x in range(10):
    squares.append(x ** 2)

# List comprehension way (one line!)
squares = [x ** 2 for x in range(10)]
print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# With condition: [expression for item in iterable if condition]
evens = [x for x in range(20) if x % 2 == 0]
print(evens)    # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

# Transform and filter
names = ["Priya", "Rahul", "Ankit", "Vikram"]
long_names_upper = [name.upper() for name in names if len(name) > 4]
print(long_names_upper)  # ['PRIYA', 'ANKIT', 'VIKRAM']

# if-else in comprehension (note different position!)
numbers = [1, 2, 3, 4, 5]
labels = ["even" if n % 2 == 0 else "odd" for n in numbers]
print(labels)  # ['odd', 'even', 'odd', 'even', 'odd']

# Nested loops in comprehension
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat = [num for row in matrix for num in row]
print(flat)    # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Create a matrix
grid = [[i * j for j in range(1, 4)] for i in range(1, 4)]
print(grid)    # [[1, 2, 3], [2, 4, 6], [3, 6, 9]]

score = 78

score = 78

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

print(grade)  # C

total = 0
for num in range(1, 21):
    if num % 2 == 0:
        total += num

print(total)  # 110

# Alternative: using range step
total_v2 = sum(range(2, 21, 2))
print(total_v2)  # 110

result = []
for num in range(1, 16):
    if num % 3 == 0 and num % 5 == 0:
        result.append("FizzBuzz")
    elif num % 3 == 0:
        result.append("Fizz")
    elif num % 5 == 0:
        result.append("Buzz")
    else:
        result.append(str(num))

print(", ".join(result))
# 1, 2, Fizz, 4, Buzz, Fizz, 7, 8, Fizz, Buzz, 11, Fizz, 13, 14, FizzBuzz

text = "Hello World"

text = "Hello World"
vowels = "aeiouAEIOU"
count = 0

for char in text:
    if char in vowels:
        count += 1

print(count)  # 3

primes = []

for num in range(2, 31):
    is_prime = True
    for i in range(2, num):
        if num % i == 0:
            is_prime = False
            break
    if is_prime:
        primes.append(num)

print(primes)
# [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]

Functions are reusable blocks of code that perform specific tasks. They're essential for writing clean, organized, and maintainable code. Let's master Python functions!

Defining Functions

Use the def keyword (short for "define") to create a function. The function name should describe what the function does, following Python's naming conventions (lowercase letters with underscores separating words, like calculate_average).

The structure is: def function_name(parameters): followed by an indented code block. Parameters are optional. Some functions don't need any input.

# Basic function definition
def greet():
    """A simple greeting function."""
    print("Hello, World!")

# Call the function (run it) by using its name with parentheses
greet()  # Output: Hello, World!

Function with parameters: Pass data into your function:

# Function with parameters (input values)
def greet_person(name):
    """Greet a specific person."""
    print(f"Hello, {name}!")

greet_person("Priya")  # Output: Hello, Priya!

Return values: Use return to send data back from a function:

# Function with return value (output)
def add(a, b):
    """Add two numbers and return the result."""
    return a + b

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

Multiple return values: Python can return multiple values as a tuple:

# Multiple return values (returns a tuple)
def get_stats(numbers):
    """Calculate min, max, and average."""
    return min(numbers), max(numbers), sum(numbers) / len(numbers)

minimum, maximum, average = get_stats([1, 2, 3, 4, 5])
print(f"Min: {minimum}, Max: {maximum}, Avg: {average}")
# Output: Min: 1, Max: 5, Avg: 3.0

Parameters and Arguments

Parameters are the variable names in the function definition. Arguments are the actual values you pass when calling the function. Python offers flexible ways to pass data to functions: positional, keyword, default values, and variable-length arguments.

Default Parameter Values

Give parameters default values to make them optional:

# Default parameter values
def greet(name, greeting="Hello"):
    """Greet with customizable greeting."""
    print(f"{greeting}, {name}!")

greet("Priya")              # Hello, Priya! (uses default)
greet("Rahul", "Hi")          # Hi, Rahul! (overrides default)
greet("Ankit", greeting="Hey")  # Hey, Ankit! (keyword argument)

Functions can have multiple parameters with default values:

# Multiple defaults
def create_user(name, age=0, city="Unknown", active=True):
    return {
        "name": name,
        "age": age,
        "city": city,
        "active": active
    }

user1 = create_user("Priya")
user2 = create_user("Rahul", 25)
user3 = create_user("Ankit", city="Mumbai", age=30)

# BAD - mutable default
def add_item(item, items=[]):
    items.append(item)
    return items

print(add_item("a"))  # ['a']
print(add_item("b"))  # ['a', 'b'] - Unexpected!

# GOOD - use None and create inside
def add_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

*args and **kwargs

These special syntaxes allow functions to accept any number of arguments:

# *args - variable positional arguments
def sum_all(*numbers):
    """Sum any number of values."""
    total = 0
    for num in numbers:
        total += num
    return total

print(sum_all(1, 2, 3))        # 6
print(sum_all(1, 2, 3, 4, 5))  # 15
print(sum_all())               # 0

# Mixed with regular parameters
def greet_all(greeting, *names):
    for name in names:
        print(f"{greeting}, {name}!")

greet_all("Hello", "Priya", "Rahul", "Ankit")
# Hello, Priya!
# Hello, Rahul!
# Hello, Ankit!

# **kwargs - variable keyword arguments
def print_info(**info):
    """Print all key-value pairs."""
    for key, value in info.items():
        print(f"{key}: {value}")

print_info(name="Priya", age=25, city="Mumbai")
# name: Priya
# age: 25
# city: Mumbai

# Mixed with regular and *args
def create_record(id, *tags, **attributes):
    return {
        "id": id,
        "tags": tags,
        "attributes": attributes
    }

record = create_record(1, "python", "data",
                       author="Priya", status="active")
# {'id': 1, 'tags': ('python', 'data'), 
#  'attributes': {'author': 'Priya', 'status': 'active'}}

Unpacking Arguments

# Unpack a list/tuple into positional arguments
def add(a, b, c):
    return a + b + c

numbers = [1, 2, 3]
print(add(*numbers))          # 6 (unpacks list into a=1, b=2, c=3)

# Unpack a dictionary into keyword arguments
def greet(name, greeting, punctuation):
    return f"{greeting}, {name}{punctuation}"

params = {"name": "Priya", "greeting": "Hello", "punctuation": "!"}
print(greet(**params))        # Hello, Priya!

# Combining unpacking
coords = (10, 20)
options = {"color": "red", "size": 5}
draw_point(*coords, **options)  # draw_point(10, 20, color="red", size=5)

Lambda Functions

Lambda functions are small, anonymous functions defined with the lambda keyword. They're useful for short operations, especially with map(), filter(), and sorted().

# Lambda syntax: lambda arguments: expression

# Regular function
def square(x):
    return x ** 2

# Equivalent lambda
square = lambda x: x ** 2

print(square(5))  # 25

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

Common use case: Sorting with custom keys:

# sorted() with custom key
students = [
    {"name": "Priya", "grade": 85},
    {"name": "Rahul", "grade": 92},
    {"name": "Ankit", "grade": 78}
]

# Sort by grade
sorted_by_grade = sorted(students, key=lambda s: s["grade"])
print([s["name"] for s in sorted_by_grade])  # ['Ankit', 'Priya', 'Rahul']

# Sort by grade descending
sorted_desc = sorted(students, key=lambda s: s["grade"], reverse=True)
print([s["name"] for s in sorted_desc])  # ['Rahul', 'Priya', 'Ankit']

map() applies a function to each element:

# map() - apply function to each element
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x ** 2, numbers))
print(squared)  # [1, 4, 9, 16, 25]

filter() keeps elements that satisfy a condition:

# filter() - keep elements that satisfy condition
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)  # [2, 4]

List comprehensions are often cleaner than combining map and filter:

# Combine map and filter (complex)
result = list(map(lambda x: x ** 2, filter(lambda x: x % 2 == 0, range(10))))
print(result)  # [0, 4, 16, 36, 64]

# List comprehension is often cleaner
result = [x ** 2 for x in range(10) if x % 2 == 0]
print(result)  # [0, 4, 16, 36, 64]

Variable Scope

Scope determines where a variable can be accessed. Python has local, enclosing, global, and built-in scopes (LEGB rule).

# Global scope - accessible everywhere
global_var = "I'm global"

def my_function():
    # Local scope - only accessible inside this function
    local_var = "I'm local"
    print(global_var)   # Can read global
    print(local_var)    # Can access local

my_function()
print(global_var)       # Works
# print(local_var)      # NameError: local_var is not defined

# Modifying global variables
counter = 0

def increment():
    global counter      # Declare we're using the global
    counter += 1

increment()
increment()
print(counter)          # 2

# Enclosing scope (nested functions)
def outer():
    outer_var = "outer"
    
    def inner():
        nonlocal outer_var  # Access enclosing scope
        outer_var = "modified by inner"
        print(outer_var)
    
    inner()
    print(outer_var)    # "modified by inner"

outer()

# Best practice: avoid global, return values instead

# BAD - Using global (not recommended)
result = 0
def calculate_bad():
    global result
    result = 42

# GOOD - Return values (recommended)
def calculate_good():
    return 42

result = calculate_good()

# Example: Pure function (no side effects)
def calculate_tax(income, rate=0.25):
    """Calculate tax. Pure function - same input always gives same output."""
    return income * rate

tax = calculate_tax(50000)  # 12500.0

Practical Example: Data Processing Functions

Let's combine everything into a real data science example:

# Data processing functions for data science

def clean_data(data, remove_nulls=True, remove_duplicates=True):
    """
    Clean a list of dictionaries (records).
    
    Args:
        data: List of dictionaries
        remove_nulls: Remove records with None values
        remove_duplicates: Remove duplicate records
    
    Returns:
        Cleaned list of dictionaries
    """
    result = data.copy()
    
    if remove_nulls:
        result = [
            record for record in result 
            if all(v is not None for v in record.values())
        ]
    
    if remove_duplicates:
        seen = set()
        unique = []
        for record in result:
            # Convert dict to tuple for hashing
            key = tuple(sorted(record.items()))
            if key not in seen:
                seen.add(key)
                unique.append(record)
        result = unique
    
    return result


def calculate_statistics(values):
    """Calculate basic statistics for a list of numbers."""
    if not values:
        return None
    
    n = len(values)
    mean = sum(values) / n
    
    # Variance and standard deviation
    variance = sum((x - mean) ** 2 for x in values) / n
    std_dev = variance ** 0.5
    
    # Sort for median
    sorted_values = sorted(values)
    if n % 2 == 0:
        median = (sorted_values[n//2 - 1] + sorted_values[n//2]) / 2
    else:
        median = sorted_values[n//2]
    
    return {
        "count": n,
        "mean": mean,
        "median": median,
        "std_dev": std_dev,
        "min": min(values),
        "max": max(values)
    }


def filter_records(data, **conditions):
    """
    Filter records based on conditions.
    
    Example: filter_records(data, age=25, city="Mumbai")
    """
    return [
        record for record in data
        if all(record.get(key) == value for key, value in conditions.items())
    ]


# Using the functions
raw_data = [
    {"name": "Priya", "age": 25, "salary": 50000},
    {"name": "Rahul", "age": 30, "salary": 60000},
    {"name": "Ankit", "age": None, "salary": 55000},  # Will be removed
    {"name": "Priya", "age": 25, "salary": 50000},      # Duplicate
    {"name": "Vikram", "age": 35, "salary": 70000},
]

# Clean the data
cleaned = clean_data(raw_data)
print(f"Cleaned: {len(cleaned)} records")  # 3 records

# Calculate salary statistics
salaries = [r["salary"] for r in cleaned]
stats = calculate_statistics(salaries)
print(f"Average salary: ${stats['mean']:,.2f}")

# Filter high earners
high_earners = filter_records(cleaned, age=30)
print(f"Age 30: {[r['name'] for r in high_earners]}")

# Test:
print(rectangle_area(5, 3))  # Expected: 15
print(rectangle_area(10, 7)) # Expected: 70

def rectangle_area(length, width):
    return length * width

print(rectangle_area(5, 3))   # 15
print(rectangle_area(10, 7))  # 70

# Test:
print(is_palindrome("Radar"))  # Expected: True
print(is_palindrome("Hello"))  # Expected: False
print(is_palindrome("Level"))  # Expected: True

def is_palindrome(text):
    text = text.lower()
    return text == text[::-1]

print(is_palindrome("Radar"))  # True
print(is_palindrome("Hello"))  # False
print(is_palindrome("Level"))  # True

# Test:
print(power(5))      # Expected: 25 (5^2)
print(power(2, 10))  # Expected: 1024 (2^10)
print(power(3, 3))   # Expected: 27 (3^3)

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

print(power(5))      # 25
print(power(2, 10))  # 1024
print(power(3, 3))   # 27

# Test:
data = [4, 2, 9, 1, 7]
minimum, maximum = min_max(data)
print(minimum)  # Expected: 1
print(maximum)  # Expected: 9

def min_max(numbers):
    return min(numbers), max(numbers)

data = [4, 2, 9, 1, 7]
minimum, maximum = min_max(data)
print(minimum)  # 1
print(maximum)  # 9

# Test:
print(sum_all(1, 2, 3))        # Expected: 6
print(sum_all(10, 20))         # Expected: 30
print(sum_all(5, 5, 5, 5, 5))  # Expected: 25

def sum_all(*args):
    return sum(args)

print(sum_all(1, 2, 3))        # 6
print(sum_all(10, 20))         # 30
print(sum_all(5, 5, 5, 5, 5))  # 25

# Test:
print(factorial(5))  # Expected: 120 (5 × 4 × 3 × 2 × 1)
print(factorial(0))  # Expected: 1 (by definition)
print(factorial(7))  # Expected: 5040

def factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n - 1)

print(factorial(5))  # 120
print(factorial(0))  # 1
print(factorial(7))  # 5040

temperatures_celsius = [0, 10, 20, 30, 40]

temperatures_celsius = [0, 10, 20, 30, 40]

temperatures_fahrenheit = list(map(
    lambda c: c * 9/5 + 32,
    temperatures_celsius
))

print(temperatures_fahrenheit)
# [32.0, 50.0, 68.0, 86.0, 104.0]