Default arguments in Python

Python allows function arguments to have default values. If the function is called without the argument, the argument gets its default value.

Default Arguments: 

Python has a different way of representing syntax and default values for function arguments. Default values indicate that the function argument will take that value if no argument value is passed during the function call. The default value is assigned by using the assignment(=) operator of the form keywordname=value.
Syntax:

def function_name(param1, param2=default_value2, param3=default_value3)

Let’s understand this through a function student. The function student contains 3-arguments out of which 2 arguments are assigned with default values. So, the function student accepts one required argument (firstname), and rest two arguments are optional. 
 

def student(firstname, lastname ='Mark', standard ='Fifth'):

     print(firstname, lastname, 'studies in', standard, 'Standard')

  
We need to keep the following points in mind while calling functions: 

1. In the case of passing the keyword arguments, the order of arguments is not important.
2. There should be only one value for one parameter.
3. The passed keyword name should match with the actual keyword name.
4. In the case of calling a function containing non-keyword arguments, the order is important.

Example #1: Calling functions without keyword arguments 
 

def student(firstname, lastname ='Mark', standard ='Fifth'):
     print(firstname, lastname, 'studies in', standard, 'Standard')

# 1 positional argument
student('John') 

# 3 positional arguments                         
student('John', 'Gates', 'Seventh')     

# 2 positional arguments  
student('John', 'Gates')                  
student('John', 'Seventh')

Output: 
 

John Mark studies in Fifth Standard
John Gates studies in Seventh Standard
John Gates studies in Fifth Standard
John Seventh studies in Fifth Standard

In the first call, there is only one required argument and the rest arguments use the default values. In the second call, lastname and standard arguments value is replaced from default value to new passing value. We can see the order of arguments is important from the 2nd, 3rd, and 4th calls of the function. 
  
Example #2: Calling functions with keyword arguments 
 

def student(firstname, lastname ='Mark', standard ='Fifth'):
     print(firstname, lastname, 'studies in', standard, 'Standard')

# 1 keyword argument
student(firstname ='John')     

# 2 keyword arguments                 
student(firstname ='John', standard ='Seventh')  

# 2 keyword arguments 
student(lastname ='Gates', firstname ='John')     

Output: 
 

John Mark studies in Fifth Standard
John Mark studies in Seventh Standard
John Gates studies in Fifth Standard

In the first call, there is only one required keyword argument. In the second call, one is a required argument and one is optional(standard), whose value gets replaced from default to a new passing value. In the third call, we can see that order in keyword argument is not important. 
  
Example #3: Some Invalid function calls 
 

def student(firstname, lastname ='Mark', standard ='Fifth'):
     print(firstname, lastname, 'studies in', standard, 'Standard')

# required argument missing
student()                

# non keyword argument after a keyword argument              
student(firstname ='John', 'Seventh') 

# unknown keyword argument 
student(subject ='Maths')              

The above code will throw an error because:
 

• In the first call, value is not passed for parameter firstname which is the required parameter.
• In the second call, there is a non-keyword argument after a keyword argument.
• In the third call, the passing keyword argument is not matched with the actual keyword name arguments.

Using mutable objects as default argument values in python

This must be done very carefully. The reason is the default values of the arguments are evaluated only once when the control reaches the function

Definition for the first time. After that, the same values(or mutable objects) are referenced in the subsequent function calls. 
Things will be much more clear with the example

# mutable default argument values example using python list

# itemName is the name of the item that we want to add to list
# that is being passed, or if it is not passed then appending in 
# the default list

def appendItem(itemName, itemList = []):
    itemList.append(itemName)
    return itemList


print(appendItem('notebook'))
print(appendItem('pencil'))
print(appendItem('eraser'))

['notebook']
['notebook', 'pencil']
['notebook', 'pencil', 'eraser']

What you have expected if you assume that a new list is created in each function call when we don’t pass a list to it

[‘notebook’]

[‘pencil’]

[‘eraser’]

But as you can see in the actual output of the program every time the function is called, the same list is used, no new list is made on a new call. 

Example using dictionary

# mutable default argument values example using python dictionary

# itemName is the name of item and quantity is the number of such
# items are there


def addItemToDictionary(itemName, quantity, itemList = {}):
    itemList[itemName] = quantity
    return itemList


print(addItemToDictionary('notebook', 4))
print(addItemToDictionary('pencil', 1))
print(addItemToDictionary('eraser', 1))

{'notebook': 4}
{'notebook': 4, 'pencil': 1}
{'notebook': 4, 'pencil': 1, 'eraser': 1}

What you have expected if you assume that a new dictionary is created in each function call

{‘notebook’: 4}

{‘pencil’: 1}

{‘eraser’: 1}

But you can clearly see the actual output of the program is different and it indicates the use of the same dictionary in each subsequent call.

The key takeaway here is we should avoid such scenarios.

Best Practices

Assign the default value as none and then check in the function if the expected list or dictionary argument is none or not.

If it is none then assign it with a list or dictionary depending on your requirement.

# using None as values of the default arguments

print('#list')
def appendItem(itemName, itemList=None):
    if itemList == None:
          itemList = []
    itemList.append(itemName)
    return itemList


print(appendItem('notebook'))
print(appendItem('pencil'))
print(appendItem('eraser'))


# using None as value of default parameter

print('\n\n#dictionary')
def addItemToDictionary(itemName, quantity, itemList = None):
    if itemList == None:
        itemList = {}
    itemList[itemName] = quantity
    return itemList


print(addItemToDictionary('notebook', 4))
print(addItemToDictionary('pencil', 1))
print(addItemToDictionary('eraser', 1))

#list
['notebook']
['pencil']
['eraser']


#dictionary
{'notebook': 4}
{'pencil': 1}
{'eraser': 1}

Here you can clearly see that every time a function is called and a list or dictionary is not passed as an argument to the function then it creates a new list or dictionary.

Default arguments in Python – FAQs

What is type with 3 arguments in Python?

The type() function with 3 arguments is used to dynamically create a new class. The arguments are:

1. Name: The name of the class.
2. Bases: A tuple of base classes from which the new class inherits.
3. Dict: A dictionary containing the class attributes and methods.

Example:

MyClass = type('MyClass', (object,), {'attr': 5, 'method': lambda self: self.attr})
instance = MyClass()
print(instance.attr)  # Output: 5
print(instance.method())  # Output: 5

What are the 4 main data types in Python?

The four main data types in Python are:

1. int: Integer type for whole numbers.
2. float: Floating-point type for decimal numbers.
3. str: String type for text data.
4. list: List type for ordered, mutable collections of items.

Example:

number = 10       # int
pi = 3.14         # float
name = "Alice"    # str
items = [1, 2, 3] # list

What is the default argument in a class method in Python?

The default argument in a class method is typically cls, which refers to the class itself rather than an instance of the class. It allows access to class variables and methods.

Example:

class MyClass:
    @classmethod
    def class_method(cls):
        print(f"Class name: {cls.__name__}")

MyClass.class_method()  # Output: Class name: MyClass

What is the default argument pointer?

In Python, there is no explicit “default argument pointer.” However, default arguments in functions or methods allow you to specify a default value for parameters if no value is provided.

Example:

def greet(name="World"):
    print(f"Hello, {name}!")

greet()       # Output: Hello, World!
greet("Alice") # Output: Hello, Alice!

What’s true about a default argument?

A default argument in Python:

• Can be assigned a value that is used if no argument is provided.
• Must be immutable types like numbers, strings, or tuples; mutable types like lists or dictionaries can lead to unexpected behavior.
• Is evaluated only once when the function is defined, not each time the function is called.

Example:

def append_to_list(element, my_list=[]):  # Mutable default argument
    my_list.append(element)
    return my_list

print(append_to_list(1))  # Output: [1]
print(append_to_list(2))  # Output: [1, 2]  # List persists across calls

P

priyankagujral

Follow

Improve

Article Tags :

• Python
• Python-Functions

Practice Tags :

• python
• python-functions