Advanced Python Fundamentals

These features are part of modern Python and are widely used in professional applications and popular frameworks such as FastAPI, Flask, Django, NumPy, Pandas, and many other third-party libraries.

Topics Covered

In this module, you’ll learn:

Everything is an Object & Variables as References
Integer Value Caching (Integer Interning)
Mutability (Mutable vs Immutable Objects)
Floating Point Precision Nuances (0.1 + 0.2 != 0.3)
Advanced String Indexing and Slicing
Important String Operations (split, join, strip, replace)
Python Nuances
for-else and while-else
Function Arguments
Packing and Unpacking

By the end of this module, you’ll be comfortable writing more flexible, reusable, and Pythonic functions that are commonly used in real-world Python applications.

Practice Along: 💻 VS Code | 🚀 Colab | 📥 Download
Verify Solutions: 💻 VS Code | 🚀 Colab | 📥 Download

Everything is an Object & Variables as References

In Python, everything is treated as an object—including integers, floats, strings, functions, and modules. Furthermore, variables in Python do not hold values directly. Instead, variables hold references (pointers) to the location in memory where the object is stored.

Understanding Object Identity

You can use the built-in id() function to find the memory address of an object. The is operator checks if two references point to the exact same object in memory, while == checks if their actual values are equal.

x = [1, 2, 3]
y = x

print(f"ID of x: {id(x)}")
print(f"ID of y: {id(y)}")
print(x is y)

Output

Show Output

ID of x: 4356781296
ID of y: 4356781296
True

If you create an identical list independently, they will have different identities despite having equal values:

x = [1, 2, 3]
z = [1, 2, 3]

print(x == z)
print(x is z)

Output

Show Output

True
False

Verification: Integers and Floats are Objects

Unlike languages like C++ or Java where primitive types (such as int, double) store raw values directly in variables, in Python, even integers and floats are objects. This has two major implications:

Variables assigned to integers or floats store references (pointers) to those numeric objects in memory.
Integers and floats have their own built-in properties and methods that you can invoke using dot notation.

1. Verifying Reference Behavior with Float Objects

When you create two floats independently, Python creates two distinct objects in memory. The variables f1 and f2 store references to these distinct objects:

f1 = 2.5
f2 = 2.5

print("Value Equality (f1 == f2):", f1 == f2)
print("Object Identity (f1 is f2):", f1 is f2)
print("ID of f1:", id(f1))
print("ID of f2:", id(f2))

Output

Show Output

Value Equality (f1 == f2): True
Object Identity (f1 is f2): False
ID of f1: 4395648112
ID of f2: 4395648240

2. Accessing Methods on Numbers

Since numbers are objects, they have built-in methods.

[!NOTE] If you call a method directly on a literal number, you must enclose the number in parentheses (e.g., (10).bit_length()). Otherwise, Python’s parser will confuse the dot . with a decimal point.

Built-in Methods on Integers:

bit_length(): Returns the number of bits required to represent an integer in binary.
as_integer_ratio(): Returns a tuple of (numerator, denominator) representing the integer as a fraction.

num = 42
print("Bits required for 42:", num.bit_length())  # 42 is binary 101010
print("Fraction representation:", num.as_integer_ratio())

Output

Show Output

Bits required for 42: 6
Fraction representation: (42, 1)

Built-in Methods on Floats:

is_integer(): Returns True if the float has no fractional part (e.g., 10.0).
as_integer_ratio(): Returns the exact fraction representing the float.

f_val = 10.5
print("Is 10.5 an integer?", f_val.is_integer())
print("Is 3.0 an integer?", (3.0).is_integer())
print("Fraction representation:", f_val.as_integer_ratio())

Output

Show Output

Is 10.5 an integer? False
Is 3.0 an integer? True
Fraction representation: (21, 2)

Exercise 1

Assign the string "FastAPI" to a variable a, and then assign a to b. Verify if they point to the same object using is and by printing their ids.

Solution

a = "FastAPI"
b = a

print(a is b)
print(id(a) == id(b))

Exercise 2

Create two float variables with the value 2.5 independently. Compare them using == and is, and explain the result.

Solution

f1 = 2.5
f2 = 2.5

print(f1 == f2)  # True (values are equal)
print(f1 is f2)  # False (different float objects in memory)

Integer Value Caching (Integer Interning)

In Python, memory optimization is built into the interpreter. One of the most famous optimizations is Integer Value Caching (also known as integer interning). At startup, Python (specifically the standard CPython implementation) pre-allocates and caches all integers in the range [-5, 256]. When you reference any integer in this range, Python does not create a new object. Instead, it returns a reference to the existing cached integer object.

a = 100
b = 100

print(a is b)
print(id(a) == id(b))

Output

Show Output

True
True

However, for integers outside this range, Python creates a new object in memory (unless optimized within the same code block by the compiler).

x = 300
y = 300

print(x is y)

Output

Show Output

False

Exercise 1

Predict the output of the following comparisons:

a = 256
b = 256
print(a is b)

x = -6
y = -6
print(x is y)

Solution

True
False

256 lies within the cache range [-5, 256], so a and b refer to the same object. -6 is outside the cache range, so x and y refer to different objects.

Exercise 2

Write a code snippet to verify that floats are not cached in the same manner as small integers (e.g., compare 1.0 and 1.0 using is).

Solution

f1 = 1.0
f2 = 1.0

# This will print False because float caching is not pre-allocated like small integers
print(f1 is f2)

Mutability (Mutable vs Immutable Objects)

In Python, every object is classified as either mutable or immutable. Understanding this distinction is crucial for understanding how Python handles variable assignment, function arguments, and memory.

Immutable Objects

An immutable object’s state cannot be changed after it is created. Examples of immutable types in Python:

Numeric types (int, float, complex)
Strings (str)
Tuples (tuple)
Booleans (bool)
Frozensets (frozenset)

If you attempt to modify an immutable object, Python does not change the original object; instead, it creates a new object in memory and updates the reference.

x = 10
print(f"Initial ID of x: {id(x)}")

x = x + 5
print(f"New ID of x: {id(x)}")

Output

Show Output

Initial ID of x: 4376378704
New ID of x: 4376378864

(Note: The exact IDs will vary across runs, but they will be different).

Mutable Objects

A mutable object’s state can be changed in-place after it is created. Examples of mutable types in Python:

Lists (list)
Dictionaries (dict)
Sets (set)

Modifying a mutable object retains the same memory address (id).

lst = [1, 2, 3]
print(f"Initial ID of lst: {id(lst)}")

lst.append(4)
print(f"New ID of lst: {id(lst)}")
print(f"List content: {lst}")

Output

Show Output

Initial ID of lst: 4377983168
New ID of lst: 4377983168
List content: [1, 2, 3, 4]

(Note: The ID remains identical, showing the object was modified in-place).

A Common Nuance: Mutable Objects Inside Immutable Containers

If a tuple contains a mutable object, such as a list, the tuple itself is still immutable (its references cannot change), but the list inside it can be mutated.

t = (1, 2, [3, 4])
t[2].append(5)
print(t)

Output

Show Output

(1, 2, [3, 4, 5])

Exercise 1

Predict whether the following operation is valid and what it outputs:

my_str = "hello"
my_str[0] = "H"

Solution

TypeError: 'str' object does not support item assignment

Strings are immutable, so you cannot mutate individual characters in-place.

Exercise 2

What is the final content of list_b?

list_a = [1, 2, 3]
list_b = list_a
list_a.append(4)

Solution

[1, 2, 3, 4]

Since lists are mutable and assignment (list_b = list_a) copies the reference, both variables point to the same list object in memory.

Floating Point Precision Nuances

Floating-point numbers in computers are represented as binary fractions. This leads to some surprising behavior when performing decimal calculations.

The Classic Floating-Point Issue: `0.1 + 0.2`

In Python:

print(0.1 + 0.2)
print(0.1 + 0.2 == 0.3)

Output

Show Output

0.30000000000000004
False

Why Does This Happen?

Numbers like 0.1 and 0.2 have infinite repeating representations in binary (similar to how

1/3

0.33333...

in base 10). The computer must truncate these values, introducing a microscopic rounding error. When you add them, the errors combine, resulting in 0.30000000000000004.

Why Does `0.5 + 0.25 == 0.75` Work?

Unlike 0.1 and 0.2, the fractions 0.5 (

2^{-1}

), 0.25 (

2^{-2}

), and 0.75 (

2^{-1} + 2^{-2}

) are sums of exact powers of 2. They can be represented perfectly in binary.

print(0.5 + 0.25)
print(0.5 + 0.25 == 0.75)

Output

Show Output

0.75
True

How to Handle Exact Decimal Math

If your application requires exact decimal calculations (e.g., handling money or financial transactions), use Python’s built-in decimal module:

from decimal import Decimal

val1 = Decimal('0.1')
val2 = Decimal('0.2')
print(val1 + val2)
print(val1 + val2 == Decimal('0.3'))

Output

Show Output

0.3
True

(Note: Always pass string representations to Decimal constructor. Passing floats like Decimal(0.1) preserves the float’s floating-point precision error).

Exercise 1

Predict the output of:

from decimal import Decimal
print(Decimal(0.1) == Decimal('0.1'))

Solution

False

Decimal(0.1) inherits the imprecise representation of the float 0.1, whereas Decimal('0.1') represents exactly 0.1.

Exercise 2

Will the expression 0.125 + 0.125 == 0.25 be True or False?

Solution

True

0.125 (

2^{-3}

) and 0.25 (

2^{-2}

) can be represented exactly in binary, so no rounding error occurs.

String Indexing and Slicing

Strings are sequences of characters. Python allows extracting portions of a string using indexing and slicing.

string[start:stop:step]

Understanding the Slice Components

start – Starting index (inclusive)
stop – Ending index (exclusive)
step – Number of characters to skip

Any of these values may be omitted.

Basic Slicing

text = "Advanced Python"

print(text[0])
print(text[3])
print(text[-1])
print(text[-2])

Output

Show Output

A
a
n
o

Extracting a Portion of a String

text = "Advanced Python"

print(text[0:8])
print(text[9:15])

Output

Show Output

Advanced
Python

Omitting Start or Stop

text = "Advanced Python"

print(text[:8])
print(text[9:])

Output

Show Output

Advanced
Python

Using Step

text = "Programming"

print(text[::2])
print(text[1::2])

Output

Show Output

Pormig
rgamn

Reversing a String

A negative step traverses the string from right to left.

text = "Python"

print(text[::-1])

Output

Show Output

nohtyP

Practical Example

Extract the file extension.

filename = "report.pdf"

print(filename[-3:])

Output

Show Output

pdf

Exercise 1

Extract "Python" from the following string.

text = "Learn Python Programming"

Solution

text = "Learn Python Programming"

print(text[6:12])

Exercise 2

Reverse the following string using slicing.

text = "Artificial Intelligence"

Solution

text = "Artificial Intelligence"

print(text[::-1])

Important String Operations for Data Processing

In real-world data processing, indexing and slicing are rarely enough. We frequently need to clean, transform, partition, and format string data.

1. Cleaning Whitespace with `.strip()`

Whitespace at the beginning or end of strings (like spaces, tabs, or newlines) is common in raw data imports.

.strip(): Removes leading and trailing whitespace.
.lstrip(): Removes leading whitespace only.
.rstrip(): Removes trailing whitespace only.

raw_data = "   \n  user_name_123   \t "
clean_data = raw_data.strip()
print(f"Original: {repr(raw_data)}")
print(f"Cleaned: {repr(clean_data)}")

2. Splitting and Joining

Converting between single strings and lists of substrings is a core data-processing pattern.

Splitting Strings (`.split()`)

The .split(sep) method splits a string on a specified separator and returns a list of substrings. If no separator is specified, it splits on any consecutive whitespace.

csv_row = "Alice,25,Engineer,Hyderabad"
parsed_list = csv_row.split(",")
print("Parsed List:", parsed_list)

sentence = "Python  is   fun"
words = sentence.split()  # Splits on multiple spaces
print("Words:", words)

Joining Lists (`.join()`)

The .join(iterable) method is called on the separator string and merges a list of strings into a single string.

words = ["Python", "FastAPI", "Uvicorn"]
joined_pipe = " | ".join(words)
print("Joined:", joined_pipe)

csv_line = ",".join(["Bob", "30", "Manager"])
print("CSV:", csv_line)

3. Replacing Substrings (`.replace()`)

You can swap out characters or substrings using .replace(old, new).

file_path = "data/2024/report.csv"
url_path = file_path.replace("/", "-")
print("New string:", url_path)

4. Validating Prefix/Suffix (`.startswith()` and `.endswith()`)

Useful for filtering filenames, URLs, or protocols.

filename = "data_export.xlsx"
print(filename.startswith("data_"))
print(filename.endswith(".xlsx"))

Exercise 3

Clean a list of raw email strings by removing leading/trailing whitespaces and converting them to lowercase.

Solution

raw_emails = ["  [email protected] ", "[email protected]\n", "\t[email protected]  "]
cleaned_emails = [email.strip().lower() for email in raw_emails]
print(cleaned_emails)

Exercise 4

Given a raw CSV row "john doe, 28, Developer, New York", parse the columns, strip the whitespace, capitalize the name ("John Doe"), and join the columns back using a semicolon ; as the separator.

Solution

raw_row = "john doe, 28, Developer, New York"
# Split by comma
columns = raw_row.split(",")
# Clean columns
cleaned = [col.strip() for col in columns]
# Capitalize the name (first column)
cleaned[0] = cleaned[0].title()
# Join using semicolon
final_row = ";".join(cleaned)
print(final_row)

Python Nuances

Python provides several elegant language features that simplify common programming tasks.

Short-Circuit Evaluation

Logical operators don’t always evaluate every expression.

Using `or`

Suppose a user doesn’t enter a name.

username = ""

if username:
    print(username)
else:
    print("Guest")

The same logic can be written more concisely.

username = ""

print(username or "Guest")

Output

Show Output

Guest

If a username exists,

username = "Alice"

print(username or "Guest")

Output

Show Output

Alice

Using `and`

Suppose a user must be logged in before displaying a welcome message.

logged_in = True

if logged_in:
    print("Welcome!")

Python allows this shorter form.

logged_in = True

logged_in and print("Welcome!")

If logged_in is False, the second expression is never evaluated.

Exercise 1

Print "Anonymous" whenever name is an empty string.

Solution

name = ""

print(name or "Anonymous")

Exercise 2

Print "Access Granted" only when is_admin is True.

Solution

is_admin = True

is_admin and print("Access Granted")

One-line `if` only statement

If you want to run a single statement on a condition without an else, you can write it on one line (though this is a statement, not an expression that returns a value):

is_ready = True
if is_ready: print("Ready!")

Exercise 1

Write a one-line conditional expression that assigns "Even" or "Odd" to a variable label based on whether num is divisible by 2.

Solution

num = 7
label = "Even" if num % 2 == 0 else "Odd"
print(label)

Exercise 2

Write a one-line conditional expression to assign "Pass" to a variable result if score >= 50 else "Fail".

Solution

score = 85
result = "Pass" if score >= 50 else "Fail"
print(result)

Conditional Expressions (One-line `if-else` / Ternary Operator)

A conditional expression (also known as a ternary operator) allows you to assign a value to a variable based on a condition in a single line.

Syntax

value_if_true if condition else value_if_false

Traditional if-else blocks:

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

Can be written cleanly as:

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

Output

Show Output

Adult

Chained Comparisons

Many range checks require two comparisons. Traditional approach:

age = 25

if age >= 18 and age <= 60:
    print("Eligible")

Python provides a cleaner syntax.

age = 25

if 18 <= age <= 60:
    print("Eligible")

This syntax is easier to read and is preferred in Python. Another example:

marks = 82

print(40 <= marks <= 100)

Checking whether a character is lowercase.

ch = "m"

print("a" <= ch <= "z")

Exercise 1

Check whether temperature lies between 20 and 35.

Solution

temperature = 28

print(20 <= temperature <= 35)

Exercise 2

Check whether a character is an uppercase alphabet.

Solution

ch = "P"

print("A" <= ch <= "Z")

Multiple Assignment and Variable Swapping

Multiple Assignment

Instead of assigning each variable separately,

language = "Python"
version = "Python"
author = "Python"

Python allows

language = version = author = "Python"

print(language)
print(version)
print(author)

Assigning Multiple Values

first_name, last_name = "John", "Doe"

print(first_name)
print(last_name)

Swapping Variables

Traditional approach:

first = "Hello"
second = "World"

temp = first
first = second
second = temp

Python provides a much cleaner solution.

first = "Hello"
second = "World"

first, second = second, first

print(first)
print(second)

Output

Show Output

World
Hello

Exercise 1

Assign "Unknown" to three variables using a single statement.

Solution

city = state = country = "Unknown"

Exercise 2

Swap the values of two variables without using a temporary variable.

Solution

language = "Python"
framework = "FastAPI"

language, framework = framework, language

print(language)
print(framework)

`for-else` and `while-else`

Unlike many programming languages, Python allows an optional else block after loops. The else block executes only when the loop completes normally without encountering a break statement.

Example 1: Searching for a Divisor

Suppose we want to check whether a number has any divisor other than 1 and itself.

number = 21

for i in range(2, number):
    if number % i == 0:
        print(f"{i} is a divisor.")
        break
else:
    print("No divisor found.")

Output

Show Output

3 is a divisor.

If a divisor is found, the loop terminates using break, so the else block is skipped.

Example 2: Checking Whether a Number is Prime

A prime number has no divisors other than 1 and itself.

number = 29

for i in range(2, int(number ** 0.5) + 1):
    if number % i == 0:
        print("Not Prime")
        break
else:
    print("Prime")

Output

Show Output

Prime

This is one of the most common real-world uses of for-else.

`while-else`

The else block also works with while loops.

count = 1

while count <= 5:
    print(count)
    count += 1
else:
    print("Loop Finished")

Output

Show Output

1
2
3
4
5
Loop Finished

Exercise 1

Write a program to check whether a given number is a perfect square using for-else.

Solution

number = 49

for i in range(1, number + 1):
    if i * i == number:
        print("Perfect Square")
        break
else:
    print("Not a Perfect Square")

Exercise 2

Print all prime numbers between 50 and 100 using for-else.

Solution

start = 50
end = 100

for number in range(start, end + 1):
    if number < 2:
        continue

    for i in range(2, int(number ** 0.5) + 1):
        if number % i == 0:
            break
    else:
        print(number)

Function Arguments

Functions become more flexible when they can accept arguments in different ways. Python supports positional arguments, keyword arguments, positional-only parameters, and keyword-only parameters.

Positional Arguments

Positional arguments are matched with function parameters based on their position.

def introduce(name, city):
    print(f"My name is {name}.")
    print(f"I live in {city}.")

introduce("Alice", "Hyderabad")

Output

Show Output

My name is Alice.
I live in Hyderabad.

Here,

"Alice" is assigned to name
"Hyderabad" is assigned to city

The order of the arguments is important.

introduce("Hyderabad", "Alice")

Output

Show Output

My name is Hyderabad.
I live in Alice.

Exercise 1

Create a function greet() that accepts a person’s name and prints a welcome message.

Solution

def greet(name):
    print(f"Welcome {name}")

greet("John")

Exercise 2

Create a function that accepts a student’s name and course, then displays both values.

Solution

def student(name, course):
    print(name)
    print(course)

student("Alice", "Python")

Keyword Arguments

Keyword arguments pass values using parameter names instead of their positions.

def introduce(name, city):
    print(f"My name is {name}.")
    print(f"I live in {city}.")

introduce(city="Hyderabad", name="Alice")

Output

Show Output

My name is Alice.
I live in Hyderabad.

Since parameter names are used, the order no longer matters. Keyword arguments improve readability, especially for functions having many parameters.

Exercise 1

Call the following function using keyword arguments.

def employee(name, department):
    print(name, department)

Solution

def employee(name, department):
    print(name, department)

employee(department="HR", name="David")

Exercise 2

Create a function that accepts a product name and price. Call it using keyword arguments.

Solution

def product(name, price):
    print(name)
    print(price)

product(price=2500, name="Keyboard")

Mixing Positional and Keyword Arguments

Positional and keyword arguments can be used together.

def introduce(name, city, profession):
    print(name)
    print(city)
    print(profession)

introduce("Alice", city="Hyderabad", profession="Developer")

Output

Show Output

Alice
Hyderabad
Developer

Rule

All positional arguments must appear before keyword arguments. ✔️ Correct

introduce("Alice", city="Hyderabad", profession="Developer")

❌ Incorrect

# introduce(name="Alice", "Hyderabad", profession="Developer")

The second call raises a SyntaxError because a positional argument appears after a keyword argument.

Exercise 1

Create a function that accepts a student’s name, course, and city. Pass the first argument positionally and the remaining arguments using keywords.

Solution

def student(name, course, city):
    print(name)
    print(course)
    print(city)

student("Alice", course="Python", city="Hyderabad")

Exercise 2

Create a function that accepts an employee’s name, designation, and salary. Mix positional and keyword arguments while calling it.

Solution

def employee(name, designation, salary):
    print(name)
    print(designation)
    print(salary)

employee("John", designation="Manager", salary=65000)

Positional-only Parameters (`/`)

Python allows certain parameters to be passed only by position. The / symbol separates positional-only parameters from the remaining parameters.

def divide(a, b, /):
    return a / b

print(divide(10, 2))

Valid

divide(20, 5)

Invalid

# divide(a=20, b=5)

The second call raises a TypeError.

Why Use Positional-only Parameters?

Sometimes parameter names are implementation details and should not become part of the public interface. For example,

def power(base, exponent, /):
    return base ** exponent

print(power(2, 5))

The function works correctly regardless of the internal parameter names.

Exercise 1

Create a function multiply() that accepts two positional-only parameters.

Solution

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

print(multiply(10, 5))

Exercise 2

Create a function discount() that accepts price and discount percentage as positional-only parameters.

Solution

def discount(price, percentage, /):
    return price - (price * percentage / 100)

print(discount(5000, 20))

Keyword-only Parameters (`*`)

Parameters appearing after * must always be passed using keyword arguments.

def register(name, *, city, email):
    print(name)
    print(city)
    print(email)

register(
    "Alice",
    city="Hyderabad",
    email="[email protected]"
)

Valid

register(
    "John",
    city="Delhi",
    email="[email protected]"
)

Invalid

# register("John", "Delhi", "[email protected]")

The second call raises a TypeError.

Why Use Keyword-only Parameters?

Keyword arguments improve readability, especially when a function has several optional settings.

def connect(host, *, port, timeout):
    print(host)
    print(port)
    print(timeout)

connect(
    "localhost",
    port=8000,
    timeout=30
)

The purpose of each value is immediately clear.

Combining Both

A function can use positional-only and keyword-only parameters together.

def calculate(a, b, /, *, operation):
    if operation == "add":
        return a + b
    elif operation == "subtract":
        return a - b

print(calculate(10, 20, operation="add"))

Exercise 1

Create a function where the first parameter is positional-only and the second parameter is keyword-only.

Solution

def display(name, /, *, city):
    print(name)
    print(city)

display("Alice", city="Hyderabad")

Exercise 2

Create a function that calculates the area of a rectangle using keyword-only parameters.

Solution

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

print(area(length=10, width=5))

Packing and Unpacking

The operators * and ** have two complementary roles in Python.

Packing collects multiple values into a single variable.
Unpacking expands a collection into individual values.

Although the same symbols are used, their behavior depends on the context.

Packing Positional Arguments (`*args`)

Sometimes we don’t know how many positional arguments a function will receive. *args collects all remaining positional arguments into a tuple.

def display(*values):
    print(values)

display("Python")
display("Python", "Java", "C++")

Output

Show Output

('Python',)
('Python', 'Java', 'C++')

A practical example:

def total(*numbers):
    result = 0

    for number in numbers:
        result += number

    return result

print(total(10, 20))
print(total(10, 20, 30))
print(total(10, 20, 30, 40))

Output

Show Output

30
60
100

Exercise 1

Write a function that accepts any number of names and prints them.

Solution

def show_names(*names):
    for name in names:
        print(name)

show_names("Alice", "Bob", "Charlie")

Exercise 2

Write a function that accepts any number of integers and returns the largest value.

Solution

def largest(*numbers):
    return max(numbers)

print(largest(12, 45, 9, 32))

Packing Keyword Arguments (`**kwargs`)

**kwargs collects keyword arguments into a dictionary.

def display(**details):
    print(details)

display(name="Alice", city="Hyderabad")

Output

Show Output

{'name': 'Alice', 'city': 'Hyderabad'}

Access individual values.

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

display(
    name="Alice",
    city="Hyderabad",
    course="Python"
)

Output

Show Output

name: Alice
city: Hyderabad
course: Python

Exercise 1

Write a function that accepts any number of student details and prints them.

Solution

def student(**details):
    for key, value in details.items():
        print(key, value)

student(
    name="John",
    course="Python",
    city="Delhi"
)

Exercise 2

Write a function that prints all keyword arguments passed to it.

Solution

def display(**kwargs):
    for key, value in kwargs.items():
        print(key, value)

display(
    language="Python",
    version="3.12"
)

Unpacking Positional Arguments (`*`)

Packing collects values. Unpacking performs the opposite operation. Instead of passing arguments one by one,

def greet(name, city):
    print(name)
    print(city)

greet("Alice", "Hyderabad")

the values can be stored in a tuple and unpacked.

def greet(name, city):
    print(name)
    print(city)

details = ("Alice", "Hyderabad")

greet(*details)

The * operator expands the tuple into individual arguments.

Exercise 1

Call a function by unpacking a tuple.

Solution

def employee(name, department):
    print(name)
    print(department)

emp = ("David", "HR")

employee(*emp)

Exercise 2

Store two numbers in a tuple and unpack them while calling a function.

Solution

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

numbers = (10, 20)

add(*numbers)

Unpacking Keyword Arguments (`**`)

A dictionary can also be unpacked into keyword arguments.

def student(name, city):
    print(name)
    print(city)

details = {
    "name": "Alice",
    "city": "Hyderabad"
}

student(**details)

The dictionary keys must match the parameter names.

Exercise 1

Create a dictionary containing product details and unpack it while calling a function.

Solution

def product(name, price):
    print(name)
    print(price)

details = {
    "name": "Keyboard",
    "price": 2500
}

product(**details)

Exercise 2

Call a function by unpacking a dictionary containing employee details.

Solution

def employee(name, department):
    print(name)
    print(department)

details = {
    "name": "John",
    "department": "Accounts"
}

employee(**details)

Extended Unpacking

Python allows collecting the remaining values using *.

text = "PYTHON"

first, *middle, last = text

print(first)
print(middle)
print(last)

Output

Show Output

P
['Y', 'T', 'H', 'O']
N

This is useful when only the first and last elements are important. Another example.

text = "Programming"

first, *remaining = text

print(first)
print(remaining)

Exercise 1

Extract the first and last characters of the string "Developer".

Solution

text = "Developer"

first, *middle, last = text

print(first)
print(last)

Exercise 2

Extract the first character separately and store the remaining characters in another variable.

Solution

text = "Python"

first, *remaining = text

print(first)
print(remaining)

Combining Everything

Python allows all parameter types to be used together.

def register(username, *courses, active=True, **details):
    print("Username :", username)
    print("Courses  :", courses)
    print("Active   :", active)
    print("Details  :", details)

register(
    "Alice",
    "Python",
    "FastAPI",
    active=False,
    city="Hyderabad",
    experience=2
)

Output

Show Output

Username : Alice
Courses  : ('Python', 'FastAPI')
Active   : False
Details  : {'city': 'Hyderabad', 'experience': 2}

This pattern is commonly used in Python libraries and frameworks.

Exercise 1

Write a function that accepts a student’s name followed by any number of marks and prints the average.

Solution

def average(name, *marks):
    total = sum(marks)
    avg = total / len(marks)

    print(name)
    print(avg)

average("Alice", 80, 85, 92)

Exercise 2

Create a function that accepts a required username, any number of hobbies, and additional user details.

Solution

def profile(username, *hobbies, **details):
    print(username)
    print(hobbies)
    print(details)

profile(
    "John",
    "Reading",
    "Gaming",
    city="Delhi",
    age=24
)

Practice

To reinforce what you’ve learned in this section, practice with the interactive follow-along notebook:

Follow-Along Practice

Practice string slicing, short-circuit logic, chained comparisons, variable swapping, loop-else clauses, and packing/unpacking positional and keyword arguments.💻 VS Code | 🚀 Colab | 📥 Download

Summary

In this module, you learned several advanced Python features that make your code cleaner, more expressive, and more reusable.

Key Concepts Covered

Advanced string indexing and slicing
Short-circuit evaluation using and and or
Chained comparisons
Multiple assignment and variable swapping
for-else and while-else
Positional arguments
Keyword arguments
Mixing positional and keyword arguments
Positional-only parameters (/)
Keyword-only parameters (*)
Packing positional arguments using *args
Packing keyword arguments using **kwargs
Unpacking tuples using *
Unpacking dictionaries using **
Extended unpacking
Combining different parameter types in a single function

​Advanced Python Fundamentals

​Topics Covered

​Everything is an Object & Variables as References

​Understanding Object Identity

​Verification: Integers and Floats are Objects

​1. Verifying Reference Behavior with Float Objects

​2. Accessing Methods on Numbers

Built-in Methods on Integers:

Built-in Methods on Floats:

​Exercise 1

​Exercise 2

​Integer Value Caching (Integer Interning)

​Exercise 1

​Exercise 2

​Mutability (Mutable vs Immutable Objects)

​Immutable Objects

​Mutable Objects

​A Common Nuance: Mutable Objects Inside Immutable Containers

​Exercise 1

​Exercise 2

​Floating Point Precision Nuances

​The Classic Floating-Point Issue: 0.1 + 0.2

​Why Does This Happen?

​Why Does 0.5 + 0.25 == 0.75 Work?

​How to Handle Exact Decimal Math

​Exercise 1

​Exercise 2

​String Indexing and Slicing

​Understanding the Slice Components

​Basic Slicing

​Extracting a Portion of a String

​Omitting Start or Stop

​Using Step

​Reversing a String

​Practical Example

​Exercise 1

​Exercise 2

​Important String Operations for Data Processing

​1. Cleaning Whitespace with .strip()

​2. Splitting and Joining

​Splitting Strings (.split())

​Joining Lists (.join())

​3. Replacing Substrings (.replace())

​4. Validating Prefix/Suffix (.startswith() and .endswith())

​Exercise 3

​Exercise 4

​Python Nuances

​Short-Circuit Evaluation

​Using or

​Using and

​Exercise 1

​Exercise 2

​One-line if only statement

​Exercise 1

​Exercise 2

​Conditional Expressions (One-line if-else / Ternary Operator)

​Syntax

​Chained Comparisons

​Exercise 1

​Exercise 2

​Multiple Assignment and Variable Swapping

​Multiple Assignment

​Assigning Multiple Values

​Swapping Variables

​Exercise 1

​Exercise 2

​for-else and while-else

​Example 1: Searching for a Divisor

​Example 2: Checking Whether a Number is Prime

​while-else

​Exercise 1

​Exercise 2

​Function Arguments

​Positional Arguments

​Exercise 1

​Exercise 2

​Keyword Arguments

​Exercise 1

​Exercise 2

​Mixing Positional and Keyword Arguments

Advanced Python Fundamentals

Topics Covered

Everything is an Object & Variables as References

Understanding Object Identity

Verification: Integers and Floats are Objects

1. Verifying Reference Behavior with Float Objects

2. Accessing Methods on Numbers

Exercise 1

Exercise 2

Integer Value Caching (Integer Interning)

Exercise 1

Exercise 2

Mutability (Mutable vs Immutable Objects)

Immutable Objects

Mutable Objects

A Common Nuance: Mutable Objects Inside Immutable Containers

Exercise 1

Exercise 2

Floating Point Precision Nuances

The Classic Floating-Point Issue: `0.1 + 0.2`

Why Does This Happen?

Why Does `0.5 + 0.25 == 0.75` Work?

How to Handle Exact Decimal Math

Exercise 1

Exercise 2

String Indexing and Slicing

Understanding the Slice Components

Basic Slicing

Extracting a Portion of a String

Omitting Start or Stop

Using Step

Reversing a String

Practical Example

Exercise 1

Exercise 2

Important String Operations for Data Processing

1. Cleaning Whitespace with `.strip()`

2. Splitting and Joining

Splitting Strings (`.split()`)

Joining Lists (`.join()`)

3. Replacing Substrings (`.replace()`)

4. Validating Prefix/Suffix (`.startswith()` and `.endswith()`)

Exercise 3

Exercise 4

Python Nuances

Short-Circuit Evaluation

Using `or`

Using `and`

Exercise 1

Exercise 2

One-line `if` only statement

Exercise 1

Exercise 2

Conditional Expressions (One-line `if-else` / Ternary Operator)

Syntax

Chained Comparisons

Exercise 1

Exercise 2

Multiple Assignment and Variable Swapping

Multiple Assignment

Assigning Multiple Values

Swapping Variables

Exercise 1

Exercise 2

`for-else` and `while-else`

Example 1: Searching for a Divisor

Example 2: Checking Whether a Number is Prime

`while-else`

Exercise 1

Exercise 2

Function Arguments

Positional Arguments

Exercise 1

Exercise 2

Keyword Arguments

Exercise 1

Exercise 2

Mixing Positional and Keyword Arguments

Rule

Exercise 1