Default values in constructors in Python - Deep Dive

Overview - Default values in constructors

What is it?

Default values in constructors are preset values given to parameters when creating an object from a class. If no value is provided during object creation, the default is used automatically. This helps make object creation flexible and simpler by not requiring all details every time. It is a way to give a class some ready-made settings while still allowing customization.

Why it matters

Without default values, every time you create an object, you must provide all details explicitly, which can be repetitive and error-prone. Default values save time and reduce mistakes by providing sensible starting points. They make your code easier to use and maintain, especially when many objects share common settings but sometimes need tweaks.

Where it fits

Before learning default values, you should understand what constructors are and how to create classes in Python. After mastering default values, you can learn about more advanced topics like method overloading, property decorators, and design patterns that use flexible object creation.

Mental Model

Core Idea

Default values in constructors act like preset options that fill in missing information when creating an object, making object creation easier and less error-prone.

Think of it like...

It's like ordering a coffee with a default size and sugar amount; if you don't specify, the barista uses the usual settings, but you can always ask for something different.

┌─────────────────────────────┐
│ Class Constructor            │
│ ┌─────────────────────────┐ │
│ │ Parameters:             │ │
│ │ - name (default: 'User')│ │
│ │ - age (default: 18)      │ │
│ └─────────────────────────┘ │
│                             │
│ Object Creation:             │
│ new_obj = Class()            │
│ → name = 'User', age = 18   │
│ new_obj2 = Class('Anna')     │
│ → name = 'Anna', age = 18   │
│ new_obj3 = Class('Bob', 25) │
│ → name = 'Bob', age = 25    │
└─────────────────────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding Constructors in Python

Concept: Learn what a constructor is and how it initializes new objects.

In Python, a constructor is a special method named __init__ inside a class. It runs automatically when you create a new object. It sets up the object's initial state by assigning values to its attributes. Example: class Person: def __init__(self, name, age): self.name = name self.age = age p = Person('Alice', 30) print(p.name, p.age)

Result

Alice 30

Understanding constructors is essential because they define how objects start their life with specific data.

2

Foundation

Parameters in Constructors

Concept: Learn how to pass information to constructors using parameters.

Parameters are placeholders in the constructor that receive values when creating an object. These values customize the object's attributes. Example: class Car: def __init__(self, brand, year): self.brand = brand self.year = year car1 = Car('Toyota', 2020) print(car1.brand, car1.year)

Result

Toyota 2020

Parameters let you create objects with different details, making classes reusable and flexible.

3

Intermediate

Introducing Default Values in Constructors

🤔Before reading on: Do you think default values must be provided for all parameters or only some? Commit to your answer.

Concept: Default values allow some parameters to have preset values if none are given during object creation.

You can assign default values to constructor parameters by using the equals sign (=) in the parameter list. If the caller does not provide a value, the default is used. Example: class Dog: def __init__(self, name='Buddy', age=3): self.name = name self.age = age # Using defaults dog1 = Dog() print(dog1.name, dog1.age) # Buddy 3 # Overriding defaults dog2 = Dog('Max', 5) print(dog2.name, dog2.age) # Max 5

Result

Buddy 3 Max 5

Knowing that defaults only apply when no argument is given helps you write flexible constructors that cover many use cases.

4

Intermediate

Order and Placement of Default Parameters

🤔Before reading on: Can a parameter with a default value come before one without? Predict yes or no.

Concept: Parameters with default values must come after parameters without defaults in the constructor definition.

Python requires that all parameters with default values be placed after parameters without defaults. This is because Python matches arguments by position. Example (correct): class Book: def __init__(self, title, author='Unknown'): self.title = title self.author = author Example (incorrect): class Book: def __init__(self, title='No Title', author): self.title = title self.author = author # This will cause a SyntaxError.

Result

SyntaxError if default parameter comes before non-default

Understanding parameter order prevents syntax errors and confusion when calling constructors.

5

Intermediate

Using Mutable Default Values Carefully

🤔Before reading on: Do you think using a list as a default value creates a new list each time or shares one list? Commit your guess.

Concept: Mutable default values like lists or dictionaries are shared across all objects if used directly as defaults, which can cause unexpected behavior.

Example of problematic code: class Basket: def __init__(self, items=[]): self.items = items b1 = Basket() b1.items.append('apple') b2 = Basket() print(b2.items) # ['apple'] - unexpected! Correct way: class Basket: def __init__(self, items=None): if items is None: items = [] self.items = items b1 = Basket() b1.items.append('apple') b2 = Basket() print(b2.items) # [] - expected

Result

Sharing mutable defaults causes bugs; using None avoids this.

Knowing this prevents subtle bugs where objects unexpectedly share data.

6

Advanced

Combining Default Values with *args and **kwargs

🤔Before reading on: Can you mix default parameters with *args and **kwargs in constructors? Predict yes or no.

Concept: You can combine default parameters with variable-length argument lists to create very flexible constructors.

Example: class Gadget: def __init__(self, name='Gizmo', *features, **settings): self.name = name self.features = features self.settings = settings g = Gadget('Phone', 'Bluetooth', 'Camera', color='black', weight=150) print(g.name) # Phone print(g.features) # ('Bluetooth', 'Camera') print(g.settings) # {'color': 'black', 'weight': 150}

Result

Allows flexible object creation with defaults and extra options.

Understanding this unlocks powerful patterns for adaptable class design.

7

Expert

How Default Values Are Evaluated at Definition Time

🤔Before reading on: Do you think default values are evaluated each time the constructor runs or once when the class is defined? Commit your answer.

Concept: Default parameter values are evaluated once when the function is defined, not each time it is called, which can lead to surprising behavior with mutable defaults.

This means if you use a mutable object as a default, the same object is reused every time. Example: class Counter: def __init__(self, counts={}): self.counts = counts c1 = Counter() c1.counts['a'] = 1 c2 = Counter() print(c2.counts) # {'a': 1} - shared dictionary This happens because the dictionary was created once when the class was loaded. To avoid this, use None and create a new object inside the constructor.

Result

Default values are fixed at definition, causing shared state if mutable.

Knowing when defaults are evaluated helps avoid hard-to-find bugs in object state.

Under the Hood

When Python reads a class, it compiles the constructor function and evaluates default parameter values immediately, storing them in the function's metadata. When you create an object, Python calls this constructor, filling in missing arguments with these stored defaults. Mutable defaults are stored as references to the same object, so changes affect all uses. This is why mutable defaults can cause shared state bugs.

Why designed this way?

Python evaluates default parameters once to optimize performance and avoid recreating objects unnecessarily. This design choice simplifies function calls but requires care with mutable defaults. Alternatives like evaluating defaults at call time would add overhead and complexity. The current design balances efficiency and flexibility, expecting programmers to handle mutable defaults carefully.

┌───────────────────────────────┐
│ Class Definition Time          │
│ ┌───────────────────────────┐ │
│ │ Constructor Function Created│ │
│ │ Default Values Evaluated    │ │
│ │ (stored in function object) │ │
│ └───────────────────────────┘ │
│                               │
│ Object Creation Time          │
│ ┌───────────────────────────┐ │
│ │ Constructor Called          │ │
│ │ Arguments Matched           │ │
│ │ Missing Args Filled from    │ │
│ │ Stored Defaults             │ │
│ └───────────────────────────┘ │
└───────────────────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does using a mutable default value create a new object each time the constructor runs? Commit yes or no.

Common Belief: Using a list or dictionary as a default parameter creates a new object every time the constructor is called.

Reality: The default object is created once when the constructor is defined and shared across all calls that use the default.

Why it matters: This causes unexpected shared state between objects, leading to bugs where one object's changes affect others.

Quick: Can you put a parameter with a default value before one without? Commit yes or no.

Common Belief: You can place parameters with default values anywhere in the constructor parameter list.

Reality: Parameters with default values must come after all parameters without defaults, or Python raises a syntax error.

Why it matters: Incorrect parameter order causes syntax errors and confusion when calling constructors.

Quick: If you don't provide a value for a parameter with a default, does Python use None automatically? Commit yes or no.

Common Belief: If you omit a parameter, Python automatically assigns None as its default value.

Reality: Python uses the default value explicitly set in the constructor; if no default is set, omitting the argument causes an error.

Why it matters: Assuming None is default can cause runtime errors when arguments are missing.

Quick: Does using *args and **kwargs prevent you from using default values? Commit yes or no.

Common Belief: You cannot use default parameter values together with *args and **kwargs in constructors.

Reality: You can combine default parameters with *args and **kwargs to create very flexible constructors.

Why it matters: Believing this limits your ability to design adaptable and powerful classes.

Expert Zone

1

Default values are evaluated once at function definition, so using mutable defaults can cause shared state bugs that are hard to detect.

2

Using None as a sentinel default and creating new objects inside the constructor is a common Python idiom to avoid mutable default pitfalls.

3

Combining default parameters with *args and **kwargs allows for very flexible and extensible constructors, useful in frameworks and libraries.

When NOT to use

Avoid default values in constructors when object initialization requires mandatory parameters for correctness or security. Instead, use explicit parameter passing or factory methods. Also, avoid mutable default values directly; use None and initialize inside the constructor.

Production Patterns

In production, default values are used to provide sensible defaults for optional settings, enabling simpler object creation. Libraries often use None as a default for mutable parameters and document expected behaviors. Constructors may combine defaults with *args/**kwargs to accept extra options without breaking compatibility.

Connections

Function Default Arguments

Default values in constructors are a specific case of Python's general function default arguments.

Understanding function defaults helps grasp constructor defaults since they share the same evaluation rules and pitfalls.

Factory Design Pattern

Default values simplify object creation, which is a core idea in factory patterns that manage complex object setup.

Knowing defaults helps understand how factories provide flexible object creation with optional parameters.

Human Decision Making

Default values in constructors mirror how humans use default choices to simplify decisions unless specific preferences are given.

Recognizing this connection shows how programming patterns often reflect natural problem-solving strategies.

Common Pitfalls

#1 Using a mutable object like a list as a default parameter directly.

Wrong approach:

class Team:
def __init__(self, members=[]):
self.members = members

team1 = Team()
team1.members.append('Alice')
team2 = Team()
print(team2.members) # ['Alice'] - unexpected sharing

Correct approach:

class Team:
def __init__(self, members=None):
if members is None:
members = []
self.members = members

team1 = Team()
team1.members.append('Alice')
team2 = Team()
print(team2.members) # [] - expected separate lists

Root cause:

Misunderstanding that default parameters are evaluated once at definition, causing shared mutable objects.

#2 Placing a parameter with a default value before one without in the constructor.

Wrong approach:

class Item:
def __init__(self, price=10, name):
self.price = price
self.name = name

# SyntaxError: non-default argument follows default argument

Correct approach:

class Item:
def __init__(self, name, price=10):
self.name = name
self.price = price

Root cause:

Not knowing Python's syntax rule that parameters with defaults must come after those without.

#3 Assuming Python assigns None automatically to missing parameters without defaults.

Wrong approach:

class User:
def __init__(self, username):
self.username = username

u = User() # TypeError: missing required positional argument

Correct approach:

class User:
def __init__(self, username=None):
self.username = username

u = User() # Works, username is None

Root cause:

Confusing default parameter behavior with optional parameters.

Key Takeaways

Default values in constructors provide preset options that simplify object creation by filling in missing information automatically.

Parameters with default values must come after parameters without defaults to avoid syntax errors.

Mutable default values are shared across all instances, so use None and initialize inside the constructor to avoid bugs.

Default values are evaluated once when the constructor is defined, not each time it is called, which affects mutable defaults.

Combining default parameters with *args and **kwargs allows for very flexible and powerful constructors.