DEV Community: Praise Idowu

Hacktoberfest 2024: My Contributor Experience

Praise Idowu — Thu, 31 Oct 2024 20:32:36 +0000

Hi, my name is Praise. I began coding in 2022, starting out as a Backend Developer, and I’m now exploring full-stack development and AI. Last year, I also ventured into technical writing, fueled by my love for teaching and guiding others on their learning paths. For me, every bit of knowledge I gain is something I want to share, because I believe in helping others grow.

I’ve always been curious about contributing to open-source. My first contribution was last year after digesting a lot of materials online, which led me to tackle a good first issue. That experience helped me get familiar with collaborative Git commands that I wouldn’t normally use. However, during last year’s Hacktoberfest, I felt overwhelmed after browsing several codebases and decided not to proceed.

Fast forward to this year, I came across a video by "Beyond the Classroom," titled "Open-source stories" where students who contributed to open-source were interviewed. I watched the video and felt inspired to try again. I opened GitHub and began searching for projects. This time, I wanted to start with documentation or writing contributions instead of code, but once again, I felt overwhelmed.

As a member of the She Code Africa (SCA) community, I found out that they had partnered with Made in Nigeria for Hertoberfest, an open-source initiative. I didn’t hesitate to apply, and I was accepted. However, when I tried joining a team, I struggled as most were already full by the time I expressed interest. I felt discouraged and decided to give up.

Then, an unexpected opportunity came. A participant from the "Beyond the Classroom" video posted about an open-source project on her LinkedIn. It was an Hertoberfest project titled LearnLink. I immediately messaged her and expressed my interest in contributing. Interestingly, I had a similar idea for a project like LearnLink last year, but I wasn’t confident enough to build it on my own.

The project resonated with me because people often reach out for guidance and resources, and since I’m focused on web development, I frequently have to connect them with people from other fields. Contributing to LearnLink felt like a natural fit. I focused on the backend and AI tracks, with 98% of my contributions being in the backend.

Beyond Hacktoberfest, I would love to expand the LearnLink project by adding additional tracks and resources to help guide learners in their journeys.

One of the biggest lessons I learned from this experience is the importance of seizing opportunities. It has also given me the confidence to take on larger challenges and contribute to bigger projects, as well as improve the software I regularly use. I have a goal of participating in the Google Season of Docs (GSOD) someday, and with this first step, I’m confident I will achieve that.

Memory

Praise Idowu — Sun, 03 Mar 2024 14:43:38 +0000

This article continues our series on Data Structures and Algorithms (DSA). So far, you have likely written "working" and "non-working" code while learning elementary programming. While the concepts apply similarly to JavaScript, we will focus on Python in this article.

Maybe you wrote messy code that "got the job done," littered it with print() statements, or even debugged it manually. However, if you understand how your code works in memory, you will go back to optimize this "messy" code.

There are two mechanisms for storing data on your computer:

Storage: This includes devices like flash drives and hard disks. Data stored here is permanent, meaning it persists even after turning your computer off and back on.

Memory: Also known as RAM (Random Access Memory). Data stored on it is temporary, which means it disappears once you turn off your computer or exit the application.

Given that storage can hold data permanently, why use memory? The answer lies in speed. Accessing data from storage is much slower than accessing it from memory. So, when you need to use data, it gets temporarily copied to memory for faster processing. Once you are done, you can save it back to storage for long-term retention.

To understand this better, let's take a look at the types of memory.

Computers have two types of memory:
Short-term memory: Used for immediate tasks.
Long-term memory: Used for storing data, this memory serves as a more permanent storage.

When you run a program, your CPU allocates a portion of short-term memory to execute its instructions.

To see memory in action, open your Task Manager and launch applications like Chrome. Observe that memory usage increases as you open more apps. This increased usage eventually slows down your computer. To improve performance, close some applications to free up memory space.

Why do we need to learn Memory?

To use the memory optimally.
To make the right decision when writing code. It's either speed or space preference, depending on what you are ready to forgo.

Memory Hierarchy

Every computer relies on a layered system called the memory hierarchy to manage data storage and access. This system balances speed, cost, and capacity by using different memory types with distinct characteristics.

Registers & Cache:
These two memories reside on the CPU itself.

Registers are the fastest areas of memory on the CPU, but they are also the smallest. They store data that is required immediately.

The cache is an area of memory on the CPU that is used to store the next instructions that need to be executed. They are slower compared to registers. It stores data that is required shortly. There are further levels within the hierarchy, like L1, L2, and L3 cache, for varying speeds and sizes.
L1 - fastest but smallest
L2 - slower but bigger
L3 - slowest but biggest

Main Memory (RAM):
The main memory is the primary working memory of your computer. It holds data and instructions currently being used by programs. Main memory is faster than secondary storage but volatile: meaning data vanishes when you power it off.

Secondary Storage (Hard Drives, SSDs):
This is a persistent storage that retains data even after power is off. Slower than RAM but much more affordable and larger. It is ideal for long-term data archiving and accessing less frequently used information.

Network-based Storage:
This storage is located on external servers accessed through networks. Offers flexibility and scalability for sharing data among multiple users and devices. It can be slower than local storage but offers remote access benefits.

Measuring Space

Have you ever wondered how the computer stores all the information you use? To understand how computers represent data, it is crucial to first grasp the decimal system.

Understanding the Decimal system

You are likely already familiar with the decimal system, also known as base-10. This decimal system uses ten digits (0-9) to represent numbers, where each digit's position holds a specific weight based on powers of 10. For instance, in the number 123, the "1" represents 1 x 10² (100), the "2" represents 2 x 10¹ (20), and the "3" represents 3 x 10⁰ (1).

The Binary System

Computers primarily rely on the binary system(bit). This base-2 system is composed of only two digits: 0 and 1. These digits symbolize different states, often likened to electrical switches, where 0 represents "off" and 1 represents "on."

Bits

The bit (short for binary digit and denoted by b) is the basic unit to measure data in a computer. It can only hold one value at a time, either 0 or 1. Just like a single switch can only be on or off.

Nibbles

A nibble (or half-byte) comprises four bits (4 bits). This grouping of bits allows for efficient representation of certain data types, such as storing a single hexadecimal digit (0-F), which requires four bits.

Bytes

A byte (denoted by B), consisting of eight bits (8 bits), is the standard unit for measuring computer memory and storage capacity. Most modern character encodings, like ASCII, assign one byte to represent a single character. For example, the ASCII encoding of letter 'A' is represented as 01000001. You can view the ASCII chart by clicking here.

Unit of measurement

While bytes are the fundamental unit, larger storage capacities utilize prefixes like kilo (103), mega (106), giga (109), and tera (1012) to represent multiples of bytes. For example, a kilobyte (KB) is equivalent to 1000 bytes, and a megabyte (MB) is equal to 1,000,000 bytes. However, some operating systems and software may use the decimal and binary systems interchangeably, which can lead to discrepancies in the reported storage capacities, as explained in the IEC article.

Metric Prefixes

Units representing larger groups of bits and bytes use the metric prefixes. Here is an overview:

Name	Value	General terms	Example
byte	1 byte	One byte	One ASCII character
Kilobyte (KB)	10³ bytes	One thousand bytes	2-3 paragraphs of text
Megabyte (MB)	10⁶ bytes	One million bytes	Picture taken by a smartphone
Gigabyte (GB)	10⁹ bytes	One billion bytes	A movie downloaded to your device
Terabyte (TB)	10¹² bytes	One trillion bytes	1,000 movies downloaded to your device

Binary-Based Units

Units based on powers of 2 have slightly different prefixes:

Value (in bytes)	Name	Approximate Decimal Equivalent
1	byte	1
2¹⁰	Kibibyte (KiB)	10³ = 1000
2²⁰	Mibibyte (MiB)	10⁶ = 1,000,000
2³⁰	Gibibyte (GiB)	10⁹ = 1,000,000,000
2⁴⁰	Tebibyte (TiB)	10¹² = 1,000,000,000,000

Prefix generation

The prefixes for binary-based units were generated by combining the standard metric prefixes with “bi,” resulting in “Kibi,” “Mebi,” “Gibi,” and “Tebi.” See example below:
Kilo + Binary = Kibi
Mega + Binary = Mebi
Giga + Binary = Gibi
Tera + Binary = Tebi

Memory Model in Python

We have seen the importance of space in algorithms. Ideally, we want to limit how much space our program uses and also optimize our program so that they can use the fast parts of the memory hierarchy. Before we can do that, we have to understand how the Python program stores data.

How are Python objects stored in Memory?
Remember that in Python, all data is represented as an object. These include numbers, strings, lists, functions, and classes. Each object has properties/attributes and methods.

The Stack and the Heap

When a Python program executes, all of its data is stored in the main memory.
It creates a runtime stack and dynamic memory heap.

The Stack

Functions and variables are created in the stack.
A new stack frame is created on the invocation of a function or method. Inside the stack frame, we have local variables and parameters.
A stack frame is destroyed as soon as the function or method returns.

def my_function1():
    x = 4
    print(x)

def my_function2():
    y = 7
    return y

my_function1()
print(my_function2())

Let’s click through our example step by step using an online visualizer.
Step 1: It creates a global frame for the functions.
Step 2: It accesses the variable within the scope and prints it in the terminal.
Step 3: my_function1() returns None because we didn’t use a return statement, while my_function2() returns 7.

Scope

We can't talk of a stack frame without discussing the concept of scope.
There are two types of scopes:

Local scope: Variables and functions within a function are only accessible through that function.

Global scope: Variables and functions declared outside any function have a global scope. They are accessible from anywhere in the program, including within functions. Using global variables excessively is generally not recommended because as your program grows, you find it hard to think of a variable name as everything is already used, leading to a name clash and many other reasons. You can check out this article for a detailed explanation of why global variables are generally bad.

In summary, think of a local scope as functions and variables declared in a function and a global scope as functions and variables declared outside a function. When you create a function, you automatically create a scope for the variables and functions inside, and for this reason, we use a return value to end the function and return a value.

y = 5
print(y)

def my_function():
    x = 4
    print(x)

my_function()
print(x)

Let’s click through our example step by step.
Step 1: It creates a global frame for y.
Step 2: It gets printed to the terminal.
Step 3: It executes my_function() and returns None.
Step 4: When it gets to print(x) it returns a NameError. But why?
The answer boils down to scope. x is within the scope of my_function() so when Python tries to find x it checks the global scope and when it can’t find it, it returns an error.

Let’s look at another example. Step through the code.

x = 5

def my_function():
    x = 4
    print(x)

my_function()
print(x)

Step 1: It creates a global frame for x and my_function().
Step 2: It prints out x and returns None.
Step 3: It checks for x in the global frame and prints it out.

Let’s take a look at another example.

x = 5

def my_function():
    print(x)

my_function()

And another.

def my_function():
    x = 5
    return x

x = my_function()
print(x)

As a rule of thumb, Python typically looks for a variable's name by:

looking at the current frame.
If not found, looking at the global frame.
If not found, raising an error.

The image above is a recursive function, we will dive deep into it in future tutorials. But I want you to take note of something. You can see a local and global scope as well as a call stack.
Try debugging your programs on vscode and take note of these things. We move on to the next concept.

The Heap

Think of the stack as the reference memory address of the object on the heap.
The heap stores the values along with its memory address.

NOTE: All values are stored in the heap. Objects are created on the heap.

When we discuss heap there are two concepts we have to learn.

Reference counting
Garbage Collector

A value in memory has references to the stack, or the stack references the value in memory. More than one stack can reference a value in memory. Once we reassign the variables in the stack it points to another memory address and another until the reference is 0. The garbage collector will deallocate it from memory. This is done automatically, so you won't have to worry about it. So this algorithm used for garbage collection is called reference counting.

To see this in action, step through this code using the online visualizer. What did you notice?

x = ['a', 'b', 'c']
y = x
print(x)
print(y)

Answer: Two arrows are pointing to the object on the heap.

Let’s make it even more fun. We will use an id to print its memory address on the terminal.

x = ['a', 'b', 'c']
y = x
print(id(x))
print(id(y))

Let’s see more examples.

# purpose - want to switch the values i.e x = 3, y = 1

x = 1
y = 3
x = y
y = x

print(x)  # result: 3
print(y)  # result: 3

This doesn’t work because we have lost xvalue in the process of reassignment. Let’s create a temp variable to store the value of x.

x = 1
y = 3
temp = x
x = y
y = temp

print(x)
print(y)

Let’s use another method and it works the same.

x = 1
y = 3
x, y = y, x

print(x)
print(y)

Let’s create an object in Python and compare the memory address.

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

point1 = Point(1, 2)
point2 = Point(3, 4)
print(point1 == point2)  # result: False

It returns False for this reason.

NOTE: When comparing objects we are comparing the address they contain in memory.

Mutability

Immutable objects cannot be modified by the program. All primitive data types are immutable.
E.g., strings, integers, floats, booleans, and tuples.
You may argue that you can reassign a variable containing these primitives and it does change.
But here is the deal. In your eyes, when it gets reassigned, it changes, but in memory, it simply changes the reference. Do you remember that the stack is a reference to the value in the heap? So if the memory address were previously 1021, now it would point to 1053. If no variable references 1053 anymore, the reference count is 0, and it gets garbage collected.

Mutable objects can be modified. E.g. Lists, dict, and user-defined object types.

We might not be able to visualize this properly using the online visualizer, so I have used a diagram and id to explain it.

name = 'Praise'
print(id(name))  # result: 140700969655408

name = 'John'
print(id(name))  # result: 140700766157320

print(name)  # result: John

Step 1: It points an arrow to 1011(lets imagine that's the memory address of Praise).
Step 2: When we reassign it points it to 1022.

Step through this code.

names = ['Praise', 'John', 'Paul']
print(id(names))

names[0] = 'Tinuke'
print(names)
print(id(names))

You will notice that the memory address is the same.

Understanding how objects are made

A space is created in memory for our object.
The variable is initialized using init.
A reference to the object created is returned.

Tracing Code using diagrams

The best way to understand how memory works is to write some codes and see the step-by-step execution of memory. I have shown you some examples so far. Look at the codes you have previously written and step through them. Python tutor visualizer has some limitations, so you would have to use the debugging tools in your code editor.

Resources & References

Summary

In this lesson, you have learned:

Storage and Memory
Short-term and long-term memory
Memory hierarchy
Measuring Space
Stacks, Heaps, Scopes, References, Garbage collector, and Mutability
Tracing the code using an online visualizer tool

Until next time, for more insights:
☕ If you enjoy my content, you can buy me a cup of coffee here.
📰 To read more from me, subscribe to my newsletter.
🧸 Check my social media profiles: Twitter, Github, and LinkedIn.

Practice Projects

Praise Idowu — Sat, 10 Feb 2024 15:22:14 +0000

Welcome to the second project in this series. In this project, you will modify the code by breaking it into simple functions and refactoring it. This will teach you how to organize your code. By the end of this project, you will be prepared to tackle the remaining exercises.

To access the project file and README, click here.

Writing Code

Open the project README. You are working on Project 1 which is “ Selective Copy”. Make sure you understand what you are to do before moving on to read the code.
This project will teach you how to read people code and improve on the code. In the real-world you will probably be working on code written by previous engineers, you are likely not going to write new codes.

import os, shutil, sys

# walk through a dir tree
# create a list of file extensions to copy
# copy it to a new folder


def select_copy(src, dest):
    src = os.path.abspath(src)
    dest = os.path.abspath(dest)

    extensions = ['.pdf', '.jpg', '.png']

    # Check if the provided path is a directory
    if not os.path.isdir(src):
        print(f'The path "{src}" you have provided is not a directory')
        return  # used to exit the function

    # walk the dir tree
    for folder_name, subfolders, filenames in os.walk(src):
        for filename in filenames:
            for extension in extensions:
                if filename.endswith(extension):
                    print(filename)

                    # check if the dest exists
                    if not os.path.exists(dest):
                        os.mkdir(dest)

                    # copy it to a new folder
                    shutil.copy(os.path.join(folder_name, filename), dest)



if __name__ == '__main__':
    src = r"C:\Users\Praise Idowu\Desktop\test2"
    dest = r"C:\Users\Praise Idowu\Desktop\test4"
    select_copy(src, dest)

Run the program. Let us move on to the refactoring phase.

Refactoring

If a variable like subfolders is not utilized, it is a Python convention to replace it with an underscore (‘_’). Replace subfolders with an underscore.

for folder_name, subfolders, filenames in os.walk(src):

Create three functions, each with a parameter.
Multiline strings explain the purpose of each function. Implement and test your code.

import os, shutil, sys
def select_files(src, extensions):
    """
    Select files with specified extensions from the source directory.


    Parameters:
    - src (str): Source directory path.
    - extensions (list): List of file extensions to select.


    Returns:
    - list: List of selected file paths.
    """
    pass


def copy_files(selected_files, dest):
    """
    Copy selected files to the destination directory.


    Parameters:
    - selected_files (list): List of file paths to copy.
    - dest (str): Destination directory path.
    """
    pass       

def select_copy(src, dest, extensions):
    """
    Select files with specified extensions from the source directory
    and copy them to the destination directory.


    Parameters:
    - src (str): Source directory path.
    - dest (str): Destination directory path.
    - extensions (list): List of file extensions to select.
    """   
    pass           


if __name__ == '__main__':
    pass

Exercise

Complete the remaining two exercises in the practice project and share your code as well.

We have come to the end of this series.

Conclusion

You already have the skills needed to organize and manipulate files. Moving forward, you will work on complex automation projects. Until next time, happy coding!

Why learn Data structures and Algorithm

Praise Idowu — Sat, 03 Feb 2024 16:27:55 +0000

What crosses your mind when the term "data structures and algorithms" (DSA) is mentioned? Let me take a guess – FAANG(Facebook, Apple, Amazon, Netflix, Google) interviews, perhaps? Spot on. Chances are, that's exactly why you are here. DSA may appear intimidating, leaving you questioning its significance. However, in today’s world, where efficiency is key and competition is fierce, mastery of DSA has become vital. Maybe you have been immersed in coding for years without needing it, and then suddenly, an interview arises, demanding you to quickly acquire DSA skills. Alternatively, it could be a pivotal course in your Computer Science curriculum, or there might be another reason altogether.

In this article, we will cover:

What is a data structure?
What is an algorithm?
Big-O time and space efficiency.
Why should you learn DSA?
How to learn DSA.

What is Data Structure?

A data structure is a way to store and organize data to allow us to efficiently access and modify the data. Operations performed on this data include adding information, searching for it, or removing it.

Let's consider a real-world example. Picture yourself at a library needing a book on Organic Chemistry. You locate the Chemistry shelf, but it contains all sorts of books unrelated to Chemistry.
Because the shelf is disorganized, you spend a longer time searching for the book, which might eventually lead you to check other shelves as well because, who knows, it could be on the linguistics shelf.

Now, envision an organized scenario. You reach the science shelf, find a section for Chemistry, and within that, distinct sections for Organic Chemistry. Suddenly, your search becomes effortless.

In computer science, how we organize data is crucial for easy retrieval. Choosing the appropriate data structure can significantly improve code efficiency.

Examples of Data Structure

Arrays/Lists: Ordered, mutable collections.
Dictionaries/Objects/Maps: Unordered, mutable key-value pairs.
Sets: Unordered, mutable collections of unique elements.
Tuples: Ordered, immutable collections.

What is an Algorithm?

An algorithm is a set of instructions to perform a computation. Simply put, it involves operations on different data structures along with a set of instructions for executing them.

Let's consider a real-world example.

Imagine you want to teach your five-year-old brother to draw a circle.

Put a small pencil in the compass.
Align the pencil in the compass to ensure its tip matches the width of the divider.
Measure the radius on a ruler.
Place the divider on the paper and move it in a circular motion until it forms a circle.

There you have it – you have just implemented an algorithm.

Now, let's transition to a programming example:
Imagine you are to write a program to calculate the sum of two numbers.

Define two variables to represent the two numbers.
Use an arithmetic operation to add the two numbers.
Return the sum.

Python Example

def find_sum(num1, num2):
    sum = num1 + num2
    return sum

if __name__ == '__main__':
  sum = find_sum(5, 7)
  print("The sum is:", sum)

JavaScript Example

function findSum(num1, num2) {
    let sum = num1 + num2;
    return sum;
};

// Example usage:
let sum = findSum(5, 7);
console.log("The sum is:", sum);

Let's discuss the space and time efficiency of an algorithm.

What is Space and time efficiency?

Space and time efficiency is concerned with how the algorithm utilizes two essential resources: space and time.

Space: This refers to memory and storage considerations.
Time: This refers to the speed at which the algorithm operates.

In the next tutorial, we will discuss Memory where we will dive into this deeper.

What is Big-O Notation?

Big-O notation can be used to describe an algorithm's space and time efficiency. It provides a set of rules to measure both space and time complexities.

Let's consider two functions.
A: Sort(): Modifies the original array and returns an ordered array.
B: Sorted(): Creates a new sorted array without modifying the original iterable.

Given solutions A and B, which one is more efficient in terms of space?

Answer: A is more efficient in terms of space because it uses minimal memory.
B needs more space to hold the new sorted array.

Now that we have clarified the key terms, let's proceed to answer the question.

Why learn DSA?

Improve Problem-Solving Skills: This is a fundamental skill for programmers. DSA teaches you to think, rapidly improving your problem-solving ability.

Help in Solving Real-world Problems: DSA assists in selecting the right data structures and algorithms to tackle real-world issues. Consider a social network or map; a graph algorithm can be instrumental in solving such problems.

Write Optimized Code: DSA improves efficiency in terms of both space and time. Optimized code runs faster, utilizes less memory, and is overall more efficient.

Prepare for Technical Interviews: Leading companies like FAANG often ask questions related to DSA in technical interviews. Familiarity with DSA concepts becomes crucial in attaining success in these interviews.

I know this has been a lot to grasp so far. Now, you might be wondering how to start and what resources you need. These questions will be answered shortly.

How to learn DSA?

Be comfortable in a programming language e.g Python, JavaScript, C, Java, etc
Start with searching and sorting algorithms because it is much easier to understand before diving into complex algorithms.
Understand, don't memorize; visualize and write pseudocode.
Scrabble algorithm on paper.
Watch various videos for implementation insights.
Apply algorithms in real-world projects, reflecting on past coding challenges.
Consider the big-O space-time complexity to determine the efficiency of your code.

Resources

Summary

Data Structures and Algorithms are key concepts in computer science. It can help you write efficient code and pass interviews.

Check out the next article where I delve into DSA in-depth.

Until then, for more insights:
☕ If you enjoy my content, you can buy me a cup of coffee here.
📰 To read more from me, subscribe to my newsletter.
🧸 Check my social media profiles: Twitter, Github, and LinkedIn.

Renaming Files with American-Style Dates to European-Style Dates

Praise Idowu — Sat, 27 Jan 2024 08:50:59 +0000

Welcome to the first project in this series. In this project you will rename files with American-Style dates to European-Style dates. You will combine your knowledge of regular expressions and file organization. To follow along with this project, access the project file here.

Before starting let us see if you are prepared for this project. Read the prerequisites below before moving on.

Prerequisites

Make sure you have a good understanding of the following resources before tackling this project:

File Organization
Series 1 and 2

Step 1: Understand the project

Assuming they are all organized in this format: MM-DD-YYYY.

What we want to achieve is this format: DD-MM-YYYY.

Observe the first image, what did you notice?
Once you are done, check out my answers.

Observation 1: Only the day and month need to be swapped.
Observation 2: Some of the filenames have a prefix before the dates.
Observation 3: The prefix is separated from the dates with an underscore.

Step 2: Write code

Step 1: Import the Required Modules
The os, sys, and re modules have been used in several other projects, so you should already be familiar with them.
The shutil module is used to perform operations such as copying, moving, and renaming files.

Step 2: Create a function with one parameter: root_dir.

Step 3: Create a regex pattern.
Comments have been used to explain it. But overall, the pattern matches American-Style dates with years in the 19's and 20's.
re.compile is used to compile a regular expression pattern into a regex object, allowing you to reuse the pattern for matching operations.

Question: Can you identify how many groups are in this pattern? Remember that a group is separated by () parenthesis. Drop your answers in the comments section.

Step 4: Test the pattern.
To test the pattern, visit this website, hover over each pattern and it interprets it as a character, metacharacter and so on. On the right side of the website, you will find a cheat sheet for reference. Paste some filenames in both correct and incorrect patterns to see if they match.

Step 5: Loop through all files in the root_dir.

Step 6: Search each file for pattern match.
Do you remember what .search does? It finds the first occurrence of a pattern in a string and returns a match object, while .findall returns all occurrences of the pattern as a list of strings.
Print out the match object to see what it returns, then comment it out and proceed.

Step 7: Check if a match is found and if true, it returns a date component.
match.groups() returns a tuple. You can unpack the tuple by assigning its elements to individual variables, such as month, day, year, and _. The underscore _ is often used as a placeholder for values you want to ignore.

Step 8: Rename the filename to the European-Style date: DD-MM-YYYY.

Give it a variable name; new_filename.
Use f-string to give it the desired name: This line uses an f-string to construct the new_filename. Here's a breakdown of how it works:
filename[:match.start()]: This part takes the portion of the original filename from the beginning up to the start of the match. It effectively includes everything before the matched text.
{day}-{month}-{year}: This part adds the date components (day, month, and year) extracted from the match. They are separated by hyphens to create a date format.
filename[match.end():]: This part takes the portion of the original filename from the end of the match to the end of the string. It effectively includes everything after the matched text.
Print the filename to check that it works correctly: You can use print(new_filename) to verify that the new filename is generated as expected. Once you confirm that it's working correctly, you can comment out the print statement.

In summary, this code creates a new filename by replacing the matched portion of the original filename with the extracted date components in a specific format.

Step 9: Get the old and new file_path and store them in a variable.

Step 10: Use shutil.move() to rename it.
Before running the code, it's a good practice to comment out the shutil.move() line. After verifying that the print statement works correctly and provides the expected file paths, you can uncomment it to actually rename the files.

Step 11: The last part is checking if a root directory is specified by calculating the length. Remember that sys.argv returns a list, so you can check the length of this list to see if a root directory is specified.

import os, shutil, re, sys

# let us assume all files are in the American Style dates and we want files in the 19's and 20's

def rename_files(root_dir):
    # Create a regex pattern for American-style dates (MM-DD-YYYY)   
    date_pattern = re.compile(
        r'''
        (0[1-9]|1[0-2])-  # matches 01-09 or 10-12 for month with a '-' character
        (0[1-9]|[12]\d|3[01])- # matches 01-31 for days
        ((19|20)\d{2})  # matches the 19's and 20's for year
        ''', re.VERBOSE
    )

    # Loop through all files in the current directory
    for filename in os.listdir(root_dir):
        # Check if the filename contains a date in American style
        match = date_pattern.search(filename)

        if match:  # not None
            # Extract the date components
            month, day, year, _ = match.groups()  # returns a tuple
            # Rename the file with European-style date (DD-MM-YYYY)
            new_filename = f'{filename[:match.start()]}{day}-{month}-{year}{filename[match.end():]}'
            print(new_filename)

            old_filepath = os.path.join(root_dir, filename)
            new_filepath = os.path.join(root_dir, new_filename)

            # Rename the file using shutil.move()
            shutil.move(old_filepath, new_filepath)
            print(f'Renamed: {filename} -> {new_filename}')
            print()

if __name__ == '__main__':
    if len(sys.argv) != 2:
        print('Usage: python main.py [root_dir]')
        exit(1)

    try:
        root_dir = sys.argv[1]  
        rename_files(root_dir)
    except FileNotFoundError as e:
        print(e)

This is the result on the terminal.

Exercise 1

Use the os module to rename files. Give it a try!

Exercise 2

Complete the exercises listed under "Ideas for Similar Program." You can find the questions here. Once you have completed them, share the link to your solution in the comments section.

Creating Python Virtual Environment on Windows 11

Praise Idowu — Sat, 20 Jan 2024 16:01:32 +0000

When you work on a Python project, the conventional approach involves globally installing a Python interpreter and creating a file named filename.py. Typically, as you advance into more complex Python tasks, you may use pip to install packages globally.

While this method might not pose a problem initially, it can become a concern as you move into specialized areas such as Data Science, Data Analytics, or Backend development.

Imagine a scenario: you have Project A where you have installed version 1.0 of a package. Then you switch to Project B and install the same package but version 2.0. Upon returning to Project A, you encounter issues—this is what we call breaking changes.

In the following sections, I will walk you through:

Creating, activating, and deactivating a virtual environment
Reproducing a virtual environment
Installing packages within the virtual environment
Specifying the Python interpreter when creating the virtual environment
Configuring and using a virtual environment in VSCode

Now, let’s address the question.

What is a virtual environment?

A virtual environment serves as a secluded space to store project dependencies. It is an isolated environment where project dependencies are stored.

Within each virtual environment, there is a specific Python version it runs on and folders of third-party libraries you have installed. Virtual environments make it easy to keep track of project dependencies, particularly useful when working on projects with dependencies.

When you think of a virtual environment, picture the two key components shown in the figure above.

The figure above illustrates what you have on your system when you create multiple virtual environments.

What is a dependency?

A dependency is a code written by other people that we can install and use on our project so we don’t have to rewrite it. However, this practice introduces potential compatibility issues, conflicts, or breaking changes, especially since every package tends to release new versions.

Semantic Versioning

The figure above illustrates the major, minor, and patch versions.

What is a pip?

Pip is a package management tool in Python that we can use to install these dependencies. Visit PyPI(Python Package Index) to install and publish Python packages. Click here to learn more about modules and packages.

pip

Run the above on the CLI to see a list of pip commands. Feeling adventurous? Play around the commands and come back to continue reading.

Mostly when you are working with virtual environments, you use pip alongside it to install dependencies.

Why installing packages globally using pip is a bad idea

It becomes challenging to keep track of project dependencies across different projects when packages are installed globally.
When working on a new project and installing the same package, pip automatically uninstalls the previous version. This can lead to compatibility issues with other projects.

Let’s take a look at the tools to create virtual environments.

Tools for creating virtual environments

venv
virtualenv
pipenv

Venv

Venv is a lightweight built-in module in Python 3.3 and later versions for creating virtual environments requiring no installation.

Creating a virtual environment

mkdir env py -m venv env/my_env
my_env is the name of the virtual environment. Replace my_env with the name of the project.

Activating a virtual environment

.\my_env\Scripts\activate

Now run this:
pip list

This command lets you see the packages you installed in the virtual environment. For now, only pip is available in the virtual environment.
Installing packages into the virtual environment
pip install python-decouple pip install pillow pip install django pip install django-autoslug

Install the above packages. Now run the pip list. You can see a list of dependencies.

Deactivating a virtual environment

deactivate

To deactivate the environment, run the above command and run the pip list again.

Reproducing the virtual environment

From the documentation, it says the virtual environment should be simple to delete and recreate from scratch.

pip freeze > requirements.txt
Delete the virtual environment, create a virtual environment, and activate it. Then run the command below:
pip install -r requirements.txt

This is particularly useful when collaborating on a project. You want to recreate the virtual environment on your machine.
NOTE: Always .gitignore the folder where the virtual environment is created.

Specify the Python Interpreter while creating the virtual environment

py –list
Run the above command to see a list of Python versions installed on your system. Automatically Python uses the latest version installed. If you want to use another version while creating the virtual environment, run:

py -X.Y -m venv myenv: e.g py -3.9 -m venv myenv

NOTE: If the Python version is not installed or in the path you will get the error below. To install Python, click here.

Virtualenv

Virtualenv is a third-party library requiring installation that is used to create virtual environments in Python. It has been available in earlier versions of Python such as Python 2. It is still being used; however, since Python 3.3, a subset of it has been integrated into the standard library under the venv module. Venv is not a replacement for virtualenv. It has small differences with the virtualenv library. To learn more about it, visit the documentation.

To get started using it you have to install the virtualenv library.

pip install pipx pipx install virtualenv

You can choose to use pip to install the library except for a small difference; the documentation recommended using pipx for the installation.

Create the environment

virtualenv my_env
This creates a folder in your current directory.

Activate the environment

.\my_env\Scripts\activate
This activates the virtual environment.
Specify the Python Interpreter while creating the virtual environment
virtualenv -p python-interpreter-path

You need the right path that ends with python.exe. You can easily get this path by checking the path in environment variables.
"C:\path\to\your\python.exe"
"C:\Users<YourUsername>\AppData\Local\Programs\Python\Python3x\python.exe"
NB: Replace x with the version.
It should look like this on your system:
virtualenv -p "C:\Users\<YourUsername>\AppData\Local\Programs\Python\Python312\python.exe" my_env

Virtualenvwrapper

Virtualenvwrapper creates and activates the virtual environment. It keeps all your environment in one place. It is an extension to the virtualenv tool. With virtualenvwrapper, you only need to type workon to switch between virtual environments. You can run the same command to see a list of virtual environments.
For windows we have a special package we use called virtualenvwrapper-win. It only works on command prompt, so be sure to switch to a command prompt.
pip install virtualenvwrapper-win
mkvirtualenv <name>
Replace with venv or any other name.
lsvirtualenv
It displays the list of virtual environments that have been created.
workon <name>
It activates the virtual environment. If the name is not specified, it lists the available environments.
deactivate
It deactivates the virtual environment.
To learn more commands you can check out the docs.

Pipenv

Pipenv is a virtualenv management tool and a package management tool. It combines venv or virtualenv and pip in a single command. It also works alongside pyenv and asdf to manage multiple python environments. It automatically creates a virtual environment and can be used for installation of packages as well.

Install Pipenv Tool

pip install pipenv

Activate the virtual environment

pipenv shell
NOTE: If you install a package with the pipenv command without activating the virtual environment, it will create a virtual environment for the project and ask you to run pipenv shell to activate it.

Install packages

pipenv install django pipenv install python-decouple

Specify a version

pipenv --python 3.9
The version of Python specified must be installed on your system or it will request you to install pyenv or asdf.

Exit the virtual environment

Exit or exit

Reproducing the virtual environment

To recreate it. All you have to do is run this command, and it installs all the dependencies from Pipfile. To learn more about its features read the docs.
pipenv install

NOTE: If pyenv is available it will automatically install the required Python version.

To learn more about the commands click here or run pipenv on the CLI.

Configuring and using a virtual environment in VSCode

To switch the virtual environment on Vs Code, look at the bottom right of the code editor. You can click on it to switch between interpreters. Another way is using a keyboard shortcut ctrl+shift+p, and the command palette pops up. Search for Python interpreters to switch between interpreters.

Others:
Poetry: This is a Python packaging and dependency management tool. You will likely find it useful if your focus is on packaging and dependency management such as publishing a package to PyPI.
Conda: It is a package management and environment management system. You will most likely find it useful if you are into data science or scientific computing. It is not limited to these two careers but it is widely used in data science and scientific computing.

Conclusion

In this tutorial we learned about virtual environments and their importance in managing multiple project dependencies. We used built-in modules and third-party libraries to create virtual environments. The choice of which virtual environment to choose from might be confusing at first but except for small differences, it doesn’t matter. The choice depends on your preferences and project standards. If you are a beginner you can start with venv since it is the easiest to set up. When you get comfortable with it you can explore other virtualenv and stick to it.

Until then, for more insights:
☕ If you enjoy my content, you can buy me a cup of coffee here.
🧸 Check my social media profiles: Twitter, Github, and LinkedIn.

Project: Regex Search

Praise Idowu — Sat, 13 Jan 2024 09:53:14 +0000

Welcome to the third project in this series. In this project, you will automate the searching of user-supplied text patterns within text files.
To follow along with this project, you can access the project files and READMEs here.

Prerequisites

Before embarking on this project, make sure you have completed Part 2 of the series.

Project Structure:

This project follows a logical structure aimed at helping you grasp the concepts and build the skills progressively. Here is how we will approach it:

Start Simple: We will begin with a straightforward approach to achieve basic functionality. Our primary goal is to make the code work as intended, even if it is not perfect initially.
Refine and Enhance: Once your code is functional, we will start improving it. This phase will involve optimizing the code for better performance and usability.
Challenge Yourself: As usual, there will be an exercise at the end of the project.

Open the project file in a separate tab and follow along with these steps.

Step 1: Understand the Project.

# provide the absolute path to the directory
# search the directory of any .txt files
# Open each file
# Search for lines that match the user-supplied regex
# print the matching result

Step 2: Import the Required Modules.

import os, re

Step 3: Create a Function.
Create a function with two parameters: dir_path and user_supplied_regex. This function will be used to perform the desired regex search.

def regex_search(dir_path, user_supplied_regex):
    # Your code goes here

Step 4: Get the Absolute Path of the Directory.
Use os.path.abspath(dir_path) to get the absolute path of the directory. Ensure you specify dir_path as a raw string to prevent the character from escaping.

if __name__ == '__main__':
    dir_path = r'C:\Users\Praise Idowu\Documents\blog-projects\Automating-the-boring-stuff-with-Python-blog-project\chapter-8\regex_search\folder1'
    user_supplied_regex = None
    regex_search(dir_path, user_supplied_regex)

Step 5: Loop Through the Files.
Use a for loop to iterate through the filenames in the specified directory.

Step 6: Check if it is a File.
Use the os.path.isfile(filepath) to check if the current item is a file.

Step 7: Check the File Extension.
Use os.path.splitext(filepath) to split the file extension from the filename. It returns a tuple and you can access the extension using indexing.

Step 8: Check if it is a .txt File and Print the Filename.
Use a conditional statement to check if the file has a .txt extension. If it does, print the filename. Once your code is working correctly, comment out the print statement and move on to the next step.

Step 9: Open the File and Read its Content.
Open the file in read mode and store its content in a variable.

Step 10: Compile the User-Supplied Regex and Find Matches.

Compile the user-supplied regex pattern using re.compile(user_supplied_regex, re.VERBOSE).
Use re.findall() to find all occurrences of the regex pattern in the file's content.
If matches are found, print them as the results.

import os, re

def regex_search(dir_path, user_supplied_regex):
    # provide abs path
    dir = os.path.abspath(dir_path)
    # print(dir)
    for filename in os.listdir(dir):
        # print(filename)
        if os.path.isfile(os.path.join(dir, filename)):
            # print(filename)
            split_file = os.path.plaintext(os.path.join(dir, filename))
            # print(split_file)
            # searches the directory for any .txt files
            if split_file[1] == '.txt':
                print(filename)

                # It opens the folder
                with open(os.path.join(dir, filename), 'r', encoding='utf-8') as f:
                    content = f.read()
                # print(content)

                # It searches for a line that matches the user-supplied regex
                user_regex = re.compile(user_supplied_regex, re.VERBOSE)
                for groups in user_regex.findall(content):
                    # it prints the result
                    print(groups)



if __name__ == '__main__':
    dir_path = r'C:\Users\Praise Idowu\Documents\blog-projects\Automating-the-boring-stuff-with-Python-blog-project\chapter-8\regex_search\folder1'
    # user_supplied_regex = r'web | scraping'
    user_supplied_regex = r'''(
        (https?://)[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?
        )'''
    regex_search(dir_path, user_supplied_regex)

The previous code works well, but it can be improved. Here are the updates that have been made:

Removed repetition of os.path.join and created a file_path variable to replace it.
Used filename.endswith to check for the '.txt' extension. It returns a boolean.

import os, re

def regex_search(dir_path, user_supplied_regex):
    # Provide an absolute path
    dir = os.path.abspath(dir_path)

    # Create a regex pattern from the user-supplied regex
    user_regex = re.compile(user_supplied_regex, re.VERBOSE)

    for filename in os.listdir(dir):
        file_path = os.path.join(dir, filename)

        # Check if the file is a .txt file
        if os.path.isfile(file_path) and filename.endswith('.txt'):
            print(filename)

            # Open and read the file
            with open(file_path, 'r', encoding='utf-8') as f:
                content = f.read()

            # Search for matches in the content
            matches = user_regex.findall(content)

            # Print the matched line
            for match in matches:
                print(match)

if __name__ == '__main__':
    dir_path = r'C:\Users\Praise Idowu\Documents\blog-projects\Automating-the-boring-stuff-with-Python-blog-project\chapter-8\regex_search\folder1'
    # user_supplied_regex = r'web | scraping'
    user_supplied_regex = r'''(
        (https?://)[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?
        )'''
    regex_search(dir_path, user_supplied_regex)

# TODO: use input() instead

Exercise 1

Instead of hard-coding dir_path and user_supplied_regex, use the input() function to prompt the user to enter these values interactively.

Exercise 2

Depending on the regex the user supplies, it can print a string, lists, or tuples.

To make the code more flexible and handle different output scenarios, Tope has already implemented some code but needs assistance in completing it. You can improve the functionality by allowing the user to choose the output format (default, returns a string, list of tuples, or tuples) and providing an option for indexing or slicing if the user chooses to do that.

Additionally, Tope has specified match[0] which isn't what we want, you can enable the user to specify the index they want to access in the results (e.g., 0, 1, etc.). After completing the code, don't forget to share your repository link in the comments section for feedback.

# Print the matched line
for match in matches:
  # Extract and print all groups in the match
  # print(type(match))
  if isinstance(match, tuple):
     print(match[0])
  elif isinstance(match, list):
     pass
  else:
     print(match)

Conclusion

In this project, you have gained valuable skills in text processing and pattern matching. We have come to the end of this series, moving forward you will write code to organize files.

If you have any questions, want to connect, or just fancy a chat, feel free to reach out to me on LinkedIn and Twitter.

Comparing CodiumAI PR-Agent to GitHub Copilot's solution for pull request

Praise Idowu — Mon, 18 Dec 2023 20:09:35 +0000

In the software development field, pull requests(PRs) play a crucial role in fostering collaboration. However, it’s not uncommon for us to overlook essential tasks before submitting a pull request. This oversight can result in rejection - whether due to unclear and lengthy descriptions or the omission of test cases for code updates. Code reviews, though vital, often consume a considerable amount of time. For developers, this can become a daunting experience, especially when they are maintaining larger projects with multiple contributors. But what if there was a way to speed up the pull request process? In this article, we will compare two tools that have the potential to speed up pull request processes. We will explore the features and capabilities of both tools.

CodiumAI PR Agent

CodiumAI PR-Agent is an AI tool that automates the PR review process. It can track your changeset and provides comprehensive reviews before you create a pull request.

This tool can be integrated into your code editor and git provider(GitHub, GitLab, etc.) environment.

As a developer, this tool is valuable when creating a PR. It helps communicate the changes made to other developers and ensures that updates and test cases are not brittle.

As a maintainer, you can use this tool to review changes and provide feedback before merging them into the codebase.

Usage

To start using CodiumAI PR-Agent. You can install it on your IDE or initiate it on GitHub by using the @CodiumAI-Agent command. If you are the one reviewing the PR you might want to use it on your git provider and if you are the one making a PR you might want to use it on your IDE.
To install it on your IDE or git provider, click here.
Now that you are done installing it, let us discuss its features.

PR-Agent Features

The PR-Agent offers a range of advanced features, designed to elevate your pull request process. PR-Agent supports a variety of commands. You can check out an example demo here.

/describe

With this command, PR-Agent retrieves the title, type(label), description, and main files walkthrough of the changeset ensuring that the essential details are captured accurately.

/ask

PR-Agent allows you to ask questions related to the changeset in your code.

/review

PR-Agent conducts a comprehensive review of the changeset, including code quality, potential bugs, and improvement suggestions. It ensures that your changeset is polished before submission.

/improve

PR-Agent provides code improvements focused on the changeset, contributing to overall code quality.

/add_doc

When invoked, this command automatically creates a docstring. This enhances the readability of your codebase and is valuable for anyone working with or contributing to the project.

In addition to these features, PR-Agent offers:

IDE integration: Seamlessly incorporate PR-Agent into your integrated development environment(IDE) such as (Vs Code, IntelliJ, WebStorm, CLion, JetBrains, Pycharm, etc).
Support multiple git providers such as (GitHub, Gitlab, Bitbucket, CodeCommit).
Support for all major programming languages.
Multiple ways to use the tool(CLI, GitHub Action, GitHub App, Docker, etc).
Multiple models (GPT-4, GPT-3.5, Anthropic, Cohere, Llama2). To learn more, click here.

GitHub Copilot

GitHub Copilot is an AI pair programmer that simplifies the process of code writing, making it faster and more efficient. It offers a range of other capabilities. For this article, our focus will be on its pull request (PR) solution. As of writing this article, GitHub PR is still on the waitlist. Here are some of its features.

GitHub Copilot PR Features

Suggestions for your pull request description.
Identification of PR changes lacking tests, with automated suggestions for test creation.
Real-time generation of text suggestions as you type.
Issue resolution, code suggestion generation, and initiation of new pull requests.
PR completion and repair functionalities
AI-powered review and responses.

GitHub Copilot PR features from GithubNext.

Potential Limitations of AI-PR Agents: CodiumAI PR-Agent and GitHub Copilot PR

In exploring the potential capabilities of these tools, it’s important to know that these tools, just like every AI come with their drawbacks.

For instance, the automated suggestions may not always align with project requirements leading to inaccuracies in the generated code.
The feedback might be inaccurate emphasizing the need for additional prompts to ensure precise feedback.
It is still under development signifying ongoing refinement and improvement.

Comparison between CodiumAI PR-Agent and Github Copilot PR

Repository Accessibility

CodiumAI PR-Agent is open-source, allowing public access, while GitHub Copilot PR resides within a private repository.

Cost

CodiumAI PR is free to use for individual developers but there are paid plans that offer more features. In contrast, GitHub Copilot PR requires a paid subscription.

Platform Support

CodiumAI PR supports all Git platforms while GitHub Copilot PR is exclusive to GitHub.

Availability

CodiumAI PR is available for use right now. On the other hand, GitHub Copilot PR is presently on a waitlist.

Command Support

CodiumAI PR supports a variety of commands as we have seen earlier and it will support more commands in the future, whereas GitHub Copilot PR primarily supports one command.

Large Language Model

CodiumAI PR uses multiple models while GitHub Copilot PR is powered by the OpenAI GPT-4 model.

IDE Support

CodiumAI PR can be integrated into your IDE such as (Vs Code, JetBrains IDE's, etc). In contrast, GitHub Copilot PR can be integrated into Vs Code, Visual Studio, Neovim, and JetBrains IDEs.

CodiumAI PR-Agent Git Solution

Collaboration: Aims to improve collaboration by speeding up the PR process.
Changelog Updates: Assists in updating changelogs with relevant information.
Concise title and description: Enables contributors to write concise and meaningful descriptions.
Commit message assistance: Generates meaningful commit messages.
Code quality evaluation and improvement: Analyzes code for quality, potential bugs, and improvement suggestions.
Q&A: Addresses contributor's questions related to the changeset.

Conclusion

In summary, both CodiumAI PR-Agent and GitHub Copilot PR present valuable PR solutions to simplify and improve the pull request process. The choice between these tools depends on specific project requirements and preferences.

What sets CodiumAI PR-Agent apart is not just its features but also its commitment to openness and collaboration. Being an open-source solution, it enables developers globally to contribute, inspect the source code, and collectively improve the tool. This transparency not only builds trust but also fosters a community-driven approach, ensuring continuous innovation.

Multi Clipboard

Praise Idowu — Fri, 15 Dec 2023 21:22:41 +0000

Project: Multi Clipboard

Welcome to the second project in this series. You will be building a functional Multiclipboard. Before you begin, let's talk about what a clipboard does.

A clipboard helps you copy and paste, but once you make another copy, it erases the last copy. This is where a Multiclipboard comes into play. It helps you store text with a certain keyword and access as many texts as possible making it possible for you to retrieve a particular text.

To learn more about the project, check out this repository.

Prerequisites

Part 1 of the series
Optionally, Python 3.9 or an earlier version.

Now that you have gone through the README, let's proceed. In this project, you will find exercises at the end of the project, which can involve fixing a bug or organizing the functions. Be sure to check the project files for reference.

Writing Code

Step 1: Create a file called mcb.py.

Step 2: In this step, we will take a different approach. We want to define the functions and their respective command line arguments.

You can see that we have defined three functions:

save_keyword should take a keyword and its content as arguments.
load_text should take a keyword as an argument and load its content.
list_keywords() does not require any arguments; it simply displays all the keywords.

This approach will help you structure your code effectively.

# save_keyword(keyword, content), load_text(keyword), list_keywords()
# Usage: 
# py mcb.py save <keyword> - Saves clipboard to keyword.
# py mcb.py <keyword> - Loads keyword to clipboard.
# py mcb.py list - Loads all keywords to the clipboard.
# py mcb.py clear - clears all keywords

Step 3: The next step is to decide how to save the keyword and its content. You have three options to choose from, although the README suggests using shelve. Let's briefly explore your options:

Dictionary: Using a dictionary allows you to store data during program execution, but it won't persist data after closing the program.
Save to a File: This approach involves saving the dictionary to a file, allowing you to read and write data to and from the file.
Shelve: Shelve provides a dictionary-like behavior, but it is different in that it acts as a persistent, on-disk storage system. Data saved using shelve remains accessible even after you close the program, making it a suitable choice for this project. You can think of it as a way to store data for the long term.

Step 4: Import the Necessary Modules
sys: allows you to interact with the command line.

import pyperclip, shelve, sys

Step 5: Create Functions
You have now created five functions, two additions to the ones defined earlier.
Let's look at these additions:

delete_keyword takes a keyword as input and deletes it along with its associated contents.
The run function is where the program's logic is written.

def save_keyword_with_content(keyword, content):
    pass

def list_keywords():
    pass

def load_content(keyword):
    pass

def delete_keyword(keyword):
    pass

def run():
    pass  

if __name__ == '__main__':
    run()

It's time to dive in and start putting these functions to work.

Step 6: save_keyword_with_content, list_keywords, load_content, delete_keyword

In this step, you have defined the save_keyword_with_content function. It takes a keyword and content as arguments and uses the shelve module to create or open a shelf with the specified prefix. It then stores the content under the given keyword on the shelf.

prefix = 'mcb'

def save_keyword_with_content(keyword, content):
     # Open and close a shelf file
    with shelve.open(prefix) as mcb_shelf:
        mcb_shelf[keyword] = content

In the list_keywords function, you want to return a list of all the keywords (keys) stored in the shelve, but you need to return this list as a string. Here's the breakdown:

mcb_shelf.keys(): This part retrieves all the keys (keywords) from the mcb_shelf object. These keys are initially in a format that is not a string.
list(mcb_shelf.keys()): You convert the keys into a list format using list(). Now, you have a list of the keywords.
str(list(mcb_shelf.keys())): Lastly, you use str() to convert this list of bytes objects into a string format. This is necessary because your function is expected to return a string. By converting the list to a string, you ensure it can be returned in a human-readable format, as byte objects are not easily human-readable.

def list_keywords():
    # Open and close a shelf file
    with shelve.open(prefix) as mcb_shelf:
        # return keys list
        return str(list(mcb_shelf.keys()))

You have created the load_content function. It opens the shelf using the prefix and retrieves the content associated with the provided keyword from the shelf.

def load_content(keyword):
    with shelve.open(prefix) as mcb_shelf:
        return mcb_shelf[keyword]

In this step, you have defined the delete_keyword function. It opens the shelf with the prefix and checks if the keyword exists on the shelf. If it does, it deletes the keyword and its associated content. If the keyword is not found, it prints a message and exits the program.

def delete_keyword(keyword):
    with shelve.open(prefix) as mcb_shelf: 
        if keyword in mcb_shelf.keys():
            del mcb_shelf[keyword]
        else:
            print(f'{keyword} not found. It must have been deleted.')
            sys.exit()

You must have noticed something in these functions. What is it you noticed?

These functions all repeat the same code for opening the shelf. This repetition is a violation of the DRY (Don't Repeat Yourself) principle, which suggests that code should be reused or abstracted to avoid redundancy. We will address this issue later in your project to make the code more efficient and maintainable. Let's move on for now.

Step 7: You define the run function, which handles different command-line arguments to interact with your Multi Clipboard.

def run():
    if len(sys.argv) == 3:
        # save clipboard content
        if sys.argv[1].lower() == 'save':
            keyword = sys.argv[2]
            content = pyperclip.paste()
            save_keyword_with_content(keyword, content)
        # delete keyword
        elif sys.argv[1].lower() == 'delete':  
            keyword = sys.argv[2]
            delete_keyword(keyword)
            print(f'{keyword} deleted with contents.')
            print(list_keywords())

    # list keywords and load content
    elif len(sys.argv) == 2:
        keywords = list_keywords()
        if sys.argv[1].lower() == 'list':
            pyperclip.copy(keywords)
            print(keywords)
        elif sys.argv[1] in keywords:
            keyword = sys.argv[1]
            content = load_content(keyword)
            pyperclip.copy(content)
            print(content)

    else:
        print(f'''Usage: python your_script.py save <keyword>
                python your_script.py <keyword>
                python your_script.py list''')

To test it, you should run your script in a terminal or command prompt, passing the appropriate arguments.

Here is how you can test it:

Open a terminal or command prompt.
Test the different functionalities with the following commands:

To save content to a keyword:
python your_script.py save my keyword.
To delete a keyword:
python your_script.py delete mykeyword
To list all keywords:
python your_script.py list
To load content from a specific keyword:
python your_script.py mykeyword

Replace mykeyword with an actual keyword, and the script should perform the corresponding action as defined in the run function.

Exercise 1

Create a function called clear_keywords without any parameters. This function will clear all keywords stored in the mcb_shelf. Additionally, handle errors properly so that if the shelf is empty, it responds with a clear message instead of generating error messages. You can run this function by executing py mcb.py clear in the command line.

Exercise 2

You will realize this code works well but as you write more code you want to write clean and efficient code, minimizing repetition.
In this exercise, the goal is to address the redundancy of opening the shelve function in multiple parts of your code.

Once you are done, the solution can be found in fix_repitition.py in the project directory.

Exercise 3

In this exercise, we focus on improving the provided code by addressing issues related to repetition.

if len(sys.argv) == 3:
        # save clipboard content
        if sys.argv[1].lower() == 'save':
            keyword = sys.argv[2]
            content = pyperclip.paste()
            save_keyword_with_content(keyword, content)
        # delete keyword
        elif sys.argv[1].lower() == 'delete':  
            keyword = sys.argv[2]
            delete_keyword(keyword)
            print(f'{keyword} deleted with contents.')
            print(list_keywords())

To improve the code, follow these steps:

Define the keyword variable in the outer loop, allowing both the save and delete sections to access it.

Exercise 4

After making the code structure more robust, we have identified another issue with the functionality when saving text.

Run this on the command line: py mcb.py save text1. Copy several different texts and run them again. What did you notice?

Currently, it overrides the previous content, which may not be desirable. In this exercise, we aim to address this issue.

Step 1: To prevent content from being overridden when saving text, you can use an if-else statement to check if the key already exists. If it exists, return a warning message; otherwise, save the new content.

Now, the program works as expected. What if you want to ask the user for confirmation? I know right now you are thinking, well I am the only user of my program. You want to think of a real-world scenario where you have several users.

Step 2: If the key already exists and you want to provide the user with an option to replace it, you can add more code to ask the user if they would like to replace the existing content. This step involves integrating user input and conditional logic to determine whether to replace the content.

These improvements ensure that the Multi Clipboard functions more naturally, avoiding accidental content loss and allowing user interaction when necessary.

Once you are done, for a detailed solution, you can refer to the "fix_repitition2.py" file provided in the project directory.

Exercise 5

There is one more issue we need to address to make our program more robust.

When users want to delete an item, it's common practice to ask for their confirmation to avoid accidental deletions. However, there is a problem with the current code, and we need to identify and correct it.

To resolve this issue, carefully review the code to find any errors that might be causing the problem. Once identified, make the necessary adjustments to ensure that the deletion confirmation process functions correctly.

For a detailed solution and to compare your answer, please refer to the "mcb2.py" file provided in your project directory.

def run():
    if len(sys.argv) == 3:
        # save clipboard content
        if sys.argv[1].lower() == 'save':
            keyword = sys.argv[2]
            content = pyperclip.paste()
            save_keyword_with_content(keyword, content)
        # delete keyword
        elif sys.argv[1].lower() == 'delete':  #TODO: CTA: Are you sure you want to
            keyword = sys.argv[2]
            while True:
                user_input = input(are you sure you want to delete {keyword}: ').lower()
                if user_input == 'yes' or 'y':  # fix this issue not working
                    delete_keyword(keyword)
                    print(f'{keyword} deleted with contents.')
                    print(list_keywords())
                    sys.exit()
                elif user_input == 'no' or 'n':  #fix:not working
                    print('Deletion abolished')
                    sys.exit()

Exercise 6

In this exercise, you will create a dictionary and practice writing it to a file to persist the data. This exercise provides an opportunity to hone your skills in writing data into files.

To complete this exercise, follow these steps:

Instead of using shelve, create an empty dictionary for storage. Store the keywords as the key and the content as the value.
Each time you create a new keyword, you want to store it and its content in a file to persist the data. Are you using 'w' or 'a'? What encoding will you use? Answer all these questions in your code editor.

When you are done implementing these steps, test your code and submit your repository link in the comments section.

Conclusion

We have reached the end of this project. It is important to remember that programming is an ever-evolving journey. If you believe some areas could be further improved, don't hesitate to revisit the code. In the world of programming, inspiration can strike at any moment, even days or months later.

Throughout this project, you utilized various Python modules. You used the pyperclip module for text copying and pasting, employed the shelve module for data persistence, and leveraged the sys module for efficient command-line interactions. You have not only achieved functional automation but also had the chance to explore problem-solving.

As you continue on your programming journey, keep in mind that each project is a stepping stone, contributing to your growth as a developer. Embrace the process, keep coding, stay curious, and enjoy problem-solving.

If you have any questions, want to connect, or just fancy a chat, feel free to reach out to me on LinkedIn and Twitter.

Generating Random Quiz Files

Praise Idowu — Thu, 07 Dec 2023 12:51:47 +0000

Welcome to the first project in this tutorial series. In this project, you will learn how to read and write to files while creating random quiz files. You will broaden your knowledge of the random module by using it to shuffle questions and answers. By the end of this project, you will have automated the creation of random quiz files.

What you will gain from this project:

You will learn how to use the os module for file operations.
You will work with the random module to enhance your Python skills.

Prerequisites

To get the most out of this project, you should already be familiar with "Automate the Boring Stuff: 'Python Programming Basics' and 'Reading and Writing to Files'".
Willingness to learn and tackle more complex exercises.

How to follow this project:

For clarity and to avoid confusion, especially with nested loops:

Open the project file in a separate tab and always refer back to it.
The “...” was used to indicate that the code has been truncated, just as you would do in your code editor when dealing with long lines of code.
Avoid copying and pasting from here; instead, use the project file.
It is often better to write small sections of code and test it.

Now, let me walk you through the steps to generate random quiz files. To access the project file, click here.

Step 1: Write Comments.

def generate_random_quiz_files():
    # Create a directory to store quiz and answer key files  
    # Generate 35 quiz files.
    # write out the header for the quiz        
    # Shuffle the order of the states         
    # Loop through all 50 states, making a question for each         
    # Create a list of answer options            
    # Write the question and answer options in the quiz file            
    # Write the correct answer to the answer file
    pass

if __name__ == '__main__':
    generate_random_quiz_files()

Step 2: Create a file and name it dict.py.
This file contains the dictionary that stores the states and capitals. To access the dict file, click here. Below is a sample of what it looks like in the repo.

capitals = {'Alabama': 'Montgomery', 'Alaska': 'Juneau', 'Arizona': 'Phoenix', 'Arkansas': 'Little Rock', 'California': 'Sacramento', 'Colorado': 'Denver',...}

Step 3: Import the Required Modules.
You will import the random module, the os module, and the dictionary.

import random, os
from dict import capitals

Step 4: Create a directory and subdirectories to store quiz and answer files.
To ensure the program functions smoothly, start by checking if the path exists. If it doesn't, proceed to create the 'quizzes' directory. Note that we are using relative paths. If you prefer to use absolute paths, you can call the os.path.abspath() function.
After creating the directory, to create a directory tree, you will use the os.makedirs function.

def generate_random_quiz_files():
    # Create a directory to store quiz and answer files
    if not os.path.exists('quizzes'):
        os.mkdir('quizzes/')
    if not os.path.exists('quizzes/questions):
        os.makedirs('quizzes/questions)
    if not os.path.exists('quizzes/answers'):
        os.makedirs('quizzes/answers')

Run the program, and only proceed to the next step if it works correctly. You should achieve a directory structure as shown below.

Step 5: Generate 35 quiz files.
Remember: The range function starts from 0 if no starting point is indicated and loops up to the endpoint, excluding the endpoint. For example, range(35) starts from 0 and ends at 34, resulting in 35 files.
Next, you will generate the question_filename. Use the os.path.join() function and f-strings to create the filename.
Lastly, test the program to ensure it functions correctly. The quickest way to do this is by using the print() statement. If everything works well, you can proceed to the next step; otherwise, troubleshoot.

def generate_random_quiz_files():
    # Create a directory to store quiz and answer key files
    #...

    # Generate 35 quiz files.
    for quizNum in range(35):
        # Create the quiz and answer key files.
        question_filename = os.path.join('quizzes', 'questions', f'quiz_{quizNum + 1}.txt')
        answer_filename = os.path.join('quizzes', 'answers', f'quiz_{quizNum + 1}_answer.txt')
        print(question_filename)
        print(answer_filename)

Step 6: Write the header for the quiz.
First, comment out the print statement for clarity.
Next, open the file in write mode. You use write mode to overwrite any previous generation and ensure a fresh start. The os.path.exists() check you implemented earlier helps handle pre-existing folders. You also add an encoding to prevent encoding error issues, then proceed to write to the file. Ensure that you run the program to confirm it works as expected.
Here's the updated code:

def generate_random_quiz_files():
    # Create a directory to store quiz and answer key files
    #...
    # Generate 35 quiz files.
    #...

        with open(question_filename, 'w', encoding='utf-8') as question_file, \
            open(answer_filename, 'w', encoding='utf-8') as answer_file:
                # write out the header for the quiz
                question_file.write('Name:\n\nDate:\n\nPeriod:\n\n')
                question_file.write(f'{" " * 20}State Capitals Quiz - Student {quizNum + 1}\n\n')
                answer_file.write(f'US State Capitals Answers - Student {quizNum + 1}\n\n')

Step 7: Shuffle the order of the states
First, retrieve the keys, which represent the states. Store them in a variable called states, and convert this into a list because we will need a list in the next step.
Next, shuffle the list. It is important to note that the shuffle method modifies the original list instead of creating a new one. Test it to ensure it works as expected. Try storing the shuffled list in a variable and observe the results. This will clarify the behavior of the shuffle operation.

def generate_random_quiz_files():
    # Create a directory to store quiz and answer key files
    #...
    # Generate 35 quiz files.
    #...

        with open(question_filename, 'w', encoding='utf-8') as question_file, \
            open(answer_filename, 'w', encoding='utf-8') as answer_file:
                # write out the header for the quiz
                #...

                # Shuffle the order of the states
                states = list(capitals.keys())
                # print(states)
                random.shuffle(states)  # it does not return a new list instead it changes d original list
                print(states)

Step 8: Loop through all 50 states, making a question for each.
Run your code to see the results. Comment out the print statement before moving on to the next step.

def generate_random_quiz_files():
    # Create a directory to store quiz and answer key files
    #...
    # Generate 35 quiz files.
    #...

        with open(question_filename, 'w', encoding='utf-8') as question_file, \
            open(answer_filename, 'w', encoding='utf-8') as answer_file:
                # write out the header for the quiz
                #...

                # Shuffle the order of the states
                #...


                # Loop through all 50 states, making a question for each
                for question_num in range(50):  # it generates 1750 questions
                    state = states[question_num]  # get questions 1-50 from the list
                    correct_answer = capitals[state]  # get the capital of the state from the capitals dictionary
                    print(state)
                    print(correct_answer)

Step 9: Create a list of answer options.

def generate_random_quiz_files():
    # Create a directory to store quiz and answer key files
    #...
    # Generate 35 quiz files.
    #...

        with open(question_filename, 'w', encoding='utf-8') as question_file, \
            open(answer_filename, 'w', encoding='utf-8') as answer_file:
                # write out the header for the quiz
                #...

                # Shuffle the order of the states
                #...


                # Loop through all 50 states, making a question for each
                for question_num in range(50):  # it generates 1750 questions
                    #...

                    # Create a list of answer options
                    answer_options = list(capitals.values())
                    del answer_options[answer_options.index(correct_answer)]  # delete the correct answer from d anaswer options
                    wrong_answers = random.sample(answer_options, 3)
                    answer_options = wrong_answers + [correct_answer]  # conactenate list with list
                    print(answer_options)
                    random.shuffle(answer_options)
                    print(answer_options)

Step 10: Write the question and answer options.
In this step, you will write the questions and answer options to the quiz file.

Step 11: Write the correct answer to the answer key file.
This is the last step and you can refer back to the code for clarity. Here is the completed code:

import random, os
from dict import capitals


def generate_random_quiz_files():
    # Create a directory to store quiz and answer key files
    if not os.path.exists('quizzes'):
        os.mkdir('quizzes/')
    if not os.path.exists('quizzes/questions'):
        os.makedirs('quizzes/questions')
    if not os.path.exists('quizzes/answers'):
        os.makedirs('quizzes/answers')

    # Generate 35 quiz files.
    for quizNum in range(35):
        # Create the quiz and answer key files.
        question_filename = os.path.join('quizzes', 'questions', f'quiz_{quizNum + 1}.txt')
        answer_filename = os.path.join('quizzes', 'answers', f'quiz_{quizNum + 1}_answer.txt')
        # print(question_file)
        # print(answer_file)

        with open(question_filename, 'w', encoding='utf-8') as question_file, \
            open(answer_filename, 'w', encoding='utf-8') as answer_file:
                # write out the header for the quiz
                question_file.write('Name:\n\nDate:\n\nPeriod:\n\n')
                question_file.write(f'{" " * 20}State Capitals Quiz - Student {quizNum + 1}\n\n')
                answer_file.write(f'US State Capitals Answers - Student {quizNum + 1}\n\n')

                # Shuffle the order of the states
                states = list(capitals.keys())
                # print(states)
                random.shuffle(states)  # it does not return a new list instead it changes d original list
                # print(states)


                # Loop through all 50 states, making a question for each
                for question_num in range(50):  # it generates 1750 questions
                    state = states[question_num]  # get questions 1-50 from the list
                    correct_answer = capitals[state]  # get the capital of the state from the capitals dictionary
                    # print(state)
                    # print(correct_answer)

                    # Create a list of answer options
                    answer_options = list(capitals.values())
                    del answer_options[answer_options.index(correct_answer)]  # delete the correct answer from d anaswer options
                    wrong_answers = random.sample(answer_options, 3)
                    answer_options = wrong_answers + [correct_answer]  # conactenate list with list
                    # print(answer_options)
                    random.shuffle(answer_options)
                    # print(answer_options)

                    # Write the question and answer options to the quiz file
                    question_file.write(f'{question_num + 1}. What is the capital of {state}?\n')
                    for index, option in enumerate(answer_options):
                        question_file.write(f'{"ABCD"[index]}. {option}\n')
                    question_file.write('\n')

                    # Write the correct answer to the answer key file
                    answer_file.write(f'{question_num + 1}. {"ABCD"[answer_options.index(correct_answer)]}\n')


if __name__ == '__main__':
    generate_random_quiz_files()

It's been a great journey of learning and practicing. Don’t worry if you are confused, everyone does. Now it is time for some practice.

Exercise

Your task is to write a program that converts the dictionary to JSON format. After that, you will modify the code to use the JSON file instead.
You will notice that there is a lot of nesting in the code which makes it less readable. Your task is to create smaller functions to get rid of the nesting.

Conclusion

By now, you should have completed the exercises and gained practical experience. Remember, getting stuck is a normal part of the learning process. In this project, you learned how to generate random quiz files using the OS and random modules. You also implemented complex loops, used range functions, and mastered writing data to a file.

This project has equipped you with essential skills that you can apply in various Python programming tasks. Continue to explore, practice, and refine your coding abilities.

If you have any questions, want to connect, or just fancy a chat, feel free to reach out to me on LinkedIn and Twitter.

How to create a regex version of strip()

Praise Idowu — Thu, 30 Nov 2023 20:35:36 +0000

Project 1: Practice Projects

Welcome to the third project in this tutorial series. In this project, you will create a Regex version of strip(). As usual, you will have examples and exercises to work on. Once you are done, you can compare your solutions by clicking here.

Exercise

Project A: Strong Password Detection

This project is available in the project's README. Once you have completed it, return here to continue.

Welcome back; now it's time to tackle Project B.
In this project, you will create a Regex Version of strip().

Prerequisites

Part 2 in the series

Before starting this project, it's essential to have a good understanding of how strip() works. Some developers use it frequently, while others seldom use it. Experiment with it to gain a clear idea of its functionality.

Write Code

Now that you understand it, let us move on to writing code.

Step 1: Create a Function
In this step, define a function called regex_strip with two parameters: input_string and chars_to_remove, which has a default value of None. This allows you to provide characters to remove if you wish, but if none are specified, it defaults to None.

Step 2: Check for chars_to_remove Being None
Here, you check if the chars_to_remove variable is None. If it is, you create a regex pattern that matches leading and trailing whitespace (similar to how strip() works by default). This step ensures that if no characters are specified for removal, the function behaves like the standard strip() method.

Step 3: Create a Pattern
You might notice that we create a pattern without using re.compile(). The reason for this is that since it is a one time use, the performance gain is negligible. To learn more, click here.

Step 4: Execute the Else Statement
In this step, it checks whether chars_to_remove is specified (not None). If it is, it executes the code inside the else block.

Step 5: Substitute the Pattern
Finally, you use re.sub() to substitute any matching patterns with an empty string, effectively removing them from the input_string.
Here's the complete code:

import re

def regex_strip(input_string, chars_to_remove=None):
    if chars_to_remove is None:
        # If chars_to_remove is not specified, remove leading and trailing whitespace
        pattern = r'^\s+|\s+$'

    else:
        # Escape characters that might be interpreted as regex metacharacters(.*?^$+)
        chars_to_remove = re.escape(chars_to_remove)
        # Create a pattern that matches characters specified in the second argument
        pattern = f'[{chars_to_remove}]+'  #['hello']+ 1 or more so it picks any matching pattern in the bracket

    return re.sub(pattern, '', input_string)

if __name__ == '__main__':
    input_string = input('Input a string: ')
    chars = input('Input a character to escape: ')

    # TEST
    # input_string = "ABCDEFHello, World!ABCDEF"
    # chars = "ABCDEF"

    # input_string = "   Hello, World!   "

    print(regex_strip(input_string, chars))

The code provides you with a tool to strip specific characters from a given string using regular expressions. Feel free to experiment with different input strings and characters to remove to see how it works.

Exercise

Here are some additional exercises to further practice your regex skills:

Parsing CSV Data: Write a regex pattern to extract data from a CSV (Comma-Separated Values) file. Test it on a sample CSV file with different data.
Extracting Hashtags from Social Media Posts: Create a regex pattern to extract hashtags from social media posts, such as #regex or #PythonProgramming.
Parsing Log Files: Develop a regex pattern to extract specific information from log files, like timestamps, error codes, and messages.
Validating ISBNs (International Standard Book Numbers): Write a regex pattern to validate ISBNs with different formats (e.g., ISBN-10 or ISBN-13). These exercises will help you apply your regex skills to real-world scenarios and expand your knowledge.

Conclusion

In this project, you created a Regex version of strip(), building upon our previous skills. Keep practicing, experimenting, and applying regex patterns in various contexts to become more proficient.

If you have any questions, want to connect, or just fancy a chat, feel free to reach out to me on LinkedIn and Twitter.

Find common typos between words

Praise Idowu — Thu, 23 Nov 2023 19:00:28 +0000

Project 1: Ideas for Similar Programs

Welcome to the second project in this tutorial series. In this project, you are about to tackle four exciting problems. As always, you will be provided with examples and exercises to work on.

Your goal in this project is to write more complex regular expressions to search, substitute, and manipulate text characters in strings.

For access to the project README, click here.

Prerequisites

Part 1 in the series

Before you start this project, you should roll up your sleeves and get some hands-on coding experience. Project A serves as a great warm-up, and it's quite similar to what we tackled in the previous project. Once you have completed it, click here to compare your solution. You will find all the necessary text files here.

Now that we have that clear, let us work on this.

Project D: Find common typos such as multiple spaces between words, accidentally accidentally repeated words, or multiple exclamation marks at the end of sentences. Those are annoying!!

Step 1: Write Comments
First, define a function called remove_typos_in_word().
Second, write comments to explain each step.
Third, call the function.

def remove_typos_in_word():
    # get the text off the clipboard

    # Define a regex pattern for multiple spaces between words
    # substitute multiple spaces with just a space

    # Define a regex pattern for accidentally repeated words
    # substitute it with just one word

    # Define a regex pattern for multiple exclamation marks at the end of sentences
    # substitute it with one exclamation mark
    # return the replaced text
    pass


if __name__ == '__main__':
    remove_typos_in_word()

Step 2: Import Necessary Modules
You already used these modules in the previous project, If you need a quick reminder, click here.

import re, pyperclip

Step 3: Paste Text from Clipboard

def remove_typos_in_word():
    copied_text = pyperclip.paste()

Step 4: Create a Regex Pattern for Multiple Spaces Between Words

# Define a regex pattern for multiple spaces between words
multiple_spaces_pattern = re.compile(r'\s{2,}')

Step 5: Substitute Multiple Spaces with a Single Space and Store It in a replaced_text Variable.
Note: This regex can be improved. It seems to also remove new lines.

To understand how re.sub() works. Just hover your mouse at the function, and you will see the parameter it takes. It takes in a pattern, a replacement, and a string. The others are optional.

Run your code to ensure that it works properly.

replaced_text = re.sub(multiple_spaces_pattern, ' ', copied_text)
print(replaced_text)

Step 6: Create Regex Patterns for the Remaining Two
You might notice that we are not using the copied_text variable anymore but rather accessing the replaced_text. Can you guess why?

The reason for this is that we want to continue working on the corrected text to apply additional regex patterns. This way, each correction doesn't interfere with the next one.

    # Define a regex pattern for accidentally repeated words
    repeated_words_pattern = re.compile(r'(\b\w+\b)(\s+\1)+')
    replaced_text = re.sub(repeated_words_pattern, r'\1', replaced_text)
    print(replaced_text)

    # Define a regex pattern for multiple exclamation marks at the end of sentences
    multiple_exclamations_pattern = re.compile(r'!{2,}')
    replaced_text = re.sub(multiple_exclamations_pattern, '!', replaced_text)
    print(replaced_text)

Step 7: The End Result
This is the final form of the code. You return the replaced_text variable, which now contains all the corrections. To access the result, you call the function and assign the returned value to the replaced_text variable. Then, you copy it to the clipboard and print it in the terminal.

import re, pyperclip

def remove_typos_in_word():
    copied_text = pyperclip.paste()

    # Define a regex pattern for multiple spaces between words
    multiple_spaces_pattern = re.compile(r'\s{2,}')
    # multiple_spaces_pattern = re.compile(r'(?<!\n)\s{2,}')
    replaced_text = re.sub(multiple_spaces_pattern, ' ', copied_text)
    # print(replaced_text)

    # Define a regex pattern for accidentally repeated words
    repeated_words_pattern = re.compile(r'(\b\w+\b)(\s+\1)+')
    replaced_text = re.sub(repeated_words_pattern, r'\1', replaced_text)
    # print(replaced_text)

    # Define a regex pattern for multiple exclamation marks at the end of sentences
    multiple_exclamations_pattern = re.compile(r'!{2,}')
    replaced_text = re.sub(multiple_exclamations_pattern, '!', replaced_text)
    # print(replaced_text)
    return replaced_text

if __name__ == '__main__':
    replaced_text = remove_typos_in_word()
    pyperclip.copy(replaced_text)
    print('Copied to clipboard.')
    print(replaced_text)

Exercise

Now, it's your turn to tackle parts B and C in the "Ideas for Similar Programs." Once you have completed them, you can compare your solutions by clicking here.

Note: It's often more helpful to attempt the exercise before seeking a solution. Jumping straight to a solution won't help you learn. Best of luck.

Conclusion

In this project, you created more complex regex patterns and implemented a search and replace functionality. Think about all the times you have encountered search and replace functionality; it's often powered by regex. Great work, and keep on learning.

If you have any questions, want to connect, or just fancy a chat, feel free to reach out to me on LinkedIn and Twitter.