<h2 id="introduction">Introduction</h2>
Python is a very high-level programming language, and it tends to stray away from anything remotely resembling internal data structure. Because of this, we usually don't really need indices of a list to access its elements, however, sometimes we desperately need them.
In this article, we will go over different approaches on how to access an index in Python's for loop.
<h2 id="howtoaccessindexinpythonsforloop">How to Access Index in Python's for Loop?</h2>
The easiest, and most popular method to access the index of elements in a for loop is to go through the list's length, increasing the <code>index</code>. On each increase, we access the list on that <code>index</code>:
<pre><code class="hljs">my_list = [3, 5, 4, 2, 2, 5, 5]

print(&quot;Indices and values in my_list:&quot;)

for index in range(len(my_list)):
 print(index, my_list[index], end = &quot;\n&quot;)
</code></pre>
Here, we don't iterate through the list, like we'd usually do. We iterate from <code>0..len(my_list)</code> with the <code>index</code>. Then, we use this <code>index</code> variable to access the elements of the list in order of <code>0..n</code>, where <code>n</code> is the end of the list.
This code will produce the output:
<pre><code class="hljs">Indices and values in my_list:
0 3
1 5
2 4
3 2
4 2
5 5
6 5
</code></pre>
<h2 id="usingenumerate">Using enumerate()</h2>
<code>enumerate()</code> is a built-in Python function which is very useful when we want to access both the values and the indices of a list. It's worth noting that this is the fastest and most efficient method for acquiring the index in a for loop.
This method adds a counter to an iterable and returns them together as an enumerated object. This enumerate object can be easily converted to a list using a <code>list()</code> constructor. This is the most common way of accessing both elements and their indices at the same time.
Now, let's take a look at the code which illustrates how this method is used:
<pre><code class="hljs">my_list = [3, 5, 4, 2, 2, 5, 5]
print(&quot;Indices and values in my_list:&quot;) 
for index, value in enumerate(my_list): 
 print(list((index, value))) 
</code></pre>
This code will produce the output:
<pre><code class="hljs">Indices and values in my_list:
[0, 3]
[1, 5]
[2, 4]
[3, 2]
[4, 2]
[5, 5]
[6, 5]
</code></pre>
What we did in this example was enumerate every value in a list with its corresponding index, creating an enumerate object. Then, we converted that enumerate object into a list using the <code>list()</code> constructor, and printed each list to the standard output.
Additionally, you can set the <code>start</code> argument to change the indexing. Currently, it's 0-based. Let's change it to start at <code>1</code> instead:
<pre><code class="hljs">my_list = [3, 5, 4, 2, 2, 5, 5]
print(&quot;Indices and values in my_list:&quot;) 
for index, value in enumerate(my_list, start=1): 
 print(list((index, value))) 
</code></pre>
Now, this produces:
<pre><code class="hljs">Indices and values in my_list:
[1, 3]
[2, 5]
[3, 4]
[4, 2]
[5, 2]
[6, 5]
[7, 5]
</code></pre>
<h2 id="usinglistcomprehensions">Using List Comprehensions</h2>
A list comprehension is a way to define and create lists based on already existing lists. It's usually a faster, more elegant, and compact way to manipulate lists, compared to functions and <code>for</code> loops.
Every list comprehension in Python contains these three elements:
<ol>
<li>iterable - A collection who's elements we can inspect one at a time</li>
<li>member - Value or object in a list (which is an iterable)</li>
<li>expression - Can be any valid expression that returns a value(a member, an iterable, a call to a function...)</li>
</ol>
Let's take a look at the following example:
<pre><code class="hljs">my_list = [1, 2, 3, 4, 5]
my_list_squared = [m*m for m in my_list]
print(my_list_squared)
</code></pre>
This code will produce the output:
<pre><code class="hljs">[1, 4, 9, 16, 25]
</code></pre>
In this list comprehension, <code>my_list</code> represents the iterable, <code>m</code> represents a member and <code>m*m</code> represents the expression.
Now that we went through what list comprehension is, we can use it to iterate through a list and access its indices and corresponding values. Let's take a look at this example:
<pre><code class="hljs">my_list = [3, 5, 4, 2, 2, 5, 5]
print(&quot;Indices and values in my_list:&quot;) 
print([list((i, my_list[i])) for i in range(len(my_list))])
</code></pre>
This code will produce the output:
<pre><code class="hljs">Indices and values in my_list:
[[0, 3], [1, 5], [2, 4], [3, 2], [4, 2], [5, 5], [6, 5]]
</code></pre>
What we did in this example was use the <code>list()</code> constructor. This constructor takes no arguments or a single argument - an iterable. This includes any object that could be a sequence (string, tuples) or a collection (set, dictionary).
If no parameters are passed, it returns an empty list, and if an iterable is passed as a parameter it creates a list consisting of its items.
We constructed a list of two element lists which are in the format <code>[elementIndex, elementValue]</code> . These two-element lists were constructed by passing pairs to the <code>list()</code> constructor, which then spat an equivalent list.
This will create 7 separate lists containing the index and its corresponding value in <code>my_list</code> that will be printed.
<h2 id="usingzip">Using zip()</h2>
The <code>zip()</code> function accepts two or more parameters, which all must be iterable.
It returns a zip object - an iterator of tuples in which the first item in each passed iterator is paired together, the second item in each passed iterator is paired together, and analogously for the rest of them:
<pre><code class="hljs">list_a = [1, 2, 3]
list_b = [&#x27;A&#x27;, &#x27;B&#x27;, &#x27;C&#x27;]

# Zip will make touples from elements with the same 
# index (position in the list). Meaning that 1 from the
# first list will be paired with &#x27;A&#x27;, 2 will be paired
# with &#x27;B&#x27; and so on...
for elem1,elem2 in zip(list_a,list_b):
 print((elem1,elem2))
</code></pre>
Running the code snippet above we get:
<pre><code class="hljs">(1, 'A')
(2, 'B')
(3, 'C')
</code></pre>
The length of the iterator that this function returns is equal to the length of the smallest of its parameters.
Now that we've explained how this function works, let's use it to solve our task:
<pre><code class="hljs">my_list = [3, 5, 4, 2, 2, 5, 5]
print (&quot;Indices and values in my_list:&quot;) 
for index, value in zip(range(len(my_list)), my_list):
 print((index, value))
</code></pre>
This code will produce the output:
<pre><code class="hljs">Indices and values in my_list:
(0, 3)
(1, 5)
(2, 4)
(3, 2)
(4, 2)
(5, 5)
(6, 5)
</code></pre>
In this example, we passed a sequence of numbers in the range from <code>0</code> to <code>len(my_list)</code> as the first parameter of the <code>zip()</code> function, and <code>my_list</code> as its second parameter. The function paired up each index with its corresponding value, and we printed them as tuples using a <code>for</code> loop.
If we wanted to convert these tuples into a list, we would use the <code>list()</code> constructor, and our <code>print</code> function would look like this:
<pre><code class="hljs">print(list((index, value)))
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article we went through four different methods that help us access an index and its corresponding value in a Python list.
Besides the most basic method, we went through the basics of list comprehensions and how they can be used to solve this task. Even though it's a faster way to do it compared to a generic for loop, we should generally avoid using it if the list comprehension itself becomes far too complicated. Complicated list comprehensions can lead to a lot of messy code.
It is important to note that even though every list comprehension can be rewritten in a for loop, not every for loop can be rewritten into a list comprehension.
Another two methods we used were relying on the Python in-built functions: <code>enumerate()</code> and <code>zip()</code>, which joined together the indices and their corresponding values into tuples. Then, we converted those tuples into lists and printed them on the standard output.

Mila Lukic

In this tutorial, we'll go over how to access the index in a Python's for loop. We'll use a generic manual approach, as well as use enumerations, the zip() function and list comprehensions.

How to Access Index in Python's for Loop

Marcus Sanatan

Ruslan Hasanov

In this tutorial, we will combine DataFrames in Pandas using the merge function. We will also merge data with join, append, concat, combine_first and update, with examples.

How to Merge DataFrames in Pandas - merge(), join(), append(), concat() and update()

<h2 id="introduction">Introduction</h2>
File manipulation is one of the most important skills to master in any programming language, and doing it correctly is of utmost importance. Making a mistake could cause an issue in your program, other programs running on the same system, and even the system itself.
Possible errors can occur due to the parent directory not existing, or by other programs changing files in the file system at the same time, creating something that is called a race condition.
A race condition (in this case called a data race) occurs when two or more programs want to create a file of the same name in the same place. If this type of bug occurs, it is very hard to find and fix since it is nondeterministic, or put simply, different things can happen depending on the exact timing of the two racers competing for the data.
In this article, we'll see how to create a subdirectory in Python the safe way, step by step. Everything henceforth will work on Mac, Linux, and Windows.
<h2 id="safelycreatinganesteddirectorywithpathlib">Safely Creating a Nested Directory with pathlib</h2>
There are plenty of ways to create a subdirectory, but perhaps the simplest is using the <code>pathlib</code> module. The <code>pathlib</code> module is primarily made to help abstract different operating system file systems and provide a uniform interface to work with most of them.
Thanks to it, your code should be platform-independent. Note that this only works on newer versions of Python (3.5 and up).
Let's say we have an absolute path of a directory given to us as a string, and we wish to create a subdirectory with a given name. Let's create a directory called <code>OuterDirectory</code>, and place <code>InnerDirectory</code> inside it.
We'll import <code>Path</code> from the <code>pathlib</code> module, create a <code>Path</code> object with the desired path for our new file, and use the <code>mkdir()</code> method which has the following signature:
<pre><code class="hljs">Path.mkdir(mode=0o777, parents=False, exist_ok=False)
</code></pre>
The following code snippet does what we described above:
<pre><code class="hljs">from pathlib import Path # Import the module
path = Path(&quot;/home/kristina/OuterDirectory/InnerDirectory&quot;) # Create Path object
path.mkdir() # Cake the directory
</code></pre>
If <code>mkdir()</code> doesn't succeed, no directory will be made and an error will be raised.
<h3 id="mkdiroptionsanderrors">mkdir() Options and Errors</h3>
If you run the code without creating the <code>OuterDirectory</code>, you'll see the following error:
<pre><code class="hljs">Traceback (most recent call last):
 File &quot;makesubdir.py&quot;, line 3, in &lt;module&gt;
 path.mkdir()
 File &quot;/home/kristina/anaconda3/lib/python3.7/pathlib.py&quot;, line 1230, in mkdir
 self._accessor.mkdir(self, mode)
FileNotFoundError: [Errno 2] No such file or directory: &#x27;/home/kristina/OuterDirectory/InnerDirectory&#x27;
</code></pre>
Or if <code>InnerDirectory</code> already exists:
<pre><code class="hljs">Traceback (most recent call last):
 File &quot;/home/kristina/Desktop/UNM/makesubdir.py&quot;, line 3, in &lt;module&gt;
 path.mkdir()
 File &quot;/home/kristina/anaconda3/lib/python3.7/pathlib.py&quot;, line 1230, in mkdir
 self._accessor.mkdir(self, mode)
FileExistsError: [Errno 17] File exists: &#x27;/home/kristina/OuterDirectory/InnerDirectory&#x27;
</code></pre>
If a directory already exists, the raised error will be <code>FileExistsError</code>, and if the parent doesn't exist, the <code>FileNotFoundError</code> will be raised.
Since we don't want our program breaking whenever it encounters an error like this, we'll place this code in a try block:
<pre><code class="hljs">from pathlib import Path 
path = Path(&quot;/home/kristina/OuterDirectory/InnerDir&quot;) 
try:
 path.mkdir() 
except OSError:
 print(&quot;Failed to make nested directory&quot;)
else:
 print(&quot;Nested directory made&quot;)
</code></pre>
When run, if the directory is successfully made, the output will be:
<pre><code class="hljs">Nested directory made
</code></pre>
If we run into errors, the following will be outputted:
<pre><code class="hljs">Failed to make a nested directory
</code></pre>
The <code>mkdir()</code> method takes three parameters: <code>mode</code>, <code>parents</code>, and <code>exit_ok</code>.
<ul>
<li>The <code>mode</code> parameter, if given, combined with <code>umask</code> indicates which users have reading, writing, and executing privileges. By default, all users have all privileges which might not be what we want if security is an issue. We'll touch more on this later.</li>
<li><code>parents</code> indicates, in the case when the parent directory is missing, should the method: 
1. Create the missing parent directory itself (<code>true</code>) 
2. Or to raise an error, like in our second example (<code>false</code>)</li>
<li><code>exist_ok</code> specifies if the <code>FileExistsError</code> should be raised if a directory of the same name already exists. Note that this error will still be raised if the file of the same name is not a directory.</li>
</ul>
<h3 id="assigningaccessprivileges">Assigning Access Privileges</h3>
Let's make a directory called <code>SecondInnerDirectory</code> where only the owner has all reading, writing and executing privileges, inside the non-existent <code>SecondOuterDirectory</code>:
<pre><code class="hljs">from pathlib import Path
path = Path(&quot;/home/kristina/SecondOuterDirectory/SecondInnerDirectory&quot;)
path.mkdir(mode = 0o007, parents= True, exist_ok= True)
</code></pre>
This should execute without error. If we navigate to the <code>SecondOuterDirectory</code> and check it's contents from the console like so:
<pre><code class="hljs">$ ls -al
</code></pre>
We should get the output:
<pre><code class="hljs">total 12
drwxrwxr-x 3 kristina kristina 4096 dec 10 01:26 .
drwxr-xr-x 77 kristina kristina 4096 dec 10 01:26 ..
d------r-x 2 kristina kristina 4096 dec 10 01:26 SecondInnerDirectory
</code></pre>
Okay, so we can see that the parent directory was successfully made, but privileges aren't as expected. The owner lacks writing privilege.
The issue we have here is that <code>umask</code> isn't letting us create the desired privileges. To get around this, we'll save <code>umask</code>'s original value, temporarily change it, and finally, return it to its original value using the <code>umask()</code> method from the OS module. <code>umask()</code> returns the old value of <code>umask</code>.
Let's rewrite our code to test this out:
<pre><code class="hljs">from pathlib import Path
import os 

old_mask = os.umask(0) # Saving the old umask value and setting umask to 0

path = Path(&quot;/home/kristina/SecondOuterDirectory/SecondInnerDirectory&quot;)
path.mkdir(mode = 0o007, parents= True, exist_ok= True)

os.umask(old_mask) # Reverting umask value
</code></pre>
Executing this code, and using the <code>ls -al</code> command again will result in the following output:
<pre><code class="hljs">total 12
drwxrwxrwx 3 kristina kristina 4096 dec 10 01:45 . 
drwxr-xr-x 77 kristina kristina 4096 dec 10 01:45 ..
d------rwx 2 kristina kristina 4096 dec 10 01:45 SecondInnerDirectory
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In order to safely manipulate files on many different systems, we need a robust way to handle errors such as data races. Python offers great support for this through the <code>pathlib</code> module.
Errors can always occur when working with file systems, and the best way to deal with this is by carefully setting up systems to catch all errors that can potentially crash our program or cause other issues. Writing clean code makes for durable programs.

Kristina Popovic

In this tutorial, we'll go over examples on how to safely create a nested directory in Python 3.5+, as well as older versions.

Python: Safely Create Nested Directory

<h2 id="introduction">Introduction</h2>
In this article we'll be taking a look at Global and Non-Local Variables in Python and how you to use them to avoid issues when writing code.
We'll be starting off with a brief primer on variable scopes before we launch into the how and why of using global and non-local variables in your own functions.
<h2 id="scopesinpython">Scopes in Python</h2>
Before we can get started, we first have to touch on scopes. For those of you who are less familiar, &quot;scope&quot; refers to the context in which a variable is defined and how it can be accessed or altered or more specifically - from where it can be accessed.
<blockquote>
And in programming, like in life, context is important.
</blockquote>
By referencing Python right now, you can infer from context that I am referring to the programming language. In another context however, Python could be a reference to a snake, or a comedic group.
Global and local scopes are how your program understands the context of the variable that you are referencing.
As a rule, variables defined within a function or class (as an instance variable) are local by default, and those outside of functions and classes are global by default.
<h2 id="localvariablesinpython">Local Variables in Python</h2>
With that understood, let's see it in action. We'll start by defining a function with it's own local variable inside. In this function we have the variable <code>fruit</code>, which we initialize as a list and print:
<pre><code class="hljs">def shopping_list():
 fruit = [&#x27;apple&#x27;, &#x27;banana&#x27;]
 print(fruit)
 
shopping_list()
</code></pre>
And as expected, this works like a charm:
<pre><code class="hljs">[&#x27;apple&#x27;, &#x27;banana&#x27;]
</code></pre>
But what happens when we move the print statement outside of the function?
<pre><code class="hljs">def shopping_list():
 fruit = [&#x27;apple&#x27;, &#x27;banana&#x27;]
 
shopping_list()
print(fruit)
</code></pre>
We get an error&quot;
<pre><code class="hljs">Traceback (most recent call last):
 File &quot;&lt;string&gt;&quot;, line 5, in &lt;module&gt;
NameError: name &#x27;fruit&#x27; is not defined
</code></pre>
Specifically a <code>NameError</code>, as the fruit was defined locally and therefore remains confined to that context. 
In order for our program to understand the variable globally (outside of the function), we need to define it globally.
<h2 id="globalvariablesinpython">Global Variables in Python</h2>
What if instead of initially defining our variable within the function, we move it outside and initialize it there?
In this case, we can reference it outside of the function and everything works.
But if we try to redefine the fruit variable inside <code>shopping_list</code>, those changes won't update to the original global variable, instead being isolated locally:
<pre><code class="hljs">fruit = [&#x27;apple&#x27;, &#x27;banana&#x27;]

def shopping_list():
 fruit = [&#x27;apple&#x27;, &#x27;banana&#x27;, &#x27;grapes&#x27;]

shopping_list()
print(fruit)
</code></pre>
Output:
<pre><code class="hljs">['apple', 'banana']
</code></pre>
This is because the <code>fruit</code> we've modified in the <code>shopping_list()</code> function is a new, local variable. We've created it, assigned a value to it, and done nothing after that. It's effectively fully redundant code. The <code>print()</code> statement prints the value of the global variable that's in scope for it.
<h3 id="theglobalkeyword">The global Keyword</h3>
If we want those changes to be reflected in our global variable, instead of making a new local one, all we have to do is add the <code>global</code> keyword. This allows us to communicate that the <code>fruit</code> variable is indeed a global variable:
<pre><code class="hljs">fruit = [&#x27;pineapple&#x27;, &#x27;grapes&#x27;]

def shopping_list():
 global fruit
 fruit = [&#x27;pineapple&#x27;, &#x27;grapes&#x27;, &#x27;apple&#x27;, &#x27;banana&#x27;]

shopping_list()
print(fruit)
</code></pre>
And sure enough, the global variable is modified with the new values, so one we call <code>print(fruit)</code>, the new values are printed:
<pre><code class="hljs">[&#x27;pineapple&#x27;, &#x27;grapes&#x27;, &#x27;apple&#x27;, &#x27;banana&#x27;]
</code></pre>
By defining the context of the fruit variable we're referring to as the global one, we can then redefine and alter it to our hearts content knowing that the changes we make within the function will be carried over.
We could also define a global variable within our function and have it be able to be referenced and accessed anywhere else.
<pre><code class="hljs">def shopping_list():
 global fruit
 fruit = [&#x27;pineapple&#x27;, &#x27;grapes&#x27;, &#x27;apple&#x27;, &#x27;banana&#x27;]


shopping_list()
print(fruit)
</code></pre>
This would output:
<pre><code class="hljs">[&#x27;pineapple&#x27;, &#x27;grapes&#x27;, &#x27;apple&#x27;, &#x27;banana&#x27;]
</code></pre>
We could even declare a global variable within one function and access it in another without specifying it as global in the second one:
<pre><code class="hljs">def shopping_list():
 global fruit
 fruit = [&#x27;pineapple&#x27;, &#x27;grapes&#x27;, &#x27;apple&#x27;, &#x27;banana&#x27;]

def print_list():
 print(fruit)
 
shopping_list()
print(fruit)
print_list()
</code></pre>
This results in:
<pre><code class="hljs">[&#x27;pineapple&#x27;, &#x27;grapes&#x27;, &#x27;apple&#x27;, &#x27;banana&#x27;]
[&#x27;pineapple&#x27;, &#x27;grapes&#x27;, &#x27;apple&#x27;, &#x27;banana&#x27;]
</code></pre>
<h3 id="cautionwhenusingglobalvariables">Caution when Using Global Variables</h3>
While being able to modify a global variable locally is a handy little tool to have, you have to treat it with a fair bit of caution. Overzealous rewriting and overriding of scope is a recipe for disaster that ends with bugs and unexpected behavior.
It's always important to make sure that you are manipulating a variable only in the context you need it, and otherwise leaving it alone, this is the main drive behind the principle of encapsulation.
We'll take a quick look at an example of a potential issue before we move on to some of the ways that global variables can be useful in your own code:
<pre><code class="hljs">fruit = [&#x27;pineapple&#x27;, &#x27;grapes&#x27;, &#x27;apple&#x27;, &#x27;banana&#x27;]

def first_item():
 global fruit
 fruit = fruit[0]
 
def iterate():
 global fruit
 for entry in fruit:
 print(entry)
 
iterate()
print(fruit)
first_item()
print(fruit)
</code></pre>
Running the code above, we get the following output:
<pre><code class="hljs">pineapple
grapes
apple
banana
[&#x27;pineapple&#x27;, &#x27;grapes&#x27;, &#x27;apple&#x27;, &#x27;banana&#x27;]
pineapple
</code></pre>
In this example we reference the variable in both functions, <code>first_item()</code> and <code>iterate()</code>. Everything seems works fine if we call <code>iterate()</code> and then <code>first_item()</code>.
If we reverse that order or attempt to iterate after, we run into a big issue:
<pre><code class="hljs">first_item()
print(fruit)
iterate()
print(fruit)
</code></pre>
This now outputs:
<pre><code class="hljs">pineapple
p
i
n
e
a
p
p
l
e
pineapple
</code></pre>
Namely, <code>fruit</code> is now a string that will be iterated through. What's worse is that this bug won't present itself until it's presumably too late. The first code ran seemingly fine.
Now, this problem is obvious on purpose. We tampered with a global variable directly - lo and behold, it's changed. However, in more complex structures, one might accidentally take global variable modification a step too far and get unexpected results.
<h2 id="thenonlocalkeyword">The nonlocal Keyword</h2>
Just because you need to be cautious doesn't mean that global variables aren't also incredibly useful. Global variables can be helpful whenever you want to update a variable without providing it in the return statement, like a counter. They are also very handy with nested functions.
For those of you using Python 3+, you can make use of <code>nonlocal</code>, a keyword which functions very similarly to <code>global</code>, but primarily takes effect when nested in methods. <code>nonlocal</code> essentially forms an in-between of global and local scope.
Since we've been using shopping lists and fruits for most of our examples, we could think of a checkout function that adds up the total of the purchases:
<pre><code class="hljs">def shopping_bill(promo=False):
 items_prices = [10, 5, 20, 2, 8]
 pct_off = 0

 def half_off():
 nonlocal pct_off
 pct_off = .50

 if promo:
 half_off()

 total = sum(items_prices) - (sum(items_prices) * pct_off)
 print(total)
 
shopping_bill(True)
</code></pre>
Running the code above, we get the output:
<pre><code class="hljs">22.5
</code></pre>
This way the global count variable is still local to the outer function, and will not impair (or exist) at a higher level. This gives you some latitude in adding modifiers to your functions.
You can always confirm this by trying to print <code>pct_off</code> outside of the shopping bill method:
<pre><code class="hljs">NameError: name &#x27;pct_off&#x27; is not defined
</code></pre>
If we had used the <code>global</code> keyword instead of the <code>nonlocal</code> keyword, printing <code>pct_off</code> would result in:
<pre><code class="hljs">0.5
</code></pre>
<h2 id="conclusion">Conclusion</h2>
At the end of the day, global (and nonlocal) keywords are a tool, and when used properly can open up a lot of possibilities for your code. I personally use both of these keywords rather frequently in my own code, and with enough practice you'll come to see how powerful and useful they really can be.
As always, thank you so much for reading and Happy Hacking!

Guest Contributor

In this tutorial, we'll go over how to use global and nonlocal variables in Python functions. We'll cover good practices and what to look out for, with examples.

How to Use Global and Nonlocal Variables in Python

<h2 id="introduction">Introduction</h2>
An object in JavaScript is a collection of key-value pairs. One of these key-value pairs is called an object property. Both keys and values of properties can be of any data type - Number, String, Array, Object, etc.
For example:
<pre><code class="hljs">const dog = {
 name: &quot;Sandy&quot;,
 age: 3,
 emoji: &quot;🐶&quot;
}
</code></pre>
Here, <code>name: &quot;Sandy&quot;</code>, <code>age: 3</code>, and <code>emoji: &quot;🐶&quot;</code> are the properties of a dog object.
In this article, we will look at a few ways to remove a property from an Object and compare them to understand which method is appropriate in a given context.
<h2 id="removeapropertyfromanobject">Remove a Property From an Object</h2>
<h3 id="thedeleteoperator">The delete Operator</h3>
The semantically correct way to delete a property from an object is the <code>delete</code> operator. Let's see it in action:
<pre><code class="hljs">const student = {
 name: &quot;Jane&quot;,
 age: 16,
 score: {
 maths: 95,
 science: 90
 }
}

// Deleting a property from an object
delete student.age
delete student[&quot;score&quot;]

console.log(student) // {name: &quot;Jane&quot;}
</code></pre>
In the example above, the <code>delete</code> operator is used to remove the <code>name</code> and <code>score</code> properties from the <code>student</code> object.
Trying to access any of the deleted properties will return <code>undefined</code>:
<pre><code class="hljs">console.log(student.age) // undefined
</code></pre>
Also, the <code>delete</code> operator returns a boolean value which signifies if the deletion was successful:
<pre><code class="hljs">if (delete student.age) {
 console.log(&quot;Removed &#x27;age&#x27; property from student&quot;);
} else {
 console.log(&quot;Failed to remove &#x27;age&#x27; property, perhaps it doesn&#x27;t exist?&quot;);
}
</code></pre>
If we run this code, since the property is already deleted, we're greeted with:
<pre><code class="hljs">Failed to remove &#x27;age&#x27; property, perhaps it doesn&#x27;t exist?
</code></pre>
<h3 id="newobjectwithouttheproperty">New Object Without the Property</h3>
If we don't want to modify an object in-place, but also want a version of it without a specific property, we can just generate another object with all the same properties but the one.
In cases when we know the name of the property we want to remove, we can just use object destructuring to unpack the object into 2 parts:
<ol>
<li>The property we want to remove</li>
<li>An object that represents the rest of the object</li>
</ol>
<pre><code class="hljs">const car = {
 brand: &quot;Ford&quot;,
 color: &quot;blue&quot;,
 yearOfManufacturing: 2019
}

const {yearOfManufacturing, ...rest} = car;

console.log(rest); // {brand: &quot;Ford&quot;, color: &quot;blue&quot;}
</code></pre>
However, if we don't know the exact name of the property we want to remove, we'll need to make a filter that will check if a property meets the deletion criteria.
For example, let's remove all properties that have a numeric value:
<pre><code class="hljs">const developer = {
 name : &quot;Fred&quot;,
 dailyCoffeIntake : 2,
 favoriteLanguage : &quot;Haskell&quot;,
 age : 27
};

const keysToKeep = Object.keys(developer).filter(
 (key)=&gt; {
 return !Number.isInteger(developer[key])
});

const newDeveloper = {};
keysToKeep.forEach((key)=&gt;{
 newDeveloper[key] = developer[key]
});

console.log(newDeveloper); // {name: &quot;Fred&quot;, favoriteLanguage: &quot;Haskell&quot;}
</code></pre>
<h3 id="thereducefunction">The reduce() Function</h3>
Alternatively we can use the <code>reduce()</code> method, which is a built-in array method which takes a collection and a reduction function as an argument.
The function then iterates through all elements in the collection and modifies the accumulator (which you can think of as a temporary result for every step) and returns it. Let's see this method in action:
<pre><code class="hljs">const dog = {
 name: &quot;Sandy&quot;,
 age: 3,
 emoji: &quot;🐶&quot;
}

const newDog = Object.keys(dog).reduce((accumulator, key) =&gt; {
 // Copy all except emoji
 if(key !== &quot;emoji&quot;){
 accumulator[key] = dog[key]
 }
 return accumulator
}, {})

console.log(newDog) // {name: &quot;Sandy&quot;, age: 3}
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we have seen how to remove a property from an object in a few ways. We have seen that using <code>delete</code> will mutate the object. So, we have discussed a couple ways - the <code>...rest</code> syntax and <code>reduce()</code> method, to remove a property from an object without mutating it.

Abhilash Kakumanu

In this tutorial, we'll go over how to remove a property from a JavaScript object. We'll cover the delete operator, as well as the {...rest} syntax and reduce() method.

JavaScript: Remove a Property From an Object

JavaScript: Remove a Property from an Object

<h2 id="introduction">Introduction</h2>
In English, it's essential to capitalize the first letter of a sentence. JavaScript has built-in methods to help us with this.
In this article we will look at three different ways to check if the first letter of a string is upper case and how to capitalize it.
<h2 id="checkiffirstletterisuppercaseinjavascript">Check if First Letter Is Upper Case in JavaScript</h2>
We can check if the first of a letter a string is upper case in a few ways. Let's take a look at some popular ones.
<h3 id="touppercase">toUpperCase()</h3>
This is a built-in string method that returns the invoked string with only upper case characters:
<pre><code class="hljs">function startsWithCapital(word){
 return word.charAt(0) === word.charAt(0).toUpperCase()
}

console.log(startsWithCapital(&quot;Hello&quot;)) // true
console.log(startsWithCapital(&quot;hello&quot;)) // false
</code></pre>
Here, we're making a single character string consisting of only the first letter/character of the provided string and comparing it to its upper case version. If they match, the original letter is uppercase.
Note: <code>string.charAt(index)</code> is preferred over <code>string[index]</code> (bracket notation). This is because <code>&quot;&quot;.charAt(0)</code> returns an empty string whereas <code>&quot;&quot;[0]</code> returns <code>undefined</code>.
This removes the need to check if a variable is <code>undefined</code>, and avoids exceptional states in your code.
<h3 id="charcodeat">charCodeAt()</h3>
Every character of a string is represented by a unique number using UTF-16 character encoding. For English capital letters: A = 65 and Z = 90. If the first letter's character code falls in this range, we know it's upper case:
<pre><code class="hljs">function startsWithCapital(word){
 return word.charCodeAt(0) &gt;= 65 &amp;&amp; word.charCodeAt(0) &lt;= 90
}

console.log(startsWithCapital(&quot;This is working!&quot;)) // true
console.log(startsWithCapital(&quot;checking!&quot;)) // false
</code></pre>
<h3 id="test">test()</h3>
Alternatively, we can check for a match between a regular expression and a specified string. This is easily achieved with the <code>test()</code> function.
Let's take a look at an example:
<pre><code class="hljs">function startsWithCapital(word){
 return /[A-Z]/.test(word.charAt(0))
}

console.log(startsWithCapital(&quot;Capital letters&quot;)) // true
console.log(startsWithCapital(&quot;is this true?&quot;)) // false
</code></pre>
Here, <code>/[A-Z]/</code> represents all capital English letters (A to Z). We are checking whether the first letter of the string matches any of them.
<h2 id="capitalizingthefirstletter">Capitalizing the First Letter</h2>
If we found out that the first letter of the string is lower case, and if we want to capitalize it, we can do that using following method:
<pre><code class="hljs">function capitalizeFirstLetter(word){
 return word.charAt(0).toUpperCase() + word.slice(1)
}

console.log(capitalize(&quot;hello world!&quot;)) // Hello world
</code></pre>
Here, we take the first character and convert it to upper case. Then, we concatenate the rest of the string to that capitalized letter. This is done via the <code>slice()</code> function, where we've specified the starting index as <code>1</code>. Since it's 0-based, we've skipped the first letter.
<h2 id="conclusion">Conclusion</h2>
In this article, we have looked at a few ways to check if the first letter of a string is upper case and how to capitalize the first letter of a string.

In this tutorial, we'll go over examples of how to check if a string starts with a capital letter in JavaScript. We'll use a few approaches and discuss good practices.

JavaScript: Check if First Letter of a String Is Upper Case

JavaScript: Check if First Letter of a String is Upper Case

In this tutorial, we'll cover everything you need to know from basic to advanced usage of Heatmaps in Seaborn and Python. 

Ultimate Guide to Heatmaps in Seaborn with Python

<h2 id="introduction">Introduction</h2>
Comparison operators are used in logical statements to determine whether two variables or objects are equal by some already set or custom defined criteria. If the two variables or objects are deduced to be equal the operator returns <code>true</code>, and <code>false</code> if they aren't.
Comparison operators in JavaScript are:
<ul>
<li><code>&lt;</code> - less than</li>
<li><code>&gt;</code> - greater than</li>
<li><code>&lt;=</code> - less or equal than</li>
<li><code>&gt;=</code> - greater or equal than</li>
<li><code>==</code> and <code>===</code> - equal to (loose and strict equality operator)</li>
<li><code>!=</code> and <code>!==</code> - not equal to (loose and strict inequality operator)</li>
</ul>
JavaScript is interesting because it's got two visually very similar, but in practice very different comparison operators for equality: <code>==</code> and <code>===</code>.
In this article, we will explain the differences between loose and strict equality operators and go over some examples of their usage.
<h2 id="looseequalityoperatorinjavascript">Loose Equality Operator in JavaScript (==)</h2>
Double equals in JavaScript are testing for loose equality. This permits the JavaScript engine to try and cast these expressions to a common type. Meaning that the expressions don't necessarily need to be of the same type.
The process of converting a value from one type to another is called type coercion. Type coercion can be explicit and implicit.
Explicit type coercion is, as its name implies, done explicitly in code by a programmer, using the built-in methods that JavaScript provides (<code>Number()</code>, <code>String()</code>, <code>Boolean()</code>...).
For example:
<pre><code class="hljs">// This would result in x being a number 42
let x = Number(&quot;42&quot;);

// Similarly,this would result in y being cast to the boolean value false 
let y = Boolean(0);
</code></pre>
Implicit type coercion is, on the other hand, done implicitly by JavaScript. This coercion type is usually done when we use operators on different types, but can be reasonably &quot;matched&quot; by one of them, for example:
<pre><code class="hljs">// x is going to be cast to the string &quot;1&quot;.
let x = 1 + &quot;&quot;; 
</code></pre>
To explain this example, let's look at it from a JavaScript engine's perspective:
<blockquote>
The expression should be evaluated and assigned to <code>x</code>. The first number is <code>1</code> and has <code>+</code> operator beside it. This implies integer addition with the next number. However, there's an empty string, <code>&quot;&quot;</code>, there. This can't be converted into a number. However, we can also concatenate strings with <code>+</code>, so let's match them as strings and perform concatenation. Finally, the result is returned and assigned to <code>x</code>.
</blockquote>
To sum up, the JavaScript engine tries to convert both values to a type that supports 
the <code>+</code> operator, which in this case is a string.
<pre><code class="hljs">/* In this case, the JS engine deduces that both the operands and the result have to be cast to an integer because it&#x27;s the only type that has a defined subtraction operation (-) */

let y = &quot;5&quot; - &quot;2&quot;;

// Because booleans don&#x27;t have a + operation, the JS engine converts both true values into 1&#x27;s

let z = true + true;
</code></pre>
Now, it's exactly this type of coercion that the <code>==</code> operator uses to check for equality. Let's go over some examples of loose equality operator usage, in the Node REPL:
<pre><code class="hljs">&gt; 42 == &quot;42&quot;
true
&gt; &quot;42&quot; == &#x27;42&#x27;
true
</code></pre>
<code>42</code>, <code>&quot;42&quot;</code> and <code>'42'</code> are all matched into the same data type, and are all loosely equal, returning <code>true</code> in the comparisons.
Booleans follow the same principle:
<pre><code class="hljs">&gt; true == 1
true
&gt; true + true == 2
true
&gt; false == 0
true
&gt; false + true == 1
true
</code></pre>
<code>true</code> is <code>1</code> and <code>false</code> is <code>0</code>. We can implicitly convert these into integers by adding them.
Finally, here's an example of an (unreadable) but syntactically valid comparison:
<pre><code class="hljs">&gt; (&quot;42&quot; == &#x27;42&#x27;) + (42 == &quot;42&quot;) == 2
true
</code></pre>
<code>&quot;42&quot; == '42'</code> is evaluated as <code>true</code>, as well as <code>42 == &quot;42&quot;</code>. The other side of the expression is also <code>true</code>, so we ended up with <code>true + true</code>, which is implicitly converted into <code>1+1</code> because of the <code>+</code> sign. That's obviously <code>==</code> to <code>2</code>, so the overall expression returns <code>true</code>.
<h2 id="falsyvaluecomparisoninjavascript">Falsy Value Comparison in JavaScript</h2>
A falsy value is a variable which evaluates to <code>false</code>. In JavaScript, there are seven falsy values - <code>false</code>, <code>0</code>, <code>&quot;&quot;</code>, <code>[]</code>, <code>null</code>, <code>undefined</code>, <code>NaN</code>.
There are a couple of simple rules when it comes to using the double equals operator on falsy values:
<ul>
<li><code>false</code>, <code>0</code> and <code>&quot;&quot;</code> are equivalent</li>
<li><code>undefined</code> and <code>null</code> return <code>true</code> when compared to themselves or each other, and <code>false</code> when compared to anything else</li>
<li><code>NaN</code> compared to anything (even another <code>NaN</code>) returns <code>false</code></li>
</ul>
So, these would all be <code>true</code>:
<pre><code class="hljs">&gt; false == 0;
true
&gt; false == &quot;&quot;;
true
&gt; 0 == &quot;&quot;;
true
&gt; undefined == null;
true
&gt; undefined == undefined;
true
&gt; null == null;
true
&gt; [] == false;
true
&gt; [] == 0;
true
</code></pre>
While these would all be <code>false</code>:
<pre><code class="hljs">&gt; undefined == false;
false
&gt; 0 == null;
false
&gt; null == true
false
&gt; NaN == false;
false
&gt; NaN == NaN;
false
</code></pre>
<h2 id="strictequalityoperatorinjavascript">Strict Equality Operator in JavaScript (===)</h2>
Triple equals in JavaScript stands for strict equality. This means that, unlike the loose equality operator we talked about before, there is no implicit conversion. Meaning the output won't be <code>true</code> unless both the type and values of the two expressions match. They aren't matched on type anymore.
Now, let's have a look at some strict equality operator examples:
<pre><code class="hljs">&gt; true === true
true
&gt; true === 1
false
&gt; false === 0
false
</code></pre>
This example produces <code>true</code> in the first case because both the type (boolean) and value (<code>true</code>) are equal. In the other two cases, it returns <code>false</code>, because although the values are the same, the types don't match. We're comparing a boolean to an integer.
<pre><code class="hljs">&gt; 42 === 42
true
&gt; 42 === &quot;42&quot;
false
</code></pre>
Here, both the number and value are equal in the first example, resulting in <code>true</code>, while the value and type mismatch in the second example, resulting in <code>false</code>.
<h2 id="conclusion">Conclusion</h2>
In this article we explained the difference between the loose equality operator and the strict equality operator in JavaScript. 
We also explained what type coercion was, and the concept of explicit and implicit type coercion.
You may have noticed that implicit type coercion that occurs when we use the loose equality operator in JavaScript can be pretty unpredictable an <a rel="nofollow noopener" raget ="_blank" href ="http://www.jsfuck.com/">counter-intuitive</a>. This is why, if you're not very experienced with JavaScript, it is usually better to stick to the strict equality operator when checking whether or not the two expressions are equal.
By using the strict equality operator you are testing both the type and value, and you can therefore be sure to always execute a true equality test.

In this tutorial, we'll go over the difference between the loose == and strict === equality operators in JavaScript with examples.

JavaScript: == vs === Operator

<h2 id="introduction">Introduction</h2>
In Python, every object instance comes pre-built with standard functions and attributes. For example, Python uses a dictionary to store an object's instance attributes. This has many benefits, like allowing us to add new attributes at runtime. However, this convenience comes at a cost.
Dictionaries can consume a fair chunk of memory, especially if we have many instance objects with a large number of attributes. If the performance and memory efficiency of code are critical, we can trade the convenience of dictionaries for <code>__slots__</code>.
In this tutorial, we will look at what <code>__slots__</code> are and how to use them in Python. We'll also discuss the tradeoffs for using <code>__slots__</code>, and look at their performance when compared to typical classes that store their instance attributes with dictionaries.
<h2 id="whatare_slots_andhowtousethem">What Are _slots_ and How to Use Them?</h2>
Slots are class variables that can be assigned a string, an iterable, or a sequence of strings of the instance variable names. When using slots, you name an object's instance variables up front, losing the ability to add them dynamically.
An object instance using slots does not have a built-in dictionary. As a result, more space is saved and accessing attributes is faster.
Let's see it in action. Consider this regular class:
<pre><code class="hljs">class CharacterWithoutSlots():
 organization = &quot;Slate Rock and Gravel Company&quot;

 def __init__(self, name, location):
 self.name = name
 self.location = location

without_slots = character_without_slots(&#x27;Fred Flinstone&#x27;, &#x27;Bedrock&#x27;)
print(without_slots.__dict__) # Print the arguments
</code></pre>
In the above snippet:
<ul>
<li><code>organization</code> is a class variable</li>
<li><code>name</code> and <code>location</code> are instance variables (note the keyword <code>self</code> in front of them)</li>
</ul>
While every object instance of the class is created, a dynamic dictionary is allocated under the attribute name as <code>__dict__</code> which includes all of an object's writable attributes. The output of the above code snippet is:
<pre><code class="hljs">{&#x27;name&#x27;: &#x27;Fred Flinstone&#x27;, &#x27;location&#x27;: &#x27;Bedrock&#x27;}
</code></pre>
This can be pictorially represented as:
<img src="https://stackabuse.s3.amazonaws.com/media/using-slots-to-store-data-in-python-1.jpg" alt="Figure 1: Behavior of a Normal Class Object">
Now, let's see how we can implement this class using slots:
<pre><code class="hljs">class CharacterWithSlots():
 __slots__ = [&quot;name&quot;, &quot;location&quot;]
 organization = &quot;Slate Rock and Gravel Company&quot;

 def __init__(self, name, location):
 self.name = name
 self.location = location

with_slots = CharacterWithSlots(&#x27;Fred Flinstone&#x27;, &#x27;Bedrock&#x27;)
print(with_slots.__dict__)
</code></pre>
In the above snippet:
<ul>
<li><code>organization</code> is a class variable</li>
<li><code>name</code> and <code>location</code> are instance variables</li>
<li>The keyword <code>__slots__</code> is a class variable holding the list of the instance variables (<code>name</code> and <code>location</code>)</li>
</ul>
Running that code will give us this error:
<pre><code class="hljs">Traceback (most recent call last):
 File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
AttributeError: &#x27;character_without_slots&#x27; object has no attribute &#x27;__dict__&#x27;
</code></pre>
That's right! Object instances of classes with slots do not have a <code>__dict__</code> attribute. Behind the scenes, instead of storing the instance variables in a dictionary, the values are mapped with the index locations as shown in the figure below:
<img src="https://stackabuse.s3.amazonaws.com/media/using-slots-to-store-data-in-python-2.jpg" alt="Figure 2: Behavior of a Class Object with ">
While there's no <code>__dict__</code> attribute, you still access the object properties as you would typically do:
<pre><code class="hljs">print(with_slots.name) # Fred Flinstone
print(with_slots.location) # Bedrock
print(with_slots.organization) # Slate Rock and Gravel Company
</code></pre>
Slots were created purely for performance improvements as stated by Guido in his <a href="http://python-history.blogspot.com/2010/06/inside-story-on-new-style-classes.html" rel="nofollow noopener" target="_blank">authoritative blog post</a>.
Let's see if they outperform standard classes.
<h2 id="efficiencyandvelocityofslots">Efficiency and Velocity of Slots</h2>
We are going to compare objects instantiated with slots to objects instantiated with dictionaries with two tests. Our first test will look at how they allocate memory. Our second test will look at their runtimes.
This benchmarking for memory and runtime is done on Python 3.8.5 using the modules <code>tracemalloc</code> for memory allocation tracing and <code>timeit</code> for the runtime evaluation.
Results may vary on your personal computer:
<pre><code class="hljs">import tracemalloc
import timeit

# The following `Benchmark` class benchmarks the
# memory consumed by the objects with and without slots
class Benchmark:
 def __enter__(self):
 self.allocated_memory = None
 tracemalloc.start()
 return self

 def __exit__(self, exec_type, exec_value, exec_traceback):
 present, _ = tracemalloc.get_traced_memory()
 tracemalloc.stop()
 self.allocated_memory = present


# The class under evaluation. The following class
# has no slots initialized
class CharacterWithoutSlots():
 organization = &quot;Slate Rock and Gravel Company&quot;

 def __init__(self, name, location):
 self.name = name
 self.location = location


# The class under evaluation. The following class
# has slots initialized as a class variable
class CharacterWithSlots():
 __slots__ = [&quot;name&quot;, &quot;location&quot;]
 organization = &quot;Slate Rock and Gravel Company&quot;

 def __init__(self, name, location):
 self.name = name
 self.location = location


# The following `calculate_memory` function creates the object for the
# evaluated `class_` argument corresponding to the class and finds the
# memory used
def calculate_memory(class_, number_of_times):
 with Benchmark() as b:
 _ = [class_(&quot;Barney&quot;, &quot;Bedrock&quot;) for x in range(number_of_times)]
 return b.allocated_memory / (1024 * 1024)


# The following `calculate_runtime` function creates the object for the
# evaluated `class_` argument corresponding to the class and finds the
# runtime involved
def calculate_runtime(class_, number_of_times):
 timer = timeit.Timer(&quot;instance.name; instance.location&quot;,
 setup=&quot;instance = class_(&#x27;Barney&#x27;, &#x27;Bedrock&#x27;)&quot;,
 globals={&#x27;class_&#x27;: class_})
 return timer.timeit(number=number_of_times)


if __name__ == &quot;__main__&quot;:
 number_of_runs = 100000 # Alter the number of runs for the class here

 without_slots_bytes = calculate_memory(
 CharacterWithoutSlots, number_of_runs)
 print(f&quot;Without slots Memory Usage: {without_slots_bytes} MiB&quot;)

 with_slots_bytes = calculate_memory(CharacterWithSlots, number_of_runs)
 print(f&quot;With slots Memory Usage: {with_slots_bytes} MiB&quot;)

 without_slots_seconds = calculate_runtime(
 CharacterWithoutSlots, number_of_runs)
 print(f&quot;Without slots Runtime: {without_slots_seconds} seconds&quot;)

 with_slots_seconds = calculate_runtime(
 CharacterWithSlots, number_of_runs)
 print(f&quot;With slots Runtime: {with_slots_seconds} seconds&quot;)
</code></pre>
In the above snippet, the <code>calculate_memory()</code> function determines the allocated memory, and the <code>calculate_runtime()</code> function determines the runtime evaluation of the class with slots vs the class without slots.
The results will look something along these lines:
<pre><code class="hljs">Without slots Memory Usage: 15.283058166503906 MiB
With slots Memory Usage: 5.3642578125 MiB
Without slots Runtime: 0.0068232000012358185 seconds
With slots Runtime: 0.006200600000738632 seconds
</code></pre>
It's evident that using <code>__slots__</code> gives an edge over using dictionaries in size and speed. While the speed difference is not particularly noticeable, the size difference is significant.
<h2 id="gotchasusingslots">Gotchas Using Slots</h2>
Before you jump into using slots in all of your classes, there are a few caveats to be mindful of:
<ol>
<li>It can only store attributes defined in the <code>__slots__</code> class variable. For example, in the following snippet when we try to set an attribute for an instance that is not present in the <code>__slots__</code> variable, we get an <code>AttributeError</code>:</li>
</ol>
<pre><code class="hljs">class character_with_slots():
 __slots__ = [&quot;name&quot;, &quot;location&quot;]
 organization = &quot;Slate Rock and Gravel Company&quot;

 def __init__(self, name, location):
 self.name = name
 self.location = location

with_slots = character_with_slots(&#x27;Fred Flinstone&#x27;, &#x27;Bedrock&#x27;)
with_slots.pet = &quot;dino&quot;
</code></pre>
Output:
<pre><code class="hljs">Traceback (most recent call last):
 File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
AttributeError: &#x27;character_with_slots&#x27; object has no attribute &#x27;pet&#x27;
</code></pre>
With slots, you need to know all the attributes present in the class and define them in the <code>__slots__</code> variable.
<ol start="2">
<li>Sub-classes will not follow the <code>__slots__</code> assignment in the superclass. Let's say your base class has the <code>__slots__</code> attribute assigned and this is inherited to a subclass, the subclass will have a <code>__dict__</code> attribute by default.</li>
</ol>
Consider the following snippet where the object of the subclass is checked if its directory contains the <code>__dict__</code> attribute and the output turns out to be <code>True</code>:
<pre><code class="hljs">class CharacterWithSlots():
 __slots__ = [&quot;name&quot;, &quot;location&quot;]
 organization = &quot;Slate Rock and Gravel Company&quot;

 def __init__(self, name, location):
 self.name = name
 self.location = location


class SubCharacterWithSlots(CharacterWithSlots):
 def __init__(self, name, location):
 self.name = name
 self.location = location

sub_object = SubCharacterWithSlots(&quot;Barney&quot;, &quot;Bedrock&quot;)

print(&#x27;__dict__&#x27; in dir(sub_object))
</code></pre>
Output:
<pre><code class="hljs">True
</code></pre>
This can be averted by declaring the <code>__slots__</code> variable one more time for the subclass for all the instance variables present in the subclass. Although this seems redundant, the effort can be weighed against the amount of memory saved:
<pre><code class="hljs">class CharacterWithSlots():
 __slots__ = [&quot;name&quot;, &quot;location&quot;]
 organization = &quot;Slate Rock and Gravel Company&quot;

 def __init__(self, name, location):
 self.name = name
 self.location = location

class SubCharacterWithSlots(CharacterWithSlots):
 __slots__ = [&quot;name&quot;, &quot;location&quot;, &quot;age&quot;]

 def __init__(self, name, location):
 self.name = name
 self.location = location
 self.age = 40

sub_object = SubCharacterWithSlots(&quot;Barney&quot;, &quot;Bedrock&quot;)

print(&#x27;__dict__&#x27; in dir(sub_object))
</code></pre>
Output:
<pre><code class="hljs">False
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we have learned the basics about the <code>__slots__</code> attribute, and how classes with slots differ from classes with dictionaries. We also benchmarked those two classes with slots being significantly more memory efficient. Finally, we discussed some known caveats with using slots in classes.
If used in the right places, <code>__slots__</code> can boost performance and optimize the code in making it more memory efficient.

Sathiya Sarathi Gunasekaran

In this tutorial, you will learn what are slots in Python. We'll discuss their memory and speed improvements as well as the tradeoffs for using them.