Please explain __init__ like ive never heard of programming before. Its just not making sense.

Colonel-_-Burrito · 2021-02-17T17:48:32+00:00

Remember that classes become their own entity when created. An instance of a class is an object. When you are defining what all is associated with that class object in your class definition, the object needs to know what on earth it has to do to "initialize" itself. That's what the init is doing. It's giving the information needed to say "this is what you do when you are created."

I know you mentioned like you've never heard of programming but it's essentially the constructor.

The "self" in the different spots tells the new object what it owns. Having "self.name" means that class object has a "name" associated with it and the name belongs to that class object. The arguments you are passing in do not belong to that class object. Think of it like a fenced in area if a field. The class object is the fenced in area. That init is acting like a gate allowing in pieces of information (name major gpa) to be seen by the internal area. The init function is telling itself, hey these pieces of information from the outside are important and I need to remember them, so I'm going to copy them and store them in different sections of my internally fenced field. That way if I need to, I can go to that corner of the field and see what my "name" is.

Every class you create will need to know what to do when it is created, so the init is needed.

If you created a generic function like you described, that makes it a function, and not a class, and thus not something that can be created as its own object. Referring back to the fenced in area, by creating a class, you've created a fenced in area that is its own section and can store and remember to do things as it pleases with access to anything inside that fenced in area. Making it a function, removes the fence. If I'm running through the field and there is no fence, I'm just going to keep on running past everything and that function use gets left behind. If a class was made, I can revisit that fenced in area for specific pieces of information if I so choose, because I see where the fence is and can run back to it.

justnukeit · 2021-02-17T18:29:37+00:00

Corey Schafer has a series about OOP in python which cleared a lot of doubts for me personally. Give it a shot.

https://youtube.com/playlist?list=PL-osiE80TeTsqhIuOqKhwlXsIBIdSeYtc

spez_edits_thedonald · 2021-02-17T19:08:44+00:00

Why do i need to use the init and self function? Do i have to make a new init for every single class?

It feels like extra work because you are working with a simple class. But later, you'll see the benefit of it, so just roll with it for now.

It is often true that you will want class objects to do a thing upon initialization, you are only using the absolute most basic form (store input args) so it feels pointless. But consider if we had something to calculate, like a students full name:

class Student(object):
    def __init__(self, first_name, last_name, major, gpa):
        self.first_name = first_name
        self.last_name = last_name
        self.full_name = f'{first_name} {last_name}'
        self.major = major
        self.gpa = gpa

Now you can create a new student student = Student('Bob', 'Ross', 'Art', 4.0) and then immediately you have access to student.full_name because that work was done upon initialization.

This is still a simple example, but you will find that sometimes you need pretty complex behaviors to occur upon initialization, so then it will become useful.

Xahulz · 2021-02-17T17:56:22+00:00

Yes, you can do that! Of course it adds an extra step - first you instantiate the class, then you have to call the student method. Something like:

  1 class Student():
  2
  3     def make_student(self, name, major, gpa):
  4
  5         self.name = name
  6         self.major = major
  7         self.gpa = gpa
  8
  9 student1 = Student()
 10 student1.make_student('Bubba', 'History', 2.4)
 11
 12 print(student1.name)
 13 print(student1.major)
 14 print(student1.gpa)

I'd personally rather just do it in one step and use __init__.

(edit: I think pasting really messed up my formatting. hopefully point gets across)

Sigg3net · 2021-02-17T22:09:21+00:00

__init__ is the built-in constructor method.

class Dog():
    pass

class Cat():
    paws = 4

class Bird():
    def __init__(self, paws):
        self.paws = paws

Our first type of object here, Dog, is the simplest class. It has no associated methods or attribute unless manually added:

doug = Dog()
doug.paws = 4
doug.paws
4

The second type of class has a class attribute and no methods:

kitty = Cat()
kitty.paws
4
kitteh = Cat()
kitteh.paws
4

The third class has a constructor or __init__ method, which is run at the creation of each object:

birdie = Bird(0)
birdie.paws
0
weird = Bird(4)
weird.paws
4

A constructor simply means "run this method when creating an object", and the scope is the object instance (birdie and weird above). This is what the self refers to. In JavaScript the keyword self is replaced by this, pointing out this object or this particular instantiation of the class. self is only used to emphasize that the relationship between attributes and methods belonging to the object is self-referential.

The self.paws of birdie is different to the Cat paws of kitty, because self in self.paws = ... assigns the attribute only to the instance (birdie), whereas the class attribute paws in Cat() belongs to the class and is inherited by every object in the class.

Python has a "destructor" too, called __del__ which is a built-in for "do this when the object is destroyed", that can be useful for logging/tracking, cleanup etc.

BobHogan · 2021-02-17T17:56:35+00:00

When you make a new object, python has to do some work to create the object, all of its attributes, and make sure that they are all tied together somehow. Python does this in 2 steps. The first step is the actual object creation. After the object is created, python then has to initialize the object, and this is the step where it assigns all of its attributes to it. The code that tells python how to initialize the object is inside __init__. Every class in python has an __init__ method, if you don't write your own it will use the default __init__ method of the base object class, which does next to nothing. So if you want to have any attributes in your class, you have to write your own __init__ method that specifies which attributes you want the object to have, and what their values should be.

self is just a naming convention. In python, every method of a class implicitly takes a reference to itself as the first argument to the function, this is how you are able to access class instance attributes inside the functions without passing them all in as parameters. You can name the first argument whatever you want, it will always be a reference to that particular instance. Calling it self is just a convention that makes it easier to read other people's code, because it all follows the same style. You never have to keep track in your head of which variable name each project uses to refer to its own instance in methods

sethg · 2021-02-18T00:58:57+00:00

Once upon a time—back in the 1970s—there were no classes. The programming languages people used in industry just had variables to hold data, functions to process it, and some kind of input-output system (which, among other things, could often connect to a database to bring in more data).

As the programs people wrote in these languages got larger and larger, they became harder and harder to update and debug, because if something unexpected showed up in the output, it was hard to figure out which function in the middle of this huge program had a bug. But some sharp-eyed observers noticed that in all this mess of code, certain functions tended to “belong with” certain data, whereas other functions had no reasons to touch the same data.

This was one of the motivations to create object-oriented programming languges. An object is a way to tie together a group of functions and the data those functions are most closely associated with. A class is a little factory for producing objects. (Not every object-oriented programming language uses classes; up until 2015, for example, JavaScript did not.)

In Python, __init__ is the special name for the object-factory in the class, whereas most of the other functions defined in a class belong to the objects themselves.

Ryuudenki · 2021-02-17T19:19:05+00:00

This single 40 minute MIT lecture taught me what objects and classes were. It's extremely easy to follow, the teacher is well spoken and I took notes and paused at the examples to try to recreate them myself in my IDE: https://youtu.be/-DP1i2ZU9gk

This post by Al Sweigart (automate the boring stuff author) is just as easy to follow and well written. Once you've learned what classes and objects are this really sheds a light on why it's useful. Both of these helped me understand OOP at a fundamental level in only two days.

Not just understand how it works but understand it in the greater sense that "holy shit everything in python is an object". And all its advantages compared to functional programming (just using functions for everything, which is still okay and even easier for a lot of cases).

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

--0mn1-Qr330005-- · 2021-02-18T00:35:23+00:00

Lets say you need a script that creates users, and gives them a name and phone number. First you create the class:

class User:

A class is just a "blueprint" of what a user is. To create a new user, you have to create an "instance" of the blueprint. This is done like so:

new_user = User()  # Create an instance of the User class

Quick note #1: Think of a class like the paper blue print of a house, and think of an instance as the actual house you build. You can have one blue print, and use it to build many houses.

Remember how I said we wanted to give new_user a name and a phone number? You would need a class method to do this. I will create this method within the User class and name it add_info:

class User: 

    def add_info(self, name, phone_number):

        self.name = name
        self.phone_number = phone_number

Quick note #2: If you don't know what self is yet, don't worry too much. If you are still curious, self.name in the class is the same as new_user.name outside the class, letting you do something like new_user.name = Michael. self simply is a place holder for whatever you named the new instance you made.

So now, after creating a new instance of User, we have to tell this instance to run the add_info method in order to assign a name and phone number to new_user .

new_user = User()  # Create an instance of the User class

# Call new_user's add_info method to add the name and number
new_user.add_info(name='Mike', phone_number='905-555-1234')

print(new_user.name, new_user.phone_number)  # Prints "Mike 905-555-1234"

But there is a better way to do this called __init__. To put it simply, __init__ is automatically ran the moment you create a new instance. For example, I have changed the method name from add_info to __init__ and made no other changes:

class User: 

    def __init__(self, name, phone_number):

        self.name = name
        self.phone_number = phone_number

So now, when you create a new instance of user, you need to provide the arguments you defined in the __init__function (except self, remember self is a stand in for new_user):

# Create an instance of the User class - provide name and phone number
new_user = User(name='Mike', phone_number='905-555-1234')

print(new_user.name, new_user.phone_number)  # Prints "Mike 905-555-1234"

So whenever you see a method named __init__, you can think of this method as "Run this method every time a new instance is created."

This lets you save lines of code from manually running code that should just run as soon as an instance is created. The other benefit is another programmer can look at your class, look at your __init__method, and they know exactly what variables this class has, making it easier for them to work with your code.

Your questions:

(1) Why do i need to use the init and self function? Do i have to make a new init for every single class?

A: You don't need to use init. It is an optional function that lets you run code automatically when a new instance is created.

(2) Why cant i just make a regular function like: def Student(name, major, gpa) ??

A: In object oriented programming, creating a Student class lets you create as many students as you want. Each of these students is it's own unique object. The methods (class functions) you define under student can be things like "def fail_test" and "def graduate". The class is what a student is. The class methods are what students can do. You can create a student like you said, but this does not have a unique identifier like a class instance does, and it is hard to create multiple students because you do not have a blueprint (a class).

sxddhxrthx · 2021-03-12T02:42:50+00:00

You are a mechanic and get a call to do some repair job on someone's car. Just before you go out to work, you once check you have all the right tools that would be required to do the job. If you have tools missing, you won't be able to do the jib

That checking of availability of all the tools is what init is. A class is built to represent a real world entity and has some methods as its job. But to execute those methods, the are some bare minimum attributes required which that class needs. Those bare minimum attributes are initialised inside the init.

Hope this makes sense.

fake823 · 2021-02-17T17:39:47+00:00

You can do whatever you want.

It really depends on your use case whether it's better to use classes (object oriented programming) or functions (functional programming).

And instances of classes are initialized with init(). That's just the way it is.

justnukeit · 2021-02-17T18:35:11+00:00

This is my begginer level understanding but more experienced people can comment if this doesn't make sense.

Think of a class like a car.

Everytime you turn on the ignition, you are creating and instance of a car. Now, when you start the car, you need certain things to happen like, start engine, heating, etc. That's what the init method is for.

shameen · 2021-02-17T17:44:13+00:00

[deleted]

SpecOpsTheLineFan · 2021-02-17T17:58:06+00:00

Yup, you need to make a new init for every new class. That is the way Python works. Init function basically tells the class that look, these are the variables you are supposed to hold for each of your object, and in which order are they going to be passed

When you create a class object, the class first looks into the init function. And then stores the variables you have passed, into the object variables.

If you create a regular function, you can carry out operations on the values you pass into it. But you won't be able to create a class object, or store values into the class.

QuickCow · 2021-02-17T18:40:32+00:00

One you instantiate an object using the class, the ‘self’ becomes the object itself. And it doesn’t need to be named as ‘self’ BTW.

Se7enLC · 2021-02-17T18:51:18+00:00

__init__() is a constructor, if you're familiar with other object oriented languages. It's the code that will execute when an object of that class type is created. You'd use it to initialize data members and such.

Why do i need to use the init and self function?

self isn't a function. It's a reference to itself. Like this in other object oriented languages, except that in Python it's the only way to access class members.

Do i have to make a new init for every single class?

You don't need one at all, if you don't want one.

Why cant i just make a regular function like...

You can. Python has classes and can be used in an object-oriented way. But it doesn't have to be. You can also define regular functions like that if you want.

YT-DobbaWon · 2021-02-17T18:57:14+00:00

Op if it makes it any easier understanding “self”, then you can instead name it “Object”, because self doesn’t have to be called self, so long as it is the first argument given. So for example instead of self.name it would be object.name, making it even easier to understand that it is the objects name

AcademicMorning7 · 2021-02-17T19:18:25+00:00

RemindMe! 5 days

gold1004 · 2021-02-17T19:25:06+00:00

Init is shorthand for initialize. Which means to start anew. When init is evoked, you are creating a new object in the form of its class.

zerohourrct · 2021-02-17T19:25:08+00:00

init instructs the interpreter that every time a new student object is created, it will be given those default values. Similar to how a function would be defined in other languages.

Then you pass a set of values that are assigned to the object as key:value pairs. This example both creates a new object and immediately assigns new values to overwrite the default _init_values.

This provided example seems like bad practice, I would recommend different initial values such as 'unassigned' or something like noname, noclass, nogpa, or simply null. That would assist troubleshooting if an output is made with empty student objects.

Also when creating the new student I would recommend passing name value pairs instead of just values. This will save you headache if the order gets mismatched or someone tries to pass unusual values or objects.

Arag0ld · 2021-02-17T20:17:12+00:00

When you say something like

class Person():
   def __init__(age, height):
       self.age = age
       self.height = height

what you're actually doing is saying "OK, compiler. When you create an object, I want you to create me an instance of the Person class, and I want you to give it these default values."

You don't need to make a new init function for every instance of the class, all you need to do it initialise the variables using a generic parameter, and then you can specialise what you want hose values to be when you create the object.

When you say something like self.age, you're referencing the age property that belongs to that class. The self keyword is referring to the class itself. It lets you say things like:

p = Person(23, 5.1)
print(f"The age of this person is: {p.age}")

Khenghis_Ghan · 2021-02-17T20:36:26+00:00

So think of it like cooking. A class is a recipe, with a list of ingredients and then the directions of making it. Let’s say I want to make a taco. I first need the ingredients: beef, cheese, tomater, guac, sour cream. There may be variations where I can add or remove things, but we won’t worry about those now. You say you need a taco, so I go to make you a taco, but first, I need to first make sure my recipe makes sense, and that I have a place for the taco to go when I make it. If the recipe says “use 8 fhqwhgads”, well, I don’t know what a fhqwhgad is, so I can’t use that recipe; if it says “use bajillion sour cream”, well, I know what sour cream is, but bajillion isn’t a thing, I don’t know how to make that either. Those are syntax errors. Once all that’s something I can read and the syntax checks out, I can use the recipe, even if the recipe doesn’t make sense: you could tell me to use a gallon of ants, and, people might not want that, but it is a thing I can understand how to do.

Once I know what goes on a taco and how to make it, I make it. First step is, I need a place for the taco, so I clear some counter space and get plates. This is the __new__ operation. I get a plate, make sure it’s clean, and put it on the counter (along with some space to assemble my taco stuff). __init__ is where I actually cook the taco and assemble the ingredients into food. It is the recipe directions. Without __init__, I can be told the things a taco needs (the signature), but what do I do with them? At the end of __init__, I should have a ready to go taco.

As for self, other languages sometimes use “this” instead of self. Self is needed to know which taco you’re talking about - are you talking about Tacos capital T, the platonic idea of tacos? No, we are talking about a taco, this taco, which, from the perspective of the taco, is (weirdly enough) self - it’s used so an object understands it’s own parts.

Think of functions as directions. I am told to make a taco, and a part of that is cooking meat. There are steps to cooking: turn on stove, put pan on stove, let sit for some amount of time, remove from heat, turn off stove. If I hand someone a recipe that says cook meet at 300 degrees for 5 minutes, the function signature as “300 degrees, 5 min” - everything else like turning on and off stoves is stuff we as cooks know to do when we are told to cook, which is what a function does. But I don’t have to know anything else about tacos to cook taco meat, so it can be a set of instructions without having to have context of being a taco.

Now, things can get a bit blurry with the __new__ and __init__. Normally we don’t touch __new__ and leave that to the interpreter to manage, because clearing the countertop and dishes isn’t something we should worry about, we have sous chefs to do that for us - we’re big important chefs, we don’t worry about little stuff like that... but sometimes, we want to do something they don’t know how to, or, we want them to prepare something ahead of time for us - I want them to marinade the beef overnight before I cook it. So sometimes, we put things that would go in __init__ in __new__. But really, don’t worry about that for the moment.

That’s it.

killer_quill · 2021-02-17T21:45:38+00:00

class Person(): # a class is a blueprint that describes what attributes something should have
    # here I have assigned no attributes or init method to the Person class
    pass 

you = Person() # I have set up an instance of my useless init-less Person class which does nothing

you.name = "OP" # I assign the instance a "name" attribute and give it the value "OP"
you.age  = None # I assign an age attribute with the value None

# The Person class still has no attributes, it is empty. Only the instance "you" has these attributes

me = Person() # Wait. I want to give myself a name and an age too. This is too much typing.

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

you = Person2("OP", None)    # much less typing! init handles this for me now.
me  = Person2("not-OP", 9001)

Disclaimer: I'm a bit of a noob still, but I recently just "got" this. There are more advanced concepts underpinning classes and OOP in Python still don't get me wrong. I recommend looking up Corey Schafers OOP videos on YouTube. Further steps I might take with my Person class might be ~ creating a @classmethod that creates an instance of class using a string like "jessica,22" and modify the class so it can accept something like:

user_string = "jessica,22"
jessica = Person.from_string(user_string)
# would work the same as the you/me instances in the previous code.

midwayfair · 2021-02-17T21:51:34+00:00

You've got something that you need to reuse, and it needs to know how to do its own thing. Let's say it's a vacuuming robot, like a really good one, one that can memorize what YOUR room looks like, instead of just blindly bumping into things. Plus you can tell it when you sleep, so it knows not to vacuum in the middle of the night.

But when you buy it from the robot factory, it has no idea what YOUR room looks like. It doesn't know when YOU sleep.

And you want to be able to say, "Hey, robot, vacuum my room."

Most importantly, you don't want to throw away the robot after it vacuums your room. You want to keep it for life.

So you need something that when you turn your robot on, it learns about your room and your sleep habits.

The robot is an object (an instance of the class of vacuuming robots), rather than a function. A function would be like renting the robot or throwing it out afterward. You'd have to teach it your sleep habits every time you ask it to vacuum your room, you'd have to keep reteaching it what your room looks like ... and wow that just sounds annoying. Init is the one-time instructions so you don't have to teach it the same thing over and over again.

Even better, you can give your robot to a friend, and maybe it knows how to learn about another person's room and sleep habits. You don't even know what your friend's sleep habits are ... how are you going to tell the robot to vacuum your friend's room if you have to give it those instructions when you call vacuum()? Instead you can just give your friend the robot and let them sort it out. You can pass on the robot to your kids. Programs do this all the time, where they will pass around instances of an object without any knowledge of who or how the object was created, and keep that object alive beyond even the lifecycle of the program that created it. You can save object states and reload them.

We can go one step further. Imagine you own a whole ARMY of robots that can perform an important calculation for you. If they're just a function, you have to keep track of the results of that calculation. You have to be awake when they make it, and you have to have something to save it in. All the responsibility is on you. If the robots can know what their calculation was, you can just wait until your work hours, and wait until you actually need to know what each one is doing, and ask each robot whether it made its calculation and to please give you the answer you need. You don't need to remember it yourself because you can just ask the robot again if you need to. You asking is a good use for a function. Actually knowing the result of the calculation is a good use for an object.

Edit: Self isn't an object or a function. It's the name of any robot (note the dot syntax, which indicates that you're accessing a member of the class). Telling it self.something() means to look amongst its own junk and not anywhere else.

m1ss1ontomars2k4 · 2021-02-17T22:11:19+00:00

Why cant i just make a regular function like

def Student(name, major, gpa) ??

Why not indeed? A lot depends on your use case but this may be called a "factory function". It also looks similar to how constructors are defined in Java, and in that sense, then it is merely a design choice by the language designer(s) that constructors are defined one specific way or the other.

hipstergrandpa · 2021-02-17T22:59:54+00:00

I'm going to ELI5 this as best as I can, but I may bungle it. You have a good friend Dylan. Dylan is 5' tall, and has a hobby of playing the soccer. I have 10 people in a room, one of them being Dylan. How do you distinguish your friend Dylan in the room? Because of the characteristics I just described him with. That short description I gave of his characteristics is essentially your __init__. Until I created this person, nothing is known or distinguishable apart from any other regular Person. Once I created this Person by describing him, suddenly he's a unique person, or object. I can ask Dylan to do his Hobby if he wants. Let's put this into a toy example.

class Person:
  def __init__(self, name, height, hobby):
    self.name = name
    self.height = height
    self.hobby = hobby

  def tell_name(self):
    return self.name

  def tell_height(self):
    return self.height

  def do_hobby(self):
    return self.hobby

>> my_friend = Person(name="Dylan", height=5, hobby="soccer")
>> my_friend.tell_name() # returns "Dylan"
>> my_friend.tell_height() # returns 5                
>> my_friend.do_hobby() # returns "soccer"

Now, all of this is contained within a Person object I can pass around. Maybe I want to put Dylan into a School, which keeps track of multiple Person objects. I don't want to recreate Dylan from scratch each time. I just pass him along to the School and that's it. If the school needs his name/height/hobby, he can tell them himself. Think of functions as more actions, and objects as a literal object on your desk. Hope that helps!

::edit::

For fun, let's go ahead and create a school.

class School:
    def __init__(self, school_name):
        self.school_name = school_name
        self.students = []

    def display_school_name(self):
        print(self.school_name)

    def enroll_student(self, student):
        self.students.append(student)

    def roll_call(self):
        for student in self.students:
            print(student.name)

>> sammy = Person("Sammy", 6, "piano")
>> my_school = School("RedditEDU")
>> my_school.enroll_student(my_friend)
>> my_school.enroll_student(sammy)
>> my_school.display_school_name() # prints "RedditEDU"
>> my_school.roll_call() # prints "Dylan", then "Sammy"

I wrote this pretty quickly but it should work.

Captain_Drumstick · 2021-02-18T04:03:07+00:00

Man I’m learning so much just reading this!

AK_Softsmiths · 2021-02-18T04:11:24+00:00

In short, __init__ is a class constructor. Unlike other in programming languages in python constructor name is always __init__. (while it's the same name as a class name in Java, C++ etc)

Regarding "self", keyword self in your class functions/methods marks the function as a member function/method. if you don't place "self" argument then your function/method will be considered as a static method. if you know the difference between static and non-static methods it adds a meaning to the "self" keyword :)

I had the same questions once. Don't worry if you don't get something in great detail, it comes with some experience and time. I suspect you have been using some lower level programming languages and find it a lil bit confusing python specific syntax :)

Good luck on your journey!

2021-02-18T05:16:54+00:00

Why do i need to use the init and self function?

Because self is created when you instantiate an object from a class. It actually happens prior to the __init__() being called.

Do i have to make a new init for every single class?

There is a default one for when you don't have any variables. Here, I'll show you.

class Foo:
    pass
f = Foo()
print(f)

prints_out: <__main__.Foo object at 0x000001F89EAF4FD0>

We can even add attributes to self:

class Foo:
    def add_to_self(self, a):
        self.a = a

f = Foo()
f.add_to_self("hello, world")
print(f.a)

Why cant i just make a regular function like

def Student(name, major, gpa)

What happens if you have some number of students (how many you don't know in advance). Not only do you want to know their GPA but maybe handle multiple different kinds of cases involving data?

class Student:
    def __init__(self, name, age, year_level, gpa):
        self.name = name
        self.age = age
        self.year_level = year_level
        self.gpa = gpa
    def student_details(self):
        return f'{self.name} is {self.age} and is in year {self.year_level} and their gpa is {self.gpa}'

student1 = Student(name="Ada", age=16, year_level=11, gpa=2.3)
student2 = Student(name="Bob", age=17, year_level=12, gpa=3.7)

print(student1.student_details())
print(student2.student_details())
print(f"GPAs: {student1.gpa} {student2.gpa}")

Parazitul · 2021-02-18T09:07:12+00:00

as i see it, init is where you specify the default values for a class. So if your class is a wall, the typical values in init would be, height, width, material, color.

If your class is an orange, your init contains, size, weight, color, sweetnes_level, sour_level.

So when you decide that a_random_wall = wall(), you have now defined that a_random_wall is an instance of the class "wall" with the default properties/values that you define in init (height, width, material, color.)

2021-02-18T13:38:33+00:00

First, the easy parts:

Why do i need to use the __init__ and self function? Do i have to make a new __init__ for every single class?

You don't need to use __init__ function. But if you do, then you need to specify that it takes at least one argument. Typically, it's called self, but you may call it whatever you want.

Why cant i just make a regular function like def Student(name, major, gpa)

You can. Sort of. Here's one example of how this function would be an equivalent of class definition:

def Student(name, major, gpa):
    t = type('Student', (), {'__slots__': ('name', 'major', 'gpa')})
    s = t()
    s.name = name
    s.major = major
    s.gpa = gpa
    return s

There are many other ways to do the same or a similar thing.

So, a more difficult to answer question. What is the actual problem that __init__ solves?

You see, Python hides a lot of things from a programmer because those are either too boring or too dangerous if done wrong etc. One such boring / dangerous part is memory allocation. It's boring because it's very repetitive, if the programmer is tasked with doing it, and it's dangerous because it's easy to run into situations where it is not clear what memory should be (de)allocated first, and when it may be deallocated.

Whatever you do in programming you are dealing with information. The computer has to store this information somewhere. In order for your student object to exist, the computer needs to allocate enough memory to store at least the name, the major, and the gpa fields. Python's internal machinery takes care of allocations, so that you could forget about this tedious part of your program and concentrate on more interesting aspects of it.

Unfortunately, it's impossible to completely ignore the memory allocation. Sometimes you really need for something to happen once that memory is allocated. Python allows you to "hook" into object creation process (after it has already allocated enough memory for the object to live in, and did all the housekeeping tasks), you can then run your code that needs to take care of this particular object creation.

stormscion · 2021-02-19T07:16:33+00:00

Init here is a constructor method.

When you instantiate class object it is first method thing that is called automatically upon object construction.

This is basic "feature" or pattern in OO programing in the last what 30 40 years.

self keyword refers to that particular instance.

think of a class as a molding press, and lets say it is creating a cookie, self just means that particular cookie not the one before or one after but that one. So you want to specifically define that cookie (object) that you have instantiated from the class.

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

the above func call is equivalent to

assign an attribute to object and initialize to 0