Today, I’m taking the to-do list application to the next level by adding the ability to mark tasks as complete. Let’s dive into the code and explore the new concepts.

Updated Code

todos = []
while True:
    user_action = input("Type add, show, edit, complete, or exit:")
    user_action = user_action.strip()
    match user_action:
        case 'add':
            todo = input("Enter a todo: ")
            todos.append(todo)
        case 'show':
            for index, item in enumerate(todos):
                row = f"{index + 1} {item}"
                print(row)
        case 'edit':
            number = int(input("Number of the todo to edit: "))
            number = number - 1
            new_todo = input("Enter new item: ")
            todos[number] = new_todo
        case 'complete':
            number = int(input("Number of the todo to complete:"))
            todos.pop(number - 1)
        case 'exit':
            break
print ("Bye!")

Enumeration with enumerate()

The enumerate() function is incredibly useful when you need to keep track of both the index and the value while iterating over a list. It creates an object with the structure [(index, item), (index, item), ...], allowing you to iterate using two variables.

In our code:

for index, item in enumerate(todos):
    row = f"{index + 1} {item}"
    print(row)

Here, enumerate(todos) generates pairs of indices and items from the todos list. This makes it easy to display each to-do item with its corresponding number.

Formatted Strings with f-strings

f-strings (formatted string literals) are a powerful feature in Python that allow you to embed expressions inside string literals, using curly braces {}. They are specialized to replace the {variable} part with the value of the variable and can also include expressions within the braces.

In our code:

row = f"{index + 1} {item}"

This line creates a formatted string where index + 1 is the task number, and item is the to-do item itself. The use of f-strings makes the code more readable and concise.

Removing Completed Tasks

I’ve added a new feature to mark tasks as complete by removing them from the list. This is achieved using the pop() method:

todos.pop(number - 1)

The pop() method removes an item at a specified index and returns it. By subtracting 1 from the user’s input, we correctly target the task number.

Practical Implications

Understanding how to use enumerate() and f-strings is essential for knowledge workers who need to create dynamic and user-friendly applications. These concepts allow you to handle lists more effectively, generate readable output, and manage user interactions seamlessly.

Learning Journey

Today’s learning experience was both enlightening and practical. I found that using enumerate() made it much easier to keep track of list indices while iterating. F-strings simplified the process of creating formatted strings, making the code cleaner and more efficient.

One key takeaway is the versatility of f-strings in handling complex string formatting tasks. This knowledge will be invaluable in future projects where dynamic string generation is required.

Conclusion

As I wrap up Day 5, I’m excited about the new functionality I’ve added to our to-do list application. The ability to mark tasks as complete has made the application even more useful and interactive.

I encourage you to experiment with enumerate() and f-strings in your own projects. Share your experiences and challenges in the comments below—let’s learn together!

Stay tuned for more updates as I continue my journey into the world of Python programming!