Self reference in Python - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a self-referencing dictionary

What is the output of this Python code that uses a dictionary referencing itself?

Python

d = {}
d['self'] = d
print(d['self'] is d)

A KeyError

B False

C TypeError

D True

💡 Hint

Think about whether the dictionary stored inside the key 'self' is the same object as d.

The dictionary d stores itself under the key 'self'. So d['self'] points to the same dictionary object as d, making the identity check True.

❓ Predict Output

intermediate

Output of a self-referencing list

What will this Python code print?

Python

lst = [1, 2]
lst.append(lst)
print(len(lst))

A 3

B 2

C TypeError

D RecursionError

💡 Hint

Appending the list to itself adds one more element.

The list initially has 2 elements. Appending itself adds a third element which is the list itself, so length becomes 3.

🔧 Debug

advanced

Why does this self-referencing class cause infinite recursion?

Consider this Python class that references itself in a method. What causes the infinite recursion error?

Python

class Node:
    def __init__(self):
        self.child = self
    def get_child(self):
        return self.child.get_child()

n = Node()
n.get_child()

A The class Node is not instantiated properly

B self.child is None causing AttributeError

C get_child calls itself endlessly because self.child is self

D The constructor __init__ is missing a return statement

💡 Hint

Look at what get_child returns and what self.child points to.

The method get_child calls itself recursively because self.child is the same Node instance, so get_child calls get_child endlessly causing infinite recursion.

🧠 Conceptual

advanced

Understanding self-reference in nested data structures

What is the output of this code that creates a nested dictionary referencing itself?

Python

a = {}
a['nested'] = {'parent': a}
print(a['nested']['parent'] is a)

A False

B True

C KeyError

D TypeError

💡 Hint

Check if the nested dictionary's 'parent' key points back to the original dictionary.

The nested dictionary inside 'nested' has a key 'parent' that points back to the original dictionary a, so the identity check is True.

❓ Predict Output

expert

Output of printing a self-referencing list

What is the output of this Python code?

Python

lst = [1, 2]
lst.append(lst)
print(lst)

A [1, 2, [...]]

B [1, 2, [1, 2]]

C RecursionError

D [1, 2, None]

💡 Hint

Python shows self-references in lists with [...].

When printing a list that contains itself, Python shows the self-reference as [...], so the output is [1, 2, [...]].

Practice

1. What does self represent inside a Python class method?

easy

A. A class method decorator

B. The current instance of the class

C. A global variable

D. A built-in Python keyword

Solution

1. Step 1: Understand the role of self in classes

   self is used to refer to the current object instance inside class methods.

2. Step 2: Differentiate from other options

   It is not a global variable, decorator, or keyword but a conventional name for the instance parameter.

3. Final Answer:

   The current instance of the class -> Option B

4. Quick Check:

   self = current object [OK]

Hint: Remember: self means 'this object' inside class methods [OK]

Common Mistakes:

• Thinking self is a keyword
• Confusing self with class itself
• Assuming self is optional

2. Which of the following is the correct way to define a method using self in a Python class?

easy

A. def method(self):

B. def method(this):

C. def method(cls):

D. def method():

Solution

1. Step 1: Recall method definition syntax in Python classes

   Instance methods must include self as the first parameter to access instance data.

2. Step 2: Check each option

   Only def method(self): correctly includes self as the first parameter.

3. Final Answer:

   def method(self): -> Option A

4. Quick Check:

   Method needs self parameter [OK]

Hint: Always put self as first parameter in instance methods [OK]

Common Mistakes:

• Omitting self parameter
• Using wrong parameter name like cls or this
• Confusing class and instance methods

3. What is the output of this code?

class Counter:
    def __init__(self):
        self.count = 0
    def increment(self):
        self.count += 1
        return self.count
c = Counter()
print(c.increment())
print(c.increment())

medium

A. 1 2

B. 0 1

C. 1 1

D. 2 3

Solution

1. Step 1: Understand the initial state and method behavior

   When Counter is created, count is 0. Each increment adds 1 and returns the new value.

2. Step 2: Trace the two calls to increment()

   First call: count goes 0 -> 1, returns 1. Second call: count goes 1 -> 2, returns 2.

3. Final Answer:

   1 2 -> Option A

4. Quick Check:

   Increment adds 1 each call [OK]

Hint: Track self.count changes step-by-step [OK]

Common Mistakes:

• Assuming count resets each call
• Confusing return values
• Ignoring self reference updates

4. Find the error in this class definition:

class Person:
    def __init__(name):
        self.name = name
p = Person('Alice')
print(p.name)

medium

A. Using self before assignment

B. Incorrect print statement

C. Missing self parameter in __init__

D. Class name should be lowercase

Solution

1. Step 1: Check method parameters

   The __init__ method must have self as the first parameter to refer to the instance.

2. Step 2: Identify the error

   Here, __init__ only has name, so self is missing, causing a runtime error.

3. Final Answer:

   Missing self parameter in __init__ -> Option C

4. Quick Check:

   __init__ needs self first [OK]

Hint: Always include self as first parameter in instance methods [OK]

Common Mistakes:

• Forgetting self in __init__
• Trying to use self without defining it
• Assuming self is automatic

5. You want to create a class Node for a linked list where each node refers to itself and the next node. Which is the correct way to set the next node using self reference?

class Node:
    def __init__(self, value):
        self.value = value
        self.next = None
    def set_next(self, next_node):
        ???

Choose the correct line to replace ???.

hard

A. next_node = self.next

B. next = self.next_node

C. self.next_node = next_node

D. self.next = next_node

Solution

1. Step 1: Understand attribute assignment with self

   To update the current object's next attribute, use self.next.

2. Step 2: Match the correct assignment

   Assigning self.next = next_node correctly sets the next node reference.

3. Final Answer:

   self.next = next_node -> Option D

4. Quick Check:

   Use self.attribute = value to update instance data [OK]

Hint: Use self.attribute to refer to current object's data [OK]

Common Mistakes:

• Assigning to local variable instead of self attribute
• Mixing attribute names
• Forgetting self in assignment