Scott Robinson

Importing Python Modules

<h2 id="introduction">Introduction</h2>
When dealing with large amounts of data or files, you might find yourself needing to compress files into a more manageable format. One of the best ways to do this is by creating a zip archive.
In this article, we'll be exploring how you can create a zip archive of a directory using Python. Whether you're looking to save space, simplify file sharing, or just keep things organized, Python's <code>zipfile</code> module provides a to do this.
<h2 id="creatingaziparchivewithpython">Creating a Zip Archive with Python</h2>
Python's standard library comes with a module named <code>zipfile</code> that provides methods for creating, reading, writing, appending, and listing contents of a ZIP file. This module is useful for creating a zip archive of a directory. We'll start by importing the <code>zipfile</code> and <code>os</code> modules:
<pre><code class="hljs">import zipfile
import os
</code></pre>
Now, let's create a function that will zip a directory:
<pre><code class="hljs">def zip_directory(directory_path, zip_path):
 with zipfile.ZipFile(zip_path, &#x27;w&#x27;) as zipf:
 for root, dirs, files in os.walk(directory_path):
 for file in files:
 zipf.write(os.path.join(root, file), 
 os.path.relpath(os.path.join(root, file), 
 os.path.join(directory_path, &#x27;..&#x27;)))
</code></pre>
In this function, we first open a new zip file in write mode. Then, we walk through the directory we want to zip. For each file in the directory, we use the <code>write()</code> method to add it to the zip file. The <code>os.path.relpath()</code> function is used so that we store the relative path of the file in the zip file, instead of the absolute path.
Let's test our function:
<pre><code class="hljs">zip_directory(&#x27;test_directory&#x27;, &#x27;archive.zip&#x27;)
</code></pre>
After running this code, you should see a new file named <code>archive.zip</code> in your current directory. This zip file contains all the files from <code>test_directory</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: Be careful when specifying the paths. If the <code>zip_path</code> file already exists, it will be overwritten.

 </div>
 </div>
 </div>
 Python's <code>zipfile</code> module makes it easy to create a zip archive of a directory. With just a few lines of code, you can compress and organize your files.
In the following sections, we'll dive deeper into handling nested directories, large directories, and error handling. This may seem a bit backwards, but the above function is likely what most people came here for, so I wanted to show it first.
<h2 id="usingthezipfilemodule">Using the zipfile Module</h2>
In Python, the <code>zipfile</code> module is the best tool for working with zip archives. It provides functions to read, write, append, and extract data from zip files. The module is part of Python's standard library, so there's no need to install anything extra.
Here's a simple example of how you can create a new zip file and add a file to it:
<pre><code class="hljs">import zipfile

# Create a new zip file
zip_file = zipfile.ZipFile(&#x27;example.zip&#x27;, &#x27;w&#x27;)

# Add a file to the zip file
zip_file.write(&#x27;test.txt&#x27;)

# Close the zip file
zip_file.close()
</code></pre>
In this code, we first import the <code>zipfile</code> module. Then, we create a new zip file named 'example.zip' in write mode ('w'). We add a file named 'test.txt' to the zip file using the <code>write()</code> method. Finally, we close the zip file using the <code>close()</code> method.
<h2 id="creatingaziparchiveofadirectory">Creating a Zip Archive of a Directory</h2>
Creating a zip archive of a directory involves a bit more work, but it's still fairly easy with the <code>zipfile</code> module. You need to walk through the directory structure, adding each file to the zip archive.
<pre><code class="hljs">import os
import zipfile

def zip_directory(folder_path, zip_file):
 for folder_name, subfolders, filenames in os.walk(folder_path):
 for filename in filenames:
 # Create complete filepath of file in directory
 file_path = os.path.join(folder_name, filename)
 # Add file to zip
 zip_file.write(file_path)

# Create a new zip file
zip_file = zipfile.ZipFile(&#x27;example_directory.zip&#x27;, &#x27;w&#x27;)

# Zip the directory
zip_directory(&#x27;/path/to/directory&#x27;, zip_file)

# Close the zip file
zip_file.close()
</code></pre>
We first define a function <code>zip_directory()</code> that takes a folder path and a <code>ZipFile</code> object. It uses the <code>os.walk()</code> function to iterate over all files in the directory and its subdirectories. For each file, it constructs the full file path and adds the file to the zip archive.
The <code>os.walk()</code> function is a convenient way to traverse directories. It generates the file names in a directory tree by walking the tree either top-down or bottom-up.

 <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: Be careful with the file paths when adding files to the zip archive. The <code>write()</code> method adds files to the archive with the exact path you provide. If you provide an absolute path, the file will be added with the full absolute path in the zip archive. This is usually not what you want. Instead, you typically want to add files with a relative path to the directory you're zipping.

 </div>
 </div>
 </div>
 In the main part of the script, we create a new zip file, call the <code>zip_directory()</code> function to add the directory to the zip file, and finally close the zip file.
<h3 id="workingwithnesteddirectories">Working with Nested Directories</h3>
When working with nested directories, the process of creating a zip archive is a bit more complicated. The first function we showed in this article actually handles this case as well, which we'll show again here:
<pre><code class="hljs">import os
import zipfile

def zipdir(path, ziph):
 for root, dirs, files in os.walk(path):
 for file in files:
 ziph.write(os.path.join(root, file), 
 os.path.relpath(os.path.join(root, file), 
 os.path.join(path, &#x27;..&#x27;)))
 
zipf = zipfile.ZipFile(&#x27;Python.zip&#x27;, &#x27;w&#x27;, zipfile.ZIP_DEFLATED)
zipdir(&#x27;/path/to/directory&#x27;, zipf)
zipf.close()
</code></pre>
The main difference is that we're actually creating the zip directory outside of the function and pass it as a parameter. Whether you do it within the function itself or not is up to personal preference.
<h3 id="handlinglargedirectories">Handling Large Directories</h3>
So what if we're dealing with a large directory? Zipping a large directory can consume a lot of memory and even crash your program if you don't take the right precautions.
Luckily, the <code>zipfile</code> module allows us to create a zip archive without loading all files into memory at once. By using the <code>with</code> statement, we can ensure that each file is closed and its memory freed after it's added to the archive.
<pre><code class="hljs">import os
import zipfile

def zipdir(path, ziph):
 for root, dirs, files in os.walk(path):
 for file in files:
 with open(os.path.join(root, file), &#x27;r&#x27;) as fp:
 ziph.write(fp.read())

with zipfile.ZipFile(&#x27;Python.zip&#x27;, &#x27;w&#x27;, zipfile.ZIP_DEFLATED) as zipf:
 zipdir(&#x27;/path/to/directory&#x27;, zipf)
</code></pre>
In this version, we're using the <code>with</code> statement when opening each file and when creating the zip archive. This will guarantee that each file is closed after it's read, freeing up the memory it was using. This way, we can safely zip large directories without running into memory issues.
<h3 id="errorhandlinginzipfile">Error Handling in zipfile</h3>
When working with <code>zipfile</code> in Python, we need to remember to handle exceptions so our program doesn't crash unexpectedly. The most common exceptions you might encounter are <code>RuntimeError</code>, <code>ValueError</code>, and <code>FileNotFoundError</code>.
Let's take a look at how we can handle these exceptions while creating a zip file:
<pre><code class="hljs">import zipfile

try:
 with zipfile.ZipFile(&#x27;example.zip&#x27;, &#x27;w&#x27;) as myzip:
 myzip.write(&#x27;non_existent_file.txt&#x27;)
except FileNotFoundError:
 print(&#x27;The file you are trying to zip does not exist.&#x27;)
except RuntimeError as e:
 print(&#x27;An unexpected error occurred:&#x27;, str(e))
except zipfile.LargeZipFile:
 print(&#x27;The file is too large to be compressed.&#x27;)
</code></pre>
<code>FileNotFoundError</code> is raised when the file we're trying to zip doesn't exist. <code>RuntimeError</code> is a general exception that might be raised for a number of reasons, so we print the exception message to understand what went wrong. <code>zipfile.LargeZipFile</code> is raised when the file we're trying to compress is too big.

 <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: Python's <code>zipfile</code> module raises a <code>LargeZipFile</code> error when the file you're trying to compress is larger than 2 GB. If you're working with large files, you can prevent this error by calling <code>ZipFile</code> with the <code>allowZip64=True</code> argument.

 </div>
 </div>
 </div>
 <h2 id="commonerrorsandsolutions">Common Errors and Solutions</h2>
While working with the <code>zipfile</code> module, you might encounter several common errors. Let's explore some of these errors and their solutions:
FileNotFoundError
This error happens when the file or directory you're trying to zip does not exist. So always check if the file or directory exists before attempting to compress it.
IsADirectoryError
This error is raised when you're trying to write a directory to a zip file using <code>ZipFile.write()</code>. To avoid this, use <code>os.walk()</code> to traverse the directory and write the individual files instead.
PermissionError
As you probably guessed, this error happens when you don't have the necessary permissions to read the file or write to the directory. Make sure you have the correct permissions before trying to manipulate files or directories.
LargeZipFile
As mentioned earlier, this error is raised when the file you're trying to compress is larger than 2 GB. To prevent this error, call <code>ZipFile</code> with the <code>allowZip64=True</code> argument.
<pre><code class="hljs">try:
 with zipfile.ZipFile(&#x27;large_file.zip&#x27;, &#x27;w&#x27;, allowZip64=True) as myzip:
 myzip.write(&#x27;large_file.txt&#x27;)
except zipfile.LargeZipFile:
 print(&#x27;The file is too large to be compressed.&#x27;)
</code></pre>
In this snippet, we're using the <code>allowZip64=True</code> argument to allow zipping files larger than 2 GB.
<h2 id="compressingindividualfiles">Compressing Individual Files</h2>
With <code>zipfile</code>, not only can it compress directories, but it can also compress individual files. Let's say you have a file called <code>document.txt</code> that you want to compress. Here's how you'd do that:
<pre><code class="hljs">import zipfile

with zipfile.ZipFile(&#x27;compressed_file.zip&#x27;, &#x27;w&#x27;) as myzip:
 myzip.write(&#x27;document.txt&#x27;)
</code></pre>
In this code, we're creating a new zip archive named <code>compressed_file.zip</code> and just adding <code>document.txt</code> to it. The 'w' parameter means that we're opening the zip file in write mode.
Now, if you check your directory, you should see a new zip file named <code>compressed_file.zip</code>.
<h2 id="extractingzipfiles">Extracting Zip Files</h2>
And finally, let's see how to reverse this zipping by extracting the files. Let's say we want to extract the <code>document.txt</code> file we just compressed. Here's how to do it:
<pre><code class="hljs">import zipfile

with zipfile.ZipFile(&#x27;compressed_file.zip&#x27;, &#x27;r&#x27;) as myzip:
 myzip.extractall()
</code></pre>
In this code snippet, we're opening the zip file in read mode ('r') and then calling the <code>extractall()</code> method. This method extracts all the files in the zip archive to the current directory.

 <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 you want to extract the files to a specific directory, you can pass the directory path as an argument to the <code>extractall()</code> method like so: <code>myzip.extractall('/path/to/directory/')</code>.

 </div>
 </div>
 </div>
 Now, if you check your directory, you should see the <code>document.txt</code> file. That's all there is to it!
<h2 id="conclusion">Conclusion</h2>
In this guide, we focused on creating and managing zip archives in Python. We explored the <code>zipfile</code> module, learned how to create a zip archive of a directory, and even dove into handling nested directories and large directories. We've also covered error handling within zipfile, common errors and their solutions, compressing individual files, and extracting zip files.

Creating a Zip Archive of a Directory in Python

<h2 id="introduction">Introduction</h2>
Python provides some very convenient ways to work with file-like objects, including the <code>with</code> feature. But what if we need to open multiple files in this way? Your could wouldn't exactly be &quot;clean&quot; if you had a bunch of nested <code>with open</code> statements. In this article, we'll show you how to open multiple files using the <code>with open</code> statement in Python.
<h2 id="whatiswithinpython">What is 'with' in Python?</h2>
The <code>with</code> statement in Python is used in exception handling to make the code cleaner and much easier to understand. It simplifies the management of common resources like file streams. Let's take a quick look at how it works:
<pre><code class="hljs">with open(&#x27;example.txt&#x27;, &#x27;r&#x27;) as file:
 data = file.read()
</code></pre>
In the above code snippet, <code>with open('example.txt', 'r') as file:</code> is the <code>with</code> statement we're referring to. The <code>open()</code> function is used to open a file, and <code>'example.txt'</code> is the name of the file we want to open. <code>'r'</code> is the mode in which we want to open the file. In this case, it's read mode. The <code>as</code> keyword is used to create an alias - in this case, <code>file</code>.
The code then reads the file <code>example.txt</code> and assigns its content to the variable <code>data</code>. One of the benefits of using <code>with</code> is that it automatically takes care of closing the file once it's no longer needed, even if exceptions were raised. This makes it much easier to handle files manually.

 <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>with</code> statement is not only used for opening files, but can also be used with other objects like threads, locks, and network connections. The main idea is to manage resources that can be open and closed.

 </div>
 </div>
 </div>
 The <code>with open</code> statement is similar to the following:
<pre><code class="hljs">try:
 file = open(&#x27;example.txt&#x27;, &#x27;r&#x27;)
 data = file.read()
finally:
 file.close()
</code></pre>
This code is more verbose and you're more likely to forget to close the file. Using <code>with</code> is a more Pythonic way of handling files.
<h2 id="whyopenmultiplefilesatonce">Why Open Multiple Files at Once?</h2>
There are a few reasons why you might want to open multiple files at once in Python. One of the most common scenarios is when you're working with a large dataset that's been split across multiple files. Instead of opening, reading, and closing each file one by one, you can streamline the process by opening all the files at once, reading in the data, and then closing the files.
This not only makes your code more efficient, but it's also cleaner and easier to read. Plus, it saves you from the potential headache of having to keep track of which files you've already opened/closed and which ones you haven't.

 <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! While opening multiple files at once can make your code more efficient, it can also consume more memory. So just be careful when working with a large number of files or very large files.

 </div>
 </div>
 </div>
 <h2 id="openingmultiplefiles">Opening Multiple Files</h2>
The basic method of opening multiple files in Python involves using the <code>with open()</code> function in combination with Python's built-in <code>zip()</code> function. Here's how you can do it:
<pre><code class="hljs">with open(&#x27;file1.txt&#x27;, &#x27;r&#x27;) as file1, open(&#x27;file2.txt&#x27;, &#x27;r&#x27;) as file2:
 for line1, line2 in zip(file1, file2):
 print(line1.strip(), line2.strip())
</code></pre>
In this code, we're opening two files, 'file1.txt' and 'file2.txt', for reading. The <code>with open()</code> function will help us make sure that the files are properly closed after they're no longer needed. We use the <code>zip()</code> function to read the lines from both files simultaneously, which is nice to have if the files are related in some way (for example, if one file contains questions and the other contains answers).
The output of this code will be the lines from 'file1.txt' and 'file2.txt' printed side by side.
This is just a basic method of opening multiple files in Python. There are other ways to do it that might be better suited to your specific use case, like using list comprehension or opening the files in a loop.
One thing to point out is that as of Python 3.10, you can now group the multiple <code>open</code> calls in parentheses and on multiple lines, which may help with readability:
<pre><code class="hljs">with (
 open(&#x27;file1.txt&#x27;, &#x27;r&#x27;) as file1,
 open(&#x27;file2.txt&#x27;, &#x27;r&#x27;) as file2
):
 for line1, line2 in zip(file1, file2):
 print(line1.strip(), line2.strip())
</code></pre>
<h2 id="usingwithopeninaloop">Using 'with open' in a Loop</h2>
Another way to open multiple files is to just use a loop and open each file one at a time so that no two files are open simultaneously. This can be helpful if you're working with very large files and can't have multiple files open due to memory constraints.
<pre><code class="hljs">filenames = [&#x27;file1.txt&#x27;, &#x27;file2.txt&#x27;, &#x27;file3.txt&#x27;]
for file in filenames:
 with open(file, &#x27;r&#x27;) as f:
 print(f.read())
</code></pre>
Here, we loop over our list of filenames. For each one, we use <code>with open</code> to open the file and assign it to the variable <code>f</code>. We then print out the contents of the file. Once the <code>with</code> block is exited, the file is automatically closed.
<h2 id="usinglistcomprehensiontoopenmultiplefiles">Using List Comprehension to Open Multiple Files</h2>
List comprehension is a popular feature in Python that allows you to create lists in a very readable and compact way. It can be used to open multiple files in a single line of code. Note that this method does not use <code>with</code>, so you'll need to manually close the files and handle errors, but it still might be helpful in some cases.
<pre><code class="hljs">filenames = [&#x27;file1.txt&#x27;, &#x27;file2.txt&#x27;, &#x27;file3.txt&#x27;]
files = [open(file) for file in filenames]
</code></pre>
In this example, we have a list of filenames. We use list comprehension to iterate over the list, opening each file, and storing the resulting file object in a new list, <code>files</code>.
<h2 id="handlingerrorsandissueswhenopeningmultiplefilesusingwith">Handling Errors and Issues When Opening Multiple Files Using <code>with</code></h2>
When working with files in any programming language, it's common to have to handle errors since so much can go wrong. Python's <code>with</code> keyword and <code>try/except</code> blocks can work together to better handle these errors
Let's take a look at an example:
<pre><code class="hljs">filenames = [&quot;file1.txt&quot;, &quot;file2.txt&quot;, &quot;nonexistent.txt&quot;, &quot;file3.txt&quot;]

for name in filenames:
 try:
 with open(name, &#x27;r&#x27;) as f:
 print(f.read())
 except FileNotFoundError:
 print(f&quot;{name} not found.&quot;)
 except PermissionError:
 print(f&quot;You don&#x27;t have permission to read {name}.&quot;)
</code></pre>
In this example, we attempt to open four files with a loop. We've wrapped the file opening operation inside a <code>with</code> block which is itself enclosed in a <code>try/except</code> block. This way, if the file doesn't exist, a <code>FileNotFoundError</code> is caught and a custom error message is printed. We use it this way to specifically handle certain scenarios and letting <code>with</code> handle the closing of the file, if it was ever opened.
Output:
<pre><code class="hljs">$ python open_multiple_files_with_with.py
...contents of file1.txt...
...contents of file2.txt...
nonexistent.txt not found.
...contents of file3.txt...
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we've explored various ways to open multiple files using <code>with open</code> in Python. We started with the basic method of opening multiple files, and then moved on to slightly more advanced techniques like using loops and list comprehension. We also briefly touched on how to handle errors and issues when opening multiple files.

Opening Multiple Files Using 'with open' in Python

<h2 id="introduction">Introduction</h2>
Python is not necessarily known for its speed, but there are certain things that can help you squeeze out a bit more performance from your code. Surprisingly, one of these practices is running code in a function rather than in the global scope. In this article, we'll see why Python code runs faster in a function and how Python code execution works.
<h2 id="pythoncodeexecution">Python Code Execution</h2>
To understand why Python code runs faster in a function, we need to first understand how Python executes code. Python is an interpreted language, which means it reads and executes code line by line. When Python executes a script, it first compiles it to bytecode, an intermediate language that's closer to machine code, and then the Python interpreter executes this bytecode.
<pre><code class="hljs">def hello_world():
 print(&quot;Hello, World!&quot;)

import dis
dis.dis(hello_world)
</code></pre>
<pre><code class="hljs"> 2 0 LOAD_GLOBAL 0 (print)
 2 LOAD_CONST 1 (&#x27;Hello, World!&#x27;)
 4 CALL_FUNCTION 1
 6 POP_TOP
 8 LOAD_CONST 0 (None)
 10 RETURN_VALUE
</code></pre>
The <a rel="nofollow noopener" target="_blank" href="https://docs.python.org/3/library/dis.html">dis</a> module in Python disassembles the function <code>hello_world</code> into bytecode, as seen above.

 <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 Python interpreter is a virtual machine that executes the bytecode. The default Python interpreter is CPython, which is written in C. There are other Python interpreters like Jython (written in Java), IronPython (for .NET), and PyPy (written in Python and C), but CPython is the most commonly used.

 </div>
 </div>
 </div>
 <h2 id="whypythoncoderunsfasterinafunction">Why Python Code Runs Faster in a Function</h2>
Consider a simplified example with a loop that iterates over a range of numbers:
<pre><code class="hljs">def my_function():
 for i in range(100000000):
 pass
</code></pre>
When this function is compiled, the bytecode might look something like this:
<pre><code class="hljs"> SETUP_LOOP 20 (to 23)
 LOAD_GLOBAL 0 (range)
 LOAD_CONST 3 (100000000)
 CALL_FUNCTION 1
 GET_ITER 
 FOR_ITER 6 (to 22)
 STORE_FAST 0 (i)
 JUMP_ABSOLUTE 13
 POP_BLOCK 
 LOAD_CONST 0 (None)
 RETURN_VALUE
</code></pre>
The key instruction here is <code>STORE_FAST</code>, which is used to store the loop variable <code>i</code>.
Now let's consider the bytecode if the loop is at the top level of a Python script:
<pre><code class="hljs"> SETUP_LOOP 20 (to 23)
 LOAD_NAME 0 (range)
 LOAD_CONST 3 (100000000)
 CALL_FUNCTION 1
 GET_ITER 
 FOR_ITER 6 (to 22)
 STORE_NAME 1 (i)
 JUMP_ABSOLUTE 13
 POP_BLOCK 
 LOAD_CONST 2 (None)
 RETURN_VALUE
</code></pre>
Notice the <code>STORE_NAME</code> instruction is used here, rather than <code>STORE_FAST</code>.
The bytecode <code>STORE_FAST</code> is faster than <code>STORE_NAME</code> because in a function, local variables are stored in a fixed-size array, not a dictionary. This array is directly accessible via an index, making variable retrieval very quick. Basically, it's just a pointer lookup into the list and an increase in the reference count of the PyObject, both of which are highly efficient operations.
On the other hand, global variables are stored in a dictionary. When you access a global variable, Python has to perform a hash table lookup, which involves calculating a hash and then retrieving the value associated with it. Though this is optimized, it's still inherently slower than an index-based lookup.
<h2 id="benchmarkingandprofilingpythoncode">Benchmarking and Profiling Python Code</h2>
Want to test this for yourself? Try benchmarking and profiling your code.
Benchmarking and profiling are important practices in performance optimization. They help you understand how your code behaves and where the bottlenecks are.
Benchmarking is where you time your code to see how long it takes to run. You can use Python's built-in <code>time</code> module, as we'll show later, or use more sophisticated tools like <a href="https://docs.python.org/3/library/timeit.html" rel="nofollow noopener" target="_blank">timeit</a>.
Profiling, on the other hand, provides a more detailed view of your code's execution. It shows you where your code spends most of its time, which functions are called, and how often. Python's built-in <a href="https://docs.python.org/3/library/profile.html" rel="nofollow noopener" target="_blank">profile</a> or <a href="https://docs.python.org/3/library/cProfile.html" rel="nofollow noopener" target="_blank">cProfile</a> modules can be used for this.
Here's one way you can profile your Python code:
<pre><code class="hljs">import cProfile

def loop():
 for i in range(10000000):
 pass

cProfile.run(&#x27;loop()&#x27;)
</code></pre>
This will output a detailed report of all the function calls made during the execution of the <code>loop</code> function.

 <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: Profiling can add quite a bit of overhead to your code execution, so the execution time shown by the profiler will likely be longer than the actual execution time.

 </div>
 </div>
 </div>
 <h2 id="benchmarkingcodeinafunctionvsglobalscope">Benchmarking Code in a Function vs. Global Scope</h2>
In Python, the speed of code execution can vary depending on where the code is executed - in a function or in the global scope. Let's compare the two using a simple example.
Consider the following code snippet that calculates the factorial of a number:
<pre><code class="hljs">def factorial(n):
 result = 1
 for i in range(1, n + 1):
 result *= i
 return result
</code></pre>
Now let's run the same code but in the global scope:
<pre><code class="hljs">n = 20
result = 1
for i in range(1, n + 1):
 result *= i
</code></pre>
To benchmark these two pieces of code, we can use the <code>timeit</code> module in Python, which provides a simple way to time small bits of Python code.
<pre><code class="hljs">import timeit

# Factorial function here...

def benchmark():
 start = timeit.default_timer()

 factorial(20)

 end = timeit.default_timer()
 print(end - start)

#
# Run benchmark on function code
#
benchmark()
# Prints: 3.541994374245405e-06

#
# Run benchmark on global scope code
#
start = timeit.default_timer()

n = 20
result = 1
for i in range(1, n + 1):
 result *= i

end = timeit.default_timer()
print(end - start) 
# Pirnts: 5.375011824071407e-06
</code></pre>
You'll find that the function code executes faster than the global scope code. This is because Python executes function code faster due to the reasons we discussed earlier.

 <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 you run the <code>benchmark()</code> function and global scope code in the same script, the global scope code will run faster. This is because the <code>benchmark()</code> function adds some overhead to the execution time and the global code is given some optimizations internally. However, if you run them separately, you'll find that the function code does run faster.

 </div>
 </div>
 </div>
 <h2 id="profilingcodeinafunctionvsglobalscope">Profiling Code in a Function vs. Global Scope</h2>
Python provides a built-in module called <code>cProfile</code> for this purpose. Let's use it to profile a new function, which computes the sum of squres, in both a local and global scope.
<pre><code class="hljs">import cProfile

def sum_of_squares():
 total = 0
 for i in range(1, 10000000):
 total += i * i

i = None
total = 0
def sum_of_squares_g():
 global i
 global total
 for i in range(1, 10000000):
 total += i * i
 
def profile(func):
 pr = cProfile.Profile()
 pr.enable()

 func()

 pr.disable()
 pr.print_stats()
#
# Profile function code
#
print(&quot;Function scope:&quot;)
profile(sum_of_squares)

#
# Profile global scope code
#
print(&quot;Global scope:&quot;)
profile(sum_of_squares_g)
</code></pre>
From the profiling results, you'll see that the function code is more efficient in terms of execution time.
<pre><code class="hljs">Function scope:
 2 function calls in 0.903 seconds

 Ordered by: standard name

 ncalls tottime percall cumtime percall filename:lineno(function)
 1 0.903 0.903 0.903 0.903 profiler.py:3(sum_of_squares)
 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects}


Global scope:
 2 function calls in 1.358 seconds

 Ordered by: standard name

 ncalls tottime percall cumtime percall filename:lineno(function)
 1 1.358 1.358 1.358 1.358 profiler.py:10(sum_of_squares_g)
 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects}
</code></pre>
We consider the <code>sum_of_squares_g()</code> function to be global since it used two global variables, <code>i</code> and <code>total</code>. As we saw earlier, it's the global variables that slow down the code execution, which is why we made those variables global in this code.
<h2 id="optimizingpythonfunctionperformance">Optimizing Python Function Performance</h2>
Given that Python functions tend to run faster than equivalent code in the global scope, it's worth looking into how we can further optimize our function performance.
Of course, because of what we saw earlier, one strategy is to use local variables instead of global variables. Here's an example:
<pre><code class="hljs">import time

# Global variable
x = 5

def calculate_power_global():
 for i in range(10000000):
 y = x ** 2 # Accessing global variable

def calculate_power_local(x):
 for i in range(10000000):
 y = x ** 2 # Accessing local variable

start = time.time()
calculate_power_global()
end = time.time()

print(f&quot;Execution time with global variable: {end - start} seconds&quot;)

start = time.time()
calculate_power_local(x)
end = time.time()

print(f&quot;Execution time with local variable: {end - start} seconds&quot;)
</code></pre>
In this example, <code>calculate_power_local</code> will typically run faster than <code>calculate_power_global</code>, because it's using a local variable instead of a global one.
<pre><code class="hljs">Execution time with global variable: 1.9901456832885742 seconds
Execution time with local variable: 1.9626312255859375 seconds
</code></pre>
Another optimization strategy is to use built-in functions and libraries whenever possible. Python's built-in functions are implemented in C, which is much faster than Python. Similarly, many Python libraries, such as NumPy and Pandas, are also implemented in C or C++, making them faster than equivalent Python code.
For example, consider the task of summing a list of numbers. You could write a function to do this:
<pre><code class="hljs">def sum_numbers(numbers):
 total = 0
 for number in numbers:
 total += number
 return total
</code></pre>
However, Python's built-in <code>sum</code> function will do the same thing, but faster:
<pre><code class="hljs">numbers = [1, 2, 3, 4, 5]
total = sum(numbers)
</code></pre>
Try timing these two code snippets yourself and figure out which one is faster!
<h2 id="conclusion">Conclusion</h2>
In this article, we've explored the interesting world of Python code execution, specifically focusing on why Python code tends to run faster when encapsulated in a function. We briefly looked into the concepts of benchmarking and profiling, providing practical examples of how these processes can be carried out in both a function and the global scope.
We also discussed a few ways to optimize your Python function performance. While these tips can certainly make your code run faster, you should use certain optimizations carefully as it's important to balance readability and maintainability with performance.

Why does Python Code Run Faster in a Function?

<h2 id="introduction">Introduction</h2>
In this article we'll be showing how to select and manipulate CSS pseudo-elements, specifically <code>::before</code> and <code>::after</code>, using JavaScript and jQuery. As a web developer, you've likely at least seen these pseudo-elements in a CSS file, but may not have had the chance to interact with them programmatically. This article will show you how and why you might want to do so.
<h2 id="whatarecsspseudoelements">What are CSS pseudo-elements?</h2>
CSS pseudo-elements are keywords added to selectors that let you style certain parts of a document. For instance, the <code>::before</code> and <code>::after</code> pseudo-elements are used to insert content before or after the content of an element.
<pre><code class="hljs">p::before {
 content: &quot;Read this - &quot;;
}

p::after {
 content: &quot; - thank you!&quot;;
}
</code></pre>
In the above code, the <code>::before</code> pseudo-element adds &quot;Read this - &quot; before the content of every <code>&lt;p&gt;</code> element, and the <code>::after</code> pseudo-element adds &quot; - thank you!&quot; after the content of every <code>&lt;p&gt;</code> element.
This is what it would actually look like:
<style>
#example p::before {
 content: "Read this - ";
}

#example p::after {
 content: " - thank you!";
}
</style>
<div id="example" class="bg-yellow-50 border rounded p-2 my-4">
 
 The quick brown fox jumps over the lazy dog. Waltz, bad nymph, for quick jigs vex. Sphinx of black quartz, judge my vow. How vexingly quick daft zebras jump! Pack my box with five dozen liquor jugs.
 
</div>
If you were to check the source of this page, you'd see that the &quot;Read this - &quot; and &quot; - thank you!&quot; are not actually in the <code>&lt;p&gt;</code> tag, they're inserted by the CSS.

 <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>::before</code> and <code>::after</code> pseudo-elements are often used with the <code>content</code> property, which is used to insert generated content.

 </div>
 </div>
 </div>
 Since these pseudo-elements are not actually part of the DOM, they can't be directly selected or manipulated using JavaScript or jQuery. This might seem like a limitation, but there are workarounds, which we'll explore in the following sections.
<h2 id="whywouldyouneedtomanipulatepseudoelements">Why would you need to manipulate pseudo-elements?</h2>
CSS pseudo-elements are a powerful tool that can be used to style specific parts of your HTML elements. They can be used to add special effects or extra content before or after the content of an element. However, there are times when you might need to manipulate these pseudo-elements dynamically, based on user interactions or changes in your application state. That's where JavaScript comes in.
Let's say you have a CSS <code>::before</code> pseudo-element that adds a decorative icon to your buttons. Now, suppose you want to change this icon when the user clicks the button. This change cannot be achieved with CSS alone. You would need to use JavaScript to select the pseudo-element and then change it.
<h2 id="selectingpseudoelementsusingjavascript">Selecting Pseudo-Elements using JavaScript</h2>
As mentioned before, pseudo-elements are not part of the DOM and cannot be directly selected using JavaScript. However, we can still manipulate them by changing their associated CSS rules. To do so, we need to first select the CSS rule that defines the pseudo-element.
Let's say we have a CSS rule for a <code>::before</code> pseudo-element on a button:
<pre><code class="hljs">button::before {
 content: &quot;Click me&quot;;
 color: blue;
}
</code></pre>
We can select this rule using JavaScript's <code>document.styleSheets</code> and <code>cssRules</code> properties. Here's how:
<pre><code class="hljs">let styleSheet = document.styleSheets[0]; // Select the first stylesheet
let cssRule;

for (let rule of styleSheet.cssRules) {
 if (rule.selectorText === &#x27;button::before&#x27;) {
 cssRule = rule;
 break;
 }
}

console.log(cssRule.style.content); // Outputs: &quot;Click me&quot;
</code></pre>
In the above code, we first select the first stylesheet of the document. Then, we iterate over its cssRules to find the rule with the selector 'button::before'. Once we find the rule, we can access its styles using the <code>style</code> property.
While this method works, it's not very efficient since it requires us to loop through all the <code>cssRules</code>. In a large app with many stylesheets/rules, this likely wouldn't perform well. Therefore, it's recommended to use this method sparingly and only when necessary.
<h2 id="manipulatingpseudoelementsusingjavascript">Manipulating Pseudo-Elements using JavaScript</h2>
In JavaScript, manipulating pseudo-elements is a bit tricky since they are not directly part of the Document Object Model (DOM). However, we can still modify them with a bit of creativity. We can't directly select pseudo-elements in JavaScript, but we can manipulate their styles via the <code>CSSStyleSheet.insertRule()</code> method.
Let's say we have a paragraph with the id &quot;example&quot; and a <code>::before</code> pseudo-element:
<pre><code class="hljs">&lt;p id=&quot;example&quot;&gt;Hello, StackAbuse readers!&lt;/p&gt;
</code></pre>
<pre><code class="hljs">#example::before {
 content: &quot;Greetings! &quot;;
}
</code></pre>
Now, suppose we want to change the content of the <code>::before</code> pseudo-element to &quot;Welcome! &quot; using JavaScript. Here's how we can do it:
<pre><code class="hljs">document.styleSheets[0].insertRule(&quot;#example::before { content: &#x27;Welcome! &#x27;; }&quot;, 0);
</code></pre>
Here, <code>styleSheets[0]</code> refers to the first stylesheet linked/embedded in the HTML document. The <code>insertRule()</code> method takes two parameters: the CSS rule to be inserted, and the index at which to insert the rule. In this case, we're inserting our rule at the beginning of the stylesheet (index 0).
If you need to eventually remove this new rule, you can do so with <code>document.styleSheets[0].removeRule()</code>.
<h2 id="selectingmanipulatingpseudoelementsusingjquery">Selecting/Manipulating Pseudo-Elements using jQuery</h2>
When it comes to jQuery, the situation is similar. We can't directly select pseudo-elements. But we can still get around this by manipulating the CSS rules that apply to them. jQuery doesn't have a built-in method like <code>insertRule()</code>, but we can use the <code>$('style')</code> selector to append a new rule to our stylesheet.
Let's use the same HTML and CSS as before:
<pre><code class="hljs">&lt;p id=&quot;example&quot;&gt;Hello, StackAbuse readers!&lt;/p&gt;
</code></pre>
<pre><code class="hljs">#example::before {
 content: &quot;Greetings! &quot;;
}
</code></pre>
Now, let's change the content of the <code>::before</code> pseudo-element to &quot;Welcome! &quot; using jQuery:
<pre><code class="hljs">$(&#x27;style&#x27;).append(&quot;#example::before { content: &#x27;Welcome! &#x27;; }&quot;);
</code></pre>
With the <code>append()</code> method, we're adding a new rule to the end of our stylesheet. This rule will override the previous rule for <code>#example::before</code>, which results in the content being changed.
<h2 id="alternativestomanipulatingcsspsuedoelements">Alternatives to Manipulating CSS Psuedo-Elements</h2>
<h3 id="usingattributes">Using Attributes</h3>
Another solution that has been proposed, and possibly a better one than what we have shown above, is to use the element's attribute to specify before/after content. For example:
<pre><code class="hljs">#example::before {
 content: attr(data-before);
}
</code></pre>
<pre><code class="hljs">&lt;p id=&quot;example&quot; data-before=&quot;Greetings! &quot;&gt;Hello, StackAbuse readers!&lt;/p&gt;
</code></pre>
The <code>attr()</code> method selects whatever text is given in the <code>data-before</code> attribute of the element. Using this, you can change the text in the <code>data-before</code> attribute, which will then alter what the psuedo-elements show.
<pre><code class="hljs">$(&#x27;#example&#x27;).click(function() {
 $(this).attr(&#x27;data-content&#x27;, &#x27;Welcome! &#x27;);
});
</code></pre>
<h3 id="usingclasses">Using Classes</h3>
Another reasonable method is to just use CSS classes, which may be something you're already doing throughout your app. You can add/remove classes that have the <code>::before</code> or <code>::after</code> selectors, thus helping you manipulate the behavior of the psuedo-elements. It doesn't give as much flexibility as the last option, but it's a familiar and simple solution to a difficult problem.
<h2 id="conclusion">Conclusion</h2>
In this article, we took a look at CSS pseudo-elements and how we can interact with them using JavaScript and jQuery. We've learned that while pseudo-elements are not actually part of the DOM and can't be selected directly, we can still manipulate them by dynamically changing the CSS rules they're associated with.
While pseudo-elements can be useful, you may want to avoid using them if possible, at least when you need to manipulat their values. They’re not a replacement for semantic HTML elements and should not be used to add content that is important to your page.

Manipulating CSS Pseudo-Elements ::before and ::after Using JavaScript/jQuery

<h2 id="introduction">Introduction</h2>
While learning Python or reading someone else's code, you may have encountered the 'u' and 'r' prefixes and raw string literals. But what do these terms mean? How do they affect our Python code? In this article, we will attemp to demystify these concepts and understand their usage in Python.
<h2 id="stringliteralsinpython">String Literals in Python</h2>
A string literal in Python is a sequence of characters enclosed in quotes. We can use either single quotes (' ') or double quotes (&quot; &quot;) to define a string.
<pre><code class="hljs"># Using single quotes
my_string = &#x27;Hello, StackAbuse readers!&#x27;
print(my_string)

# Using double quotes
my_string = &quot;Hello, StackAbuse readers!&quot;
print(my_string)
</code></pre>
Running this code will give you the following:
<pre><code class="hljs">$ python string_example.py
Hello, StackAbuse readers!
Hello, StackAbuse readers!
</code></pre>
Pretty straightforward, right? In my opinion, the thing that confuses most people is the &quot;literal&quot; part. We're used to calling them just &quot;strings&quot;, so when you hear it being called a &quot;string literal&quot;, it sounds like something more complicated.
Python also offers other ways to define strings. We can prefix our string literals with certain characters to change their behavior. This is where 'u' and 'r' prefixes come in, which we'll talk about later.
Python also supports triple quotes (''' ''' or &quot;&quot;&quot; &quot;&quot;&quot;) to define strings. These are especially useful when we want to define a string that spans multiple lines.
Here's an example of a multi-line string:
<pre><code class="hljs"># Using triple quotes
my_string = &quot;&quot;&quot;
Hello, 
StackAbuse readers!
&quot;&quot;&quot;
print(my_string)
</code></pre>
Running this code will output the following:
<pre><code class="hljs">$ python multiline_string_example.py

Hello, 
StackAbuse readers!
</code></pre>
Notice the newlines in the output? That's thanks to triple quotes!
<h2 id="whatareuandrstringprefixes">What are 'u' and 'r' String Prefixes?</h2>
In Python, string literals can have optional prefixes that provide additional information about the string. These prefixes are 'u' and 'r', and they're used before the string literal to specify its type. The 'u' prefix stands for Unicode, and the 'r' prefix stands for raw.
Now, you may be wondering what Unicode and raw strings are. Well, let's break them down one by one, starting with the 'u' prefix.
<h2 id="theustringprefix">The 'u' String Prefix</h2>
The 'u' prefix in Python stands for Unicode. It's used to define a Unicode string. But what is a Unicode string?
Unicode is an international encoding standard that provides a unique number for every character, irrespective of the platform, program, or language. This makes it possible to use and display text from multiple languages and symbol sets in your Python programs.
In Python 3.x, all strings are Unicode by default. However, in Python 2.x, you need to use the 'u' prefix to define a Unicode string.
For instance, if you want to create a string with Chinese characters in Python 2.x, you would need to use the 'u' prefix like so:
<pre><code class="hljs">chinese_string = u&#x27;你好&#x27;
print(chinese_string)
</code></pre>
When you run this code, you'll get the output:
<pre><code class="hljs">$ 你好
</code></pre>
Which is &quot;Hello&quot; in Chinese.

 <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 Python 3.x, you can still use the 'u' prefix, but it's not necessary because all strings are Unicode by default.

 </div>
 </div>
 </div>
 So, that's the 'u' prefix. It helps you work with international text in your Python programs, especially if you're using Python 2.x. But what about the 'r' prefix? We'll dive into that in the next section.
<h2 id="therstringprefix">The 'r' String Prefix</h2>
The 'r' prefix in Python denotes a raw string literal. When you prefix a string with 'r', it tells Python to interpret the string exactly as it is and not to interpret any backslashes or special metacharacters that the string might have.
Consider this code:
<pre><code class="hljs">normal_string = &quot;\tTab character&quot;
print(normal_string)
</code></pre>
Output:
<pre><code class="hljs"> Tab character
</code></pre>
Here, <code>\t</code> is interpreted as a tab character. But if we prefix this string with 'r':
<pre><code class="hljs">raw_string = r&quot;\tTab character&quot;
print(raw_string)
</code></pre>
Output:
<pre><code class="hljs">\tTab character
</code></pre>
You can see that the '\t' is no longer interpreted as a tab character. It's treated as two separate characters: a backslash and 't'.
This is particularly useful when dealing with regular expressions, or when you need to include a lot of backslashes in your string.
<h2 id="workingwithuandrprefixesinpython2x">Working with 'u' and 'r' Prefixes in Python 2.x</h2>
Now, let's talk about Python 2.x. In Python 2.x, the 'u' prefix was used to denote a Unicode string, while the 'r' prefix was used to denote a raw string, just like in Python 3.x.
However, the difference lies in the default string type. In Python 3.x, all strings are Unicode by default. But in Python 2.x, strings were ASCII by default. So, if you needed to work with Unicode strings in Python 2.x, you had to prefix them with 'u'.
<pre><code class="hljs"># Python 2.x
unicode_string = u&quot;Hello, world!&quot;
print(unicode_string)
</code></pre>
Output:
<pre><code class="hljs">Hello, world!
</code></pre>
But what if you needed a string to be both Unicode and raw in Python 2.x? You could use both 'u' and 'r' prefixes together, like this:
<pre><code class="hljs"># Python 2.x
unicode_raw_string = ur&quot;\tHello, world!&quot;
print(unicode_raw_string)
</code></pre>
Output:
<pre><code class="hljs">\tHello, world!
</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 'ur' syntax is not supported in Python 3.x. If you need a string to be both raw and Unicode in Python 3.x, you can use the 'r' prefix alone, because all strings are Unicode by default.

 </div>
 </div>
 </div>
 The key point here is that the 'u' prefix was more important in Python 2.x due to the ASCII default. In Python 3.x, all strings are Unicode by default, so the 'u' prefix is not as essential. However, the 'r' prefix is still very useful for working with raw strings in both versions.
<h2 id="usingrawstringliterals">Using Raw String Literals</h2>
Now that we understand what raw string literals are, let's look at more examples of how we can use them in our Python code.
One of the most common uses for raw string literals is in regular expressions. Regular expressions often include backslashes, which can lead to issues if not handled correctly. By using a raw string literal, we can more easily avoid these problems.
Another common use case for raw string literals is when working with Windows file paths. As you may know, Windows uses backslashes in its file paths, which can cause issues in Python due to the backslash's role as an escape character. By using a raw string literal, we can avoid these issues entirely.
Here's an example:
<pre><code class="hljs"># Without raw string
path = &quot;C:\\path\\to\\file&quot;
print(path)
# Output: C:\path		o\file

# With raw string
path = r&quot;C:\\path\\to\\file&quot;
print(path)
# Output: C:\\path\\to\\file
</code></pre>
As you can see, the raw string literal allows us to correctly represent the file path, while the standard string does not.
<h2 id="commonmistakesandhowtoavoidthem">Common Mistakes and How to Avoid Them</h2>
When working with 'u' and 'r' string prefixes and raw string literals in Python, there are a number of common mistakes that developers often make. Let's go through some of them and see how you can avoid them.
First, one common mistake is using the 'u' prefix in Python 3.x. Remember, the 'u' prefix is not needed in Python 3.x as strings are Unicode by default in this version. Using it won't cause an error, but it's redundant and could potentially confuse other developers reading your code.
<pre><code class="hljs"># This is redundant in Python 3.x
u_string = u&#x27;Hello, World!&#x27;
</code></pre>
Second, forgetting to use the 'r' prefix when working with regular expressions can lead to unexpected results due to escape sequences. Always use the 'r' prefix when dealing with regular expressions in Python.
<pre><code class="hljs"># This might not work as expected
regex = &#x27;\bword\b&#x27;

# This is the correct way
regex = r&#x27;\bword\b&#x27;
</code></pre>
Last, not understanding that raw string literals do not treat the backslash as a special character can lead to errors. For instance, if you're trying to include a literal backslash at the end of a raw string, you might run into issues as Python still interprets a single backslash at the end of the string as escaping the closing quote. To include a backslash at the end, you need to escape it with another backslash, even in a raw string.
<pre><code class="hljs"># This will cause a SyntaxError
raw_string = r&#x27;C:\path\&#x27;

# This is the correct way
raw_string = r&#x27;C:\path\\&#x27;
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we've explored the 'u' and 'r' string prefixes in Python, as well as raw string literals. We've learned that the 'u' prefix is used to denote Unicode strings, while the 'r' prefix is used for raw strings, which treat backslashes as literal characters rather than escape characters. We also delved into common mistakes when using these prefixes and raw string literals, and how to avoid them.

The 'u' and 'r' String Prefixes and Raw String Literals in Python

<h2 id="introduction">Introduction</h2>
Whether you're reading data from files or writing data to files, understanding file operations is important. In Python, and other languages, we often need to copy files from one directory to another, or even within the same directory. This article will guide you through the process of copying files in Python using various modules and methods.
<h2 id="pythonsfilesystemandfileoperations">Python's Filesystem and File Operations</h2>
Python provides several built-in modules and functions to interact with the filesystem and perform file operations. The two most commonly used modules for file operations are the <code>os</code> and <code>shutil</code> modules.
The <code>os</code> module provides a way of using operating system dependent functionality. It includes functions for interacting with the filesystem, such as <code>os.rename()</code>, <code>os.remove()</code>, <code>os.mkdir()</code>, and so on.
<pre><code class="hljs">import os

# Rename a file
os.rename(&#x27;old_name.txt&#x27;, &#x27;new_name.txt&#x27;)

# Remove a file
os.remove(&#x27;file_to_remove.txt&#x27;)

# Create a directory
os.mkdir(&#x27;new_directory&#x27;)
</code></pre>
The <code>shutil</code> module offers a number of high-level operations on files and collections of files. It comes under Python’s standard utility modules. This module helps in automating process of copying and removal of files and directories.
<pre><code class="hljs">import shutil

# Copy a file
shutil.copy(&#x27;source.txt&#x27;, &#x27;destination.txt&#x27;)

# Remove a directory and all its contents
shutil.rmtree(&#x27;directory_to_remove&#x27;)
</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: While <code>os</code> module functions are efficient for simple file operations, for higher-level file operations such as copying or moving files and directories, <code>shutil</code> module functions are more convenient.

 </div>
 </div>
 </div>
 Now, let's dive deeper into how we can use these modules to copy files in Python.
<h2 id="howtocopyfilesinpython">How to Copy Files in Python</h2>
Python, being a high-level programming language, provides us with several modules to simplify various tasks. One of those tasks is copying files. Whether you want to back up your data or move it to another location, Python makes it easy to copy files and directories. Here we'll take a look at how to copy files using different built-in modules.
<h2 id="usingtheshutilmoduletocopyfiles">Using the shutil Module to Copy Files</h2>
The <code>shutil</code> module has methods that help in operations like copying, moving, or removing files/directories. One of its most used functionalities is the ability to copy files.
To copy a file in Python using the <code>shutil</code> module, we use the <code>shutil.copy()</code> function. This function takes two parameters: the source file path and the destination path.
Let's look at an example:
<pre><code class="hljs">import shutil

source = &quot;/path/to/source/file.txt&quot;
destination = &quot;/path/to/destination/file.txt&quot;

shutil.copy(source, destination)
</code></pre>
In this code snippet, we first import the <code>shutil</code> module. We then define the source and destination file paths. Finally, we call the <code>shutil.copy()</code> function with the source and destination as arguments.

 <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>shutil.copy()</code> function will overwrite the destination file if it already exists. So, be cautious while using it!

 </div>
 </div>
 </div>
 If you want to preserve the metadata (like permissions, modification times) while copying, you can use the <code>shutil.copy2()</code> function. This works the same way as <code>shutil.copy()</code>, but it also copies the metadata.
<pre><code class="hljs">import shutil

source = &quot;/path/to/source/file.txt&quot;
destination = &quot;/path/to/destination/file.txt&quot;

shutil.copy2(source, destination)
</code></pre>
<h2 id="usingtheosmoduletocopyfiles">Using the os Module to Copy Files</h2>
Python's built-in <code>os</code> module is another great tool for interacting with the operating system. Among its many features, and just like <code>shutil</code>, it allows us to copy files. However, it's important to note that the <code>os</code> module doesn't provide a direct method to copy files like <code>shutil</code> does. Instead, we can use the <code>os.system()</code> function to execute shell commands within our Python script.
Here's how you'd use the <code>os.system()</code> function to copy a file:
<pre><code class="hljs">import os

# Define source and destination paths
src = &quot;/path/to/source/file.txt&quot;
dest = &quot;/path/to/destination/file.txt&quot;

# Use os.system to execute the cp shell command
os.system(f&#x27;cp {src} {dest}&#x27;)
</code></pre>
After running this script, you'll find that <code>file.txt</code> has been copied from the source path to the destination path.

 <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! Since the <code>os.system()</code> function can execute any shell command, it can also be a potential security risk if misused, so always be careful when using it.

 </div>
 </div>
 </div>
 This may be a helpful way to copy files if you also need to execute other shell commands or use <code>cp</code> flags that aren't available with <code>shutil</code>'s methods.
<h2 id="copyingfileswithwildcards">Copying Files with Wildcards</h2>
In other use-cases, you might want to copy multiple files at once. Let's say we want to copy all <code>.txt</code> files in a directory. We can achieve this by using wildcards (<code>*</code>) in our file paths. The <code>glob</code> module in Python can be used to find all the pathnames matching a specified pattern according to the rules used by the Unix shell.
Here's is how we'd use the <code>glob</code> module to copy all <code>.txt</code> files from one directory to another:
<pre><code class="hljs">import glob
import shutil

# Define source and destination directories
src_dir = &quot;/path/to/source/directory/*.txt&quot;
dest_dir = &quot;/path/to/destination/directory/&quot;

# Use glob to get all .txt files in the source directory
txt_files = glob.glob(src_dir)

# Loop through the list of .txt files and copy each one
for file in txt_files:
 shutil.copy(file, dest_dir)
</code></pre>
In this code, we use <code>glob</code> to get a list of all text files in our source directory, which we then iterate over and copy each one individually.
After running this script, you'll see that all <code>.txt</code> files from the source directory have been copied to the destination directory.
<h2 id="copyingdirectoriesinpython">Copying Directories in Python</h2>
Copying individual files in Python is quite straightforward, as we've seen. But what if you want to copy an entire directory? While it sounds more complicated, this is actually pretty easy to do with the <code>shutil</code> module. The <code>copytree()</code> function allows you to copy directories, along with all the files and sub-directories within them.
<pre><code class="hljs">import shutil

shutil.copytree(&#x27;/path/to/source_directory&#x27;, &#x27;/path/to/destination_directory&#x27;)
</code></pre>
This will copy the entire directory at the source path to the destination path. If the destination directory doesn't exist, <code>copytree()</code> will create 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 the destination directory already exists, <code>copytree()</code> will raise a <code>FileExistsError</code>. To avoid this, make sure the destination directory doesn't exist before you run the function.

 </div>
 </div>
 </div>
 <h2 id="errorhandlingandtypesoferrors">Error Handling and Types of Errors</h2>
When dealing with file operations in Python, it's important to handle potential errors. There are many types of errors you might encounter, with some of the more common ones being <code>FileNotFoundError</code>, <code>PermissionError</code>, and <code>IsADirectoryError</code>.
You can handle these errors using Python's <code>try/except</code> blocks like this:
<pre><code class="hljs">import shutil

try:
 shutil.copy2(&#x27;/path/to/source_file&#x27;, &#x27;/path/to/destination_file&#x27;)
except FileNotFoundError:
 print(&quot;The source or destination file was not found.&quot;)
except PermissionError:
 print(&quot;You don&#x27;t have permission to access the source or destination file.&quot;)
except IsADirectoryError:
 print(&quot;The source or destination path you provided is a directory, not a file.&quot;)
</code></pre>
In this example, we're using the <code>shutil.copy2()</code> function to copy a file. If the source or destination file doesn't exist, a <code>FileNotFoundError</code> is raised. If the user doesn't have the necessary permissions, a <code>PermissionError</code> is raised. If the source or destination path is a directory instead of a file, an <code>IsADirectoryError</code> is raised. Catching each error in this way allows you to handle each case in the appropriate way.
<h2 id="conclusion">Conclusion</h2>
In this article, we have showed different ways to copy files in Python. We saw how the Python's built-in <code>shutil</code> and <code>os</code> modules provide us with simple and powerful tools for file copying. We also showed how to employ wildcards to copy multiple files and how to copy entire directories.
And finally, we looked at a few different types of common errors that might occur during file operations and how to handle them. Understanding these errors can help you debug your code more efficiently and prevent issues, like data loss.

How to Copy Files in Python

<h2 id="introduction">Introduction</h2>
React.js uses a number of unique concepts that can initially seem a bit confusing. One such concept is the use of keys, particularly when working with component arrays. Why and how do we use these keys? This article aims to explain the use of unique keys for array children in React.
<h2 id="keysinreact">Keys in React</h2>
In React, a key is a string attribute you need to include when creating lists of elements. Let's take a look at a simple example:
<pre><code class="hljs">const numbers = [1, 2, 3, 4, 5];
const listItems = numbers.map((number) =&gt;
 &lt;li key={number.toString()}&gt;
 {number}
 &lt;/li&gt;
);
</code></pre>
In this example, we're creating a list of numbers. Each <code>&lt;li&gt;</code> element needs a unique key attribute. Here, we're using the string value of the number as the key.
These keys serve as a hint to React's reconciliation algorithm by giving elements a stable identity. They're not intended to be globally unique; they only need to be unique between components and their siblings.
But why do we need keys in the first place? Well, keys help React identify which items have changed, are added, or are removed. Keys should be given to the elements inside an array to give the elements a stable identity, and therefore easier access.
It's worth noting that the best way to pick a key is to use a string that uniquely identifies a list item among its siblings. A common way to do that is to use IDs from your data as keys:
<pre><code class="hljs">const todoItems = todos.map((todo) =&gt;
 &lt;li key={todo.id}&gt;
 {todo.text}
 &lt;/li&gt;
);
</code></pre>
Here, we assume that <code>todos</code> is an array of objects with an <code>id</code> and a <code>text</code> attribute. The <code>id</code> of each <code>todo</code> object is unique, so it makes a good candidate for a key.
But what happens if you don't have a unique ID or string to use as a key? In that case, you might be tempted to use the item index as a key:
<pre><code class="hljs">const todoItems = todos.map((todo, index) =&gt;
 // Only do this if items have no stable IDs
 &lt;li key={index}&gt;
 {todo.text}
 &lt;/li&gt;
);
</code></pre>
However, this is generally not recommended. Index as a key is an anti-pattern in React because it can negatively impact performance and may cause issues with component state. It's better to use unique string identifiers if possible.
But why do we need these keys?
In React.js, whenever we create a list or array of elements, each element needs a unique <code>key</code> attribute. This might seem like an unnecessary step at first, but it's actually crucial for React's diffing algorithm, which helps optimize the rendering process.
When a component's state changes, React needs to determine whether to update the existing DOM or create a new one. This is where the diffing algorithm comes into play. It compares the new virtual DOM with the old one and updates only the parts that have changed.
he diffing algorithm increases performance by minimizing the amount of DOM manipulation.
By assigning a unique key to each element in a list, you're giving React a way to identify each element in the array. This allows React to efficiently re-render components or update the DOM. Without unique keys, React has to re-render all elements in the list, which can reduce performance, especially when dealing with large lists.
<h2 id="howtouseuniquekeyswitharraychildren">How to Use Unique Keys with Array Children</h2>
Now that we understand why unique keys are important, let's see how we can use them with array children. The most common scenario where you'll need to use unique keys is when rendering a list of elements based on an array of data.
Let's take a look at our previous example, but more in-depth. Here we have an array of to-do items and we want to render them into a list:
<pre><code class="hljs">const todos = [&#x27;Buy groceries&#x27;, &#x27;Walk the dog&#x27;, &#x27;Write article&#x27;];

return (
 &lt;ul&gt;
 {todos.map((todo, index) =&gt; (
 &lt;li key={index}&gt;{todo}&lt;/li&gt;
 ))}
 &lt;/ul&gt;
);
</code></pre>
In this example, we're using the array index as a key. This is a common practice, but it's not recommended if the order of items in your list can change. This is because the key should be stable between re-renders, and using the index as a key can cause issues if the order of items changes.
Here's how you could do that:
<pre><code class="hljs">const todos = [
 { id: &#x27;1&#x27;, text: &#x27;Buy groceries&#x27; },
 { id: &#x27;2&#x27;, text: &#x27;Walk the dog&#x27; },
 { id: &#x27;3&#x27;, text: &#x27;Write article&#x27; },
];

return (
 &lt;ul&gt;
 {todos.map((todo) =&gt; (
 &lt;li key={todo.id}&gt;{todo.text}&lt;/li&gt;
 ))}
 &lt;/ul&gt;
);
</code></pre>
In this example, each <code>todo</code> item is an object with a unique <code>id</code> and <code>text</code>. We're using the <code>id</code> as a key, which ensures that each element in the list has a unique key that remains stable between re-renders.
<h2 id="howtofixandavoidkeyrelatederrors">How to Fix and Avoid Key Related Errors</h2>
One of the most common errors that developers encounter when working with keys in React is the &quot;Warning: Each child in a list should have a unique 'key' prop&quot; warning. This warning appears when you forget to assign unique keys to your list items.
The simplest example we can show is where we're mapping over an array of numbers and returning a list of elements:
<pre><code class="hljs">const numbers = [1, 2, 3, 4, 5];

return (
 &lt;ul&gt;
 {numbers.map((number) =&gt;
 &lt;li&gt;{number}&lt;/li&gt;
 )}
 &lt;/ul&gt;
);
</code></pre>
You'll notice that we didn't provide a <code>key</code> prop to our list items. Running this code will result in the previous warning.
To fix this, we simply need to assign a unique key to each list item. In this case, we can use the array index as the key:
<pre><code class="hljs">const numbers = [1, 2, 3, 4, 5];

return (
 &lt;ul&gt;
 {numbers.map((number, index) =&gt;
 &lt;li key={index}&gt;{number}&lt;/li&gt;
 )}
 &lt;/ul&gt;
);
</code></pre>
<h2 id="otherkeyrelatederrors">Other Key Related Errors</h2>
Another common key-related issue in React is using keys that are not unique. This can lead to unexpected behavior, as React relies on keys to correctly identify elements.
For instance, consider the following example:
<pre><code class="hljs">const numbers = [1, 2, 3, 4, 5, 5];

return (
 &lt;ul&gt;
 {numbers.map((number) =&gt;
 &lt;li key={number}&gt;{number}&lt;/li&gt;
 )}
 &lt;/ul&gt;
);
</code></pre>
In this case, we have two <code>5</code>s in our array, which means two list items will have the same key. This will result in a new warning: &quot;Encountered two children with the same key&quot;.
To fix this error, you need to ensure that your keys are unique. You could do this by appending the index to the number:
<pre><code class="hljs">const numbers = [1, 2, 3, 4, 5, 5];

return (
 &lt;ul&gt;
 {numbers.map((number, index) =&gt;
 &lt;li key={number + &#x27;-&#x27; + index}&gt;{number}&lt;/li&gt;
 )}
 &lt;/ul&gt;
);
</code></pre>
In this code, even if the numbers are the same, the keys will be unique because the index is part of the key.
Although, as mentioned a few times before, using the array index as a key is not recommended.
<h2 id="conclusion">Conclusion</h2>
In this article, we've taken a look at the concept of unique keys for array children in React.js. Like what keys in React are, why we need unique keys, how to use them with array children, and how to fix and avoid key related errors.
So, the next time you're mapping over an array in React, remember to give each child a unique key. It's a small step that can save you from a lot of potential headaches down the line.

Understanding Unique Keys for Array Children in React.js

<h2 id="introduction">Introduction</h2>
As a web developer, you've likely encountered the need to persist data across different sessions or even tabs in a browser. This is where HTML5's localStorage and sessionStorage come in handy. These two web storage objects allow you to store data right in the user's browser, no server-side code required.
In this article, we'll take a look at what these storage objects are, and how you can utilize them to store your JavaScript objects.
<h2 id="whatislocalstoragesessionstorage">What is localStorage/sessionStorage?</h2>
localStorage and sessionStorage are part of the Web Storage API, which provides consistent ways for browsers to store key/value pairs. These pairs are kept in a web browser with no expiration date in the case of localStorage, and for the duration of the page session in case of sessionStorage.
Here's a simple way to think about it:
<ul>
<li><code>localStorage</code> is like a box in your garage where you store things you might need later. It's just always there. It persists across different sessions and even if you close and reopen your browser.</li>
<li><code>sessionStorage</code>, on the other hand, is like a backpack you carry around. It only lasts as long as your &quot;journey&quot; (or in web terms, your session). If you close the tab or the browser, the data vanishes.</li>
</ul>
Here's a basic example of how to use them:
<pre><code class="hljs">// Storing data
localStorage.setItem(&#x27;key&#x27;, &#x27;value&#x27;);
sessionStorage.setItem(&#x27;key&#x27;, &#x27;value&#x27;);

// Retrieving data
let localValue = localStorage.getItem(&#x27;key&#x27;);
let sessionValue = sessionStorage.getItem(&#x27;key&#x27;);
</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: Both localStorage and sessionStorage are limited to storing string data only. So, if you want to store objects, you'll need to convert them into strings using <code>JSON.stringify()</code>. We'll cover this in later sections.

 </div>
 </div>
 </div>
 While these storage objects are incredibly useful, they shouldn't be used for sensitive data like passwords or credit card information, as the data is not encrypted and can be accessed by any script on your site.
<h2 id="howtostoreobjectsinlocalstorage">How to Store Objects in localStorage</h2>
Now that we have a better understanding of what <code>localStorage</code> is, let's look at how to actually do it. As mentioned earlier, <code>localStorage</code> can only store strings. So, we'll need to convert our object to a string before storing it.
Here's an example of how you might do this:
<pre><code class="hljs">let user = {
 name: &#x27;John Doe&#x27;,
 email: &#x27;john.doe@example.com&#x27;
};

// Convert the user object into a string using JSON.stringify
let userString = JSON.stringify(user);

// Store the stringified user object in localStorage
localStorage.setItem(&#x27;user&#x27;, userString);
</code></pre>
In this code, we first create a <code>user</code> object with <code>name</code> and <code>email</code> properties. We then convert this object into a string using the <code>JSON.stringify</code> method. This method takes an object and returns a string representation of that object.
Finally, we store the stringified object in <code>localStorage</code> using the <code>setItem</code> method. This method takes two arguments: the key to store the data under, and the data itself.
Now, if you open your browser's developer tools and navigate to the Application tab, you should see your stored data under the localStorage section.

 <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>JSON.stringify</code> method can also be used to convert arrays and other complex data types to a string format. This makes it a versatile tool for storing a wide range of data in <code>localStorage</code>.

 </div>
 </div>
 </div>
 <h2 id="howtostoreobjectsinsessionstorage">How to Store Objects in sessionStorage</h2>
Just like localStorage, sessionStorage also provides the ability to store key-value pairs. However, there is a key difference between the two: sessionStorage retains data for only as long as the session is active - that is, until the user closes the tab or browser. This can be useful for storing temporary data like form inputs, or other session-specific information.
Let's see how we can store objects in sessionStorage. Just like with localStorage, we cannot directly store objects as they are. We first need to convert them into a string using <code>JSON.stringify()</code>. Here's an example:
<pre><code class="hljs">let user = {
 name: &#x27;John Doe&#x27;,
 age: 25,
 email: &#x27;johndoe@example.com&#x27;
};

// Convert the user object into a string
let userString = JSON.stringify(user);

// Store the stringified object in sessionStorage
sessionStorage.setItem(&#x27;user&#x27;, userString);
</code></pre>
In the above example, we first define an object <code>user</code> with some properties. We then convert this object into a string using <code>JSON.stringify()</code>, and store it in sessionStorage using <code>sessionStorage.setItem()</code>.
<h2 id="retrievingstoredobjectsfromlocalstoragesessionstorage">Retrieving Stored Objects from localStorage/sessionStorage</h2>
Now that we've stored our objects in localStorage or sessionStorage, we'll likely want to retrieve them at some point. The process for this is fairly straightforward, but does require a couple of steps due to the fact that we've stored our objects as strings.
Here's how we can retrieve our <code>user</code> object from sessionStorage:
<pre><code class="hljs">// Get the stringified object from sessionStorage
let userString = sessionStorage.getItem(&#x27;user&#x27;);

// Parse the string back into an object
let user = JSON.parse(userString);

console.log(user);
</code></pre>
When we run this code, we'll see our original <code>user</code> object logged to the console:
<pre><code class="hljs">{
 name: &#x27;John Doe&#x27;,
 age: 25,
 email: &#x27;johndoe@example.com&#x27;
}
</code></pre>
The process for retrieving objects from localStorage is identical, just replace <code>sessionStorage</code> with <code>localStorage</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: Make sure to always use <code>JSON.parse()</code> when retrieving objects from localStorage or sessionStorage. If you forget to do this, you'll be working with a string representation of your object, rather than the object itself.

 </div>
 </div>
 </div>
 <h2 id="conclusion">Conclusion</h2>
In this article, we've covered the basics of how to store, retrieve, and work with objects in HTML5's localStorage and sessionStorage. We've seen how these web storage mechanisms can provide a simple and effective way to persist data across browser sessions, all while maintaining a high level of performance and security.
One common use case for localStorage and sessionStorage is storing user preferences. For example, if a user prefers a dark theme for your website, you could store this preference in localStorage and apply it every time the user visits.
Here's a quick recap of what we covered:
<ul>
<li>localStorage and sessionStorage are web storage mechanisms provided by HTML5.</li>
<li>localStorage persists data across sessions, while sessionStorage only persists data for the duration of the current session.</li>
<li>You can store objects in localStorage or sessionStorage by converting them to a string format using <code>JSON.stringify()</code>.</li>
<li>You can retrieve objects from localStorage or sessionStorage by parsing the stored string back into an object using <code>JSON.parse()</code>.</li>
</ul>