Python Notes
HubHistory of Python - Complete Guide 2026Python Applications - Complete Guide 2026Python Features - Complete Guide 2026What is Python? - Complete Guide 2026Why Learn Python? - Complete Guide 2026Your First Python Program – Hello World & Beyond 2026How to Install Python on Windows, Mac & Linux – Complete Guide 2026Install VS Code for Python – Complete Setup Guide with Extensions 2026Python Environment Setup – Virtual Environments, pip & Project Structure 2026Python IDLE – Complete Guide for Beginners 2026Python CommentsPython Data TypesPython Input and OutputPython OperatorsPython SyntaxPython Strings BasicsPython Type CastingPython VariablesBreak, Continue and Pass in PythonElif Statement in PythonFor Loop in PythonIf-Else Statement in PythonIf Statement in PythonNested If in PythonPattern Programs in PythonWhile Loop in PythonDecorators in PythonFunction Arguments in PythonFunctions Basics in PythonGenerators in PythonLambda Functions in PythonRecursive Functions in PythonReturn Statement in PythonScope of Variables in PythonAbstraction in PythonClasses and Objects in PythonConstructors in PythonEncapsulation in PythonInheritance in PythonMagic Methods (Dunder Methods) in PythonMethod Overriding in PythonPolymorphism in PythonPython Comprehensions – List, Dict, Set & GeneratorPython Dictionaries – Key-Value StorePython Dictionary Methods – Complete ReferencePython List Methods – All Built-in MethodsPython Lists – Complete GuidePython Set Methods – Complete ReferencePython Sets – Unordered Unique CollectionsPython Tuples – Immutable SequencesPython Asynchronous Programming with asyncioPython Context ManagersAdvanced Python DecoratorsAdvanced Python GeneratorsPython Iterators - Advanced GuidePython Memory ManagementPython MultiprocessingPython MultithreadingCRUD Operations in Python DatabasesMySQL with Python (mysql-connector-python)ORM Introduction with SQLAlchemyPostgreSQL with Python (psycopg2)SQLite3 with PythonIntroduction to DjangoDjango Models and ORMDjango REST API with DRFDjango ViewsIntroduction to FlaskFlask RoutingFlask Templates with Jinja2Email Automation with PythonPDF Automation with PythonSelenium Web Automation with PythonTask Scheduler with PythonWeb Scraping with PythonData Analysis with PythonData Cleaning with PythonData Visualization ProjectData Visualization with MatplotlibNumPy IntroductionPandas IntroductionStatistical Visualization with SeabornClassification AlgorithmsClustering AlgorithmsIntroduction to Machine LearningMachine Learning Project: Churn PredictionModel Evaluation and SelectionRegression AlgorithmsSave pipeline (includes preprocessing + model)AI Assistant ProjectCalculator ProjectChatbot ProjectExpense Tracker ProjectFace Detection ProjectPassword Generator ProjectWeather App ProjectPython Coding Interview QuestionsPython OOP Interview Questions and AnswersPython Master CheatsheetPython Interview Questions and AnswersPython Best PracticesCommon Python Errors and SolutionsPython Debugging TechniquesPython Learning Resources
Complete guide to Python function arguments — positional, keyword, default, *args, **kwargs and their real-world use cases. Understand argument types with best practices.
A function needs data to work — this data is called Arguments and Parameters. Python has 5 types of arguments!
1️⃣ Positional Arguments (In sequence order)
Example
# ─────────────────────────────────────
# Positional Arguments — order matter karta hai!
# ─────────────────────────────────────
def introduce(name, city, profession):
"""Prints the user's introduction"""
print(f"I am {name}, from {city}, and I am a {profession}.")
# Order SAHI hai ✅
introduce("Ananya", "Bangalore", "Engineer")
# Order is WRONG ❌ — city and profession got swapped
introduce("Ananya", "Engineer", "Bangalore")
Example
# OUTPUT:
Main Ananya hoon, Bangalore se hoon, aur main ek Engineer hoon.
Main Ananya hoon, Engineer se hoon, aur main ek Bangalore hoon.
Example
# ─────────────────────────────────────
# Real-world: Book details
# ─────────────────────────────────────
def show_book(title, author, year, price):
print(f"📚 {title}")
print(f" ✍️ Author : {author}")
print(f" 📅 Year : {year}")
print(f" 💰 Price : ₹{price}")
show_book("Python Crash Course", "Eric Matthes", 2019, 799)
show_book("Fluent Python", "Luciano Ramalho", 2022, 1299)
| ✍️ Author | Eric Matthes |
| 📅 Year | 2019 |
| 💰 Price | ₹799 |
| ✍️ Author | Luciano Ramalho |
| 📅 Year | 2022 |
| 💰 Price | ₹1299 |
2️⃣ Keyword Arguments (Passing by name)
Example
# ─────────────────────────────────────
# Keyword Arguments — naam se dena
# ─────────────────────────────────────
def order_food(item, quantity, size):
print(f"🍕 Order: {quantity}x {size} {item}")
# Positional
order_food("Pizza", 2, "Large")
# Keyword — order can be anything!
order_food(size="Medium", item="Burger", quantity=3)
order_food(item="Pasta", size="Small", quantity=1)
| 🍕 Order | 2x Large Pizza |
| 🍕 Order | 3x Medium Burger |
| 🍕 Order | 1x Small Pasta |
Example
# ─────────────────────────────────────
# Mixed: Positional + Keyword
# ─────────────────────────────────────
def send_email(to, subject, body, cc=""):
print(f"📧 To : {to}")
print(f" Subject : {subject}")
print(f" Body : {body[:50]}...")
if cc:
print(f" CC : {cc}")
# Positional first, keyword after
send_email(
"rahul@example.com",
"Python Class Tomorrow",
body="Kal subah 10 baje class hogi. Sab log attend karein.",
cc="priya@example.com"
)
| 📧 To | rahul@example.com |
| Subject | Python Class Tomorrow |
| Body | Kal subah 10 baje class hogi. Sab log attend ka... |
| CC | priya@example.com |
3️⃣ Default Arguments (Default Values)
Example
# ─────────────────────────────────────
# Default Arguments — already set values
# ─────────────────────────────────────
def create_profile(name, age, country="India", language="Hindi"):
"""
User profile create karta hai.
country aur language ke liye default values hain.
"""
print(f"👤 Name : {name}")
print(f" Age : {age}")
print(f" Country : {country}")
print(f" Language : {language}")
print()
# Default values use karenge
create_profile("Deepak", 25)
# Override the default
create_profile("Alex", 30, country="USA", language="English")
# Override only one default
create_profile("Fatima", 28, country="UAE")
| 👤 Name | Deepak |
| Age | 25 |
| Country | India |
| Language | Hindi |
| 👤 Name | Alex |
| Age | 30 |
| Country | USA |
| Language | English |
| 👤 Name | Fatima |
| Age | 28 |
| Country | UAE |
| Language | Hindi |
⚠️ Default Arguments ka Order (Important!)
Example
# ─────────────────────────────────────
# RULE: Default arguments come AFTER non-default ones
# ─────────────────────────────────────
# ✅ SAHI
def func1(a, b, c=10):
pass
def func2(a, b=5, c=10):
pass
# ❌ GALAT — SyntaxError aayega
# def func3(a=1, b, c): # Error!
# pass
⚠️ Mutable Default Arguments — Common Pitfall!
Example
# ─────────────────────────────────────
# DANGER: Mutable default argument trap
# ─────────────────────────────────────
# ❌ BAD — list as default (yeh bug create karta hai!)
def add_item_bad(item, shopping_list=[]):
shopping_list.append(item)
return shopping_list
print(add_item_bad("milk")) # ['milk']
print(add_item_bad("eggs")) # ['milk', 'eggs'] ← Bug! Pichli list reuse ho gayi
print(add_item_bad("bread")) # ['milk', 'eggs', 'bread'] ← Aur bada bug!
print()
# ✅ GOOD — Use None, create list inside
def add_item_good(item, shopping_list=None):
if shopping_list is None:
shopping_list = [] # Har call pe fresh list
shopping_list.append(item)
return shopping_list
print(add_item_good("milk")) # ['milk']
print(add_item_good("eggs")) # ['eggs'] ← Alag list!
print(add_item_good("bread")) # ['bread'] ← Alag list!
Example
# OUTPUT:
['milk']
['milk', 'eggs']
['milk', 'eggs', 'bread']
['milk']
['eggs']
['bread']
4️⃣ *args — Variable Positional Arguments
Example
# ─────────────────────────────────────
# *args — any number of positional arguments
# ─────────────────────────────────────
def add_all(*numbers):
"""
Kitne bhi numbers add kar sakta hai.
*numbers ek TUPLE ban jaata hai andar.
"""
print(f"Numbers received: {numbers}")
print(f"Type: {type(numbers)}")
return sum(numbers)
print(add_all(1, 2)) # 3
print(add_all(1, 2, 3, 4, 5)) # 15
print(add_all(10, 20, 30)) # 60
| Numbers received | (1, 2) |
| Type | <class 'tuple'> |
| Numbers received | (1, 2, 3, 4, 5) |
| Type | <class 'tuple'> |
| Numbers received | (10, 20, 30) |
| Type | <class 'tuple'> |
Example
# ─────────────────────────────────────
# *args with loop
# ─────────────────────────────────────
def print_menu(restaurant_name, *dishes):
"""Prints the restaurant menu"""
print(f"\n🍽️ {restaurant_name} — Today's Menu")
print("=" * 35)
for i, dish in enumerate(dishes, 1):
print(f" {i}. {dish}")
print(f"\n Total items: {len(dishes)}")
print_menu("Sharma Ji ka Dhaba", "Dal Makhani", "Butter Naan", "Paneer Tikka")
print_menu("Pizza Hub", "Margherita", "BBQ Chicken", "Veggie Delight", "Cheese Burst")
Example
# OUTPUT:
🍽️ Sharma Ji ka Dhaba — Today's Menu
===================================
1. Dal Makhani
2. Butter Naan
3. Paneer Tikka
Total items: 3
🍽️ Pizza Hub — Today's Menu
===================================
1. Margherita
2. BBQ Chicken
3. Veggie Delight
4. Cheese Burst
Total items: 4
Example
# ─────────────────────────────────────
# Regular + *args combination
# ─────────────────────────────────────
def create_team(team_name, leader, *members):
print(f"\n🏢 Team: {team_name}")
print(f"👑 Leader: {leader}")
print(f"👥 Members:")
for m in members:
print(f" • {m}")
print(f"📊 Total: {1 + len(members)} people")
create_team("Team Alpha", "Rajesh", "Sunita", "Mohan", "Geeta", "Vijay")
| 🏢 Team | Team Alpha |
| 👑 Leader | Rajesh |
| 📊 Total | 5 people |
5️⃣ **kwargs — Variable Keyword Arguments
Example
# ─────────────────────────────────────
# **kwargs — any number of keyword arguments
# **kwargs ek DICTIONARY ban jaata hai andar
# ─────────────────────────────────────
def build_profile(**info):
"""
Kisi bhi user ka profile build karta hai.
**info ek dictionary ban jaata hai.
"""
print(f"Type: {type(info)}")
print(f"Data: {info}")
print("\n👤 Profile:")
for key, value in info.items():
print(f" {key.capitalize()}: {value}")
build_profile(name="Kavya", age=24, city="Hyderabad", hobby="Coding")
| Type | <class 'dict'> |
| Data | {'name': 'Kavya', 'age': 24, 'city': 'Hyderabad', 'hobby': 'Coding'} |
| Name | Kavya |
| Age | 24 |
| City | Hyderabad |
| Hobby | Coding |
Example
# ─────────────────────────────────────
# **kwargs real-world: HTML Tag Builder
# ─────────────────────────────────────
def build_html_tag(tag, content, **attributes):
"""
HTML tag generate karta hai.
Attributes dynamically add hote hain.
"""
attr_str = ""
for key, val in attributes.items():
attr_str += f' {key}="{val}"'
return f"<{tag}{attr_str}>{content}</{tag}>"
# Simple use
print(build_html_tag("p", "Hello World"))
# With attributes
print(build_html_tag("a", "Click Here", href="https://wohotech.in", target="_blank"))
# Image tag
print(build_html_tag("img", "", src="logo.png", width="200", height="100", alt="Logo"))
# Styled div
print(build_html_tag("div", "Welcome!", id="main", class_name="container", style="color:blue"))
Example
# OUTPUT:
<p>Hello World</p>
<a href="https://wohotech.in" target="_blank">Click Here</a>
<img src="logo.png" width="200" height="100" alt="Logo"></img>
<div id="main" class_name="container" style="color:blue">Welcome!</div>
🔀 Combining All Argument Types
Example
# ─────────────────────────────────────
# Correct ORDER: positional, *args, default, **kwargs
# ─────────────────────────────────────
#
# def func(pos1, pos2, *args, key=val, **kwargs):
# │ │ │ │ │
# │ │ │ │ └── Variable keyword args
# │ │ │ └─────────── Keyword-only default
# │ │ └────────────────── Variable positional
# │ └──────────────────────── Positional
# └─────────────────────────────── Positional
#
def complete_order(customer_name, *items, discount=0, **extras):
"""
Complete order function with all argument types
"""
print(f"\n🛒 Order for: {customer_name}")
print(f"📦 Items:")
for item in items:
print(f" • {item}")
subtotal = len(items) * 100 # ₹100 per item (demo)
if discount:
saved = subtotal * discount / 100
total = subtotal - saved
print(f"💸 Subtotal : ₹{subtotal}")
print(f"🏷️ Discount : {discount}% (saves ₹{saved:.0f})")
print(f"✅ Total : ₹{total:.0f}")
else:
print(f"✅ Total : ₹{subtotal}")
if extras:
print(f"📝 Notes:")
for k, v in extras.items():
print(f" {k}: {v}")
# Call karo
complete_order(
"Meera", # positional
"Python Book", # *items start
"Notebook",
"Pen Set", # *items end
discount=10, # keyword-only
delivery="Express", # **extras start
note="Handle with care" # **extras end
)
| 🛒 Order for | Meera |
| 💸 Subtotal | ₹300 |
| 🏷️ Discount | 10% (saves ₹30) |
| ✅ Total | ₹270 |
| delivery | Express |
| note | Handle with care |
📦 Argument Unpacking (Spread Operator)
Example
# ─────────────────────────────────────
# Unpacking a List/Tuple — * operator
# ─────────────────────────────────────
def add_three(a, b, c):
return a + b + c
numbers = [10, 20, 30]
# result = add_three(numbers) # ❌ Error — list as single argument
result = add_three(*numbers) # ✅ Unpack karo
print(f"Sum: {result}") # 60
# With Tuple
coords = (3, 4, 5)
print(add_three(*coords)) # 12
Example
# ─────────────────────────────────────
# Unpacking a Dict — ** operator
# ─────────────────────────────────────
def greet_user(name, age, city):
print(f"Hello {name}! Age: {age}, City: {city}")
user_data = {"name": "Suresh", "age": 28, "city": "Chennai"}
greet_user(**user_data) # Dict unpack!
Example
# OUTPUT:
Sum: 60
12
Hello Suresh! Age: 28, City: Chennai
🔒 Keyword-Only Arguments (Python 3+)
Example
# ─────────────────────────────────────
# After *, only keyword arguments are allowed
# ─────────────────────────────────────
def create_user(name, age, *, role="user", active=True):
"""
* ke baad role aur active SIRF keyword se de sakte hain.
Positional se nahi de sakte.
"""
print(f"User: {name}, Age: {age}, Role: {role}, Active: {active}")
# ✅ Sahi
create_user("Arjun", 25)
create_user("Arjun", 25, role="admin")
create_user("Arjun", 25, role="moderator", active=False)
# ❌ Galat — TypeError
# create_user("Arjun", 25, "admin") # Error!
| User | Arjun, Age: 25, Role: user, Active: True |
| User | Arjun, Age: 25, Role: admin, Active: True |
| User | Arjun, Age: 25, Role: moderator, Active: False |
🔢 Type Hints with Arguments (Python 3.5+)
Example
# ─────────────────────────────────────
# Type hints — code readable banta hai
# ─────────────────────────────────────
def calculate_emi(principal: float, rate: float, months: int) -> float:
"""
EMI calculate karta hai.
Args:
principal: Loan amount (₹)
rate: Annual interest rate (%)
months: Loan duration in months
Returns:
Monthly EMI amount
"""
monthly_rate = rate / (12 * 100)
emi = (principal * monthly_rate * (1 + monthly_rate) ** months) / \
((1 + monthly_rate) ** months - 1)
return round(emi, 2)
# Home loan example
home_loan = calculate_emi(
principal=5_000_000, # ₹50 lakh
rate=8.5, # 8.5% annual
months=240 # 20 years
)
print(f"🏠 Home Loan EMI: ₹{home_loan:,.2f}/month")
# Car loan example
car_loan = calculate_emi(
principal=800_000, # ₹8 lakh
rate=9.0,
months=60 # 5 years
)
print(f"🚗 Car Loan EMI: ₹{car_loan:,.2f}/month")
Example
# OUTPUT:
🏠 Home Loan EMI: ₹43,391.16/month
🚗 Car Loan EMI: ₹16,607.45/month
📊 Arguments Summary Diagram
| Type | Example |
|---|---|
| Positional | func(1, 2, 3) |
| Order MUST match parameters | |
| Keyword | func(a=1, b=2) |
| Order doesn't matter | |
| Default | def func(a, b=10) |
| Optional — has a fallback value | |
| *args | def func(*args) → tuple |
| Unlimited positional args | |
| **kwargs | def func(**kwargs) → dict |
| Unlimited keyword args |
❓ Interview Questions
Q1: What is the difference between *args and **kwargs?
-*args— takes variable positional arguments, stores in a tuple -kwargs— takes variable keyword arguments, stores in a dictionary**
Q2: Can we use only *args or only **kwargs?
python example
def only_args(*args): # ✅ Sirf *args
print(args)
def only_kwargs(**kwargs): # ✅ Sirf **kwargs
print(kwargs)
def both(*args, **kwargs): # ✅ Dono saath
print(args, kwargs)Q3: What is the mutable default argument bug and how to fix it?
python example
# Bug
def bad(lst=[]):
lst.append(1)
return lst
# Fix
def good(lst=None):
if lst is None:
lst = []
lst.append(1)
return lstQ4: How to force keyword-only arguments?
python example
# Parameters after * can only be passed by keyword
def func(a, b, *, c, d=10):
print(a, b, c, d)
func(1, 2, c=3) # ✅
# func(1, 2, 3) # ❌ TypeErrorQ5: How to check a function signature?
python example
import inspect
def my_func(a, b, c=10, *args, **kwargs):
pass
sig = inspect.signature(my_func)
print(sig) # (a, b, c=10, *args, **kwargs)
for name, param in sig.parameters.items():
print(f"{name}: {param.kind.name}")📋 Quick Reference
Example
# ─────────────────────────────────────
# CHEAT SHEET: All argument types
# ─────────────────────────────────────
def super_function(
req_arg, # Required positional
another_req, # Required positional
*args, # Optional: extra positional → tuple
keyword_only, # Keyword-only (required)
optional_kw=42, # Keyword-only (optional, has default)
**kwargs # Optional: extra keyword → dict
):
print(f"req_arg = {req_arg}")
print(f"another_req = {another_req}")
print(f"args = {args}")
print(f"keyword_only = {keyword_only}")
print(f"optional_kw = {optional_kw}")
print(f"kwargs = {kwargs}")
super_function(
"hello",
"world",
"extra1", "extra2",
keyword_only="required!",
optional_kw=99,
custom_key="custom_val"
)
Example
# OUTPUT:
req_arg = hello
another_req = world
args = ('extra1', 'extra2')
keyword_only = required!
optional_kw = 99
kwargs = {'custom_key': 'custom_val'}
🚀 Next: For an in-depth guide on Return Statement, see return-statement.mdx!⚠️ Common Mistakes
❌ Mistake 1: Giving Positional after Keyword, then back to Positional
python example
def greet(name, age, city):
print(f"{name}, {age}, {city}")
# ❌ WRONG — positional argument cannot come after keyword
# greet("Rahul", age=25, "Delhi") # SyntaxError!
# ✅ CORRECT — positional first, keyword after
greet("Rahul", age=25, city="Delhi")Example
# OUTPUT:
Rahul, 25, Delhi
💡 Rule: Once you start giving keyword arguments, only keyword arguments can follow. You cannot go back to positional!
❌ Mistake 2: Mutable Default Argument use karna (List/Dict)
Example
# ❌ BAD — same list is reused in every call
def add_student(name, students=[]):
students.append(name)
return students
print(add_student("Aman")) # ['Aman']
print(add_student("Priya")) # ['Aman', 'Priya'] 😱 Bug!
# ✅ GOOD — None use karo
def add_student_fixed(name, students=None):
if students is None:
students = []
students.append(name)
return students
print(add_student_fixed("Aman")) # ['Aman']
print(add_student_fixed("Priya")) # ['Priya'] ✅ Fresh list!
Example
# OUTPUT:
['Aman']
['Aman', 'Priya']
['Aman']
['Priya']
💡 Remember: Never put List, Dict, Set directly as a default argument. Always use None and create inside.❌ Mistake 3: Treating *args like a Keyword argument
python example
def show(*args):
print(args)
# ❌ WRONG — *args only takes positional values
# show(name="Rahul") # TypeError: got an unexpected keyword argument 'name'
# ✅ SAHI
show("Rahul", 25, "Delhi")Example
# OUTPUT:
('Rahul', 25, 'Delhi')
💡 Understand the difference:*args= positional values (tuple),**kwargs= keyword values (dict). Don't mix them!
❌ Mistake 4: Placing Default argument before Non-default
python example
# ❌ GALAT — SyntaxError aayega
# def register(country="India", name, age):
# pass
# SyntaxError: non-default argument follows default argument
# ✅ CORRECT — defaults always come after
def register(name, age, country="India"):
print(f"{name}, {age}, {country}")
register("Amit", 22)Example
# OUTPUT:
Amit, 22, India
❌ Mistake 5: Giving the same argument both ways (Positional + Keyword)
python example
def info(name, age):
print(f"{name} is {age}")
# ❌ WRONG — 'name' given twice
# info("Rahul", name="Rahul")
# TypeError: info() got multiple values for argument 'name'
# ✅ CORRECT — give only once
info("Rahul", age=25)Example
# OUTPUT:
Rahul is 25
❌ Mistake 6: **kwargs mein invalid identifier dena
python example
def show_info(**kwargs):
for k, v in kwargs.items():
print(f"{k}: {v}")
# ❌ WRONG — spaces or special chars cannot directly appear in key names
# show_info(first name="Rahul") # SyntaxError
# ✅ CORRECT — use only valid Python identifiers
show_info(first_name="Rahul", last_name="Sharma")Example
# OUTPUT:
first_name: Rahul
last_name: Sharma
❌ Mistake 7: Putting *args and **kwargs in wrong order
python example
# ❌ WRONG — **kwargs first, *args after is not allowed
# def func(**kwargs, *args): # SyntaxError!
# pass
# ✅ SAHI ORDER: positional → *args → keyword-only → **kwargs
def func(a, b, *args, key="default", **kwargs):
print(f"a={a}, b={b}, args={args}, key={key}, kwargs={kwargs}")
func(1, 2, 3, 4, key="custom", extra="hello")Example
# OUTPUT:
a=1, b=2, args=(3, 4), key=custom, kwargs={'extra': 'hello'}
✅ Key Takeaways
- 📌 Parameter is in the function definition, Argument is given in the function call — both are different concepts!
- 1️⃣ Positional Arguments — order matters — wrong order = wrong output. Like writing a phone number in the name field of a form!
- 2️⃣ Keyword Arguments — values are passed by name — order can be anything. This makes code readable and safe.
- 3️⃣ Default Arguments provide optional values — if the user doesn't provide one, a fallback value is used. But beware of mutable defaults (list/dict)!
- 4️⃣ **
*argspacks unlimited positional arguments into a tuple** — when you don't know how many values will come.
- 5️⃣
kwargs packs unlimited keyword arguments into a dictionary** — when you don't know how many named values will come.
- 🔐 Keyword-only arguments — use
*separator to force them — this prevents users from accidentally passing them positionally.
- 📦 Argument Unpacking:
*listunpacks into positional arguments,**dictunpacks into keyword arguments — you can directly call functions from existing data.
- 📏 Order Rule:
positional → *args → keyword-only → **kwargs— yeh sequence kabhi break mat karo!
- 🎯 Type Hints — use them with arguments — code becomes readable and you get autocomplete in the IDE. Must-have for production code!
❓ FAQ
Q1: Is it necessary to name *args exactly "args"?
No! In *args, args is just a convention. You can give any name — what matters is the * (asterisk) operator. Example: *numbers, *items — all valid.
Q2: Can *args and **kwargs be used together?
Yes, absolutely! Both can be used together. Remember the order: *args first, **kwargs after.
python example
def flexible(*args, **kwargs):
print(f"Positional: {args}")
print(f"Keyword: {kwargs}")
flexible(1, 2, 3, name="Rahul", age=25)Example
# OUTPUT:
Positional: (1, 2, 3)
Keyword: {'name': 'Rahul', 'age': 25}
Q3: Can a function call be given as a default argument? Like def f(x=len([1,2]))?
Yes, you can — but note that this value is evaluated at function definition time, not on every call! If you need dynamic evaluation, use None as default and calculate inside the function.
Q4: Positional-only arguments kya hain? (Python 3.8+)
Python 3.8 introduced the / separator — arguments before it can only be passed positionally:
python example
def divide(a, b, /):
return a / b
print(divide(10, 2)) # ✅ Positional se — works!
# print(divide(a=10, b=2)) # ❌ Keyword se — TypeError!Example
# OUTPUT:
5.0
Q5: Why is *args a tuple and not a list?
Tuple is immutable — meaning it cannot be accidentally modified inside the function. This is a safety measure. If you need to modify, convert to list: args = list(args).
Q6: Do unlimited arguments in a function create performance issues?
Normally no. Python tuples and dicts are very optimized. But if you're passing hundreds of thousands of arguments (which is a rare case), memory usage can increase. In normal use (10-100 args), there's no performance issue.
Q7: Is key order maintained in kwargs?
Yes! In Python 3.7+, dictionaries maintain insertion order. So in **kwargs, arguments are received in the same order they were given.
Q8: Can we directly index *args?
Yes! *args is a tuple, so indexing works:
Example
def first_and_last(*args):
if args:
print(f"First: {args[0]}, Last: {args[-1]}")
first_and_last("A", "B", "C", "D")
Example
# OUTPUT:
First: A, Last: D
🎯 Interview Questions
Q1: What is the fundamental difference between *args and **kwargs?
Answer:*argscollects variable-length positional arguments into a tuple, whilekwargscollects variable-length keyword arguments into a dictionary**. In*args, values come without names; in**kwargs, each value has a key (name).
Q2: What is the mutable default argument trap? How to avoid it in production code?
Answer: When you use a mutable object (list, dict, set) as a default value, that object is created once at function definition time and is shared across all calls. Fix: UseNoneas default and doif param is None: param = []in the function body. This is Python's most common gotcha.
Q3: What is the real-world use case of Keyword-only and Positional-only parameters?
Answer: Keyword-only (after*): When you want users to explicitly name them — prevents accidental wrong ordering (e.g.,sorted(data, *, key=func, reverse=True)). Positional-only (before/): When the parameter name is an implementation detail and may change in the future (e.g.,len(obj, /)— Python built-ins use this).
Q4: How does argument unpacking (* and **) work in a function call?
Answer:*iterableunpacks a list/tuple into individual positional arguments.**dictunpacks a dictionary into individual keyword arguments. Example:func(*[1,2,3])is the same asfunc(1,2,3). This is powerful for dynamic function calling — when arguments are decided at runtime.
Q5: How to achieve function overloading in Python through arguments?
Answer: Python doesn't have traditional function overloading (like Java/C++). Alternatives: (1) Default arguments for optional params, (2)*args/**kwargsfor flexible signatures, (3)functools.singledispatchdecorator, (4) Type checking inside function. The most Pythonic way is default args +*args/**kwargs.
Q6: What is the use of inspect.signature() in real projects?
Answer: inspect.signature() provides complete parameter info for a function — names, types, defaults, kinds (POSITIONAL_ONLY, KEYWORD_ONLY, etc.). Real uses: (1) Auto-generation of documentation, (2) Writing decorators that preserve the original signature, (3) API frameworks like FastAPI/Flask that map URL parameters to function params, (4) Testing/validation tools.Q7: If a parameter comes after *args, what does it become?
Answer: Any parameter that comes after*argsautomatically becomes a keyword-only argument. Users must provide that value by name only, they cannot pass it positionally. Example:def func(*args, separator="-")— hereseparatorcan only be given asfunc(1, 2, separator="/").
Q8: Python mein pass-by-value hai ya pass-by-reference?
Answer: Python uses pass-by-object-reference (or "pass-by-assignment"). Meaning: the function receives a reference to the object. For immutable objects (int, str, tuple), it appears like pass-by-value (since they can't be modified). For mutable objects (list, dict), it appears like pass-by-reference (since they can be modified in-place). Technically, variable reassignment doesn't affect the original, but mutation does.
Q9: How to forward **kwargs to another function?
Answer: Simply unpack and pass with kwargs. This is very common in decorator patterns and wrapper functions**:python example
def wrapper(*args, **kwargs):
print("Before call")
result = actual_function(*args, **kwargs)
print("After call")
return resultThis pattern is extensively used in decorators, middleware, and proxy functions.
Q10: What is the maximum number of arguments a function can have?
Answer: In Python 3.7+, there was technically a limit of 255 positional arguments in theCALL_FUNCTIONbytecode instruction, but in Python 3.8+ this limit has been effectively removed. With*argsand**kwargs, you can practically pass unlimited arguments — memory is the only limit. But in clean code, if you have more than 5-7 parameters, you should usually use a class/dataclass.
🚀 Next: For an in-depth guide on Return Statement, see return-statement.mdx!Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Function Arguments in Python.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Python Master Course topic.
Search Terms
python-master-course, python master course, python, master, course, functions, function, arguments
Related Python Master Course Topics
Continue learning this concept
FunctionsDecorators in PythonDetailed guide to Python decorators — function decorators, class decorators, stacking, functools.wraps, and real-world use cases. Learn with examples and best practices.FunctionsFunctions Basics in PythonPython mein functions ki complete guide — definition, calling, types, aur best practices. Samjho functions ka syntax, purpose, aur real-world usage Hindi explanations ke saath.FunctionsGenerators in PythonPython generators ki detailed guide — yield keyword, generator functions, generator expressions, send/throw/close, aur real-world use cases jaise infinite sequences, data pipelines, aur memory-efficient file processing. Hindi mein.FunctionsLambda Functions in PythonComplete guide to Python lambda functions — syntax, use cases, usage with map/filter/sorted, and comparison with regular functions. Learn with practical examples.FunctionsRecursive Functions in PythonPython mein recursion ki complete guide — base case, recursive case, call stack, fibonacci, factorial, binary search aur tree traversal ke saath Hindi explanations.FunctionsReturn Statement in PythonPython mein return statement ki poori guide — single/multiple return values, early return, None return, aur real-world patterns. Hindi mein samjho return ke saare use cases.