Self reference in Python - Mini Project: Build & Apply

Self Reference in Python

📖 Scenario: Imagine you are creating a simple program to represent a person who can introduce themselves by name.

🎯 Goal: You will build a small program where a variable refers to itself to print a self-introduction message.

📋 What You'll Learn

Create a variable with a person's name

Create a variable that holds a message referencing the name variable

Use self reference to build the message

Print the final self-introduction message

💡 Why This Matters

🌍 Real World

Self reference is useful when you want to build messages or data that depend on existing variables, like user profiles or personalized greetings.

💼 Career

Understanding how variables can refer to themselves or be used inside functions is a basic skill for programming jobs involving data handling and user interaction.

1

Create a variable with the name

Create a variable called name and set it to the string "Alice".

Python

# Create a variable called name and set it to "Alice"
# Your code here

Hint

Use the equals sign = to assign the string "Alice" to the variable name.

2

Create a self-reference message

Create a variable called message that uses the variable name to build the string "Hello, my name is Alice." using an f-string.

Python

name = "Alice"
# Create a variable called message using an f-string that includes name
# Your code here

Hint

Use an f-string like f"Hello, my name is {name}." to include the variable name inside the string.

3

Use self reference in a function

Define a function called introduce that takes no parameters and returns the message variable. Use the message variable inside the function to refer to the self-introduction message.

Python

name = "Alice"
message = f"Hello, my name is {name}."
# Define a function called introduce that returns message
# Your code here

Hint

Define the function with def introduce(): and return the variable message inside it.

4

Print the self-introduction message

Call the function introduce() and print its return value.

Python

name = "Alice"
message = f"Hello, my name is {name}."

def introduce():
    return message

# Call introduce() and print the result
# Your code here

Hint

Use print(introduce()) to show the message on the screen.

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