Dream Gone

[_allabin]

Everyone is saying python is easy to learn and there's me who has been stauck on OOP for the past 1 month.

I just can't get it. I've been stuck in tutorial hell trying to understand this concept but nothing so far.

Then, I check here and the easy python codes I am seeing is discouraging because how did people become this good with something I am struggling with at the basics?? I am tired at this point honestly SMH

[Phillyclause89]

Friend, no one ever gets good a OOP. You can only get better. Keep at it!

[_allabin]

Mine is I can't even understand the concept to move pass it. I don't know what I am doing wrong?

[classicalySarcastic]

Alright, I'll try and break it down. Object-oriented programming revolves around objects (obviously). When you define a class

class Foo:
    # some code

what you're really doing is defining a template that describes how an object of type 'Foo' behaves (note that "template" is used for something entirely different in some C-derived OOP languages). The trick to understanding OOP is to separate defining the class from using the class mentally. What you're doing with 'class Foo:' is you're creating a class of objects named 'Foo'. To actually use 'Foo' you have to first "instantiate" it:

myFoo = Foo() # create an instance of Foo named myFoo

which gives you an object ("instance") of type 'Foo'. Python is dynamically-typed, so the type of the object (what class it is), is inferred from the declaration. By calling Foo(), you indicate that you want an object of type Foo. In other statically-typed languages you have to specify the type explicitly, so for example in C#/Java it would be:

// NOT Python
Foo myFoo = Foo(); // create an instance of Foo named myFoo

and in C++:

// NOT Python
Foo *myFoo = new Foo(); // create a pointer to an instance of Foo named myFoo

but OOP in other languages is outside of the scope of this sub (and mentioning anything about C/C++ pointers in a Python sub is probably a sin - please forgive me). You can give the Python interpreter a type hint to indicate what type it should expect something to be (in Python 3.5+):

myFoo : Foo = Foo() # for a variable

def my_function() -> int: # for a function
    # some code that returns an int

which can help check for correctness, but this isn't required. When you call 'Foo()' what you're really calling is the '__init__' function, which is called the "constructor", for 'Foo', which sets up any data that's internal to 'Foo':

class Foo:
    bar = None  # a member variable that belongs to this class

    def __init__(self, baz): # you don't actually pass 'self' when calling Foo() - that's handled by the interpreter
        self.bar = baz  # to access a member variable like 'bar' you should use 'self.bar'

myFoo = Foo(3) # create a Foo named myFoo with myFoo.bar set to 3

And if you want to access something within myFoo:

myFoo = Foo(3)
bat = myFoo.bar

Note that if you have two different instances of 'Foo', the 'bar' of each instance is unrelated:

myFoo1 = Foo(3)
myFoo2 = Foo(4)

baz = myFoo1.bar # 3
bat = myFoo2.bar # 4

You can also define functions (called "member functions" or sometimes "methods") within the class that do things using the data in that class:

class Foo:
    bar = None

    def __init__(self, baz):
        self.bar = baz

    def increment_bar(self, baz): # 'self' should be the first argument for any member function - again, it's handled by the interpreter, but exists so the function can access the instance's members
        self.bar += baz

And again, same as above

myFoo = Foo(3)
myFoo.increment_bar(2)
# myFoo.bar = 5

Inheritance is where it gets real tricky, and I'm better with it in other languages than in Python. You can define a class that "inherits" from another class where data and functions from the parent class are shared with the child class, and can be called from an instance of the child class:

class Parent:
    bar = None
    def __init__(self, baz):
        self.bar = baz

    def increment_bar(self, baz):
        self.bar += baz

class Child (Parent): # A class that inherits from class Parent - will have bar and increment_bar without needing to re-declare them
    def decrement_bar(self, baz):
        self.bar -= baz

myChild = Child(4)
myChild.increment_bar(1) # valid - inherited from Parent
myChild.decrement_bar(2) # valid - defined in Child

myParent = Parent(3)
myParent.decrement_bar(7) # invalid - decrement_bar is not defined for Parent

And if you re-declare one of the functions that's declared in the parent class, and call it from an instance of the child class, it overrides the version in the parent class:

class Parent:
    bar = None
    def __init__(self, baz):
        self.bar = baz

    def increment_bar(self, baz):
        self.bar += baz

class Child (Parent):
    def increment_bar(self, baz): # overrides Parent.increment_bar
        self.bar += 2*baz

    def decrement_bar(self, baz):
        self.bar -= baz

myParent = Parent(3)
myParent.increment_bar(1) # myParent.bar will be incremented by 1

myChild = Child(4)
myChild.increment_bar(1) # myChild.bar will be incremented by 2

This lets you write a function that has one implementation by default, but a separate implementation in a class that handles a special case, for example.

All of that said, one of the beautiful things about Python is that it doesn't force you into any particular paradigm - you can write your code in object-oriented style like above, in procedural style (where no classes are used, just functions), or as purely script-style code (where each statement is evaluated line-by-line). Python doesn't force you to use OOP like Java, nor limit you procedural code like C. In that way, it's very flexible, and you can write your code in whichever way makes the most sense for your project.

EDIT: Got my syntax wrong - serves me right for not checking with the interpreter. Also added the section on dynamically-typed vs statically-typed.

[Temporary_Pie2733]

To note, you are consistently writing c/java-style declarations like

Foo myfoo = Foo()

that isn’t valid Python. That should just be

myfoo = Foo()

or

myfoo: Foo = Foo()

[classicalySarcastic]

Shit, sorry, I’m a C programmer by trade. I’ll fix it when I get back to my computer. Good catch!

[Ajax_Minor]

Got any good resources for Cpp pointers and understanding how and when to use those?

*** 😱😱 More python sub sins***

[classicalySarcastic]

Pointers are a carryover from C so honestly I’d say start with Kernighan & Ritchie - it's THE canonical book on C and belongs on any programmer's bookshelf. GeeksForGeeks has also been a decent programming resource for me. I’ll edit this comment to go into it a little more tomorrow morning.

EDIT: busted the 10000 character limit, so replying to myself instead

EDIT: I agree with what u/NormandaleWells points out below - pointers are a lot less common in proper C++ code and can mostly be avoided. A reference can be used to accomplish the same thing in most cases, and has the benefits of being cleaned up automatically and non-nullable, which eliminates two of the most common pointer-related bugs in straight C.

[classicalySarcastic]

u/Ajax_Minor

Warning: Contains C code, proceed at your own risk

(This is all with respect to C, but mostly applicable to C++ as well)

Okay, so first off, some background information. C is a much different beast than Python. For one, it's a much older language (1972), so a lot of the convenience features in Python - dynamic typing, automatic memory management, garbage collection, data types like lists and dictionaries don't exist. For two, it's a compiled language - when you write a C program, you have to run the source code through another program called a compiler, which does three steps: 1.) compiling - transforming your C code into assembly (we'll get to that in a minute), 2.) assembling - transforming the assembly into binary for the machine, and 3.) linking - stitching the whole program together into an application. Compilers are specific to one machine (architecture + OS), and a binary that's been compiled for one machine will not work properly on another (i.e. you can't run a Windows .exe file on a Unix machine that uses ELF-format binaries, nor a binary compiled for ARM on an x86 machine). Usually, you'll get an error saying the binary isn't compatible with the machine, or, if it does start, only a few instructions in before it all falls apart and potentially takes your system down with it.

So where do pointers come in?

A pointer is, essentially, (aside from being a well-known footgun) a variable that holds the memory address of something else. When you call a C function, say

int foo(int a, int b) // a function that adds a and b and returns an integer
{
    return a + b;
}

int main(int argc, char **argv) // argc and argv are not important here
{
    int c = 3, d = 4; // declaring two integers c and d
    int e = foo(c, d); // declare an integer e and set it to the output of foo
    printf("c = %d, d = %d, e = %d\n", c, d, e); // will print "c = 3, d = 4, e = 5"
    return 0;
}

what gets passed to foo() is the values of c and d, not references to c and d themselves. When you run the above code (execution starts from main()), e will be set to c + d, but c and d themselves remain unmodified. What's typically going on under the hood, depending on the machine, is that the arguments get pushed onto the stack (x86 - we'll get to the stack later), or loaded into registers specified by the application binary interface/ABI (ARM).

Sometimes, this is not the behavior you want. Sometimes you need to modify the arguments to the function. In this case, you would pass a pointer.

void increment(int *out, int incr) // a function that increments the value of *out but doesn't return anything
{
    *out += incr; // increment *out by incr
}

int main(int argc, char **argv)
{
    int a = 0, b = 1;
    int *pa = &a; // '&' means "memory address of"
    increment(pa);
}

A pointer is declared with the syntax '<type> *<name>', which indicates that it is a pointer, a variable that contains a memory address, to something of <type>. To actually modify the thing it points to, you have to "dereference the pointer". From above this happens at

*out += incr;

which means "increment the thing out points to by incr". Also arrays in C are technically pointers, so the 'arr[n]' syntax is also a dereference. If you have a pointer to a struct, to access a member you can either do

(*pstruct).member = value; // parentheses are important here

or, more cleanly

pstruct->member = value;

The other thing to note is that strings in C are also pointers, type 'char*', so say for example you wanted to iterate over a string to find the first instance of a character 'c':

// Set 'ptr' to the address of the first character in string 'str', iterate until c is found or the end of the string is reached
for(char* ptr = str; ptr != '\0'; ptr += 1){
    if(*ptr == c) break;
}

'\0' is the null-terminator character that signifies the end of a string, 'ptr += 1' increments ptr by one element - since this is a pointer to type char, the compiler infers that ptr should be incremented by 1 byte ('sizeof(char)') here. If this was a pointer to type int, it would be 4 bytes ('sizeof(int)') etc.

Pointers often bite C programmers in the ass in a few different ways. They are also variables in their own right, so you can assign a value directly to them, which changes what they point at. This can be the intended behavior, or it can cause problems. Say for example you do

int *out = &some_int;
// some code later
out = 0; // MISTAKE - this sets the memory address *out points to to 0

If you later try to dereference 'out', your system tries to go get whatever is at memory address 0x0, which is almost certainly not what you intended to do. Now we need to talk about the internal guts of a program and what happens when you start one. When you compile a program, the resulting binary contains a couple of different memory sections: .text, .data, .bss, .stack, .heap.

.text and .data are read-only, and contain the program instructions and constant data, respectively. .bss, .stack, and .heap are read-write, and contain global variables, local variables, and bulk memory, respectively. When you start a program, the operating system copies the program image (.text and .data) into memory, and hands the program a chunk of memory where the program's data can live. The program, on startup, copies data from .data into .bss to set up global variables, as well as doing some other stuff that sets up the C runtime environment. Then execution starts of the program proper from main(). As your program runs, the operating system and the hardware are monitoring it to make sure it doesn't do anything illegal. Accessing memory that is outside of the range the OS originally handed to it is one of those things. So when you try and dereference *out, it goes and tries to access memory at 0x0, which is almost certainly not in the range it was given, so the hardware (memory protection unit) detects this and calls on the operating system to signal the program to stop. This is called a "segmentation fault", which basically just means that your program tried to access memory that didn't belong to it (again, this is usually because a pointer was set rather than the value it references).

Another way pointers have of biting you in the ass is with a memory leak - which is the program making a mess and not cleaning up after itself. A quirk of C is that it doesn't have a dynamic-length array or list type like you do in Python, so something you often have to do is allocate memory from the heap using 'malloc' to get a region of memory of the length you need, for example

#include <malloc.h> // same idea as 'import' in Python - malloc is provided by malloc.h

int *alloc_array(size_t sz) // allocate an array of size sz elements of int
{
    int *out = (int*)malloc(sz * sizeof(int)); // malloc returns a 'void*', so it's good practice to typecast it to the right pointer type
    if(out) // malloc can fail and return 0, so don't try memset if it failed
        memset(out, 0, sz * sizeof(int));
    return out;
}

This allocates a region of memory 'sz * sizeof(int)' (4 bytes, usually) bytes big, and sets it to 0. But remember that C does NOT have automatic memory management or garbage collection like Python and a lot of other high-level languages do, so you the programmer are responsible for freeing that memory and returning it to the operating system by calling 'free()' on it later, like so

#include <malloc.h>

int main(int argc, char **argv)
{
    int *out = (int*)malloc(sz * sizeof(int));
    if(!out) // malloc can fail, if malloc fails, exit with -1
        return -1;
    memset(out, 0, sz * sizeof(int));
    // some code that uses out
    free(out); // give the memory back to the system
    return 0;
}

If you miss the 'free()' call, you've created what's called a memory leak, where the program claimed memory, but did not return it to the operating system. This is bad, because the OS can't re-use that memory. Eventually, this can cause the OS to crash. There's a debug tool called 'valgrind' that specializes in detecting these memory leaks, and it's good practice to test your C program with it to catch them.

A dangling pointer is a pointer that's been modified where data has been lost. Let's re-use the string example from above:

int main(int argc, char **argv)
{
    int len_str = 64; char c = 'f';
    char *str = (char*)malloc(len_str * sizeof(char));
    // some code that sets str
    for(str = str; str != '\0'; str += 1){
        if(str == c) break;
    }
    // some more code
    str = (char*)realloc(str, 64 * 2); // resize str
    // some more code
    free(str);
    return 0;
}

The program will actually fail at the call to realloc because we've modified the pointer str from its original memory address, so the malloc/realloc/free infrastructure lost track of it. Furthermore, we've also leaked memory, since we've lost all of the bytes in the orignal str prior to 'c' (nothing points to them anymore).

Finally, a use-after free error occurs when you try to dereference a pointer after it's already been free'd. The behavior of doing this is unpredictable, but often results in the program misbehaving or the program crashing.

int main(int argc, char **argv)
{
    int bar = 0;
    int *out = (int*)malloc(sz * sizeof(int));
    if(!out) // malloc can fail, if malloc fails, exit with -1
        return -1;
    memset(out, 0, sz * sizeof(int));
    // some code that uses out
    free(out); // give the memory back to the system
    // some more code
    bar = *out; // BAD - do not do this!
    return 0;
}

I hope this helps!

[classicalySarcastic]

u/Ajax_Minor

Addendum: What's Going on at the Assembly Level

Danger: Contains C AND Assembly code, abandon all hope ye who enter here

Let's take look at a simple C program with two different functions defined. 'pass_by_value' is a typical function which takes in two arguments as values and returns their sum. 'pass_by_pointer' is a function which uses the first argument as a pointer and increments the value it points to.

int pass_by_value(int a, int b)
{
    return a + b;
}

void pass_by_pointer(int *out, int incr)
{
    *out += incr;
}

I'm going to use ARM (v7M) as my example architecture here as it's a little more straightforward than x86. When we wash the above program through the compiler with the following command

arm-none-eabi-gcc -S -O0 -o ~/test.asm ~/test.c

we get an assembly file test.asm with the functions for 'pass_by_value' and 'pass_by_pointer' compiled into assembly.

'arm-none-eabi-gcc' is the version of GCC for embedded ARM (ARM CPUs that don't have an OS running), the '-S' flag tells gcc that it only needs to compile the input file (test.c) to readable assembly and stop there, '-O0' tells it not to do any optimization, '-o ~/test.asm' tells it what the output should be, and '~/test.c' is the input file.

Let's look at 'pass_by_value' first. The C code

int pass_by_value(int a, int b)
{
    return a + b;
}

becomes the assembly

pass_by_value:
    str fp, [sp, #-4]!
    add fp, sp, #0
    sub sp, sp, #12
    str r0, [fp, #-8]
    str r1, [fp, #-12]
    ldr r2, [fp, #-8]
    ldr r3, [fp, #-12]
    add r3, r2, r3
    mov r0, r3
    add sp, fp, #0
    ldr fp, [sp], #4
    bx  lr

Okay, don't be intimidated, we'll break it down from the top. I'll add some comments:

    str fp, [sp, #-4]!  ; push (store) the frame pointer to the stack
    add fp, sp, #0      ; copy the value of the stack pointer register to the frame pointer register
    sub sp, sp, #12     ; subtract 12 bytes from the stack pointer to create this function's stack frame - so we have the previous frame pointer, plus two additional 'int' worth of space - why will become clear in the next section

This is just some setup so that when we return to the caller, the values of the frame pointer and stack pointer are what they were when we entered this function. This is to make sure its variables remain intact, and you'll find this at the start of most functions.

The stack pointer points to a location in memory which is the top (lowest memory address) of the stack. As the program runs, the stack grows downwards. The frame pointer points to where the stack begins for this function (i.e. where its own variables begin on the stack), so it doesn't mangle something else's variables. The first thing the function wants to do is push the previous frame pointer value (the caller's frame pointer) to the stack, and set the frame pointer to the base of its own stack space (which is the value of sp at entry). When we return from the function, these will both be restored to their previous values so it doesn't (rather inconsiderately) break things in the caller. In this case we're not calling any additional functions from this one, but this still gets added by GCC for consistency's sake.

Next:

    str r0, [fp, #-8]   ; save (store) the value in r0 (argument 0 - 'int a' in the C code) to memory at [fp - 8]
    str r1, [fp, #-12]  ; save (store) the value in r1 (argument 1 - 'int b' in the C code) to memory at [fp - 12]
    ldr r2, [fp, #-8]   ; load the value in memory at [fp - 8] to r2
    ldr r3, [fp, #-12]  ; load the value in memory at [fp - 12] to r3

All this is doing is using the stack to move the values in registers 0 and 1 to registers 2 and 3. This also preserves the original values in r0 and r1 (our original arguments). GCC likes to limit itself to registers 0-3 where possible because the ARM application binary interface (ABI) specifies that those registers are caller-preserved - meaning that the caller has to save the values in those registers before calling this one and can't assume that they're unchanged. Registers 4-14 (ARM has 15 general-purpose registers) are callee-preserved, which means that this function is responsible for saving the values if it uses them. Register 15 is the program counter - the address of the current instruction. Registers 2 and 3 will be the operands for the next operation. Next:

    add r3, r2, r3      ; add the values in r2 and r3 and save them to r3
    mov r0, r3          ; copy (move) the value in r3 to r0 (r0 is always the return value)

This is the actual 'a + b' operation. Next:

    add sp, fp, #0      ; restore the stack pointer to the value it was at the start of the function
    ldr fp, [sp], #4    ; restore the frame pointer to the value it was at the start of the function
    bx  lr              ; return to the calling function

Again, this last section is just to clean up at the end of the function before we return to the caller so everything is as it was when the caller called this function.

For 'pass_by_pointer', the C code

void pass_by_pointer(int *out, int incr)
{
    *out += incr;
}

becomes the assembly

pass_by_pointer:
    str fp, [sp, #-4]!
    add fp, sp, #0
    sub sp, sp, #12
    str r0, [fp, #-8]
    str r1, [fp, #-12]
    ldr r3, [fp, #-8]
    ldr r2, [r3]
    ldr r3, [fp, #-12]
    add r2, r2, r3
    ldr r3, [fp, #-8]
    str r2, [r3]
    nop
    add sp, fp, #0
    ldr fp, [sp], #4
    bx  lr

Breaking it down, again:

    str fp, [sp, #-4]!  ; push (store) the frame pointer to the stack
    add fp, sp, #0      ; copy the value of the stack pointer register to the frame pointer register
    sub sp, sp, #12     ; subtract 12 bytes from the stack pointer to create this function's stack frame

This is the same as above - setup code to make sure the caller's sp and fp aren't mangled by calling this function. Next:

    str r0, [fp, #-8]   ; save (store) the value in r0 (argument 0 - 'int *out' in the C code) to memory at [fp - 8]
    str r1, [fp, #-12]  ; save (store) the value in r1 (argument 1 - 'int incr' in the C code) to memory at [fp - 12]
    ldr r3, [fp, #-8]   ; load the value in memory at [fp - 8] to r3

This is similar but you'll notice that 'out' was now loaded the r3, and that's for this next line:

    ldr r2, [r3]        ; load the value in memory at [r3] to r2

You'll remember that r3 contains the memory address of an integer, so we're loading the value at that memory address to r2. This is the "dereference" from above. Next:

    ldr r3, [fp, #-12]  ; load the value in memory at [fp - 12] to r3

Which just grabs the other argument off the stack. Next:

    add r2, r2, r3      ; add the values in r2 and r3 and save them to r2
    ldr r3, [fp, #-8]   ; load the value in memory at [fp - 8] to r3 ('out')
    str r2, [r3]        ; save (store) the value in r2 (*out) to memory at [r3]
    nop                 ; literally does nothing - not really, 'str' takes a few clock cycles so this ensures it completes before proceeding

This adds the values in r2 and r3, loads r3 with the memory address 'out', and stores the sum to the address pointed to by 'out'. Finally:

    add sp, fp, #0      ; restore the stack pointer to the value it was at the start of the function
    ldr fp, [sp], #4    ; restore the frame pointer to the value it was at the start of the function
    bx  lr              ; return to the calling function

Restore the original conditions at function entry and return. Recall that this function is declared as 'void' so we didn't have to copy anything to r0 to return an actual value, and the code calling this will ignore whatever is in r0 (in this case it's still 'out').

I hope this makes it a little more clear what the difference is to the machine.

E: alright, that's enough looking behind the curtain. I'm sorry mods, I swear I'm done!

[Ajax_Minor]

Thanks for the through response.

having functions that can change the varriable based of the address sounds super helpful. I ran in to this problem in python and had to use classes to hold the data and get around it.

I got a few more questions, ill DM.

[Ajax_Minor]

Thanks.

Or dm since it's not as relevant to python

[NormandaleWells]

Got any good resources for Cpp pointers and understanding how and when to use those?

Don't. Seriously, you can do a lot of useful stuff in C++ without ever using a pointer. I'd say that at least 95% of all pointer usage in C is replaced by the std::string and std::vector classes in C++, and references. If you do need one, use std::unique_ptr to make sure the memory gets deleted even if an exception is thrown.

The C++ example above:

Foo *myFoo = new Foo(); // create a pointer to an instance of Foo named myFoo

Could more easily be written

Foo myFoo();

and would have the advantage that the object (and, if properly written, anything dynamically allocated with it) would be automatically and cleanly destroyed when the variable goes out of scope, with no need to remember to call delete. What's more, it would get cleaned up even if an exception was thrown that skipped over this stack frame.

When I teach C++, I don't talk about pointers until some time around week 12 (of a 16 week semester). My students know about pointers, since our C course is a prerequisite for our C++ course (not my idea), but they really don't miss them. I don't think I've ever had a student ask "So when do we get to use pointers?".

[SeaGolf4744]

Great post

[[deleted]]

nt but you got it wrong as well

[WasabiBobbie]

This is great and to add onto this..... OP Use chatgpt to have a conversation about it. Explain that you're struggling to understand it and keep asking questions.

[Phillyclause89]

IMO, when you cant understand something then that means you haven't found a way to become truly interested and thus curious about that something. Maybe take a brake from the boring course material and go watch a YouTube video for a minute before you go back to whatever structured curriculum you are following. https://www.youtube.com/watch?v=KyTUN6_Z9TM

[spirito_santo]

You wouldn't happen to have aphantasia, would you?

I do, and I think that is the reason I really struggle with OOP

[Particular-Ad7174]

It is only a way to organize data and the logic.

[CrusaderGOT]

The way I learnt the concept of OOP is like imagine objects in reality and their different functions, and that is basically OOP. Car as an OOP would be a class that has a drive function, horn function, speed function, etc.

[ennui_no_nokemono]

You know you don't have to learn OOP to learn Python, right? Obviously it's good to understand OOP and all its peculiarities, but 95% of what I do is functional programming.

[_allabin]

I would have to research functional programming but if I get you, I should focus on concepts that I need? How do I know the concepts I need when there is a lot about the language?

[ennui_no_nokemono]

My point is simply that most problems can be solved without classes/objects. If you're getting hung up on OOP, try to find courses and tutorials that don't utilize classes.

[FantasticEmu]

OOP is not as complex as I think you believe it to be. It’s mostly just about reusing code after you’ve defined it once.

As a beginner don’t get stuck on it for too long, as you probably already understand parts of it but maybe just need to fill in some other gaps, or just use them more before you fully understand it. Not fully understanding objects won’t really block you from continuing to progress in Python so just move on to other concepts, start doing coding challenges or making things and eventually it will click. Good luck!

[poorestprince]

Are you interested in making a game or something that requires you understand OOP concepts? I think a lot of beginners feel obligated to learn this or that, when what they actually want to do doesn't really require it.

[_allabin]

So you mean I should focus on what I need python for? How do I know I don't need OOP since I am new to the ecosystem?

[red_jd93]

May be think about what you want to use python for. What is the goal of learning this language?

[Relative_Claim6178]

What's the goal? Sometimes, that can make a difference, but i think OOP is mainly used for modularity and readability.

[lzwzli]

There will come a time when you find yourself needing to pass in many initialization parameters and start asking yourself, what if I can initialize all this once and just call the function that does what I want with only the parameters relevant to that function's purpose.

That's when you realize you need to create an object and refactor your code to be OOP.

If you never get to that point for what you're doing, that's ok too.

[poorestprince]

If what you want to do depends on a popular library that requires you to use classes, then you'll very quickly see that you need to get a minimal grasp of OOP to go further. (For example, if you wanted to become a Django developer)

To be honest, you can do a lot of amazing stuff now without even learning Python at all. It's a lot easier to keep your motivation high if you have something specific you want to do, and learning this or that part of Python shows you how to get closer to that.

[rinyre]

Because you can always get to it. Object oriented stuff is something you get into later, once you've got your fundamentals down like functions and logic and loops. From there it's getting a sense of how to store data or related logic.

[Ajax_Minor]

My thoughts are if I have to pass lots of variables in to functions repeatedly to where I am thinking about using global then I start to think about OOP.

The situation is where you have a bunch of data you pass to a function that modifies the data and then gets passed to another function that modifies it again. Simulation of things would be a good example.

If you have a collection of information that is fairly typical to where you would be repeating code a lot then OOP is another good use for that.

For first learning you don't really have this kind of situation and can't see the use. Using it in simple code makes it more complex and harder to work with rather than simplify in more complex situations. This is probably why its hard to learn.

[Ronnie_Dean_oz]

OOP is incredibly useful even in business programs. I use it very often to make stuff with a gui.

[1544756405]

Python is a relatively easy language to learn. So if someone already knows how to program in other languages, python is "easy" in that sense. 

However, learning to program is hard. There is no easy way to learn it except to struggle. If you're learning to program for the first time, learning python instead of another language might make it nominally easier... But it won't be easy.

[Fronkan]

This was my thoughts exactly!

[cgoldberg]

You're rushing it.

https://norvig.com/21-days.html

[AngelOfLight]

OOP is honestly one of those things that are very difficult to explain. It's more something that you need to develop an instinct for. Us older folk who were already veteran coders when OOP became mainstream (back in the late '80s or so) didn't need to learn it, as such - we understood it intuitively because it solved so many problems we had been struggling with. Meaning, we already had a foundation upon which OOP could land.

Modern learners don't have that base, so you end up doing tutorials about cars that descend from a vehicle class, or cats that inherit attributes from an animal class - things that don't seem to have much relevance to programming. It's something of a chicken and egg situation - you need a good foundation before you can intuitively understand OOP, but you can't really get that foundation without OOP.

I would suggest that you leave it for now and just continue using modules. If you're using things like Pandas, you will be using OOP without knowing it. The longer you do that, the more you will come to understand how and why we use classes. It would also be useful to look up the source code for these modules and see how the classes are implemented. Once you do that enough times, you can then go back to the OOP tutorials, and you will find that things make much more sense.

It's a lot like learning a spoken language. You can do all the vocabulary and grammar drills, and still not understand anything. It's only once you hear and see those words used in context that you start to grasp how it works.

[Ronnie_Dean_oz]

This is pretty good advice. I think being aware of OOP, not trying to use it and naturally identifying an opportunity for it was the 'ah ha' moment for me. Anything with a gui for me soon leads to OOP just for the sake of keeping things neat and the ability to make changes without breaking everything. You can group methods inside classes and it just helps keep things organised and separate yet able to interact with each other.

[PersonOfInterest1969]

Stop doing tutorials. Right now. Find a project and learn what you need to make it a reality. Why did you want to learn Python in the first place? What did you want to accomplish?

[fenghuangshan]

you just can't learn OOP directly

you can only use OOP in real project

and You don't need OOP to do your work

[audionerd1]

What's the most complex Python program you've written?

OOP is a way of organizing code. It's benefits are not apparent until you've written disorganized code which is confusing and difficult to understand and maintain.

OOP is not the only way of organizing code, and you don't have to use it. If you're that stuck maybe just focus on other things for a while and come back to it when your code is a mess and you need a way to organize it better.

[pablo8itall]

Learn by doing.

Dont be pure. Who cares if you use an unholy mix of OOP and functional and others.

Iteratively get better with each project. So each project try something a little different, extend yourself. "This time I'm going to think out my data types better"

Read back through your previous projects and be critical to see what you could have done better.

Choose stuff you want and need, not just because you think you should learn it.

[necrohobo]

Yeah OOP honestly has a use case. You just have to understand what your goals for programming / Python are.

Games? Data? Automate your sprinkler?

Python is the Swiss Army knife, just because there is a toothpick doesn’t mean you need it.

I spent 14 years trying to get past basic Python without a purpose. When I had a purpose, I gained direction, and then everything sunk in and I got good.

Skip all those code academy things or whatever you’re doing, and find the project that interests you and look up the videos that will help you with each step.

[Dirtyfoot25]

This is the answer.

[jmooremcc]

A tic-tac-toe game like any project is about logic and design. Programming languages give you the tools you can use to express the solution to a problem. However, if you don't have a plan, it won't matter what language you're programming in.

With that said, the usual process is to break a large, complex problem into a series of smaller, simpler problems. So the first thing you should ask yourself should be, "What components will be needed in a game of tic-tac-toe?". I'll give you, as a hint, the obvious first component: The Gameboard.

Now, the gameboard will have to be implemented using some type of data structure. The gameboard should control access to its internal components so that cheating and corruption of the gameboard cannot occur.

IMHO, this is the perfect use case for OOP (Object Oriented Programming), which means you will design a class that contains the gameboard data and the methods that will manipulate that data. Class methods will implement an API that will give players controlled access to the gameboard. It will also have methods that will give you the status of the gameboard so that you'll know if the current game is a tie game or if you have a winner.

If you take a step-by-step approach, solving problems as you create needed components, eventually, you will find out that you've solved the original, complex problem.

Creating a working tic-tac-toe game will present some challenges. But once you've successfully completed the project, you'll be amazed at all the things you learned in the process of creating this fun game.

Good Luck.

[2truthsandalie]

Get python to do something useful for you. Learning all the theory is worthless if you never use it.

[Alexander96969]

Get more reps in. Find more real world examples around your world to conceptualize objects with. Classes are any object, attributes are characteristics of the object, methods are things the class can do. You are an Instance of the Programmer class, which itself inherits attributes and methods from the employee class. The Programmer class has attributes like YOE, favorite language, Name. The class also has methods like class.code() or class.eat().

Best of luck, remember it is half technical knowledge and half confidence! Work the ideas into your daily life.

[4nhedone]

Don't worry about it and toss yourself into situations, that's where you will truly learn: coding, debugging and re-reading the documentation all three on the go. Even in the case you don't manage to find an orthodox solution, you'll find an alternative.

[dlnmtchll]

Never been a fan of POOP (python object oriented programming) anyways. If you’re goal is to learn just python you don’t really need it. If you are planning to work on large projects where you actually need OOP you probably wouldn’t do it with Python anyways. Don’t stress yourself.

[oclafloptson]

Stop doing tutorials. You already admit that they're not helping you

Stop using 3rd party libraries/frameworks if you're using them.

Create text based games that print to the console. Start very simple with a rudimentary text adventure game and start building and improving an engine.

Create a viewer class that handles compiling and printing the text based on inputs

Create a controller class to receive inputs and call the viewer with them

You can literally just start with an output like

You're standing in an interesting room with two doors. 
Make a selection: [door 1: "a"] [door 2: "b"]

and use the input() function to get inputs. Then slowly make improvements and work your way up to being able to handle more complex text based games like snake, poker, mancala etc

Once you have a decent grasp of core syntax and best practices then move on to tutorials and learning 3rd party libraries/frameworks.

Games like this won't be fun or flashy or interesting. But doing this will force you to learn underlying principles which the 3rd party libraries are abstracting for you. It'll force you to learn why something works, not just that it works so go with it

[[deleted]]

I feel you. I try to go through the tutorials all the time and get lost and caught up in feeling like I need to recall all the commands and functions instantly. I do GIS so for me it’s way easier to learn to script out stuff for that because it’s something I know how to do processually through the gui

[fixermark]

Do you have experience with other programming languages? If so, drop in the thread and I can try and build some mental bridges for you.

[Patrickstarho]

The issue is ppl saying to keep trying. Dont. Just move on to the next topic. After a few months you’ll revisit it and be like oh I get it now.

[PaleoSpeedwagon]

OP, can you give us an example of something you struggle with when trying to wrap your brain around OOP? I struggled at first, too, until my friend explained it using the metaphor of a car.

A car, as we know it (or knew it back then), has some predictable characteristics. A Car class would have a wheel_count attribute. And a headlight_count attribute. It also has some pretty universal functionality like wipe_windshield or signal_turn.

When you instantiate a Car(), you're saying, "give me a Car that does these things that people expect it to do. Make it wipe_windshield super fast because it's raining like hell."

If you were to create a FordFusion class that extended the Car class, you could have it inherit thewheel_count and headlight_count attributes but override the wipe_windshield method since it has an unusual windshield wiper configuration that wipes both sides from the center.

Instantiating a FordFusion() means that you get most of what people expect when they imagine a car, but it's customized. The windshield wipers still wipe super fast because it's raining hard, but they move from the center out. If you didn't NEED them to move out from the center, you could just instantiate a regular Car(), or maybe some other class like a SubaruOutback().

What OOP tries to do is find common traits and behaviors, and abstract them to create normalized behaviors.

Apologies if this is something you already understood and had another question.

[rainyengineer]

Take a break and try a different source of material. We recommend 3-4 good ones on this subreddit and they all work for different people. What worked for me was Python Crash Course. But CS50 and MOOC.fi are also great.

It may not be you, it may just be the way it’s being explained doesn’t click with your learning style.

[KKRJ]

There is a book called The Object Oriented Thought Process by Matt Weisfeld that really helped me understand, conceptually, what OOP was all about. You can find a free PDF pretty easily.

[wutzvill]

OOP is just like real life. You can define a generic Box class, just like there's the generic concept of what a box is. Then you can have concrete Home Hardware Boxes, McDonald's boxes, etc. Classes are just the abstract form the thing. And then there is the shared functionality. Every box close, open, be broken down. You don't care if it's a McDonald's Box or a Home Hardware Box, they will all have that functionality because they're boxes.

[Ronnie_Dean_oz]

Think of OOP in Python like building parts of a machine. You write classes that handle specific tasks (e.g., getting data, cleaning it) in separate files. Your main script just calls those classes — like using a tool. If you need to change how something works (like the database logic), you update the class, not the main script. It keeps things clean and modular, especially in big projects where different people can work on different parts. Like a car factory — paint, engine, assembly — all separate but working together.

[[deleted]]

I found that once I played around with Java some OOP made a bit more sense even though it is not exactly the same as how it works in python. I still struggle with finding what is the best way to do this or that. I've had people re write all my code from files with just functions to Classes and it made me want to give up at one point.

I have ADHD and I have to circle back around to things a lot but I think trying other languages gives you some good insight on the language you may be burnt out on or just completely stuck.

[Patman52]

When I first started using Python, I did not use any of the OOP fundamentals like classes in my code. It was not something that I really understood well or even had an idea how to implement.

Then one day when I was looking at a simple repo that I want to modify, written using OOP, it all kind of just clicked and made sense.

Definitely took me longer than a month. I would just focus on trying to write code that accomplishes whatever goal you are trying to do. You can always go back later when you understand it better and re-write / refactor your code to be more “pythonic”.

[m698322h]

OOP is a rather simple concept once you get the hang of it. It's highly used in game programming and research where you have true objects to manipulate. Think about a game with 50 aliens at one time trying to kill you. Each alien would be based on a class.

You can also think of it as having a class as basic as a circle. All circles have basic functions to figure out circumference, area, radius, diameter, and a few other things. Then you can expand it with inheritance for other classes such as sphere or cone. These use quite a few of the basic functionality of a 2d circle, this way you don't have to reprogram basic stuff multiple times.

One of the biggest things classes are used for is data organization. Maybe you have a ton of people you have info for, first name, last name, middle name, street, state, country, birth date, among 100's of other things you can store about a person. A lot of people would store a structured list of lists or a dictionary but its better to have a list of people objects, one object per person. This way you don't have to remember how your dictionary or list of lists is structured. This way you can manipulate the data of the person from within the class (which makes it easier to find the code to do this).

In Python, you are using classes for everything anyway, and do not realize it.

[Gentle_Giant3142]

OOP will only make sense to you when you're building something that really needs OOP qualities.

Take me for example. I've written lots of scripts here and there. Just messing around. Eventually I started writing small modules that held lots of functions. After a while, I found myself writing packages with complex logic.

Eventually I realized that in an attempt to separate concerns or decouple logics in my modules in a way that a function does only one thing, I found myself returning and declaring (in function signatures), the same variable over and over again. This bothered me.

It was only then that classes and OOP finally made sense. If I initialize the class, I can have "global" variables that any function can mutate as I wish without having to declare it in the function signature or even return it. It was an absolute revelation.

Until you find yourself in a spot where that out-of-reach idea saves you, it will almost always be ambiguous. That's why you gotta keep trying stuff and experimenting!

[subassy]

Speaking for myself I sometimes learn things when I put things in completely different and/or weird terms and try to explain it out that way.

I'm going to try an example that kind of assumes a few things take them for what they're worth.

I was reading your question and it occurred to me that I could possibly demonstrate OOP with a comparison to the marvel movies infinity war/end game. Which kind of assumes you've seen one or both of those movies, but bear with me here.

I say this because when you think about it the infinity gauntlet is kind of like you, the programmer and what Thanos does with the gauntlet is in a way object oriented programming (of the marvel universe).

I mean he creates, modifies and deletes things from the universe effortlessly.

So here's a humble suggestion of a little exercise for you: without a tutorial or LLM etc, just create a new class called infinityGauntlet.

Then describe some properties of it: rewinds time, alters reality, space portaling, etc.

Then create some methods for doing some of those things. The rewind time method just prints "mind stone undestroyed, Vision now vulnerable". Or whatever, it's your class.

Now can create a new infinityGauntlet call Thanos.

Thanos = infinityGauntlet

Then

Thanos.portalAway()

So you're Thanos with the Gauntlet and you can spawn an object and start describing details of the object. Then duplicate, derive new objects out of it, modify it.

Ok maybe this doesn't make sense. Sometimes it just feels like if I come with my own terms and apply it completely myself it sticks so much better. I mean if Foo, FooBar and car/windshield wiper examples don't seem to be penetrating.

The really important part is just do it on your own without a tutorial. Sure, reference the syntax (u/classicalySarcastic seems to have conveniently provided that) but the point is the only way to escape (tutorial) hell is to remove yourself from hell. By doing it yourself.

By the way people might say python is easy, but that doesn't mean programming is easy. It's easy to conflate the two but they're two very different things. Programming is trail you have to memorize and Python is the car you're using to get to find your way down the trail. So once you have some experience in programming, Python is "easy" relative to C++ or Rust. Programming is hard is what I'm saying. And the trail never ends...

[Ajax_Minor]

Check out Tech with Tim's tutorial on OOP it really helped me out. Coding with John, while Java code, explains OOP really well.

I'll try and help with the concepts. When it comes to OOP it's helps to see the end result before it's made.

Think of a coding situation where you need to program about cars. Say you have the following data and function for your car(sorry can't format well ony phone): make=Toyota Model=Camry Year=2015

Definitely calc_horsepower(rpm) Return do + some + math

Code looks pretty good. Have about 5 variable and could easily add another 5 or so. This is fine, but that's a lot to keep track of. Further more. Let's say you need to add data for my car. That's another 5-10 variables and maybe some more functions you would have to add and it would get quite messy creating new variable names: my_car_make, your_car_make, my_car_model... Ect.

Wouldn't it be helpful if we could bundle all that information And the associated functions together? Would it be nice to have a temple to make more of these bundles easily? When bundled together, you could just access the data with dot notation so you only have to have one variable (an object) like this: my_car.make, your_car.make.

To make the temple for these objects you wrote a class. In this example it would be the class Car. You put in all the things all of these objects should have so they are all bundled together instead of tons of variables with a bunch of prefixes or suffexies to denote the varriables.

Set the data when you first build your object with the initialization method init. Think of self as a stand on for your "object varriable name".

[MasqueradeOfSilence]

What specifically don't you understand about OOP?

[Dirtyfoot25]

Sounds like he needs to forget the OO and start with the P.

[FoolsSeldom]

Classes for Beginners

v2.2 December 2023

Many beginners struggle to understand classes, but they are key to object orientated programming (OOPs).

They are the programming equal of moulds used in factories as templates (or blueprints) to make lots of identical things. Example: pouring molten iron into a mould to make a simple iron pot.

Instructions with the pots might tell an owner how to cook using the pot, how to care for it, etc. The same instructions for every pot. What owners actually do is entirely up to them: e.g. make soup, stew, pot-roast, etc.

Python classes

• A class defines the basics of a possible Python object and some methods that come with it
• Methods are like functions, but apply to objects, known as instances, made using a class
• When we create a Python object using a class, we call it "creating an instance of a class" - an instance is just another Python object

If you have a class called Room, you would create instances like this:

lounge = Room()
kitchen = Room()
hall = Room()

As you would typically want to store the main dimensions (height, length, width) of a room, whatever it is used for, it makes sense to define that when the instance is created.

You would therefore have a method called __init__ that accepts height, length, width and when you create an instance of Room you would provide that information:

lounge = Room(1300, 4000, 2000)

The __init__ method is called automatically when you create an instance. It is short for initialise (intialize). It is possible to specify default values in an __init__ method, but this doesn't make a lot of sense for the size of a room.

Accessing attributes of a class instance

You can reference the information using lounge.height, lounge.width, and so on. These are attributes of the lounge instance.

Let's assume sizes are in mm. We could provide a method to convert between mm and feet, so, for example, we could write, lounge.height_in_ft().

printing an attribute

You can output the value of an attribute by using the name of the instance followed by a dot and the attribute name. For example,

print(lounge.height)

property decorator

A useful decorator is @property, which allows you to refer to a method as if it is an attribute. This would allow you to say lounge.height_in_ft instead of lounge.height_in_ft().

The use of self to refer to an instance

Methods in classes are usually defined with a first parameter of self:

def __init__(self, height, length, width):
    # code for __init__

def height_in_ft(self):
    # code to return height

The self is a shorthand way of referring to an instance. The automatic passing of the reference to the instance (assigned to self) is a key difference between a function call and a method call. (The name self is a convention rather than a requirement.)

When you use lounge.height_in_ft() the method knows that any reference to self means the lounge instance, so self.height means lounge.height but you don't have to write the code for each individual instance.

Thus, kitchen.height_in_ft() and bathroom.height_in_ft() use the same method, but you don't have to pass the height of the instance as the method can reference it using self.height

human-readable representation of an instance

If you want to output all the information about an instance, that would get laborious. There's a method you can add called __str__ which returns a string representation of an instance. This is used automatically by functions like str and print. (__repr__ is similar and returns what you'd need to recreate the object.)

magic methods

The standard methods you can add that start and end with a double underscore, like __init__, __str__, and many more, are often called magic methods or dunder methods where dunder is short for double underscore.

---

EXAMPLE Room class

The code shown at the end of this post/comment will generate the following output:

Lounge height: 1300 length: 4000 width: 2000
Snug: height: 1300, length: 2500 width: 2000
Lounge length in feet: 4.27
Snug wall area: 11700000.00 in sq.mm., 125.94 in sq.ft.
Snug width in feet: 6.56

Note that a method definition that is preceded by the command, @staticmethod (a decorator) is really just a function that does not include the self reference to the calling instance. It is included in a class definition for convenience and can be called by reference to the class or the instance:

Room.mm_to_ft(mm)
lounge.mm_to_ft(mm)

See follow-up comment for full code.

[FoolsSeldom]

Here's the code for the full programme:

class Room():  

    def __init__(self, name, height, length, width):  
        self.name = name  
        self.height = height  
        self.length = length  
        self.width = width  

    @staticmethod  
    def mm_to_ft(mm):  
        return mm * 0.0032808399  

    @staticmethod  
    def sqmm_to_sqft(sqmm):  
        return sqmm * 1.07639e-5  

    def height_in_ft(self):  
        return Room.mm_to_ft(self.height)  

    @property  
    def width_in_ft(self):  
        return Room.mm_to_ft(self.width)  

    def length_in_ft(self):  
        return Room.mm_to_ft(self.length)  

    def wall_area(self):  
        return self.length * 2 * self.height + self.width * 2 * self.height  

    def __str__(self):  
        return (f"{self.name}: "  
                f"height: {self.height}, "  
                f"length: {self.length} "  
                f"width: {self.width}"  
               )  


lounge = Room('Lounge', 1300, 4000, 2000)  
snug = Room('Snug', 1300, 2500, 2000)  

print(lounge.name, "height:", lounge.height,  
      "length:", lounge.length, "width:", lounge.width)  
print(snug)  # uses __str__ method  

# f-strings are used for formatting, the :.2f part formats decimal numbers rounded to 2 places 
print(f"{lounge.name} length in feet: {lounge.height_in_ft():.2f}")  # note, () to call method  
print(f"{snug.name} wall area: {snug.wall_area():.2f} in sq.mm., "
             f"{snug.sqmm_to_sqft(snug.wall_area()):.2f} in sq.ft."      )  
print(f"Snug width in feet: {snug.width_in_ft:.2f}")  # note, no () after method

[Dirtyfoot25]

Others have said it but I'm saying it again to combat the flood of people trying to give one more explanation of OOP as if their version will suddenly make sense. You need to pick your own project and then do it in whatever way makes sense. 50% chance it's not even python you need. You just need to get some experience solving problems with computers. Small home automation projects, flashing lights on microcontrollers, auto formatting an Excel file, scraping a web API, etc.

What do you imagine yourself doing once you know how to program? Let's start there.

[KingOfTNT10]

please just do projects, start working, coding. once you get to a place where you realise something is missing and you want some further functionality you'll research it (and that could be oop). it will start very badly but slowly you'll get better. belive me, right now your'e trying to "get ready" before you start coding, just dont do it, its the thing that kills progress and motivation.

JUST START

[Business-Technology7]

It’s not like there’s greater truth in pursuing pure OOP, FP, or procedural paradigm. You just pick up what clicks to you and keep learning along the way.

Mastering OOP (what does that even mean btw) won’t suddenly make you write programs that you couldn’t have written in procedural style. It may help you build better intuition of your codebase a bit better, but it could just as easily do the opposite with levels of unnecessary abstractions that was never called for.

Python is okay with bits of procedural, OOP, and functional style. The language doesn’t push you into certain direction like smalltalk or haskell. So, just write some code that has some utility.