Start assessmentBinary TreeUseful learning, one step at a time
Online
Offline-ready notes · progress saves on this device
Project LibraryStudy workspace →
Courses/Intermediate Python/Lesson 4

Lesson 4 of 5

Object-Oriented Programming

Read the overview in
English overview

Model related data and behavior with classes and objects, initialize unique state through constructors, and use encapsulation, inheritance, and polymorphism intentionally.

13:22 lectureIntermediate12 video chapters30 flashcards + 30 questions
Official Binary Tree uploadIntermediate Python Lesson 4Published 2026-08-05 · embedded with chapters, checkpoints, deep notes, and a project

Four clear stages

Learn → Project → Check → Finish

Watch and work through the lecture →
  1. 1LearnWatch and work through the lectureUse the chapter notebook and answer each video checkpoint.Do this now
  2. 2ProjectCode a course-progress classPlan it, create it, then prove it meets the definition of done.Next
  3. 3CheckAnswer all 30 questionsCorrect weak spots using the explanation after each answer.Next
  4. 4FinishMark the lesson completeThen move to Capstone: Console Item Lister.Next
Course outlineIntermediate Python

Interactive lecture

Watch, pause, think, apply.

Design a small class with clear attributes, methods, defaults, scope, and object responsibilities, then test independent instances.

0:003 thinking points marked13:22

Numbered markers show where the video will pause. Seeking past one opens the first unanswered check.

Connecting to the lecture…Open on YouTube ↗

Chapter-by-chapter lecture notebook

Everything in the video, organized for learning

The lecture introduces OOP through blueprints, instances, scope, and clean code. The deeper skill is assigning one coherent responsibility to a class.

Source reviewed13:22 lectureReviewed against the public lecture with timestamped slide sampling across the full runtime and cross-checked against the source lesson context.
12

video chapters mapped into notes, examples, and a concrete action.

This is a detailed learning companion reconstructed from the reviewed lecture—not a verbatim transcript.
01
0:00 in the lectureThink in objects with a book analogy
What the video is teaching

OOP groups data as attributes and actions as methods. A class is the blueprint; each object is an independent instance built from it.

Use a class when several values and behaviors form a stable concept, not merely to wrap one unrelated function.

What to noticeWorked example

A Course object stores title, learner count, and completed lessons and exposes methods to record completion and calculate progress.

Do this before continuing

List the state and behavior of two real concepts, then decide whether each deserves a class.

Replay this chapter on YouTube ↗
02
0:55 in the lectureOOP and its core ideas
What the video is teaching

OOP groups data as attributes and actions as methods. A class is the blueprint; each object is an independent instance built from it.

Use a class when several values and behaviors form a stable concept, not merely to wrap one unrelated function.

What to noticeWorked example

A Course object stores title, learner count, and completed lessons and exposes methods to record completion and calculate progress.

Do this before continuing

List the state and behavior of two real concepts, then decide whether each deserves a class.

Replay this chapter on YouTube ↗
03
2:10 in the lectureClass blueprint and object instance
What the video is teaching

OOP groups data as attributes and actions as methods. A class is the blueprint; each object is an independent instance built from it.

Use a class when several values and behaviors form a stable concept, not merely to wrap one unrelated function.

What to noticeWorked example

A Course object stores title, learner count, and completed lessons and exposes methods to record completion and calculate progress.

Do this before continuing

List the state and behavior of two real concepts, then decide whether each deserves a class.

Replay this chapter on YouTube ↗
04
3:40 in the lectureCreate multiple instances
What the video is teaching

OOP groups data as attributes and actions as methods. A class is the blueprint; each object is an independent instance built from it.

Use a class when several values and behaviors form a stable concept, not merely to wrap one unrelated function.

What to noticeWorked example

A Course object stores title, learner count, and completed lessons and exposes methods to record completion and calculate progress.

Do this before continuing

List the state and behavior of two real concepts, then decide whether each deserves a class.

Replay this chapter on YouTube ↗
05
4:55 in the lectureInstance variables and methods
What the video is teaching

__init__ receives construction inputs and assigns instance attributes through self. Defaults can simplify common cases but should not create shared mutable state accidentally.

Validate required values at creation and keep each instance’s data independent. Use class attributes only for values genuinely shared by all instances.

What to noticeWorked example

Two Course objects have different completion counts; a shared organization_name can be a class attribute if it truly applies to both.

Do this before continuing

Design a constructor with two required values, one safe default, and one validation rule.

Replay this chapter on YouTube ↗
06
6:05 in the lectureConstructors and class attributes
What the video is teaching

__init__ receives construction inputs and assigns instance attributes through self. Defaults can simplify common cases but should not create shared mutable state accidentally.

Validate required values at creation and keep each instance’s data independent. Use class attributes only for values genuinely shared by all instances.

What to noticeWorked example

Two Course objects have different completion counts; a shared organization_name can be a class attribute if it truly applies to both.

Do this before continuing

Design a constructor with two required values, one safe default, and one validation rule.

Replay this chapter on YouTube ↗
07
7:15 in the lectureOptional parameters
What the video is teaching

__init__ receives construction inputs and assigns instance attributes through self. Defaults can simplify common cases but should not create shared mutable state accidentally.

Validate required values at creation and keep each instance’s data independent. Use class attributes only for values genuinely shared by all instances.

What to noticeWorked example

Two Course objects have different completion counts; a shared organization_name can be a class attribute if it truly applies to both.

Do this before continuing

Design a constructor with two required values, one safe default, and one validation rule.

Replay this chapter on YouTube ↗
08
8:20 in the lectureLocal, global, and instance scope
What the video is teaching

Method variables are local to one call, global names exist across the module, and instance attributes live on an object. A local name can shadow a global name without changing it.

Prefer local and instance state over hidden globals. Name variables clearly and make mutation explicit.

What to noticeWorked example

A method uses local new_total, then assigns self.completed_lessons; it does not depend on a global counter shared by every course.

Do this before continuing

Trace three same-named variables at local, global, and instance scope and predict which each expression reads.

Replay this chapter on YouTube ↗
09
9:25 in the lectureClean code versus spaghetti code
What the video is teaching

Clean OOP reduces coupling and makes responsibilities, tests, and changes easier to understand. Inheritance and polymorphism are useful only when they model a true substitutable relationship.

Give each class one reason to change, hide internal details behind meaningful methods, and test multiple independent objects.

What to noticeWorked example

Course records progress; Report formats a summary. One class does not also send email, manage authentication, and edit files.

Do this before continuing

Build two Course objects, update one, and prove the other remains unchanged.

Replay this chapter on YouTube ↗
10
10:40 in the lectureScope discussion
What the video is teaching

Clean OOP reduces coupling and makes responsibilities, tests, and changes easier to understand. Inheritance and polymorphism are useful only when they model a true substitutable relationship.

Give each class one reason to change, hide internal details behind meaningful methods, and test multiple independent objects.

What to noticeWorked example

Course records progress; Report formats a summary. One class does not also send email, manage authentication, and edit files.

Do this before continuing

Build two Course objects, update one, and prove the other remains unchanged.

Replay this chapter on YouTube ↗
11
11:40 in the lectureObject and self questions
What the video is teaching

Clean OOP reduces coupling and makes responsibilities, tests, and changes easier to understand. Inheritance and polymorphism are useful only when they model a true substitutable relationship.

Give each class one reason to change, hide internal details behind meaningful methods, and test multiple independent objects.

What to noticeWorked example

Course records progress; Report formats a summary. One class does not also send email, manage authentication, and edit files.

Do this before continuing

Build two Course objects, update one, and prove the other remains unchanged.

Replay this chapter on YouTube ↗
12
12:55 in the lectureDesign review
What the video is teaching

Clean OOP reduces coupling and makes responsibilities, tests, and changes easier to understand. Inheritance and polymorphism are useful only when they model a true substitutable relationship.

Give each class one reason to change, hide internal details behind meaningful methods, and test multiple independent objects.

What to noticeWorked example

Course records progress; Report formats a summary. One class does not also send email, manage authentication, and edit files.

Do this before continuing

Build two Course objects, update one, and prove the other remains unchanged.

Replay this chapter on YouTube ↗

Deep explanations

The ideas behind each chapter

Use these sections when the video moves quickly or you need another example.

010:55

Use objects to connect state and behavior

OOP groups data as attributes and actions as methods. A class is the blueprint; each object is an independent instance built from it.

Use a class when several values and behaviors form a stable concept, not merely to wrap one unrelated function.

Worked example

A Course object stores title, learner count, and completed lessons and exposes methods to record completion and calculate progress.

Try it now

List the state and behavior of two real concepts, then decide whether each deserves a class.

024:55

Initialize valid instance state

__init__ receives construction inputs and assigns instance attributes through self. Defaults can simplify common cases but should not create shared mutable state accidentally.

Validate required values at creation and keep each instance’s data independent. Use class attributes only for values genuinely shared by all instances.

Worked example

Two Course objects have different completion counts; a shared organization_name can be a class attribute if it truly applies to both.

Try it now

Design a constructor with two required values, one safe default, and one validation rule.

038:20

Reason about scope and references

Method variables are local to one call, global names exist across the module, and instance attributes live on an object. A local name can shadow a global name without changing it.

Prefer local and instance state over hidden globals. Name variables clearly and make mutation explicit.

Worked example

A method uses local new_total, then assigns self.completed_lessons; it does not depend on a global counter shared by every course.

Try it now

Trace three same-named variables at local, global, and instance scope and predict which each expression reads.

049:25

Use clean class boundaries

Clean OOP reduces coupling and makes responsibilities, tests, and changes easier to understand. Inheritance and polymorphism are useful only when they model a true substitutable relationship.

Give each class one reason to change, hide internal details behind meaningful methods, and test multiple independent objects.

Worked example

Course records progress; Report formats a summary. One class does not also send email, manage authentication, and edit files.

Try it now

Build two Course objects, update one, and prove the other remains unchanged.

Language of the lesson

Know these ideas

Class
A definition of object state and behavior.
Object
A specific instance created from a class.
Attribute
Data stored on a class or object.
Method
A function defined as part of a class.
Constructor
Initialization logic normally implemented with __init__.
Scope
The region where a name can be accessed.

Reason like a practitioner

Misconceptions to correct

  • A class and object are the same thing.The class is the definition; objects are instances.
  • Every value should be global so methods can reach it.Instance and local state reduce coupling and accidental interference.
  • More classes automatically mean cleaner code.Classes need coherent responsibilities and useful boundaries.
Transfer challenge

Implement a Course class with validation, safe defaults, three methods, and two independent instances; add tests for construction, mutation, progress calculation, and invalid input.

Lesson project · Python OOP project

Code a course-progress class

A checked Course class with independent state, completion behavior, validation, and a progress method.

0%0 of 5 checks
Your brief

Design a Course class with title, learner count, and completed lessons. Add methods to record completion and calculate progress, then create two independent course objects.

  1. 1
    Plan the work

    State the goal, audience or user, and the evidence a strong result needs. Explain how Class changes your plan.

  2. 2
    Build and test

    Design a Course class with title, learner count, and completed lessons. Add methods to record completion and calculate progress, then create two independent course objects.

  3. 3
    Prove and improve

    Use Object and Encapsulation to check the result. Record one piece of evidence, one correction, and one improvement you would make next.

Offline referenceRead the independent walkthrough and practice notes

Why this lesson matters

Model related data and behavior with classes and objects, initialize unique state through constructors, and use encapsulation, inheritance, and polymorphism intentionally.

The goal is not to memorize vocabulary. By the end of the lesson, you should be able to use the ideas in a realistic situation, explain the reason for your choices, and check whether the result actually works for the intended person or task.

Learning objectives

  • Explain Class in your own words.
  • Apply Object to a realistic classroom or community example.
  • Connect Class with Encapsulation when making a decision.
  • Complete the practice task and reflect on one improvement.

Core ideas

1. Class

A blueprint that defines the attributes and methods shared by objects of the same conceptual type.

In practice: Look for this idea while you complete the lesson task. Pause before each major step and explain how Class changes what you choose, create, or check.

2. Object

A concrete instance of a class with its own state while using the behavior defined by the class.

In practice: Look for this idea while you complete the lesson task. Pause before each major step and explain how Object changes what you choose, create, or check.

3. Encapsulation

Keeping related data and operations together behind a clear interface so internal details can change without breaking callers.

In practice: Look for this idea while you complete the lesson task. Pause before each major step and explain how Encapsulation changes what you choose, create, or check.

How the ideas connect

Start with Class to understand the foundation of the lesson. Use Object to turn that understanding into an action. Then apply Encapsulation to check the quality, safety, or usefulness of the result. The three ideas are strongest when you can explain their relationship rather than treating them as separate definitions.

Guided walkthrough

  1. Name the goal. In one sentence, write what you are trying to understand, create, or improve.
  2. Make a prediction. Before touching a device, use Class and Object to predict what a strong result should look like.
  3. Complete the task. Design a Course class with title, learner count, and completed lessons. Add methods to record completion and calculate progress, then create two independent course objects.
  4. Check the outcome. Use Encapsulation to inspect the result. Ask what worked, what did not, and what evidence supports your judgment.
  5. Explain and revise. Tell a partner what you changed and why. Make one small improvement, then compare the new result with the first one.

Worked classroom scenario

Imagine two learners sharing one device. The first learner is the driver and performs the steps; the second is the navigator and reads the goal, predicts the next step, and checks the result. Halfway through the task, switch roles. Both learners should be able to explain how Class, Object, and Encapsulation appeared in the work.

If no device is available, complete the same reasoning on paper: sketch the screen or result, label each decision, and describe what you would test when a device becomes available.

Common mistakes and fixes

  • Rushing into the tool: Write the goal and prediction first so every click or step has a reason.
  • Copying without understanding: After each major step, explain it in your own words to a partner.
  • Accepting the first result: Compare the outcome with the goal and make at least one deliberate improvement.
  • Letting one person control a shared device: Rotate driver and navigator roles so both learners think and practice.

Independent practice

Design a Course class with title, learner count, and completed lessons. Add methods to record completion and calculate progress, then create two independent course objects.

For an extra challenge, adapt the task for a different audience or community need. Write two sentences explaining what changed and which lesson idea guided your decision.

Check your understanding

  1. How would you explain Class to someone new to the topic?
  2. What is one realistic example of Object outside this classroom?
  3. When might Encapsulation prevent a weak, unsafe, or confusing result?
  4. How are Class and Object connected?
  5. What evidence would convince you that your practice result works?
  6. If you repeated the activity tomorrow, what would you improve first and why?

Key takeaway

Model related data and behavior with classes and objects, initialize unique state through constructors, and use encapsulation, inheritance, and polymorphism intentionally.

You are ready to move on when you can explain the three core ideas, complete the practice without copying, and describe one improvement using evidence from your result.

Open lecture on YouTube ↗Open lecture deck ↗Study in focused mode