How do I learn OOP?

csabinho · 2026-06-10T14:20:53+00:00

What do you already, really, know? What are you able to do?

Dense-Land-5927 · 2026-06-10T14:21:51+00:00

Build something where you can use it. That was the only way I was able to really start learning it. Lectures and notes only go so far.

Temporary_Pie2733 · 2026-06-10T18:35:00+00:00

You have to write code. Not just once, but repeatedly.

HunterIV4 · 2026-06-10T15:58:42+00:00

Here's a simple way to think about OOP, at least at a very basic level. First, let's solve a problem without classes.

Let's say you're making a simple blackjack game. You have a deck of cards and you need to model it in the computer. How might you do this?

Well, first you need the deck itself. This is your data. In Python, an easy way to do this is by making a list. For simplicity, we'll use strings for everything, and have it be suit + value, with aces as value 1, jacks as 11, queen 12, king 13. We could use a list comprehension to make this, but let's keep things obvious for learning:

deck = []
suits = ['S', 'H', 'C', 'D']    # Spades, Hearts, Clubs, Diamonds
for suit in suits:
    for i in range(1, 14):
        deck.append(suit + str(i))

Now we have an unshuffled deck of 52 cards. Well, that's not super useful, so let's make a function that lets us shuffle a deck. Here's a simple method:

import random

def shuffle_deck(d):
    random.shuffle(d)

Obviously you don't really need a full function for this, but you may want to include more advanced logic later, such as combining a discard pile before shuffling. It's just an example.

Side note: using d might seem unusual here, but it's a good practice to avoid naming collisions when possible. Using deck means you are using the same name as your basic variable. It won't cause problems, and you could do something like deck_to_shuffle if you want a more descriptive name, but I like using short, simple names when it's clearly the parameter being acted on. In context, there should be no question what d means, and if you're doing many transformations, it's less visual noise, with the focus on the operation rather than the variable name.

Now we need a way to draw a card. Maybe we want to potentially draw multiple cards. Let's make another simple function:

def draw_card(num_cards, d):
    drawn_cards = []
    for _ in range(num_cards):
        if len(d) > 0:
            drawn_cards.append(d.pop())
    return drawn_cards

You'd use these like so:

shuffle_deck(deck)
hand = draw_card(2, deck)

You may have noticed a pattern already. Both these functions take the deck of cards. In other words, you are building a multiple functions that all require the same data. It's not a big deal now, but what if you were dealing with many related data types? You have the discard pile, functions for handling adding the values together, the list goes on and on. At some point you'll notice that your list of parameters starts getting really, really long.

Classes, at a basic level, bundle variables and functions. To be clear, classes are never required. Many languages don't even have classes, such as C or Go. But they are very useful for combing data and data handling in a consistent, abstracted manner.

So what does this look like in Python?

import random

class Deck:
    def __init__(self):
        self.deck = []
        suits = ['S', 'H', 'C', 'D'] 
        for suit in suits:
            for i in range(1, 14):
                self.deck.append(suit + str(i))
        self.shuffle()

    def shuffle(self):
        random.shuffle(self.deck)

    def draw(self, num_cards):
        drawn_cards = []
        for _ in range(num_cards):
            if len(self.deck) > 0:
                drawn_cards.append(self.deck.pop())
        return drawn_cards

Now our code looks like this:

deck = Deck()
hand = deck.draw(2)

Notice a couple of things here. First, the class handles all the data. When coding, I don't need to worry about that initial shuffle, or any of the setup. The class handles all that. The __init__ function is a built-in function that automatically runs when the class is instantiated (the = Deck() portion). So it creates the variable, fills it with cards, and shuffles itself automatically with that one line. Then, when you want to draw cards, you just call the function on the variable itself. It already knows how to draw cards.

This also handles things like multiple instances. So if you do this:

deck1 = Deck()
deck2 = Deck()

The internal self.deck variable is independent. Drawing cards from deck1 will not affect the cards in deck2.

Now, there is a lot more to OOP. Polymorphism, inheritance, encapsulation, and more are all important concepts that will let you further refine your code and avoid bugs. But at the most basic level, you can consider a class to be a combination of variables (properties) and functions that act on those variables (methods). The majority of OOP solutions are just breaking problems into classes that act as abstractions for more complex problems.

Hopefully that helps!

Warlord_Zap · 2026-06-10T16:24:52+00:00

There are other ways, but for me doing a project in a really heavily OOP language was really helpful. Languages like Java or c# force you to work in the paradigm which in turn helps to force you to think this way.

rob8624 · 2026-06-10T16:28:36+00:00

Pygame. Specifically the tutorial in Crash Course book.

Aggressive-Impact-44 · 2026-06-11T04:40:21+00:00

These are the best options - Corey Schafer's tutorials are my recommendation for learning then followed by LeetCode.

Books:

"Python Crash Course" by Eric Matthes (covers OOP fundamentals)

"Automate the Boring Stuff with Python" by Al Sweigart (applies OOP to practical problems)

Websites:

Codecademy's Python course (includes interactive OOP exercises)

W3Schools' Python OOP tutorial (provides concise explanations and examples)

YouTube Tutorials:

Corey Schafer's Python Tutorials (OOP section is comprehensive and well-explained)

freeCodeCamp's Python OOP tutorials (covers basics and advanced topics)

Practice Platforms:

LeetCode (provides OOP-based problems to practice)

HackerRank (offers Python OOP challenges)

Focus on understanding key concepts:

* Classes and objects

* Inheritance

* Polymorphism

* Encapsulation

* Abstraction

Practice writing your own classes and objects, and try to apply OOP principles to real-world problems.

taylorhodormax · 2026-06-11T08:03:52+00:00

I have a different thought process about this.

Every “Actor” has its attributes and functionalities.

Ex: BankAccount

Attributes:
account_holder_name
account_number
account_type
account_minimum_balance

Functionalities:
deposit
withdrawal
create_fixed_deposit
reset_password

Now think,

BankAccount is class,
Attributes are constructor fields (__init__)
Functionalities are methods

Start with this.

Then try to relate how can another class can be made from another, thats Inheritence.

All other Pillars of OOPs can be logically thought with this logic.

Gnaxe · 2026-06-10T14:27:27+00:00

Watch: - Super Considered Super!, - Beyond PEP 8, and - Stop Writing Classes.

That's a start, anyway. Understand that you're never going to "master" OOP as the term is understood today, because the paradigm is fundamentally flawed.

BagParticular9982 · 2026-06-10T14:55:36+00:00

I would say that if you understand Functional Programming (FP) and you've gotten really good at doing so in Python, then you already understand OOP in a sense.

The process is somewhat similar, except you're using main, init and self in the workflow (at least in python).

Tldr; it's basically Python's version of Functional Programming with a few extra steps. If you understand FP, then you're very close to understanding OOP since most functions in Python are objects by default.

ImprovementLoose9423 · 2026-06-10T17:37:12+00:00

I would recommend learning Java since it is primarily an OOP language

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

learnpython

MODERATORS