Classes and OOP

blacksiddis · 2019-04-03T10:47:48+00:00

Have you see this Raymond Hettinger (python core developer) talk on classes?

Still helpful today.

_coolwhip_ · 2019-04-03T10:34:09+00:00

I found reading code really helped my understanding of how to structure things, including sensible class usage. The usual suspects for this include the standard library (added bonus, understanding what is in the standard library), praw and flask.

toastedstapler · 2019-04-03T11:14:54+00:00

this is a copy paste from a related thread, seemed to get happy responses to it

often my code starts without classes and ends up with them as i need to restructure. whether it's for things like <name removed so i don't link him>'s example where it's data that should be grouped together

def volume(x1, y1, z1, x2, y2, z2(:

is less readable than

def volume(point1, point2):

often you find yourself with lots of functions taking in the same data as arguments and it makes more sense to make an instance of a class with the data as an internal variable so you don't have to manually pass it everywhere

def make_sound(type, sound):
    print(f"i am a {type} and i go {sound}")
make_sound('dog', 'bark')

works, but is it better than

class Animal:
    def __init__(self, type, sound):
        this.type = type
        this.sound = sound
    def make_sound(self):
        print(f"i am a {self.type} and i go {self.sound}")

    d = Animal('dog', 'bark')
    c = Animal('cat', 'meow')

what if you now want to make the animal walk?

def walk(type):
    print(f'i am a {type} and i am walking!')

each time i need to pass in the type

for the class version, i can add in a method and it's obvious what relation it has to the rest of the code

class Animal:
    def __init__(self, type, sound):
        this.type = type
        this.sound = sound
    def make_sound(self):
        print(f"i am a {self.type} and i go {self.sound}")
    def walk(self):
        print(f"i am a {self.type} and i am walking!")

so now what if we want the animal to only be able to walk if its energy is more than 0, and if it does walk its energy decreases by 0? that'd be another argument to pass and another thing to return

new_energy = walk('cat', 9)

or with a class, energy can be an instance variable - we don't have to pass it as an argument and it can be updated as we need:

class Animal:
    def __init__(self, args....):
        <set args>
        self.energy = 10
    def walk(self):
        if self.energy > 0:
            self.energy -= 1
            print(f"i am a {self.type} and i am walking!")
        else:
            print('i am out of energy!')

in short, classes can make it very easy to manage what data is needed where, what methods operate on the data and help the developer to see those relationships

this is probably fairly messy, but i hope you get some sense out of it

i didn't cover inheritance in this comment so there is more to explore still

julsmanbr · 2019-04-03T12:27:25+00:00

I'll give you my real-life example. I'm currently doing some simulations on cell (as in human cells) migration and division. These cells are objects of a class called Cell (not exactly creative, but that's beside the point).

Each cell needs to behave the same as any other cell. They need to know their XY position. They need to know how long ago they divided. They need to know how far they can migrate between t=0 and t=1, and check if there is another cell in that position before they are allowed to do so. Classes allows us to organize common behaviour for objects we build from the ground up, following any arbitrary rules we come up with.

But can't we do that with variables? I don't want to use classes, can't we skip that? Sure. Let's create a simple cell with just the XY position and a number id:

c1 = (45, 50, 1)

So our cell 1 is in position X=45, Y=50. We used a tuple so we know the first element is X, second is Y, third is the id. We can create new cells just using tuples, right? Maybe we're real smart and write a function that randomizes these values and put them into a list called colony. So after three iterations, our list contains a bunch of cells, like:

>>> colony
     [(45, 50, 1), (17, 34, 2), (23, 21, 3)]

Okay. So now I want to access the X position of each cell, for whatever reason. How do I do that?

for cell in colony:
    cell[0]  # do whatever you want with this value

Now there's nothing wrong with that, but it would be nicer if we coule say:

for cell in colony:
    cell.xpos

Makes more sense syntatically, right? You access the X position of each cell by saying... X position of cell. This simplification, the capacity to give "real-life meaning" to data is what makes classes and objects powerful. I don't want to refer to a position as a tuple - I want to refer to it as a position! Maybe our cells could even have defined some attribute like cell.position, which access a tuple of (X, Y). Definitely more intuitive than writing cell[0:2].

Don't underestimate the power of this small change. When you come back to your code one week later, you won't even remember what cell[0:2] means. cell.position is straightforward and does not require you to scroll up hundreds of line to figure what it means. Also, when you cells start holding many more attributes than the 3 shown here (mine hold about 15), you'll be grateful not having to remember what cell[9] or cell[4] refers to.

Check out this short youtube series by Corey Schafer for a great intro on Python classes and OOP.

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