The correct answer is that class attributes are shared across all instances, which is why modifying `ServerConfig.port` on the class itself immediately changes the value seen by every existing instance. This happens because Python’s attribute lookup first checks the instance namespace, and if no instance attribute exists, it falls back to the class attribute—so when you set `ServerConfig.port = 9090`, you are updating the single shared value in the class namespace, not creating an instance-specific copy. On the PCAP exam, this concept tests your understanding of Python’s attribute resolution order and the distinction between class and instance attributes; a common trap is assuming each instance gets its own copy of a class attribute, or that reassigning via the class only affects new instances. To remember: think of class attributes as a shared whiteboard—write on the board itself, and everyone reads the new message; write on an instance’s sticky note, and only that instance sees it.
PCAP Object-Oriented Programming Practice Question
This PCAP practice question tests your understanding of object-oriented programming. Read the scenario carefully and evaluate each option against the stated constraints before committing to an answer. After answering, compare your reasoning against the explanation and wrong-answer breakdown below. Once you have made your selection, read the full explanation to reinforce the concept and understand why each distractor is designed to mislead on exam day.
A class `ServerConfig` has a class attribute `port = 8080`. After deployment, a developer runs `ServerConfig.port = 9090` in one module, and unexpectedly all existing instances now use port 9090. What concept explains this behavior?
Answer the question above first, then reveal the full breakdown to understand why each option is right or wrong.
Correct answer & explanation
✓
Class attributes are shared among all instances of a class.
Option C is correct because class attributes in Python are shared across all instances of a class. When you modify `ServerConfig.port` on the class itself, every instance that accesses `port` via the class (or via an instance that hasn't overridden it) sees the new value. This is fundamental to Python's attribute lookup mechanism: instance attributes shadow class attributes, but if no instance attribute exists, the class attribute is used.
Key principle: Answer the scenario, not the keyword: identify the specific constraint before choosing the most familiar-sounding option.
Answer analysis
Option-by-option breakdown
For each option: why learners choose it and why it is or isn't the right answer here.
✗
Instance attributes always override class attributes.
Why it's wrong here
This explains why modifying via an instance would not affect the class, but the scenario modified via the class.
✗
The attribute is immutable.
Why it's wrong here
Immutability would prevent modification altogether, not explain the propagation.
✓
Class attributes are shared among all instances of a class.
Why this is correct
Changing a class attribute via the class affects all instances, as they all reference the same attribute.
Related concept
Read the scenario before looking for a memorised answer.
✗
Python uses copy-on-write for attribute access.
Why it's wrong here
Copy-on-write is not a Python mechanism for attribute access.
Common exam traps
Common exam trap: answer the scenario, not the keyword
Python Institute often tests the distinction between modifying a class attribute via the class vs. modifying it via an instance; the trap is that candidates think assigning to `instance.port` changes the class attribute, but it actually creates a new instance attribute that shadows the class attribute.
Trap categories for this question
Scenario analysis trap
This explains why modifying via an instance would not affect the class, but the scenario modified via the class.
Detailed technical explanation
How to think about this question
Under the hood, Python's attribute access follows the descriptor protocol and the MRO (Method Resolution Order). When you write `ServerConfig.port = 9090`, you are directly modifying the class's `__dict__`, which is a mutable mapping. All instances that have not set their own `port` attribute will then resolve `port` from the class's `__dict__`. This is why changing a class attribute affects all existing instances — they share the same class-level reference until an instance attribute shadows it.
KKey Concepts to Remember
Read the scenario before looking for a memorised answer.
Find the constraint that changes the correct option.
Eliminate answers that are true in general but not in this case.
TExam Day Tips
→Watch for words such as best, first, most likely and least administrative effort.
→Review why wrong options are wrong, not only why the correct option is correct.
Key takeaway
Answer the scenario, not the keyword: identify the specific constraint before choosing the most familiar-sounding option.
Real-world example
How this comes up in practice
A company's IT admin needs to give a contractor read-only access to production logs without sharing account credentials. Using role-based access control (RBAC) and temporary scoped permissions — not a permanent shared password — is the correct pattern. Questions like this test whether you can apply least-privilege access across cloud identity services.
What to study next
Got this wrong? Here's your next step.
Identify which exam domain this question belongs to, review the core concept, then practise similar questions from the same domain.
Object-Oriented Programming — This question tests Object-Oriented Programming — Read the scenario before looking for a memorised answer..
What is the correct answer to this question?
The correct answer is: Class attributes are shared among all instances of a class. — Option C is correct because class attributes in Python are shared across all instances of a class. When you modify `ServerConfig.port` on the class itself, every instance that accesses `port` via the class (or via an instance that hasn't overridden it) sees the new value. This is fundamental to Python's attribute lookup mechanism: instance attributes shadow class attributes, but if no instance attribute exists, the class attribute is used.
What should I do if I get this PCAP question wrong?
Identify which exam domain this question belongs to, review the core concept, then practise similar questions from the same domain.
What is the key concept behind this question?
Read the scenario before looking for a memorised answer.
About these practice questions
Courseiva creates original exam-style practice questions with explanations and wrong-answer analysis. It does not publish real exam questions, exam dumps, or protected exam content. Learn why practice questions differ from exam dumps →
These questions test the same concept from different angles. Work through them to make sure you can recognise it however the exam phrases it.
Variation 1. Which TWO of the following statements about class attributes in Python are true?
easy
A.Class attributes are always immutable.
✓ B.Class attributes are shared by all instances.
C.Class attributes are defined inside methods.
D.Modifying a class attribute via an instance modifies it for all instances.
✓ E.Class attributes can be accessed via the class name.
Why B: Class attributes are accessible via the class name and are shared across all instances. Options C, D, and E are false because class attributes can be mutable (e.g., lists), modifying via an instance creates an instance attribute if assigned, and they are defined directly in the class body, not inside methods.
Variation 2. Which TWO of the following statements about Python classes are true? (Select exactly 2.)
medium
A.Class names should be written in snake_case per PEP 8.
✓ B.Class variables are shared among all instances.
C.Private attributes (starting with __) cannot be accessed outside the class.
D.__init__ is the constructor of a class.
✓ E.Instance methods must have 'self' as the first parameter.
Why B: Option B is correct because class variables are defined directly in the class body and are shared across all instances of that class. When you modify a class variable through the class itself, the change is reflected in every instance, as the variable is stored in the class's __dict__ rather than in each instance's __dict__.
Share a tip, memory trick, or ask about the reasoning behind this question. Do not post real exam questions, leaked content, braindumps, or copyrighted exam material. Comments are moderated and may be removed without notice.
This PCAP practice question is part of Courseiva's free Python Institute certification practice question bank. Courseiva provides original exam-style practice questions with explanations, topic-based practice, mock exams, readiness tracking, and study analytics to help learners prepare for the PCAP exam.
Question Discussion
Share a tip, memory trick, or ask about the reasoning behind this question. Do not post real exam questions, leaked content, braindumps, or copyrighted exam material. Comments are moderated and may be removed without notice.
Sign in to join the discussion.