DEV Community: Snehangsu De

The Brotherhood of : `str` & `repr`

Snehangsu De — Wed, 09 Mar 2022 13:25:08 +0000

If you want to view the notebook version of this, you can view it here.

Diving in the nitty-gritty details of Python introduces us to Dunder Methods. Dunder means "double underscores" as it starts and ends with two underscores. A dunder method acts as a contract between the Python interpreter and the person who made a particular Python class.

For example, the len method, it helps us with the length of any given string or list or a dictionary, however, it uses a dunder method __len__. Since the length of something is fundamental to any programming language it was made a built-in method but nonetheless, it internally delegates the task to __len__.

>>> integers = [1, 2, 3, 4, 5]
>>> len(integers)
Output: 5

>>> integers.__len__()
Output: 5

There are quite a few built-in functions that internally use dunder methods to work, such as indexing which uses __getitem__, or print which uses __str__. If you are interested to know about all dunder methods here's a good resource: Dunder Methods

The Difference

Understanding __str__ & __repr__ allows us greater control for us to not only edit and upgrade classes but also to debug and create libraries.
In a nutshell, if I had to explain to you about __str__ or __repr__ they both do the same thing i.e. they print an output. However, __repr__ is mostly used by programmers to debug, and __str__ is for the users using the program. Let's dive in to see how exactly are they both different and learn about when to use which!

>>> repr('Triceratops')
Output: "'Triceratops'"

>>> str('Triceratops')
Output: 'Triceratops'

Looking at the above lines of code, there isn't much difference apart from the fact that repr('Triceratops') throws us an output which is within a double-inverted comma ("") and then the string within a single-inverted ('') comma. As for the str('Triceratops') it's within a single-inverted comma(''). If you ask me, that's not even a difference as both of them do the same exact thing and there isn't much difference.

Let's look at something a bit more interesting.

>>> import datetime

>>> current_time = datetime.datetime.now()
>>> print(current_time)
Output: 2022-03-03 01:04:19.955451

>>> str(current_time)
Output: 2022-03-03 01:04:19.955451

>>> repr(current_time)
Output: 'datetime.datetime(2022, 3, 3, 1, 4, 19, 955451)'

Fascinating, isn't it!

While using the datetime library we created a variable current_time which stores as the variable says, the current time. Running a print statement gives us an output that is similar to the output when we use the current_time variable inside the str() function. A user-friendly output of the variable giving is the year-month-date hour:minutes:seconds.

However, using the same variable inside the repr() function gives us an entirely different output. It tells us that it's a datetime object which holds the values (year, month, day, hour, minutes, seconds, microseconds). A developer-friendly output that provides adequate information for a developer to understand.

The Brotherhood

While it may be intriguing to prefer one over another, truth be told, we need both of them to make sure they cover both cases. The general idea is to make the __repr__ function help you as much as you can with maximum details. While the __str__ function with the minimum details which a user can read or understand. For example:

Defining a class:

>>> class Dinosaur:
    ... def __init__(self, name):
        ... self.name = name

>>> def __repr__(self):
    ... return (f'{self.name.__class__.__name__}({self.name})') 

>>> def __str__(self):
        ... return (f'{self.name}')

Code:

>>> dino = Dinosaur(1)
>>> print(dino)
Output: 1

>>> str(dino)
Output: 1

>>> repr(dino)
Output: int(1)

Note: __class__ and __name__ represents the name of the class the name belongs to.

Conclusion

Now that, you have got a grasp into what __repr__ & __str__ does, you are one step closer to debugging your own code. Try creating a class that gives you all the information using repr() but only the necessary one using str().

If you are interested to know about how datetime wrote their library __repr__ and __str__ function, you can see the source code here. It might be overwhelming when you look at the code but try to search through the document to find __str__ and __repr__. Hint: Use Ctrl + F. This will give you a broader idea of how these functions are different, yet so similar.

Oh! And something interesting while I was working on this article, I saw the Jupyter notebooks use __repr__ when the output is requested without the print. If you want to view the notebook version of this you can use view it here.

The Power of Inheritance

Snehangsu De — Mon, 28 Feb 2022 14:52:42 +0000

If you Google "Inheritance" the most expected definition in the language of Biology would be that it's a trait passed down from your ancestors to you or from you to your descendants.

Me, you, alike have had some specific traits or qualities that have been passed down from our ancestors. While true, this doesn't mean I or you are exactly the same as our ancestors i.e. we have our own qualities and traits in addition to the traits from them.

Inheritance in Machines

Inheritance is similar in the life of machines. It helps them take in a specific trait or functionality from a Parent Class but also add a few functionalities of its own. If you are to ask me, Inheritance is undoubtedly one of the most powerful features in Object-Oriented Programming.

It allows us to create an entirely new Class with no modification or changes to the Parent Class. The new class is called the Child Class and the class it inherits from is the Parent Class.

In the image, we have two Classes Animal, which is the Parent Class, and Dog, which is the Child Class. We have talked about how to define classes before and that stays exactly the same for the Parent Class. However, we have two new things which are on Line 9 and Line 11. Let's dive in.

Line 9: To define a Child Class Dog, which would inherit all the functionality from the Parent class Animal we declare the Parent Class name within parenthesis.

Line 11: Now that we have defined the Parent Class we want to inherit from we would need to specify an in-built function that allows us to inherit the functionality to the Child Class. super().__init__() does the exact same thing.

We will see how this works as we walk through an example below

Everything else stays the same. The Parent Class has a method breathe while the Child Class has its own method bark. Also, the Child Class takes in one positional argument which is the breed of the Dog.

Let's now look at how to use these in our code.

The initial surprise that came to me when I was learning Inheritance was that I didn't really need the Parent Class to work with the Child Class, which is such a beautiful thing.

Line 1: We have defined two Classes before Animal and Dog. Surprise, surprise, we don't need the Animal Class to work with our Dog Class though it actually inherits from the Animal Class. Less Code, More Functionality.

Line 3: We have created an object roxy with our class Dog passing in one positional argument 'Border Collie'.

Line 5–8: These are the attributes of the Child Class i.e. Dog. Tapping into the methods and attributes provides the same output that we defined inside the Class.

Line 11–14: These are the attributes of the Parent Class i.e. Animal. This is the interesting part, Dog being a Child Class inherits all the attributes of the Parent Class without being explicitly defined. This is the work of the super() function which has the ability to reference the Parent Class.

Without the super() function trying to work with Line 11 -14 would result in an Attribute Error as it would not be inheriting any attribute of Parent Class. However, the method breathe() will still be inherited.

Multiple Inheritance

Inheritance can go into depth as well, just like us humans can inherit genes from our great grandparents. However, the important thing to remember is that the entire understanding of Inheritance stays the same i.e. it inherits functionality from the Parent Class.

In the above image, I haven't written the demo code for the classes but the structure of the Class is shown.

Conclusion

We have now embraced the power of Inheritance and why it makes our life even easier. All of this while reducing redundant lines of code and making our code re-useable. I hope you now have a good grasp of Inheritance. I look forward to seeing more of this functionality used in projects, do comment below if you have any interesting projects or in general comments or feedback.

I hope this message finds you in good health! If you have any interesting suggestions or feedback, feel free to connect with me on Twitter.

The Secrets of Self

Snehangsu De — Sat, 05 Feb 2022 15:26:12 +0000

in the previous article, we learned how Object-Oriented Programming can be replicated multiple times or can be reused later for fulfilling different utilities. For example, we can import a library (a well-documented pre-written code) into our program and create objects from there to use them inside our code.

While we were learning about Object-Oriented Programming, we saw the repetitive pattern for a parameter inside the Class in general as self. Let’s dive a bit into understanding, how self works and why do we use it?

Why do we need `self`?

Let’s take a look at the Class Animal. We have explicitly defined self while introducing attributes to the class as well as while we are defining a method.

We by now know that a Class creates a blueprint for us to create an Object. In the above picture, we have created two Objects named dog1 and dog2. The self term helps us represent the respective instance of an Object.

What do I mean by that?

In this picture, we have:

dog1 : name = Roxy & breed = BorderCollie

dog2 : name = Brent & breed = Doberman

Both the Objects are created from the same class i.e. from the same blueprint, the self parameter helps identify each object we have created and assign respective attributes and methods to it.

dog1 holds the name Roxy and breed as BorderCollie whereas dog2 holds the name Brent and the breed as Doberman. If we didn’t have the self parameter these would have not been possible.

How `self` works?

I mentioned a hint of how self works in the previous article but let’s dive into understanding what exactly happens under the hood.

For anyone, looking at the method breathe() would seem really weird that it takes one argument however when we call it, we don’t actually need to pass an argument for it to work nor does Python tell us anything about it.

When we run the above commands in the file type.py we see that Animal.breathe is a function while dog1.breathe is a method and that is quite interesting. Why? Well, the thing with Python method is that it passes the object as the first parameter inside the function.

So, when I type in dog1.breathe() into my console, it internally passes Animal.breathe(dog1) as a function with the self parament being the object we create itself.

Conclusion

Before we end, a quick notion that the self term doesn’t really need to be self, you can put it as dinosaur and it would still work the same, just make sure you replace all of them with dinosaur.

However, it’s generally recommended that you use self, as that’s followed by the entire community.
Additionally, if you are interested you can read more on the self parameter from the creator of Python itself here.

I hope I was able to explain why we need self and how it works under the hood. If you have any interesting suggestions or feedback, feel free to connect with me on Twitter. I also have a newsletter, which I send out every week. You can subscribe to it here.

The Elegance of Classes

Snehangsu De — Fri, 10 Dec 2021 09:14:17 +0000

Section 4: Objects and Classes

If you are someone who used to code back in the late 1960s, then you know how hard writing pages and pages of code were. Today, we are effectively using object-oriented programming and our lives have become easier. Back in those days, procedure-oriented programming was used which focused mostly on functions, whereas object-oriented programming focuses on objects.

Let’s dive into understanding what objects actually are and how to create them.

Objects and Classes

To understand better, let’s take an example of a virtual zoo. Say, we want to create a virtual zoo, wherein in total there would be 2 dogs, and 1 dinosaur (you knew Dinosaurs were coming), and each with a unique nickname.

To create this database using procedure-oriented programming, it would not only require lists and loops to create them but as hundreds and thousands of various kinds of animals are brought in, the code would not only be lengthy but extremely hard to debug in case of any errors.

Enter Object-oriented programming.

In object-oriented programming, we create a blueprint defined as a class, so that we can create multiple objects using it. This is best explained in an example, so here’s how to define a class:

Class

Here, there are a few things to put your eye on. Let’s look at them all.

Class: To define a Class, we use the class keyword and initialize it with the name of the class. Note: The name is in Camel-case.
Constructor: init is a dunder method, a special kind of function. We will discuss dunder methods later but what it basically does is help us construct any attributes of the Class hence called a constructor.
Attributes: So what exactly are attributes? It’s a fancy term used for variables inside the Class.
Method: Method is another fancy term used for Functions inside a Class. It’s generally a good idea to know the terms as they are widely used but none of the basic idea changes just cause they are inside a Class.
self: When I got first introduced to object-oriented programming I had a tough time understanding what self does. I will be explaining in detail in the next blogpost but for now, accept it as something that allows the object; we will create to access both the attribute and the method inside a class. It will become a bit more clear when we understand Objects. 👇🏼

Objects

Try Right-Clicking on the image, then select Open image in a new tab if the image is unreadable.

After declaring the Class (previous image) with the file named mammal.py we import the Animal Class. It’s not necessary but recommended as separating your code into two different files makes debugging easier. Once imported we create the object, let’s dive into the code and how it works internally.

Creating Objects: We create two objects of name dog1 and dog2 using the Animal class, just by assigning two different variables to store the Object into. I have used keyword arguments to declare the values but can be done using positional arguments too.

What exactly happens under the hood is when I declare the Animal class and pass on the name & the breed it constructs the Object based on the blueprint of the Animal Class which is defined by the init method. Here the self word helps in connecting the arguments declared while creating the Object in main.py with the attributes inside the Class Animal in mammal.py.

Calling the Method: Calling the breathe() method on each of the variables inside the main.py would call the Function inside the Animal Class and do whatever is defined inside the Function. Here’s it to print 'Inhale - Exhale'.

What exactly happens under the hood is when the method is called on the Object created, it passes the Object (dog1, dog2, or dinosaur1) on the self parameter and then calls the Function to do the action defined inside the Function. This means that dog1.breathe() translates to Animal.breathe(dog1).

Note: While calling a Method, not providing the parenthesis would not run the code instead the location the Object is created will be printed

Changing the Attributes: You may have noticed that I have changed the value for tail for the Object dog2 as False. One of the blessings of using object-oriented programming or OOP is that you can change and create variables on the go.

dog2.tail = False is an example of changing the value. dinosaur1.horn = True is an example of adding a new attribute to the Object.

Conclusion

We have now learned the essence of Classes and why it makes our life easier without having to write redundant lines of code. Object-Oriented Programming is the way to go for us. While we have only scratched the surface of OOP, a lot more is there to unveil. And I will be talking about them in the upcoming blogposts, making it easier for you to grasp.

If you have any interesting suggestions or feedbacks, feel free to connect with me on Twitter. I also have a newsletter, which I send out every week Thursday. You can subscribe it here.

Hope you enjoy this, see you next week! 👋🏼

Overcoming the Initial Challenge

Snehangsu De — Fri, 03 Dec 2021 08:49:37 +0000

The Power of being present

We have all started something we didn't continue. If you are above the age of 10, I'm sure you know exactly what I'm talking about. Starting from going to the gym, learning a new language, or meditation, we have all wanted to be constant. So, the question arises why can't we continue? Why do we fail if we want something?

Imagine yourself deciding to start learning a new language one hour each day. You complete Day 1, Day 2, and Day 3. On Day 4, however during your schedule, an important emergency drops in and you make adjustments to your routine to attend to that emergency. Now here's the thing, we humans love order. In fact, we are so ordered that we maintain ourselves subconsciously. We follow the exact order to put our shoes on, we brush our teeth in the same rhythmic motion each day and even follow the same routine when we step out of a room.

The moment, our schedule is interrupted, we divert from the plan as we no longer would get back the same one hour hence we tend to postpone it to the next available day. Here's where the issue lies-

If you miss a day that's twice as more harmful than getting your work done even for 5 minutes.

The Contingency Plan

We know that emergencies and work can pop up anytime, regardless of how planned or how well managed our schedule or routine is. So, what can we do to dampen the damage?

Luckily, we have a choice. I like to call it the Contingency Plan. The contingency plan is a normal plan but only triggered when the normal routine is hindered. The idea to make this plan is to narrow down on the important, the necessary, and the extras. Here's an image to summarize how you create them.

Our goal is to be consistent not to be a perfectionist while trying to make a habit. Once we hit the threshold for it to be a habit, the skill we are trying to achieve would be subconsciously done. On that note, when we are working against time to manage the change in schedule, the idea is to follow the easiest path to be consistent i.e. to be present to make sure we are attending to the things we want to achieve.

Conclusion

In a nutshell, to achieve something you have dreamt of achieving or you want to achieve, just be sure to be consistent.

Remember, consistency can move mountains.

Here's another picture from the book Atomic Habits by James Clear which tells you how much showing up consistently with 1% improvement can help you grow in a year compared to disjointed performances.

I hope that that this helps you understand and plan out the stuff you want to start. Take a week may be two, to understand how you'd like to start your journey and then stick to it.

If you have any interesting suggestions or feedbacks, feel free to connect with me on Twitter. I also have a newsletter, which I send out every week Thursday. You can subscribe it here.

See you next week! 👋🏼

The Weaponization of Functions

Snehangsu De — Thu, 25 Nov 2021 09:19:30 +0000

Section 3: Advanced Functions 🛠

"The Art of Functions" covered the basics of functions but we need to learn quite a few important utilities as we start using various libraries or write our own code. Today, we will dive into a few major concepts as we learn more about *args, **kwargs, Higher-order functions, and recursion.

*args:

These allow unlimited positional arguments to be passed inside a function with input or output functions. *args are tuples and can be looped through.

*args are usually used when you'd like your user to input many arguments and make them work in a similar kind of way. To put it in easier terms, do one action with the arguments.

For example, in the above image we only sum up the arguments. You can similarly set colors for an image with various hex codes as arguments.

**kwargs:

These allow unlimited keyword arguments to be passed inside a function with input or output functions. **kwargs are dictionaries and can be used as a key, value pair.

**kwargs are usually used when you'd like your user to input many arguments but to make them work in various different ways. To put it in easier terms, do multiple actions with the arguments.

For example, in the above image we sum and multiply the arguments. You can similarly set various properties such as the width, the height of an image with keyword arguments. These are extremely popular in Data Science libraries such as Seaborn and Matplotlib.

Higher-Order Functions:

Higher-order functions are functions that take in other functions as a parameter.

Higher-order functions are usually used when you'd like your user's choice to be separate and divide the actions.

For example, in the above image we use the cal function to take another function add or mul and pass in the argument given by the user to return a value. These are generally used if you are using a GUI application to assign respective functions to a button or a label.

Points to remember:

Higher-order function takes other functions as parameters
Remember to not add parenthesis inside the argument

Recursion:

Recursion is the method of calling a function within a function, similar to a while loop.

Recursion is usually used when you'd like to loop in a particular set of actions until another set of actions is done. Recursion is extremely handy as they can work with multiple libraries without necessarily using the while-loop. Since Recursion is an important topic we will discuss more, while understanding Data Structures especially Binary Trees.

Conclusion

Functions are generally used to avoid repeatable code which not only makes our code look ugly and extremely hard to debug but also helps with readability since they help summarize a particular set of work inside a defined function. In general, functions with outputs are widely used and are more popular as they serve greater flexibility towards clean code.

This is only a brief overview of the power functions hold to make our life easier. We will dive more into how we can use them and learn more on where we can use them in the upcoming series understanding the nitty-gritty stuff.

If you have any interesting suggestions or feedback, feel free to connect with me on Twitter. I also have a newsletter, which I send out every week Thursday. You can subscribe it here.

Hope you enjoy this, see you next week! 👋🏼

The Art of Functions

Snehangsu De — Thu, 18 Nov 2021 21:32:50 +0000

Section 2: Functions ⚙

Wondering, what's up with this weird ancient art? Well, they help portray how civilization evolved much like how we learned to evolve our ways to talk to machines. Like us humans divided our society to do specific tasks say carpenters to work with wood, barbers to trim our hairs, similarly, we can ask machines to work specifically on something or take a specific action when some work is given. As an example imagine, when we wake up, we follow the below step -

Get your bed done > Brush your teeth > Wash your face > Dry your face

For machines, these are described as functions. To understand what a function is imagine a set of instructions that needs to be done when something happens.

Now you might think why do we need to have functions? It's simple, however much we like to abuse Ctrl+C & Ctrl+V it's not a good practice to have repeatable code. Instead, every time you have to do the same action, you can simply call the function to make it work.

Fundamentals of Functions

In Python, there are two kinds of functions - Built-in functions and User-defined functions. We will talk about Built-in functions in a later post.

Today, we will discuss the three kinds of User-defined functions, let's start with the basic one. To write any function we need to have a few important things in mind -

A function should always start with def word
The def will be followed by the name of the function, recommended in all lower case
The name of the function is followed by a parenthesis and colon ():, denoting the end of defining a function
Any lines inside the function should be indented to work under the function call.
Optional requirement, a docstring can be added right below the function.

Here's how it would look like. 👇

Now the important takeaway from here is how a function when defined doesn't do anything, which means that it would be defined inside the variable wake_up when you run the file, however, you would need to call it to make sure it does what you have asked it to do. You can call it by writing the unique name of the function you have defined, followed by the parenthesis.

Here, I've asked it to print I woke up at 8 AM

Before we jump into understanding the other two types of functions and when to use them, we need to understand two important concepts:

Parameters - Parameters are something that your function can take and work with, inside the function. Think of it as a variable inside a function that can take inputs or can be optional too.
Arguments - Arguments are the values that you would assign to your parameter when calling the function. Think of it as assigning a value to the pre-defined parameters. Arguments are again defined into two groups:

Positional Arguments - Arguments that are called into functions based on the positions of the paraments.
Keyword Arguments - Arguments that are called into functions using the same keyword that is used to define the parameters.

As we have grasped the basic idea of Parameters and Arguments let's dive into the next type of function drum-roll -

Functions with inputs 👇

Here, we can see that wake_up has two parameters time & meridian. You can see that time requires a value however meridian has a pre-assigned value of a string 'AM', which means that the meridian is optional for you to assign. Here's how you can call this function:

Calling the function with only the required data -

Positional argument: wake_up(12) --> This will print I woke up at 12 AM
Keyword argument: wake_up(time=12) --> This will also print I woke up at 12 AM

Here, the 12 gets assigned to the time variable whereas the meridian uses the 'AM' as the default value.

Calling the function with both data -

Positional argument: wake_up(12, 'PM') --> This will print I woke up at 12 PM
Keyword argument: wake_up(meridian='PM', time=12) --> This will print I woke up at 12 PM

Here, the 12 gets assigned to the time variable and the meridian gets assigned to the 'PM' value. This is one of the benefits of using keyword variables as it doesn't require the position of arguments to match the position of parameters.

Note: Changing the positional argument wake_up('PM', 12) would print --> I woke up at PM 12

Functions with inputs and outputs 👇

This is probably the most used kind of function and is really handy to work with. Almost every rule stays the same from when we defined the Fundamentals of Functions apart from the addition of one:

As this gives us an output a command return is added at the end which allocates the output to a variable outside the function which can then be re-used.

Note: Anything after the command return would be ignored by the console as the function would immediately end and allocate the value.

Calling the function with positional argument -

returned_value = add(2, 3) --> This doesn't print any value but instead allocated the variable returned_value with 5.

Try this out and see, how the print statement is absolutely ignored by the console.

Calling the function with keyword argument -

returned_value = add(number1 = 6, number2 = 3) --> This too doesn't print any value but instead allocated the variable returned_value with 9.

Conclusion

We have now understood the types of functions that we can write to help us talk to machines efficiently, without having to repeat ourselves. However, sometimes, we speak in languages our machines have a hard time understanding, those are bugs or errors in our code.

Here are a few common ones for you to catch:

Missing an argument, if your function has parameters would pop a TypeError
Writing a Keyword argument before a Positional argument would result in SyntaxError
Any line of code after the return command on the same indentation level would be ignored.

Here's an image that summarizes how functions are triggered and how they work.

The code starts execution from the arrow tail and follows its head
When it hits the star
It jumps to see the function under the name of sum
Executes everything inside the function taking the arguments to replace the parameters
Hits the return statement
Allocates the value of the local variable num to the global variable addition

That's it for Functions! Next, we will talk about more advanced function usages. Hope this has helped you understand how functions work & what exactly happens under the hood making our lives easier. If you have any interesting suggestions or feedbacks, feel free to connect with me on Twitter. I also have a newsletter, which I send out every week Thursday. You can subscribe it here.

I hope this message finds you in good health!

The Start of Something Beautiful

Snehangsu De — Mon, 11 Oct 2021 09:51:50 +0000

"For millions of years mankind lived just like the animals.
Then something happened which unleashed the power of our imagination,
We learned to talk."

Quoting from the lines of Pink Floyd, it's simple to understand how communication has shaped our society, likely the single most important thing that has made civilizations stand. While we have created types of communication for us humans, since the age of machines we have learned to communicate with machines too, and surprisingly it spans back to the 40s.

I wanted to start with the history as to where do programming languages come from, as they help us understand why we are working with them. Plus it narrates a nice story on how far we have come. As we begin, today we will be discussing Import Statements. However, here's a quick look at what the first high-level language looked like.

Traumatizing, right? I agree we have come a long way from the above image to print('Hello, world!').

Let's begin!

Section 1: Imports in Python 🐍

To help us understand what and how imports work, let's assume we have a module (basically a sheet of code) named dinosaur.py that has

type = 20 [A variable]

def roar(name): ... return f'{name} roars'

We can import this module in two different ways :

Import statement 1:

import dinosaur

Import statement 2:

from dinosaur import roar

Here are few general pointers for import -

Imports are statements and not functions
Importing dinosaur.py creates a variable name dinosaur and also creates another variable type which is inside the dinosaur.py module
Importing creates a module object (object can be defined as a blueprint) and sets a variable (the name of the module) to point to that module object. [Defined in the 3rd point]

Running Import statement 1 executes the module line by line. So, when I call the statement :

It defines the global variable type as an integer.
Defines the global variable roar as a function that takes one argument.
Then import defines a variable dinosaur, through whose attributes (dinosaur.type and dinosaur.roar) we can get to our variable and function.

Running Import statement 2 executes the module but only by the respective variable roar. So, when I call the statement :

It defines only the variable roar to be used inside the program.
It would not define a variable under the module name, so we would not have a variable named dinosaur anymore.

There is one other rare way to import which should be avoided at all costs.

from dinosaur import * [This causes to replace all variables in your local namespace]

A namespace is the current *.py file we would be working on, or importing the statements to.

Here's a picture to understand better how variables work inside namespaces when imported.

Hope this has helped you understand how imports work. As this being my first article, if you have any interesting suggestions, feel free to connect with me on Twitter. I also have a newsletter, which I send out every week Thursday. You can subscribe it here.

I hope this message finds you in good health, see you next week!

DEV Community: Snehangsu De

The Brotherhood of : `__str__` & `__repr__`

The Difference

The Brotherhood

Conclusion

The Power of Inheritance

Inheritance in Machines

Multiple Inheritance

Conclusion

The Secrets of Self

Why do we need self?

How self works?

Conclusion

The Elegance of Classes

Section 4: Objects and Classes

Objects and Classes

Class

Objects

Conclusion

Overcoming the Initial Challenge

The Power of being present

The Contingency Plan

Conclusion

The Weaponization of Functions

Section 3: Advanced Functions 🛠

*args:

**kwargs:

Higher-Order Functions:

Points to remember:

Recursion:

Conclusion

The Art of Functions

Section 2: Functions ⚙

Fundamentals of Functions

Functions with inputs 👇

Functions with inputs and outputs 👇

Conclusion

The Start of Something Beautiful

Section 1: Imports in Python 🐍

The Brotherhood of : `str` & `repr`

Why do we need `self`?

How `self` works?