Forem: P0intMaN

How I cracked MLH Fellowship in my first attempt: Journey & Tips

P0intMaN — Tue, 02 Nov 2021 11:22:49 +0000

I am pretty much sure you know what MLH Fellowship is. For those who don't know about this, let me brief you about this amazing program. MLH Fellowship, powered by GitHub, is a global program aimed at providing experience to talented individuals with an unlimited thirst for learning. You would be learning the in-demand technologies from the leading tech mentors. Also, you will be put in a healthy competitive environment consisting of other hand-picked fellows, with similar interests and zeal.

My Journey

I applied for MLH Fellowship in the early weeks of October from the official MLH website. Then, I got scheduled with my Initial Interview (kind of behavioral). After a week, I gave my Technical Interview and finally, after another week's wait, I received the result and guess what, I got selected.

This was the very first interview I have ever given and the result is quite motivating! If I can do this, so could you.

The Selection Process

The entire procedure is neatly divided into three phases:

Application
Interviews
Final Review

Let's understand each process in detail

The Application

In this phase, you would be filling out an application form. The form contains choice-based questions (like, Which programming language(s) are you comfortable working with? And then they provide some choices), essay questions (like, Why are you applying for MLH Fellowship?) and finally, detail-based questions (like, Your Name, GitHub profile link, Code Sample etc).

The form filling is a fairly easy process and it would take around 10--13 mins to fill out the form. Once you have submitted the form, you'd have to wait for a considerable period of time (probably, for around 10--15 days) before getting to know your result. During this period, your application is reviewed by multiple MLH recruiters. This is done to filter out the most apt and genuine application from a vast pool of applications. If your application is unique or interesting, then you'd be called in for the interview phase.

The Interviews

There would be two interviews: Initial and Technical.

The Initial interview's purpose is to find out whether you are an appropriate candidate who can successfully complete the MLH Fellowship. The questions asked in this round are:

Why do you think you are a good fit for MLH Fellowship?
How do you keep yourself updated with the new trends in technology?
You have mentioned this in your application form. Could you please tell me about a situation where you demonstrated this?

The duration of this interview was roughly around 15-25 minutes.

The Technical interview is primarily based on the code sample that you have submitted in the application form. You would be given most of the control where you'd have to do a brief code walkthrough. The interviewer will then stop you in between and ask questions related to certain concepts. In my interview, since I demonstrated a Flask application, I was asked the following major questions:

Why did you prefer Flask? You could have also opted for other frameworks (like DJango)
What is a decorator? Explain to me briefly
What is an ORM? How is it useful to a developer who wants to create rapid applications?
Several other concept based questions.

One thing to note here is that, you need to have an in-depth knowledge of what you are demonstrating. The entire duration of this interview was around 20-30 minutes.

The Final Review

After successfully completing both the interviews, your entire performance is analyzed and then top folks are selected. Those who get shortlisted gets an acceptance letter along with the time and date of commencement of the program.

The Strategy

If you want to see good results, you must plan it properly. With enough research and thorough understanding, you can clearly envision what's going to happen and what to do if its going to fail. After all, we are computer science students, we should look at the world from a different, systematic perspective right? Okay, so I am going to share with you the mindset I followed which got me through all the phases in the first attempt.

Feel The Heat

I firmly believe that humans are capable of performing things way better when they feel the heat. MLH is a highly competed internship. The seat that you are vying for has an acceptance rate of 2.5%. No, the data is not to scare you rather, its to challenge you to push harder. Now that you are feeling the heat and in the right mindset, lets proceed further.

First Things First

Before even applying to MLH, you must have a good understanding of the following technologies:

Any Programming Language(s) excluding C, C++, BASH. Yes, even I was pretty much taken aback by this. Preferred: Python, JAVA, JS, TypeScript.
Git/GitHub.

If you don’t have any good understanding of the aforementioned topics, I suggest you to spend some time learning it. I would give you some cool resources at the end.

Cracking the Application Process

The first milestone to be reached. Let's understand this from MLH's perspective. Why are they conducting this Initial Application process? One reason would be to remove spurious or "copy-pasted" applications. The key thing to consider here is, be authentic. Trust me on this. Many of my colleagues who went after the shortcut ways of filling application ended up receiving the same "Apply next time" letters.

Write essays that reflects you, in a professional way. Use good amount of vocabulary (something we never even really cared). Use big words, no really, I am not trying to be ostentatious 😃. This would, overall, make your application top-notch. The reviewers would feel as if you have done hard work. A sweet psychological trick ain't it?

In the choice based questions, choose things that are applicable to you. The more the merrier is not applicable here. In my application, I only opted for Python as the preferred Programming language (even though I knew around 3-4 others). Be simple, be genuine and be professional.

There would be one section, where you would have to describe a project that you are going to submit as a code sample. One interesting observation I made here was that web-based projects were preferred over other ones. My colleagues gave projects like Library Management System, Hotel Booking Management System etc. These projects are great from the beginner's standpoint but are not multi disciplinary. Projects like Full stack website, Simple Chat application, even Calendar shows that you have a varied understanding of several topics. Go for such projects if you haven't already and if you are already working on such projects, then great! You are on the right track.

Cracking the Interviews

Once you clear the first round, you are in for a tougher fight. Here, all the candidates who passed the application process are interviewed. This is a phase where many candidates loose focus and starts doubting.

Let's again understand why interviews are conducted from the MLH's standpoint. Well, one obvious reason would be to check whether you are a good fit or not. Whether you have it in you to complete the internship. Keeping these in mind, its time to oil our guns.

For initial interview, being in the right mindset is really important. Let's look at this way: The interviewer has to interview many candidates. So, it is quite certain that there would be many questions he/she would ask that are common for all. Be prepared for these questions. The questions are going to be from your application form and some general questions I mentioned way earlier in this post. The key thing to demonstrate is your calm and composed attitude. Believe me, its the easiest and the most interesting interview you'd have ever given so, enjoy the process.

Technical interview, however requires some grinding. In this process, you would be given most of the control to demonstrate and give a brief walkthrough of the code sample you have submitted. It's you who has the complete authority. As you start explaining your project, follow this paradigm:

Describe briefly about the project
Tech stacks used
Start explaining the project structure
Start explaining the concepts

The interviewer is not going to look for the number of lines or files in your project rather, he/she is interested in finding out how deep you know a certain concept. If the project is solely yours, then no need to fear at all. You would easily be able to give answer to the questions.

You are expected to be an individual with strong fundamentals. If you are a Python programmer, consider following this playlist. Pick a topic that you don't know and start learning.

I used a neat trick to trap my interviewer. While explaining my project, I gave emphasis on concepts like decorators, ORMs, Flask, Object Oriented Programming among many that I was dead comfortable with. By doing this, I took him to my territory and guess what, the interviewer asked the questions related to those same concepts. You can also do this, but only when your fundamentals are quite robust and have something to fall back on. The aim here, is to prove your interviewer that you are one of the top folks.

Anticipating the Final Result

If you have followed the above methods systematically, then no need to worry at all. Consider yourself selected*. In fact, I was pretty confident that the moment after my technical interview got over, I notified my colleagues that I am going to be selected.

"A perfect amalgamation of psychology, smart work and dedication can take you a long way."

If you get selected and followed my techniques, then be sure to tell me about your story! Would love to hear it. You can mail me at: pratheekastro3@gmail.com or follow me at GitHub or connect with me on LinkedIn

Resources

These are some of the cool resources I found helpful during preparation:

Python Programming Playlist : Pick a concept, start learning

Linux Fundamentals : Understand Linux structure and basics

Git Essentials : A comprehensive Git guide

YouTube Channel : A channel (relatively new) which aims at promoting contents related to computer science.

Alternative Constructors in Python

P0intMaN — Fri, 29 Oct 2021 15:27:43 +0000

Article Agenda

This post is dedicated towards understanding how we can create alternative constructors in Python. Also, we would be taking a look at a real developmental scenario where I felt comfortable using it. To cut this short, we would be covering:

Constructors
Alternative Constructors
A Real Application Example

Introduction

Python OOPs has rocked the world with its simple yet stunning flow of programming. Almost all the programs and software written in Python follow the OOPs paradigm. The OOP in Python is so modernized and enhanced that huge amount of developers are making a shift towards this amazing Programming language.

In case you are wondering what an OOP is, I already have a Python OOP post on this, which gives you a brief overview about it. You may want to give it a thorough read.

Constructors

Constructors by definition, is a subroutine designed to create an object in a particular class. In layman's terms, a method, which gets automatically called at the time of object creation and assists it.

Constructors are like ordinary methods defined inside the class. The only difference being, we need not call it explicitly. Programming languages automatically calls it while creating the object of the class.

In C++, constructors have the same name as the class name. For example (I know this is a Python tutorial, but I really felt the urge to show you the difference. So, here you go):

class MyClass          // Class name
{
public:
    int a, b;

    // Constructor. Notice how its name is same as class name
    MyClass()   
    {
        // I will be automatically executed during instantiation
    }
};

int main()
{
    MyClass obj;       // instantiation.

}

In Python, this is not the case. However, there is a huge misconception out there:

The `init()` vs `new()`. Which one is the real constructor?

As opposed to a popular yet wrong belief where __init__() method is considered to be constructor, its actually the __new__() method which is the constructor of the class. To put it more clearly:

__new__() : This method is called automatically to control the object creation.
__init__() : This method is also called automatically during object creation, but this is more of an initializer method which initializes the object attributes. That's why we used it in our OOPs concept (an earlier post), to initialize our object attributes.

Moreover, if both __new__() and __init__() methods exist in the same class, then __new__() is called first and then Python interpreter decides whether to call __init__() or not.

So, from the OOP standpoint, and from the above observations, it can be safely concluded that __new__() is the real constructor. But several Devs just want to stay out of this pandemonium. Therefore, instead of going after this "init vs new thing", they adopted another way to create constructors, enter the Alternative Constructors

Alternative Constructors

Alternative constructors are actually class methods which serves the purpose of object creation. We hack the class methods and command them to control the object creation. This is pretty similar to a constructor's (__new__()'s) working.

There is a convention for naming methods to be used as alternative constructors. All such methods should start with from_. For example, if I have a method say, getDetails() and if I were to make it an alternative constructor, then I would have to rename it as from_getDetails(). Although this is not necessary, but it is considered to be a good practice.

The following snippet shows the basic syntax of defining alternative constructors (AC):

class MyClass:

    @classmethod
    def from_alternativeConstructor(cls):      # Alternative Constructor
        return cls()                           # returns object

object = MyClass.from_alternativeConstructor() # calling AC

# an object is crafted successfully due to the execution of AC

A Real Application Example

While I was developing a backend, I had a long list of strings. I had to come up with a way to convert these strings to objects. Luckily, I had AC by my side and the task went on smoothly. In real world, you would get raw data like these. You would have to circumvent these obstacles and find a solution.

The following snippet shows a demonstration of how I converted a long list of strings (but here, for the sake of simplicity, lets take a single string) and then converted it into objects.

class Professor:

    def __init__(self,name,id,age):
        self.name = name
        self.id = id
        self.age = age

    @classmethod
    def from_getDetails(cls, string):      # Alternative Constructor
        name, id, age = string.split(',')  # split string and assign to variables
        return cls(name,id,age)            # returns object

details = "Jack Robins,2233394,45"

prof = Professor.from_getDetails(details)  
print(prof.name,prof.id,prof.age)          # prints --> "Jack Robins" 2233394 45

The string is now converted to an object and I can easily access it using its attributes. So, this was all about alternative constructors. One of the most interesting ways to bypass the basic working system of OOPs and also, exploiting the most out of it. After all, we are programmers, its in our DNA to exploit stuff and get things working for us.

Would You Like to Support Me?

If you want to support me and my contents, then go ahead and consider doing it. I would highly appreciate that:

YouTube Channel: Home to all sorts of peculiar tutos.
GitHub: Looking forward to your PR 😉

All You Need to Know About Closures in Python.

P0intMaN — Thu, 28 Oct 2021 06:35:59 +0000

Article Agenda

In this article, I will explain you the concept of Closures in Python. More specifically, we will explore the following:

Nested Functions
Closure Property

Introduction

Now, there's a caveat to this post and that is: You must have a knowledge of First Class Functions. If you don't know about this, then no need to worry. I got your back. Just view my article on First Class Function or if you are more of an observational learner, then you may go ahead and watch the video version of First Class Function as well.

Psst.. If you are in a hurry, you can watch the video version of this post instead

Alright, let's get started.

Nested Functions

Before we understand Closures, it is really important to know about nested functions. Essentially, when you define one function inside another function, the resultant is called Nested function. The following code snippet shows a nested function:

def calculation(number):
    def double(no):
        return no*2

    return double(number)

calculation(10)               # 20

In the above code, I have a function calculation() which takes in a number as argument. Inside it, I have declared another function double() which also takes in an argument no and then returns the double of no. Finally, I exited from the calculation() function by making a call to the double() function.

Now the above scenario was a classical example of a nested function. Let's understand each step briefly:

A call is made to calculation() with parameter value 10.
Interpreter jumps inside calculation() and finds a return statement with call to another function double() with the same parameter number = 10. Current state is paused.
Interpreter jumps inside double() with parameter no = 10 and then returns the double of no which is 20. Exits the double() function.
20 gets reflected and the paused state is resumed. This results in us finally getting the value 20.

Great! See, how easy it was? Okay, lets cover a scenario where you have multiple nested functions inside a parent function. In this case, all those functions will be executed whose call have been made in the parent function's return statement. The following example demonstrates it:

def calculation(number):
    def double(no):           # executed
        return no*2

    def triple(no):           # skipped
        return no*3

    def quadruple(no):        # executed
        return no*4

    return double(number), quadruple(number)

calculation(10)               # (20, 40) <-- this is a tuple

Very well. Now this was all about Nested Functions. Now, what if I tell you that there is a neater way of writing the nested functions? There exists a more professional and a cleaner way of writing nested functions and that way makes use of a property called Closure.

Closure Property

Closure property (simply closure) by definition, are function objects that can remember values in its enclosing scopes and these values can be used within that function. I know this might've gone way over your head, so let's understand it bit more clearly.

First of all, let's see what an enclosing scope means:

def parent():
    def child()
        pass
    pass

In the above code, parent is the enclosing scope for child. Which means that child will only be invoked if parent makes a call for it. Otherwise, child will stay dormant.

Now, let's see what does "values inside the enclosing scope" mean:

outside1 = "Outside parent func"

def parent(msg):

    inside1 = "I am inside parent"

    def child()
        pass

    inside2 = "I am inside parent"

    pass

outside2 = "Outside parent func"

parent("Hello there!")

In the above code, outside1 and outside2 are not inside parent() therefore, they are not inside the enclosing scope of child(). On the other hand, inside1 and inside2 are inside parent() function, this means that they are within the enclosing scope of child().

Similarly, can you find one more value (or variable) which is inside the enclosing scope of child()? Yes, the msg variable. Since we can use msg inside the parent() function, we can successfully call it to be in the enclosing scope of child().

Finally, let's understand what does "remembers the value in enclosing scope" mean. Let's take our previous example and move on from there:

def calculation(number):

    number2 = 30             

    def double(no):
        return no*2

    number3 = 50

    return double(number)

calculation(10)               # 20

I have added two extra variables as well, for better understanding. Okay, so here, as per our previous observations, we can quickly conclude that, number, number2, number3 are in the enclosing scope of double(). Now, let me remind you, closure property states that:

function objects can remember values in its enclosing scopes and these values can be used within that function.

This means that all these variables in the enclosing scope of double() can easily be accessed inside double and be used in any way you want without even passing them as the parameters to double() function. Didn't get this? Check out the valid snippet below:

def calculation(number):

    number2 = 30             

    def double():
        print(f"I can remember: {number},{number2},{number3}")

    number3 = 50

    return double()

calculation(10)               # I can remember: 10,30,50

Notice that how double() can access and modify number, number2, number3 without them being passed as arguments. Well, this is the due to it being able to "remember" the values in its enclosing scope. This was the great story of Closure.

Now, before ending this article, lets refactor our previous cluttered code that we wrote without closures. You would be seeing a significant difference in the style.

def calculation(number):
    def double():           # executed
        return number*2

    def triple():           # skipped
        return number*3

    def quadruple():        # executed
        return number*4

    return double(), quadruple()

calculation(10)               # (20, 40) <-- this is a tuple

Looks neat ain't it? No tossing around of parameters and not even explicitly passing them. The code looks way more cleaner and professional.

Would You Like to Support Me?

If you want to support me and my contents, then go ahead and consider doing it. I would highly appreciate that:

YouTube Channel: Home to all sorts of peculiar tutos.
GitHub: Looking forward to your PR 😉

What are First Class Functions in Python?

P0intMaN — Wed, 27 Oct 2021 17:31:15 +0000

Article Agenda

This article is focused at making you understand the property of functions to behave as first class objects. We will cover the following:

First Class Object
First Class Functions
What Next?

Introduction

You might have heard of the famous saying, "In Python, everything is an object". Very confusing as it may sound, this is absolutely true. In Python, every single entity is represented as an object ( Yes, object from the OOP. In case you don't know about OOP, I have got it briefly covered in this article ). This concept has given rise to many methodologies and principles in Python like Closures and Decorators.

Psst.. If you are in a hurry, you can watch the video version of this post instead

Alright, let's get started.

First Class Object

To keep it short and simple, A first-class object is an entity within a programming language that can:

Appear in an expression
Be assigned to a variable
Be used as an argument
Be returned by a function call

So, what do you think would be candidates to this? Well, Python datatypes fit these criteria, so datatypes like Integer, String, Boolean etc are first-class objects. So, let me ask: Are loops and conditionals first-class objects? Of course not since they both are failing multiple criteria. Finally, we can achieve all the aforementioned with functions as well! Therefore, functions are also first-class objects.

First Class Functions

In programming languages like Python, JavaScript, we have functions as First-Class Objects. Hence, the formal name of a function is First-Class Function (although we just call it function). First-Class Functions can be treated as any other object. This means that in Python, functions can be passed around, tossed in as arguments to other functions and even be assigned to variables.

Given below is a function which increments a number by 1:

def plusOne(number):
    return number+1

Now to prove that functions can be treated as other objects, let me go ahead and rename this function like so:

def plusOne(number):
    return number+1

#renaming the above function
re = plusOne

#calling both the functions
plusOne(10)            # 11
re(10)                 # 11

You'd notice that both of them gives you the same output. Do you remember encountering this behavior elsewhere? Well, if you run the following code, you might get an idea:

x = 11
y = x
print(x)          # 11
print(y)          # 11

Surprising ain't it? Therefore, functions behave like the first-class objects. This is something unique that other programming languages like C, C++ never had. Functions in Python can be treated as first class objects (String, Integer, etc).

Now, I am going to spice things up. This might seem a bit weird in the beginning but you will understand it and grasp the concept pretty quick.

If you remember that we can store the First Class Objects in some other data structure like Lists, Dictionaries right? Well, this means that a function too can be stored in these data structures and used accordingly. Let me explain this more briefly (using List as the data structure):

def plusOne(number):
    return number+1

def plusTwo(number):
    return number+2

def plusThree(number):
    return number+3

def plusFour(number):
    return number+4

# list storing function objects
func_list = [plusOne, plusTwo, plusThree, plusFour]

# executing each function
for func in func_list:
    print(func(10))

# It will print out ---> 11, 12, 13, 14

In the above snippet, I have created a func_list list which will store the function objects. Now, before I move further, it is imperative to understand that Python does not make a call to the function unless you succeed it with brackets (). So, if I only do this:

print(plusOne)

# prints out ---> <function plusOne at 0x000001B4FC7FEF70>

Python would only give me the function reference as shown above. Alright, let's go back. Now, the func_list holds the function objects (which are not yet executed). Then, I ran a for loop, accessed each function and then finally executed it with the help of parenthesis and a parameter, 10.

Great stuff! I believe now you got to know what the original behavior of functions are. To truly solidify your grasp on this concept, try to make use of it wherever you find its possible use case.

Let me try and come up with a use case of first class functions:

def plusOne(number):
    return number+1

def plusTwo(number):
    return number+2

def listModifier(li, func):
    result = []

    for element in li:
        result.append(func(element))

    return result

# executing listModifier
print(listModifier([1,2,3,4], plusOne))

# prints out ---> [2,3,4,5]

In the above snippet, I passed a function (plusOne) as the parameter to another function (listModifier). Then, I made a call to plusOne from within the listModifier function. This would trigger the plusOne function and will increment each value of list passed and then append it to a result list. Finally, after the above operation, simply returned result.

Now, let's suppose for some reason, the client comes to me and tells me that instead of incrementing each value of the element by 1, do it by 2, all I would have to do is simply replace the plusOne parameter of listModifier to plusTwo like so:

print(listModifier([1,2,3,4], plusTwo))   # pretty neat eh?

# prints out ---> [3,4,5,6]

What Next

Let me tell you that, you have reached a major milestone by learning this concept. First Class Function form the basis of several other design patterns and concepts such as Closures and Decorators. You'd have a better understanding of those topics by having a knowledge of first class functions beforehand.

Would You Like to Support Me?

If you want to support me and my contents, then go ahead and consider doing it. I would highly appreciate that:

YouTube Channel: Home to all sorts of peculiar tutos.
GitHub: Looking forward to your PR 😉

A Primer on Object Oriented Programming with Python.

P0intMaN — Wed, 27 Oct 2021 08:47:20 +0000

Article Agenda

This article is focused at getting you up and running pretty quick on the concept of OOPs in Python. More specifically, we will cover the following topics:

Classes
Instances
Methods

This article is going to be a quite a bit lengthy since I will be giving you a proper explanation to each concepts that I am going to discuss. But I hope you will have a lot to take away form this.

There is another interesting follow up topic to OOP in Python, which is called inheritance. This is a whole world in itself and for the sake of not converting this article into a full-fledged book, I decided to talk about it in another article. It deserves a dedicated article on its own.

Introduction

Python has been there in the computer science realm for a long time. Before Python, JAVA used to be the Big Thing (It is still very popular, but not that much when compared to Python).

One of the most desirable features of Python is Object Oriented Programming (OOP in short). OOP in Python is pretty neat and very organized. Developers really love the flow while writing Python OOP.

So, with that being said, lets quickly jump right in.

Object Oriented Programming

In object-oriented programming, I realized the power of using classes and objects as a paradigm for writing codes. In fact, OOPs, as it is called, is all about using classes and objects. One thing I noticed while using Python’s OOPs is that, its quite different from other programming languages like C, C++. Python’s OOPs is crisp and straight to the point.

By definition:

Object-oriented programming (OOP) is a method of structuring a program by bundling related properties and behaviors into individual objects

Conceptually, objects are like the components of a system. Think of a program as a factory assembly line of sorts. At each step of the assembly line a system component processes some material, ultimately transforming raw material into a finished product. An object contains data, like the raw or pre-processed materials at each step on an assembly line, and behavior, like the action each assembly line component performs.

Class in Python OOPs

To understand the concept of class, lets take an example. Suppose in LPU (a university), there are hundreds of professors. Each professors have their own credentials like name, age, id etc. What sort of data type will you use to store such a vast data and manage them in a meaningful way? One quick workaround would be to use a list to represent them. For example:

ishaan = ['Ishaan', 125, 23]
loviRaj = ['Lovi Raj', 225, 34]
pooja = ['Pooja Rana', 34, 25]
# nameofProfessor = [‘name’, age, id]

But this mode of representation has a big limitation. You’d need to create separate variables for all the professors. Also, lets suppose that a newly joined professor say, Pratheek has not been assigned an id yet. Now, if you are managing a really big data like this one, you might not even realize that Pratheek has no id yet. So, generally, if you try to retrieve Pratheek’s id, you might end up getting his age as shown below:

shaan = ['Ishaan', 125, 23]
loviRaj = ['Lovi Raj', 225, 34]
pooja = ['Pooja Rana', 34, 25]
pratheek = ['Pratheek', 19] # id has not been given yet

#retrieving ids
pooja[1] # will give you pooja's id
pratheek[1] # will give you pratheek's AGE (but needed his id)

This is some sort of inconsistency. Therefore, we need a better way to handle such real-world data. Here comes the class.

Creating class is easy. It is shown below:

class Myclass:
    pass

Now, to solve our above problem using classes, first of all, we would have to declare a class with a useful name, say Professor. Each class in python has its own attributes. These attributes are either the instance variables or the class variables.

class Professor:
    pass

It’s that simple. You have a class named Professor. Now, we will currently leave class as empty. I will fill this once I finish talking about the instances.

Instance (Or Object) in Python OOPs

Instances are ways through which one can assign or retrieve information from the class or perhaps even modify it. Every instance in class is unique having their own blueprints of the class. So, if I create three instances of Professor class, I would have blueprints of Professor’s class in each of these three instances and all the three instances are independent of each other.

The syntax for instantiation is:

instanceName = className(inheritSomething[if any])

Let’s see this in action. In the following code, I have instantiated the class with an instance called prof. Then, I have given the attributes (name, id, age) of the class by using the instance prof.

class Professor:
    pass
prof = Professor() # instantiated the class with prof instance

# using prof instance to give class attributes
prof.name = "ProfessorName" 
prof.id = 123
prof.age = 45

So, with this, we have successfully registered an object of Professor class. Now, lets take a look at the previous case where we don’t have Pratheek’s id. So, in that case you don’t even have to pass the id attribute. Therefore, when the developer tries to retrieve Pratheek’s id, he would be thrown an error instead of giving him the age of Pratheek which is absolutely good since it did not fetch us the wrong value. The below code demonstrates this scenario:

class Professor:
    pass

#instances
pooja = Professor()
pratheek = Professor()

#assigning attributes
pooja.name = "Pooja Rana"
pooja.id = 34
pooja.age = 25

pratheek.name = "Pratheek"
pratheek.age = 19

#retrieving the ids
pooja.id                      # no error
pratheek.id                   # error

In the previous no-class scenario, we could have got an ambiguous value (mismatch of age and id), which would have gotten us into some serious troubles. Also, by using class, the code got a meaningful structure. When you want to add a new attribute, just use an object and give an appropriate attribute name and you are done! That’s why Oops is really interesting to work with.

Ok, so one thing I noticed in the above way of assigning attributes to instances is that, we would have to use the dot and attribute name every time we would want to give a value. This might get cumbersome if you are having really large number of professors in the university. Also, this is a repetitive task. Notice how ‘.name, .id, .age’ is repeated for all the instances? Well, there is a neat way to circumvent this. It is, by using init() method. But before moving onto init method, lets talk about methods for a moment.

Method in Python OOPs

Just like we make use of functions in Python, we can have functions inside class as well. Any function that you define inside class is no longer called a function, it’s called a method. Every method inside a class must’ve it’s first argument as self. There is a reason to it. Which I will be demonstrating in the upcoming code snippet. We can call the function from outside the class using the instance name. The following code snippet demonstrates the methods concept of Python:

class Professor:
    def displayName(self):
        print(self.name)

#instances
pooja = Professor()
pratheek = Professor()

# assigning attributes
pooja.name = "Pooja"
pratheek.name = "Pratheek"

# calling method
pooja.displayName()       # Pooja
pratheek.displayName()    # Pratheek

Here, notice how the displayName gave different outputs for both Pratheek and Pooja. Well, that’s because as I mentioned earlier in this report that, whenever you create an instance, it gets an independent blueprint of the class. Therefore, the attributes of Pratheek are in no way having control over Pooja’s. Hence, we got two outputs.

Okay, lets talk about that self keyword. Now, by default, whenever you call a method, in the backend, python does this conversation implicitly:

className.methodName(instanceVar)

Therefore, pooja.displayName() is converted implicitly to:

Professor.displayName(pooja)

So, as you can see that automatically, python passes the instance as its first argument. Therefore, to receive this argument, we use the keyword self, although you can use any word of your choice.

Now, let me take you back to the init method. Init method is used to initialize attributes to a given object. So, instead of writing object dot attributename every time, we can pass
those attributes values as the parameters to the class name when we declare an instance.
The following code demonstrates the usage of init method:

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

    def displayName(self):
        print(self.name)

#instances
pooja = Professor('Pooja', 34, 25)
pratheek = Professor('Pratheek',None, 19)

#calling methods
pooja.displayName()        # Pooja
pratheek.displayName()     # Pratheek

The code looks more organized now. See how I’ve passed the attribute values while I declared the object. Also, id has become a mandatory field now. Since Pratheek doesn’t have an id yet, I assigned None as its id.

In python, we do have other method types apart from these normal methods and they are:
class methods and static methods

Methods vs Class Methods vs Static Methods

In this sub section, we will be covering class and static methods. Now, before starting off with these, its imperative to understand the difference between class and instance variables. Class variable is shared across all the instances while instance variables are specific and is unique for that instance only. Class variables are declared inside class and outside any methods. Instance variables are declared inside init method. The following code snippet shows class and instance variables:

class Professor:
    classvar = "this is a class variable" # class variable

    def __init__(self, name, id, age):
        self.name = name      # instance variable
        self.age  = age       # instance variable
        self.id   = id        # instance variable

    def displayName(self):
        print(self.name)

#instances
pooja = Professor('Pooja', 34, 25)
pratheek = Professor('Pratheek',None, 19)

In the above snippet, classvar is common variable to all the instances (if you explicitly assign it or not). Therefore, even though we did not mention about classvar in pooja and pratheek, they both will contain a class variable called classvar which can be accessed and used whichever way you’d like.

Now, lets talk about the classmethods. Generally, class methods are used to modify, edit or even delete the class variables. Just like a normal method, it also takes a first argument by default but only in this case, it takes class name as its first argument. Also, whenever you are declaring a class method, you should enclose it using a @classmethod decorator. This is done to show Python that the method defined here is a class method and should not be mistaken with the normal method. Class methods are usually called using the class name. The following code snippet demonstrates the use of classmethod:

class Professor:
    classvar = "this is a class variable" # class variable

    def __init__(self, name, id, age):
        self.name = name      # instance variable
        self.age  = age       # instance variable
        self.id   = id        # instance variable

    @classmethod
    def dean(cls, name):
        cls.dean = f"{name}"

#instances
pooja = Professor('Pooja', 34, 25)
pratheek = Professor('Pratheek',None, 19)

# calling the class method
Professor.dean('LPU Dean')

print(pooja.dean)       # LPU Dean
print(pratheek.dean)    # LPU Dean

In the above snippet, you can see that although I haven’t declared dean attribute for pooja and pratheek, but still it got reflected later as their attributes. This is one of the most common use case of class methods. They are used to set / modify class variables. You could also use instances to set the class variable, but it would be a vague or unsuitable candidate and also, I can’t really think of a case where an object can decide what class variable should the class hold.

Now, comes the static method. Static method, in general, does not serve other purposes rather than to use them as logical connectors which means that it is used to implement some sort of logic within the class and does not affect the instances in any way.

Static methods do not take any default arguments. You can declare a static method using the @staticmethod decorator. It can be called using the class name or instance name. The following snippet shows its usage:

class Professor:
    classvar = "this is a class variable" 

    def __init__(self, name, id, age):
        self.name = name      
        self.age  = age       
        self.id   = id        

    @classmethod
    def dean(cls, name):
        cls.dean = f"{name}"

    @staticmethod
    def displayPrompt():
        print("The details have been entered")

#instances
pooja = Professor('Pooja', 34, 25)
pooja.displayPrompt()       # calling via instance

pratheek = Professor('Pratheek',None, 19)
Professor.displayPrompt()   # calling via class name

# both prints out the same result.

In the above code, both displayPrompt() will output the same result. Also, notice that in it, we haven’t passed any default arguments.

The End is Not Nigh

We discussed a lot in this article. You are now well equipped with the fundamentals to take on this OOPs fight. In future, I will include some Inheritance articles and even some extras that many don't know about OOPs.

Would You Like to Support Me?

If you want to support me and my contents, then go ahead and consider doing it. I would highly appreciate that:

YouTube Channel: Home to all sorts of peculiar tutos.
GitHub: Looking forward to your PR 😉

Forem: P0intMaN

How I cracked MLH Fellowship in my first attempt: Journey & Tips

My Journey

The Selection Process

The Application

The Interviews

The Final Review

The Strategy

Feel The Heat

First Things First

Cracking the Application Process

Cracking the Interviews

Anticipating the Final Result

Resources

Alternative Constructors in Python

Article Agenda

Introduction

Constructors

The __init__() vs __new__(). Which one is the real constructor?

Alternative Constructors

A Real Application Example

Would You Like to Support Me?

All You Need to Know About Closures in Python.

Article Agenda

Introduction

Psst.. If you are in a hurry, you can watch the video version of this post instead

Nested Functions

Closure Property

Would You Like to Support Me?

What are First Class Functions in Python?

Article Agenda

Introduction

Psst.. If you are in a hurry, you can watch the video version of this post instead

First Class Object

First Class Functions

What Next

Would You Like to Support Me?

A Primer on Object Oriented Programming with Python.

Article Agenda

There is another interesting follow up topic to OOP in Python, which is called inheritance. This is a whole world in itself and for the sake of not converting this article into a full-fledged book, I decided to talk about it in another article. It deserves a dedicated article on its own.

Introduction

Object Oriented Programming

Class in Python OOPs

Instance (Or Object) in Python OOPs

Method in Python OOPs

Methods vs Class Methods vs Static Methods

The End is Not Nigh

Would You Like to Support Me?

The `init()` vs `new()`. Which one is the real constructor?