What is the difference between a class and an instance in Python?
A class is a callable object that produces instances; each instance has its own dict and shares the class's attributes
A class is itself an object: it is created by the class statement (or by calling type()) and is an instance of a metaclass. It defines shared attributes and behavior in its own dict. An instance is a separate object produced by calling the class. Attribute lookup on an instance first checks the instance dict, then the class and its MRO. That is why class attributes are shared by default and assigning to self.attr creates a per-instance attribute that shadows the class one, whereas assigning to ClassName.attr changes it for everyone that has not shadowed it.
- 1
Class: blueprint plus runtime object; stores methods, class variables, and annotations.
- 2
Instance: independent namespace; stores per-object state in obj.dict.
- 3
Mutable class attributes are the classic trap: a list defined on the class is shared by every instance unless each instance assigns its own.
- 4
Trade-off: shared class state saves memory and enables registry patterns; per-instance state is safer for anything mutable.
- 5
Common mistake: assuming methods are copied into each instance. They live on the class and are bound on access through the descriptor protocol.
- 6
Version note: since Python 3, all classes are new-style; the old-style class distinction from Python 2 is gone.
Scenario Questions
0-2 years experience
- 1You define counters as a class attribute list and every instance sees the same values. Why, and how do you fix it?
- 2Where does Python look first when you access obj.attr?
2-5 years experience
- 1You want a shared default configuration but per-instance overrides. How do you structure the class?
- 2A subclass reassigns a parent class attribute. Which instances see the new value?
5-8 years experience
- 1You need a registry of every instance created. Where do you store it and how do you avoid memory leaks?
- 2You are designing a plugin system where shared class-level state must remain consistent under concurrent registration. How do you handle this?
8+ years experience
- 1Design an object model that shares immutable defaults at the class level while allowing cheap per-instance overrides at scale.
- 2How do slots, __dict__, and class-level attributes interact for memory and lookup performance in CPython?
Follow-up Questions
- Why is defining a mutable list as a class attribute risky?
- How does method binding work if methods are stored on the class rather than the instance?