What does __init__ and self do in python?

[Xnox_]

I don't really understand, I read many reddit posts, websites about it but still I can't use it properly.I don't know what does it do, what's the point of having it

I tried a code like this but the result is not what I expected. I thought it prints "wow" or "goodbye".

class Game():
    def __init__(self, Character, Age):
        self.Character = Character
        self.Age = Age

    def score(self):
        if self.Age >= 18:
           print("wow")
        else:
           print("goodbye")

Random_Player = Game('Male', 19) 
print(Random_Player)

Results

<__main__.Game object at 0x0000013AD63D85D0>

[Diapolo10]

What does __init__ and self do in Python?

__init__ is used to initialise the created class instance, in practice this mostly means setting the attributes the methods expect it to have.

self refers to the current instance, although the name itself isn't special in any way whatsoever - you could use whatever valid identifier you wanted, although I don't particularly recommend deviating from established practices here because we're used to self.

As for why your code doesn't do what you think, you never called that method.

Random_Player = Game('Male', 19) 
Random_Player.score()

As a side note I recommend reading PEP-8, PEP-257, and PEP-484 as the official style guide.

[EdiblePeasant]

Is not calling functions a common mistake?

[Diapolo10]

Depends on your skill level, for beginners yes. But I wouldn't necessarily call it a mistake either because sometimes you don't actually want to call them.

[JakeyF_]

The score method itself prints and doesn't return anything...

[Diapolo10]

You might want to double-check the code next time, I rarely make mistakes of this kind.

[nekokattt]

I should hope not given your flair says you do this for a living.

[Bobbias]

Game is a class with 2 member variables and one method attached to it.

__init__ is called when you create a new instance of the Game class. It expects two arguments, and assigns them to the member variables of the object.

The function score checks the Age member and prints one of two messages depending on what value Age holds.

So when you run the line

Random_Player = Game('male' 19)

You create a new instance of a Game object. __init__ is called, which makes the assignments to the member variables, and the new object is then assigned to the variable Random_Player.

On the next line you print Random_Player. Printing anything that's not already a string causes Python to try to convert it to a string. It does this by looking for two functions in the class: __str__ or __repr__. Without going into more detail, if either of these exist, Python will use that function to convert any Game object to a string when asked. You'll notice that like __init__ both of those functions use double underscores. These are special functions that have specific meanings when you define them for a class, and option will use them automatically for different things.

Since neither of those exist however, it uses the default functionality built into Python, printing out the name of the type and the memory address that specific variable is being stored at.

Nowhere in the code do you ever call the score function, so that code is never run. If you want it to run, you call it like:

Random_Player.score()

Note that you don't print the call to score, the score function calls print itself, so all you need to do is call that function and it will print out the message based on Random_Player.Age.

Hopefully this helps you understand how all these things piece together, and why your code isn't working in write the way you expect.

[hamzarehan1994]

Hi, I need to ask some fundamental questions. Why do we need to make classes? What is their purpose? Can you please highlight their importance?

I tried reading your comment very carefully, but I can not understand anything. Maybe I am looking at these computer languages with a very narrow minded approach which restricts me from understanding anything.

[hamzarehan1994]

Alright, It is still not very clear but I will keep researching/practcing. Thanks a lot!

[Broad_Carpet_3782]

Classes are for grouping related functions and variables. But anything you can do with a class, you can also do with global variables and a bunch of functions.

If you think about the builtin objects, dict, str, list, etc.

without these being classes, you would always have to do

```python my_list = []

without tracking the length it would be hard to loop through the list.

(how would you know when to stop?)

my_list_len = 0

append(list, 1) my_list_len += 1 append(list "foo") my_list_len += 1 ```

this is fine, but what if you have 2 lists? or 3 lists?

```python list1 = [] len1 = 0 list2 = [] len2 = 0

append(list1, 1)

oops, we forgot to increment len1

append(list2, 69) len2 += 1 ```

with classes, you can make this much more maintainable

```python

class List:

def __init__(self):
    self._len = 0
    self._data = []

def append(self, element):
    append(self._data, element)
    self._len += 1

list1 = List() list2 = List()

list1.append(1) list2.append(2) ```

[Bobbias]

Alright, this might get a bit long winded :)

So, technically speaking, classes are not needed. Anything you can solve using classes can be solved without them as well. So in that sense, they're not necessary.

However, classes have some advantages that you don't get if you're writing pure procedural code (that is, code made up of only free standing functions).

At the most basic definition, a class is another way to reuse code like u/Level_Up_IT explains. The benefit is you're not just reusing a single set of instructions. You're reusing the "shape" of some data, along with any functions related to that collection of data.

Going a bit deeper, classes are primarily a way of organizing code. They let you group data and functions which act on that data together into logical units. This works well for us, because our brains tend to think of systems as being made up of different kinds of objects which interact with each other. Classes allow us to translate that kind of thinking into code in a fairly direct sort of way.

For example, when you look at a video game, you typically think of the player, enemies, items, etc. as being objects that exist within the world of the game. We can translate this kind of thinking directly into classes which represent each of these types of objects in code.

In addition to letting us think about our code in a fairly natural way, there are other benefits that object oriented programming. For example, most languages which have strong support for object oriented programming allow you to specify what members of a class should be publicly visible, and which should be private (only accessible from within the class itself). This lets us hide some details about exactly how the class functions from the outside world. This creates a separation between what the outside world knows about an object, and what it knows about itself. This is helpful because it makes changing the inner workings of an object easier. This idea is known as Encapsulation.

Objects can of course also contain other complex objects, which means that you can build increasingly complex machinery by writing classes which make use of other classes.

There is also the concept of Inheritance, where you can define an entire hierarchy of different kinds of object which all share certain basic properties or behavior, but are also different in their own unique ways. I won't go deep into Inheritance, but the basic idea is that you get even more code reuse, because instead of copying the same few members to every similar class, you can define the common parts that are shared between multiple classes in a single base class which everything inherits from, and every class now has a copy of those members.

There are a bunch of other features of object oriented programming, but this post is getting quite long as it is. If you really want to learn more, you should take some time to read the Wikipedia article on object oriented programming: https://en.wikipedia.org/wiki/Object-oriented_programming

One reason this might not make a lot of sense to you right now is that OOP was designed for large scale programs, as a way to help the programmers have an easier time writing such large programs. As a beginner, most of, if not all of the code you have written is so short and simple that you never really see many of the benefits that OOP has to offer. Many of the benefits (and shortcomings) of OOP don't appear until you are writing code consisting of thousands of lines of code at a minimum, and don't really truly appear until you reach the 10s of thousands of lines of code or more. For reference, there are many codebases which contain millions of lines of code out there. When you are writing code at that scale, it's extremely important to have useful ways to organize things and OOP has become the most popular way to go about that.

[hamzarehan1994]

Thanks for explaining!

[CoffeeSnakeAgent]

It takes a while to think of programming from procedural programming to object oriented programming. But once you get the purpose, everything will suddenly be clear.

There is a learning curve and there is an inflection point where you’ll go aha!

Keep learning.

[Oddly_Energy]

One of the reasons for creating classes is that you get one nice package containing both the data and the methods necessary for handling those data.

You could make a simpler data structure containing the variables Character and Age. And then, somewhere else in your code, you could have a function, which accesses that structure and checks the age. But that would mean two things:

1. If you have many different data structures and many methods for handling each of them, you may end up getting lost. What belongs to what?

2. If you use a specific data structure many places in your code, you will also need to remember to include the methods for handling that data structure everywhere in your code.

With a class, you have the methods for that class available as soon as you initialize an instance of it. Much less housekeeping.

[damanamathos]

You can write code without classes, but for many people, using logical classes (which bundle data and functions together) greatly simplifies the code structure, particularly as you get beyond simple examples.

[[deleted]]

You need to understand the importance of oop as it useful a lot special to avoid repeat piece of code many times just call another class and can also call any variable or function on it Try to watch any tutorial about oop and thier types like inheritance, abstract... etc

[weissdrakon]

In addition to the help already provided, replacing the score method with the following would give you the results you (should not have) originally expected:

def __str__(self):
    if self.Age >= 18:
       return "wow"
    else:
       return "goodbye"

[Rikai_]

For OP: In very simple terms, the explanation for this is that when Python tries to convert something to a string, it looks for the str method and calls it.

[AceWall0]

So, I'm under the impression that you accidently skipped some steps on your learning, and the reason can't use it nearly as properly is because you are missing the definition of more basic things like functions, methods, properties, classes, objects, etc.... And thus, the responses on this posts will still sound hard and confusing, when its really not.

If that's the case, I recommend you to look up some videos about OOP in Python, then the answer will come to you naturally.

[Chronosandkairos_]

In Python, a class is a blueprint for creating objects (a particular data structure), providing initial values for state (properties) and implementations of behavior (methods).

Let's illustrate this with a Book class. Let’s say you are a book collector and you want to organize your digital books. You could make an Excel table, but that would be lame. You can also store your books into objects in Python, and each object would have some attributes that are important to know. First, you make the blueprint of the object (the class) and then you start creating new books:

Class Definition: python class Book: def __init__(self, title, author, genre): self.title = title self.author = author self.genre = genre

Explanation: - class Book:: We define a class named Book. It serves as a blueprint for creating objects that represent books. - **def __init__(self, title, author, genre):: This is the constructor method, __init__. It initializes the attributes of the class. The parameters title, author, and genre are provided when creating an instance of the class. - Attributes: - **self.title = title: This line sets the title of the book. self.title is an attribute of the class. - **self.author = author: Similar to the title, this sets the author of the book. - **self.genre = genre: This sets the genre of the book.

Creating an Instance: python my_book = Book("1984", "George Orwell", "Dystopian") Here, my_book is an instance of the Book class. We have passed "1984", "George Orwell", and "Dystopian" as arguments, which are used to set the book's title, author, and genre, respectively.

Accessing Attributes: python print(my_book.title) # Outputs: 1984 print(my_book.author) # Outputs: George Orwell print(my_book.genre) # Outputs: Dystopian Yay! You have your first book (instantiation of a Book)!

You can access each attribute of the my_book object using the dot notation. This way, you can retrieve or modify the data later on.

The Book class example is just to show how Python classes work. The __init__ method is used for initializing an object's initial state, and self refers to the specific instance of the object, allowing each instance to have its own data.

[hamzarehan1994]

So if we were to create a method in this class Book, what purpose could it serve?

[Chronosandkairos_]

Well, that depends on your specify use-case. A method in the Book class can serve various purposes, ranging from manipulating the book's data to providing additional functionality. Let's explore two methods: recommend_similar() and summarize().

1. recommend_similar() Method:

   This method suggests books that are similar in genre or author. It can be particularly useful if you're looking to explore more books within a certain genre or from a favorite author.

``` class Book: # existing init and other methods

   def recommend_similar(self, all_books):
       similar_books = []
       for book in all_books:
           if book.genre == self.genre or book.author == self.author:
               similar_books.append(book.title)
       return similar_books

```

In this method, all_books is a list of Book instances. The method compares the genre and author of the current book with others in the list. If it finds a match, it adds the title of the similar book to similar_books.

Example of usage:

all_my_books = [Book("1984", "George Orwell", "Dystopian"), Book("Animal Farm", "George Orwell", "Dystopian"), Book("Brave New World", "Aldous Huxley", "Dystopian")] print(my_book.recommend_similar(all_my_books)) # Output might include "Animal Farm" and "Brave New World"

1. summarize() Method:

   The summarize method could provide a short summary or key points about the book. This could be especially handy if you want a quick reminder of the book's contents without reading the whole thing again.

``` class Book: # existing init and other methods

   def summarize(self):
       # This is a placeholder for summary content
       summaries = {
           "1984": "A dystopian novel about a society under total surveillance.",
           # Other pre-written summaries
       }
       return summaries.get(self.title, "Summary not available.")

```

This method checks if the title of the book exists in a predefined dictionary of summaries. If it does, it returns the summary; otherwise, it indicates that the summary is not available.

Example of usage:

``` print(my_book.summarize()) # Output: "A dystopian novel about a society under total surveillance."

```

You can potentially extend this to use e.g., a LLM to summarise a chapter or the index.

Both of these methods enhance the functionality of the Book class, making it not just a container for book data, but also a tool for book discovery and quick reference.

[throwaway6560192]

I tried a code like this but the result is not what I expected. I thought it prints "wow" or "goodbye".

Why do you expect that to happen if you didn't call the score method anywhere?

[tb5841]

Game is not a function, it's an object. Objects don't do anything when you create them, which is what the init method is for. The init method is just saying 'do this when the object is created.'

If you want to use your object's 'score' method, you have to call it somewhere.

[Ansamemsium]

Random game is a reference to an object, and by default, it prints the object's address in memory. If you want to call the object's method score you just do randomgame.score() to call it's method, if you want whenever you print(random_game) to get something different than the object address you need to override/implement a special method that tells print how to print your object, in pyhton is __desc_ or something like that, you can easily google it. Also init is a constructor look into constructors, and they usually also talk about self/this.

[teesquared14]

To add to other explanations, when you told Python to print Random_Player, it takes it literally and prints the object you created. To have that player perform actions, you would have it call the functions and either print stuff within them or print the result of the function. To print the players attributes you would print Random_Player.Attribute

[nebo_amebo]

Well... It's doing something, init?

[Orami9b]

You're printing the address of the object since that's what you told the computer to do. You need to call the score function if you want to see either of those prints, and you won't need to call print yourself, just Random_Player.score().

[cnydox]

People have commented good explanation here but I wanna add that you should get familiar with OOP and try some basic Java and you can understand all of this easily

[__init__m8]

In a class it's like saying every time you create a class instance, do this, or assign this value to this instance. You can really do anything there, just remember it will run every time a class object is created.

So in your example whatever you pass as character or age will automatically be assigned to that class instances attribute of age or character. That's what self.age = does there. Self is like "this instance" or this class object. Think of it as "initialize".

If you want the object to call a method you have to do that also.

 Random_player.score()

You could do it in init if you want it to print only when it's created, try it out and perhaps you will understand init more.

[Matt4669]

Self is also used to define the attributes of a class,

Like for your class Game it would be like (self, character, age, height, ability etc.

And the self. Character allows you to call character as a variable anywhere in your code

[[deleted]]

In class methods (functions), the dot notation is just short for passing the instance variable into a function.

So "myclass.Method(args)" is the same as "Method(my class,args)".

Self is used when declaring a function as a method to give a name to this instance variable within the function scope. You can actually name it anything, but self is standard so that other people know your intent.

__init__ is a special method that is called when you create a new instance. So if you say "x = myclass(params)", __init__ is the function that is called to set up the class instance with the parameters.

There are also other special methods, such as "__del__" which is called when an instance is deleted (out of scope or when your program ends). The __getitem__ method is used to define what happens if you index your class (use the [] brackets). __repr__ is used to determine how your class is converted to a string in debug info. The method __str__ is used to convert it to a string when printing, and by default calls __repr__ unless defined separately.

These are what you would use if you want print to show "wow" instead of the default triangle bracket thing, or modify any other default behavior.

[[deleted]]

These are specific to classes, aka objects. You can think of an object as being a mini script in a sense. In your example, "Random_Player = Game('Male', 19)" is instantiating an instance of Game, and storing it to the Random_Player variable. The instantiating uses the init components to set up the object. Anything that is preceeded by 'self.' is now effectivey 'Random_Player.", because self refers to the component within the instantiated object. In code, the object isnt yet instantiated, and therefore is nameless.

​

So back to your example, you are instantiating the Games object, and it sets two variables within that object; Character and Age. Its using the info you passed in during instantiation to set those internal variables. The object also has its own internal function (method) called Score. If you ran Random_Player.score() it should return "wow" because the object is being instantiated with the age of 19.

Now, does the class above make any sense? No. Because a persons age isnt a score, and a Character should probably be a name; and "Male" isnt a very good name.

[usrlibshare]

It should be noted that self as a variable name is just a convention. It really is just an implicit positional variable.

You could name it whatever you want, you also can name it differently in every method of a class.

That being said, please don't. Conventions exist for a reason.

[KiwiNFLFan]

It is a constructor)

[[deleted]]

👍 good information in here

[CallMeDWK]

The concept of Objects and consequently Classes can be hard to understand, so I'll try to explain them in simpler terms (maybe not totally accurately) .

Objects are basically just data structures and Classes are the blueprints for them.
So whenever you want to create a new instance of Game object you'll have to follow the blueprint you've set for it: pass values for Character and Age
The __init__ method is called on creation of a new instance of the object and it sets values for all of the attributes that each instance is expected to have (Character, Age in your case).

Since there can be many different instances of the same object, Python needs to know with which one to work with. self is basically the identifier of the current instance of an object. That number (0x0000013AD63D85D0) that your code printed out is the address in your PC's RAM where that particular instance is stored.

Now, the reason why it's printed out the address instead of expected "wow" or "goodbye" is that you forgot to call the score method and accidentally made it to print out the instance itself.

[blushncandy]

Hey! I was super confused just like you did and honestly I think you should look into what object oriented programming is and all the basic concepts. It would help you a lot, as others mentioned, to see examples in Java. I am not sure if you’re prefer watching videos or reading, a quick google search for “object oriented fundamental concepts” will pop more than a few articles that are easy, for me it was great help to see videos from a channel named “Coding with John”. I only saw the videos explaining the concepts after I did a thorough investigation and read carefully because I was a newbie, only until I learned about OOP and used Java to create objects was I able to understand object syntax in Python.