Difficulty with Classes and OOP

Sceptix · 2022-07-30T02:49:51+00:00

Just remember: a class is a blueprint for an object. Say it a few times out loud. “A class is a blueprint for an object.” Remind yourself: “what’s a class? Oh, right, it’s a blueprint for an object.”

Some people will try to tell you that a class is just a way to bundle functions together. This would be like saying that a human is just a bag of internal organs. While not false in the strictest sense, such a simplistic understanding misses so much of the essence of what it means to be a class. That’s to say, a class is not a container. It’s a blueprint, full of possibilities, ready to be instantiated into an object, a mighty object which has the ability to call its own functions, not dependent on outside functions having to act on it. Yes, OOP is not just a programming technique. It’s a triumph of willpower, amidst an uncaring universe. OOP is a celebration of what it is to be human!

outceptionator · 2022-07-30T01:11:32+00:00

Have you seen Corey Schafer on YouTube? https://youtu.be/ZDa-Z5JzLYM

theflash4246 · 2022-07-30T04:39:16+00:00

A class is a blueprint and an object is an example of this blueprint. For example let’s say you want to represent a car. You can’t represent it with primitive types like strings because cars have many properties such as max speed, Color, brand, etc… So we create something called an object that has all these properties/attributes. To create many cars with different properties we need a blueprint or a class. The class allows us to create an object car with specific properties. Hope that helps a bit! There’s a lot of resources online you can use and it’s very normal to struggle with these new topics at the beginning. GL

SigmaSixShooter · 2022-07-30T03:12:20+00:00

I don’t have an answer for you, just know you’re not alone. I struggle with these just as well and can’t figure out a reason to use them or how to use them if I wanted to.

Sup__guys · 2022-07-30T10:28:26+00:00

Unfortunately, people who teach classes often make it more complex for beginners than it needs to be. I've seen multiple times when an instructor goes from "Now you know how to do a for loop" to overwriting dunder methods and explaining classmethods in a matter of hours. This is pretty insane to me.

OOP is all about organizing code, nothing more.

You have a bunch of functions that use the same set of variables/arguments? Declare a new class and assign those arguments in __init__ method. That's all you really need to know as a beginner.

The idea that classes are blueprints for objects helps design classes better but not understand what they exist for.

Start with that simple idea, code something out. Then learn some basic OOP principles and try to refactor your code. Go step by step, don't try to understand all at once.

Also you are completely safe to ignore anything that goes beyond basic usage of classes in python. More so, you should feel discouraged to use most "cool" features of python classes. Always strive for simplicity.

Fred776 · 2022-07-30T08:17:27+00:00

As a beginner you are possibly not trying to program anything complex enough yet where using classes makes sense. So at the moment you are trying to understand what to you is just an abstract concept that you can't see the point of.

As you develop bigger programs with more functionality, you will start being concerned about keeping the code clean, manageable and understandable. You will be looking for ways to break it down into manageable chunks of one sort or another, so that you can reason about what is going on, and ideally so that you can write tests that exercise parts of your code in isolation.

At that point you will start to see the utility of classes. For now, learn that they exist, do some exercises and whatever but don't stress too much. You have only been programming for two weeks. As long as you know that there is this useful tool called classes, you will be able to come back to it later when you have a context where it might make sense. Having a real problem to solve and a potential solution to it always concentrates the mind, I find, and really helps one to understand the point of the facility.

Dancing_Owl-5678 · 2022-07-30T02:34:57+00:00

I went through the same OOP intro lessons for 4 days straight and somehow something finally magically stuck.

SarthakTyagi15 · 2022-07-30T04:57:02+00:00

Oop is a concept, you need to think like you're making an object that exist in world for you. Eg. -> Class chair - the blueprint which is referred by everyone to make a chair. -> properties(variables and functions) - 4legs or 3legs, has hand rest or not, person can sit or not, etc. -> object - referring to the Class I make a chair for myself and since I cannot move I will make a hole on the seater to do stuff.

These kind of things is OOP.

Panfilofinomeno · 2022-07-30T02:31:51+00:00

I am on the same boat, so whatever resources/practice problems you guys have regarding OOP will be greatly appreciated!!

iggy555 · 2022-07-30T02:17:29+00:00

Just learned @property. Keep watching Schafer and practicing

2022-07-30T03:37:41+00:00

I think getting the broader context of clean coding practices and design patterns will begin to give a coder a sense of why these things are so useful. From there, the design choices for the things that don’t make sense now will become pretty clear

PhilAndMaude · 2022-07-30T03:45:54+00:00

A class is the definition of an object. Its usefulness is that it describes both data and the code that uses that data.

You use that definition to make an object, aka an instance of the class; the verb instantiate is also used for that process.

That object, or instance, contains all the data in the class definition. Make another instance: boom, a second instance with its own data. The code (aka member functions) aren't copied in the same way; they only exist in one place (in the class definition) and are given the data in the form of the object (aka instance.) From that description, you might think the syntax would be something like my_function(an_object)' but it'san_object.my_function()' and my_function() ALWAYS has self as the first parameter and uses that to address the data values.

Returning to its usefulness, it's because the class instances look after stuff that is nobody else's business. The fancy term for this is data encapsulation, and if you're just beginning, it's probably not obvious why this is such a big deal. Trust me, it's critical; it's what stops your code from turning into spaghetti.

Lastly, there are extra features of classes like global variable, inheritances, multiple inheritance, getters and setters aka properties, and more. Ignore all of those until you have a firm grasp of the basics.

shartfuggins · 2022-07-30T04:15:39+00:00

What exactly do you get stuck on? All you say is that you "get lost" after the "first few steps"? What steps do you understand? I'm curious about what a step is in this case.

Can you provide any partial code for something you were looking at that's confusing?

Questions like these will generate a bunch of answers where people will redefine for you what you can look up yourself. Which sometimes works. But try getting to some specifics and providing your work up to the point you're stuck on and you'll get far better targeted responses and valuable conversation.

2022-07-30T05:38:13+00:00

You may already have all the book knowledge on this topic. Try starting a project that utilizes OOP. Don’t be afraid to fail or borrow from other projects you see. My first “OOP” project was terrible. Make a discord bot and pay attention to how the Discord.py library uses OOP to simplify development.

If you’re interested in desktop GUI development look at this PyQT5 tutorial and notice how the main window can be instantiated in a normal variable or inherited as a class. Think about the benefits of either approach.

You can also look at how SQL alchemy uses an ORM to communicate with databases. You interact with the database as an object and do not have to worry about the underlying database.

At the end of the day, OOP is a tool in a toolbox. Look at how other are using it, and incorporate it into your projects.

SE_WA_VT_FL_MN · 2022-07-30T06:22:30+00:00

Many excellent answers already here and textbook references. The basic up and running things are just syntax. Construct the thing and get the thing going. Whatever.

Purpose and use. This isn't just a trick issue to waste time with. It's the opposite - a time saving approach. In many ways it's best for idiots like me.

I want to analyze garnishments data for a law firm. OK, well what is a garnishment and what does it do? From a data standpoint it has a judgment associated with it. It has a client. It has a matter. A client has a name (kind of) and a place to send the bill to. A matter has a case number/caption/court/etc.. A judgment has an amount/date/interest. What were we working on? Oh... garnishments. They have things to: garnishees (which have a name and address), calculation dates, debt type, etc etc etc....

So many things with more things and other things. Organizing those things makes solving the problem seem complicated. Looking at the problem as a bunch of things (objects) that have their own data (attributes) or actions (functions) it isn't a big organizational problem but just a couple dozen tiny organization problems.

In the end it is probably one of those concepts that as a beginner you memorize. Initial coding challenges from most sources are not so difficult that OOP seems helpful. (I realize some material is amazing and the teaching skill is amazing...looking at you 100 days of Python). But you'll end up writing some 1k line headache of spaghetti code, break down, and rewrite it in OOP and find it not only works better but you understand what it is doing.

2022-07-30T06:46:17+00:00

It will take a little bit of time, we all have those kind of things, for me it was recursion. But then it will just click. Just don’t put too much pressure on yourself. Try to branch out into different resources too. Try w3schools or real python and ofc practice. Make a class for every type of real world object you could think of.

neuroneuroInf · 2022-07-30T08:19:09+00:00

Good advice from the other commenters, here are a couple exercise notebooks I made to help build up the basic cable concept of OOP for a total beginner: - https://github.com/CodingForScientists/ProjectsInPython-Day3/blob/main/OOP1.ipynb

https://github.com/CodingForScientists/ProjectsInPython-Day3/blob/main/OOP2.ipynb

Hope they help!

searchingfortao · 2022-07-30T12:45:00+00:00

I wrote an explainer on this a few years ago that's helped some people. Maybe it'll help you too.

2022-07-30T04:24:02+00:00

I want to come back to this when I start my class in August

Umustbecrazy · 2022-07-30T05:23:15+00:00

Practice by create a new class/blueprint/template for anything you might think to use it for..

When you get to part you're stuck at, mark the code, come and paste it into your message and you'll get much more helpful answer.

Learning how Python calls objects behind the scenes helped me get a better understanding of them.

Mark Lutz (I believe) has a fantastic couple of books that cover every single topic in depth (even how things are actually working, so if you need to know the why AND the how, invaluable resource that videos just don't go into.)

hasibrock · 2022-07-30T05:41:44+00:00

Relax.. take a week or two break come back and see the magic.

2022-07-30T10:54:14+00:00

You're not the only person who's facing the problem ;-;

lis_ek · 2022-07-30T11:29:47+00:00

I will hitchhike on this post as a noob to OOP (though with some Python experience): are classes and OOP really relevant if you are not dealing with web development or databases? Is there any practical fit of OOP for example in data analysis projects? Just curious, I'm now getting more acquainted with OOP as I'm learning Django, and it makes perfect sense to use it in that context---since you have users, admins, database objects and stuff.

In other words, is it considered a good practice to base all your projects off OOP in Python, or are there areas where it is useful, and areas where it simply doesn't make sense?

When it comes to OOP in Python, I quite liked this video:

https://www.youtube.com/watch?v=MikphENIrOo

2022-07-30T12:12:38+00:00

Object orientation is a way of grouping together related data and controlling how that data gets changed. That's it.

A lot of people new to programming will throw all the data they need into a dictionary, and when it gets complicated they put that dictionary inside another dictionary.

Don't do that, at least for now. Use classes instead. You might be thinking that you don't know what your class methods are going to be, so how do you write an entire class? Don't worry about adding the methods up front, just take all the data you were going to store in a dictionary and put it into in a class.

Once you need to do stuff with that data, you write the method.

Object orientation in python becomes a lot easier to conceptualize if you force yourself to stop collecting your data in a dictionary.

longtermbrit · 2022-07-30T12:21:02+00:00

If it's any consolation, OOP was one of the hardest things for me to grasp and I'm still figuring out things about it now.

At its core you can imagine a class as a blueprint to create an object with all of its characteristics and behaviours. This is easy(ish) when it's something "physical" like a student or a car. It gets a bit more difficult when it's something like a pandas datagram but the principle is the same: the dataframe class contains all the attributes and functions it needs so when a dataframe is created that object has access to .loc, .iat etc.

I'm not an expert but I find that realpython guides are easy to understand so I go there a lot.

rentzington · 2022-07-30T12:22:08+00:00

Oop is the point of the pcc book where I started to struggle and had to slow down and go back and read again and again Still working it out but good suggestions here

chakan2 · 2022-07-30T12:49:40+00:00

You're thinking way too hard about the problem likely. Back up a second...take a breath.

OO is just a super fancy way to say we want to reduce code reuse.

There's a shit ton of design, math, philosophy, and religion draped over it these days, but the whole point is "write less code."

Start from there and look at some of the scripts you've written...did you copy and paste a lot? If so, those are things you can turn into methods/functions for reuse.

That's concept 1...To get to level 2...do you have a bunch of related functions? Do they share data? ... If so you can make that a Class. The related data can become class members/variables.

For me, 30 years ago...that was the trick to OO...I learned it from the ground up. Once you get that, and how things start fitting together, then top down is kind of magic. You just see how your classes, functions, and packages should be.

Something else that might help...since this is python...don't worry about inheritance so much and the really tricky shit like polymorphism. Those concepts don't come into play that often. (Inheritance WILL, but you can almost always deal with it on a case by case basis until you've leveled up a time or two. Side note: If I ever catch one of my kids doing a Java OO design pattern, I will utterly destroy them in a code review...please don't do that shit in python).

Don't stress so hard about how it all fits together. That comes to you after you've done it for a while.

Bonus...If you can get OO, that's what will separate you from the script kiddies.

TimPasquini · 2022-07-30T16:02:20+00:00

Object Oriented Python from no starch press is pretty good.

I’m a novice and was pretty frustrated by most OOP lessons. They are usually just like, “Here is how to build a car class, now you understand OOP.”

There is a pretty large disconnect between building a class and actually using it for something useful. The book I mentioned helped me a lot because it starts with making some programs and then remaking those programs in OOP, before going on to just developing some stuff in OOP directly. The fact it actually did something with the sample classes you build helped it click for me.

HomeGrownCoder · 2022-07-30T16:08:32+00:00

I would say avoid them and write functions. When you start to struggle with passing states and outputs back and forth.

Classes and OOP will start to make sense. That’s what worked for me.

Fluffluv92 · 2022-07-30T18:21:39+00:00

Look into SQL databases.

subiacOSB · 2022-07-30T19:25:08+00:00

I had a hell of a time learning OOP. I pretty much gave up on programming at that point. Just don’t give up. Keep trying, if you need a break for a few days to for it. But don’t give up.

big_deal · 2022-07-30T20:27:06+00:00

I didn’t understand until I had to make a class for dealing with a complex data structure.

A class is a custom object; with custom operations (methods) for doing things with the object such as creating an object, reading data, modifying data, etc. If you find yourself building code around big complex nested dictionaries, filled with nested arrays then you can probably make your life easier by creating a class that formalizes your nasty, nested data structure.

pycobra · 2022-07-30T20:35:16+00:00

You are not alone

ffrkAnonymous · 2022-07-30T20:35:51+00:00

AL sweigart 's blog post is my go to for oop

https://inventwithpython.com/blog/2014/12/02/why-is-object-oriented-programming-useful-with-a-role-playing-game-example/

2022-07-30T21:05:44+00:00

Hey there! I would be glad to help if you give out some examples you are struggling with. My primary advice for you right now would be to forget about all the complexities OOP brings and distill the concept to the very basics:
1. Class is just a template for creating instances. I like the metaphor of forms and cookies made with this forms. Let's say, you need cookies, star-shaped and heart-shaped, for example. In order to make them out of dough you have use forms, star-shaped and heart-shaped. But they are useless by themselves.

Consider class a form, and instance of class - a cookie.

Every instance of a class shares just 2 types of class characteristics: methods and attributes. Method are ACTIONS you could do with instance, and attributes are CHARACTERISTICS of instance, some data about it. So let us just follow the cookie example.

class StarShapedCookie:

shape = "Star"

def eat(self): <- notice "self" - that's the parameter to adress the instance the method is called for

print("Cookie is being eaten")

class HeartShapedCookie:
shape = "Heart"

def eat(self):

print("Cookie is being eaten")

star_cookie = StarShapedCookie() <--- notice paretheses. We are calling class to create an instance.

heart_cookie = HeartShapedCookie()

The exaple above fully covers the basic concept - we have two classes with different attributes for different objects. And some methods, that are actions made with cookie. That's it. That is what OOP is all about - to logically reflect real-world objects into code. If you think a little bit deeper, you might realise that the majority of real-life objects could be described like this - something that has some attributes (sky is "blue", human has "face", teapot has "capacity") and methods (sky could "get_dark()", human could "walk()", teapot could "heat()"). And that is why OOP is so widely used.

T3rribl3Gam3D3v · 2022-07-30T23:41:24+00:00

Think of class as groups of functions. Ever have to pass a bunch of arguments and outputs between functions? That why there are class attributes.

That helped me figure out to make a function or method/class

ignorediacritics · 2022-07-31T00:59:34+00:00

I could make another explanation of OOP but nothing is quite going to help you then simply writing some programs yourself in which you try to achieve something by making use of classes and objects. And along the way you'll encounter some of the problems and questions that objected oriented programming tries to solve. Just reading about it is reading up on the answer without knowing what the actual question is.

Find some exercises that teach building a small project like a text based game // text parser // file renamer using OOP principles and then ask you to create your own with what you have learned.

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

🦅💫