<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.

Marcus Sanatan

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.

Using __slots__ to Store Object Data in Python

Naazneen Jatu

In this article, we will learn how to load and export HTML table data to and from a Pandas DataFrame.

Reading and Writing HTML Tables with Pandas

Guest Contributor

In this tutorial, we'll go over how to create a confirmation dialogue in Vue.js, by making a general modal popup window and inheriting it for this purpose, with examples.

How to Create a Confirmation Dialogue in Vue.js

<h2 id="introduction">Introduction</h2>
Working with arrays in JavaScript is a common activity. Sometimes we get a variable in JavaScript that we need to be an array, but we aren't sure that it is.
Non-primitive data types in JavaScripts are all objects (functions have their own type, but they too are objects). As a result, it's not sufficient to use the <code>typeof</code> operator that's commonly used to determine a data type:
<pre><code class="hljs">let result = { subject: &#x27;Science&#x27;, marks: 97 };
let numbers = [1, 2, 3, 4, 5];

console.log(typeof result); // Object
console.log(typeof numbers); // Object
</code></pre>
In this article, we'll take a look at how to check if a given variable or value is an array or not, in JavaScript.
<h2 id="usingthearrayisarraymethod">Using the Array.isArray() Method</h2>
As the name suggests, this method can be used to identify whether the given argument is an array or not. It returns a boolean (<code>true</code>/<code>false</code>) value with the result.
For example, with the following variables the <code>Array.isArray()</code> method correctly determines if they are one or not:
<pre><code class="hljs">let result = { subject: &quot;Science&quot;, marks: 97 }; // Object
let numbers = [1, 2, 3, 4, 5]; // Array
let name = &quot;Mark&quot;; // String
let names = new Array(&quot;Jill&quot;, &quot;Jane&quot;, &quot;Jacqueline&quot;);

console.log(Array.isArray(result)); // false
console.log(Array.isArray(numbers)); // true
console.log(Array.isArray(name)); // false
console.log(Array.isArray(names)); // true
</code></pre>
<h2 id="usinganobjectsconstructorproperty">Using an Object's constructor Property</h2>
Every object has a <code>constructor</code> property (except objects created with <code>Object.create(null)</code>, an unlikely occurrence). We can compare the constructor property directly with JavaScript's constructor functions. Therefore, if we compare it with the array constructor function, we'll know if it's an array.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: A constructor function is a function that initializes an object. If you've created an object with the <code>new</code> keyword, you did so with a constructor function. For example, in <code>let myArray = new Array(1, 2)</code> the constructor function used is <code>Array()</code>.

 </div>
 </div>
 </div>
 You can use the constructor property to determine if a variable is an array:
<pre><code class="hljs">let result = { subject: &quot;Science&quot;, marks: 97 };
let numbers = [1, 2, 3, 4, 5];
let name = &quot;Mark&quot;;
let names = new Array(&quot;Jill&quot;, &quot;Jane&quot;, &quot;Jacqueline&quot;);

console.log(result.constructor === Array); // false
console.log(numbers.constructor === Array); // true
console.log(name.constructor === Array); // false
console.log(names.constructor === Array); // true
</code></pre>
<h2 id="usingtheinstanceofoperator">Using the instanceof Operator</h2>
The <code>instanceof</code> operator checks if a constructor function is found in the prototype chain of an object. If you're less familiar with JavaScript's prototypal inheritance, the operator checks if an object was created by a class, and if not, checks if the object was derived from that class.
Like the <code>typeof</code> operator, it returns a boolean value. To determine if a variable is an array, we can use <code>instanceof</code> like this:
<pre><code class="hljs">let result = { subject: &quot;Science&quot;, marks: 97 };
let numbers = [1, 2, 3, 4, 5];
let name = &quot;Mark&quot;;
let names = new Array(&quot;Jill&quot;, &quot;Jane&quot;, &quot;Jacqueline&quot;);

console.log(result instanceof Array); // false
console.log(numbers instanceof Array); // true
console.log(name instanceof Array); // false
console.log(names instanceof Array); // true
</code></pre>
<h2 id="usingtheobjectprototypecallmethod">Using the Object.prototype.call() Method</h2>
All objects in JavaScript inherit properties from the main prototype object, aptly named <code>Object.prototype</code>. A <code>toString()</code> method exists in <code>Object.prototype</code>, which is why every object has a <code>toString()</code> method of their own. The <code>toString()</code> method of <code>Object.prototype</code> displays the type of an object.
The <code>call()</code> method of objects executes a function but changes the value of <code>this</code> to the object passed in its arguments i.e. it allows an object to use a method from another object.
Therefore, we can use <code>Object.prototype.toString()</code> to print the type and then use <code>call()</code> so it's done for another object. We then compare that string value to determine if it's an array:
<pre><code class="hljs">let result = { subject: &quot;Science&quot;, marks: 97 };
let numbers = [1, 2, 3, 4, 5];
let name = &quot;Mark&quot;;
let names = new Array(&quot;Jill&quot;, &quot;Jane&quot;, &quot;Jacqueline&quot;);

console.log(Object.prototype.toString.call(result)); // [object Object]
console.log(Object.prototype.toString.call(numbers)); // [object Array]
console.log(Object.prototype.toString.call(name)); // [object String]
console.log(Object.prototype.toString.call(names)); // [object Array]

console.log(Object.prototype.toString.call(result) === &quot;[object Array]&quot;); // false
console.log(Object.prototype.toString.call(numbers) === &quot;[object Array]&quot;); // true
console.log(Object.prototype.toString.call(name) === &quot;[object Array]&quot;); // false
console.log(Object.prototype.toString.call(names) === &quot;[object Array]&quot;); // true
</code></pre>
It's unlikely that you'll use this method, but it never hurts to know more about JavaScript objects!
<h2 id="conclusion">Conclusion</h2>
In this article, we looked at a few ways in JavaScript to determine if an object is an array. The easiest method is the <code>Array.isArray()</code> method that will most likely be used in production.
However, we can always leverage the <code>instanceof</code> operator and other object properties to determine if it's an array.

In this article, we'll discuss various methods to determine whether an object is an array in JavaScript using the Arrays.isArray() method, instanceof operator, etc.

JavaScript: Check if Object is Array

Dan Nelson

In this tutorial, we'll go over how to plot Violin Plots with Seaborn. We'll go over simple and advanced customized Violin Plots with examples.

Seaborn Violin Plot - Tutorial and Examples

<h2 id="introduction">Introduction</h2>
Python is supported by many libraries which simplify data transfer over HTTP. The <code>requests</code> library is one of the most popular Python packages as it's heavily used in web scraping. It's also popular for interacting with servers! The library makes it easy to upload data in a popular format like JSON, but also makes it easy to upload files as well.
In this tutorial, we will take a look at how to upload files using Python's <code>requests</code> library. The article will start by covering the <code>requests</code> library and the <code>post()</code> function signature. Next, we will cover how to upload a single file using the <code>requests</code> package. Last but not least, we upload multiple files in one request.
<h2 id="uploadingasinglefilewithpythonsrequestslibrary">Uploading a Single File with Python's Requests Library</h2>
This tutorial covers how to send the files, we're not concerned about how they're created. To follow along, create three files called <code>my_file.txt</code>, <code>my_file_2.txt</code> and <code>my_file_3.txt</code>.
The first thing we need to do is install our the <code>request</code> library in our workspace. While not necessary, it's recommended that you install libraries in a virtual environment:
<pre><code class="hljs">$ python3 -m venv .
</code></pre>
Activate the virtual environment so that we would no longer impact the global Python installation:
<pre><code class="hljs">$ . bin/activate
</code></pre>
Now let's install the <code>requests</code> library with <code>pip</code>:
<pre><code class="hljs">$ pip install requests
</code></pre>
Create a new file called <code>single_uploader.py</code> which will store our code. In that file, let's begin by importing the <code>requests</code> library:
<pre><code class="hljs">import requests
</code></pre>
Now we're set up to upload a file! When uploading a file, we need to open the file and stream the content. After all, we can't upload a file we don't have access to. We'll do this with the <code>open()</code> function.
The <code>open()</code> function accepts two parameters: the path of the file and the <a href="/file-handling-in-python/" target="_blank">mode</a>. The path of the file can be an absolute path or a relative path to where the script is being run. If you're uploading a file in the same directory, you can just use the file's name.
The second argument, mode, will take the &quot;read binary&quot; value which is represented by <code>rb</code>. This argument tells the computer that we want to open the file in the read mode, and we wish to consume the data of the file in a binary format:
<pre><code class="hljs">test_file = open(&quot;my_file.txt&quot;, &quot;rb&quot;)
</code></pre>
Note: it's important to read the file in binary mode. The <code>requests</code> library typically determines the <code>Content-Length</code> header, which is a value in bytes. If the file is not read in bytes mode, the library may get an incorrect value for <code>Content-Length</code>, which would cause errors during file submission.
For this tutorial, we'll make requests to the free httpbin service. This API allows developers to test their HTTP requests. Let's create a variable that stores the URL we'll post our files to:
<pre><code class="hljs">test_url = &quot;http://httpbin.org/post&quot;
</code></pre>
We now have everything to make the request. We'll use the <code>post()</code> method of the <code>requests</code> library to upload the file. We need two arguments to make this work: the URL of the server and <code>files</code> property. We'll also save the response in a variable, write the following code:
<pre><code class="hljs">test_response = requests.post(test_url, files = {&quot;form_field_name&quot;: test_file})
</code></pre>
The <code>files</code> property takes a dictionary. The key is the name of the form field that accepts the file. The value is the bytes of the opened file you want to upload.
Normally to check if your <code>post()</code> method was successful we check the HTTP status code of the response. We can use the <code>ok</code> property of the response object, <code>test_url</code>. If it's true, we'll print out the response from the HTTP server, in this case, it will echo the request:
<pre><code class="hljs">if test_response.ok:
 print(&quot;Upload completed successfully!&quot;)
 print(test_response.text)
else:
 print(&quot;Something went wrong!&quot;)
</code></pre>
Let's try it out! In the terminal, execute your script with the <code>python</code> command:
<pre><code class="hljs">python single_uploader.py
</code></pre>
Your output would be similar to this:
<pre><code class="hljs">Upload completed successfully!
{
 &quot;args&quot;: {}, 
 &quot;data&quot;: &quot;&quot;, 
 &quot;files&quot;: {
 &quot;form_field_name&quot;: &quot;This is my file\nI like my file\n&quot;
 }, 
 &quot;form&quot;: {}, 
 &quot;headers&quot;: {
 &quot;Accept&quot;: &quot;*/*&quot;, 
 &quot;Accept-Encoding&quot;: &quot;gzip, deflate&quot;, 
 &quot;Content-Length&quot;: &quot;189&quot;, 
 &quot;Content-Type&quot;: &quot;multipart/form-data; boundary=53bb41eb09d784cedc62d521121269f8&quot;, 
 &quot;Host&quot;: &quot;httpbin.org&quot;, 
 &quot;User-Agent&quot;: &quot;python-requests/2.25.0&quot;, 
 &quot;X-Amzn-Trace-Id&quot;: &quot;Root=1-5fc3c190-5dea2c7633a02bcf5e654c2b&quot;
 }, 
 &quot;json&quot;: null, 
 &quot;origin&quot;: &quot;102.5.105.200&quot;, 
 &quot;url&quot;: &quot;http://httpbin.org/post&quot;
}
</code></pre>
As a sanity check, you can verify the <code>form_field_name</code> value matches what's in your file.
<h2 id="uploadingmultiplefileswithpythonsrequestslibrary">Uploading Multiple Files with Python's requests Library</h2>
Uploading multiple files using requests is quite similar to a single file, with the major difference being our use of lists. Create a new file called <code>multi_uploader.py</code> and the following setup code:
<pre><code class="hljs">import requests

test_url = &quot;http://httpbin.org/post&quot;
</code></pre>
Now create a variable called <code>test_files</code> that's a dictionary with multiple names and files:
<pre><code class="hljs">test_files = {
 &quot;test_file_1&quot;: open(&quot;my_file.txt&quot;, &quot;rb&quot;),
 &quot;test_file_2&quot;: open(&quot;my_file_2.txt&quot;, &quot;rb&quot;),
 &quot;test_file_3&quot;: open(&quot;my_file_3.txt&quot;, &quot;rb&quot;)
}
</code></pre>
Like before, the keys are the names of the form fields and the values are the files in bytes.
We can also create our files variables as a list of tuples. Each tuple contains the name of the form field accepting the file, followed by the file's contents in bytes:
<pre><code class="hljs">test_files = [(&quot;test_file_1&quot;, open(&quot;my_file.txt&quot;, &quot;rb&quot;)),
 (&quot;test_file_2&quot;, open(&quot;my_file_2.txt&quot;, &quot;rb&quot;)),
 (&quot;test_file_3&quot;, open(&quot;my_file_3.txt&quot;, &quot;rb&quot;))]
</code></pre>
Either works so choose whichever one you prefer!
Once the list of files is ready, you can send the request and check its response like before:
<pre><code class="hljs">test_response = requests.post(test_url, files = test_files)

if test_response.ok:
 print(&quot;Upload completed successfully!&quot;)
 print(test_response.text)
else:
 print(&quot;Something went wrong!&quot;)
</code></pre>
Execute this script with the <code>python</code> command:
<pre><code class="hljs">$ python multi_uploader.py
</code></pre>
You'll see this output:
<pre><code class="hljs">Upload completed successfully!
{
 &quot;args&quot;: {}, 
 &quot;data&quot;: &quot;&quot;, 
 &quot;files&quot;: {
 &quot;test_file_1&quot;: &quot;This is my file\nI like my file\n&quot;, 
 &quot;test_file_2&quot;: &quot;All your base are belong to us\n&quot;, 
 &quot;test_file_3&quot;: &quot;It&#x27;s-a me, Mario!\n&quot;
 }, 
 &quot;form&quot;: {}, 
 &quot;headers&quot;: {
 &quot;Accept&quot;: &quot;*/*&quot;, 
 &quot;Accept-Encoding&quot;: &quot;gzip, deflate&quot;, 
 &quot;Content-Length&quot;: &quot;470&quot;, 
 &quot;Content-Type&quot;: &quot;multipart/form-data; boundary=4111c551fb8c61fd14af07bd5df5bb76&quot;, 
 &quot;Host&quot;: &quot;httpbin.org&quot;, 
 &quot;User-Agent&quot;: &quot;python-requests/2.25.0&quot;, 
 &quot;X-Amzn-Trace-Id&quot;: &quot;Root=1-5fc3c744-30404a8b186cf91c7d239034&quot;
 }, 
 &quot;json&quot;: null, 
 &quot;origin&quot;: &quot;102.5.105.200&quot;, 
 &quot;url&quot;: &quot;http://httpbin.org/post&quot;
}
</code></pre>
Good job! You can upload single and multiple files with <code>requests</code>!
<h2 id="conclusion">Conclusion</h2>
In this article, we learned how to upload files in Python using the <code>requests</code> library. Where it's a single file or multiple files, only a few tweaks are needed with the <code>post()</code> method. We also verified our response to ensure that our uploads were successful.

Mohamed Echout

In this tutorial, will learn how to upload files with the Python requests library. We'll cover uploading single and many files in one request.

How to Upload Files with Python's Requests Library

How to Upload Files with Python's requests Library

<h2 id="introduction">Introduction</h2>
There are many data visualization libraries in Python, yet Matplotlib is the most popular library out of all of them. Matplotlib’s popularity is due to its reliability and utility - it's able to create both simple and complex plots with little code. You can also customize the plots in a variety of ways.
In this tutorial, we'll cover how to plot Violin Plots in Matplotlib.
<blockquote>
Violin plots are used to visualize data distributions, displaying the range, median, and distribution of the data.
</blockquote>
Violin plots show the same summary statistics as box plots, but they also include Kernel Density Estimations that represent the shape/distribution of the data.
<h2 id="importingdata">Importing Data</h2>
Before we can create a Violin plot, we will need some data to plot. We’ll be using the <a rel="nofollow noopener" target="_blank" href="https://www.kaggle.com/tklimonova/gapminder-datacamp-2007?select=gapminder_full.csv">Gapminder dataset</a>.
We’ll start by importing the libraries we need, which include Pandas and Matplotlib:
<pre><code class="hljs">import pandas as pd
import matplotlib.pyplot as plt
</code></pre>
We’ll check to make sure that there are no missing data entries and print out the head of the dataset to ensure that the data has been loaded correctly. Be sure to set the encoding type to <code>ISO-8859-1</code>:
<pre><code class="hljs">dataframe = pd.read_csv(&quot;gapminder_full.csv&quot;, error_bad_lines=False, encoding=&quot;ISO-8859-1&quot;)
print(dataframe.head())
print(dataframe.isnull().values.any())
</code></pre>
<pre><code class="hljs"> country year population continent life_exp gdp_cap
0 Afghanistan 1952 8425333 Asia 28.801 779.445314
1 Afghanistan 1957 9240934 Asia 30.332 820.853030
2 Afghanistan 1962 10267083 Asia 31.997 853.100710
3 Afghanistan 1967 11537966 Asia 34.020 836.197138
4 Afghanistan 1972 13079460 Asia 36.088 739.981106
</code></pre>
<h2 id="plottingaviolinplotinmatplotlib">Plotting a Violin Plot in Matplotlib</h2>
To create a Violin Plot in Matplotlib, we call the <code>violinplot()</code> function on either the <code>Axes</code> instance, or the PyPlot instance itself:
<pre><code class="hljs">import pandas as pd
import matplotlib.pyplot as plt

dataframe = pd.read_csv(&quot;gapminder_full.csv&quot;, error_bad_lines=False, encoding=&quot;ISO-8859-1&quot;)

population = dataframe.population
life_exp = dataframe.life_exp
gdp_cap = dataframe.gdp_cap

# Extract Figure and Axes instance
fig, ax = plt.subplots()

# Create a plot
ax.violinplot([population, life_exp, gdp_cap])

# Add title
ax.set_title(&#x27;Violin Plot&#x27;)
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-violin-plot-tutorial-and-examples-1.png" alt="matplotlib violin plot">
When we create the first plot, we can see the distribution of our data, but we will also notice some problems. Because the scale of the features are so different, it’s practically impossible the distribution of the Life expectancy and GDP columns.
For this reason, we want to plot each column on its own subplot.
We'll do a little sorting and slicing of the dataframe to make comparing the dataset columns easier. We'll group the dataframe by &quot;country&quot;, and select just the most recent/last entries for each of the countries.
We'll then sort by population and drop the entries with the largest populations (the large population outliers), so that the rest of the dataframe is in a more similar range and comparisons are easier:
<pre><code class="hljs">dataframe = dataframe.groupby(&quot;country&quot;).last()
dataframe = dataframe.sort_values(by=[&quot;population&quot;], ascending=False)
dataframe = dataframe.iloc[10:]
print(dataframe)
</code></pre>
Now, the dataframe looks something like:
<pre><code class="hljs"> year population continent life_exp gdp_cap
country
Philippines 2007 91077287 Asia 71.688 3190.481016
Vietnam 2007 85262356 Asia 74.249 2441.576404
Germany 2007 82400996 Europe 79.406 32170.374420
Egypt 2007 80264543 Africa 71.338 5581.180998
Ethiopia 2007 76511887 Africa 52.947 690.805576
... ... ... ... ... ...
Montenegro 2007 684736 Europe 74.543 9253.896111
Equatorial Guinea 2007 551201 Africa 51.579 12154.089750
Djibouti 2007 496374 Africa 54.791 2082.481567
Iceland 2007 301931 Europe 81.757 36180.789190
Sao Tome and Principe 2007 199579 Africa 65.528 1598.435089
</code></pre>
Great! Now we can create a figure and three axes objects with the <code>subplots()</code> function. Each of these axes will have a violin plot. Since we're working on a much more manageable scale now, let's also turn on the <code>showmedians</code> argument by setting it to <code>True</code>.
This will strike a horizontal line in the median of our violin plots:
<pre><code class="hljs"># Create figure with three axes
fig, (ax1, ax2, ax3) = plt.subplots(nrows=1, ncols=3)

# Plot violin plot on axes 1
ax1.violinplot(dataframe.population, showmedians=True)
ax1.set_title(&#x27;Population&#x27;)

# Plot violin plot on axes 2
ax2.violinplot(life_exp, showmedians=True)
ax2.set_title(&#x27;Life Expectancy&#x27;)

# Plot violin plot on axes 3
ax3.violinplot(gdp_cap, showmedians=True)
ax3.set_title(&#x27;GDP Per Cap&#x27;)

plt.show()
</code></pre>
Running this code now yields us:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-violin-plot-tutorial-and-examples-2.png" alt="matplotlib violin plot show medians">
Now we can get a good idea of the distribution of our data. The central horizontal line in the Violins is where the median of our data is located, and minimum and maximum values are indicated by the line positions on the Y-axis.
<h2 id="customizingviolinplotsinmatplotlib">Customizing Violin Plots in Matplotlib</h2>
Now, let's take a look at how we can customize Violin Plots.
<h3 id="addingxandyticks">Adding X and Y Ticks</h3>
As you can see, while the plots have successfully been generated, without tick labels on the X and Y-axis it can get difficult to interpret the graph. Humans interpret categorical values much more easily than numerical values.
We can customize the plot and add labels to the X-axis by using the <code>set_xticks()</code> function:
<pre><code class="hljs">fig, ax = plt.subplots()
ax.violinplot(gdp_cap, showmedians=True)
ax.set_title(&#x27;violin plot&#x27;)
ax.set_xticks([1])
ax.set_xticklabels([&quot;Country GDP&quot;,])
plt.show()
</code></pre>
This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-violin-plot-tutorial-and-examples-3.png" alt="add x and y ticks to violin plots in matplotlib">
Here, we've set the X-ticks from a range to a single one, in the middle, and added a label that's easy to interpret.
<h3 id="plottinghorizontalviolinplotinmatplotlib">Plotting Horizontal Violin Plot in Matplotlib</h3>
If we wanted to we could also change the orientation of the plot by altering the <code>vert</code> parameter. <code>vert</code> controls whether or not the plot is rendered vertically and it is set to <code>True</code> by default:
<pre><code class="hljs">fig, ax = plt.subplots()
ax.violinplot(gdp_cap, showmedians=True, vert=False)
ax.set_title(&#x27;violin plot&#x27;)
ax.set_yticks([1])
ax.set_yticklabels([&quot;Country GDP&quot;,])
ax.tick_params(axis=&#x27;y&#x27;, labelrotation = 90)
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-violin-plot-tutorial-and-examples-4.png" alt="plot horizontal violin plot in matplotlib">
Here, we've set the Y-axis tick labels and their frequency, instead of the X-axis. We've also rotated the labels by 90 degrees
<h3 id="showingdatasetmeansinviolinplots">Showing Dataset Means in Violin Plots</h3>
We have some other customization parameters available to us as well. We can choose to show means, in addition to medians, by using the <code>showmean</code> parameter.
Let’s try visualizing the means in addition to the medians:
<pre><code class="hljs">fig, (ax1, ax2, ax3) = plt.subplots(nrows=1, ncols=3)
ax1.violinplot(population, showmedians=True, showmeans=True, vert=False)
ax1.set_title(&#x27;Population&#x27;)

ax2.violinplot(life_exp, showmedians=True, showmeans=True, vert=False)
ax2.set_title(&#x27;Life Expectancy&#x27;)

ax3.violinplot(gdp_cap, showmedians=True, showmeans=True, vert=False)
ax3.set_title(&#x27;GDP Per Cap&#x27;)
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-violin-plot-tutorial-and-examples-5.png" alt="show dataset means in violin plot in matplotlib">
Though, please note that since the medians and means essentially look the same, it may become unclear which vertical line here refers to a median, and which to a mean.
<h3 id="customizingkerneldensityestimationforviolinplots">Customizing Kernel Density Estimation for Violin Plots</h3>
We can also alter how many data points the model considers when creating the Gaussian Kernel Density Estimations, by altering the <code>points</code> parameter.
The number of points considered is 100 by default. By providing the function with fewer data points to estimate from, we may get a less representative data distribution.
Let's change this number to, say, 10:
<pre><code class="hljs">fig, ax = plt.subplots()
ax.violinplot(gdp_cap, showmedians=True, points=10)
ax.set_title(&#x27;violin plot&#x27;)
ax.set_xticks([1])
ax.set_xticklabels([&quot;Country GDP&quot;,])
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-violin-plot-tutorial-and-examples-6.png" alt="customize kernel density estimation for violin plots in matplotlib">
Notice that the shape of the violin is less smooth since fewer points have been sampled.
Typically, you would want to increase the number of points used to get a better sense of the distribution. This might not always be the case, if 100 is simply enough. Lets plot a 10-point, 100-point and 500-point sampled Violin Plot:
<pre><code class="hljs">fig, (ax1, ax2, ax3) = plt.subplots(nrows=1, ncols=3)
ax1.violinplot(gdp_cap, showmedians=True, points=10)
ax1.set_title(&#x27;GDP Per Cap, 10p&#x27;)

ax2.violinplot(gdp_cap, showmedians=True, points=100)
ax2.set_title(&#x27;GDP Per Cap, 100p&#x27;)

ax3.violinplot(gdp_cap, showmedians=True, points=500)
ax3.set_title(&#x27;GDP Per Cap, 500p&#x27;)
plt.show()
</code></pre>
This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-violin-plot-tutorial-and-examples-7.png" alt="various KDE sample sizes for violin plot">
There isn't any obvious difference between the second and third plot, though, there's a significant one between the first and second.
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over several ways to plot a Violin Plot using Matplotlib and Python. We've also covered how to customize them by adding X and Y ticks, plotting horizontally, showing dataset means as well as altering the KDE point sampling.
If you're interested in Data Visualization and don't know where to start, make sure to check out our bundle of books on <a class="ebook-link" href="https://gum.co/data-visualization-in-python-book-bundle">Data Visualization in Python</a>:
<div style="border: 1px solid #ebebeb;padding: 15px;">
 <a class="ebook-link" rel="nofollow" target="_blank" href="https://gum.co/data-visualization-in-python-book-bundle" style="text-decoration: none;color: inherit;">
 <h4 style="margin-top: 10px;">Data Visualization in Python</h4>
 <div class="row">
 <div class="col-md-4 col-xs-12">
 <img class="img-responsive center-block" src="https://s3.stackabuse.com/media/ebooks/data-visualization-in-python/dvp-mpl-bundle-1-small.jpg">
 </div>
 <div class="col-md-8 col-xs-12 my-auto">
 Become dangerous with Data Visualization
 ✅ 30-day no-question money-back guarantee 
 ✅ Beginner to Advanced 
 ✅ Updated regularly for free (latest update in April 2021) 
 ✅ Updated with bonus resources and guides 
 </div>
 </div>
 </a>
</div>
Data Visualization in Python with Matplotlib and Pandas is a book designed to take absolute beginners to Pandas and Matplotlib, with basic Python knowledge, and allow them to build a strong foundation for advanced work with these libraries - from simple plots to animated 3D plots with interactive buttons.
<blockquote>
It serves as an in-depth guide that'll teach you everything you need to know about Pandas and Matplotlib, including how to construct plot types that aren't built into the library itself.
</blockquote>
Data Visualization in Python, a book for beginner to intermediate Python developers, guides you through simple data manipulation with Pandas, covers core plotting libraries like Matplotlib and Seaborn, and shows you how to take advantage of declarative and experimental libraries like Altair. More specifically, over the span of 11 chapters this book covers 9 Python libraries: Pandas, Matplotlib, Seaborn, Bokeh, Altair, Plotly, GGPlot, GeoPandas, and VisPy.
<blockquote>
It serves as a unique, practical guide to Data Visualization, in a plethora of tools you might use in your career.
</blockquote>

In this tutorial, we'll be going over how to plot a Violin Plot in Matplotlib and Python. We'll go over everything you need to know to plot and customize Violin Plots.

Matplotlib Violin Plot - Tutorial and Examples

Branko Ilic

In this guide, we'll go over the important functionalities of the Apache Commons StringUtils class in Java, with tutorials and examples of everything you need to know.

Guide to Apache Commons' StringUtils Class in Java

<h2 id="introduction">Introduction</h2>
Finding the right data we need is an age-old problem before computers. As developers, we create many search algorithms to retrieve data efficiently.
Search algorithms can be divided into two broad categories: sequential and interval searches. Sequential searches check each element in a data structure. Interval searches check various points of the data (called intervals), reducing the time it takes to find an item, given a sorted dataset.
In this article, you will cover Jump Search in Python - a hybrid combination of sequential search and interval search on sorted arrays.
<h2 id="jumpsearch">Jump Search</h2>
With Jump Search, the sorted array of data is split into subsets of elements called blocks. We find the search key (input value) by comparing the search candidate in each block. As the array is sorted, the search candidate is the highest value of a block.
When comparing the search key to a search candidate, the algorithm can then do 1 of 3 things:
<ol>
<li>If the search candidate is lesser than the search key, we'll check the subsequent block</li>
<li>If the search candidate is greater than the search key, we'll do a linear search on the current block</li>
<li>If the search candidate is the same as the search key, return the candidate</li>
</ol>
The size of the block is chosen as the square root of the array's length. Therefore, arrays with length <code>n</code> have a block size of <code>√n</code>, as this on average gives the best performance for most arrays.
It might be useful to illustrate how it works. Here's how Jump Search would find the value 78 in an array of 9 elements:
<img src="https://stackabuse.s3.amazonaws.com/media/jump-search-in-python-1.jpg" alt="Illustration finding the value 78 on a sorted array with jump search">
The above example finds the element in 5 steps, as there are two checks in the linear search section.
Now that we have a high-level appreciation for how it works, let's look at a pseudocode implementation of the algorithm.
<h2 id="jumpsearchsteps">Jump Search Steps</h2>
Inputs:
<ul>
<li>Array/list <code>A</code> of size <code>n</code></li>
<li>Search Key <code>item</code></li>
</ul>
Output:
<ul>
<li>Index of the matched Search Key or <code>-1</code> if the <code>item</code> is not found</li>
</ul>
<h3 id="steps">Steps</h3>
<ul>
<li>Step 1: Find the length of the sorted source list - <code>n = len(A)</code></li>
<li>Step 2: Determine the suitable Block Size - <code>m = √n</code></li>
<li>Step 3: Iteration begins at the index of the <code>item</code> at <code>i = 0</code> with a step of <code>m</code> and continues until the window reaches the end of the list.</li>
<li>Step 4: Compare <code>A[i+m]</code> (<code>i+m</code> is the last index of a block) and the <code>item</code>
<ul>
<li>a) If <code>A[i+m] == item</code>, Return <code>i+m</code>; Code Exits</li>
<li>b) If <code>A[i+m] &gt; item</code>, Proceed to the linear search inside the block known as derived list <code>B = A[i: i+m]</code>
<ul>
<li>Iterate and compare each element of the list with the search key and return the matching <code>i</code> if found; Code Exits</li>
</ul>
</li>
<li>c) If <code>A[i+m] &lt; item</code>, Proceed with the next iteration to Step 4 :arrows_clockwise:</li>
</ul>
</li>
<li>Step 5: Iterate the elements of the list that don't fit in the block and return the matching index <code>i</code>. If no matches were found, return <code>-1</code>; Code Exits</li>
</ul>
As we now understand how it works, let us implement this algorithm in Python!
<h2 id="implementation">Implementation</h2>
Knowing how Jump Search works, let's go ahead and implement it in Python:
<pre><code class="hljs">&#x27;&#x27;&#x27;
Jump Search function
Arguments:
A - The source list
item - Element for which the index needs to be found
&#x27;&#x27;&#x27;
import math

def jump_search(A, item):
 print(&quot;Entering Jump Search&quot;)
 n = len(A) # Length of the array
 m = int(math.sqrt(n)) # Step length
 i = 0 # Starting interval

 while i != len(A)-1 and A[i] &lt; item:
 print(&quot;Processing Block - {}&quot;.format(A[i: i+m]))
 if A[i+m-1] == item: # Found the search key
 return i+m-1
 elif A[i+m-1] &gt; item: # Linear search for key in block
 B = A[i: i+m-1]
 return linear_search(B, item, i)
 i += m

 B = A[i:i+m] # Step 5
 print(&quot;Processing Block - {}&quot;.format(B))
 return linear_search(B, item, i)
</code></pre>
The <code>jump_search()</code> function takes two arguments - the sorted list under evaluation as the first argument and the element that needs to be found in the second argument. The <code>math.sqrt()</code> function is used to find the block size. The iteration is facilitated by a <code>while</code> condition and the increment is made feasible by the incremented <code>i += m</code>.
You would have noticed that the <code>Step 4b</code> and <code>Step 5</code> have a <code>linear_search()</code> function invoked. The <code>linear_search()</code> function is triggered in one of the following scenarios.
<ul>
<li>
<code>Step 4b</code> - When there's a shift in comparison. If the last element of a block/window is greater than the <code>item</code>, the <code>linear_search()</code> is triggered.
</li>
<li>
<code>Step 5</code> - The remaining elements of the source list <code>A</code> that don't fit in a block are passed as a derived list to the <code>linear_search()</code> function.
</li>
</ul>
The <code>linear_search()</code> function can be written like this:
<pre><code class="hljs">&#x27;&#x27;&#x27;
Linear Search function
Arguments:
B - The derived list
item - Element for which the index needs to be found
loc - The Index where the remaining block begins
&#x27;&#x27;&#x27;

def linear_search(B, item, loc):
 print(&quot;\t Entering Linear Search&quot;)
 i = 0

 while i != len(B):
 if B[i] == item:
 return loc+i
 i += 1
 return -1
</code></pre>
In step 5, the remaining elements of the original list are passed to the <code>linear_search()</code> function as a derived list. The comparison is done against each element of the derived list <code>B</code>.
The matched index of the derived list is added to the index of the source block, to provide the exact index position of the element in the source list. If there are no matches found, we return <code>-1</code> to indicate that <code>item</code> was not found.
The complete snippet can be found on &lt;a rel=”nofollow noopener” href=&quot;https://github.com/StackAbuse/search-algorithms&quot; target=&quot;_blank&quot;&gt;GitHub</a>.
<h2 id="benchmarkingjumpsearchvslinearsearch">Benchmarking - Jump Search vs Linear Search</h2>
The runtime for the Jump Search can be benchmarked against Linear Search. The following visualization illustrates how the algorithms perform while searching for an element near the end of a sorted array. The shorter the bar, the better:
<img src="https://stackabuse.s3.amazonaws.com/media/jump-search-in-python-2.jpg" alt="Graph comparing Jump Search performance against Linear Search. For larger lists of numbers, jump search performs better">
As the number of elements in the list increases, Jump Search is quicker than the Linear Search algorithm.
<h2 id="bigoanalysis">Big-O Analysis</h2>
Let's do a more general analysis of how Jump Search performs. We'll once again consider the worst-case scenario where the element to be found is at the end of the list.
For a list of <code>n</code> elements and a block size of <code>m</code>, Jump Search would ideally perform <code>n/m</code> jumps. Considering the block size to be <code>√n</code>, the runtime too would be <code>O(√n)</code>.
This puts Jump Search in between Linear Search (worst) with a runtime complexity of <code>O(n)</code> and Binary Search (best) with a runtime complexity of <code>O(log n)</code>. Hence, Jump Search can be used in places where the binary search is not feasible and linear search is too costly.
<h2 id="conclusion">Conclusion</h2>
In this article, we have covered the basics of the Jump Search algorithm. We then examined how Jump Search works with pseudocode before implementing it in Python. Thereafter, we analyzed how Jump Search performs, as well as its theoretical speed bounds.

The Jump Search algorithm is a hybrid combination of sequential search and interval search on sorted arrays. Let's learn how to implement it in Python.