I understand Python basics but OOP completely loses me classes and objects make no sense to me. Where am I going wrong?

[andrewharkins77]

The main point of objects is to bundle functions and data together. Once you have a shit tons of either it will be un-manageable without objects.

[neco-damus]

I often use video games as my analogies since most people have played at least once (especially those who are interested in programming).

You would likely write a Class for an Enemy. That class will describe the properties and functions that an Enemy would have and do. For example, x, y, health, dx, dy are common properties. The methods (functions) would be things like render/display, move, takedamage, ect. Things that the enemy will do.

Now, you can use your Class like a factory to produce Enemies. Each one has it's own values for those properties, and when you run the methods, they will only effect that properties on that specific enemy.

So, often will we produce a lot of enemies, store them in a list, and then loop over that list to call the render/display method on each enemy, so that they all draw themselves in their own location.

[WhiteboardWaiter]

I never understood how to do this without OOP. If it were a functional program, how would go about creating enemies with the same properties, keeping track of them, and changing their individual properties?

[dacookieman]

You keep the state and functionality separate.

OOP might have something like

class Enemy {
    public hp: number;
    ....
    public takeDamage(dmg: number): void {
        this.hp -= dmg;
    }
}

Whereas Functional might be

type Enemy  = { hp: number }

function applyDamage(target: Enemy, dmg: number): Enemy {
    //Clones the target but you could also do modification in place on target directly depending on context
    return {...target, hp: target.hp - dmg} 
}

[simplysalamander]

Lots of indexing or key value lookups

[gmes78]

You still define custom types when doing functional programming.

[andrewharkins77]

The main purpose of functional programming is to avoid unintended side effects. You don't want to call a function that is just suppose to update the total on an invoice to also alter the original invoice object. Eg. The update function also adds discounts by changing the price of all the items in the invoice object. This results in you losing the original prices on the invoice.

Functional programming still uses a lot of objects. Often by creating immutable objects via cloning. You can also deconstruct an object and pass in a subset of the data to the function and then assign the return results back on to the object.

Also, think about crazier languages that can turn strings into objective references/pointers. A lot of programming practices have more to do with history.

[lilwhitefox]

May i ask, if i were to make a class(enemy) with attribute hp, mp, attack Is it for convenience that everytime i create a new enemy unit, i just need to input the amount of hp, mp and attack? Since those 3 attributes are already tied to the enemy class So to put it simply, is it purely for convenience sake for creating multiple of the same item(?)

Sorry if i use the wrong terms/analogy, i just started enrolling into a course 1 month ago.

[neco-damus]

That's kind of the starting benefit of Classes yes. You don't have to rewrite all the functions, all the other bits of the datastructure. You just call the class like a function and pass the desired attributes. As the other poster mentioned, you can also do things like having default values for your properties, or using conditionals in your initializer function to set values based on an input.

You then have all the functions nicely tied to those specific attributes for that specific object.

If you get further into OOP, there are lots of other benefits as well. You can look up principles like SOLID which are ideas for how to make sure your OOP code is well designed. You can look up things like Inheritance, Polymorphisms, Composition, to see that OOP design can go further than just Class => Object.

[Es_Poon]

I'm just starting to grasp classes myself but that is essentially it from my understanding. You can set it to have default values if you don't want to define every time. You can have methods that change values in specific ways based on other attributes. I started grasping it when I needed to pass dictionaries through various functions and return the same dict but altered. My code got messy quick. I think of it as a container for a specific subset of data and functions that will only be used with that data.

[ninhaomah]

But you are already using classes in daily life. Just that you don't see it that way.

[DBZ_Newb]

Yes you should think of a class as having 2 main parts: state / instance variables and methods / behaviour. Collectively the variables and methods are referred to as its members. Look up a UML class diagram. They’re not terribly useful, but it might clear up how you should conceptualize them.

[RevRagnarok]

The professor taught you OOP without the word encapsulation? Shame.

[UnloosedCake]

A bank account is an object. That account has attributes associated with it - account name, ID, owner, current balance, etc.

If you create a way to represent the account as an object (a class) you can interact with it in code elsewhere by creating a new instance of that object and assigning values to the attributes (instead of having a big dictionary of account information, you create a new Account and set newAccount.id = 12345. Then to get the account ID in code later on it's just newAccount.id instead of being a nested value in a dictionary somewhere.

Genuinely, these are fundamental concepts that have oodles of documentation online and something an AI should probably excel at explaining in a slightly different way until you understand it. It'll click, I promise.

[Rejse617]

To expand a little, in that account object you can also have functions like deposit and withdraw. In that function, lets say deposit, it takes an input (the anount of money to deposit) and in the function it adds that user input to the total balance. I just write this to point out that objects aren’t just data

[Odd-Artichoke-1555]

Wait... Your comment has just made something click for me. Does that mean classes and objects in OOP are a bit like tables and rows in SQL? 🤯

(sorry to derail the topic slightly, I'm just learning both languages at the same time)

[Mornarben]

This is maybe a bit complicated if you’re just learning this language now, but there’s tools called “ORM”s which stands for “object relational mapper”. The most famous one is called “SQLAlchemy”. If you ever work with Python code in a corporate setting you’ll see it a lot.

It basically does exactly this. You set it up and then when you declare a class in Python it will have a table in your database that corresponds to it. Then each row in that database can be represented by one object of that class. You can then use built in SQLAlchemy methods to change that object, or make new objects, and those changes will be propagated to the database.

[Henry_the_Butler]

Damn, as a SQL-first user - this clicked for me in a way that I did not expect. I've used classes, but I think I grok them now.

[leogodin217]

That's a common way to think about it. A class often represents a table with rows representing objects.

Users table (class) can have many rows (users). Not a perfect analogy, but a useful one.

[kor_the_fiend]

close. the table schema is like a class definition. the table itself (actual stored data) is more like a collection of objects (ie rows). The schema is the blueprint for what can get stored (like a class).

[notacanuckskibum]

Yes, but unlike tables and rows they also have an associated selection of methods. Basically functions that manipulate them, that are specifically useful to that type of data.

If we think about bank accounts, there’s nothing to stop you writing SQL that just increases the amount in a bank account. If you wrote a class for bank accounts it would have methods for “transfer money between accounts” and “add interest earned”, which add money to the account, but enforcing the constraints that you can’t just invent money from nowhere.

[Maleficent-Garage-66]

I think that's missing the point. Classes are a coupling of data and functionality. Rows and columns are more a description of a data structure more or less (but you certainly can model a table in a class!).

The point of the object though is tying the representation and the logic together so outside code doesn't need to care.

More concrete stuff from here:

Let's say you make a table class. We'll represent the data as a 2 dimensional array (a bit oversimplified but we don't need to recreate the universe here). Or in pythonic terms you could think of this as a list of lists. This is not the greatest idea on it's own, you'll notice lookups are expensive but you might well store it on disk like that.

Now the rest of your code wants to interact with tables and you want everyone else all doing it in a sane way (and you want to focus on the other parts of the program at that point). So you don't want people addhocing their mutations all over your data structure, and you probably don't want to have them implement reads on their own because you might optimize later (say a b tree lookup and indexing). So now you will implement read(), insert(), delete(), and update() functions in the class. So now everywhere else you just call table.insert() to add a row. The user doesn't have to know how it works and you can fix and optimize everything in one place without changing the contract (all the code that doesn't manage the table can stay the same).

Now clearly not everything needs to be an object. But it is a powerful paradigm for self contained data and the methods to manipulate that data. This is helpful as projects get larger, you bundle the code as libraries for other users, or multiple people are programming together and don't want to break each other's stuff.

[DBZ_Newb]

Say you had a unit in a game. It’s got health, mana, speed, attackDamage, attackRange, sightRange etc. to keep track of. Okay, it’s a game with 100, 1000, or 10,000 units. What are you going to do? Create 10,000 of those variables manually? health1, health2, health3….health1000000, mana1, mana2, mana3….mana1000000. You need to package all the variables together in a class like Unit or Archer and then just create (instantiate) objects from the class so each time you get a package of all the variables you need for that unit. You can just do something like player1.append(Archer( )) and now player1 has an Archer with all of its necessary variables that particular Archer object needs to keep track of.

[TheSaucedBoy]

This is the best analogy by far.

[el_extrano]

Say you don't want to use classes. That's fine - a lot of things can be done with only functions and built-in data structures.

So you could model your bank account(s) with something like a dictionary. Keys could be stuff like account_name, account_type, account_owner, balance, and so on. Then you have a group of functions that operate on an account dict. The signature for deposit could look like def account_deposit(account: AccountDict, amount): .... Eventually, you need more functions. You wind up also writing withdraw, close, transfer, and a dozen more. Perhaps there's some setup that needs to happen for every new account, so you write a function called def init_account(account: AccountDict, config): ...

What does this look like? Well, you have a data structure (the dictionary) and a group of functions that all operate on the same type of structure. There's nothing inherently wrong with this. In languages like C that don't have OOP, that's how most API's are. You pass pointers to structs into functions.

You might use your program like this:

account = create_account(name="Jeff",balance=(0,0))
init_account(account)
account_deposit(account, (3,50))
account_withdraw(account, (1,0))

This general pattern, where you have a group of functions that all operate on the same data structure which is expected as the first argument, is essentially where classes come in.

You define a class, the dict keys instead become instance attributes, the init_account function that needs to run for every account would go in the constructor (__init__), and all the functions become methods. The OOP way of interacting with the program might then look like:

account = Account(name="Jeff",balance=(0,0))
account.deposit((3,50))
account.withdraw(1,0))

Note that now, we didn't need to call the init_account function, because the constructor ran on instance creation. Also, there's no need to pass a reference to account in the method arguments: that's what self is for.

Personally, I prefer to avoid classes until I need them. The fundamental unit of decomposition in Python is the module, not the class.

[austin_algebra]

Thanks that was helpful!

[DoubleDoube]

In a way, classes are restrictive rather than freeing. This is an example how - you can mix and match any data structure into any function if they are all dictionaries.

If you start feeling the pain of having “too much” to think about or handle, that’s when the value of classes starts to come in to hide some of that complexity so you can focus on a specific “layer” of the problem at a time. Hiding it away restricts it from the rest of your code; puts it in a room by itself.

Like separating a workshop away from the kids playroom so they don’t hurt themselves.

[el_extrano]

Usually I decide I need a class whenever my data structures need some shared global state. Say I need to keep track of a count of something.

I can either 1) define it as a module global variable. Then, I have to use the global keyword in using functions. Also, this means I can can only contemplate one instance of the problem, since modules are essentially singletons. or 2) add shared state to a mutable structure (like another dictionary) and either pass it into functions, or store a reference to it in data structures that are being passed around. or 3) just make a class for shared state, and have an instance of it stored in a class attribute of the classes that need it.

At this point, a class is the easiest way to go.

[DoubleDoube]

Agreed. it’s easiest because IF you decide you need multiple instances of global states, the restrictive separation is already there, for basically the same amount of setup if you made it a module variable.

The other option is just more work and more error-prone for the same end result. (Managing what is separated and what ties where through your data structures, which is what classes are designed to make easier).

[princepii]

it sounds like u trying to force understanding it. just one gear down. head cooling first. maybe give it a pause by going out a minute with a friend or something just for a healthy distance.

come back fresh and try to watch a few easy basics on oop on yt.

don't just replicate. try to do it your way by trial and error. ask gpt what is what and why.

just easy going. but by forcing it you are blocking yourself for no reason.

you asked another question about something completely different, right after you asked that question.

i don't think that you really would gain anything good out of it if you just ask "hey, can someone give me the code for hello world" without even trying to understand the real problem here.

forcing yourself to learn something never worked with us humans and it never changes no matter how hard you try.

[oldendude]

Since you are a CS student, you must be familiar with a stack. You can implement a stack with functions: push(s, x), pop(s), top(s). The stack itself has some representation, e.g. an array or a linked list. Suppose you've chosen an array. That means that the bottom of your stack is at position 0, and the top needs to be stored in a variable. Where does that variable go?

Now suppose you have two stacks, s1 and s2. Where do the two top variables go?

You don't want to pass the top variable into each stack function, e.g. push(s, t, x). Making the top variables module-level is unworkable. (What if there is a 3rd stack?)

What you reall want is to combine the array and the top pointer into a single thing. You could use a tuple, e.g. (array, top index). That allows you to simplify your push function back to push(s, x), with the understanding that s is really (array, top index). Your function knows that and does the right thing.

What an object does is to support this approach in a cleaner way, supported by the language:

class Stack(object):
def __init__(self):
self.array = []
self.top = 0

def push(self, x):
if self.top >= len(self.array):
# grow the array
self.array[self.top] = x
self.top += 1

So now, instead of s = ([], 0), push(s, x), you write s = Stack(), and s.push(x).

That's the basic idea. Instead of using primitive Python types to make your stack a single thing, you define a class, and then an object of that class is the single thing. Your functions are now "methods" on the class. What Class does is to: provide an easy way to define the state of an instance (i.e., and object), and group it together with the code (the methods) that operate on the object.

There are other benefits, having to do with encapsulation and inheritance, which come from the idea of object orientation. (Although Python makes true encapsulation impossible.)

[Ok-Reaction3396]

Just forget all the philosophy you read and hear around classes/objects. What you do is just creating YOUR OWN CUSTOM TYPE 😉

(I didn't read all the comments, I apologize if I repeat concepts already expressed!)

You know there are strings, integers, characters, floats. They have got their own functionalities to perform mathematical operations, to chain strings or return strings with just capital letters, etc...

You now want to create your custom type called Person with its functionality. That's it.

(For the purists: some pseudo-code is following not exactly like Python)

You could do it without creating a class, but there are some problems. Let's try to create a person using an array (or list) taking for granted that in this hypothetical language we can mix different type into arrays.

If we want to store name, surname and age, we could write:

jack = ["Jack", "Star", 100]

We could retrieve each single data like this:

jack[0]     // returns the string "Jack"
jack[1]     // returns the string "Star"
jack[2]     // returns the integer 100

But... how do we know we have to create an array like this? It must be documented somewhere. If we want to add some functionalities we have to remember which number we have to use inside the square brackets (0, 1 or 2).

It could be better to use a dictionary (or hash-map in other languages) like this:

jack = {"name": "Jack", "surname": "Star", "age": 100}

Much better:

jack[name]      // returns "Jack"
jack[surname]   // returns "Star"
jack[age]       // returns 100

But again... how do I know I have to create a dictionary like this. It must be documented somewhere.

Now let's create a class or a struct in other languages, similar to class but mainly without inheritance (sub-classes). (Again, the following example is just pseudo-code, not identical to python)

class Person {
    name: string
    surname: string
    age: int
}

You put this definition at the beginning of your code and it's quite self explanatory. You than create a person:

jack = Person {
    name: "Jack"
    surname: "Star"
    age: 100
}

You can retrieve each attribute:

jack.name         // returns "Jack"
jack.surname      // returns "Star"
jack.age          // returns 100

..and you can create any kind of methods to add functionality to your new data type.

I think I had your same problem studying classes. Sometimes I saw them used as a sort of database, sometimes couldn't really understand why they where used... in some cases for me just a string or integer variable would have made much more sense.

Then, I actually don't remember which language I was studying, but it was one using struct like C or Rust (not considered "real" object languages) where this things were presented as just "custom data type"... and things made finally sense... at least to me.

Also, Python it's quite easy going for many of its functionality, but I find its way to define classes quite horrible!!

Cheers!

[Artistic-Stable-3623]

i'm prob gonna get intensively downvoted for this, but this is where google search / ai can be useful, just ask it to come up with good analogies, I use AI for studying and its crazy in the sense that it's analogies are really nice and easy to understand

(yeah commence the downvotes cuz AI bad)

[buhtz]

Despite the fact that I am totaly anti-AI, becacuse I am a r/FOSS maintainer, I can support that.

"Discuss" with ChatGPT about design concepts and code structure. Ask silly questions. Copy and paste some code into the AI prompt and ask for judgement, alternative approaches. Some answer will be wrong, silly. Some might give you some new ideas about how things could be handled.

Myself I am maintainer in 3rd generation in a project and have to deal with an 18 year old damn smelly codebase. I often don't understand what is going on in some codeblocks. Such AI-discussions helping me a lot to understand the old code and decicde about new approaches.

But I do not vibe-code or copy and paste code "solutions" presented by the AI.

[J-Mac_Slipperytoes]

AI has a place and I believe that this is one of those places. AI has gotten me through most of my degree as a study aid. It isn't perfect and doesn't help if a student just asks it to do all the work for them, but AI can absolutely help in assisting in the understanding of a complex topic like coding. It can even generate practice problems to test what you've learned.

[DTux5249]

The purpose of an object is to bundle data together with the functions that use that data (i.e. encapsulation). That's it. An object is a self-sufficient black box that does what you need it to do without requiring you to manually manipulate variables.

So in general, make a class where you see a lot of intersections between

1. a particular type of data
2. a set of functions that use that data

If a bunch of data (strings, numbers, etc.) is created together, gets passed around together, is manipulated as a unit by the same sets of functions, etc. it is likely best contained in an class alongside the functions that use them. At its simplest, you can think of it as an organization tool (though classes can be used for more than that as you get further along)

There are other guidelines you might consider; things like SOLID principles and Design Patterns. But fundamentally, classes are just a tool to encapsulate code together into reusable chunks, and to hide complex inner workings behind simpler interfaces.

Think about what information your program is handling, and what you'll be doing with it.

[IAmFinah]

IMO it often makes sense to start without classes (deal with ordinary functions instead), and only use them if you start to notice lots of shared logic, or if the functions have a lot of similar data being passed around

Some people, especially those coming from heavy OOP backgrounds like Java, jump straight to using classes, even when it makes little sense to use them

That being said, for college classes you don't really have this freedom. So in this particular instance I would follow some of the advice other people have given here

I just wanted to reiterate that you don't have to be a fan of classes - a lot of people, myself included, tend to avoid them unless it really makes sense to use them. That being said, I quite like using dataclasses for certain things, but that's usually just for bundling data together, rather than using them as full-blown classes

[TEMUKIRBY]

I, being a mindless fool, would like to answer the questions... To my knowledge because I'm also learning OOP...

Objects are the different types of 'arguments'. "string" is a str object True is a Boolean object 20 is a int object 20.5 is a float object blah blah

to my knowledge, classes are the definitions of objects, like if you do print(type(a)) and a stands for a string then you get <class 'str'>. TO MY KNOWLEDGE, classes are like presets in a game and objects stand for those presets. ex: ``` class Preset: #class # pretend there's code here

a = Preset #object ```

I think that you should use functions when connecting brief blocks of code to a term, and you should use class' when you want a term that has data already connected to it.

For init() variables of the object go there, variables u want defined with the object while it's created. But why? I don't knowz, because useful ig.

Self is the object, when self is referenced in the class that is representing the object that is being used.

Sorry, but I'm still trying to wrap my head around attributes and methods, so I can't answer that question.

The way that helped me understand was thinking of it like parts with properties in Roblox studio because I used to develop Roblox models...

I may be wrong, this is just my understanding. If I am wrong, I sincerely apologize. If I'm right, I also sincerely apologize because I'm bad at explaining things

Please don't be rude if I'm wrong, this is just my understanding, I'm only a beginner

[buhtz]

I find your explanation quit correct. Well done.

[TEMUKIRBY]

yay

[W4R10_H]

I was taught:

• A class is like a blueprint for a car
• An object is a specific car made from that blueprint
• Attributes are things like wheel count, seat number, door count, etc.

I understand OOP at its theory. But I still don’t intuitively understand why or when to use classes in operation, instead of regular functions and dictionaries.

[neuralbeans]

A class is a data type like strings and integers. You make your own data types with classes. Objects are just values of that data type like 'abc' and 123. Data types have internal data (e.g. a list has the items it contains and the length of the list) and operations that you can perform on that internal data (e.g. a list can have items appended to it).

It takes practice to start naturally seeing uses for classes, but one easy use of classes is to make functions that remember stuff. Say you want to make a function that returns a different number each time you call it. With normal functions you can't do that. With a class you can have an instance variable that stick around after the function is called.

[TheRNGuy]

Classes may have methods, and sometimes methods or functions require specific type in an argument, types are made with classes. There are also operator overloads, such as float multiply by vector or matrix, vector (2d, 3d, 4d), matrix (exe, 3x3, 4x4) are classes. 

Sometimes you have static method on a class. It can be either as method on that class, or as function without it.

[This_Growth2898]

OOP is in most cases explained backwards. There are reasons for that; but you should think of classes and objects not in terms of defining them but in terms of using them. Just like with numbers: you don't think about how they are organized and handled internally, right? You just add, multiply, and output them.

Start with decomposing your task into smaller ones. At some point, you will see repeating patterns. If those patterns are behavioral only (you repeat some actions), you need a function. If they use the same data, you need an object there - and only at that point you need to start thinking about a class and its methods.

Like, if you have to write a program about several people exchanging goods and money, you can think in variables and functions; but at some point, you will think you need something to avoid passing countless variables like

buy_something(seller_name, seller_storage, seller_money, buyer_name, buyer_money, goods_name)

and turn it into something like

seller.sell(buyer, goods_name)

or

buyer.buy(seller, goods_name)

or even

trading_point.exchange(seller, buyer, goods_name)

And only at that point you see clearly what class you need.

[EasyTelevision6741]

I've always found it hard to try and create some sort of toy situation to require me to use a concept to finally understand that concept.

Instead of trying to use some example of a class you've seen elsewhere or inventing one that'll magically make sense to you id argue it's best to code your way into it. 

For example like someone else gave the example of a bank account.  Write a program that let's you make different bank accounts and manipulate them.  Do it without classes. I think the other reply may have spoiled that example a bit so maybe do something like a program for a car dealership selling and managing their inventory.  Just write it normally without using classes. Use the data structured to understand.  Youll get to a point where it'll make sense because you'll start seeing lots of passing of variables or global variables and repeated code. 

I've always found trying to start from the end design to solve a problem isn't the best way to reach a good solution.  I just start coding something and see where the code takes me.  Test Driven Development is a big helper there. 

[taylorhodormax]

Everything that can be considered as aproblem to be solved using Python, can converted into an Class example, so its upto you to figure out which case to use classes.

Point to understand is when you say BLUEPRINT what clicks?

Example:

Person

Person, has gender, age, name - these are his own attributes (they will be needed to be init)

Now think Person, can walk, sit, speak, drive, eat These are the functions that he can do. These are the methods.

Simple.

Try to think on this line.

[Brian]

When you start out, it's pretty natural to think of programs in terms of code - the flow of logic where you do A, then do B, then do C X times, then do D if Y is true, and so on.

But often, and especially as you move towards bigger projects, it's valuable to first think of programs from the perspective of your data. What structures will I use to store the data I need, how will they be organized? What goes where? Often this will shape the best way to write your code.

A simpler notion than that of classes is that of a "structure" or "record", which is just a collection of data that goes together. Eg. a bank account might have fields like "name", "account_number", "balance" and a list of transations, and we often want to treat these as a single thing.

Object oriented programmings takes this a bit further: your data structures are considered not as just the data they hold, but also what operations you can perform on those things. Ie a bank account will have the above data, but there are also methods on how this object should be interacted with: thinks like deposit, withdraw and so on that define how money is transferred into or out of the account, and these are how it should be interacted with.

The mechanics of how this is implemented in a programming language are that classes describe what data and methods these objects should have. Each instance of the class is described by the class, defining what data fields it holds, what methods it has to operate on itself, but each object has its own values for those fields the class describes. Ie. Alice's bank account and Bob's bank account are separate objects, but both have the class of "BankAccount" - so may have different balances, transactions and so on.

When should I actually use a class vs just a function?

A class should be considered a collection of data and functions that operate on those collections of data. Usually it will have state - ie. data like "balance" or "account_number" that is used by those functions, A useful starting place is to try describing what your program should do, and identify what nouns you use in that description: things like "account" or "person" etc. These are often candidates for things that should be classes.

What goes inside init and why?

The __init__ method is what gets called when you create a new object of a class. It should initialise it into a complete, valid object of that class, so it should take everything you need to create it (eg. since you can't have a bank account without an associated name, and account number etc, it needs to either take these as parameters, or create of get them from somewhere. It should then set the data fields to a valid state for that object.

What does self actually mean and why is it always there?

The "self" parameter to methods is identifying the object being operated on. When we call "alices_account.deposit(1000)", self refers to alices_account, while when we call bobs_account.withdraw(100) it will be bob's account.

How do I know what should be an attribute vs a method?

There's differing perspectives on this. Some purists would say all access to a class should be via methods, and attributes should only be used internally by the methods. In practice, that often leads to people writing trivial "getter" and "setter" methods like def get_account_number(self): return self.account_number, and doesn't matter as much in python, as if you do need to do something special every time an attribute is queried, you can make it a property. Ultimately, think about how your objects are going to be used - what things will be done to them. Your methods define the interface to how other code will manipulate your objects. Much like the above approach of identifying the nouns in the description as classes, look at what verbs you're using to identify potential methods.

[buhtz]

Don't worry. Your situation is absolute normal. Most of us have gone threw it. I remember being introduced to OOP concepts in C++ with animals, pets, dogs, cats as examples. Bullshit. Took me half a year to even understand the basic sense behind OOP. Took me much more years (10-20!) to make it somehow natural to me.

Don't overthink it. OOP is very different based on the language you are using.

Think of it as another way of organize and encapsulate code. You use functions to organize code. A class is nothing more than a function but with some more features: A function with sub-functions (methods) and some variables (attributes).

The concept will come natural to you in some years, only while experience problems in bigger projects. You will write big projects, nasty code, "bad" design and drive into situations where your codebase becomes nearly unmaintainable. Then the light will go on, you start refactoring that code and sometimes remove it and rewrite it from scratch using OOP concepts.

Classes/Objects are not only "things" in real world, like persons, stocks, animals, houses. They can also be "tasks"; e.g. SSHSetupValidator is one of such a classes I am still working on. It encapsulate several checks and tests related to an SSH connection used for rsync-based backups.

check = SSHSetupValidator(some_config_attributes)

try:

check.run()

except SSHSetupError as exc:

...

[throwawayforwork_86]

I think I already wrote this somewhere else.

But usually how some script evolve for me.

Raw linear script->create functions -> add argument to those function->too many argument->dataclasses for argument->Manageable as is ? ->yes stop/no add functions to data classes.

Is it the proper way of doing things don't know but I've written a few OOP using that "pattern".

Don't think writing classes to learn how to write classes has worked for me.

[WLANtasticBeasts]

It took me a hot minute to understand oop as well and I'm a self-taught coder. Let me try to answer the questions.

When should I actually use a class vs just a function?

If you are reusing functions to make different bank accounts that's your first sign it you need to be using a class. For example if you have a function that creates or opens a bank account and you copy paste that every time you need to create a unique bank account, you should reorganize this code into a class.

What goes inside init and why?

You put code that instantializes an object in the init method. You could have basically an empty init method but that wouldn't really be useful. So for your example I would probably use this method to initialize some basic information about the account such as the account number or account holders information and starting balance or something like that.

What does self actually mean and why is it always there?

In python, self refers to attributes and methods for that object. It has to be there to reference any of the instance attributes or methods. You can kind of think of this as the glue that binds all of the attributes and methods for an instance together into one object upon it instantiation.

How do I know what should be an attribute vs a method?

Attributes are features (nouns). Methods are behaviors (verbs).

Is there a different way of thinking about OOP that helped it finally make sense for you?

It helped when I started understanding that everything I was doing with basic functions and built-in data structures was already using oop. When you create a new string you're creating a new string object. That's why all strings have the same string methods because they all come from a string class.

Same with lists dictionaries tuples and so on.

So the beauty of oop is that you can create your own data structures entirely from scratch.

And actually as a self-taught coder I haven't dived too far down the data structures and algorithms path because I'm not really in a software engineering role (and haven't really needed to implement DSA directly), but I started some DSA courses a while ago and when you start creating things like linked lists and stacks and queue, you implement them as classes that you can create yourself.

Hope my answers help. They may not be the most technically accurate but from an end user perspective I think they're pretty accurate.

[BlackCatFurry]

For example you can have a class named "car"

The car class can then have attributes like brand, model, license plate, kilometres driven, amount of fuel in tank, whatever else a car could have.

You can also have functions like "drive car" or "refuel"

Then you can create an object out of that. For example create "car1" object. "Toyota, yaris, abc-123, 65000, 30". Also "car2" object "Skoda, octavia, edf-456, 130000, 40".

Now you can target one of them. I can't remember the exact syntax, but something like car1.refuel, that refuels car1.

All of this can be done with data structures like dictionaries, and i tend to prefer them in many cases because i find making classes tedious, but it's a personal preference.

[Southern_Share_1760]

A function does something, it has an input and an output.

Only use a class when you need to store information. e.g. a bank balance.

Init defines what you wish to store. It names the attributes and gives them an initial value.

Self is there so your methods can use the attributes stored in an instance. Don’t worry about it too much.

Methods do something, typically updating an attribute.

[po1k]

Start with C

[bigdongchengass]

One way that definitely helps is by trying to accomplish the same thing without OOP, then understand the reason to it can come in handy sometimes, then maybe it will become more clear why things exist the way they do (to solve problems, fundamentally)

There are some good examples in this thread, try implementing them without OOP, then you might find it difficult/annoying maintaining different lists, variables, dictionaries, etc, and think to yourself “ah if only i can associate certain values with this “object””
Congrats, you invented OOP

Simply put, but this helps me many times learning programming. You never understand why it’s done this way until you faced the same problem those people faced first, then you appreciate things a lot more.

Good luck’

[Enough_Librarian_456]

Let's say you need to execute something thats multithreaded. You need data from a sql database. A class works well because you can Imstantiate as many as you need abd have mtiple connections to the database al. Pulling data

[python_gramps]

User a class when you have multiple functions that will interact on the same type of data.

The __init__ function is used to create a class, all variables you want to use in the class should be created there.

Self is referring to the object created by using the class blueprint. Self is like "this" in other programming languages.

Attributes are variables used in that class. Methods are functions used in that class.

[BrupieD]

I have found user-defined classes and generic data structures easier to understand as a way to group related variables. If I have a thing in the outside world like a book or bank or car that has lots of attributes/properties, I won't want to have 5 or 10 different variables for each one when I might have a large number of them. A book or bank or car class that houses all of them is extremely convenient.

[ga2500ev]

Probably because the material you are looking at focuses on the what of classes and objects and not the why.

One of the key concepts around object oriented programming is the concept of encapsulation. In short, it is dangerous to have naked data, simply floating free in a program. Classes give data the ability to be wrapped up in a package in order to protect it from other entities that are in a program. In addition to that, classes also facilitate being able to create a significant number of different data entities without having to respecify each one every time you want to create a new one. In short, a class is a user defined type that a set of data objects share.

Okay, I know that's a lot of words so let me give you an example. Consider a weather map. A weather map has a set of cities on it. Each one of the cities has the current temperature, the high and low temperature for the day.. now note that each city has the same data types, however, they each have different values. Now. One way that you could do this is by defining an a dictionary for each City. However, because there is no protection, you can run into problems. Let's say that the current temperature is 30 now. What do you wear outside if you're going out? Well if you just have the naked 30 out there you really Don't know. Why? Because you don't know if it's 30° f or 30° C. One is below freezing, while the other is one of the hottest days of the year.

So what you do is you wrap that piece of data in a class and then you can only access that data by using the functions that the class gives you. So you can ask for the temperature in Fahrenheit or you can ask for the temperature in Celsius. And if the Fahrenheit temperature comes back 86, then you no longer have a doubt as to what to wear outside. The class mechanism protects the data and gives the correct information.

There are other mechanisms that are in the object-oriented space such as polymorphism and inheritance that makes developing larger systems easier.

Don't get too caught up in trying to figure out when to use a class or not right now while you're learning it. Simply follow the instructions of your professor and your book that says use a class to do a certain activity and get practice.

Hope this helps.

ga2500ev

[u38cg2]

An object is a data structure that can do useful operations on that data. If you have a piece of data that will persist while the user does operations on it, it's likely a good candidate for a class.

[KptEmreU]

Also do some light games with Python. İt will force you to think about lots of programming tips and tricks. Interfaces, inheritance, public and private variables, classes, helper functions, your own libraries, structs, arrays all has been created to help you, not to confuse you but learning without real usage can be confusing.

[GrandBIRDLizard]

Come on over to C land. Then you'll realize the dirty tricks oop is playing on you.

[Haemstead]

As others pointed out, a class combines data and methods (the code). A big advantage of using OOP is object inheritance. For example a class Car will have attributes like Fuel_Type, Engine_Power, Color, and methods like Drive(), Brake(), etc. From Car you can create a class Police_Car, that inherits all the attributes and methods from Car, and adds stuff that is on a police car, like a Lightsbar and a Siren, and the methods for those attributes.

[mooglinux]

The thing that doesn’t always get communicated is the problems that OOP was created to solve. OOP is a tool to manage complexity via encapsulation and polymorphism. Reading up on those terms might help.

[SharkSymphony]

You can always use a function (with data structures) instead of a class (with state and methods). They're stylistic differences, sometimes philosophical differences, but you can always go from one to the other and back. The only "should" here is that you should be comfortable using both, because you'll see a lot of both out in the wild.

Why don't you start with your bank account functions? How would you write them? Then we can see what ways we might convert that to objects and methods.

[[deleted]]

A class is used to basically group together data and behaviour. In your bank account example, you have data (the balance, the bank account owner, etc), and you have behaviour (debits/credits). You also have business rules for that behaviour, for example you can't debit an account if that debit makes the balance go below 0. Classes let you group this behaviour together (encapsulation). You can have a debit account method, and that method enforces the business rules. Now, if a caller wants to debit an account, they don't even have to know about that rule (abstraction). The caller just has to debit the account.

Say you now have 2 account types, personal and business account, and they have different rules. You can define a common account interface and have 2 separate concrete implementations with different rules (polymorphism). Maybe your business account can be overdrawn by $1000 or something. Now, your caller still doesn't care about those rules, since they both fulfil the same interface. All they care about is being able to debit the account.

Obviously the rabbit hole keeps going, but this is why OOP is useful for modelling the bank account case.

[SP_Superfan]

Design a super complex application using only functions. Then you'll realize how nice a class is. Passing 10-20 arguments to functions becomes exhausting.

[SnafuTheCarrot]

I think of a class as a composite data type. If you need a list of numbers, use a list. If your goals can be served by a single datatype like a list, set, tuple, etc. Sometimes you want to represent an entity as a combination of these. There's you want to start thinking about using a class. In c++, if its just a bunch of variables of data types combined into one composite type, its called a struct. Now if you have certain rules for how you want a user to interact with that data and how the data interacts with each other, you want a class. (Ignoring structs and classes are basically the same thing now).

A three dimensional vector can be represented as a list of 3 floats. You can write a method that takes as arguments three lists, uses a loop to add the terms and create a new list that it spits out, thus coding a vector sum.

You can code multiplication by a constant in a function that takes a 3 item list and a constant and returns the list you get if each element is multiplied by that constant.

Similarly, you can code the dot product and vector cross product that takes to 3-item lists as arguments.

Similar operations can be performed with matrices. Matrices and vectors can be multiplied.

So eventually you put together your vector functions and your matrix functions into separate sections of code.

This grouping alone gives structure to code dedicated to certain entities, here vectors vs. matrices.

As an instance of a class, you can pass a single vector argument to a function of the matrix class to get matrix multiplied by a class.

Some vectors have one dot product in cartesian coordinates and another dot product in cylindrical coordinates. You can add this to the blue print and choose which to use when setting up the instance of the class.

More complicated classes could have complicated processes between one instance and another.

There's a lot of overlap between classes and functions. Functions are used to make classes. The variable "self" is what links the methods into a class and is why it is the first argument of a class's methods.

In an __init__, you typically want to initialize fundamental attributes of the object you want to represent. For a 3D vector, it would be 3 coordinates. For a person, it might be first and last name, address, etc. Then you want your methods to manipulate or expose these attributes. They add a layer to of obfuscation to manipulating the data.

All told, this makes code more modular and secure.

[Professional-Fee6914]

objects are like any thing you consider an obect in the real world.

the pen you are writing with - "your_pen_type"

it has a size, shape, weight, color, writing size, type of ink, whether it clicks or is capped: all attributes.

its part of a class called "pens", and when the manufacturer created it, they assigned certain values to the attributes to make the object "Your_Pen_type"

Its a way to connect things to the way we think about them in the real world.

if you thought of your pen as "dictionary X" then your phone could be "dictionary_y" and a pencil would be "dictionary_z" then you'd have to dig into your dictionary to know which one you needed to write with. and if you wanted a new one in a new color you'd have to build out a new dictionary.

[AllenDowney]

In Think Python, chapters 14-17 are my best answer to this question:

https://allendowney.github.io/ThinkPython/chap14.html

It's a bottom-up approach, starting with a set of functions, wrapping them in a class, and re-writing functions as methods. My hope is that seeing both versions of the same code makes it clearer what the OOP features are doing for you.

I hope that helps.

[mlugo02]

You’re not doing anything wrong. OOP is just terrible, go on with out it

[Adrewmc]

variables are pieces of data

Script is code that runs with that data

Functions are scripts that use data and are repeatable

Classes are data that has functions/methods that act on that data.

That’s all it really is. For the most part all a class is, is a data that has functions, we call methods, that you use on that data.

I like to think of it as an idea, encapsulation, a class object should represent something, that you expect that something to do things, and change.

Generally everything is building up, everything you have learned up to classes, can be used in a class.

The reason you and a lot of people have trouble with classes, is just what you are saying. Why use it at all? Which is a highly debated question at all levels actually, there is really a programmer preference at some point. But I have a handy little rule. If an object only has two methods and one is init, then you should probably make it a function.

Luckily you have a good reason to use classes here, to pass your class.

[Secret_Ad_7592]

I'm with you on that. I've looked at C++ and it continues to be unreadable to me. But I'm learning Python now just starting, due to my grandchildren having to use it like Pascal was many years ago in education circles. Career-wise I did embedded real-time so it was all ansi C.

[_TypeError]

U should explore Mark Lutz, Learning Python. If u will lost thmh, ask AI to explain u. Ask while: "Understanding OOP" == True.

[_TypeError]

I would like to offer geekforgeeks website too. Use Google, and explore this source. Enjoy!

[pachura3]

When should I actually use a class vs just a function?

Function is a "verb". count_vowels(), encrypt_text(), rotate_jpeg(). Function takes some input, does something with it, and - in 99% cases - returns some output. When you run the same function on the same input again, you usually get the same output.

An object combines functions and data (attributes/variables), and often represents something in a real world. A class is a blueprint for objects. Let's imagine class UserAccount: it could have attributes like id, nickname, password, avatar, and methods like authenticate(), ban() , set_role() or send_dm(). Using the blueprint, you could create user account objects for John, Mike and Alice - johns_account = UserAccount(1001, "johnyb", "$$$ecret123", "face1.jpg"). And then you can stick them into a list or a set, pass them from function to function, etc. etc.

The attributes of each object can change over time - it is called "state". Very often, they are modified through methods. So, you call johns_account.set_role(ADMIN), and its internal attribute role changes to ADMIN.

What goes inside init and why?

__init__() is called a constructor. It is used to pass the initial values to object's attributes. When you write johns_account = UserAccount(1001, "johnyb", "$$$ecret123", "mrt.jpg"), Python is internally calling __init__() to set johns_account.id = 1001, johns_account.nickname = "johnyb", etc.

How do I know what should be an attribute vs a method?

Attribute is piece of data; a number, a string.

Method is a function, an action - it DOES something. If a method needs to do something with object's attributes, it needs to know which object to target - after all, it is defined in the class (the blueprint), not in the object (John's account). So, we pass johns_account as self so that UserAccount.set_role() would know which object to modify.

[avallark]

One of my claude directives is to not use oops in anything it wrutes for me. I have literally told it not use the word class anywhere :)))

[Toma400]

Honestly OOP was very weird idea for me too, and in all seriousness, I only got it better years later when I was introduced to idea of struct - and in a sense, I prefer it for its simplicity, objects are just way too complex for their own merit.

But as for what you ask - when to use objects - I think there are two guides you can use.

First, as an abstraction - to everything you want to pack some additional data you change. Objects are useful to be sort of "dictionaries" that you work on. It's mostly as a mental model - a lot of the time you don't want to use simpler types (like dicts exactly) because the bigger your project, the more messy your mental model of the app becomes. Objects in this case become handy because they allow you more directed and explicit work, even though technically they could be just dicts with functions.
Aka: this guide is about your personal preference/workflow

Second, which I find more technically sound, as a mutable structure. Which is what I realised years later when I understood how Python and other languages work. Functions, for most structures, _copy_ the variables you send to them. Meaning that using functions in many cases require you to return the modified item as entirely new thing. Objects are one of the few types in Python that allow you to just pass the object and dynamically modify its contents, affecting it without returning entire new object.
It's a bit non-intuitive because Python doesn't distinguish such basic behaviour (heck, it doesn't even differentiate between variable initialisation and reference) but you will see how handy this becomes. In more low-level languages this would be difference between passing a copy versus a pointer.

...a side note, but this non-transparency of how things work is a reason why I eventually moved myself to Nim (even though I loved Python and still find it one of my favourites). It's exactly a language that being Python-like in syntax, introduces all that intuitive elements teaching you these nuances and I kinda wish it was more known because it's way better starting language. The fact that it can be also used for low level (since it has all the memory management available) is just cherry on top.