<h2 id="introduction">Introduction</h2>
Data structures in JavaScript are often very composable. This means that you can take a data structure and transform it into a different data structure relatively easy. This is helpful when you need to transform data into a format that is more useful for your application.
In this article, we'll be looking at how to convert an array to an object with JavaScript.
<h2 id="whyconvertarraystoobjects">Why Convert Arrays to Objects?</h2>
Objects in JavaScript provide a structured way to store data with key-value pairs. This structure can be beneficial when we want to access data using specific keys, rather than relying on indices as we do with arrays. For instance, if we have a list of users with their respective properties, it's much more intuitive to access a user's age with <code>user.age</code> than with <code>user[3]</code>.
<h2 id="usingtheobjectassignmethod">Using the Object.assign() Method</h2>
One of the most obvious ways to convert an array to an object is by using the <code>Object.assign()</code> method. This method copies all enumerable own properties from one or more source objects to a target object and returns the target object.
Here's a simple example:
<pre><code class="hljs">let array = [&#x27;apple&#x27;, &#x27;banana&#x27;, &#x27;cherry&#x27;];
let object = Object.assign({}, array);

console.log(object);
</code></pre>
The output will be:
<pre><code class="hljs">{ &#x27;0&#x27;: &#x27;apple&#x27;, &#x27;1&#x27;: &#x27;banana&#x27;, &#x27;2&#x27;: &#x27;cherry&#x27; }
</code></pre>
As you can see, the <code>Object.assign()</code> method took our array and transformed it into an object, where the indices of the array became the keys of the object.

 <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>Object.assign()</code> method does not deep copy properties of the input object. This means that if your array contains objects and you modify those after using <code>Object.assign()</code>, the changes will be reflected in the new object as well.

 </div>
 </div>
 </div>
 <h2 id="usingthearrayreducemethod">Using the Array.reduce() Method</h2>
Another method for converting an array to an object is the <code>Array.reduce()</code> method. This applies a function against an accumulator and each element in the array (from left to right) to reduce it to a single output value.
Here's how you can use it:
<pre><code class="hljs">let array = [&#x27;apple&#x27;, &#x27;banana&#x27;, &#x27;cherry&#x27;];
let object = array.reduce((obj, item, index) =&gt; {
 obj[index] = item;
 return obj;
}, {});

console.log(object);
</code></pre>
The output will be the same as the previous example:
<pre><code class="hljs">{ &#x27;0&#x27;: &#x27;apple&#x27;, &#x27;1&#x27;: &#x27;banana&#x27;, &#x27;2&#x27;: &#x27;cherry&#x27; }
</code></pre>
In this example, we're using <code>Array.reduce()</code> to create a new object (<code>obj</code>), and for each item in the array, we're adding a new property to <code>obj</code> with a key of the current index and a value of the current item.
The advantage of the <code>Array.reduce()</code> method is that it gives us more flexibility. We can easily modify the code to use the array items as keys and the indices as values, or to transform the data in other ways.
<h2 id="usingthespreadoperator">Using the Spread Operator</h2>
One of the most elegant and modern (i.e. ES6) ways to convert an array to an object in JavaScript is by using the spread operator (<code>...</code>). Introduced in ES6, the spread operator lets us expand iterable elements like arrays into individual elements.
Here's how you can use the spread operator to convert an array to an object:
<pre><code class="hljs">const array = [&#x27;apple&#x27;, &#x27;banana&#x27;, &#x27;cherry&#x27;];
const object = { ...array };
console.log(object);
</code></pre>
The output of the above code will be:
<pre><code class="hljs">{ &#x27;0&#x27;: &#x27;apple&#x27;, &#x27;1&#x27;: &#x27;banana&#x27;, &#x27;2&#x27;: &#x27;cherry&#x27; }
</code></pre>
As you can see, the array indices become the keys of the object, and the array elements become the corresponding values.
<h2 id="convertingmultidimensionalarrays">Converting Multidimensional Arrays</h2>
Dealing with multidimensional arrays can be a bit confusing, especially for novice programmers. Lucky for us, JavaScript provides us with some nice tools to handle them. Let's say we have a 2D array where each sub-array contains a pair of values. We can convert this to an object where the first element of each pair is the key and the second element is the value:
<pre><code class="hljs">const array = [[&#x27;name&#x27;, &#x27;John&#x27;], [&#x27;age&#x27;, 30], [&#x27;city&#x27;, &#x27;New York&#x27;]];
const object = Object.fromEntries(array);
console.log(object);
</code></pre>
The output will then be:
<pre><code class="hljs">{ name: &#x27;John&#x27;, age: 30, city: &#x27;New York&#x27; }
</code></pre>
The <code>Object.fromEntries()</code> method transforms a list of key-value pairs into an object, which is perfect for our use case. The data in the multidimensional array is now much easier to access.
<h2 id="convertingarrayswithnonnumericindices">Converting Arrays with Non-numeric Indices</h2>

 <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: JavaScript arrays are technically objects, where indices are properties that can be strings. However, when we talk about arrays in a conventional sense, we usually think of them as lists with numeric indices.

 </div>
 </div>
 </div>
 So, how do we convert an array with non-numeric indices to an object? Well, in JavaScript, it's already an object! But if we want to convert it into a more standard object format, we can use the <code>Object.assign()</code> method.
Consider the following:
<pre><code class="hljs">const array = [];
array[&#x27;name&#x27;] = &#x27;John&#x27;;
array[&#x27;age&#x27;] = 30;
array[&#x27;city&#x27;] = &#x27;New York&#x27;;

const object = Object.assign({}, array);
console.log(object);
</code></pre>
The output will be:
<pre><code class="hljs">{ name: &#x27;John&#x27;, age: 30, city: &#x27;New York&#x27; }
</code></pre>
In case you're curious, what does the <code>array</code> variable look like after assigning values to non-numeric indices? This can be pretty unintuitive, but once you can wrap your head around arrays actually being objects, it can make more sense.
<pre><code class="hljs">const array = [];
array[&#x27;name&#x27;] = &#x27;John&#x27;;
array[&#x27;age&#x27;] = 30;
array[&#x27;city&#x27;] = &#x27;New York&#x27;;

console.log(object);
</code></pre>
<pre><code class="hljs">[ name: &#x27;John&#x27;, age: 30, city: &#x27;New York&#x27; ]
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this Byte, we've seen the different ways to convert an array to an object in JavaScript, including using <code>Object.assign()</code>, <code>Array.reduce()</code>, and the spread operator. We also showed how to deal with multidimensional arrays and handle arrays with non-numeric indices.

Scott Robinson

How to Convert an Array to an Object with JavaScript

<h2 id="introduction">Introduction</h2>
In Python, variables declared outside of the function or in global space are known as global variables. These variables can be accessed by any function in the program. However, there may be instances where you want to delete or change a global variable within a function. This byte will guide you through the process of doing just that.
<h2 id="globalvariablesinpython">Global Variables in Python</h2>
Before we delve into how to delete or change a global variable, let's take a moment to understand what a global variable is. In Python, a variable declared outside of a function is known as a global variable. This means that the variable can be accessed from anywhere in the code - be it within a function or outside.
Here's a simple example of a global variable:
<pre><code class="hljs">x = 10

def print_global():
 print(&quot;The global variable is: &quot;, x)

print_global()
</code></pre>
Output:
<pre><code class="hljs">The global variable is: 10
</code></pre>
Here, <code>x</code> is a global variable because it is defined outside of the <code>print_global</code> function, yet it can still be accessed within the function.
<h2 id="whydeleteaglobalvariable">Why Delete a Global Variable?</h2>
So you might be wondering, why would we ever want to delete a global variable? Well, in large programs, global variables can consume significant memory resources, especially if they contain large data structures or objects. Or maybe your list of global variables (via <code>globals()</code>) has become far too cluttered.
One advantage of deleting global variables you no longer need is that it can help to free up memory, improving the footprint and efficiency of your code.

 <div class="alert alert-warn">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-exclamation-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Wait! Deleting a global variable should be done with caution, as it can lead to errors if other parts of your program are still trying to access it.

 </div>
 </div>
 </div>
 <h2 id="howtodeleteaglobalvariable">How to Delete a Global Variable</h2>
Deleting a global variable in Python is pretty easy to do - we just use the <code>del</code> keyword. However, if you try to delete a global variable directly within a function, you will encounter an error. This is because Python treats variables as local by default within functions.
Here's an example:
<pre><code class="hljs">x = 10

def delete_global():
 del x
 print(x)

delete_global()
</code></pre>
This will output:
<pre><code class="hljs">UnboundLocalError: local variable &#x27;x&#x27; referenced before assignment
</code></pre>
To delete the global variable within the function, we need to declare it as global within the function using the <code>global</code> keyword:
<pre><code class="hljs">x = 10

def delete_global():
 global x
 del x

delete_global()

print(x)
</code></pre>
This will output:
<pre><code class="hljs">NameError: name &#x27;x&#x27; is not defined
</code></pre>
As you can see, after calling the <code>delete_global</code> function, trying to print <code>x</code> results in a <code>NameError</code> because the global variable <code>x</code> has been deleted.
<h2 id="conclusion">Conclusion</h2>
In this Byte, we've learned about global variables in Python and why you might want to delete them. We've also seen how to delete a global variable within a function using the <code>del</code> and <code>global</code> keywords. Just always make sure that the variable is not needed elsewhere in your code before deleting it.

How to Delete a Global Variable in Python

<h2 id="introduction">Introduction</h2>
In this Byte we'll see several methods to find multiple elements in an array. By the end, you'll know how to do it with methods like <code>include()</code>, <code>some()</code>, and <code>every()</code>.
<h2 id="whycheckformultiplevaluesinanarray">Why Check for Multiple Values in an Array?</h2>
When using arrays, there are times when we need to check if certain values exist in an array. This could be for any number of reasons, like filtering data or simply checking conditions in your code.
For example, let's say you're building a movie recommendation engine. You have an array of all the movies a user has watched, and an array of unwatched movies. Now, to recommend a new movie, you'd want to check the movies array for the movies that have been watched so that you can then only recommend new movies.
In the next few sections we'll show the different methods you can use to achieve this.
<h2 id="usingtheincludesmethod">Using the includes() Method</h2>
The <code>includes()</code> method is a built-in JavaScript method that checks if a specific element exists in an array. It returns <code>true</code> if the element is found, and <code>false</code> otherwise.
Here's an example:
<pre><code class="hljs">let fruits = [&#x27;apple&#x27;, &#x27;banana&#x27;, &#x27;cherry&#x27;, &#x27;date&#x27;];

console.log(fruits.includes(&#x27;banana&#x27;)); // true
console.log(fruits.includes(&#x27;grape&#x27;)); // false
</code></pre>
However, <code>includes()</code> only checks for a single value. To check for multiple values, we can use a simple <code>for</code> loop:
<pre><code class="hljs">let fruits = [&#x27;apple&#x27;, &#x27;banana&#x27;, &#x27;cherry&#x27;, &#x27;date&#x27;];
let checkFruits = [&#x27;banana&#x27;, &#x27;date&#x27;, &#x27;grape&#x27;];

for (let i = 0; i &lt; checkFruits.length; i++) {
 console.log(fruits.includes(checkFruits[i]));
}
</code></pre>
Here, we loop over the <code>checkFruits</code> array and checking if each fruit exists in the <code>fruits</code> array. The output will be <code>true</code> for 'banana' and 'date', and <code>false</code> for 'grape'.
<h2 id="usingthesomemethod">Using the some() Method</h2>
The <code>some()</code> method is another method that tests whether at least one element in the array passes the test given by the provided function. It returns <code>true</code> if at least one element passes the test, and <code>false</code> otherwise.
We can use the <code>some()</code> method to check if multiple values exist in an array:
<pre><code class="hljs">let fruits = [&#x27;apple&#x27;, &#x27;banana&#x27;, &#x27;cherry&#x27;, &#x27;date&#x27;];
let checkFruits = [&#x27;banana&#x27;, &#x27;date&#x27;, &#x27;grape&#x27;];

let result = checkFruits.some(fruit =&gt; fruits.includes(fruit));
console.log(result); // true
</code></pre>
In this code, we're using the <code>some()</code> method on the <code>checkFruits</code> array. The function we gave checks if each fruit exists in the <code>fruits</code> array using the <code>includes()</code> method. The <code>some()</code> method returns <code>true</code> because 'banana' and 'date' exist in the <code>fruits</code> array, even though 'grape' does not. All it needs is for one item to be true for the entire function to returnt true.
<h2 id="usingtheeverymethod">Using the every() Method</h2>
The <code>every()</code> method in JavaScript is another useful method that can be used to check if all elements in an array pass a test from our function. Let's see how we can use this method to check if multiple values exist in an array.
<pre><code class="hljs">let fruits = [&#x27;apple&#x27;, &#x27;banana&#x27;, &#x27;cherry&#x27;, &#x27;date&#x27;];
let checkFruits = [&#x27;banana&#x27;, &#x27;date&#x27;, &#x27;grape&#x27;];

let result = checkFruits.every(fruit =&gt; fruits.includes(fruit));
console.log(result); // false
</code></pre>
Similar to our previous examples, this will check if the items in <code>checkFruits</code> exist in <code>fruits</code>. However, since we use the <code>every()</code> method, it will only return true if all items from <code>checkFruits</code> exist in <code>fruits</code>, which in this case is false.
<h2 id="conclusion">Conclusion</h2>
In this Byte, we've shown different methods to check if multiple values exist in an array in JavaScript. We've seen how we can use the <code>includes()</code> method, <code>some()</code> method, and the <code>every()</code> method to check for multiple values.

JavaScript: Check if Multiple Values Exist in Array

<h2 id="introduction">Introduction</h2>
Let's say you have a list of home addresses and want to see which ones reside on a &quot;Street&quot;, &quot;Ave&quot;, &quot;Lane&quot;, etc. Given the variability of physical addresses, you'd probably want to use a regular expression to do the matching. But how do you apply a regex to a list? That's exactly what we'll be looking at in this Byte.
<h2 id="whymatchlistswithregularexpressions">Why Match Lists with Regular Expressions?</h2>
Regular expressions are one of best, if not the best, ways to do pattern matching on strings. In short, they can be used to check if a string contains a specific pattern, replace parts of a string, and even split a string based on a pattern.
Another reason you may want to use a regex on a list of strings: you have a list of email addresses and you want to filter out all the invalid ones. You can use a regular expression to define the pattern of a valid email address and apply it to the entire list in one go. There are an endless number of examples like this as to why you'd want to use a regex over a list of strings.
<h2 id="pythonsregexmodule">Python's Regex Module</h2>
Python's <code>re</code> module provides built-in support for regular expressions. You can import it as follows:
<pre><code class="hljs">import re
</code></pre>
The <code>re</code> module has several functions to work with regular expressions, such as <code>match()</code>, <code>search()</code>, and <code>findall()</code>. We'll be using these functions to check if any element in a list matches a regular expression.

 <div class="alert alert-reference">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-link-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Link: For more information on using regex in Python, check out our article, <a target="_blank" href="https://stackabuse.com/introduction-to-regular-expressions-in-python/">Introduction to Regular Expressions in Python</a>

 </div>
 </div>
 </div>
 <h2 id="usingthematchfunction">Using the match() Function</h2>
To check if any element in a list matches a regular expression, you can use a loop to iterate over the list and the <code>re</code> module's <code>match()</code> function to check each element. Here's an example:
<pre><code class="hljs">import re

# List of strings
list_of_strings = [&#x27;apple&#x27;, &#x27;banana&#x27;, &#x27;cherry&#x27;, &#x27;date&#x27;]

# Regular expression pattern for strings starting with &#x27;a&#x27;
pattern = &#x27;^a&#x27;

for string in list_of_strings:
 if re.match(pattern, string):
 print(string, &quot;matches the pattern&quot;)
</code></pre>
In this example, the <code>match()</code> function checks if each string in the list starts with the letter 'a'. The output will be:
<pre><code class="hljs">apple matches the pattern
</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>^</code> character in the regular expression pattern indicates the start of the string. So, <code>^a</code> matches any string that starts with 'a'.

 </div>
 </div>
 </div>
 This is a basic example, but you can use more complex regular expression patterns to match more specific conditions. For example, here is a regex for <a target="_blank" href="https://stackabuse.com/python-validate-email-address-with-regular-expressions-regex/">matching an email address</a>:
<pre><code class="hljs">([A-Za-z0-9]+[.-_])*[A-Za-z0-9]+@[A-Za-z0-9-]+(\.[A-Z|a-z]{2,})+
</code></pre>
<h2 id="usingthesearchfunction">Using the search() Function</h2>
While <code>re.match()</code> is great for checking the start of a string, <code>re.search()</code> scans through the string and returns a <code>MatchObject</code> if it finds a match anywhere in the string. Let's tweak our previous example to find any string that contains &quot;Hello&quot;.
<pre><code class="hljs">import re

my_list = [&#x27;Hello World&#x27;, &#x27;Python Hello&#x27;, &#x27;Goodbye World&#x27;, &#x27;Say Hello&#x27;]
pattern = &quot;Hello&quot;

for element in my_list:
 if re.search(pattern, element):
 print(f&quot;&#x27;{element}&#x27; matches the pattern.&quot;)
</code></pre>
The output will be:
<pre><code class="hljs">&#x27;Hello World&#x27; matches the pattern.
&#x27;Python Hello&#x27; matches the pattern.
&#x27;Say Hello&#x27; matches the pattern.
</code></pre>
As you can see, <code>re.search()</code> found the strings that contain &quot;Hello&quot; anywhere, not just at the start.
<h2 id="usingthefindallfunction">Using the findall() Function</h2>
The <code>re.findall()</code> function returns all non-overlapping matches of pattern in string, as a list of strings. This can be useful when you want to extract all occurrences of a pattern from a string. Let's use this function to find all occurrences of &quot;Hello&quot; in our list.
<pre><code class="hljs">import re

my_list = [&#x27;Hello Hello&#x27;, &#x27;Python Hello&#x27;, &#x27;Goodbye World&#x27;, &#x27;Say Hello Hello&#x27;]
pattern = &quot;Hello&quot;

for element in my_list:
 matches = re.findall(pattern, element)
 if matches:
 print(f&quot;&#x27;{element}&#x27; contains {len(matches)} occurrence(s) of &#x27;Hello&#x27;.&quot;)
</code></pre>
The output will be:
<pre><code class="hljs">&#x27;Hello Hello&#x27; contains 2 occurrence(s) of &#x27;Hello&#x27;.
&#x27;Python Hello&#x27; contains 1 occurrence(s) of &#x27;Hello&#x27;.
&#x27;Say Hello Hello&#x27; contains 2 occurrence(s) of &#x27;Hello&#x27;.
</code></pre>
<h2 id="workingwithnestedlists">Working with Nested Lists</h2>
What happens if our list contains other lists? Python's <code>re</code> module functions won't work directly on nested lists, just like it wouldn't work with the root list in the previous examples. We need to flatten the list or iterate through each sub-list.
Let's consider a list of lists, where each sub-list contains strings. We want to find out which strings contain &quot;Hello&quot;.
<pre><code class="hljs">import re

my_list = [[&#x27;Hello World&#x27;, &#x27;Python Hello&#x27;], [&#x27;Goodbye World&#x27;], [&#x27;Say Hello&#x27;]]
pattern = &quot;Hello&quot;

for sub_list in my_list:
 for element in sub_list:
 if re.search(pattern, element):
 print(f&quot;&#x27;{element}&#x27; matches the pattern.&quot;)
</code></pre>
The output will be:
<pre><code class="hljs">&#x27;Hello World&#x27; matches the pattern.
&#x27;Python Hello&#x27; matches the pattern.
&#x27;Say Hello&#x27; matches the pattern.
</code></pre>
We first loop through each sub-list in the main list. Then for each sub-list, we loop through its elements and apply <code>re.search()</code> to find the matching strings.
<h2 id="workingwithmixeddatatypelists">Working with Mixed Data Type Lists</h2>
Python lists are versatile and can hold a variety of data types. This means you can have a list with integers, strings, and even other lists. This is great for a lot of reasons, but it also means you have to deal with potential issues when the data types matter for your operation. When working with regular expressions, we only deal with strings. So, what happens when we have a list with mixed data types?
<pre><code class="hljs">import re

mixed_list = [1, &#x27;apple&#x27;, 3.14, &#x27;banana&#x27;, &#x27;123&#x27;, &#x27;abc123&#x27;, &#x27;123abc&#x27;]

regex = r&#x27;\d+&#x27; # matches any sequence of digits

for element in mixed_list:
 if isinstance(element, str) and re.match(regex, element):
 print(f&quot;{element} matches the regex&quot;)
 else:
 print(f&quot;{element} does not match the regex or is not a string&quot;)
</code></pre>
In this case, the output will be:
<pre><code class="hljs">1 does not match the regex or is not a string
apple does not match the regex or is not a string
3.14 does not match the regex or is not a string
banana does not match the regex or is not a string
123 matches the regex
abc123 does not match the regex or is not a string
123abc matches the regex
</code></pre>
We first check if the current element is a string. Only then do we check if it matches the regular expression. This is because the <code>re.match()</code> function expects a string as input. If you try to use it on an integer or a float, Python will throw an error.
<h2 id="conclusion">Conclusion</h2>
Python's <code>re</code> module provides several functions to match regex patterns in strings. In this Byte, we learned how to use these functions to check if any element in a list matches a regular expression. We also saw how to handle lists with mixed data types. Regular expressions can be complex, so take your time to understand them. With a bit of practice, you'll find that they can be used to solve many problems when working with strings.

Check if Elements in List Matches a Regex in Python

<h2 id="introduction">Introduction</h2>
Working with any language, you've probably come across warnings - and lots of them. In Python, our warnings are the yellow-highlighted messages that appear when code runs. These warnings are Python's way of telling us that, while our code is technically correct and will run, there's something in it that's not quite right or could eventually lead to issues. Sometimes these warnings are helpful, and sometimes they're not. So what if we want to disable them?
In this Byte, we'll show a bit more about what Python warnings are, why you might want to disable them, and how you can do it.
<h2 id="pythonwarnings">Python Warnings</h2>
Python warnings are messages that the Python interpreter throws when it encounters unusual code that may not necessarily result in an error, but is probably not what you intended. These warnings can include things like deprecation warnings, which tell you when a Python feature is being phased out, or syntax warnings, which alert you to weird but syntactically correct code.
Here's an example of a warning you might see:
<pre><code class="hljs">import warnings

def fxn():
 warnings.warn(&quot;fxn() is deprecated&quot;, DeprecationWarning, stacklevel=2)

warnings.simplefilter(&#x27;always&#x27;, DeprecationWarning)
fxn()
</code></pre>
When you run this code, Python will output a <code>DeprecationWarning</code>:
<pre><code class="hljs">$ python warnings.py 
warnings.py:9: DeprecationWarning: fxn() is deprecated
 fxn()
</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: We had to add the <code>warnings.simplefilter('always', DeprecationWarning)</code> line in order to get the warning to show. Otherwise <code>DeprecationWarning</code>s are ignored by default.

 </div>
 </div>
 </div>
 <h2 id="whydisablethem">Why disable them?</h2>
That's a good question. Warnings are indeed useful, but there are times when you might want to disable them.
For example, if you're working with a large codebase and you're aware of the warnings but have decided to ignore them for now, having them constantly pop up can be not only annoying but also cause you to miss more important output from your code. In the same vein, if you're running a script that's outputting to a log file, you might not want warnings cluttering up your logs.
<h2 id="howtodisablepythonwarnings">How to Disable Python Warnings</h2>
There are a few ways to disable warnings in Python, and we'll look at three of them: using the <code>warnings</code> module, using command line options, and using environment variables.
<h3 id="usingthewarningsmodule">Using the warnings Module</h3>
Python's <code>warnings</code> module provides a way to control how warnings are displayed. You can use the <code>filterwarnings</code> function to ignore all warnings programmatically:
<pre><code class="hljs">import warnings
warnings.filterwarnings(&quot;ignore&quot;)
</code></pre>
This will suppress all warnings. If you want to suppress only a specific type of warning, you can do so by specifying the warning class:
<pre><code class="hljs">warnings.filterwarnings(&quot;ignore&quot;, category=DeprecationWarning)
</code></pre>
In this case, only <code>DeprecationWarning</code>s will be suppressed.
<h3 id="usingcommandlineoptions">Using Command Line Options</h3>
If you're running your Python script from the command line, you can use the <code>-W</code> option followed by <code>ignore</code> to suppress all warnings:
<pre><code class="hljs">$ python -W ignore your_script.py
</code></pre>
<h3 id="usingenvironmentvariables">Using Environment Variables</h3>
You can also use the <code>PYTHONWARNINGS</code> environment variable to control the display of warnings. To ignore all warnings, you can set this variable to <code>ignore</code>:
<pre><code class="hljs">$ export PYTHONWARNINGS=&quot;ignore&quot;
$ python your_script.py
</code></pre>
This will suppress all warnings for the entire session. If you want to suppress warnings for all sessions, you can add the <code>export PYTHONWARNINGS=&quot;ignore&quot;</code> line to your shell's startup file (like <code>.bashrc</code> or <code>.bash_profile</code> for bash) so that this setting is always set.
<h2 id="risksofdisablingwarnings">Risks of Disabling Warnings</h2>
While there are several ways to disable warnings in Python, you should also understand the risks associated with doing this.
For example, a <code>DeprecationWarning</code> alerts you that a function you're using is slated for removal in a future version of Python or a library. If you ignore this warning, your code may suddenly stop working when you upgrade to a new version.
As a general rule, it's best to just fix the issues causing the warnings, instead of simply suppressing the warnings. There are, however, situations where removing warnings is actually the most practical solution, like when you're using a library that generates warnings you can't control and aren't actually helpful. In these cases, it's best to just suppress only the specific warnings you need to, and avoid using a blanket &quot;ignore all&quot; command.
<h2 id="conclusion">Conclusion</h2>
Warnings are there for a reason, like signaling potential issues in the code that might lead to bugs or unexpected behavior, so it's best not to suppress them. However, there are times when you may want to disable these warnings, whether to clean up your console output or because you're aware of the warning and have decided it's not relevant to your particular situation.
In this Byte, we've learned about Python's warnings, how to suppress them, along with the potential risks of doing so.

How to Disable Warnings in Python

<h2 id="introduction">Introduction</h2>
In the world of JavaScript, there are lots of ways to manipulate strings as JS provides many methods to do so. Two of those methods are <code>substr()</code> and <code>substring()</code>. At first glance, they might seem identical - both are used to extract parts of a string. However, they have subtle differences in the way they work. This Byte aims to shed light on these two methods, their differences, and when to use each.
<h2 id="substr">substr()</h2>
The <code>substr()</code> method in JavaScript is used to extract parts of a string, starting from the index specified and extending for a given number of characters afterwards. Its syntax is as follows:
<pre><code class="hljs">string.substr(startIndex, length)
</code></pre>
The <code>startIndex</code> parameter is required and specifies where to start the substring to be extracted. The <code>length</code> parameter is optional and specifies the number of characters to extract. If <code>length</code> is not provided, characters will be extracted to the end of the string.
Here's an example:
<pre><code class="hljs">let text = &quot;Hello, World!&quot;;
let result = text.substr(7, 5);
console.log(result); // Outputs: &quot;World&quot;
</code></pre>
In this example, <code>substr()</code> starts at the index 7 of the string and returns 5 characters, resulting in &quot;World&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: <code>substr()</code> does support negative indexing. So if <code>startIndex</code> is a negative number, it counts from the end of the string.

 </div>
 </div>
 </div>
 <h2 id="substring">substring()</h2>
The <code>substring()</code> method, on the other hand, also extracts characters from a string between two indices. Its syntax is as follows:
<pre><code class="hljs">string.substring(indexStart, indexEnd)
</code></pre>
Both <code>indexStart</code> and <code>indexEnd</code> parameters are optional. If <code>indexEnd</code> is not given, characters will be extracted to the end of the string, just like with <code>substr()</code>.
Here's an example:
<pre><code class="hljs">let text = &quot;Hello, World!&quot;;
let result = text.substring(7, 12);
console.log(result); // Outputs: &quot;World&quot;
</code></pre>
In this example, <code>substring()</code> starts at index 7 and ends at index 12, which returns &quot;World&quot;.
<h2 id="comparingsubstrandsubstring">Comparing substr() and substring()</h2>
Although both <code>substr()</code> and <code>substring()</code> are used for extracting parts of a string, they do have their differences, mostly in how their parameters work.
The second parameter in <code>substr()</code> is the number of characters to extract, whereas in <code>substring()</code>, it is the index where to stop the extraction.
Also, <code>substr()</code> can accept a negative start index, which is counted from the end of the string. However, <code>substring()</code> does not support negative indices. If a negative or <code>NaN</code> is passed, it will be treated as if it were a 0.
Here's a code snippet demonstrating these differences:
<pre><code class="hljs">let text = &quot;Hello, World!&quot;;

let substrResult = text.substr(-6, 5);
console.log(substrResult); // Outputs: &quot;World&quot;

let substringResult = text.substring(-6, 5);
console.log(substringResult); // Outputs: &quot;Hello&quot;
</code></pre>
You can see that <code>substr()</code> treats the negative start index as a position from the end of the string and returns &quot;World&quot;, while <code>substring()</code> treats the negative index as 0 and returns &quot;Hello&quot;.
<h2 id="whentouseeach">When to Use Each</h2>
I should start off by saying that the <code>substr()</code> method is deprecated, so by default you should use the <code>substring()</code> method instead. However, it's still supported in major browsers, so it can still be used if needed, but I don't recommend it.
The <code>substr()</code> method is great for when you want to extract a string from the end. For instance, if you want to retrieve the last four characters of a string, <code>substr()</code> is your go-to method since it supports negative indexing.
<pre><code class="hljs">let str = &quot;Hello, World!&quot;;
let lastFour = str.substr(-4); // &quot;rld!&quot;
console.log(lastFour);
</code></pre>
In this case, we're passing a negative value to <code>substr()</code>, which starts counting from the end of the string. The output will be &quot;rld!&quot;.
On the other hand, <code>substring()</code> may be better if you're dealing with indexes instead of lengths. If you know the start and end indexes of the substring you want, <code>substring()</code> may be the better choice.
<pre><code class="hljs">let str = &quot;Hello, World!&quot;;
let world = str.substring(7, 12); // &quot;World&quot;
console.log(world);
</code></pre>
In this case, we're passing the start and end indexes to <code>substring()</code>. The output will be &quot;World&quot;.
<h2 id="conclusion">Conclusion</h2>
In this Byte we compared the string manipulation methods <code>substr()</code> and <code>substring()</code>. Both methods have their own strengths and use-cases. <code>substr()</code> is typically better when dealing with lengths, especially from the end of strings, while <code>substring()</code> is more intuitive when working with known indexes. Although, note that <code>substr()</code> is technically deprecated, so <code>substring()</code> should be preferred.

Difference Between substr() and substring() in JavaScript

<h2 id="introduction">Introduction</h2>
JavaScript is a remarkably flexible language, but it's not without its limitations. One of these limitations is the maximum and minimum integer value that can be accurately represented. In this Byte, we'll discuss the JavaScript number type, the maximum and minimum integer values in JavaScript, and how you can work around these limitations if needed.
<h2 id="javascriptsnumbertype">JavaScript's Number Type</h2>
In JavaScript, numbers are stored as 64-bit floating point values, following the international <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/IEEE_754">IEEE 754</a> standard. This format stores numbers in three parts: the sign, the exponent, and the fraction. It's this format that allows JavaScript to handle a very wide range of values, from very small to very large.
However, because of the way numbers are stored, there is a limit to the size of an integer that can be accurately represented.
<h2 id="maximumintegervalueinjavascript">Maximum Integer Value in JavaScript</h2>
The largest exact integral value that JavaScript can represent is 2^53 - 1, or 9007199254740991. This value is defined in JavaScript as <code>Number.MAX_SAFE_INTEGER</code>.
<pre><code class="hljs">console.log(Number.MAX_SAFE_INTEGER);
// Output: 9007199254740991
</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 term &quot;safe&quot; in <code>MAX_SAFE_INTEGER</code> refers to the ability to represent integers exactly and to correctly compare them. For example, <code>(Number.MAX_SAFE_INTEGER + 1) === Number.MAX_SAFE_INTEGER</code> will return <code>true</code>, because the value of <code>Number.MAX_SAFE_INTEGER + 1</code> can't be represented exactly and is rounded to <code>Number.MAX_SAFE_INTEGER</code>.

 </div>
 </div>
 </div>
 <h2 id="minimumintegervalueinjavascript">Minimum Integer Value in JavaScript</h2>
Similarly, the smallest exact integral value that JavaScript can represent is -(2^53 - 1), or -9007199254740991. This value is defined in JavaScript as <code>Number.MIN_SAFE_INTEGER</code>.
<pre><code class="hljs">console.log(Number.MIN_SAFE_INTEGER);
// Output: -9007199254740991
</code></pre>
Remember that these limitations are inherent to the way JavaScript (and many other languages) represent numbers. If you need to work with larger or smaller integers, you'll need to use a workaround, like the <code>BigInt</code> type, which we'll briefly cover later in this Byte.
<h2 id="othernumberpropertiesinjavascript">Other Number Properties in JavaScript</h2>
JavaScript provides a few other built-in properties to work with numbers. For instance, <code>Number.MAX_VALUE</code> returns the largest positive representable number, which is approximately 1.8e+308. On the other hand, <code>Number.MIN_VALUE</code> gives the smallest positive representable number, which is about 5e-324.
<pre><code class="hljs">console.log(Number.MAX_VALUE); // 1.7976931348623157e+308
console.log(Number.MIN_VALUE); // 5e-324
</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>Number.MIN_VALUE</code> is not the lowest number JavaScript can handle. It's the smallest positive number greater than zero that JavaScript can represent with precision.

 </div>
 </div>
 </div>
 There's also <code>Number.POSITIVE_INFINITY</code> and <code>Number.NEGATIVE_INFINITY</code> which represent the mathematical concepts of positive and negative infinity.
<pre><code class="hljs">console.log(Number.POSITIVE_INFINITY); // Infinity
console.log(Number.NEGATIVE_INFINITY); // -Infinity
</code></pre>
<h2 id="bigintanalternativeforlargerintegers">BigInt: An Alternative for Larger Integers</h2>
When dealing with numbers larger than <code>Number.MAX_SAFE_INTEGER</code>, JavaScript has another number type called <code>BigInt</code>. It can represent integers of arbitrary length. A <code>BigInt</code> is created by appending <code>n</code> to the end of an integer or by calling the <code>BigInt</code> function.
<pre><code class="hljs">let big = 9007199254740993n;
console.log(big); // 9007199254740993n

big = BigInt(9007199254740993);
console.log(big); // 9007199254740993n
</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>BigInt</code> and <code>Number</code> are not implicitly convertible. You have to manually convert them if you want to use them together in an operation. Keep in mind that you may not be able to accuratley convert a <code>BigInt</code> to a <code>Number</code> due to the fact that it can represent much larger numbers than <code>Number</code> is able to handle.

 </div>
 </div>
 </div>
 <h2 id="conclusion">Conclusion</h2>
Understanding JavaScript's number properties, including the maximum and minimum integer values that can be accurately represented, is important for avoiding unexpected results in your calculations. For handling larger integers, <code>BigInt</code> is a great, built-in alternative.

Maximum and Minimum Values for Integers in JavaScript

<h2 id="introduction">Introduction</h2>
Python, somewhat similar ot Node, uses a system of installed modules/packages. But as you continue to install more and more modules, it might get a bit tricky to keep track of all of them. In this Byte, we'll explore how to get a list of all locally installed Python modules, which can be very helpful in managing your Python environment.
<h2 id="pythonmodules">Python Modules</h2>
A Python module is basically just a file (or directory of files) containing Python definitions and statements. These modules can define functions, classes, and variables that can be utilized in other Python code. It's like a toolkit filled with various tools, each designed for a specific task. Python comes with a standard library of modules, but the beauty of Python actually lies in the vast array of 3rd party modules that are available. These can be installed locally and used as needed.
For instance, if you're working on a web scraping project, you might install the <code>BeautifulSoup</code> module. Or, if you're dealing with data analysis, the <code>pandas</code> module is popular for many data-related tasks.
<h2 id="howtolistinstalledpythonmodules">How to List Installed Python Modules</h2>
Python provides a few different ways to list all the modules installed in your local environment. The most common method is using the <code>pip</code> command, which is the standard package manager for Python.
<h3 id="usingpiplist">Using pip list</h3>
The <code>pip list</code> command is a quick way to see all the Python modules installed in your current environment. Open up your terminal or command line interface and type in the following command:
<pre><code class="hljs">$ pip list
</code></pre>
This will provide you with a list of all installed packages, along with their respective versions.
<pre><code class="hljs">Package Version
--------------- -------
beautifulsoup4 4.9.3
numpy 1.19.5
pandas 1.1.5
pip 21.0.1
setuptools 54.1.2
</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: Remember that the list of modules you see will be specific to your current Python environment. If you're using a virtual environment, only the modules installed in that environment will be shown.

 </div>
 </div>
 </div>
 That's it for the <code>pip list</code> command. It's a pretty simple way to get a quick overview of your installed Python modules. In the next section of this Byte, we'll see another useful command, <code>pip freeze</code>, and see how it differs from <code>pip list</code>.
<h3 id="usingpipfreeze">Using pip freeze</h3>
<code>pip freeze</code> is another command that you can use to list all installed Python modules. But unlike <code>pip list</code>, <code>pip freeze</code> returns the list of modules in a format that <code>pip</code> can consume. This means each line of the output is a valid argument for <code>pip install</code>.
Let's run <code>pip freeze</code> in the command line and see what it gives us:
<pre><code class="hljs">$ pip freeze
</code></pre>
This will return something like:
<pre><code class="hljs">asn1crypto==0.24.0
certifi==2018.1.18
cffi==1.11.5
chardet==3.0.4
cryptography==2.1.4
idna==2.6
pycparser==2.18
PySocks==1.6.8
requests==2.18.4
six==1.11.0
urllib3==1.22
</code></pre>
Each line in the output is a module along with its installed version. This is super helpful when you need to replicate your environment elsewhere or create your requirements.txt file.
<h2 id="differencesbetweenpiplistandpipfreeze">Differences Between pip list and pip freeze</h2>
Now that you've seen both <code>pip list</code> and <code>pip freeze</code> in action, you might be wondering what the difference is, other than some simple formatting.
And the main difference between the two commands really is just the formatting of their output. <code>pip list</code> outputs a slightly more human-readable format of installed packages, which is great when you're quickly checking what's installed. On the other hand, <code>pip freeze</code> outputs a list of packages in a format that <code>pip</code> can use in other commands. This is particularly useful when you want to replicate your environment, as you can simply redirect the output of <code>pip freeze</code> to a requirements file, then use <code>pip install -r requirements.txt</code> on another machine to install the same packages.

 <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: Both <code>pip list</code> and <code>pip freeze</code> will list all installed packages, regardless of where they were installed from. This includes packages installed via pip, setup.py, and other package managers.

 </div>
 </div>
 </div>
 <h2 id="listingmodulesinavirtualenvironment">Listing Modules in a Virtual Environment</h2>
Working in a virtual environment can help you manage dependencies for different Python projects and keep them separate. When you activate a virtual environment, <code>pip list</code> and <code>pip freeze</code> will only show the packages installed in that environment.
To illustrate, let's create a new virtual environment and install a package:
<pre><code class="hljs">$ python3 -m venv myenv
$ source myenv/bin/activate
(myenv) $ pip install requests
</code></pre>
Now, if we run <code>pip list</code> or <code>pip freeze</code>, only the <code>requests</code> package and its dependencies will be listed:
<pre><code class="hljs">(myenv) $ pip list
</code></pre>
<pre><code class="hljs">Package Version
---------- -------
certifi 2021.5.30
chardet 4.0.0
idna 2.10
requests 2.25.1
urllib3 1.26.6
</code></pre>
<h2 id="conclusion">Conclusion</h2>
To sum up, Python provides a few ways to list all installed modules, whether you're working in a global or virtual environment. <code>pip list</code> and <code>pip freeze</code> are two commands that not only list the installed packages but also provide additional info, namely the version of the packages. Remember that the list of installed packages can vary depending on your active environment, so always double-check which environment you're in before installing or listing packages.

How to List Installed Python Modules

<h2 id="introduction">Introduction</h2>
In web development, we often need to communicate with servers to send or receive data. This is typically done via HTTP requests, and one of the most common types of requests is the POST request. In this Byte, we're going to explore how to use the Fetch API to send POST requests with JSON data from our JavaScript applications.
<h2 id="thefetchapi">The Fetch API</h2>
The Fetch API is a modern, promise-based API that makes it easy to make asynchronous HTTP requests from the browser or Node.js. It's built into most modern browsers and replaces the older, callback-based XMLHttpRequest.
Here's a basic example of how to use the Fetch API to send a GET request:
<pre><code class="hljs">fetch(&#x27;https://api.example.com/data&#x27;)
 .then(response =&gt; response.json())
 .then(data =&gt; console.log(data))
 .catch(error =&gt; console.error(&#x27;Error:&#x27;, error));
</code></pre>
The <code>fetch()</code> call returns a Promise that resolves to the <code>Response</code> object which represents the response to the request. The <code>response.json()</code> method also returns a Promise that resolves with the result of parsing the body text as JSON.
<h2 id="howtopostjsondatawithfetchapi">How to Post JSON Data with Fetch API</h2>
To send a POST request with JSON data using Fetch, we need to pass an <code>options</code> object as the second argument to <code>fetch()</code>. This object includes properties like <code>method</code>, <code>headers</code>, and <code>body</code>.
Here's how we can do it:
<pre><code class="hljs">const url = &#x27;https://api.example.com/data&#x27;;
const data = { username: &#x27;example&#x27; };

fetch(url, {
 method: &#x27;POST&#x27;, 
 headers: {
 &#x27;Content-Type&#x27;: &#x27;application/json&#x27;,
 },
 body: JSON.stringify(data), 
})
.then(response =&gt; response.json())
.then(data =&gt; console.log(data))
.catch((error) =&gt; {
 console.error(&#x27;Error:&#x27;, error);
});
</code></pre>
Using this code, we're sending a POST request to the specified URL with a JSON body. The <code>JSON.stringify()</code> method is used to convert a JavaScript object or value to a JSON string.
<h2 id="handlingerrorsinfetchapi">Handling Errors in Fetch API</h2>
One thing to note about the Fetch API is that it doesn't reject the Promise on HTTP error status, even if the response is an HTTP 404 or 500. Instead, it will only reject on network failure or if anything prevented the request from completing.
Personally, I prefer this style as it's easier to work with than handling these errors in a <code>catch</code> method. For example, retrying a request that returned HTTP 500 is eaiser to do when it doesn't throw an error. It also gives us more control over how we want to handle errors.
To actually handle HTTP errors, we need to check if the <code>response.ok</code> property is <code>true</code>, which indicates that the response was successful (status is in the range 200-299). If <code>response.ok</code> is <code>false</code>, we can either choose to throw an error or handle it right there.
<pre><code class="hljs">fetch(&#x27;https://api.example.com/data&#x27;)
 .then(response =&gt; {
 if (!response.ok) {
 throw new Error(&#x27;HTTP error &#x27; + response.status);
 }
 return response.json();
 })
 .then(data =&gt; console.log(data))
 .catch(error =&gt; console.error(&#x27;Error:&#x27;, error));
</code></pre>
If the HTTP status code is not in the range 200-299, an error will be thrown, and the catch block can then handle it.
<h2 id="comparingfetchtoaxios">Comparing Fetch to Axios</h2>
If you're used to using another library, you might be wondering how Fetch compares to other popular HTTP clients like <a href="https://github.com/axios/axios" rel="nofollow noopener" target="_blank">Axios</a>. Both Fetch and Axios can be used to send HTTP requests from JavaScript, but there are a few key differences between the two.
Fetch is now built into most modern browsers, which means you can use it without installing any additional libraries. It returns Promises natively and is generally simpler and more straightforward to use. However, one downside is it doesn't support request cancellation, and error handling doesn't work the way many developers expect it to, as it only rejects a Promise on network failure, not on HTTP error status.
On the other hand, Axios needs to be installed as a separate library, but it provides a wider range of features. It supports request cancellation, automatic transformation of JSON data, and provides a way to set a response timeout. It also rejects a Promise on HTTP error status, which you may prefer over Fetch's way of doing it.
<h2 id="conclusion">Conclusion</h2>
In this short Byte, we learned how to use the Fetch API to POST JSON data, and we compared Fetch to Axios. Fetch is a powerful tool built into modern browsers that allows us to send HTTP requests directly from JavaScript. While it may lack some of the advanced features of Axios, it's a convenient and straightforward solution for many use cases.