What is the difference between default parameters and positional parameters in Python ? Also give an example o

Question 42 of 97

Q. What is the difference between default parameters and positional parameters in Python ? Also give an example of a function header which uses both.

CBSECBSE Class XII Board 2026Subjective· 2mImportance★★★★★

43% · 42/97 Questions

🔒 Locked · start free trial →

You're viewing a preview — the full solution, concept, methods & PYQ mapping are locked.

Start your 14-day free trial to unlock the full solution →

The key idea is how arguments are assigned to parameters when a function is called.

Positional parameters must be supplied in the exact order they appear in the function definition. Default parameters have a default value assigned in the header; if the caller omits that argument, the default is used. Default parameters must always come after all positional parameters in the definition.

Example function header using both:

def create_profile(name, age, city="Unknown"):
``` …

Start your 14-day free trial to unlock the full solution →

Default parameters have pre-assigned values used when no argument is passed; positional parameters must receive an argument in the correct order. A function header like def greet(name, greeting="Hello") uses both — name is positional, greeting is default.

The core idea

When you define a function in Python, you decide which inputs are mandatory and which are optional. Positional parameters are the mandatory ones — the caller must supply a value for each, in the exact order they appear. Default parameters are optional — they already have a value baked in, so the caller can skip them if the default works.

Think of it like ordering at a restaurant. The positional parameter is the dish you must choose (e.g., "pasta"). The default parameter is like asking for extra cheese — if you say nothing, you get no extra cheese; but you can override it by saying "yes, please."

Step-by-step breakdown

Positional parameters

These are the parameters listed first in the function definition. They get their values from the arguments passed in the same left-to-right order. Every positional parameter must be supplied an argument — there is no fallback value.

Example:
```
def add(a, b):
    return a + b
```
Here, a and b are positional. Calling add(5) would raise a TypeError because b is missing.
Default parameters

These are assigned a default value in the function header using the = operator. If the caller omits that argument, the default is used. If they do pass a value, it overrides the default.

Example:
```
def power(base, exp=2):
    return base ** exp
```
exp has default 2. So power(3) returns 3 ** 2, which is 9, while power(3, 3) returns 3 ** 3, which is 27.
The key difference
- Positional: required, no default, order matters.
- Default: optional, has a default, can be omitted. Python enforces that all positional parameters come before any default parameters in the function header. This is not just convention — it's a syntax rule. If you write def f(a=1, b):, Python will raise a SyntaxError.

Watch out

A common mistake is to think default parameters are evaluated once at definition time, not each time the function is called. This matters for mutable defaults like lists or dictionaries. For example:

def append_to(item, lst=[]):
    lst.append(item)
    return lst
``` …

Start your 14-day free trial to unlock the full solution →

Same / Similar Concept — real previous-year questions on the same or a closely similar concept, not this exact question.

CBSE 2026Set 91/41 markMCQ
$Q. What will be the output of the following code ? def f1(a,b=1): print(a+b,end='-') c=f1(1,2) print(c,sep='') (A) 3-2 (B) 3-2 (C) 3-None (D) 3*None-$
›Reveal solutionSolution
The function f1 prints 3- (since 1+2=3 with end='-'), then returns None implicitly, which the outer print displays — giving 3-None, option (C).

When a Python function has no explicit return, it returns None. This question tests the difference between what a function prints and what it returns, and how print handles None and its keyword arguments.

The function f1(a, b=1) computes a+b and prints it with end='-' instead of a newline. There is no return, so calling f1(1,2) prints the sum and evaluates to None, which is then assigned to c.

Trace of the execution:

Call f1(1, 2) — inside, a=1 and b=2, so a+b is 3.

print(a+b, end='-') — outputs 3 and, instead of a newline, ends with -. So far the console shows:

3-

Function returns None — with no return statement, f1 returns None, so c = f1(1,2) stores None in c. …
Start your 14-day free trial to see the full solution →
CBSE 2025Set 91/41 markMCQ
$Q. Identify the invalid Python statement out of the following options: (A) print("A",10,end="*") (B) print("A",sep="*",10) (C) print("A",10,sep="*") (D) print("A"*10)$
›Reveal solutionSolution
The invalid Python statement is print("A",sep="*",10) because a positional argument (10) cannot follow a keyword argument (sep="*") in a function call.

The print() function in Python is incredibly versatile, but it has specific rules about how you pass arguments to it. Understanding these rules, especially the distinction between positional and keyword arguments, is crucial for writing correct Python code.

When you call a function in Python, you can pass arguments in two main ways:

Positional Arguments: These are arguments whose meaning is determined by their position in the function call. For example, in print("Hello", "World"), "Hello" is the first item to print, and "World" is the second.

Keyword Arguments: These are arguments identified by a keyword (their parameter name) followed by an equals sign and a value. They are used to specify optional parameters like sep (separator) and end (what to print at the end). For example, print("A", "B", sep="-") explicitly tells print to use a hyphen as a separator.

The fundamental rule for mixing these two types of arguments is that all positional arguments must come before any keyword arguments. If you place a positional argument after a keyword argument, Python will raise a SyntaxError.

Let's examine each option:

Option (A): print("A",10,end="*")

Here, "A" and 10 are positional arguments.

end="*" is a keyword argument.

The keyword argument end="*" correctly follows all positional arguments.

This statement is valid. It will print A 10* (note the space between A and 10, which is the default separator).

Option (B): print("A",sep="*",10)

Here, "A" is a positional argument.

sep="*" is a keyword argument.

10 is another positional argument.

This statement attempts to place a positional argument (10) after a keyword argument (sep="*"). This violates Python's syntax rules.

This statement is invalid. Python would raise a SyntaxError: positional argument follows keyword argument. …
Start your 14-day free trial to see the full solution →
CBSE 2024Set 91/41 mark
$Q. State True or False: While defining a function in Python, the positional parameters in the function header must always be written after the default parameters.$
›Reveal solutionSolution
The statement is False. In Python, positional (non-default) parameters must always be written before parameters that have default values; otherwise Python raises a SyntaxError.

Concept

When a function is called, Python matches arguments to parameters from left to right. A parameter with a default value is optional, while a plain positional parameter is mandatory. If a mandatory parameter came after an optional one, Python could not tell whether a single supplied value was meant for the optional parameter or the mandatory one, so the language forbids that ordering.

Correct order

def calculate_area(length, width=10): # valid: positional first, default after return length * width

Calling calculate_area(5) gives length=5, width=10; calculate_area(5, 20) gives length=5, width=20.

The order the statement claims …
Start your 14-day free trial to see the full solution →
CBSE 2024Set 91/41 markMCQ
$Q. Observe the given Python code carefully: a=20 def convert(a): b=20 a=a+b convert(10) print(a) Select the correct output from the given options: (A) 10 (B) 20 (C) 30 (D) Error$
›Reveal solutionSolution

The output of the code is 20 because the variable a inside the function is local and does not change the global a outside it.

This question tests your understanding of how Python handles variable scope — specifically, the difference between global and local variables. The code defines a global variable a = 20, then defines a function convert(a) that takes a parameter also named a. Inside the function, a new local variable b is set to 20, and then a (the local parameter) is increased by b. The function is called with the argument 10, so inside the function, the local a starts at 10, becomes 30 after adding b, and then the function ends. The crucial point: this change affects only the local a inside the function, not the global a outside.

When the function call finishes, the program moves to the next line: print(a). At this point, a refers to the global variable, which was never modified — it remains 20. The local a that was changed to 30 is gone, as if it never existed outside the function.

Note

If the programmer had intended to modify the global a, they would have used the global keyword inside the function. Without it, any assignment to a inside the function creates or updates a local variable only. …

Start your 14-day free trial to see the full solution →
CBSE 2020Set 91/D1 mark
$Q. Write the output of the following Python code: def Update(X=10): X += 15 print('X = ', X) X=20 Update() print('X = ', X)$
›Reveal solutionSolution
Python function parameters create local scope: changes inside a function don't affect variables outside. The output is X = 25 then X = 20.

Why scope matters in Python

When you call a function with a parameter, Python creates a local variable inside that function's namespace. Any modifications to that variable stay confined to the function—they never reach back out to change variables in the outer (global) scope, even if they share the same name.

This is fundamentally about namespaces: the X inside Update and the X in the global scope are two distinct entities that happen to have the same identifier. The function parameter X shadows the global X for the duration of the function call.

Tracing the execution

Let's walk through what Python does, line by line:

Function definition

def Update(X=10): X += 15 print('X = ', X)

This defines a function Update with a default parameter value of 10 for X. The parameter X is local to this function.

Global assignment

X = 20

A global variable X is created and set to 20. This lives in the module's global namespace.

Function call

Update()

Since no argument is passed, the default value kicks in: the local X starts at 10.

Then X += 15 increments the local X to 10 + 15 = 25.

The print statement outputs:

X = 25

When the function returns, the local X is destroyed.

Global print

print('X = ', X) ``` …
Start your 14-day free trial to see the full solution →

←Previous questionQ21 — Q. Nos. 20 and 21 are Assertion (A) and Reason (R) based questions. Ma…→Next questionQ23 — Assuming that D1 is a dictionary in Python, (i) (a) Write a Python exp…

Q.What is the difference between default parameters and positional parameters in Python ? Also give an example of a function header which uses both.

Concept understanding — Python Functions, Arguments and Scope

The core idea

Step-by-step breakdown

Concept

Correct order

The order the statement claims …

Why scope matters in Python

Tracing the execution

Q.What is the difference between default parameters and positional parameters in Python ? Also give an example of a function header which uses both.

The core idea

Step-by-step breakdown

🎓Unlock everything free for 14 days

Unlock everything free for 14 days