What is this shi…?

Imagine a function as a hall. Normal parameters are the front-line greeters—they don’t unpack bags (*args) or decode secret scrolls (**kwargs). They simply welcome each guest by name, in order, and guide them to their spot.

For Example,

def greet(name, time_of_day):
    print(f"Good {time_of_day}, {name}!")

Here, name and time_of_day are normal parameters. When you call greet("Moksh", "morning"), each argument is matched positionally to its parameter—first to first, second to second.

Okay, so what is Normal Parameter in Professional Terms ?

Normal parameters are the named placeholders inside a function definition that expect one specific value each when the function is called. Think of them as reserved seats at a function’s dinner table—each seat has a name, and each guest (argument) knows exactly where to sit.

So, You got any more good examples of it ?

Absolutely, Here’s a classic one:

def calculate_area(length, width):    # two parameters
    return length * width

area = calculate_area(5, 3)           # two arguments
print(area)                           # Output: 15

Each parameter (length, width) expects one value. No unpacking. Just direct mapping.

Can I skip a Normal Parameter while calling the function ?

Not unless you’ve given it a default value in the function definition.

def greet(name, time_of_day="morning"):
    print(f"Good {time_of_day}, {name}!")

greet("Buddy")  # Uses default "morning"

If no default is provided, skipping will trigger a TypeError.

What happens if I pass too few or too many arguments ?

Same thing that your parents does when you become over-smart to them💀🩼

Python throws a TypeError— It’s strict about matching.

def greet(name, time_of_day):
    print(f"Good {time_of_day}, {name}!")

greet("Human")      `               # ❌ TypeError: missing 1 required positional argument
greet("SirJi", "morning", "extra")  # ❌ TypeError: too many positional arguments

Normal parameters are like reserved seats—no overbooking, no empty chairs.

How’s It Different from *args and **kwargs ?

• *args lets you pass any number of unnamed positional arguments.

• **kwargs lets you pass any number of named keyword arguments.

• Normal parameters? They expect exactly one value per name, in order.

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

show(1, 2, 3, name="Someone", age=21)
# args → (1, 2, 3)
# kwargs → {'name': 'Moksh', 'age': 21}

Normal Parameters don’t collect — they just recieve.

So when should I use Normal Parameters ?

Use them when:

• You know exactly what inputs your function needs.

• You want clarity and strictness.

• You’re writing beginner-friendly or predictable code.

They’re perfect for rituals that don’t need flexibility — just precision.

Beginner Mistake

1. Do Argument and Parameter Names Have to Match?

Nope. The parameter name is what’s inside the function definition. The argument name is what you pass when calling the function.

def greet(person):
    print(f"Hello, {person}!")

name = "Organism"
greet(name)  # Works fine, even though 'name' ≠ 'person'

They’re like labels on luggage and tags on seats—they don’t have to match, just arrive in the right order.

Next Article:

*args — The Argument Tsunami