Namespaces and Scope
Fields are ordinary variables bound to class or object namespaces, scoped to their context and not global.
Two Kinds of Ownership
A field is an ordinary variable bound to a namespace. In a class design, that namespace belongs either to the class itself or to one individual object. This ownership decision controls whether the value is shared or separate. Class variables have one shared copy for all instances, while object variables have an independent copy for each instance.
Ask who owns the data: the class as a whole, or each individual instance? That question usually tells you which variable type to use.
Shared and Separate Values
A class variable is owned by the class. There is one copy, so every instance sees the same value. If that shared value changes, the change is visible to all instances. An object variable is owned by one instance. Each instance has its own independent copy, so changing one object's value does not change the corresponding value in another object.
| Question | Class variable | Object variable |
|---|---|---|
| Who owns it? | The class | One individual instance |
| How many copies exist? | One shared copy | One independent copy per instance |
| Who sees a change? | All instances | Only the instance whose value changed |
| How is it accessed? | Through the class name, such as Robot.population | Through an instance, such as robot1.name |
Ownership determines whether a field is shared or independent.
Robot Population Trace
The source example uses a Robot class with a class variable named population and an object variable named name. The class-level definition population = 0 creates the shared count. Inside initialization, self.name = name creates a name field for the individual object. The population count is increased when a robot is created and decreased when robot1.die() runs.
Following Two Robots
Two robots are created: robot1 with the name R2D2 and robot2 with the name C3PO. Then robot1 dies. Determine the population and each robot's name after each important step.
- 1Initial class state
The class variable population begins at 0. No robot-specific name has been created yet.
- 2Create robot1
The initialization process creates robot1's object variable name with the value R2D2. The shared class variable population increases to 1.
- 3Create robot2
A separate object variable name is created for robot2 with the value C3PO. The same shared population variable increases to 2. The two name values remain independent.
- 4Remove robot1
The die operation decreases the shared class variable population to 1. It does not change robot2's object variable name.
After robot1 dies, the shared population is 1. robot1's name is R2D2 and robot2's name is C3PO; the object variable belonging to robot2 is unaffected.
Reading Variable Access
The access form identifies the owner. A class variable is accessed through the class name, as in Robot.population. An object variable is accessed through an instance, as in robot1.name. When tracing code, first identify the name before the dot, then ask whether that name refers to the class or to one object. That tells you which namespace contains the field and who will observe a change.
- 1Find the variable access, such as Robot.population or
robot1.name. - 2Identify the owner named before the dot.
- 3Classify the owner as the class or as one individual instance.
- 4Predict who will see a change: all instances for a class variable, or only the owning instance for an object variable.
- 5Check whether the operation changes the shared class value or the selected object's independent value.
Choosing the Right Owner
Choose a class variable when the data logically belongs to the class as a whole and every instance should see the same value. A count of all objects is the source example's use case. Choose an object variable when each instance needs its own independent value, such as an individual object's name or state.
| Data requirement | Appropriate variable type | Reason |
|---|---|---|
| One count shared by all objects | Class variable | The class owns one shared value. |
| A separate name for each object | Object variable | Each instance owns its own value. |
| A value that every instance must see after one shared update | Class variable | Changes are visible to all instances. |
| A value that one object can change without affecting others | Object variable | Each instance has an independent copy. |
Match the variable type to the ownership requirement.
Mistakes in Scope Tracing
Common mistake Assuming every field belongs separately to each object.
What it looks likeTreating Robot.population as if robot1 and robot2 each had unrelated population values.
Why it failspopulation is a class variable with one shared copy.
Do this insteadTrace the owner named before the dot. Robot identifies the class namespace, so every instance sees the shared population value.
Common mistake Assuming an object variable is shared because several objects use the same field name.
What it looks likeAssuming robot1.name and robot2.name must refer to one common name value.
Why it failsThe same field name can exist in separate object namespaces.
Do this insteadTreat robot1.name and robot2.name as independent object variables belonging to different instances.
Common mistake Ignoring the access form.
What it looks likeReading robot1.name and Robot.population without using the owner to classify the field.
Why it failsThe owner indicates whether the field is attached to the class or to one object.
Do this insteadInspect the name before the dot, then predict who observes a modification.
Common mistake Choosing a variable type without considering ownership.
What it looks likeUsing a shared class variable for data that should differ for every object.
Why it failsA class variable gives all instances the same value and exposes shared changes.
Do this insteadUse an object variable when each instance requires an independent value.
Practice the Ownership Test
A class needs to store the total number of objects created and a separate label for each object. Decide which data should be a class variable and which should be an object variable. Then predict what happens to the other objects when one object's label changes and when the total count changes.
Hints
- Ask whether the total belongs to the class as a whole or to one object.
- Ask whether each object needs an independent label.
- Use the owner before the dot to predict who sees each change.
What do you think happens?
Two Robot objects exist. If the shared population value is decreased when one robot dies, should the other robot see the new population value?
Reveal answer
Yes, because population belongs to the class.
A class variable has one shared copy, so a change to it is visible to all instances. The other robot's individual name remains unaffected because name is an object variable.
Key Takeaways
- Fields are variables bound to either a class namespace or an object namespace; they are not global by default.
- Class variables are shared: one copy exists, and all instances see changes to it.
- Object variables are independent: each instance has its own copy, and changes affect only that instance.
- The owner before the dot helps identify the namespace: use the class name for class variables and the instance name for object variables.
- Choose the variable type by asking whether the data belongs to the class as a whole or to each individual object.