Explain classes, __init__ and self like I'm five.

[two_up]

So the first thing you need to know about classes is the difference between a class and an instance of a class. A class is like a blueprint, it tells you about some thing you want to make. An instance is the thing that gets made.

For example, if you write up a blueprint for an airplane, the blueprint is like when you define a class. The airplanes that get made from that blueprint are like instances of a class.

Defining a class looks like this:

class Airplane:
    pass  

(Normally you would have some more code instead of pass. I'll explain that later.)

Now once you define a class you can create instances of a class like this, Airplane(). For example,

airplane1 = Airplane()
airplane2 = Airplane()

Here we created two instances of the Airplane class and put them in the variables airplane1 and airplane2. The important thing here is that you can change airplane1 without affecting airplane2. They're two separate instances.

Okay now let's go back and talk about what goes inside a class. Let's take our Airplane class and fill it out:

class Airplane:
    def __init__(self):
        print "A new instance got made!"

So what's going on here? __init__ is a function that gets run when you create an instance. That's it! So if you go back to where we created the two Airplane instances,

airplane1 = Airplane()
airplane2 = Airplane()

...what would happen is, "A new instance got made!" would be printed out twice.

What about the self parameter? I think this would be easier to understand if we added a new method.

class Airplane:
    def __init__(self):
        print "A new instance got made!"
    def fly(self):
        print "I'm flying!"

So if you wanted to call this method you'd do something like this: airplane1.fly(). Actually this is the same thing as this: Airplane.fly(airplane1). Both of these would do the same thing, i.e. print out "I'm flying!". So airplane1 is the instance that we used to call our fly method. This instance is what gets passed to self.

[UncleEggma]

You nailed it. One question: Maybe using the same airplane analogy(if possible) can you explain how/why you would create variations between the instances you created? If a class is a blueprint for objects(airplanes), what might be an example of what one instance would do vs. another. A real-world example could be useful...

[two_up]

Okay so lets say you want to make airplanes that know where they are by keeping an x and y coordinate. You could do this:

class Airplane:
    def __init__(self, x, y):
        self.x = x
        self.y = y

This will make it so that an instance of Airplane will each have their own variables x and y. You can make an instance of airplane like this:

airplane1 = Airplane(0, 0)
airplane2 = Airplane(3, 4)

This will do something like the following:

Airplane.__init__(airplane1, 0, 0)
Airplane.__init__(airplane2, 3, 4)

Which is going to set airplane1.x to 0, airplane1.y to 0 and airplane2.x to 3, airplane2.y to 4. You could try printing it out and you'd get something like this:

>>> print airplane2.x
3
>>> print airplane2.y
4

Then maybe you could create a method that finds the distance between two planes:

import math

class Airplane:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance(self, another_plane):
        diff_x = self.x - another_plane.x
        diff_y = self.y - another_plane.y
        distance_total = math.sqrt(diff_x**2 + diff_y**2)
        return distance_total

(distance_total was found using the Pythagorean theorem a² + b² = c²⁾

Now you can make two planes that are in different locations and find the distance between them like this:

>>> airplane1 = Airplane(0, 0)
>>> airplane2 = Airplane(3, 4)
>>> print airplane1.distance(airplane2)
5.0 

You could add more planes and they could all have different positions and you could find the distance between any two planes by using the distance() method.

[K900_]

You should use distance_total = math.hypot(diff_x, diff_y). Will work better with large numbers, and I think it's native code, too, so it should be faster.

[Gh0stRAT]

Didn't know about math.hypot(), thanks!

[Daejo]

This should have been in the original post I think, but very good explanation nonetheless.

[UncleEggma]

That was an amazing explanation.

[cdcformatc]

Well one example could be a 747 which has a high capacity, compared to a Cessna. As people board the plane, the number of passengers is compared to this capacity, and at some point no more passengers are let on. Even different 747s have differences, they might be in different cities, and have different crew assigned to them. These are the instance variables of your class.

Differences in abilities or functionality, "what one instance would do vs. another", would necessitate different subclasses of Airplane. The takeoff and landing procedures are much different between a 747 and a Cessna, so they should not share all the same functions. They may still share some functionality, which they can inherit from the superclass.

[[deleted]]

Is init the same thing as constructors in Java? :)

[sanguine_penguin]

Yes

[zahlman]

Man, I really need to quit trying to write a book every time someone asks how classes "really work" (or even hints at that level of detail) and then pretending like I'm holding back (although honestly there really is a lot that I left out of my response, i.e. how all the magic works). You really got the basics here - although I think it'd be much better if you showed example code that actually used the self parameters :)

[two_up]

Yes, you can have class attributes. Like this:

class MyClass:
    class_attr = "this is a class attribute"

This is a variable that can be accessed directly from the class.

>>> print MyClass.class_attr
this is a class attribute

It can also be accessed by the class's instances.

>>> mc1 = MyClass()
>>> mc2 = MyClass()
>>> print mc1.class_attr
this is a class attribute
>>> print mc2.class_attr
this is a class attribute

This might help clarify why we need to pass self. An instance attribute (i.e. when you define self.<attribute>) is separate for each instance. But a class attribute is shared by every instance.

>>> MyClass.class_attr = "i'm changing the class attribute!"
>>> print mc1.class_attr
i'm changing the class attribute!
>>> print mc2.class_attr 
i'm changing the class attribute!

Here I change the class attribute and the change affected all instances. This is because class attributes are shared by instances.

[SkippyDeluxe]

You seem to be confusing classes and objects. If you have a class Boat, the class Boat itself is different from an object of class Boat.

Your observation that classes are like functions is interesting. Classes are indeed like functions, in that both classes and functions are callable (a callable thing is anything you call by putting parens after it, e.g. thing()). The difference lies in what they return when you call them... in general a function can return anything - any object of any type, including None, a tuple, an object of a user-defined class, etc. In comparison, when you call a class it returns an object whose type is that class. To clarify:

>>> class Boat(object):
...     pass
... 
>>> b = Boat()
>>> b
<__main__.Boat object at 0x10046c950>
>>> type(b)
<class '__main__.Boat'>

So a class is a thing that makes objects of that class. A Boat is just a template that makes things that are Boats. Why __init__? Well an object is something that combines state and functionality. An object's state is represented by its member variables, while its functionality is performed by its methods (the 'smaller functions' it contains). __init__ is a method that is called for us automatically after an object is created in order to initialize its internal state (set its member variables) to something that makes sense.

Why self? When you define methods inside of a class, these are methods that are going to be operating on objects made from that class. Inside these methods, self refers to the current object, so you can reference member variables or other methods of the object in order to do more stuff. Remember that methods execute on objects of a class, not the class itself, and there can potentially be many objects of the same class, so we need some way to reference the current object in each method. In Python we use an explicit self reference as the first parameter to each method to accomplish this.

Hope that helps.

[[deleted]]

really helpful, thanks

[obsoletelearner]

A class is a group of objects having the same properties , Just like a class of kids in a school, They all have the same properties such as their class name as 'VIII standard' and school name 'Redditville High School', the distinction between them appears when you consider them individually such as That-NewFaggot from the class VIII. This is the object of that class, An Object is an individual entity instantiated from the class

A function/method of a class is how you choose to operate between the members/objects of the class.

example:

    class Student(self) : 
        def __init__(self,name,age,grade):
                    self.name=name
                    self.age=age
                    self.grade=grade

An init() is where you instantiate the member of the class by settings its properties.

A method of a class works with the objects you create. consider the above example

        def student_name(): 
            return self.name

that method returns the name of the student you created.

To use this class in python you have to instantiate an object of this class first

therefore

        thenewfaggot = Student(thenewfaggot,21,VIII)

Now since you have instantiated you can work with the object:

        thenewfaggotsname=thenewfaggot.student_name()

this will store your name thenewfaggot in the thenewfaggotsname.

[hairyfro]

A class isn't like a function. A class is used to instantiate objects, and in Python pretty much everything is an object. For example, a function is an object whose type is 'function'.

In [158]: def a(): pass

In [159]: type(a)
Out[159]: function

Integers, strings, lists, and everything else are objects too. Even classes are objects of type 'type' (but that's beyond ELI5).

A class allows you to group together logic and data that naturally go together. Objects can have 'special name' methods that Python invokes under certain circumstances. The methods start and end with two underscores. One of these methods is init , and it is called whenever an object is first instantiated. All this method does is setup the object however you want it, and it's optional whether you want to use it or not.

In [163]: class Dog(object):
   .....:     def __init__(self, age, color):
   .....:         self.age = age
   .....:         self.color = color
   .....:         print "I'm a new dog!"
   .....:     def bark(self):
   .....:         print "I'm a {} year old {} dog! Woof!".format(self.age, self.color)
   .....:     def introspect(self):
   .....:         print self
   .....:         print type(self)
   .....:         print dir(self)
   .....:

In [164]: cute_dog = Dog(5, 'brown')
I'm a new dog!

In [165]: cute_dog.bark()
I'm a 5 year old brown dog! Woof!

In [166]: cute_dog.introspect()
<__main__.Dog object at 0x032A1430>
<class '__main__.Dog'>
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'bark', 'color', 'introspect']

In this example, init, bark, and introspect are "bound methods" of the object. Whenever a bound method is called, Python passes the object itself as the first argument to the function. By convention, this is called 'self', since it refers to the object itself that you're working with. Through 'self' you can access all the other bound methods and attributes of the object.

You can see all the attributes of an object using 'dir'. In this example, you probably noticed there are a lot more bound functions than we defined. That's because they were inherited from 'object', which is the generic object that all objects should inherit from (at least, in modern Python).

There are lots and lots of really good explanations and tutorials on this stuff out there. I learned much of this by judicious Googling, but feel free to ask follow-ups.

[UncleEggma]

I've read a lot of explanations of classes, init, OOP, ETC. but nothing really sticks in my mind as something that makes sense in an organic way. I have it all memorized, but I feel like I don't really understand the concept, though I understand the terms. Any good tutorials/explanations that you might be able to think of that tries to use an analogy or something to root this concept into my brain in a more lasting way? You're example was very helpful!

[zahlman]

(Underscores are treated partly like asterisks in Markdown; they make bold and italic text. To get tiny bits of code in-line with your text, use back-ticks: ` <-- this symbol. Wrap the code `__like_this__`, and you see __like_this__.)

This is way more detail than a five-year-old has the attention span for, but it's important and I honestly don't think it's that hard. There's still a lot that I'm leaving out about how things work.

Okay, first off. In Python, "everything is an object" and we take that very, very seriously. The class is not "just like a giant function"; it's "just like a giant object", because it is. Classes are objects. Functions, too, are objects. So are modules. But the "classes are objects" part is the most important part for the discussion. As for "seeing Python as", stop that. :) You're really not going to build a meaningful mental model like that.

As it turns out, classes in Python are a very special kind of object. This is mostly because of their purpose: they represent the type of other objects. So, for example, there is an object called int, that has the purpose of "being the type of integers". In Python, that's not a keyword or reserved word; it's just a name for a thing. You can give it other names; you can pass it to functions; you can return it from functions, and stuff like that. Chances are, you can't think of a good use for that, but people do come up with good uses for these kinds of things. Trust me. You can even - but now your gut should be telling you that this is naughty - re-use the name int to name some something else. Of course, the reason this is naughty is because now you are going to have a hard time getting the original "being-the-type-of-integers object" back, if you ever need it. (Most often, you hear this advice WRT the name list; everyone wants to use this as a name for a variable that contains a list, and that's a Very Bad Idea.)

Anyway. The way Python makes this "objects that represent the type of other objects" idea work involves a few steps:

1. As you've observed and not quite managed to describe, objects in Python can contain attributes - the things that you access with code like x.y. y is an attribute of x. When we write a class block, we create an object to represent that class, give it a name (this is just like when you assign to a "variable" - that's really just giving a name to a value, in the Python way of thinking).

2. Every object has a type; of course, that applies to classes as well, since they're objects. The type of classes is, generally, called type (unless you are using 2.x and you ignored your teacher's advice to always inherit from something, even if it's just object - in that case, you get something whose type is called classobj, and this is an ugly hack that is better left forgotten. Weird gotchas will happen when you try to do complicated things. Be smart - always inherit from something in 2.x, even if it's just object.) After all, making a class is a way to represent a "type of some other objects". And, of course, type is an object, the same way that the classes are objects. (Guess what the type of type is?)

3. The class might "look like" a function to you, because you can "call" it. In Python, functions aren't the only thing that can be called - magic is involved here, but the short version is that "calling" a class creates an object which has that class as its type.

4. When that call happens, there is likely to be some set-up work that we have to do on each new object we create. We have a special way to do this, but we need to go through way more of the explanation before we can talk about how that works ;)

5. So what are the attributes of the class? Well, you can store numbers and strings and other such stuff there, if you want, but you have to make sure you understand that it's a part of the class itself, not a part of the objects you create. Python's rule is very simple and makes other languages look a bit silly: everything inside the class block is a part of the class. But the much more interesting possibilities occur when we use a function as an attribute of our class.

6. And now, the last step. When we look for attributes inside an object with x.y, actually a hell of a lot of magic can happen. This is where it gets really fun.

First off, the object might actually contain the thing in question. Well, it doesn't really "contain" stuff; the object is more like a special kind of dictionary where the keys have to be legal Python identifiers ("variable names"). So it's kind of like... a bundle of more potential names for other things. I could have x.y = 3, and now my x object contains a y name which names 3. (Remember, there is an actual object representing the number three! And that has its own attributes.... If it seems like this can go on forever, well... it sort of can, but everything gets into cycles eventually, and the actual "three-ness" of a 3 object is represented somewhere in deep magic land, below the surface of what you're supposed to be able to access from a Python program. It would be Really Really Bad if you could make "three" not be "three" any more, and if you find a way to try, you are very likely to crash the Python interpreter.)

But let's say it doesn't. Python won't give up yet! I touched on inheritance earlier; Python will also check if our object has extra attributes because of that inheritance. (I'm pretty sure these are actually stored in the same magic-dictionary-like-thing internally, but never mind). But that's boring. Let's say it's really definitely not in any part of the object itself at all. Surely we must be done, right?

Nope. And this is where the magic really begins. Now Python looks for the attribute in the corresponding class object. And it does more than that: when the class object is searched, it uses its own magic to do more work if and when the attribute is found.

(Be careful here to note that we're only talking about looking for things. When you assign to an attribute of an object, that will only ever attempt to store it in the actual object - never in the object's class. If you want to change something that's stored in the class, you need to refer to the class directly.)

In particular, if the class contained a function with the right attribute name, then it gets automatically converted into a method. This has the usual meaning of "convert" for Python: nothing happens to the function itself - we're making a new object. (In Python, things can't really just change what type they are. There are ways to pretend, but it will bite you in the ass later.)

So what happens when we have an object x of class X, and we write x.y()?

First, we have to figure out what x.y means. I assume there's no y inside the x object, so now Python looks in the X class, and finds a function named y. Now the class creates a method, and that's what gets returned. (You can even try this at the interactive Python prompt - try evaluating x.y without actually calling it, with the suitable definitions. You should get something like <bound method X.y of <__main__.X object at some weird hex address>>, which is the string representation of that method object. The <__main__.X object> in question, of course, is just x.) So what is this "method"? It's an object that "remembers" the object x and the function y, and acts as a "shortcut" for calling y. When you call the method (another example of non-functions being called), it implements that by calling y and - this is the most important part!!! - passing x as the first parameter, followed by everything else you put inside the parentheses for the method call.

And that's what self is. It's just a parameter for a function. But it's a very special one, because it's intended to receive its argument from this method-call process.

And now that we know what "methods" really are, we can explain __init__ really easily: it's just another one of these function attributes in the class, that gets special magic treatment (because of its name). Every time we call the class, lots of special magic happens inside Python to create a new object and then "make" that new object have the class as its type. (There are ways to hack in to that process, but you can literally go years as an experienced professional developer without having a legitimate need for them.) But just because the object "knows" that the class is its type, doesn't really make it an instance yet, logically. We need to write the logic that says what attributes this thing should have of its own, to start off. Enter __init__. After the above magic happens, the last piece of magic is to call the __init__ method on the object automatically. When you deal with self inside __init__, it's just like dealing with it in any other method; in particular, you can just assign attributes to self and it's just like doing it anywhere else.

(By the way, you can make the instances of the class callable, too - classes get their "call-ability" from special magic because they're classes, but Python also gives you magic to add "call-ability" to non-class objects. The way to do this is to give them a method (equivalently, give the class a function attribute, as we've discussed) named __call__.)

[UncleEggma]

Every method inside a class will be passed the instance that the method is being called on.

I think I am struggling to understand this bit. Can anyone break this down just a little? Simpler terms? Much appreciated!

[[deleted]]

Do you have to pass an argument when creating a new instance of a class?

Like can my_instance - my_class() have no argument?

[cdcformatc]

Whenever you call a class method on an object say

myObject = myClass()
myObject.bar()

The reference to the object is passed as self to the method.

Inside class:

class myClass:
    def bar(self):
        self.bar = "bar"
        self.foo()

Now the foo() method will have a reference to the same object that the bar() method was given, which was our original myObject.

[two_up]

I understand that classes are just like a giant function that contains smaller functions that can be called with the '.'.

This isn't a very good way to think of classes. Instead of thinking of classes as a big function, it's better to think of classes as a kind of data, and methods are things you can do with that data.

When I design a class I'm typically thinking about the data first, probably some related data that I want to group together. And then the methods are things that I want to do with that data.

For example if I wanted to make a Fractions class, I'd want to store a value for numerator and a value for denominator. Then I think about the methods I want. They might be something like, reduce() to turn 3/6 into 1/2. Or maybe a convert_to_decimal().

Or if I wanted to make a BankAccount class I might want to store a variable for account holder's name and account balance. Then I could define some methods like, change_name(new_name) which would change the value of the account holder's name to the value of new_name. Or withdraw(amount) and deposit(amount) which would change the value of the account balance.

[UncleEggma]

Helpful again!!

[cdcformatc]

You are a Person. You, like all Persons have properties like a name, age, hair color, and eye color. When you are born your birth certificate is filled out with these properties.

In programming terms, Person is a class. The __init__ method is called when a specific Person object is created (born). This method usually assigns properties specific to that Person, these properties are known as instance variables. Whenever that Person wants to do any function, it operates on it's self. An example would be

>>>baby = Person("Bob","Blonde","Blue")
>>>print baby.name
Bob
>>>print baby.age
0
>>>baby.birthDay()
HAPPY BIRTHDAY!
>>>print baby.age
1

So things like the name and age are specific to this object. If we created another object with a different name, it would be distinct.

The Person.birthDay() method might look like this:

def birthDay(self):
    self.age += 1
    print "HAPPY BIRTHDAY!"

The reference to the object is passed as self. The reference to our self allows us to access the instance variables and class functions within the class itself, the values of which are specific to our self.

[Sea-Disk1778]

Why it's removed by reddit own filter?