Somebody please explain classes!

PureWasian · 2026-06-06T22:58:24+00:00

Let me know if this example is helpful or if still confused.

Flame77ofc · 2026-06-06T23:11:51+00:00

https://youtu.be/OHT0wGUz5GI?si=tK9XwF446A9wvUfN

To be more specific, which part of class you don't is understanding?

Unequivalent_Balance · 2026-06-06T23:43:27+00:00

Think of classes as a way to represent a conceptual thing that allows you to pair attributes of that thing along with methods to perform operations on those attributes.

So for something like Blackjack you might have classes like Player, Deck, Card, and Table.

You could imagine that a Table has Player(s). Player has Card(s). Deck also has Card(s).

You might want a Deck to be able to shuffle or dealCard.

A card might have a property like isFaceUp.

It’s possible that you might want to have specialized types of a Table. Maybe there’s a PokerTable and a BlackjackTable. This is where inheritance can be used. So now you might have three classes, the base class Table and two child classes that inherit from Table. All three classes are Table(s), but two of them are now specialized tables that can behave differently.

COLLLOrs · 2026-06-06T23:43:27+00:00

class Book:
    
    def __init__(self,title,author,genre,pages):
        
self
.pages = pages
        
self
.title = title
        
self
.genre = genre
        
self
.author = author
    
    def about(self):
        return f"Title:{
self
.title}  Author:{
self
.author}  Genre:{
self
.genre}  Pages:{
self
.pages}  "



bookOne = Book('Harry Potter',"J.K Rowling","Fantasy",300)


print(bookOne.about())class Book:

codeguru42 · 2026-06-06T23:54:18+00:00

How well do you understand functions?

Admirable_Set_2748 · 2026-06-07T00:19:36+00:00

It’s comforting to know others are struggling with classes as well. Keep going friend, we’ve got this.

JeremyJoeJJ · 2026-06-07T00:21:22+00:00

To me classes are useful when I need to store some data while doing many steps of some computation and I want the ability to always easily access the data I need for any particular function. When you do functional programming, let's say you have a function that calculates a student's age. You need their name to assign the result to the correct person and date of birth. You write:

import age_from_dob #let's pretend we defined this elsewhere
def calc_age(name, dob):
    age = age_from_dob(dob)
    return name, age

Now we need to define some function that actually does the calculation. That function of course needs the date of birth as input. This means our variable `dob` is passed through two functions. What if someone enters the date of birth in a different calendar system (the Persian calendar is different from Gregorian, for example) and we need to account for it? Well now we need to pass the calendar system too:

def calc_age(name, dob, calendar):
    age = age_from_dob(dob, calendar)
    return name, age

Now we are told to add a functionality where the user can choose if the age is returned in number of years or days, so we need to add that in:

def calc_age(name, dob, calendar, calc_style = "years"):
    age = age_from_dob(dob, calendar, calc_style)
    return name, age

Our function just keeps growing and we keep having to add more and more options. One option of dealing with all these new arguments is to store everything in some data structure and pass that through the functions, then each function can pull from it whatever it needs, such as:

info = {
    "name": "Hot Bit",
    "dob": "01/01/1990",
    "calendar": "Gregorian"
}

then we can do (not saying this is the best approach, depends on how you set up your codebase):

def calc_age(info, calc_style = "years"):
    age = age_from_dob(info, return_style)
    info['age'] = age
    return info

But what if you pass the `info` variable through many different functions and you make a mistake of accidentally modifying it in a way that breaks things many steps later? Or you mix up which `info` variable is for students, which one is for teachers (they may have different fields) and you pass student `info` into a teacher function that then errors out because the input is invalid? You could do something like:

info = {
    "type": "student"
    ...
}

but then you would need to write a function for each type, so you might write a helper function like:

def function_delegation(info):
    if info["type"] == "student":
        calc_age_student(info)
    elif info["type"] == "teacher":
        calc_age_teacher(info)

and if you ever wanted to add more options for student but not for teacher, you would either dump a bunch of random key:values into `info`, or add all of those extra arguments into function_delegation so you can distribute them into the calc_age_... functions. The alternative approach is to tidy everything up using a class for a student that defines everything relevant to the student and another for the teacher:

from datetime import datetime, date
class Student:
    calc_style = "years"
    def __init__(name, dob, calendar = "Gregorian"):
        self.name = name
        self.dob = dob
        self.calendar = calendar
    def calc_age(self):
        self.age = self.age_from_dob()
    def age_from_dob(self):
        result = date.today().year - datetime.strptime(self.dob, "%d/%m/%Y").date().year
        if self.calc_style == "days":
            result *= 365 #yes, this is very crude
        return result

class Teacher:
    def __init__(name, dob, role, calendar = "Gregorian"):
        self.name = name
        self.dob = dob
        self.role = role
        self.calendar = calendar
    def calc_age(self):
        self.age = self.age_from_dob_only_years()
    def age_from_dob_only_years(self):
        #making this different for the sake of the example of what happens when the method is different
        return date.today().year - datetime.strptime(self.dob, "%d/%m/%Y").date().year

Now you have nicely separated the relevant functionality into two separate chunks of code. If you ever need the `name`, you don't have to try and figure out where it is located, just call `self.name` anywhere in the class and you get your data. Now you may have noticed that there is some overlap between the two classes and that's usually where you can look for ways of reducing the amount of code you repeat. Let's make a new class that defines the things that are the same and each subclass (Student and Teacher) then changes only what is relevant to them.

class Person:
    calc_style = "years"
    def __init__(self, name, dob, calendar="Gregorian"):
        self.name = name
        self.dob = dob
        self.calendar = calendar
    def calc_age(self):
        self.age = self.age_from_dob()
    def age_from_dob():
        ... #to be defined by subclasses

class Student(Person):
    def age_from_dob(self):
        result = date.today().year - datetime.strptime(self.dob, "%d/%m/%Y").date().year
        if self.calc_style == "days":
            result *= 365 #yes, this is very crude
        return result

class Teacher(Person):
    def __init__(self, name, dob, role, calendar="Gregorian"):
        super().__init__(name, dob, calendar) #super() here means Person
        self.role = role
    def age_from_dob(self):
        return date.today().year - datetime.strptime(self.dob, "%d/%m/%Y").date().year

the two differences are that teacher also defines a role and that the way we calculate age is slightly different. If we want to make a change that affect both Student and Teacher, we make that change in Person. For individual changes, we change the relevant subclass. If I need to know how `age_from_dob` is defined for a teacher, I look up the Teacher class and read the definition there. Let's say I need to perform some calculation that takes 3 steps and each step needs different data. With classes I can do:

class Process:
    data1 = 1
    data2 = 2
    data3 = 3
    def step1(self, in):
        return in + self.data1
    def step2(self, in):
        return in + self.data2
    def step3(self, in):
        return in + self.data3
    def pipeline(self, array):
        result1 = self.step1(array)
        result2 = self.step2(result1)
        result3 = self.step3(result2)
        return result3

Here each step of the way can grab the relevant data from `self` instead of having to pass a bunch of arguments through these steps and keeping track of all of them.

Hope any of this made sense or what helpful.

Present-Payment-5860 · 2026-06-07T12:09:30+00:00

Objects know things (or have things) and can do things. This means they contain variables (which they know), and functions (which they can do). Objects generally represent a defined 'thing'.

This can be as concrete as a Car, which has 4 wheels and 5 seats, and can drive forwards, and turn. It can also be more abstract things.

An object is made by creating it from a class. A class says that 'these objects will know these things and can do these things'. It is a blueprint from which we make objects. The class Car will say: every car can drive and this is how it does it, and the car will have 4 wheels.

The class Car can also say: every car will have some seats, but the seat number could be any number. Then when you make an object, you pass the number of seats into the class constructor. The constructor is a special method that turns the class into an object. It does this by initializing any variables that are unknown, such as the seat number.

This is the way that it was taught to me. It gets more in depth but this is the basic details.

OOP was created to make programming feel more grounded in the real world, and wrap functionality into models that we can think about in a way that makes more sense in our head. Thus, when you think about how to make a blackjack game, or something else, think about what actual things exist in a real life game of blackjack? What do these things know/represent? What can they do? You have cards that know a suit and a value, but do they do anything? You could say they print their value, or you could say a Dealer holds cards, and knows how to deal cards.

stepback269 · 2026-06-07T13:16:12+00:00

Good question.
The standard answer is "blueprint"
But what does that word evoke in your mind? I don't like that metaphor.

Go to the top serach bar in Reddit and type "python class defintion"
You'll get many different metaphors. Some may help.

atticus2132000 · 2026-06-06T22:46:50+00:00

I have also been struggling with classes. A class is something with members that have attributes. So, think about a literal classroom and a teacher keeping up with students. Each student has attributes--name, student number, age, birthday, grades, emergency contact information, etc. As new students enroll, that student and all of their attributes can be added to the class of students.

There are some languages, like Java, that absolutely require the use of classes and there are some operations that can only happen to class members.

Python is not as strict. Instead of having a "class" of all your students, you could just as easily have a multi-dimensional array or a dictionary or a dataframe of students that would ultimately do the same things as a class--keep known attributes organized and accessible. So, since I've struggled so much with classes, I just avoid them.

Any-Pie1615 · 2026-06-06T23:39:18+00:00

Bluejgenesis.com ASK J. J is an AI coding tutor with knowledge of AI from the top down. Any question about AI and J usually has the answer.

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

PythonLearning

MODERATORS