Python Programming Object-Oriented Programming Syllabus

Object-Oriented Programming syllabus — full chapter and topic list

Expand any chapter to see its topics and sub-topics. This is the whole examinable outline for Object-Oriented Programming in Python Programming, not a summary of it.

1. 1

   Classes and Objects

   4 topics

   • Defining Classes
   • Instance Attributes and Methods
   • The __init__ Constructor and self
   • Class vs Instance Variables
2. 2

   Inheritance and Polymorphism

   4 topics

   • Single and Multiple Inheritance
   • Method Overriding and super()
   • Method Resolution Order (MRO)
   • Polymorphism and Duck Typing
3. 3

   Encapsulation and Properties

   3 topics

   • Public, Protected and Private Members
   • Property Decorators and Getters/Setters
   • Name Mangling
4. 4

   Special and Magic Methods

   3 topics

   • String Representation
   • Operator Overloading
   • Comparison and Hashing Methods
5. 5

   Advanced Class Concepts

   4 topics

   • Class Methods and Static Methods
   • Abstract Base Classes
   • Dataclasses
   • Slots and Memory Optimization

Object-Oriented Programming flashcards for Python Programming

23 of 50 cards from the Object-Oriented Programming deck — real questions with worked answers.

1. In Python, what keyword defines a class, and what is the conventional naming style for class names?

   The `class` keyword defines a class. Class names conventionally use CapWords/PascalCase (e.g., `BankAccount`).

2. What is an instance attribute, and where is it typically created?

   An instance attribute is data unique to each object, stored on the instance itself. It is typically created by assigning to `self.name` inside `__init__` (or any method).

3. What is the purpose of the `__init__` method, and is it technically a constructor?

   `__init__` initializes a newly created instance's state. It is not the true constructor; `__new__` creates the object, and `__init__` only initializes it after creation.

4. What does the `self` parameter refer to, and how is it passed?

   `self` refers to the current instance. It is passed automatically as the first argument when you call a method on an object (e.g., `obj.method()` passes `obj` as `self`).

5. What is the key difference between a class variable and an instance variable?

   A class variable is shared by all instances (defined in the class body), while an instance variable is unique per object (assigned via `self`). Assigning to `self.x` shadows a class variable of the same name for that instance.

6. If a class variable is a mutable object (e.g., a list) shared across instances, what common bug occurs?

   All instances share the same object, so mutating it via one instance (e.g., `self.items.append(x)`) affects every instance. Mutable defaults should be created per-instance in `__init__`.

7. What is an instance method versus how it differs from accessing an attribute?

   An instance method is a function defined in a class that takes `self` as its first parameter and operates on instance data; it is called as `obj.method(args)`.

8. How do you define single inheritance in Python?

   List the parent class in parentheses after the class name: `class Child(Parent):`. `Child` inherits Parent's attributes and methods.

9. What is multiple inheritance, and what is its syntax?

   Multiple inheritance lets a class inherit from more than one base: `class C(A, B):`. `C` combines the members of A and B, resolved by the MRO.

10. What does method overriding mean?

    Method overriding is redefining a method in a subclass with the same name as one in the parent, so the subclass version replaces the parent's for instances of the subclass.

11. What does `super()` do, and give a common use in `__init__`.

    `super()` returns a proxy that delegates to the next class in the MRO. It is commonly used to call the parent initializer: `super().__init__(...)` to run the base class setup.

12. What is the Method Resolution Order (MRO)?

    The MRO is the ordered list of classes Python searches to find an attribute or method. For new-style classes it is computed by the C3 linearization algorithm.

13. How can you inspect a class's MRO?

    Use `ClassName.__mro__`, `ClassName.mro()`, or `help(ClassName)`. It lists classes from the class itself up through its bases to `object`.

14. What guarantees does C3 linearization provide for the MRO?

    C3 preserves the order that each class lists its bases (local precedence) and ensures a class always appears before its parents (monotonicity), producing a single consistent order or raising a TypeError if none exists.

15. What is polymorphism in the OOP sense?

    Polymorphism lets objects of different classes respond to the same method call in their own way, so code can operate on a common interface without knowing concrete types.

16. What is duck typing?

    Duck typing determines suitability by an object's methods/attributes rather than its type: 'if it walks like a duck and quacks like a duck, it's a duck.' Code works with any object that supports the required behavior.

17. By convention, what does a single leading underscore (e.g., `_value`) signal about a member?

    It marks the member as protected/internal—an implementation detail not part of the public API. It is a convention only; Python does not enforce access restriction.

18. What is a public member in Python, and how is access control enforced?

    A public member has no leading underscore and is part of the intended API. Python has no true access enforcement; 'private' and 'protected' are conventions plus name mangling for double-underscore names.

19. What does a double leading underscore (e.g., `__value`) trigger, and what is that feature called?

    It triggers name mangling: inside a class `Foo`, `__value` becomes `_Foo__value`. This is called name mangling and helps avoid accidental name clashes in subclasses.

20. Name mangling: from outside the class, how would you access an attribute declared as `self.__secret` in class `Vault`?

    As `obj._Vault__secret`. Name mangling rewrites `__secret` to `_Vault__secret`, so it is still accessible—just harder to hit accidentally.

21. What does the `@property` decorator do?

    `@property` turns a method into a read-only computed attribute, letting you access it as `obj.attr` (no parentheses) while running getter logic behind the scenes.

22. How do you define a setter for a property named `x`?

    Define the getter with `@property`, then a method decorated `@x.setter`, both named `x`: assigning `obj.x = value` invokes the setter. A `@x.deleter` similarly handles `del obj.x`.

23. What is the main advantage of using properties over public attributes?

    Properties let you add validation or computed logic later without changing the attribute-access syntax, preserving the public interface while controlling get/set/delete behavior.

See more Object-Oriented Programming flashcards →

Planning Object-Oriented Programming for Python Programming

Object-Oriented Programming (Python Programming) FAQ