David Landup

Joel Olawanle

In this guide, you'll learn how to filter an array in JavaScript with the filter() method. You'll learn how to use the context, index and array arguments, as well as how to chain filter() with map(), indexOf() and find(), through practical code examples.

Guide to JavaScript's filter() Method

<h2 id="introduction">Introduction</h2>
Storing passwords securely should be imperative for any credible engineer. Plain text passwords are extremely insecure - you shouldn't even bother considering storing them a plain format. It's enough that someone gains view privileges on a database for an entire user base to be compromised.
<blockquote>
Passwords must be stored in a database in a secure, yet manageable way.
</blockquote>
You should always assume that your database will be compromised and take all necessary precautions to prevent anyone, who could get hold of your data, from exploiting it in any way possible. That is especially true for databases that store users' login credentials or other sensitive data.
Additionally - it's a question of ethical conduct. If a user signs up for your website - should you be able to find their password ad verbatim? Passwords are oftentimes used on multiple websites, contain personal information and/or could expose a side of the user that they wouldn't like to put out publicly. Neither you nor a malicious actor should be able to read a plain-text password at any point. This is why websites can't email you your password when you forget it - they don't know it. You have to reset it.
<blockquote>
Hashing passwords is a cheap, secure and standard procedure that keeps passwords safe from both a webmaster and malicious actors.
</blockquote>
To prevent anyone from blatantly exploiting login credentials, you should always hash passwords before storing them in a database. That is the simplest, yet most effective way to prevent the unauthorized use of passwords stored in your database. Even if someone gets a hold of users' login credentials, that information can't be used in any shape or form, since the format is unreadable for humans, and hard to crack computationally.
<blockquote>
In this guide, we'll explain how to hash your passwords in Python using BCrypt. We'll cover what hashing is, how hashes are compared, how &quot;salting&quot; works and how hashing even makes passwords secure.
</blockquote>
<h2 id="whatispasswordhashing">What Is Password Hashing?</h2>
In its most basic form, hashing refers to converting one string to another (which is also called a hash) using a hash function. Regardless of the size of an input string, the hash will have a fixed size which is predefined in a hashing algorithm itself. The goal is that the hash doesn't look anything like the input string and that any change in the input string produces a change in the hash.
Additionally - hashing functions hash input in a one-way fashion. It's not a round trip and a hashed password cannot be unhashed. The only way to check whether an input password matches the one in the database is to hash the input password as well, and then compare the hashes. This way, we don't need to know what the actual password is to ascertain whether it's matching the one in the database or not.

 <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: In this guide, we'll use the term &quot;hashing function&quot; for a mathematical function used to calculate the fixed-size hash based on the input string (popular hashing functions include SHA256, SHA1, MD5, CRC32, BCrypt etc.). A &quot;hashing algorithm&quot; refers to the whole process of hashing, including not only a hashing function used but many more parameters that can be altered during the process of hashing.

 </div>
 </div>
 </div>
 <img src="https://s3.stackabuse.com/media/articles/hashing-passwords-in-python-with-bcrypt-2.png" alt="how salting works during password hashing">
Every time you put something such as <code>&quot;myPwd&quot;</code> into the hashing algorithm you'll get the same exact output. But, if you change <code>&quot;myPwd&quot;</code> even a bit, the output will be changed beyond recognition.
That ensures that even similar input strings produce completely different hashes. If similar passwords produced the same hashes - cracking one simple password could lead to creating a lookup table for other characters. On the other hand, since the same input always yields the same output, a hashing is pretty predictable.
<blockquote>
Predictability is easily exploitable.
</blockquote>
If someone knows what hashing function was used to hash a certain password (and there isn't a large list of hash functions in use), they can crack it by guessing all possible passwords, hashing them with the same hashing function, and comparing obtained hashes to the hash of the password that they want to crack. This type of attack is called a brute-force attack and the attack used to work extremely well for simple passwords, such as <code>password123</code>, <code>12345678</code>, etc.
The easiest way to prevent brute-force attacks is to use a hashing function that is relatively slow to compute. That way the brute-force attack would take so much time to compute all possible hashes, that it's not even worth trying to perform.
Additionally, most web applications have built-in &quot;timeouts&quot; after a certain number of incorrect passwords were input, making brute-force guessing not viable if someone's trying to brute-force a password through a controlled UI, though, this doesn't hold if someone obtains a local copy of a hashed password.
<h3 id="whatissaltinpasswordhashing">What Is Salt in Password Hashing?</h3>
As cryptography, price per computation and technology advance - just choosing a proper hashing function isn't quite enough to secure passwords stored in a database. In some cases, even a great hashing function can't prevent an attack. Therefore, it's advised to take additional precautions to make cracking stored passwords even more difficult.
The problem with hashing is that the output (i.e. hash) is always the same for the same input. That makes hashing predictable, thus vulnerable. You can solve that by passing an additional random string alongside the input string when performing hashing. That will ensure that the hashing no longer produces the same output every time it gets the same string as the input.
That fixed-length pseudo-random string passed alongside the input string when performing hashing is called salt. Every time you want to store a password in a database, a new, random salt will be created and passed alongside the password to the hashing function. Consequently, even if two users have the same password, its record in a database will be totally different.
<blockquote>
Remember that adding a single character to the end of a string before hashing changes the hash completely.
</blockquote>
<img src="https://s3.stackabuse.com/media/articles/hashing-passwords-in-python-with-bcrypt-1.png" alt="what is a salt in password hashing?">
The salt used to generate a password is stored separately, and added to any new input that's to be hashed and compared to the stored hash in the database, ensuring that even with the addition of random elements - the user can log in using their respective password. The point of salting isn't to make it much more computationally difficult to crack a single password - it's to prevent finding similarities between hashed strings, and to prevent an attacker from cracking multiple passwords if they're the same.
Through salting - extremely computationally expensive operations are localized to a single instance and have to be repeated for every password in the database, stopping a cascade of broken security.
Thankfully - the entirety of this logic is typically abstracted away by security frameworks and modules that we can readily use in code.
<h2 id="whatisbcrypt">What is BCrypt?</h2>
BCrypt is a password hashing algorithm, designed with all security precautions we've mentioned in mind. It is used as the default password hashing algorithm in OpenBSD, an open-source security-focused operating system, and is the most widely supported hashing algorithm to date.
BCrypt is considered to be fairly secure. Its hashing function is based on the Blowfish (cipher) algorithm, implements salting and adaptive computation speed. Adaptive speed refers to the ability to increase the complexity of calculating hash value, which future proofs the algorithm. It keeps being slow enough to prevent brute-force attacks no matter the increasing computing speed of the hardware.
BCrypt is widely supported and implemented in most mainstream languages. There publicly available implementations for Java, JavaScript, C, C++, C#, Go, Perl, PHP, etc. In this guide, we'll cover the Python implementation of the BCrypt algorithm.
<h2 id="howtohashapasswordinpythonusingbcrypt">How to Hash a Password in Python Using BCrypt</h2>
The <code>bcrypt</code> module on PyPi offers a great implementation of BCrypt that we can easily install via <code>pip</code>:
<pre><code class="hljs">$ pip install bcrypt
</code></pre>

 <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: 
To make sure that all required dependencies are installed, the official documentation advises you to run the following commands based on your operating system of choice.

 </div>
 </div>
 </div>
 For Debian and Ubuntu:
<pre><code class="hljs">$ sudo apt-get install build-essential libffi-dev python-dev
</code></pre>
For Fedora and RHEL-derivatives:
<pre><code class="hljs">$ sudo yum install gcc libffi-devel python-devel
</code></pre>
For Alpine:
<pre><code class="hljs">$ apk add --update musl-dev gcc libffi-dev
</code></pre>
After you've installed BCrypt using <code>pip</code>, you can import it to your project:
<pre><code class="hljs">import bcrypt
</code></pre>
To hash your password using BCrypt, you must convert it to the array of bytes first. To achieve that, we can use the <code>encode()</code> method of the <code>string</code> class! It will encode the string version of the password you want to hash into a byte array, given a certain encoding type, and make it possible to hash using BCrypt.
Let's take <code>'MyPassWord'</code> as the example password to illustrate the usage of BCrypt:
<pre><code class="hljs">pwd = &#x27;MyPassWord&#x27;

bytePwd = pwd.encode(&#x27;utf-8&#x27;)
</code></pre>
The <code>encode()</code> method takes a string in some encoding (e.g. ASCII, UTF-8, etc.) and converts it to a corresponding array of bytes. That byte-array formed of a string is called a b-string.

 <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: In the previous example, <code>pwd</code> is a string and <code>bytePwd</code> is a byte-array. But if you print both variables, the only visible difference is that the <code>bytePwd</code> has <code>b</code> as a prefix before its value - <code>b'myPassword'</code>. Thence the name of that type of byte-array - a b-string.

 </div>
 </div>
 </div>
 Finally, you can hash the encoded password using BCrypt:
<pre><code class="hljs"># Generate salt
mySalt = bcrypt.gensalt()

# Hash password
pwd_hash = bcrypt.hashpw(bytePwd, mySalt)
</code></pre>
As you can see, the method used for hashing in BCrypt is <code>hashpw()</code>. It takes two arguments, the b-string representation of a password and a salt. Obviously, you can manually create a salt, but it's definitely recommended to use the <code>gensalt()</code>method instead. It's a BCrypt method created specifically for creating salt in a cryptographically secure fashion.

 <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: Adaptive computation speed in BCrypt is achieved by setting a number of iterations needed to create a salt. That value is passed as the argument of the <code>gensalt()</code>method. The default value is 12, meaning that BCrypt uses 212 (4096) iterations to generate a salt. By increasing the value of that argument, you increase the number of iterations used to generate a salt, and by extension, the time needed to compute the hash.

 </div>
 </div>
 </div>
 Now, the <code>hash</code> is storing the hashed version of the password <code>pwd</code>. The <code>hash</code> should look somewhat similar to:
<pre><code class="hljs">b&#x27;$2b$12$1XCXpgmbzURJvo.bA5m58OSE4qhe6pukgSRMrxI9aNSlePy06FuTi&#x27;
</code></pre>
Not very similar to the original password, right? But if you compare the <code>hash</code> to the original password using BCrypt's <code>checkpw()</code> method, it returns a <code>True</code> value!

 <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: The <code>checkpw()</code> method is designed for validating hashed passwords. It hashes the new input password, adds the salt it automatically tracks, and then compares the results.

 </div>
 </div>
 </div>
 Let's check whether the literal-text <code>password</code> is a valid password for the new <code>hash</code> we've just created:
<pre><code class="hljs">password = &#x27;MyPassWord&#x27;
password = password.encode(&#x27;utf-8&#x27;)
print(bcrypt.checkpw(password, pwd_hash))
# Output: True
</code></pre>
<h2 id="componentsofabcryptoutput">Components of a BCrypt output</h2>
As we've seen in the previous example, the input to BCrypt is a password (up to 72 bytes) and a salt (with the associated number of iterations) and the output is the 24-byte hash.
Let's examine the following illustration to get a grasp of how BCrypt constructs the produced hash:
<img src="https://s3.stackabuse.com/media/articles/hashing-passwords-in-python-with-bcrypt-3.png" alt="BCrypt Explained">
This illustration shows a hashing of the password, <code>'MyPassword'</code>, therefore it illustrates hashing from the previous section.
As we've discussed before, every time you call the <code>gensalt()</code> method, it produces a new fixed-size byte-array (represented by a b-string). In this example, the <code>gensalt()</code> method produced the output marked as <code>salt</code> in the illustration. Let's decompose the <code>salt</code> section and explain each individual subsection.
The <code>salt</code> has three subsections divided by the <code>$</code> sign:
<ul>
<li>
bcrypt version 
A special hashing algorithm identifier - in this case <code>2b</code> - the newest version of the BCrypt algorithm.
</li>
<li>
exponent 
The argument of the <code>gensalt()</code> method represents the number of iterations used to compute a salt. If no argument is passed, the default value is 12, therefore 212 iterations are used to compute a salt.
</li>
<li>
generated salt 
A radix-64 encoding of the generated salt represented by 22 characters.
</li>
</ul>
After that, BCrypt sticks the <code>salt</code> together with the hashed value of <code>MyPassword</code> and thus creates the final <code>hash</code> of the <code>MyPassword</code>.

 <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: The hashed value of <code>MyPassword</code> (or any other password) refers to a radix-64 encoding of the first 23 bytes of the 24-byte hash. It is represented by 31 characters.

 </div>
 </div>
 </div>
 <h2 id="conclusion">Conclusion</h2>
After reading this article you will have a solid understanding of how to use a BCrypt to hash a password before storing it into a database. To put things into a perspective, we've explained basic terminology in a general sense and then illustrated the process of hashing a password on the example of BCrypt.

Dimitrije Stamenic

Jovana Ninkovic

In this guide, we'll take a look at how to hash passwords in Python with BCrypt and answer questions such as - what is password hashing and what is salting through practical code examples.

Hashing Passwords in Python with BCrypt

<h2 id="introduction">Introduction</h2>
Objects are used to store a collection of properties, each of which may be thought of as an association between a name (or key) and a value (a collection of key-value pairs).
<blockquote>
In this guide, we will explore many JavaScript methods on how to check if an object is empty. We'll be using Vanilla JavaScript, as well as common libraries such as <a rel="nofollow noopener noreferrer" target="_blank" href="https://lodash.com/">lodash</a> and <a rel="nofollow noopener noreferrer" target="_blank" href="https://underscorejs.org/">underscore</a>.
</blockquote>
When it comes to small applications that don't require external dependencies - checking whether an object is empty is best done with pure JavaScript. However, if your application already has external libraries such as lodash and underscore - they offer great ways to perform these checks as well.
Checking if an object is empty or not is a basic and frequent operation, however, there are several methods for determining whether it's empty or not.
Let's start by creating an empty Object with the object literal syntax:
<pre><code class="hljs">const emptyObject = {}
</code></pre>
<h3 id="usingtheobjectkeysmethod">Using the Object.keys() Method</h3>
<code>Object.keys()</code> is a static method that returns an Array when we pass an object to it, which contains the property names (keys) belonging to that object. We can check whether the <code>length</code> of this array is <code>0</code> or higher - denoting whether any keys are present or not. If no keys are present, the object is empty:
<pre><code class="hljs">Object.keys(obj).length === 0 &amp;&amp; obj.constructor === Object;
</code></pre>

 <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: The constructor check makes sure the passed argument is indeed an object.

 </div>
 </div>
 </div>
 We could also create a reusable function, if you're using the check multiple times in the project:
<pre><code class="hljs">const isEmptyObject = (obj) =&gt; {
 return Object.keys(obj).length === 0 &amp;&amp; obj.constructor === Object;
}

console.log(isEmptyObject(emptyObject)); // true
</code></pre>
This is by far the simplest method for determining whether an object is empty, though it's a bit verbose. We'll remove this verbosity with the following approaches - after we take a look at the <code>Object.values()</code> and <code>Object.entries()</code> static methods, which can be used in much the same way as <code>Object.keys()</code>.
<h4 id="usingtheobjectvaluesmethod">Using the Object.values() Method</h4>
Just as with keys - if an object has no <code>values</code> associated (not even an <code>undefined</code>/<code>null</code>) - it's empty:
<pre><code class="hljs">const isEmptyObject = (obj) =&gt; {
 return Object.values(obj).length === 0 &amp;&amp; obj.constructor === Object;
}

console.log(isEmptyObject(emptyObject)); // true
</code></pre>
<h4 id="usingtheobjectentriesmethod">Using the Object.entries() Method</h4>
The <code>entries()</code> method represents all key-value pairs (entries), which can be used as a wrapper for both of the approaches above:
<pre><code class="hljs">const isEmptyObject = (obj) =&gt; {
 return Object.entries(obj).length === 0 &amp;&amp; obj.constructor === Object;
}

console.log(isEmptyObject(emptyObject)); // true
</code></pre>
<h3 id="forinandhasownproperty">for...in and hasOwnProperty()</h3>
For browsers that don't support the <code>keys()</code>, <code>values()</code> and <code>entries()</code> methods - you can explicitly loop through the properties! You can wrap this logic within a method that returns <code>true</code> if no properties were found, and <code>false</code> if properties were found:
<pre><code class="hljs">const isEmptyObject = (objectName) =&gt; {
 for (var prop in objectName) {
 if (objectName.hasOwnProperty(prop)) {
 return false;
 }
 }
 return true;
}

console.log(isEmptyObject(emptyObject)); // true
</code></pre>
<h3 id="usingjsonstringify">Using JSON.stringify</h3>
This is one of the simplest methods to use. When we stringify an object and the output is only an opening and closing bracket, we know the item is empty:
<pre><code class="hljs">JSON.stringify(objectName) === &#x27;{}&#x27;;
</code></pre>
We could also easily be wrapped into a function:
<pre><code class="hljs">const isEmptyObject = (objectName) =&gt; {
 return JSON.stringify(objectName) === &#x27;{}&#x27;;
}

console.log(isEmptyObject(emptyObject)); // true
</code></pre>
<h3 id="checkifobjectisemptywithjavascriptlibraries">Check if Object Is Empty With JavaScript Libraries</h3>
Libraries help us write code faster, by incorporating advanced functionality, used and honed by countless other developers, instead of writing our own solutions.
Libraries are common, typically fast/optimized, and some are present in many projects due to how useful they are. Several of them can also be used for checking whether an object is empty or not. The majority of them offer excellent compatibility for older browsers.
<h4 id="usingunderscoreandlodash">Using Underscore and Lodash</h4>
Both lodash and underscore are utility libraries that offer a fair bit of common utilities. They're both typically imported as <code>_</code>, and can be imported via a CDN:
<pre><code class="hljs">&lt;script src=&quot;https://cdn.jsdelivr.net/npm/lodash@4.17.21/lodash.min.js&quot;&gt;&lt;/script&gt;
&lt;script src=&quot;https://cdn.jsdelivr.net/npm/underscore@1.13.2/underscore-umd-min.js&quot;&gt;&lt;/script&gt;
</code></pre>
Or installed a package manager such as NPM, and then imported via the <code>require()</code> syntax:
<pre><code class="hljs">$ npm install lodash
$ npm install underscore
</code></pre>
<pre><code class="hljs">const _ = require(&#x27;lodash&#x27;);
const _ = require(&#x27;underscore&#x27;);
</code></pre>
Both libraries have the exact same syntax for checking whether an object is empty:
<pre><code class="hljs">_.isEmpty();
</code></pre>
This function works with any data structure - lists, arrays, strings, objects, etc. The function is a wrapper around the logic that checks the length of the object that was passed in, returning <code>true</code> or <code>false</code>:
<pre><code class="hljs">_.isEmpty(emptyObject); // true
</code></pre>
<h4 id="jquery">jQuery</h4>
<a rel="nofollow noopener noreferrer" target="_blank" href="https://jquery.com/">jQuery</a> is a popular JavaScript library, present in many projects around the world. Due to its light weight and features that expand the scope of JavaScript's built-in capabilities - it's become a staple.
jQuery can be imported via a CDN:
<pre><code class="hljs">&lt;script src=&quot;https://code.jquery.com/jquery-3.6.0.min.js&quot; integrity=&quot;sha256-/xUj+3OJU5yExlq6GSYGSHk7tPXikynS7ogEvDej/m4=&quot; crossorigin=&quot;anonymous&quot;&gt;&lt;/script&gt;
</code></pre>
Or installed a package manager such as NPM, and then imported via the <code>require()</code> syntax:
<pre><code class="hljs">$ npm install jquery
</code></pre>
It's typically imported as <code>$</code>:
<pre><code class="hljs">const $ = require(&#x27;jquery&#x27;);
</code></pre>
Naturally, you can use it to check whether an object is empty or not:
<pre><code class="hljs">$.isEmptyObject(emptyObject); // true
</code></pre>
<h4 id="ramda">Ramda</h4>
<a rel="nofollow noopener noreferrer" target="_blank" href="https://www.npmjs.com/package/ramda">Ramda</a> is a functional JavaScript library! It never mutates data and supports the creation of purely functional pipelines. For those with a more functional programming background - it's a great library to feel at home with.
Ramda can be imported via a CDN:
<pre><code class="hljs">&lt;script src=&quot;https://cdnjs.cloudflare.com/ajax/libs/ramda/0.28.0/ramda.min.js&quot;&gt;&lt;/script&gt;
</code></pre>
Or installed a package manager such as NPM, and then imported via the <code>require()</code> syntax:
<pre><code class="hljs">$ npm install ramda
</code></pre>
It's typically imported as <code>R</code>:
<pre><code class="hljs">const R = require(&#x27;ramda&#x27;);
</code></pre>
If you're already using it - it offers an <code>isEmpty()</code> function as well:
<pre><code class="hljs">R.isEmpty(emptyObject); // true
</code></pre>
<h4 id="hoek">Hoek</h4>
<a rel="nofollow noopener noreferrer" target="_blank" href="https://www.npmjs.com/package/@hapi/hoek">@hapi/hoek</a> is part of the hapi ecosystem, and a popular utility method library for hapi-based apps. It offers a <code>deepEqual()</code> method, that checks whether two objects are the same (depth-wise):
<pre><code class="hljs">Hoek.deepEqual({}, emptyObject); // true
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we have taken a look at how to check whether an object is empty or not in JavaScript. To this end - we've used several Vanilla JS approaches, jQuery, Underscore, Lodash, Ramda, Hoek and the JSON module.

In this tutorial - learn how to check if an object is empty in JavaScript with Vanilla JS, jQuery, Lodash, Underscore, Ramda and Hoek, with practical code examples!

JavaScript: Check if an Object is Empty

<h2 id="introduction">Introduction</h2>
Subtracting two matrices in NumPy is a pretty common task to perform. The most straightforward way to subtract two matrices in NumPy is by using the <code>-</code> operator, which is the simplification of the <code>np.subtract()</code> method - NumPy specific method designed for subtracting arrays and other array-like objects such as matrices.

 <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: The array-like object in NumPy is considered to be any object which can be passed to the <code>np.array()</code> method so that it creates an object that has the <code>ndarray</code> type.

 </div>
 </div>
 </div>
 In this guide, you'll find out how to subtract two matrices in NumPy using both <code>-</code> operator and <code>np.subtract()</code> method, when to use either of them, and have a deeper understanding of all the nuances of the <code>np.subtract()</code> method in NumPy.
<h2 id="howtosubtracttwomatricesinnumpy">How to Subtract Two Matrices in NumPy</h2>
In algebra, two matrices can be subtracted only if both of them have the same number of rows and columns, meaning that they are of the same shape. Let's assume you have two matrices of the same shape that you want to subtract:
<pre><code class="hljs">matrix1 = np.array([[2, 4, 0], [9, 1, 7]])
matrix2 = np.array([[2, 2, 1], [3, 5, 8]])
</code></pre>

 <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: Before calling any of NumPy's methods, such as the <code>np.array()</code> method for the first time, you have to import the NumPy module in your project with <code>import numpy as np</code>

 </div>
 </div>
 </div>
 As you can see, two matrices are of the same shape, meaning that the <code>matrix1.shape</code> is equal to <code>matrix2.shape</code> - both are equal to <code>(2, 3)</code>. This fact is crucial because both the <code>-</code> operator and the <code>np.subtract()</code> method won't behave as expected otherwise.

 <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: The <code>shape</code> property of any <code>ndarray</code> object (an array or a matrix) stores the shape of that object in a form of <code>(m, n)</code>, where <code>m</code> represents the number of rows and <code>n</code> represents the number of columns in a matrix.

 </div>
 </div>
 </div>
 Now you can subtract those two matrices using the <code>-</code> operator:
<pre><code class="hljs">resultMatrix = matrix1 - matrix2
</code></pre>
As simple as that! This line is equal to the following line:
<pre><code class="hljs">resultMatrix = np.subtract(matrix1, matrix2)
</code></pre>
In both of those cases, the <code>resultMatrix</code> will have exactly the same value, as expected:
<pre><code class="hljs">[ 0 2 -1]
[ 6 -4 -1]
</code></pre>
<h2 id="subtractingtwomatricesofdifferentshapesinnumpy">Subtracting Two Matrices of Different Shapes in NumPy</h2>
The previous section illustrated the most intuitive way of using the subtraction in NumPy. Rules of algebra state that you can subtract two matrices only if they are of the same shape, thus the previous section describes the only type of matrix subtraction that is mathematically valid.
However, the NumPy library allows the <code>np.subtract()</code> method to work even if argument matrices are not of the same shape. It does so with help of a mechanism called broadcasting, which defines how NumPy treats arrays of different shapes during arithmetic operations. Ultimately, they're equalized shape-wise, and the usual subtraction takes place.
For example, let's take a look at the following two matrices:
<pre><code class="hljs">rowMatrix = np.array([1, 2, 3])
columnMatrix = np.array([[1], [2], [3]])
</code></pre>
Those matrices definitely have different shapes, <code>rowMatrix.shape</code> is <code>(1, 3)</code>, and <code>columnMatrix.shape</code> is <code>(3, 1)</code>. This could confuse you into thinking that you can't perform subtraction of them in NumPy, but that is definitely possible (albeit, indirectly, as they're automatically broadcast before subtraction):
<pre><code class="hljs">resultMatrix = np.subtract(rowMatrix, columnMatrix)
</code></pre>

 <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: The <code>resultMatrix</code> will have the exact same value if you use the <code>-</code> operator instead of <code>np.subtract()</code> method

 </div>
 </div>
 </div>
 The <code>resultMatrix</code> will have the following value:
<pre><code class="hljs">[ 0 1 2]
[-1 0 1]
[-2 -1 0]
</code></pre>
Though, this result may look a bit counterintuitive, but let's use it to illustrate the mechanism of broadcasting in simple terms.
<h3 id="whatisnumpybroadcasting">What is NumPy Broadcasting?</h3>
In order to subtract <code>columnMatrix</code> from <code>rowMatrix</code> both of them must be of the same shape. Since those two matrices do not meet the mentioned criterion, the broadcasting mechanism comes in place. It makes sure to stretch both of them to have compatible shapes. Therefore, the <code>rowMatrix</code> is stretched so that it forms the matrix of the shape <code>(3, 3)</code>:
<pre><code class="hljs">&gt; Original `resultMatrix`:
[1 2 3]

&gt; Broadcasted `resultMatrix`:
[1 2 3]
[1 2 3]
[1 2 3]
</code></pre>
In a similar manner, the <code>columnMatrix</code> is stretched to form the <code>(3, 3)</code> matrix as well:
<pre><code class="hljs">&gt; Original `resultMatrix`:
[1]
[2]
[3]

&gt; Broadcasted `resultMatrix`:
[1 1 1]
[2 2 2]
[3 3 3]
</code></pre>
Now that you have two modified matrices of the same shape, the subtraction can be performed on them. The resulting matrix is the same as the <code>resultMatrix</code> from the example above.
<pre><code class="hljs">[1 2 3] [1 1 1] [ 0 1 2]
[1 2 3] - [2 2 2] = [-1 0 1]
[1 2 3] [3 3 3] [-2 -1 0]
</code></pre>

 <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">
 Alert: Broadcasting is a far more complex mechanism than described here, so we strongly advise you to use it with caution or perform further research on the topic. For example, some other combination of two matrix shapes will produce a <code>ValueError</code> because those shapes can't be broadcast into the same shape.

 </div>
 </div>
 </div>
 <h2 id="whentousenpsubtractmethodinsteadofoperator">When to Use np.subtract() Method Instead of - Operator</h2>
Based on what you've seen until now, you can conclude that you can use both <code>-</code> and <code>subtract()</code> interchangeably pretty much any time you want. That's almost true, but there are some cases where you should consider using the <code>np.subtract()</code> method instead of the <code>-</code> operator.
In essence, the <code>-</code> operator is an abstraction of the <code>np.subtract()</code> method. When called, the <code>-</code> operator will, effectively, call the <code>np.subtract()</code> with its default parameters. Therefore, the one use case where you can consider using the <code>np.subtract()</code> over the <code>-</code> operator is when you want to tweak the predefined default behavior of the subtraction in the NumPy. We'll take a look at a few arguments that can be interesting to play around with.
Firstly, let's take a look at the declaration of the<code>np.subtract()</code> method:
<pre><code class="hljs">numpy.subtract(x1, x2, /, out=None, *, where=True, casting=&#x27;same_kind&#x27;, order=&#x27;K&#x27;, dtype=None, subok=True[, signature, extobj]) = &lt;ufunc &#x27;subtract&#x27;&gt;
</code></pre>
Besides a few usual and self-explanatory arguments, the section of the declaration that will most probably draw your attention is <code>&lt;ufunc 'subtract'&gt;</code>, so let's first clarify what it stands for. In NumPy, <code>ufunc</code> stands for universal function, thus this argument signalizes that the <code>np.subtract()</code> method is a universal function.
Universal functions in NumPy operate on arrays (more specifically <code>ndarrays</code>) in an element-by-element fashion. They can efficiently iterate over elements of two <code>ndarrays</code> and perform a predefined operation on corresponding elements. For example, <code>np.subtract()</code> will subtract two corresponding elements from two <code>ndarrays</code>. Therefore, you can think of universal functions as basic, predefined functions, which enable you to perform a wide variety of basic mathematical operations on <code>ndarrays</code>.
Now we can describe some other interesting arguments:
<ul>
<li><code>x1</code> (required)
<ul>
<li>the first input array (or other array-like objects)</li>
<li>has to be either the same shape as <code>x2</code> or broadcastable to the same shape as <code>x2</code></li>
</ul>
</li>
<li><code>x2</code> (required)
<ul>
<li>the second input array (or other array-like objects)</li>
<li>has to be either the same shape as <code>x1</code> or broadcastable to the same shape as <code>x1</code></li>
</ul>
</li>
<li><code>out</code> (optional)
<ul>
<li>used if you want to specify the location where to store the result</li>
<li>if not specified, the new object is created to store the result</li>
<li>if specified, it has to be a <code>ndarray</code> object or a tuple of <code>ndarray</code> and <code>None </code>objects</li>
<li>the specified object has to have the shape that the two input arrays broadcast to</li>
</ul>
</li>
<li><code>where</code> (optional)
<ul>
<li>used if you want to specify some elements of the input array on which the <code>ufunc</code> will not be performed</li>
<li>the default value is <code>True</code>, thus the <code>np.subtract()</code> will subtract all corresponding elements from <code>x1</code> and <code>x2</code></li>
<li>if you want not to subtract elements on a certain position in the <code>out</code> array, you can pass the array of Boolean values which has the same shape as the <code>out</code> array, and set the value to <code>False</code> on those positions</li>
</ul>
</li>
<li><code>dtype</code> (optional)
<ul>
<li>used to specify the type of the result matrix</li>
<li>by default, it is equal to the type of the input arrays</li>
</ul>
</li>
</ul>
<h2 id="conclusion">Conclusion</h2>
Whether you were looking for an easy way to subtract two matrices using NumPy or trying to recall more advanced concepts surrounding the <code>np.subtract()</code> method, this guide has you covered. The main point of this guide was to give you the answer to both of those questions.
Firstly, we've covered the easy and intuitive way to subtract two matrices in the NumPy module. Alongside that, we've discussed the similarities and differences between the <code>-</code> operator and the <code>np.subtract()</code> method. Afterward, we've illustrated the concept of broadcasting in NumPy, but we do advise you to dig deeper on the subject of broadcasting.
In the end, we've given you a detailed overview of the <code>np.subtract()</code> method in NumPy, thus you can tweak its default behavior to make it more suitable for certain more specific use cases.

In this guide, learn how to perform NumPy matrix subtraction of same-shape and different-shape matrices, with broadcasting, in Python.

Guide to NumPy Matrix Subtraction

<h2 id="setfloatingpointprecisioninjavascript">Set Floating-Point Precision in JavaScript</h2>
Floating-points in JavaScript have an extremely high precision, and you don't always need this precision. Additionally - your user is even less likely to want it. More often than not - we'll want to &quot;trim&quot; floating-point numbers by setting a specific precision (such as, say, two decimal points) for an end-user.
The <code>Number</code> object has several methods that allow us to change the precision of a floating-point number in JavaScript!
<h3 id="tofixed">toFixed()</h3>
<code>toFixed()</code> is a <code>Number</code> method that is used to convert a number to fixed-point notation (rounding the result where necessary) and returns the value as a string:
<pre><code class="hljs">number.toFixed([decimalPlaces]);
</code></pre>
<code>decimalPlaces</code> is optional, and defines the number of digits that should be present after the decimal place and defaults to <code>0</code>:
<pre><code class="hljs">let number = 12345.6789
 
console.log(number.toFixed()) // Returns &#x27;12346&#x27;: note rounding, no fractional part
console.log(number.toFixed(1)) // Returns &#x27;12345.7&#x27;: note rounding
console.log(number.toFixed(6)) // Returns &#x27;12345.678900&#x27;: note added zeros
console.log((1.23e+20).toFixed(3)) // Returns &#x27;123000000000000000000.000&#x27;
</code></pre>
If the floating-point number didn't offer precision up to the fixed point you're formatting to - 0s are added as padding to the end.
<h3 id="toprecision">toPrecision()</h3>
<code>toPrecision()</code> is a <code>Number</code> method that formats a number to a precision string - keeping track of how many total digits (including digits to the left and right of the decimal) to display of a number:
<pre><code class="hljs">number.toPrecision([significantDigits]);
</code></pre>
<code>significantDigits</code> is optional, denoting the number of significant digits to display in the result. If omitted, the method just converts the number to a string.
<pre><code class="hljs">let number = 5.123456
 
console.log(number.toPrecision()) // logs &#x27;5.123456&#x27;
console.log(number.toPrecision(5)) // logs &#x27;5.1235&#x27;
 
number = 0.000123
 
console.log(number.toPrecision()) // logs &#x27;0.000123&#x27;
console.log(number.toPrecision(5)) // logs &#x27;0.00012300&#x27;
</code></pre>
The returned values are of <code>string</code> type:
<pre><code class="hljs">console.log(typeof number.toPrecision()) // string
</code></pre>

 <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: The <code>toPrecision()</code> method will pad the resulting value with 0's if there are not enough significant digits, and it does not change the value of the original number - it returns a new result.

 </div>
 </div>
 </div>
 <h3 id="toexponential">toExponential()</h3>
The <code>toExponential()</code> function in JavaScript is used to show a number in exponential notation (sometimes known as scientific notation), even if the number is inside the range where JavaScript ordinarily uses standard notation:
<pre><code class="hljs">number.toExponential([fractionalDigits]);
</code></pre>

 <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: It's worth noting that with sufficiently small and sufficiently large numbers - JavaScript automatically displays them in their exponential notation.

 </div>
 </div>
 </div>
 <code>fractionalDigits</code> as an argument is optional, and specifies how many fractional digits are to be displayed in the result. If this argument is missing, the output may contain up to 16 fractional digits, depending on your browser:
<pre><code class="hljs">let number = 95.3434;
 
console.log(number.toExponential()); // 9.53434e+1
console.log(number.toExponential(4)); // 9.5343e+1
console.log(number.toExponential(2)); // 9.53e+1
console.log(95.3434.toExponential()); // 9.53434e+1
</code></pre>

 <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: The <code>toExponential()</code> method does not change the value of the original number - it returns a new value to be stored.

 </div>
 </div>
 </div>
 <h2 id="conclusion">Conclusion</h2>
In this short tutorial, we've covered the process of setting a precision for floating-point numbers in JavaScript, using the <code>toExponential()</code>, <code>toFixed()</code> and <code>toPrecision()</code> methods of the <code>Number</code> object.

In this short tutorial, we'll take a look at how to set floating-point precision to a certain decimal place and how to convert to exponential (scientific) notation in JavaScript with toFixed(), toPrecision() and toExponential().

How to Set Floating-Point Precision in JavaScript

<h2 id="introduction">Introduction</h2>
Floats and doubles represent floating-point numbers - numbers with decimal points. While this type is very useful for a wide variety of environments, depending on what they're used for, we sometimes want to round them to a whole number - closest whole integer, up or down.
<blockquote>
In this article, we will explore how to round double/float numbers (including strings) in JavaScript using built-in methods of the <code>Math</code> object.
</blockquote>
<h3 id="themathobject">The Math Object</h3>
The <code>Math</code> object is used to conduct commonplace mathematical operations. Because the <code>Math</code> object is a static built-in object, you can't and won't need to initialize it - it can be invoked at any point as a static object with helper methods. It has a plethora of constants and techniques for doing mathematical operations, all of which may be accessed directly.
Let's look at some of the <code>Math</code> object's handy methods for rounding doubles/floats in JavaScript!
<h4 id="mathround">Math.round()</h4>
<code>Math.round()</code> is a function used to return the value of a floating-point number rounded to the nearest whole integer. Depending on the supplied float/double, <code>Math.round()</code> either rounds up or down.
If the floating-point number is above or equal to <code>x.5</code> - it's rounded up to the nearest integer. If the floating-point number is below <code>x.5</code>, it's rounded down to the nearest integer:
<pre><code class="hljs">Math.round(24.49); // 24
Math.round(&#x27;29.5&#x27;); // 30
Math.round(72); // 72
Math.round(-40.51); // -41
</code></pre>
<h4 id="mathfloor">Math.floor()</h4>
The <code>Math.floor()</code> method is used to return the nearest whole integer that is less than or equal to a specified value. In layman's terms, the <code>floor()</code> method rounds a number down and returns an integer result:
<pre><code class="hljs">Math.floor(75.95); // 75
Math.floor(75.05); // 75
Math.floor(4); // 4
Math.floor(&#x27;-65.05&#x27;); // -66
Math.floor(-65.95); // -66
</code></pre>

 <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: <code>Math.floor(null)</code> returns 0, not a <code>NaN</code> error.

 </div>
 </div>
 </div>
 <h4 id="mathceil">Math.ceil()</h4>
The <code>Math.ceil()</code> method rounds a number up to the nearest greatest integer. Simply said, it is used to round up a number and return an integer value:
<pre><code class="hljs">Math.ceil(0.95); // 1
Math.ceil(7); // 7
Math.ceil(&#x27;9.008&#x27;); // 10
Math.ceil(-0.95); // -0
Math.ceil(-7); // -7
Math.ceil(-9.008); // -10
</code></pre>

 <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: <code>Math.ceil(null)</code> returns integer 0 and does not give a <code>NaN</code> error.

 </div>
 </div>
 </div>
 <h4 id="mathtrunc">Math.trunc()</h4>
While truncating isn't rounding - it's worth mentioning the <code>Math.trunc()</code> method. It returns the whole integer of the number, by truncating (cutting off) the floating-point precision, regardless of whether the argument is positive or negative:
<pre><code class="hljs">Math.trunc(38.37); // 38
Math.trunc(72.84); // 72
Math.trunc(0.123); // 0
Math.trunc(-0.13323); // -0
Math.trunc(&#x27;-1.18923&#x27;); // -1
Math.trunc(NaN); // NaN
Math.trunc(&#x27;john&#x27;); // NaN
Math.trunc(); // NaN
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this short article, we've taken a look at how to round doubles/floats in JavaScript, with the help of <code>Math.round()</code>, <code>Math.floor()</code>, <code>Math.ceil()</code> and <code>Math.trunc()</code>.

In this tutorial - learn how to round decimal numbers (floats/doubles) in JavaScript to whole integers - up, down or nearest.

How to Round Doubles/Floats in JavaScript

<h2 id="introduction">Introduction</h2>
As you aim to become a better JavaScript developer, it is expedient you understand some tricks and methods in JavaScript to save you from unnecessary hard-to-decode bugs in the future. Whenever users input string values through form fields, it is a good practice for you to remove the white spaces from the start and end of the strings and all unnecessary characters. Input is rarely clean, and unclean input can, in some cases, break an application.
<blockquote>
In this guide, we will explore different methods on how to trim characters from strings in JavaScript, as well as when to use which.
</blockquote>
<h2 id="removingwhitespacesfromstrings">Removing White Spaces From Strings</h2>
Whitespace is defined as an empty space, i.e. a space with no visual representation, but a space that does exist to separate two characters. These whitespace characters are created by using the computer keyboard's Space Bar and Tabs, as well as line break characters or line terminators such as <code>\n</code>, <code>\t</code>, <code>\r</code>.

 <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: Trimming a string usually refers to trimming the left, right, or more commonly both sides of a string. Most commonly, we trim the potential whitespace around the string, but we could also trim other characters.

 </div>
 </div>
 </div>
 JavaScript provides three functions to assist us in trimming strings entering into our database or application from input fields.
<h3 id="trimstringwhitespaceinjavascriptwithtrim">Trim String Whitespace in JavaScript with trim()</h3>
<code>trim()</code> is a built-in string method which is used to, well, trim a string. The method removes whitespace from both ends of a string and returns it:
<pre><code class="hljs">string.trim();
</code></pre>
Let's create a <code>username</code> - with a double whitespace in the beginning and a single whitespace at the end:
<pre><code class="hljs">let username = &#x27; John Doe &#x27;;
let trimmed = username.trim();

console.log(trimmed);
</code></pre>
This results in:
<pre><code class="hljs">John Doe
</code></pre>
<code>trim()</code> doesn't work in-place, as strings are immutable. It returns a trimmed string back - so we've captured the returned value and printed it.

 <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: If whitespace is found between two characters, then, the whitespace is preserved. They're only trimmed from the start and end of a string.

 </div>
 </div>
 </div>
 The method is also used to remove line terminators such as <code>\n</code>, <code>\t</code>, <code>\r</code>, etc. For instance, say there's a nasty tab right before a serial number and a newline break after it:
<pre><code class="hljs">let serialNumber = &#x27;\t 011-34201 \n&#x27;;
console.log(&#x27;Untrimmed: &#x27;, serialNumber)
console.log(&#x27;Trimmed: &#x27;, serialNumber.trim());
</code></pre>
This results in:
<pre><code class="hljs">Untrimmed:	 011-34201 
Trimmed: 011-34201
</code></pre>
Again, <code>trim()</code> works by removing the whitespace from both sides. However, sometimes, you may want to only trim one of the sides instead. This is where you'll opt to use the <code>trimStart()</code> and <code>trimEnd()</code> methods instead.
<h3 id="trimstartofstringwithtrimstart">Trim Start of String with trimStart()</h3>
Similar to the <code>trim()</code> method and just like the name implies, <code>trimStart()</code> is used to trim out whitespace and line terminators only from the beginning of a string. For instance:
<pre><code class="hljs">let company = &#x27; Stack Abuse &#x27;;
company.trimStart(); // &#x27;Stack Abuse &#x27;
 
let serialNumber = &#x27;\t 011-34201 \n&#x27;;
serialNumber.trimStart(); // &#x27;011-34201 \n&#x27;
</code></pre>
In the example above, you will notice that the space at the beginning of the company name was removed. The same logic applies to the still-present newline in the <code>serialNumber</code>.
<h3 id="trimendofstringwithtrimend">Trim End of String with trimEnd()</h3>
<code>trimEnd()</code> is a polar opposite of the <code>trimStart()</code> method and, just as the name implies, is used to trim out whitespace and line terminators only from the end of a string. For instance:
<pre><code class="hljs">let company = &#x27; Stack Abuse &#x27;;
company.trimEnd(); // &#x27; Stack Abuse&#x27;
 
let serialNumber = &#x27;\t 011-34201 \n&#x27;;
serialNumber.trimEnd(); // &#x27;\t 011-34201&#x27;
</code></pre>
In the example above, you will notice that instead of affecting the beginning like that of <code>trimStart()</code>, the end was affected by removing space and also the line terminator.
<h3 id="trimallwhitespacefromstrings">Trim All Whitespace From Strings</h3>
Moving on, let's now see how to trim all whitespace using Regular Expressions. So far we have only seen how to remove whitespace from the start or end of our strings - let's now see how to remove all whitespace.
This is possible using the JavaScript's <code>string.replace()</code> method, which supports Regular Expressions (RegEx) and helps find matches within a particular string. <code>replace()</code> takes two arguments, the first being the Regular Expression matching what we want to remove, and the second being the pattern we'd like to insert instead of the first.
<blockquote>
If you'd like to read more about Regular Expressions - read our <a target="_blank" href="https://stackabuse.com/guide-to-regular-expressions-and-matching-strings-in-javascript/">Guide to Regular Expressions and Matching Strings in JavaScript</a>!
</blockquote>
Let’s now compose a Regular Expression to handle the removal of all whitespace from strings:
<ul>
<li><code>\s</code>: Matches any whitespace symbol such as spaces, tabs, and line breaks.</li>
<li><code>+</code>: Matches one or more of the preceding tokens (referencing <code>\s</code>).</li>
<li><code>g</code>: Placed at the end to indicate iterative searching throughout the full string.</li>
</ul>
Let's now combine this RegEx and make use of it to remove whitespace within, before and after strings:
<pre><code class="hljs">let sentence = &#x27; I and the man decided to move ouT &#x27;;
let trimmed = sentence.replace(/\s+/g, &#x27;&#x27;); // &#x27;IandthemandecidedtomoveouT&#x27;
 
console.log(&#x27;Untrimmed: &#x27;, sentence)
console.log(&#x27;Trimmed: &#x27;, trimmed);
</code></pre>
This results in:
<pre><code class="hljs">Untrimmed: I and the man decided to move ouT 
Trimmed: IandthemandecidedtomoveouT
</code></pre>
In the example above, we took out whitespace characters and replaced them with an empty string.
<h2 id="trimarbitrarycharacterswithjavascript">Trim Arbitrary Characters with JavaScript</h2>
When using Regular Expressions, and the <code>string.replace()</code> method - you're not limited to trimming whitespace. You can really trim any pattern, and Regular Expression patterns are quite flexible.
We just need to derive a particular RegEx expression depending on the arbitrary characters you wish to trim. Suppose we want to remove a particular character from the start and a different one from the end of a string:
<pre><code class="hljs">let example = &quot;cccccccccccccccccccccI know the manaaaaaaaaaaaaaaaaaaaa&quot;;
let show = example.replace(/c+/, &quot;&quot;).replace(/a+$/, &quot;&quot;);
console.log(show); // &quot;I know the man&quot;
</code></pre>
Or we could also work any arbitrary pattern, such as any number between <code>0</code> and <code>9</code>:
<pre><code class="hljs">let example = &quot;1234567890I know the man1234567890&quot;;
let show = example.replace(/^[0-9]+/, &#x27;&#x27;).replace(/[0-9]+$/, &#x27;&#x27;);
console.log(show); // &quot;I know the man&quot;
</code></pre>
<h2 id="trimmingcharacterfromaparticularindexwithjavascript">Trimming Character From a Particular Index With JavaScript</h2>
Finally, another built-in string method can be used to trim strings, given a particular index. The <code>substr()</code> method substrings a string, and returns the subset as a new string. It is used to extract the parts of the string between the given starting and ending index.
To remove the first character from a string - we cut it off at index <code>1</code>, and set the second parameter as the <code>length</code> of the string:
<pre><code class="hljs">let username = &#x27;John Doe&#x27;;
console.log(&#x27;Original Name: &#x27;, username);
 
let newName = username.substr(1, username.length);
console.log(&#x27;After removing the first character: &#x27;, newName);
</code></pre>
This results in:
<pre><code class="hljs">Original Name: John Doe
After removing the first character: ohn Doe
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this guide, we've taken a look at how to trim whitespace from strings - be it from starts, ends or both ends of the string, in JavaScript.
We've explored the <code>trim()</code>, <code>trimStart()</code> and <code>trimEnd()</code> methods, which automatically trim whitespace. We've then explored the use of Regular Expressions to replace patterns of whitespace, with empty strings. Additionally, we've then explored the replacement of any arbitrary pattern in strings with any other pattern instead.
Finally, we've taken a look at the <code>substr()</code> method, to substring and trim characters with a given <code>start</code> and <code>end</code> index.

In this guide, learn how to trim the whitespaces at the start and end of a string in JavaScript with built-in methods and Regular Expressions. We'll use the `trim()`, `trimStart()`, `trimEnd()`, `substr()` and `replace()` methods.

How to Trim Whitespaces/Characters from a String in JavaScript

<h2 id="introduction">Introduction</h2>
Programming has always included the definition of data, manipulation of data, and finally displaying data. Data can be represented as bits of information that we can alter in computer programs. Since memory locations aren't very human-readable, and change through time - we've started annotating variable data, with human-readable signifiers, which we can call on, to indirectly point to data in-memory.
<blockquote>
These signifiers are commonly called variables or reference variables.
</blockquote>
Variables are, essentially, pointers or references to some data in a machine's memory, and the pointer can dynamically be changed to reflect the true state of the data we've &quot;labeled&quot;.

 <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: Commonly and colloquially, it's said that &quot;variables store data&quot; and that they're &quot;containers for data&quot;. This is technically incorrect, and stems from a blurred semantic boundary - it's unclear whether people refer to reference variables or objects in-memory. (Reference) Variables are pointers, and they point to objects in the machine's memory - where the data is stored. The colloquial terms are commonplace enough that you'll find them present in documentation, but it's worth keeping object-memory-allocation at least in the back of your head.

 </div>
 </div>
 </div>
 Prior to the release of ES2015 (ES6), JavaScript variables were only declared using the <code>var</code> keyword; however, with the introduction of ES6, new ways to declare variables, <code>let</code> and <code>const</code>, were introduced. This oftentimes brings up questions - mainly as to which keyword should be used, and when:
<pre><code class="hljs">var english = &quot;Hello there!&quot;;
let french = &quot;Bonjour!&quot;;
const german = &quot;Hallo!&quot;;
</code></pre>
<blockquote>
In this guide, we will explore the difference between the three various ways to declare variables in JavaScript - <code>var</code>, <code>let</code> and <code>const</code>, their scopes and when to choose which.
</blockquote>
<h3 id="whatisscopeinjavascript">What is Scope in JavaScript?</h3>
Scope is an important concept to grasp in order to write code in most programming languages, and plays an important part in choosing which variable keyword you'll want to use. Scope defines variable availability. In JavaScript, we have two scopes: global and local.
<ul>
<li>Global Scope: Variables declared outside any code block or function are known as global variables because they have a global scope, and can be referenced from any function or block.</li>
</ul>

 <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: In a JavaScript document, only one global scope exists.

 </div>
 </div>
 </div>
 Suppose you have a script file. Again, any variable declared outside any function or block is globally scoped:
<pre><code class="hljs">// Initialized outside of function or block
var name = &quot;John Doe&quot;;
function logName() {
 console.log(name);
};
 
logName();
</code></pre>
In the example above, <code>name</code> is accessible within the <code>logName()</code> function, as it has a global scope. It exists in the context of the application, and the <code>logName()</code> function can call on that context!
<ul>
<li>Local Scope: Variables declared within any code block or function are known as local variables, because they have a local scope. They can be referenced only within the code blocks or functions in which they're defined.</li>
</ul>
<pre><code class="hljs">function logName() {
 // Initialized within a function or block
 var name = &quot;John Doe&quot;;
 var id = 1;
 console.log(name);
};
 
function logId() {
 console.log(id);
}
 
logId();
</code></pre>
This results in:
<pre><code class="hljs">error: Uncaught ReferenceError: id is not defined
</code></pre>
How come? <code>id</code> is defined - but it isn't defined in the scope of the <code>logId()</code> function. As far as the function is concerned - no <code>id</code> exists. It starts by checking whether there's a locally scoped variable. Since there's none, it checks whether there's a globally scoped variable. If not - <code>id</code> is not defined from the context of <code>logId()</code>!
With the primer/reminder out of the way - let's take a look at how <code>var</code>, <code>let</code> and <code>const</code> depend on the scope, and when each should be used!
<h2 id="thevarkeywordinjavascript">The var Keyword in JavaScript</h2>
In JavaScript, <code>var</code> is a reserved keyword which is followed by a reference variable name. The name defined after the keyword can then be used as a pointer to the data in-memory.
Using <code>var</code> is the oldest method of variable declaration in JavaScript. Let's declare a variable and initialize it by assigning a value to it using the assignment operator (<code>=</code>):
<pre><code class="hljs">// Declaration and initialization
var name = &quot;John Doe&quot;;
</code></pre>
Alternatively, you can break this down into two steps - variable declaration (what it is), and variable initialization (assigning a value to it):
<pre><code class="hljs">// Declaration
var name;
// Initialization
name = &quot;John Doe&quot;;
</code></pre>

 <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: In strongly-typed languages, such as Java, for a long time, you'd define the type of the variable during declaration, and during initialization, you could only assign a value fitting that type. Since Java 10 - a <code>var</code> keyword has been added, which is type-agnostic and infers the type during runtime.

 </div>
 </div>
 </div>
 <h3 id="scopeofvar">Scope of var</h3>
When defined within a function - any <code>var</code> is restricted to that function. When defined outside of a function, a <code>var</code> is global:
<pre><code class="hljs"> var firstName = &quot;John&quot;;
 
 function checkLastName() {
 var lastName = &quot;Doe&quot;;
 }
</code></pre>
We have two declarations in the preceding example: <code>firstName</code> is globally scoped because it's defined outside a function, and <code>lastName</code> is locally/function scoped because it's defined within a function:
<pre><code class="hljs">var firstName = &quot;John&quot;;
 
function checkLastName() {
 var lastName = &quot;Doe&quot;;
 console.log(lastName); // &quot;Doe&quot;
 console.log(firstName); // &quot;John&quot;
}
 
checkLastName();
console.log(lastName); // Uncaught ReferenceError: lastName is not defined
</code></pre>
So far so good. However - <code>var</code> has an issue.
<h3 id="theissuewithvar">The Issue with var</h3>
<code>var</code> is not block-scoped. When you declare a variable within a code block, using curly braces (<code>{}</code>), its scope &quot;flows out&quot; of the block! For instance:
<pre><code class="hljs">var name = &quot;John Doe&quot;;
 
var someBool = true;
if (someBool) {
 var name = &quot;Daniel Joan&quot;;
}
 
console.log(name);
</code></pre>
The <code>name</code> that points to &quot;John Doe&quot; is global, and the <code>name</code> that points to &quot;Daniel Joan&quot; is defined within a block. However, when we try printing the <code>name</code> that's within scope, we run into:
<pre><code class="hljs">Daniel Joan
</code></pre>
<blockquote>
<code>var</code> is not block-scoped. We may think that we've defined a local <code>var name</code> to point to &quot;Daniel Joan&quot;, but what we've done in reality is overwrite the <code>var name</code> that points to &quot;John Doe&quot;.
</blockquote>
Declaring variables using the <code>var</code> declarations everywhere in your code can lead to confusion, overwriting of existing global variables and by extension - bugs, just as we saw in the code snippet.
This is where <code>let</code> and <code>const</code> kick in!
<h2 id="theletkeywordinjavascript">The let Keyword in JavaScript</h2>
The <code>let</code> declaration was introduced with ES6 and has since become the preferred method for variable declaration. It is regarded as an improvement over <code>var</code> declarations and is block-scoped (variables that can be accessed only in the immediate block), circumventing the main issue that can arise with using <code>var</code>.
<h3 id="scopeoflet">Scope of let</h3>
A variable defined with the <code>let</code> keyword has a scope limited to the block or function in which it is defined:
<pre><code class="hljs">let firstName = &quot;John&quot;;
let lastName = &quot;Doe&quot;;

let someBool = true;
if(someBool){
 let firstName = &quot;Jane&quot;;
 console.log(firstName);
}
 
console.log(firstName);
</code></pre>
This time around - the <code>firstName</code> referring to &quot;Jane&quot; and the <code>firstName</code> referring to &quot;John&quot; don't overlap! The code results in:
<pre><code class="hljs">Jane
John
</code></pre>
The <code>firstName</code> declared within the block is limited to the block in scope and the one declared outside the block is available globally. Both instances of <code>firstName</code> are treated as different variable references, since they have different scopes.
<h2 id="theconstkeywordinjavascript">The const Keyword in JavaScript</h2>
The <code>const</code> declaration was introduced with ES6, alongside <code>let</code>, and it is very similar to <code>let</code>. <code>const</code> points to data in memory that holds constant values, as the name implies. <code>const</code> reference variables cannot be reassigned to a different object in memory:
<pre><code class="hljs">const name = &quot;John&quot;;
const name = &quot;Jane&quot;;
</code></pre>
This results in:
<pre><code class="hljs">Uncaught SyntaxError: Identifier &#x27;name&#x27; has already been declared
</code></pre>
<h3 id="scopeofconst">Scope of const</h3>
The scope of a variable defined with the <code>const</code> keyword, like the scope of <code>let</code> declarations, is limited to the block defined by curly braces (a function or a block). The main distinction is that they cannot be updated or re-declared, implying that the value remains constant within the scope:
<pre><code class="hljs">const name = &quot;John&quot;;
name = &quot;Doe&quot;;
 
// Uncaught TypeError: Assignment to constant variable. 
</code></pre>
<h2 id="goodcodingconventions">Good Coding Conventions</h2>
So, what does this all mean, and which should you choose, other than the obvious requirements to avoid bugs? This can actually be boiled down to a couple of good practices:
<ul>
<li><code>const</code> is preferred to <code>let</code>, which is preferred to <code>var</code>. Avoid using <code>var</code>.</li>
<li><code>let</code> is preferred to <code>const</code> when it's known that the value it points to will change over time.</li>
<li><code>const</code> is great for global, constant values.</li>
<li>Libraries are typically imported as <code>const</code>.</li>
</ul>
When importing a library and instantiating it - you don't want to be able to reassign the instance to something else, since you'd enter a slippery slope of &quot;using the library&quot;, whereas, something else is &quot;slipping code in&quot; under the hood.
For instance, if you were to <code>require()</code> a library such as Axios, you're conceivably wanting to use its API. However, there's nothing preventing you (or someone else) to switch out the <code>axios</code> instance with something else if you haven't used <code>const</code> to declare it:
<pre><code class="hljs">let axios = require(&#x27;axios&#x27;);
axios.get(&#x27;some_url&#x27;).then(someFunction());

axios = &quot;Totally not a string!&quot;
axios.get(&#x27;some_url&#x27;).then(someFunction()); // String has no method `get()`
</code></pre>
By having <code>axios</code> be <code>const</code> - this issue is avoided. Additionally, you can define global constants, which can be used as configuration constants:
<pre><code class="hljs">const WIDTH = 1920;
const HEIGHT = 1080;
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this guide, we've explored the progression of variable declaration in JavaScript, from the original <code>var</code> to the newer <code>let</code> and <code>const</code>.
We've explored Scopes in JavaScript and how the different declaration signifiers affect the scope of a variable in code, noting a glaring issue with using <code>var</code>. Finally, we've explored some good practices, noting when to use which keyword.

In this guide, learn what the difference is between the var, let and const variable declarations in JavaScript, including best practices, with examples.

The Difference Between var, let and const in JavaScript and Best Practices

<h2 id="introduction">Introduction</h2>
Converting an object into a savable state (such as a byte stream, textual representation, etc) is called serialization, whereas deserialization converts data from the aforementioned format back to an object. A serialized format retains all the information required to reconstruct an object in memory, in the same state as it was when serialized.
<blockquote>
In this guide, you will learn how to serialize and deserialize data in Python with the Pickle module. We'll additionally be working with data that's been serialized/deserialized, with Pandas.
</blockquote>

 <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: Some knowledge of file handling operations is recommended if you are a complete beginner to the Python programming language. If so - read our <a href="/saving-text-json-and-csv-to-a-file-in-python/">Guide to Saving Text, JSON and CSV to a File in Python</a>.

 </div>
 </div>
 </div>
 <h2 id="whatispicklingandunpicklinginpython">What is Pickling And Unpickling in Python?</h2>
Python comes with a built-in package, known as <code>pickle</code>, that can be used to perform “pickling” and “unpickling” operations.
Pickling and unpickling in Python is the process that is used to describe the conversion of objects into byte streams and vice versa - serialization and deserialization, using Python's <code>pickle</code> module. Let's take a look at a few examples!

 <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: The <code>pickle</code> module is available in the standard library from Python 3.x onward.

 </div>
 </div>
 </div>
 Consider the following code that prints the contents of a dictionary:
<pre><code class="hljs">import pickle

athletes = {
 &quot;Name&quot;: [&quot;Cristiano Ronaldo&quot;, &quot;Lionel Messi&quot;, &quot;Eden Hazard&quot;, &quot;Luis Suarez&quot;, &quot;Neymar&quot;],
 &quot;Club&quot;: [&quot;Manchester United&quot;, &quot;PSG&quot;, &quot;Real Madrid&quot;, &quot;Atletico Madrid&quot;, &quot;PSG&quot;]
 }

print(athletes)
</code></pre>
This would result in:
<pre><code class="hljs">{
&#x27;Name&#x27;: [&#x27;Cristiano Ronaldo&#x27;, &#x27;Lionel Messi&#x27;, &#x27;Eden Hazard&#x27;, &#x27;Luis Suarez&#x27;, &#x27;Neymar&#x27;],
&#x27;Club&#x27;: [&#x27;Manchester United&#x27;, &#x27;PSG&#x27;, &#x27;Real Madrid&#x27;, &#x27;Atletico Madrid&#x27;, &#x27;PSG&#x27;]
}
</code></pre>
Let's try to &quot;pickle&quot; the <code>athletes</code> object to a binary file. We can do this with the <code>dump()</code> function. It takes two parameters - the object being “pickled” and a <code>File</code> object to write the data to. The following code “pickles” the data to a new file <code>athletes.txt</code> that will be created in the same directory the script is running in:
<pre><code class="hljs">athletes_file = open(&#x27;athletes.txt&#x27;, &#x27;wb&#x27;)
pickle.dump(athletes, athletes_file)
athletes_file.close()
</code></pre>

 <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: The mode that we have used in the file handling is <code>&quot;wb&quot;</code> which is used to write binary files. Since we are converting the object to byte stream we will use the <code>&quot;b&quot;</code> with each mode while handling files.

 </div>
 </div>
 </div>
 The created file's contents can't be viewed by a regular text editor because it's binary data and isn't meant to be stored in a human-readable format. To read this information, we'll have to “unpickle” or deserialize this data. We can do this with the <code>load()</code> function!
The <code>load()</code> function reads the contents of a “pickled” file and returns the object constructed by reading the data. The type of object as well as its state depend on the contents of the file. Since we've saved a dictionary with athlete names - this object with the same entries is reconstructed. Let's read the “pickled” file you just created back to a Python object and print its contents:
<pre><code class="hljs">import pickle

athletes_file = open(&quot;athletes.txt&quot;, &quot;rb&quot;)
athletes = pickle.load(athletes_file)
athletes_file.close()
print(athletes)
</code></pre>
This results in:
<pre><code class="hljs">{&#x27;Name&#x27;: [&#x27;Cristiano Ronaldo&#x27;, &#x27;Lionel Messi&#x27;, &#x27;Eden Hazard&#x27;, &#x27;Luis Suarez&#x27;, &#x27;Neymar&#x27;], &#x27;Club&#x27;: [&#x27;Manchester United&#x27;, &#x27;PSG&#x27;, &#x27;Real Madrid&#x27;, &#x27;Atletico Madrid&#x27;, &#x27;PSG&#x27;]}
</code></pre>
As you see, we get back all the data that was “pickled”.

 <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: Just like how we used <code>&quot;wb&quot;</code> to write binary data, we used the <code>&quot;rb&quot;</code> mode during file handling to read binary data.

 </div>
 </div>
 </div>
 Now that we've covered the process of “pickling” and “unpickling” in Python, let's read “pickled” files so that we can put their contents in a Pandas <code>DataFrame</code>!
<h2 id="howtoreadapicklefileinapandasdataframe">How to Read a Pickle File in a Pandas DataFrame?</h2>
We'll be using the same data as we did in the earlier examples. First, ensure that you have the Pandas library installed:
<pre><code class="hljs">$ pip install pandas
</code></pre>
Now let's start by converting the objects into a Python DataFrame:
<pre><code class="hljs">import pickle
import pandas as pd

athletes = {
 &quot;Name&quot;: [&quot;Cristiano Ronaldo&quot;, &quot;Lionel Messi&quot;, &quot;Eden Hazard&quot;, &quot;Luis Suarez&quot;, &quot;Neymar&quot;], 
 &quot;Club&quot;: [&quot;Manchester United&quot;, &quot;PSG&quot;, &quot;Real Madrid&quot;, &quot;Atletico Madrid&quot;, &quot;PSG&quot;]
}

df = pd.DataFrame(athletes)
print(df)
</code></pre>
This results in:
<pre><code class="hljs"> Name Club
0 Cristiano Ronaldo Manchester United
1 Lionel Messi PSG
2 Eden Hazard Real Madrid
3 Luis Suarez Atletico Madrid
4 Neymar PSG
</code></pre>
As you can see in the output, we will get a Pandas DataFrame object with 3 columns and 6 rows including the indices. After this, the process is similar to how we handled the normal, non-DataFrame objects. We will use file handling along with the <code>dump()</code> and <code>load()</code> methods to first create a “pickle” file from a Pandas <code>DataFrame</code>, and then read the byte stream to get the Pandas <code>DataFrame</code>:
<pre><code class="hljs"># ...
df = pd.DataFrame(athletes)

athelets_df_file = open(&quot;athletes_df.txt&quot;, &quot;wb&quot;)
pickle.dump(df, athelets_df_file)
athelets_df_file.close()
</code></pre>
The above code will create a “pickle” file that will store the Pandas DataFrame as a byte stream in our current directory as <code>athletes_df.txt</code>.
When we want to use this DataFrame again, we can just “unpickle” this file to get it back:
<pre><code class="hljs">import pickle

athletes_df_file = open(&quot;athletes_df.txt&quot;, &quot;rb&quot;)
athletes = pickle.load(athletes_df_file)
athletes_df_file.close()
print(athletes)
</code></pre>
This results in:
<pre><code class="hljs"> Name Club
0 Cristiano Ronaldo Manchester United
1 Lionel Messi PSG
2 Eden Hazard Real Madrid
3 Luis Suarez Atletico Madrid
4 Neymar PSG
</code></pre>
That's the awesome thing about “pickled” files! We don't just get the contents stored in the <code>DataFrame</code> object when we load it, we get the <code>DataFrame</code> object itself. Without these capabilities, it's common for programmers to save the data in an accessible format like JSON, and then load the JSON data into a new object to use it.
<blockquote>
Pickling and unpickling save us from using intermediate data formats and creating methods to load our data.
</blockquote>
<h2 id="picklingintostringsandunpicklingfromstrings">Pickling into Strings and Unpickling from Strings</h2>
It's good to know that the <code>pickle</code> module also provides us with <code>dumps()</code> and <code>loads()</code> methods as well. These methods will “pickle” and “unpickle” Python objects, but instead of using a binary file to store data they return and accept string data.
Let's take a look at a simple example to understand how the <code>dumps()</code> and <code>loads()</code> methods work in Python:
<pre><code class="hljs">import pickle

simple_obj = {1: [&#x27;o&#x27;, &#x27;n&#x27;, &#x27;e&#x27;], &quot;two&quot;: (1, 2), 3: &quot;Three&quot;}
pickled_obj = pickle.dumps(simple_obj)
print(pickled_obj)
</code></pre>
This results in:
<pre><code class="hljs">b&#x27;\x80\x04\x95-\x00\x00\x00\x00\x00\x00\x00}\x94(K\x01]\x94(\x8c\x01o\x94\x8c\x01n\x94\x8c\x01e\x94e\x8c\x03two\x94K\x01K\x02\x86\x94K\x03\x8c\x05Three\x94u.&#x27;
</code></pre>
As you can see in the output, the binary string is returned instead of a “pickled” file that was created with the <code>dump()</code> method. We can take this string and load the object in a new variable:
<pre><code class="hljs">out = pickle.loads(obj)
print(out)
</code></pre>
This results in:
<pre><code class="hljs">{1: [&#x27;o&#x27;, &#x27;n&#x27;, &#x27;e&#x27;], &#x27;two&#x27;: (1, 2), 3: &#x27;Three&#x27;}
</code></pre>
These two methods facilitate easier transfer between Python-based applications, and you could very well send “pickled” data through APIs. More commonly, though, for Python-based web applications, you'll be using JSON-serialized objects instead.
<h2 id="conclusion">Conclusion</h2>
In this article, we learned about the “pickling” and “unpickling” operations in Python that are useful to store your objects for later use. Methods like <code>load()</code>, <code>loads()</code>, <code>dump()</code>, <code>dumps()</code> are provided by the built-in <code>pickle</code> module to convert Python objects to and from byte streams.
Creating and loading the data to and from a Pandas <code>DataFrame</code> object can be done easily using the <code>pickle</code> module in Python.

 <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 that “pickling” and “unpickling” are not recommended if you are planning to use the objects in other programming languages as the module does not guarantee cross-programming compatibility.

 </div>
 </div>
 </div>

Marcus Sanatan

Mohammad Waseem

In this article, you will learn how to serialize and deserialize data in Python with the Pickle module. Furthermore, you'll use data that's been serialized/deserialized with Pandas.