Forem: Blackie

Python Day 13: Creating a Simple Todo App with Django

Blackie — Fri, 24 May 2024 12:36:25 +0000

Django is a powerful web framework that can be used to build web applications. In this article, we will walk through the process of creating a simple to-do list app using Django.

Step 1 Install Django: Firstly, let's install Django.

Open up the terminal and run the code below.

pip install django

Step 2: Create a new Django project: Once we've installed Django, we can create a new project by running the code below in the terminal.

django-admin startproject mytodo

This will create a new directory called mytodo that contains the files and directories for our project.

Step 3. Create a new Django app:
Next, we'll need to create a new Django app for our to-do list.

To do this, let's navigate to mytodo directory by running the command in our terminal.

cd mytodo

Next, run the code below to create our app.

python manage.py startapp todo

This will create a new directory called todo that contains the files and directories for our app.

Step 4. Define to-do list model: A model is a representation of a database table in Django. We'll need to define a model for our to-do list that includes fields for the task name and a boolean field to indicate whether the task is complete. To do this, let's open up the models.py file in the todo directory and add the following code:

from django.db import models

class TodoItem(models.Model):
    text = models.CharField(max_length=200)
    complete = models.BooleanField(default=False)

With code above we've created a new model called TodoItem with two fields: text and complete.

Step 5. Install the app: To use the todo app in our project, we'll need to add it to the INSTALLED_APPS list in the settings.py file in the mytodo directory. To do this, let's open up the settings.py file and add the following line to the INSTALLED_APPS list:

'todo.apps.TodoConfig',

This will tell Django to include the todo app in our project.

Step 6. Run migrations: Once we've defined our model, we'll need to create the corresponding database table. To do this, we can run migrations.

To run migrations, run the code below in the terminal.

python manage.py makemigrations todo

This will create a new migration file in the migrations directory in the todo app.

Then, let's run the code below to apply the migration and create the database table.

python manage.py migrate todo

Step 7. Create views: A view is a function that takes a web request and returns a web response. We'll need to create two views for our to-do list: one to display the list of tasks and another to handle the form submission for adding a new task. To do this, let's open up the views.py file in the todo directory and add the following code:

from django.shortcuts import render, redirect, get_object_or_404
from .models import TodoItem

def todo_list(request):
    items = TodoItem.objects.all()
    return render(request, 'todo/todo_list.html', {'items': items})

def add_item(request):
    if request.method == 'POST':
        text = request.POST['text']
        TodoItem.objects.create(text=text)
        return redirect('todo_list')
    else:
        return render(request, 'todo/add_item.html')

def toggle_complete(request, item_id):
    item = get_object_or_404(TodoItem, id=item_id)
    item.complete = not item.complete
    item.save()
    return redirect('todo_list')

def delete_item(request, item_id):
    item = get_object_or_404(TodoItem, id=item_id)
    item.delete()
    return redirect('todo_list')

This code defines four views: todo_list, add_item, toggle_complete, and delete_item.

Step 8. Create templates: A template is a file that defines the HTML structure of a web page.

We'll need to create two templates for our to-do list: one to display the list of tasks and another to handle the form submission for adding a new task. To do this, let's open up the todo directory and create a new directory called templates.

Inside the templates directory, let's create a new directory called todo. Inside the todo directory, let's create two new files: todo_list.html and add_item.html.

Hence, add the following code to todo_list.html:

<h1>My To-Do List</h1>

<form method="post" action="{% url 'add_item' %}">
    {% csrf_token %}
    <input type="text" name="text" placeholder="Add a new item">
    <button type="submit">Add</button>
</form>

<ul>
    {% for item in items %}
        <li>
            {{ item.text }}
            {% if item.complete %}
                (Completed)
            {% endif %}
            <form method="post" action="{% url 'toggle_complete' item.id %}">
                {% csrf_token %}
                <button type="submit">
                    {% if item.complete %}
                        Mark as Incomplete
                    {% else %}
                        Mark as Complete
                    {% endif %}
                </button>
            </form>
            <form method="post" action="{% url 'delete_item' item.id %}">
                {% csrf_token %}
                <button type="submit">Delete</button>
            </form>
        </li>
    {% endfor %}
</ul>

And add the following code to add_item.html:

<h1>Add a New To-Do Item</h1>

<form method="post">
    {% csrf_token %}
    <label for="text">Text:</label>
    <input type="text" name="text" id="text">
    <button type="submit">Add</button>
</form>

Step 9. Update URLs: Finally, we'll need to update our URLs to map to the views we've created. To do this, let's open up the urls.py file in the mytodo directory and add the following code:

from django.urls import path
from todo.views import todo_list, add_item, toggle_complete, delete_item

urlpatterns = [
    path('', todo_list, name='todo_list'),
    path('add/', add_item, name='add_item'),
    path('toggle_complete/<int:item_id>/', toggle_complete, name='toggle_complete'),
    path('delete/<int:item_id>/', delete_item, name='delete_item'),
]

This code maps the URLs to the views we've created.

And that's it! Now we have a working app. Run the code in the terminal.

python manage.py runserver

We can then access our app by navigating to http://127.0.0.1:8000/ in the web browser.

Python Day 12: Django or Flask

Blackie — Fri, 17 May 2024 20:22:13 +0000

Hey developers! 👩‍💻👨‍💻 It's Python Day 12 and we're talking about web frameworks. If you had to choose between Django and Flask for your next project, which one would you go with and why?

Python Day 11 | Mastering SQL: A Beginner's Guide to Database Management

Blackie — Fri, 10 May 2024 15:07:16 +0000

Section	Description
Introduction	Overview of the topic and purpose of the article
Database Key Terms	Explanation of important terms and concepts related to databases
SQL	Introduction to SQL and its basic syntax and commands
SQL Searches	Explanation of how to use SQL to search for and retrieve data from a database
Data Types	Overview of the different data types used in databases and how to work with them
Insert, update, delete	Explanation of how to use SQL to insert, update, and delete data in a database
Solutions	Common problems and solutions related to databases and SQL

Introduction

Imagine you have a large collection of books in your personal library. Each book has a title, author, and other information such as publication year, genre, and publisher. If you wanted to find a specific book, you would need to manually search through each book until you found the one you were looking for. This process can be time-consuming and inefficient.

Now, imagine that you had a database of your book collection. The database would be structured in a way that makes it easy to search and update. Each book would be represented as a row in a table, with each column representing a different piece of information about the book. You could search for a book by title, author, or any other criteria, and the database would quickly retrieve the information you need.

A database is a structured set of data. It is structured in tables that are easy to search and update. By organizing data into tables and making it easy to search and update, databases help businesses make informed decisions, improve efficiency, and save time and money.

Database Key Terms

A table holds a collection of records for a particular theme in rows and columns. Each row represents a single record or item, and each column represents a specific attribute or field.

Each record in the table needs a unique identifier. A primary key is used to give each record a unique code. A primary key can never be repeated. This ensures that each record in the table is unique. This is very important when dealing with thousands or even millions of records.

A flat file database is a database that contains a single table.

A relational database contains more than one table. The most common model for a database is a relational model. The data in the tables are linked using relationships. Relationships can be:

One to one
One to many
Many to many

In relational database, Data doesn’t need to be repeated and relationships can be made using the source table’s unique identifier. A primary key is unique to the original source of the data.

When you link to a source table’s primary key you use a foreign key. A foreign key can be repeated because it is a link back to the primary key in the source table.

SQL

SQL stands for Structured Query Language. It is a language used to communicate with a database. You can use SQL to manipulate databases and retrieve records.

SQL is widely used. It is a standard language that comes in many varieties. The most popular are MySQL and SQLite. For this tutorial you will be using SQLite.

SQL uses recognisable commands that are similar to the English language, making it easy for users to write and understand queries.

The commands used in SQL are called keywords, and they are used to perform various operations on a database, such as creating tables, inserting data, updating records, and retrieving information.

Some of the most commonly used SQL keywords include SELECT, FROM, WHERE, INSERT, UPDATE, and DELETE. These keywords are designed to be intuitive and easy to understand, even for those who are not familiar with programming or database management.

For example when you shop for items online you will typically be searching a database that uses SQL. Your search terms will be added to SQL statements and the relevant records will be retrieved from the database.

A SELECT query could be used to retrieve data from the database.

SELECT the item, price and description columns.
FROM the tblProducts table.
WHERE the criteria has been met

SELECT item, price, description 
FROM tblProducts 
WHERE keyword = "toy";

SQL Searches

After installing SQLite, download and open dbMusic. Then Complete the following activities.

Explore a Database
A3 Worksheet.
Retrieving Data with SQL
A1 Worksheet.
Retrieving data from more than one table
A2 Worksheet

Data Types

Fields in a database (as with variables in a programming language) have data types associated with them. Data types specify the type of value the field can hold.

MySQL and SQLite are both relational database management systems that provide different data types to define the type of data that can be stored in a field.

For example, MySQL provides data types like INT, VARCHAR, TEXT, DATE, etc., while SQLite provides data types like INTEGER, TEXT, REAL, etc.

In conclusion, data types are essential elements in any database that define the type of data that can be stored in a particular field. Choosing the appropriate data type for each field is crucial to ensure the accuracy and consistency of data stored in the database.

With the wide range of data types available in database management systems like MySQL and SQLite, developers can create more robust and efficient databases capable of handling various types of data.

Insert, update, delete

Insert, update, and delete are the three fundamental operations in database management used to add, modify, and remove data. They are crucial for maintaining database integrity and accuracy.

Inserting data

An SQL INSERT statement allows you to add data into pre-existing tables.

The statement allows you to specify:

The table which you intend to insert data into.
Which fields to use.
Which VALUES to enter into those fields.

INSERT INTO tblFriends (firstname,surname) 
VALUES(“Rachel”, “Green”), (“Phoebe”,”Buffay”),(“Chandler”, “Bing”);

INSERT INTO tblMembers (Firstname,Surname, Email, Password)
VALUES(“Nicole”, “Battle”,”Nbat@mail.com”,”Nr5@Wd”);

Updating Data

An SQL UPDATE statement allows you to amend existing records in tables.

To update data in a table, you are required to specify the following:

The table which you intend to UPDATE
The new value that you want to SET
WHERE a condition is being met

UPDATE tblUsers 
SET Firstname = “James” 
WHERE userid = 8;

Deleting Data

An SQL DELETE statement allows you to remove existing records from a table.

To delete data from a table, you are required to specify the following:

The table which you intend to DELETE FROM
WHERE a condition is being met

DELETE FROM tblStudents 
WHERE date_of_birth < 31/08/2002;

Solutions:

Explore a Database Solutions

Retrieving Data with SQL Worksheet Solutions

Retrieving data from more than one table Solutions

Python Day 10 - Meme Magic 😍: Building a Custom Meme Generator with Python

Blackie — Fri, 03 May 2024 20:31:07 +0000

In this article, we'll create a Meme Generator app, a web-based tool for creating custom memes. The app is built using the Taipy GUI library, which provides a simple and intuitive way to create interactive web interfaces. We'll explore the app's features and functionality, as well as the underlying code and design principles. let's get started!

Say Hello Taipy

Create a meme generator with TaipyGUI

Bonus Tips: Improve the Layout

Hosting on Taipy Cloud

Conclusion

Say Hello Taipy!

Taipy is a Python open-source library that makes it simple to create data-driven web applications. It takes care of both the visible part(Frontend) and the behind-the-scenes(Backend) operations. Its goal is to speed up the process of developing applications, from the early design stages to having a fully functional product ready for use.

Source: Taipy Docs

Requirement: Python 3.8 or later on Linux, Windows, and Mac.

Installing Taipy: Open up a terminal and run the following command, which will install Taipy with all its dependencies.

pip install taipy

We're set, let say hello to Taipy...

# import the library
from taipy import Gui

page = "# Hello Taipy!" 

# run the gui
Gui(page).run()

Save the code as a Python file: e.g., hi_taipy.py.
Run the code and wait for the client link http://127.0.0.1:5000 to display and pop up in your browser.
You can change the port if you want to run multiple servers at the same time with Gui(...).run(port=xxxx).

Create a meme generator with TaipyGUI:

Since we are familiar with Taipy, Let's get our hands dirty and build our meme generator.

Step 1: Import the required libraries

# Import taipy library
from taipy.gui import Gui, notify
import requests
import urllib

Step 2: Navigate to imgflip to create an account, set the username and password. After then navigate to Google to search for my user agent, copy and set your username and password from imgflip, then copy and paste your userAgent from the google search result.

username = "your_own_username" 
password = "your_own_password"
userAgent = "your_own_userAgent"

Step 3: Fetch the available meme templates from the Imgflip API using a GET request and store the relevant information (name, URL, and ID) in a list of dictionaries called 'images'

# Fetch the available memes
data = requests.get('https://api.imgflip.com/get_memes').json()['data']['memes']
images = [{'name':image['name'],'url':image['url'],'id':image['id']} for image in data]

Step 4: Initialize empty variables for storing the selected meme template, top and bottom text, and the generated meme

meme_template = ""
top_text = ""
bottom_text = ""
meme_download = None
meme_image = None

Step 5: Create a list of tuples called 'memes' containing the index and name of each meme template for use in the dropdown selector

memes = [(str(ctr), img['name']) for ctr, img in enumerate(images, start=1)]

Step 6: Define a function called 'generate_meme' that takes a 'state' object as an argument, which contains the user input for the meme template, top and bottom text. The function uses the Imgflip API to generate a meme using the provided inputs and stores the generated meme URL and image in the 'meme_download' and 'meme_image' variables respectively.

def generate_meme(state):
    # Get the top and bottom text entered by the user and remove any leading/trailing whitespace
    top_text = state.top_text.strip()
    bottom_text = state.bottom_text.strip()

    # Check if both top and bottom text are specified
    if not top_text or not bottom_text:
        # Notify the user that both top and bottom text must be specified
        notify(state, 'error', 'Both top and bottom text must be specified.')
        # Return from the function without generating a meme
        return

    # Set up the API endpoint URL for generating a meme
    URL = 'https://api.imgflip.com/caption_image'

    # Set up the parameters for the API request
    params = {
        'username': username,    # The username for the Imgflip account
        'password': password,    # The password for the Imgflip account
        'template_id': images[int(state.meme_template[0]) - 1]['id'],    # The ID of the selected meme template
        'text0': top_text,        # The top text entered by the user
        'text1': bottom_text     # The bottom text entered by the user
    }

    # Send a POST request to the API endpoint with the specified parameters
    response = requests.request('POST', URL, params=params).json()

    # Check if the API response contains a 'data' key, indicating that the meme was successfully generated
    if 'data' in response:
        # Notify the user that the meme was successfully generated
        notify(state, 'success', f'meme successfully generated!')

        # Save the URL of the generated meme
        meme_url = response['data']['url']
        state.meme_download = meme_url

        # Display the generated meme image
        response = requests.get(meme_url)
        state.meme_image = response.content
    else:
        # Notify the user that the meme generation failed and provide an error message if available
        notify(state, 'error', f'Failed to generate meme: {response.get("error_message", "Unknown error")}')

Step 7: Define a function called 'download_meme' that takes the 'state' object as an argument and downloads the generated meme image from the 'meme_download' URL using the urllib library.

def download_meme(state):
    if state.meme_download:
        opener = urllib.request.URLopener()
        opener.addheader('User-Agent', userAgent)
        file_path = images[int(state.meme_template[0]) - 1]['name'] + '.jpg'
        opener.retrieve(state.meme_download, file_path)
        return file_path

Step 8: Define the Taipy GUI page using the page string, which contains the user interface elements such as the dropdown selector, input fields, and buttons. The page string also specifies the event handlers for each UI element, such as the 'on_action' event for the 'Generate Meme' button, which calls the 'generate_meme' function.

# Definition of the page
page = """
# Meme Generator! {: .color-primary}
Select Character Image: <|{meme_template}|selector|lov={memes}|dropdown|>
Top Text: <|{top_text}|input|><br />
Bottom Text: <|{bottom_text}|input|><br />
<|Generate Meme|button|class_name=plain|on_action=generate_meme|> 
<|{meme_download}|file_download|label=Download Meme|active={meme_download is not None}|><br />
<|{meme_image}|image|active={meme_download is not None}|>
"""

Step 9: Run the Taipy GUI application using the 'Gui' object and passing the 'page' string to its constructor. The 'run' method starts the application.

Gui(page).run(debug=True)

Full Code

# import taipy library
from taipy.gui import Gui, notify

import requests
import urllib

username = "AbideenTunde"
password = "2nhnUFx@bmbs4Jf"

userAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36"

#Fetch the available memes
data = requests.get('https://api.imgflip.com/get_memes').json()['data']['memes']
images = [{'name':image['name'],'url':image['url'],'id':image['id']} for image in data]

meme_template = ""
top_text = ""
bottom_text = ""
meme_download = None
meme_image = None

memes = [(str(ctr), img['name']) for ctr, img in enumerate(images, start=1)]

def generate_meme(state):
    top_text = state.top_text.strip()
    bottom_text = state.bottom_text.strip()

    if not top_text or not bottom_text:
        notify(state, 'error', 'Both top and bottom text must be specified.')
        return

    URL = 'https://api.imgflip.com/caption_image'
    params = {
        'username': username,
        'password': password,
        'template_id': images[int(state.meme_template[0]) - 1]['id'],
        'text0': top_text,
        'text1': bottom_text
    }

    response = requests.request('POST', URL, params=params).json()

    if 'data' in response:
        notify(state, 'success', f'meme successfully generated!')

        # Save the meme URL
        meme_url = response['data']['url']
        state.meme_download = meme_url

        # Display the meme image
        response = requests.get(meme_url)
        state.meme_image = response.content
    else:
        notify(state, 'error', f'Failed to generate meme: {response.get("error_message", "Unknown error")}')

def download_meme(state):
    if state.meme_download:
        opener = urllib.request.URLopener()
        opener.addheader('User-Agent', userAgent)
        file_path = images[int(state.meme_template[0]) - 1]['name'] + '.jpg'
        opener.retrieve(state.meme_download, file_path)
        return file_path

# Definition of the page
page = """
# Meme Generator! {: .color-primary}
Select Character Image: <|{meme_template}|selector|lov={memes}|dropdown|>
Top Text: <|{top_text}|input|><br />
Bottom Text: <|{bottom_text}|input|><br />
<|Generate Meme|button|class_name=plain|on_action=generate_meme|> 
<|{meme_download}|file_download|label=Download Meme|active={meme_download is not None}|><br />
<|{meme_image}|image|active={meme_download is not None}|>
"""

Gui(page).run(debug=True)

Bonus Tips: Improve the Layout

Click here to try the app.

Define the layout of the user interface for the Meme Generator app. Now we have two columns: a sidebar with a width of 300 pixels, and a main content area.

page="""
<|layout|columns=300px 1|
<|part|render=True|class_name=sidebar|
# Meme **Magic**{: .color-primary}
Select Character Image: <|{meme_template}|selector|lov={memes}|dropdown|>
Top Text: <|{top_text}|input|><br />
Bottom Text: <|{bottom_text}|input|><br />
<|Generate Meme|button|class_name=plain|on_action=generate_meme|> 
|>

<|part|render=True|class_name=p2 align-item-center|
<|{meme_image}|image|active={meme_download is not None}|> <br />
<|{meme_download}|file_download|label=Download Meme|active={meme_download is not None}|>
|>
|>
"""

Hosting on Taipy Cloud

Navigate to Taipy Cloud and create a free account.

https://github.com/jrshittu/meme_magic/assets/110542235/8e81eee7-026d-46aa-89e0-8f69e3667899

To deploy the app to Taipy Cloud, follow these steps:

Connect to Taipy Cloud and sign in to your account.
Click on the "Add Machine" button to create a new machine. Fill in the required fields, such as the machine name and the desired size.
Select the machine that you just created and click on the "Add App" button to create a new app.
Zip the main.py and requirements.txt files for your app and upload the zip file to the "App Files" field.
Fill in the other required fields for the app, such as the app name and the entry point.
Press the "Deploy App" button to deploy the app to Taipy Cloud.

Conclusion

In this article, we learned how to build a custom meme generator using Python and the Taipy GUI library. We explored the features and functionality of the app and walked through the code and design principles. With Taipy, we were able to create an interactive web interface for our meme generator that is both simple and intuitive. We also discussed how to improve the layout of the app and host it on Taipy Cloud. Overall, Taipy provides a powerful and easy-to-use tool for building data-driven web applications.

Python Day 9: Building Interactive Web Apps without HTML/CSS and JavaScript

Blackie — Fri, 26 Apr 2024 11:09:59 +0000

Table of Contents
Introduction
Meet Taipy
Why Taipy?
Explore Apps Built With Taipy
Build Your First Web Apps with Taipy
Conclusion

Introduction

Over the past few years, HTML, CSS & JavaScript has been the go to technologies for building web applications. However, the learning curve has been a tedious and time consuming especially for python developers and data scientists. This is where Taipy comes into play.

Meet Taipy!

Taipy is an open-source Python library that enables data scientists and developers to build robust end-to-end data pipelines.

Data and AI Algorithms into Production-Ready Web Apps

Taipy GUI enables developers to create interactive web interfaces for their data pipelines without requiring HTML/CSS & JavaScript skills. It provides access to interactive widgets, controls and presentative elements to design user interfaces using Python and connect them to your data pipeline functions.

Source: Taipy Docs

Why Taipy?

Taipy provides a simple and intuitive way to build web apps with minimal coding. It offers several advantages over traditional methods. Here are some reasons why Taipy is worth considering for your next web development project:

Simplicity: Taipy simplifies web development by providing an intuitive GUI and a Python API that enable developers to build web applications without the need for extensive coding skills. This makes it an ideal choice for python developers, data scientists and citizen developers who want to build web applications that meet their needs.
Flexibility: Taipy's data-centric approach offers flexibility in building web applications that are optimized for performance, scalability, and adaptability. With Taipy, developers can build web applications that handle large and complex data sets with ease, making it an ideal choice for building data-driven web applications.
Efficiency: Taipy's data-centric approach enables developers to focus on what really matters: the data. By prioritizing data management and analysis, Taipy streamlines the development process, making it more efficient and less time-consuming. This means that developers can build web applications faster and with fewer resources.
Powerful data processing capabilities: Taipy offers powerful data processing capabilities that enable developers to perform complex data analysis and visualization tasks with ease. This makes it an ideal choice for building web applications in fields such as finance, healthcare, and science, where data analysis and visualization are critical.
Easy deployment: Taipy makes it easy to deploy web applications, with support for popular cloud platforms such as AWS, Azure, and Google Cloud. This means that developers can easily deploy their web applications to the cloud, without the need for extensive configuration or setup.

Explore Apps Built with Taipy

Let's explore some of the amazing applications that have been built using Taipy.

Stock Visualization

COVID Dashboard

Production Planning

LLM Chatbot

TalkToTaipy

Measuring Industry Agglomeration

Real-time Face Recognition

Click here for the project gallery.

Building Web Apps with Taipy

Requirement: Python 3.8 or later on Linux, Windows, and Mac.

Installing Taipy: Open up a terminal and run the following command, which will install Taipy with all its dependencies.



pip install taipy

Hence, let say hello to Taipy...



# import the library
from taipy import Gui

page = "# Hello Taipy!" 

# run the gui
Gui(page).run()

Save the code as a Python file: e.g., app.py.
Run the code and wait for the client link http://127.0.0.1:5000 to display and pop up in your browser.

You can change the port if you want to run multiple servers at the same time with Gui(...).run(port=xxxx).

Project One: Personal Details Generator

A simple GUI application that generates random user details, including a name, phone number, and address, using the Faker library.

Full code



from faker import Faker
from taipy.gui import Gui, notify

name = ""
phone = ""
address = ""

fake = Faker()

def generate_name(state):
    state.name = fake.name()
    state.phone = fake.phone_number()
    state.address = fake.address()
    notify(state, 'info', f'Here is your new details: {state.name}')

page = """
# Generate Fake Data {: .color-primary}

<|personal.png|image|> <br />
Generated name is: <|{name}|> <br />
Generated Phone Number: <|{phone}|> <br />
Generated Address: <|{address}|>

<|Generate|button|class_name=plain mt1 p1|on_action=generate_name|>
"""

Gui(page).run(debug=True, title="Fake Details")

Q: What do you think will happen when you run the program?

Now, let's break it down and create the program step by step

Step 1: Import the required libraries

Import the Faker library to generate fake data.
Import the Gui and notify classes from taipy.gui to create the GUI and display notifications. ```python

from faker import Faker
from taipy.gui import Gui, notify

**Step 2: Initialize global variables**

Initialize three global variables `name`, `phone`, and `address` as empty strings. These variables will store the generated fake data.
```python


name = ""
phone = ""
address = ""

Step 3: Create an instance of the Faker class

Create an instance of the Faker class to generate fake data.



fake = Faker()

Step 4: Define the generate_name function

Define a function generate_detail that takes a state parameter. This function generates fake data using the Faker instance and updates the global variables name, phone, and address with the generated data. The notify function is used to display a notification to the user with the generated name.



def generate_detail(state):
    state.name = fake.name()
    state.phone = fake.phone_number()
    state.address = fake.address()
    notify(state, 'info', f'Here is your new details: {state.name}')

Step 5: Define the Taipy GUI page layout

Define the Taipy GUI page layout using Markdown syntax. The layout includes a header, an image, three text fields to display the generated fake data, and a button to generate new data. The on_action attribute of the button is set to the generate_name function.



page = """
# Generate Fake Data {: .color-primary}

<|personal.png|image|> <br />
Generated name is: <|{name}|> <br />
Generated Phone Number: <|{phone}|> <br />
Generated Address: <|{address}|>

<|Generate|button|class_name=plain mt1 p1|on_action=generate_detail|>
"""

Step 6: Run the Taipy GUI application

Finally, run the Taipy GUI application using the Gui class. The page variable is passed to the Gui constructor to set the page layout. The debug parameter is set to True to enable debug mode, and the title parameter is set to "Fake Details" to set the application title.



Gui(page).run(debug=True, title="Fake Details")

When you run this code, the "Generate" button triggers the generate_detail function, which updates the displayed data and shows a notification with the generated name.

Project 2: Image Background Remover 🤖

Now let's create a Taipy GUI app to remove backgrounds from images

Full Code: main.py



from PIL import Image
from rembg import remove
from taipy.gui import Gui, notify
from io import BytesIO

image_upload = ""
image_download = "removebg_img.png"
old_image = None
new_image = None
bg_removed = False

def convert_image(img):
    buf = BytesIO()
    img.save(buf, format="PNG")
    byte_im = buf.getvalue()
    return byte_im

def rm_bg(state):
    notify(state, 'info', 'Uploading image...')
    image = Image.open(state.image_upload)

    notify(state, 'info', 'Removing bg...')
    new_image = remove(image)
    new_image.save("removebg_img.png")

    notify(state, 'success', 'bg removed successfully!')
    state.old_image = convert_image(image)
    state.new_image = convert_image(new_image)
    state.bg_removed = True

page = """
# Image Background Remover {: .color-primary}
Upload an Image: <|{image_upload}|file_selector|extensions=.png,.jpg|on_action=rm_bg|> <br />
<|{old_image}|image|>
<|{new_image}|image|><br/>
<|{image_download}|file_download|label=Download Image|active={bg_removed}|>
"""

Gui(page).run(debug=True)

Now, let's break it down and create the program step by step

Step 1: Import necessary libraries

In this step, we import the necessary libraries for working with images, removing backgrounds, creating a GUI, and working with binary data.



from PIL import Image
from rembg import remove
from taipy.gui import Gui, notify
from io import BytesIO

Step 2: Initialize variables

In this step, we initialize variables for storing the uploaded image file, the name of the downloaded image file, the original and processed images, and a boolean variable for indicating whether the background has been removed.



image_upload = ""
image_download = "removebg_img.png"
old_image = None
new_image = None
bg_removed = False

Step 3: Define the convert_image function

In this step, we define a function for converting an image to binary data. This function takes an image as input and returns its binary data.



def convert_image(img):
    buf = BytesIO()
    img.save(buf, format="PNG")
    byte_im = buf.getvalue()
    return byte_im

Step 4: Define the rm_bg function

In this step, we define a function for removing the background from an image and displaying notifications to the user. This function takes a state object as input and performs the following operations:

Displays a notification indicating that the image is being uploaded.
Opens the uploaded image using the Image.open method from the PIL library.
Displays a notification indicating that the background is being removed.
Removes the background from the image using the remove function from the rembg library.
Saves the processed image to a file using the save method from the PIL library.
Displays a notification indicating that the background has been removed successfully.
Converts the original and processed images to binary data using the convert_image function.
Sets the old_image, new_image, and bg_removed attributes of the state object to the original image data, processed image data, and True respectively. ```python

def rm_bg(state):
notify(state, 'info', 'Uploading image...')
image = Image.open(state.image_upload)

notify(state, 'info', 'Removing bg...')
new_image = remove(image)
new_image.save("removebg_img.png")

notify(state, 'success', 'bg removed successfully!')
state.old_image = convert_image(image)
state.new_image = convert_image(new_image)
state.bg_removed = True

**Step 5: Define the GUI layout**

In this step, we define the layout of the GUI using a string. The layout consists of a file upload widget, two image display widgets, and a file download widget.
```python


page = """
# Image Background Remover {: .color-primary}
Upload an Image: <|{image_upload}|file_selector|extensions=.png,.jpg|on_action=rm_bg|> <br />
<|{old_image}|image|>
<|{new_image}|image|><br/>
<|{image_download}|file_download|label=Download Image|active={bg_removed}|>
"""

Step 6: Run the GUI

In this step, we create a Gui object using the page string and run it in debug mode.



Gui(page).run(debug=True)

Conclusions

In this article, we introduced Taipy, an open-source Python library that enables data scientists and developers to build robust end-to-end data pipelines and interactive web interfaces without requiring HTML/CSS & JavaScript skills. We discussed the advantages of using Taipy, such as simplicity, flexibility, efficiency, powerful data processing capabilities, and easy deployment.

We also provided a step-by-step guide to building web apps with Taipy and explored some examples of applications built with Taipy. Taipy provides a simple and intuitive way to build web apps with minimal coding, making it an ideal choice for python developers, data scientists, and citizen developers who want to build web applications that meet their needs.

We encourage you to explore Taipy and see how it can help you build data-driven web applications with ease. You can start by checking out the official Taipy repository on GitHub and adding a star to show your support.

Thank you for reading, and happy coding!

Don't Forget to ⭐️ the Official Repo

Day 8: File Handling and I/O Operations

Blackie — Fri, 19 Apr 2024 14:39:43 +0000

Introduction

Handling Files

CSV Files

Conclusion

Introduction

In Python, files are used to store data permanently on disk. File handling involves reading, writing, and manipulating data stored in files. In this article, we will explore how to perform file handling and I/O operations in Python.

A file is a term used to describe data that is held in storage on a computer.
Files come in many forms, for example:

Text files
Image files
Video files
Sound files

Handling Files

File handling is a term used to describe how programs work with the files that are stored in a computer.
Having the ability to use file-handling techniques in your own programs opens up endless possibilities.

All of the programs that you have created so far have lost any data generated within them once they have been terminated.
Saving program data to an external file allows you to use that data again.

An example of when this might be used is to keep track of the highest score for a game.

A text file can be used to store the highest score and this can be accessed and modified each time the game is played.

Key File Handling Techniques

The key file-handling techniques that you need to be able to use are:

Open
Read
Close
Write
Append

Open and read a text file

In order to read the data stored in a text file, you must open it first.

Think of it a bit like a book. You can’t read what is inside if you don’t open it first.

Here is an instruction that will open a text file in read mode.

file = open("quick.txt","r")

Creates an identifier for the file that is to be accessed.
Calls a function that returns a file object.
The first argument is the name of the text file to be opened.
The second argument is the mode that the file will be opened.

There are four modes for opening a file:

'r' - Read mode (default)
'w' - Write mode
'a' - Append mode
'r+' - Read and write mode

Read a Text File

To read the contents of a text file, we can use the read() method on the file object: Once a file has been opened, it can then be read.

file = open("quick.txt","r")
quicktext = file.read()

After we are done working with a file, it's important to close it using the close() method. This ensures that any changes made to the file are saved and the file is released from memory.

file.close()

Reading and Writing to Files

To read data from a file, we can use the read() method. This method reads the entire contents of the file and returns it as a string.

file = open('example.txt', 'r')
contents = file.read()
print(contents)
file.close()

To write data to a file, we can use the write() method. This method writes a string to the file.

file = open('example.txt', 'w')
file.write('Hello, World!')
file.close()

We can also use the writelines() method to write a list of strings to a file.

file = open('example.txt', 'w')
lines = ['Hello, World!\n', 'This is a test.\n']
file.writelines(lines)
file.close()

File Errors and Exceptions

When working with files, it's important to handle errors and exceptions that may occur. For example, if we try to open a file that doesn't exist, Python will raise a FileNotFoundError. We can handle this error using a try-except block.

try:
    file = open('example.txt', 'r')
    contents = file.read()
    print(contents)
    file.close()
except FileNotFoundError:
    print('File not found.')

Project: File Organizer

For this project, we will create a file organizer that moves files from one directory to another based on their file extension.

Step 1: Create a directory called 'files' and add some files with different file extensions to it.

Step 2: Create a dictionary that maps file extensions to their respective directories.

file_extensions = {
    'txt': 'text_files',
    'jpg': 'image_files',
    'png': 'image_files',
    'pdf': 'document_files'
}

Step 3: Loop through the files in the 'files' directory and move them to their respective directories based on their file extension.

import os
import shutil

for filename in os.listdir('files'):
    extension = filename.split('.')[-1]
    if extension in file_extensions:
        directory = file_extensions[extension]
        if not os.path.exists(directory):
            os.makedirs(directory)
        shutil.move(os.path.join('files', filename), os.path.join(directory, filename))

Step 4: Run the script and verify that the files have been moved to their respective directories.

CSV Files

CSV stands for comma-separated values.

CSV files can be read by a range of different spreadsheet software packages as well as Python files.

CSV files contain data structured so that a comma separates individual items in the file, and each record is on a new line of the file.

A CSV file can be created in a text editor by changing the extension of the file to .csv

You can also create CSV files in spreadsheet software by exporting them as a .csv file.

When you open a CSV file in spreadsheet software, the commas are used as a guide to display the data neatly in rows and columns.

When a CSV file is opened in spreadsheet software, it is displayed in tabular format.

A CSV file is still a text file. Each row is stored as string.

Modern spreadsheet software will typically recognise a number and store it as that data type.

Python will not do this automatically. Any data is always read as string and will need to be casted before it is used as any other data type.

Reading a CSV File

To read a CSV file, we first need to open it using the open() function with the file name and mode 'r' for reading. Then, we create a csv.reader() object by passing the file object to it. The csv.reader() object reads the CSV file line by line and returns an iterator that yields a list of values for each row.

Here's an example of reading a CSV file:

import csv

with open('example.csv', 'r') as file:
    reader = csv.reader(file)
    for row in reader:
        print(row)

In this example, we open the file 'example.csv' in read mode and create a csv.reader() object. Then, we loop through the rows in the CSV file using a for loop and print each row as a list.

By default, the csv.reader() object assumes that the delimiter is a comma. However, we can specify a different delimiter using the delimiter parameter. For example, to read a TSV (Tab Separated Values) file, we can set the delimiter to '\t':

import csv

with open('example.tsv', 'r') as file:
    reader = csv.reader(file, delimiter='\t')
    for row in reader:
        print(row)

In addition to reading the data as lists, we can also read it into a dictionary using the csv.DictReader() class. This is useful when we want to access the values in each row using the column names as keys. To use csv.DictReader(), we need to pass the file object and a list of column names as arguments. The first row of the CSV file should contain the column names.

Here's an example of reading a CSV file into a dictionary:

import csv

with open('example.csv', 'r') as file:
    reader = csv.DictReader(file, fieldnames=['Name', 'Age', 'Gender'])
    for row in reader:
        print(row)

In this example, we create a csv.DictReader() object and pass it the file object and a list of column names. Then, we loop through the rows in the CSV file and print each row as a dictionary.

Write to CSV File

Writing to a CSV file is very similar to writing to a standard text file.

The key thing is to remember how a CSV file is structured.

The next thing to remember is that a CSV file is a text file. You can only write data to it that has the string data type.

Here is a program that is attempting to write an integer to a CSV file.

file = open("numbers.csv", "w")
numbers = 3
file.write(numbers)
file.close()

When executed, this error message will occur.

TypeError: write() argument must be str, not int

Any data written to a CSV file must be sent in the format that it requires:

Data must have the string data type
Each item should be separated by a comma
Each new row or record should be indicated by a line space \n which stands for newline

Writing a List of Numbers to a CSV File in Python

In this example, we'll write a list of numbers to a CSV file using Python. Here are the steps:

Step 1: Create a List of Numbers

First, let's create a list of numbers that we want to write to the CSV file:

numbers = [3, 4, 5]

Step 2: Convert the Numbers to Strings

Next, we need to convert the numbers to strings so that we can write them to the CSV file. We'll use a for loop to iterate through the list of numbers and append each string representation to a new list:

str_numbers = []
for number in numbers:
    str_numbers.append(str(number))

Step 3: Join the Strings into a Single String

Now that we have a list of string representations of the numbers, we need to join them into a single string separated by commas. We can use the ",".join(str_numbers) method to do this:

data = ",".join(str_numbers)

Step 4: Open the File in Write Mode

Next, we need to open the CSV file in write mode. We'll use the open() function to do this:

file = open("numbers.csv", "w")

Step 5: Write the Data to the File

Now we can write the data to the CSV file using the write() method:

file.write(data)

Step 6: Close the File

Finally, we need to close the file using the close() method:

file.close()

And that's it! When we run this code, a new CSV file named "numbers.csv" will be created in the current directory, containing the list of numbers separated by commas.

Here's the complete code:

numbers = [3, 4, 5]

str_numbers = []
for number in numbers:
    str_numbers.append(str(number))

data = ",".join(str_numbers)

file = open("numbers.csv", "w")
file.write(data)
file.close()

Conclusion

In this article, we learned how to perform file handling and I/O operations in Python. We covered how to open and close files, read and write data to files, handle file errors and exceptions, and create a file organizer project. File handling is an important skill to have in Python, as it allows us to work with data stored on disk.

Day 7: GUIs: Graphical User Interface

Blackie — Fri, 12 Apr 2024 06:57:45 +0000

Introduction

Install and Setup Guizero

Project One: Hello GUI

Project Two: Lost Cat Poster

Project Three: A Dice Game

Project Four: Username Generator

Project Five: Create a meme generator

Project Six: Popups

Project Seven: Calculator App

Project Eight: Tic Tac Toe Game

Summary

References

Introduction

By using a graphical user interface (GUI), or "gooey"), Python programs can be made more user-friendly and fascinating. With the help of the Guizero library, beginners can add several "widgets" to their user interfaces, giving the program a wide variety of input and output methods. It allows people to be able to select an item from a menu, press a button, or see some text on a screen.

Install and Setup Guizero

Python’s standard GUI package is called tkinter, and is already installed with Python on most platforms. As a wrapper for tkinter, the guizero package provides a considerably more user-friendly interface for using the default GUI library for Python.

You need to install Guizero to get it up and running. To install it, open your command line / terminal and input the command provided below.

pip3 install guizero

You can visit the Github Page for detailed installation instructions.

Project One: Hello GUI

To create your first GUI app, open your code editor or Python IDE. After that, you'll need to import each widget; hence, you can use it as many times as you wish throughout your program. To import the App widget, select and import the widgets you need from the guizero library at the start of each guizero program using the following command.

from guizero import App

After that, enter the following code to create your first GUI app.

app = App(title="Hello, world!")
app.display()

You can now save and run your code. A GUI window with the title "Hello, world!" should appear.

Congrats!! You created your first GUI application.

Project Two: Lost Cat

Click here to download the project files.

from guizero import App, Text, Picture

app = App("Wanted Cat", bg='pink')

picture = Picture(app, image="cat-133_128.gif")
message = Text(app, text='Help find my Cat', color='green', size=16, font='verdana')

app.display()

The creates a GUI window using the guizero library, displays a picture of a cat, and shows a text message below it. The background color of the app window is set to pink.

Exercise: Create a Birthday Card

Project Three: Dice Roll Game

from guizero import App, Box, Text, PushButton
import random

# App
app = App("Dice Rolling Game")

# Function to roll the dice
def roll_dice():
    dice_value = random.randint(1, 6)
    dice_text.value = str(dice_value)

# Create the dice box
dice_box = Box(app, layout="grid")

# Create the dice text
dice_text = Text(dice_box, text="Click to roll", size=40, grid=[0, 0, 2, 1])

# Create the roll button
roll_button = PushButton(dice_box, text="Roll", command=roll_dice, grid=[0, 1, 2, 1])

# Display the app
app.display()

The code is basic implementation of a dice rolling game using the guizero library. When the user clicks the "Roll" button, a random value between 1 and 6 is generated, and the value is displayed on the screen.
If you'd like to expand the functionality of the dice rolling game, here are a few ideas:

Add multiple dice: Modify the code to include multiple dice and display the individual values of each dice.
Keep track of the total score: Create a variable to keep track of the total score and update it with each roll.
Add animations: Use guizero's Animation class to create dice rolling animations for a more interactive experience.
Create a game interface: Design a user interface that includes a score tracker, player names, and buttons for different game actions.

These are just a few suggestions to enhance the dice rolling game. Feel free to explore and implement additional features based on your preferences.

Project Four: Create a username generator

It's time to get into the really interactive part and make a GUI application that generate a random username. Faker is a widely-used library for generating fake data, including names. It provides a range of methods to generate names in various languages and formats. You can install it using pip with the command.
open the terminal and run. pip install Faker

from guizero import App, Text, PushButton
from faker import Faker

fake = Faker()

# Function to generate a random name
def gen_name():
    name = fake.name()
    names.value = name

# Create the app window
app = App("Username Generator", bg='orange')

# Create the widgets
message = Text(app, text="Click here to generate the username")
button = PushButton(app, gen_name, text="Generate")
button.text_color = '#ffffff'
button.bg = 'red'
names = Text(app, text='', color='#ffffff', size=34)

# Display the app window
app.display()

The code creates a GUI window using the guizero library. When the "Generate" button is clicked, it calls the gen_name function, which generates a random name using the fake.name() method from the faker library and displays it in a larger text size below the button.

Running this code will display an app window titled "Username Generator" with a button labeled "Generate." When you click the button, it will generate a random name and display it in a larger text size below the button.

Exercise: Create a pass_key generator, check example here

Project Five: Create a meme Generator

It's time to get into the really interactive part and Start by creating a simple GUI with two text boxes for the top and bottom text. This is where you will enter the text which will be inserted over your picture to create your meme. Add this line to import the widgets needed.

from guizero import App, Drawing, Slider, Combo, TextBox

# App
app = App("Meme Generator", bg="lightgray")

# Function to draw the meme
def draw_meme():
    meme.clear()
    meme.image(0, 0, "cat-133_128.gif")
    meme.text(
        0, 0, top.value,
        color=color.value,
        size=size.value,
        font=font.value,
    )
    meme.text(
        0, 200, bottom.value,
        color=color.value,
        size=size.value,
        font=font.value,
    )

# TextBox
top = TextBox(app, "top_text", command=draw_meme)
bottom = TextBox(app, "bottom_text", command=draw_meme)

# Drawing
meme = Drawing(app, width="fill", height="fill")

# Combo
color = Combo(app, options=["orange", "red", "blue", "green", "grey"], command=draw_meme, selected="blue")
font = Combo(app, options=["monospace", "verdana", "helvetica", "cursive", "sans-serif"], command=draw_meme)

# Slider
size = Slider(app, start=10, end=100, command=draw_meme)

# Call the draw_meme function
draw_meme()

# Display the app
app.display()

The code allows users to enter top and bottom text, select a color and font, and adjust the text size using a slider. The draw_meme function clears the drawing, adds an image at the top left corner, and overlays the entered text based on the user's input.

The code uses the "cat-133_128.gif" image for the meme background. If you have that image file in the same directory as your Python script, the app should display it correctly. Make sure the image file name and path are correct.
Click here to access the files

Project Six: Pop-ups

In this project you're going to learn several functions to demonstrate different types of pop-ups:

show_info function displays an information pop-up using the info function.
show_warning function displays a warning pop-up using the warn function.
show_error function displays an error pop-up using the error function.
ask_question function displays a yes/no question pop-up using the yesno function. It shows a response based on the user's selection.

from guizero import App, PushButton, info, warn, error, yesno, question

# App
app = App("GUI Examples")

# Function for info pop-up
def show_info():
    info("Information", "This is an information pop-up!")

# Function for warning pop-up
def show_warning():
    warn("Warning", "This is a warning pop-up!")

# Function for error pop-up
def show_error():
    error("Error", "This is an error pop-up!")

# Function for yes/no question pop-up
def ask_question():
    response = yesno("Question", "Do you like guizero?")
    if response:
        info("Response", "You clicked 'Yes'!")
    else:
        info("Response", "You clicked 'No'!")

# Button for info pop-up
info_button = PushButton(app, text="Info", command=show_info)

# Button for warning pop-up
warning_button = PushButton(app, text="Warning", command=show_warning)

# Button for error pop-up
error_button = PushButton(app, text="Error", command=show_error)

# Button for yes/no question pop-up
question_button = PushButton(app, text="Question", command=ask_question)

# Display the app
app.display()

Project Seven: Calculator App

In this code, a 2D list named button_layout is used to define the layout of the calculator buttons. Each inner list represents a row of buttons, and each element represents a button label. The layout is used to create the button grid dynamically.

from guizero import App, Box, PushButton, Text

# Function to update the display
def update_display(text):
    display.value += text

# Function to calculate the result
def calculate_result():
    try:
        result = eval(display.value)
        display.value = str(result)
    except:
        display.value = "Error"

# Function to clear the display
def clear_display():
    display.value = ""

# Create the app
app = App("Calculator", width=600, height=800)

# Create the display box
display_box = Box(app, width="fill", height=100, align="top")
display = Text(display_box, text="", size=40)

# Define the button layout
button_layout = [
    ["7", "8", "9", "/"],
    ["4", "5", "6", "*"],
    ["1", "2", "3", "-"],
    ["0", ".", "=", "+"],
    ["C"]
]

# Create the button grid
button_box = Box(app, width="fill", height="fill", layout="grid")

# Create the buttons
buttons = []
for row, row_buttons in enumerate(button_layout):
    for col, label in enumerate(row_buttons):
        button = PushButton(
            button_box, text=label, grid=[col, row],
            width=7, height=5, padx=10, pady=10
        )
        button.bg = "white"
        button.text_color = "black"

        if label == "C":
            button.update_command(clear_display)
        elif label == "=":
            button.update_command(calculate_result)
        else:
            button.update_command(update_display, [label])

        buttons.append(button)

# Display the app
app.display()

The functions update_display, calculate_result, and clear_display handle the button actions.

Inside the nested loop that iterates over the button_layout, the buttons are created dynamically using the label from the layout. The commands for the buttons are set based on the label, and the buttons are added to the buttons list.

Project Eight: Tic Tac Toe Game

Create a simple Tic Tac Toe game using guizero that defines functions to handle various game actions such as clearing the board, choosing a square, taking turns, checking for a win, counting moves, resetting the game, and disabling buttons.

#imports
from guizero import App, Box, PushButton, Text

# Functions
def clear_board():
    new_board = [[None, None, None], 
                 [None, None, None], 
                 [None, None, None]]
    # generate a 3x3 grid
    for x in range(3):
        for y in range(3):
            button = PushButton(
                board, text='', grid=[x, y], width=3, command=choose_square, args=[x,y])
            new_board[x][y] = button
    return new_board

def choose_square(x, y):
    board_square[x][y].text = turn
    board_square[x][y].disable()
    take_turns()
    check_win()

def take_turns():
    global turn
    if turn == "X":
        turn = "O"
    else:
        turn = "X"
    message.value = "It's your turn, " + turn

def check_win():
    winner = None

    # vertical lines
    if(
        board_square[0][0].text == board_square[0][1].text == board_square[0][2].text
    ) and board_square[0][2].text in ["X", "O"]:
        winner = board_square[0][0]
    elif (
        board_square[1][0].text == board_square[1][1].text == board_square[1][2].text
    ) and board_square[1][2].text in ["X", "O"]:
        winner = board_square[1][0]
    elif (
        board_square[2][0].text == board_square[2][1].text == board_square[2][2].text
    ) and board_square[2][2].text in ["X", "O"]:
        winner = board_square[2][0]

    # horizontal
    elif (
        board_square[0][0].text == board_square[1][0].text == board_square[2][0].text
    ) and board_square[2][0].text in ["X", "O"]:
        winner = board_square[0][0]
    elif (
        board_square[0][1].text == board_square[1][1].text == board_square[2][1].text
    ) and board_square[2][1].text in ["X", "O"]:
        winner = board_square[0][1]   
    elif (
        board_square[0][2].text == board_square[1][2].text == board_square[2][2].text
    ) and board_square[2][2].text in ["X", "O"]:
        winner = board_square[0][2]  

    # diagonals
    elif (
        board_square[0][0].text == board_square[1][1].text == board_square[2][2].text
    ) and board_square[2][2].text in ["X", "O"]:
        winner = board_square[0][0]   
    elif (
        board_square[2][0].text == board_square[1][1].text == board_square[0][2].text
    ) and board_square[0][2].text in ["X", "O"]:
        winner = board_square[0][2]  

    if winner is not None:
        message.value = winner.text + " wins!"
    elif moves_taken() == 9:
        message.value = "It's a tie🤝🤝"
        disable_buttons()

def moves_taken():
    moves = 0
    for row in board_square:
        for col in row:
            if col.text == "X" or col.text == "O":
                moves = moves + 1
    return moves 

def reset_game():
    global turn
    turn = "X"
    message.value = "It's your turn, " + turn
    for row in board_square:
        for col in row:
            col.text = ""
            col.enable()

def disable_buttons():
    for row in board_square:
        for col in row:
            col.disable()


# Variables
turn = "X"

# App
app = App('Tic Tac Toe Game', bg='burlywood')
board = Box(app, layout='grid') # Create the board        
board_square = clear_board()
message = Text(app, text="It is your turn, " + turn)
message.text_color = "green"

# Display app
app.display()

The game interface is created using guizero's App and Box components. The board is represented as a 3x3 grid of PushButton objects within the board box. Each button corresponds to a square on the board and has a command assigned to it to handle user input. The game state is tracked using a 2D list board_square, where each element represents a button/square on the board.

The check_win function checks for winning conditions by comparing the text values of the buttons in various winning combinations (vertical, horizontal, and diagonal lines). If a winner is found, the appropriate message is displayed. If no winner is found and all squares are filled, it's considered a tie.

Summary

Guizero aims to make the process of developing quick GUIs simple, approachable, and accessible for new users. There is no need to install additional libraries as it works with the standard Python Tkinter GUI library.

☕ Enjoyed this article? Support my work with a coffee: https://www.buymeacoffee.com/cqvuesleq

Also open for technical writing and frontend dev roles!

References

Guizero Github Page: https://github.com/lawsie/guizero

Python Official Docs, Tkinter: https://docs.python.org/3/library/tkinter.html

Day 6 - Object Oriented Programming

Blackie — Sat, 06 Apr 2024 17:32:55 +0000

Day 6: Object Oriented Programming

Introduction

Object Oriented Programming Keywords

Creating a template for an object

Creating An Instance

Creating getters for an object

Creating set methods

Inheritance

Polymorphism

Encapsulation

Summary

Object-oriented programming (OOP) is another programming paradigm that was derived from procedural programming. The first language to include object-oriented principles was called Simula, released in 1967. Now a number of modern languages use or allow the use of OOP.

In object-oriented programming, objects are used to model things in code.

An object is a collection of data. Each object has the same basic attributes but the values may be different.

Its associated actions is called methods.

In procedural programming, data is stored in the main program and passed to subroutines but in OOP the data and subroutines are stored together in objects which are created from classes.

The OOP paradigm is focused on objects which represent parts of a computer program. You can create objects to represent real physical things, like a human being. They can also be used for small parts of a larger program, like a widget in a user-interface.

For Example:

Object - Car
Attributes - Make, model, colour
Methods - Accelerate, slow down, change gear

In this example, we could create lots of instances of cars of varying makes and models, all with different colours, but they are all the same type of object, sharing the same attributes.

To create objects you must first define a class.

A class is like a blueprint, it contains the plans for the data and behaviours an object should possess. You can create many objects from a single class. Just like you can make many houses from the same blueprint.

A class needs a constructor.

A constructor is a special type of method that initialises (constructs) an object of that type and defines what attributes the object has.

joe = User("Joe Dalton", "joeboss@example.com")

This method is called to create a new instance of a class, a new object.

Creating A Template for An Object

Start by creating an identifier for your class with the object you want to create, For example we are going to create an object for a bank account.

class Bank_account()

Next, we write the constructor, a special method to instruct Python how to create on object of this class.

class Bank_account:
    def __init__(self, account_name, account_number, balance):
        self.account_name = account_name
        self.account_number = account_number
        self.balance = balance

init here stands for ‘initialise’. In this example we can see the Bank_account will have a, account_name, account_number, and balance. These are the attributes that the Bank_account will have.

Note: If we set the attribute values to None, they would start off with no value.

We always refer to attributes within the object in the format self.name_of_attribute to tell Python that we are referring to a piece of data within the object.

self means “this object”.

Save this file as bank_account.py

Creating An Instance of Bank_account

Now we have a class file for our object, we can go ahead and create a new instance of a Bank_account.

In a new file (but in the same folder as your class file), we are going to import the Bank_account object from our custom class file bank_account.

from bank_account import Bank_account

Next, we need to define the attributes of our bank account.

from bank_account import Bank_account

account_a = Bank_account("John Dalton", "123456789", 1000)

Here we have created a variable called account_a. The account's name, has been assigned the value “John Dalton”, the account number has been assigned the value “123456789”, and a balance of 1000 has been included.

Save your new file as accounts.py.

If you now execute your accounts.py file you will not see any output. However an instance of your Bank account has been created in memory with the attributes assigned in accounts.py.

Creating getters for an object

To make use of information in our objects, we need to write some methods that give us access to it.

These are called getters. They are essentially functions that can be called to get information about our objects.

class Bank_account:
    def __init__(self, account_name, account_number, balance):
        self.account_name = account_name
        self.account_number = account_number
        self.balance = balance

    def get_account_name(self):
        return self.account_name

Go back and open up bank_accounts.py. A method has been added above to get the name of the bank account. Can you add this, as well as two more methods to get the account_number, and the balance?

class Bank_account:
    def __init__(self, account_name, account_number, balance):
        self.account_name = account_name
        self.account_number = account_number
        self.balance = balance

    def get_account_name(self):
        return self.account_name

    def get_account_number(self):
        return self.account_number

    def get_balance(self):
        return self.balance

The getter methods here allow us to test and get information about our object.

What will be displayed on the screen when this is executed?

As they just return the value, nothing will actually be printed to the screen. They are useful if we want to concatenate the information together.

We can however print the result of calling these get methods.

from bank_account import Bank_account

account_a = Bank_account("John Dalton", "123456789", 1000)

print(account_a.get_account_name())

John Dalton
>>>

Go back and open up accounts.py. Using a print statement, test that your getter methods are working. One has been done for you above.

from bank_account import Bank_account

account_a = Bank_account("John Dalton", "123456789", 1000)

print(account_a.get_account_name())
print(account_a.get_account_number())
print(account_a.get_balance())

John Dalton
123456789
1000
>>>

Whilst this is a useful way of seeing information about our objects, a method could be included within the class itself to describe the object.

Problem: Instead of three separate print statements in your accounts.py file, we will now use a different approach. Go back to bank_accounts.py and add an additional method called display_info() which will print out the object’s attribute details when called.

Solution

class Bank_account:
    def __init__(self, account_name, account_number, balance):
        self.account_name = account_name
        self.account_number = account_number
        self.balance = balance

    def get_account_name(self):
        return self.account_name

    def get_account_number(self):
        return self.account_number

    def get_balance(self):
        return self.balance

    def display_info(self):
        print("Account Details: %s, %s, balance is %s" %(self.account_name, self.account_number, self.balance))

Go back and open up accounts.py. Using a print statement, test that your method is working.

from bank_account import Bank_account

account_a = Bank_account("John Dalton", "123456789", 1000)

print(account_a.display_info())

Account Details: John Dalton, 123456789 balance is 1000
>>>

Creating set methods

Previously we created get methods to retrieve information about our objects. What if we want to set/change information?

For this we use set methods that allow us to change information within our objects. An example set method has been created below

class Bank_account:
     ...
     ...
     ...
     ...
     ...
     def set_account_name(self, account_name):
          self.account_name = account_name

Modify your bank_account file to include the set_account_name() method, and check it works by calling it in your accounts file using your display_info() method.

Can you create additional methods in your accounts.py file to set the account_number and the balance?

class Bank_account:
    def __init__(self, account_name, account_number, balance):
        self.account_name = account_name
        self.account_number = account_number
        self.balance = balance

    def get_account_name(self):
        return self.account_name

    def get_account_number(self):
        return self.account_number

    def get_balance(self):
        return self.balance

    def set_account_name(self, account_name):
        self.account_name = account_name

    def set_account_number(self, account_number):
        self.account_number = account_number

    def set_balance(self, balance):
        self.balance = balance

    def display_info(self):
        print("Account Details: %s, %s, balance is %s" %(self.account_name, self.account_number, self.balance))

Inheritance

Inheritance is a mechanism for basing one class off of another.

The new class is called a subclass. The original class is a superclass.

The subclass inherits all the attributes and methods of the superclass.

When you create a new subclass it inherits all the attributes and methods of the superclass.

You can add new attributes and methods as well, allowing you to add specific data or actions that are only applicable to the subclass.

Here's an example of inheritance in Python:

class Animal:
    def __init__(self, name):
        self.name = name

    def make_sound(self):
        print("Some animal sound")

class Dog(Animal):
    def make_sound(self):
        print("Woof!")

dog = Dog("Max")
dog.make_sound() Woof!

Woof!
>>>

In this example, the class Dog is a subclass of the class Animal, and it inherits the attribute name and the method make_sound from the superclass. However, the method make_sound is redefined in the subclass to provide a different implementation. This is a simple example. Hence, another example is here below...

class Bank_account:
    def __init__(self, account_name, account_number, balance):
        self.account_name = account_name
        self.account_number = account_number
        self.balance = balance

    def get_account_name(self):
        return self.account_name

    def get_account_number(self):
        return self.account_number

    def get_balance(self):
        return self.balance

    def set_account_name(self, account_name):
        self.account_name = account_name

    def set_account_number(self, account_number):
        self.account_number = account_number

    def set_balance(self, balance):
        self.balance = balance
class Credit(Bank_account):
    def __init__(self, account_name, account_number, balance, loans, liability):
        super.__init__(self, account_name, account_number, balance):
        self.loans = loans 
        self.liability = liability

    def get_loans():
        return self.loan

    def set_loans(self, loans):
        self.loans = loans

    def get_liability():
        return self.liability

    def set_liabilities(self, liability):
        self.loans = loans

Now open the accounts.py file, add the objects and print it's attributes

from bank_account import Bank_account, Credit

account_a = Credit("John Dalton", "123456789", 1000, 2400, "Car")

print(account_a.get_liability())

Car
>>>

Polymorphism

Polymorphism is a key feature of Object-Oriented Programming (OOP) in Python that allows you to use objects of different classes with a common interface (i.e. method names).

In polymorphism, objects of different classes can respond to the same method call in a unique way, as determined by the class of the object. This allows you to write code that can work with objects of different classes interchangeably, as long as they have a common interface.

There are two main types of polymorphism in Python:

Duck Typing: Duck typing is a dynamic typing approach that allows an object to be used as long as it has the required methods, regardless of the class it belongs to.

Method Overloading: Method overloading is a static typing approach that allows multiple methods with the same name, but with different parameters, in the same class or in different classes.

Here's an example of polymorphism in Python

def make_sound(animal):
    animal.make_sound()

class Dog:
    def make_sound(self):
        print("Woof!")

class Cat:
    def make_sound(self):
        print("Meow!")

dog = Dog()
cat = Cat()
make_sound(dog)
make_sound(cat)

Woof!
Meow!
>>>

In this example, the function make_sound takes an object of any class that has a method named make_sound and calls that method. The classes Dog and Cat both have a method make_sound, so they can be used interchangeably with the make_sound function.

This is just a simple example of polymorphism in Python. The concept of polymorphism is essential for writing robust and flexible code, and can be used in a variety of ways in OOP.

Encapsulation

Encapsulation is a key feature of Object-Oriented Programming (OOP) in Python that allows you to control access to an object's attributes and methods. It helps you to hide the implementation details of an object and provide a public interface for accessing and using the object.

Encapsulation in Python is achieved by using the private and protected access modifiers. By convention, private attributes and methods in Python are denoted with a double underscore __ prefix, and protected attributes and methods are denoted with a single underscore _ prefix.

Here's an example of encapsulation in Python:

class Bank_account:
    def __init__(self, balance):
        self.__balance = balance

    def get_balance(self):
        return self.__balance

    def deposit(self, amount):
        self.__balance += amount

    def withdraw(self, amount):
        if self.__balance >= amount:
            self.__balance -= amount
            return True
        else:
            return False

account = Bank_account(100)
print(account.get_balance()) 
account.deposit(50)
print(account.get_balance()) 
print(account.withdraw(200)) 
print(account.get_balance())

100
150
False
150
>>>

In this example, the class BankAccount has a private attribute __balance that stores the account balance, and several public methods for accessing and modifying the balance. The get_balance method returns the balance, the deposit method adds an amount to the balance, and the withdraw method subtracts an amount from the balance.

Encapsulation allows you to encapsulate the implementation details of an object and provide a public interface for using the object, making your code more maintainable and less prone to errors.

Summary

Object oriented programming is a way of creating programs using classes.

Classes are collections of data (attributes) and behaviours(methods). When we want to use the classes we create objects that we can manipulate in our programs.

Classes and objects hold information and behaviours.

Attributes are the data that an object holds, it’s variables.

Methods are an object’s actions, the things it can do. They are functions defined inside a class.

The principles of OOP guide the way you create programs and software.

Inheritance allows you to derive classes from one another.

The original class is called a superclass.

The new class is called a subclass.

☕ Enjoyed this article? Support my work with a coffee: https://www.buymeacoffee.com/cqvuesleq

Also open for technical writing and frontend dev roles!

Thank you...

Day 5 - Subroutines and Scopes

Blackie — Mon, 25 Mar 2024 12:24:07 +0000

1. Introduction

2. Subroutines

3. Control Flow

4. Procedures and Functions

5. Scope

6. Constants

Conclusions

Introduction

def calculate(a, b):
    answer = a + b
    print(f"{a} + {b} = {answer}")

num1 = 10
num2 = 15

calculate(num1, num2)

Explain exactly what you think will happen when this code is executed.
Run the code and check if you are right.

Subroutines

A subroutine is a sequence of instructions to perform a specific task with an identifiable name.

def calculate(a, b):
    answer = a + b
    print(f"{a} + {b} = {answer}")

Subroutines can be called upon whenever they are required.

def just defines the subroutine. It is not executed unless the subroutine is called.

Parameters are values passed into the subroutine. In the calculate function above, the parameters are a and b.

A subroutine call has arguments. The values held in the arguments are passed to the parameters.

def calculate(a, b):
    answer = a + b
    print(f"{a} + {b} = {answer}")

num1 = 10
num2 = 5

calculate(num1, num2) # 10 + 5 = 15

What exactly do you think are the arguments passed to the parameters?

Control Flow

The control flow differs when a subroutine call is encountered.

Instead of running statements one after another, the program transfers control ‘out of line’ to the subroutine, and the code in the subroutine is executed.

def greet(name):
  print("Hello, " + name + "!")

print("Starting program...")
greet("Alice")
print("Ending program...")

In this example, the greet function is a subroutine that takes a single argument, name. When the greet function is called, control is transferred to the code inside the function, and the message "Hello, Alice!" is printed to the console. Once the function has finished executing, control is transferred back to the main program, and the message "Ending program..." is printed.

Procedures and functions

Subroutines come in two categories:

Procedures
Functions

A procedure executes a specific set of commands when it is called. It does not return a value.

def calculate(a, b):
    answer = a + b
    print(f"{a} + {b} = {answer}")

calculate(5, 10)

A function is used to calculate or process a value based on arguments given. It always returns a value.

def calculate(a, b):
    answer = a + b
    return answer

answer = calculate(5, 10)

Note: In Python, there is no distinction between a function and a procedure.

It is important to note that when the return line is executed. The function will terminate, returning the value.

Any code after the return is executed is ignored.

Project: Create a Calculator

def add(x, y):
  return x + y

def subtract(x, y):
  return x - y

def multiply(x, y):
  return x * y

def divide(x, y):
  return x / y

num1 = float(input("Enter first number: "))
num2 = float(input("Enter second number: "))

operator = input("Would you like to +, -, / or * ? ")

if operator == "+":
  result = add(num1, num2)
  print(f"The result is {result}")
elif operator == "-":
  result = subtract(num1, num2)
  print(f"The result is {result}")
elif operator == "*":
  result = multiply(num1, num2)
  print(f"The result is {result}")
elif operator == "/":
  result = divide(num1, num2)
  print(f"The result is {result}")
else:
  print("Invalid operator")

Questions:

What exactly do you think will happen when you run the program?
How can you improve the program?

Scope

The scope of a variable is the section of the program where the variable can be accessed and modified.

Variables can either have global scope or local scope.

Global scope refers to a variable that can be accessed and modified from anywhere in the program, even from inside subroutines.

Local scope refers to variables that can only be accessed and modified within the code block that they were declared.

Not all programming languages handle scope in the same way.

Python has been designed to discourage the modification of global variables, you’ll find out why during this lesson. Variables are local unless otherwise declared.

A variable declared in the main part of the program can be accessed globally by all subroutines.
It cannot be modified unless you explicitly state that the program should modify the global variable.

def example():
    print(number)

number = 5 # global variable
example()
print(number)

What exactly will happen when you run this program?

def example():
    number = 10 
    print(number) # outputs 10

number = 5
example()
print(number) # outputs 5

The intention of this subroutine is to modify the global variable number. However, it doesn’t execute as expected.

A new variable is declared with local scope. A global variable cannot be modified unless it is explicitly stated in the program.

Here is a subroutine that will access and modify the global variable.

def example():
    global number
    number = 10
    print(number) # outputs 10

number = 5
example()
print(number) # outputs 10

Global variables are generally seen as bad practice by programmers. This is because it can be difficult to track the value of the global variable if it is modified in other areas of the program. It is also harder to test a function in isolation if it accesses global variables.

If you are tempted to use a global variable, it is a good idea to try and think carefully whether parameter passing would be a better approach.

Constants

A constant is a fixed value that doesn’t change through the execution of the program.

Constants can be helpful in programming when you need to ensure that a value stays the same throughout execution. One example of this might be the value of pi.

Not all programming languages deal with constants in the same way.

In C for example, you need to declare a constant:

const float pi=3.14;

If the program is instructed to change the value of a declared constant, then it will produce an error.

In Python it is different. Python does not have a specific feature for declaring constants. If you wish to use a constant, then you follow a naming convention.

All constants are declared using capital letters.

PI = 3.14

The Python language will still treat this as a variable and it will not produce an error message if the value is changed during execution.

The naming convention is used to let programmers know that this variable is to be used as a constant.

Example

A game designer wants to ensure that all new levels begin with the background moving at the same speed.
This start speed should be the same for all new levels.

INITIAL_SPEED = 5

def level_1():
    speed = INITIAL_SPEED
    print("Go faster? Y/N")
    answer = input()
    if answer == "Y":
        speed = speed + 5

level_1()

At the start of each new level, the speed is set by assigning the constant SPEED to the variable speed.

INITIAL_SPEED = 5

def level_1():
    speed = INITIAL_SPEED
    print("Go faster? Y/N")
    answer = input()
    if answer == "Y":
        speed = speed + 5

level_1()

As each level gets harder, the speed will increase at different rates. The speed at the beginning of each level will always be the same.

The programmer could just assign 5 to speed at the beginning of each level. This would remove the need for the constant.

def level_1():
    speed = 5
    print("Go faster? Y/N")
    answer = input()
    if answer == "Y":
        speed = speed + 5

level_1()

Question:
What would happen if the programmer decided that the start speed should be 10 instead?

They would need to go to every part of the program that referenced the start speed and change each individual value to 10.

By having a constant, the programmer can simply change the value once and it will change the value everywhere.

INITIAL_SPEED = 5

def level_1():
    speed = INITIAL_SPEED
    print("Go faster? Y/N")
    answer = input()
    if answer == "Y":
        speed = speed + 5

level_1()

Conclusion

In this lesson, we have learned about subroutines, their parameters and arguments, and how they affect control flow. We have also explored the difference between procedures and functions, and how to create a simple calculator program using functions. Additionally, we have discussed the concept of scope, including global and local scope, and the best practices for using global variables. Finally, we have learned about constants and their importance in programming. Understanding these concepts is crucial for writing efficient and well-structured code.

Day 4 of 30 Days of Python - Strings Manipulation and Formatting

Blackie — Mon, 18 Mar 2024 10:50:40 +0000

String Manipulation and Formatting

Introduction

Strings in Python are a sequence of characters, enclosed in either single quotes ('...') or double quotes ("..."). They can contain letters, numbers, special characters, and spaces. Strings are immutable, meaning that once you create a string, you cannot change its content. Here's an example of a string in Python:

my_string = "Hello, World!"

String formatting is a way to create strings by inserting variables into placeholders within the string. One of the most popular ways to format strings in Python is using f-strings, which were introduced in Python 3.6. F-strings are prefixed with the letter f or F and allow you to embed expressions inside curly braces {}. Here's an example:

name = "Alice"
age = 25
message = f"{name} is {age} years old."
print(message) # Alice is 25 years old.

F-strings offer several advantages over other string formatting methods, such as being more concise and easier to read. They also support more advanced formatting options, such as expression evaluation and string formatting specifiers. Here's an example:

pi = 3.14159
radius = 5
area = pi * radius ** 2
formatted_area = f"The area of a circle with radius {radius} is {area:.2f}."
print(formatted_area) # The area of a circle with radius 5 is 78.54.

In this example, the expression pi * radius ** 2 is evaluated and inserted into the string formatted_area. The :.2f specifier is used to format the floating-point number area with two decimal places.

Python String methods.

Strings in Python are objects that come with a set of built-in methods for performing common operations on them. These methods allow you to manipulate strings in various ways, such as searching for substrings, modifying case, removing whitespace, and more.

Here are some of the most commonly used string methods in Python:

upper(): Converts all the characters in a string to uppercase.
lower(): Converts all the characters in a string to lowercase.
title(): Converts the first character of each word in a string to uppercase, and the rest of the characters to lowercase.
strip(): Removes leading and trailing whitespace from a string.
lstrip(): Removes leading whitespace from a string.
rstrip(): Removes trailing whitespace from a string.
replace(old, new): Replaces all occurrences of the old substring with the new substring in a string.
split(sep): Splits a string into a list of substrings based on the specified separator sep.
find(sub): Returns the index of the first occurrence of the sub substring in a string, or -1 if not found.
startswith(prefix): Returns True if a string starts with the specified prefix, and False otherwise.
endswith(suffix): Returns True if a string ends with the specified suffix, and False otherwise.

Examples

text = "   Hello, World!   "
print(text.upper()) # "   HELLO, WORLD!   "
print(text.lower()) # "   hello, world!   "
print(text.strip()) # "Hello, World!"
print(text.replace("World", "Python")) # "   Hello, Python!   "
print(text.split(" ")) # ['', '', 'Hello,', 'World!', '', '']
print(text.find("World")) # 13
print(text.startswith("Hello")) # False
print(text.endswith("World!")) # True

In this example, we're using various string methods to manipulate the text string. The upper() and lower() methods are used to change the case of the string, while the strip() method is used to remove leading and trailing whitespace. The replace() method is used to replace a substring, while the split() method is used to split the string into a list of substrings. The find(), startswith(), and endswith() methods are used to search for substrings within the string.

Exercises

Now let's explore how to slice, dice, search, and replace text with ease using strip(), split(), join(), lower(), upper(), replace(), and find().

Exercise One: Palindrome Checker

Problem: Implement a program that takes a string as input and checks if it is a palindrome (reads the same forwards and backwards). Use string methods to remove whitespace and punctuation, and compare the modified string with its reverse.

Solution:
1. Import the string module: The first step is to import the string module, which provides a set of string constants and functions for manipulating strings.

import string

2. Define a function to check if a word is a palindrome: The next step is to define a function called check_palindrome that takes a string word as input and returns True if the string is a palindrome, and False otherwise.

def check_palindrome(word):

3. Convert the string to lowercase: The first step inside the function is to convert the input string to lowercase using the lower() string method. This ensures that the palindrome check is case-insensitive.

    word = word.lower()

4. Remove punctuation: The next step is to remove any punctuation characters from the string using the translate() string method and the string.punctuation constant. The translate() method takes a translation table as input, which maps each character in the string to a replacement character. In this case, we're using the maketrans() function to create a translation table that maps each punctuation character to an empty string, effectively removing them from the string.

    word = word.translate(str.maketrans("", "", string.punctuation))

5. Remove whitespace: The next step is to remove any whitespace characters from the string using the replace() string method. This ensures that the palindrome check is not affected by spaces or other whitespace characters.

    word = word.replace(" ", "")

6. Check if the string is a palindrome: The final step is to check if the string is a palindrome by reversing it using slicing with a step of -1 (word[::-1]) and comparing it to the original string. If the two strings are equal, then the input string is a palindrome.

    return word == word[::-1]

7. Get user input: The next step is to get user input using the input() function and store it in a variable called example.

example = input("Enter a word: ")

8. Call the check_palindrome function: The next step is to call the check_palindrome function with the user input as the argument and store the result in a variable called is_palindrome.

is_palindrome = check_palindrome(example)

9. Print the result: The final step is to print the result using an if statement. If the is_palindrome variable is True, then we print "Palindrome😍", otherwise we print "Not a palindrome🤣".

if is_palindrome:
    print("Palindrome😍")
else:
    print("Not a palindrome🤣")

Full Code

# imports
import string

def check_palindrome(word):
    # convert the word to lowercase
    word = word.lower()

    # remove punctuations
    word = word.translate(str.maketrans("", "", string.punctuation))

    # remove whitespaces
    word = word.replace(" ", "")

    # Reverse the string using slicing with a step of -1
    return word == word[::-1]

exaample = input("Enter a word: ")
# check_palindrome(exaample)

if check_palindrome(exaample):
    print("Palindrome😍")
else:
    print("Not a palindrome🤣")

In summary, this code defines a function called check_palindrome that takes a string as input and returns True if the string is a palindrome, and False otherwise. It then gets user input, calls the check_palindrome function with the user input, and prints the result. The function uses various string methods to preprocess the input string before checking if it's a palindrome.

Exercise 2: Password Strength Checker

Problem: Create a program that prompts the user to enter a password and evaluates its strength. Use string methods to check for various criteria such as length, presence of uppercase and lowercase letters, numbers, and special characters.

Solution:
1. Import the string module: The first step is to import the string module, which provides a set of string constants and functions for manipulating strings.

import string

2. Define a function to check if a passkey is strong: The next step is to define a function called is_passkey_strong that takes a string passkey as input and returns True if the passkey is strong, and False otherwise.

def is_passkey_strong(passkey):

3. Check passkey length: The first step inside the function is to check if the passkey is at least 8 characters long using the len() function.

    length = len(passkey) >= 8

4. Check for uppercase letters: The next step is to check if the passkey contains at least one uppercase letter using the isupper() string method and the any() function.

    uppercase_check = any(key.isupper() for key in passkey)

5. Check for lowercase letters: The next step is to check if the passkey contains at least one lowercase letter using the islower() string method and the any() function.

    lowercase_check = any(key.islower() for key in passkey)

6. Check for special characters: The next step is to check if the passkey contains at least one special character using the punctuation constant from the string module and the any() function.

    special_char_check = any(key in string.punctuation for key in passkey)

7. Check for numbers: The next step is to check if the passkey contains at least one number using the isdigit() string method and the any() function.

    number_check = any(key.isdigit() for key in passkey)

8. Check passkey strength: The final step is to check if the passkey meets all the criteria for a strong passkey. If it does, then the function returns True, otherwise it returns False.

    if (length and uppercase_check and lowercase_check and special_char_check and number_check):
        return True
    elif (length and uppercase_check and lowercase_check and special_char_check):
        return True
    elif (length and uppercase_check and lowercase_check):
        return False
    else:
        return False

9. Get user input: The next step is to get user input using the input() function and store it in a variable called user_key.

user_key = input("Kindly create a passkey: ")

10. Check passkey strength: The final step is to call the is_passkey_strong function with the user input as the argument and print the result using an if statement. If the passkey is strong, then we print "Your 🔐 is 💪", otherwise we print "Enter a strong 🔐.....", and repeat the input process until a strong passkey is entered.

while True:
    user_key = input("Kindly create a passkey: ")
    if is_passkey_strong(user_key):
        print("Your 🔐 is 💪")
        break
    else:
        print("Enter a strong 🔐.....")

Full Code

import string

def is_passkey_strong(passkey):
    # checks for strong passkey
    length = len(passkey) >= 8
    uppercase_check = any(key.isupper() for key in passkey)
    lowercase_check = any(key.islower() for key in passkey)
    special_char_check = any(key in string.punctuation for key in passkey)
    number_check = any(key.isdigit() for key in passkey)

    # check all the criteria and return the comment
    if (length and uppercase_check and lowercase_check and special_char_check and number_check):
        return True
    elif (length and uppercase_check and lowercase_check and special_char_check):
        return True
    elif (length and uppercase_check and lowercase_check):
        return False
    else:
        return False

# ask for input   

# check passkey strength
while True:
    user_key = input("Kindly create a passkey: ")
    if is_passkey_strong(user_key):
        print("Your 🔐 is 💪")
        break
    else:
        print("Enter a strong 🔐.....")

In summary, this code defines a function called is_passkey_strong that takes a string as input and returns True if the string is a strong passkey, and False otherwise. It then gets user input, calls the is_passkey_strong function with the user input, and prints the result. The function uses various string methods and the any() function to check if the passkey meets the criteria for a strong passkey. The code also uses a while loop to repeatedly prompt the user for input until a strong passkey is entered.

Exercise 3: Anagram Finder

Problem: Develop a program that takes two strings as input and determines if they are anagrams (contain the same letters but in a different order). Use string methods to remove whitespace and compare the sorted versions of the strings.

Solution:
1. Import the string module: The first step is to import the string module, which provides a set of string constants and functions for manipulating strings.

import string

2. Define a function to check if two strings are anagrams: The next step is to define a function called is_anagram that takes two strings str1 and str2 as input and returns True if the strings are anagrams of each other, and False otherwise.

def is_anagram(str1, str2):

3. Remove whitespace: The first step inside the function is to remove any whitespace characters from both strings using the replace() string method.

    str1 = str1.replace(" ", "")
    str2 = str2.replace(" ", "")

4. Remove punctuation: The next step is to remove any punctuation characters from both strings using the translate() string method and the string.punctuation constant.

    str1 = str1.translate(str.maketrans("", "", string.punctuation))
    str2 = str2.translate(str.maketrans("", "", string.punctuation))

5. Convert to lowercase: The next step is to convert both strings to lowercase using the lower() string method.

    str1 = str1.lower()
    str2 = str2.lower()

6. Sort the characters: The next step is to sort the characters in both strings using the sorted() function, which takes an iterable as input and returns a new sorted list containing the elements of the original iterable in ascending order.

    sorted_str1 = sorted(str1)
    sorted_str2 = sorted(str2)

7. Check if the sorted strings are equal: The final step is to check if the sorted strings are equal using the == operator. If they are equal, then the input strings are anagrams of each other.

    return sorted_str1 == sorted_str2

8. Get user input: The next step is to get user input using the input() function and store it in variables called input_str1 and input_str2.

input_str1 = input("Enter the first string: ")
input_str2 = input("Enter the second string: ")

9. Call the is_anagram function: The final step is to call the is_anagram function with the user input as the arguments and print the result using an if statement. If the strings are anagrams, then we print "The strings are anagrams.", otherwise we print "The strings are not anagrams.".

if is_anagram(input_str1, input_str2):
    print("The strings are anagrams.")
else:
    print("The strings are not anagrams.")

Full Code

import string

def is_anagram(str1, str2):
    # Remove whitespace from both strings
    str1 = str1.replace(" ", "")
    str2 = str2.replace(" ", "")

    # Remove punctuation from both strings
    str1 = str1.translate(str.maketrans("", "", string.punctuation))
    str2 = str2.translate(str.maketrans("", "", string.punctuation))

    # Convert both strings to lowercase
    str1 = str1.lower()
    str2 = str2.lower()

    # Sort the characters in both strings
    # sorted takes an iterable as input
    # returns a new sorted list containing the elements of the original iterable in ascending order.
    sorted_str1 = sorted(str1)
    sorted_str2 = sorted(str2)

    # Check if the sorted strings are equal
    return sorted_str1 == sorted_str2

# Test the is_anagram function
input_str1 = input("Enter the first string: ")
input_str2 = input("Enter the second string: ")

if is_anagram(input_str1, input_str2):
    print("The strings are anagrams.")
else:
    print("The strings are not anagrams.")

In summary, this code defines a function called is_anagram that takes two strings as input and returns True if the strings are anagrams of each other, and False otherwise. It then gets user input, calls the is_anagram function with the user input, and prints the result. The function uses various string methods to preprocess the input strings, and then sorts the characters in the strings and checks if the sorted strings are equal to determine if the input strings are anagrams.

Exercise 4: Text Encryption/Decryption

Problem: Build a program that encrypts and decrypts text using a simple substitution cipher. Implement string methods to manipulate the text, such as shifting characters, replacing characters, or reversing the string.

Solution:
1. Initialize the encrypted text: The first step inside the function is to initialize an empty string called encrypted_text that will be used to store the encrypted version of the input text.

encrypted_text = ""

2. Iterate over the characters in the input text: The next step is to iterate over each character in the input text using a for loop.

for char in text:

3. Replace characters with their 8-bit binary representation: For each character in the input text, the function replaces the character with its 8-bit binary representation using the format() function and the ord() function. The ord() function returns the Unicode code point of the character, and the format() function formats the code point as an 8-bit binary string using the '08b' format code.

    binary_representation = format(ord(char), '08b')  # Get the 8-bit binary representation

4. Add the binary representation to the encrypted text: The binary representation of the character is then added to the encrypted_text string, followed by a space character.

    encrypted_text += binary_representation + " "

5. Remove trailing whitespace: The final step is to remove any trailing whitespace from the encrypted_text string using the strip() string method.

return encrypted_text.strip()  # Remove trailing whitespace

6. Get user input: The next step is to get user input using the input() function and store it in a variable called input_text.

input_text = input("Enter the text: ")

7. Call the encrypt function: The final step is to call the encrypt function with the user input as the argument and store the result in a variable called encrypted_text. The encrypted text is then printed to the console using the print() function.

encrypted_text = encrypt(input_text)
print("Encrypted text:", encrypted_text)

Full Code

def encrypt(text):
    encrypted_text = ""
    for char in text:
        # Replace characters with their 8-bit binary representation
        # convert the Unicode code point of the character char to its 8-bit binary representation
        binary_representation = format(ord(char), '08b')  # Get the 8-bit binary representation
        encrypted_text += binary_representation + " "

    return encrypted_text.strip()  # Remove trailing whitespace


# Test the encryption and decryption functions
input_text = input("Enter the text: ")

encrypted_text = encrypt(input_text)
print("Encrypted text:", encrypted_text)

In summary, the encrypt function takes a string as input and returns a string containing the 8-bit binary representation of each character in the input string, separated by space characters. The function uses the format() function to convert the Unicode code point of each character to its 8-bit binary representation, and then concatenates the binary representations into a single string. The function also removes any trailing whitespace from the encrypted text before returning it. The code then gets user input, calls the encrypt function with the user input, and prints the encrypted text to the console.

Exercise 5: URL Parser

Problem: Create a program that parses a URL and extracts specific components like the protocol, domain, path, and query parameters. Utilize string methods to extract and manipulate different parts of the URL.

Solution:
1. Remove the protocol prefix: The first step inside the function is to remove the protocol prefix (if present) from the input URL using the startswith() string method and string slicing.

if url.startswith("http://"):
    url = url[len("http://"):]
elif url.startswith("https://"):
    url = url[len("https://"):]

2. Split the URL into domain and path/query parts: The next step is to split the input URL into domain and path/query parts using the split() string method. The split() method splits the input string into a list of substrings based on a specified separator. In this case, the separator is the first occurrence of the '/' character.

parts = url.split("/", 1)
domain = parts[0]
path_query = parts[1] if len(parts) > 1 else ""

3. Split the path/query part into path and query parameters: The path/query part of the URL is then split into path and query parameters using the split() string method. The separator is the first occurrence of the '?' character.

parts = path_query.split("?", 1)
path = parts[0]
query = parts[1] if len(parts) > 1 else ""

4. Return a dictionary containing the parsed URL parts: The final step is to return a dictionary containing the parsed URL parts, including the domain, path, and query parameters.

return {
    "domain": domain,
    "path": path,
    "query": query
}

5. Get user input: The next step is to get user input using the input() function and store it in a variable called input_url.

input_url = input("Enter the URL: ")

6. Call the parse_url function: The final step is to call the parse_url function with the user input as the argument and store the result in a variable called parsed_url. The parsed URL is then printed to the console using the print() function.

parsed_url = parse_url(input_url)
print("Parsed URL:", parsed_url)

Full Code

def parse_url(url):
    # Remove the protocol prefix if present
    if url.startswith("http://"):
        url = url[len("http://"):]
    elif url.startswith("https://"):
        url = url[len("https://"):]

    # Split the URL into domain and path/query parts
    parts = url.split("/", 1)
    domain = parts[0]
    path_query = parts[1] if len(parts) > 1 else ""

    # Split the path/query part into path and query parameters
    parts = path_query.split("?", 1)
    path = parts[0]
    query = parts[1] if len(parts) > 1 else ""

    return {
        "domain": domain,
        "path": path,
        "query": query
    }

# Test the URL parser
input_url = input("Enter the URL: ")

parsed_url = parse_url(input_url)
print("Parsed URL:", parsed_url)

In summary, the parse_url function takes a string as input and returns a dictionary containing the parsed URL parts, including the domain, path, and query parameters. The function first removes the protocol prefix (if present) from the input URL, and then splits the URL into domain and path/query parts using the split() string method. The path/query part is then split into path and query parameters using the split() string method. The function returns a dictionary containing the parsed URL parts. The code then gets user input, calls the parse_url function with the user input, and prints the parsed URL to the console.

Exercise 6: Sentence Capitalizer

Problem: Write a program that takes a paragraph as input and capitalizes the first letter of each sentence. Use string methods to split the paragraph into sentences, capitalize the first letter of each sentence, and join them back together.

Solution:
1. Split the paragraph into sentences: The first step inside the function is to split the input paragraph into sentences using the split() string method. The separator is the '. ' substring, which represents the end of a sentence followed by a space.

sentences = paragraph.split(". ")

2. Capitalize each sentence: The next step is to capitalize the first letter of each sentence using the capitalize() string method. This is done using a list comprehension that applies the capitalize() method to each sentence in the sentences list.

capitalized_sentences = [sentence.capitalize() for sentence in sentences]

3. Join the capitalized sentences into a paragraph: The capitalized sentences are then joined back together into a single paragraph using the join() string method. The separator is the '. ' substring, which represents the end of a sentence followed by a space.

capitalized_paragraph = ". ".join(capitalized_sentences)

4. Return the capitalized paragraph: The final step is to return the capitalized paragraph as a string.

return capitalized_paragraph

5. Get user input: The next step is to get user input using the input() function and store it in a variable called input_paragraph.

input_paragraph = input("Enter the paragraph: ")

6. Call the capitalize_sentences function: The final step is to call the capitalize_sentences function with the user input as the argument and store the result in a variable called capitalized_paragraph. The capitalized paragraph is then printed to the console using the print() function.

capitalized_paragraph = capitalize_sentences(input_paragraph)
print("Capitalized Paragraph:")
print(capitalized_paragraph)

Full Code

def capitalize_sentences(paragraph):
    sentences = paragraph.split(". ")
    capitalized_sentences = [sentence.capitalize() for sentence in sentences]
    capitalized_paragraph = ". ".join(capitalized_sentences)
    return capitalized_paragraph

# Test the program
input_paragraph = input("Enter the paragraph: ")

capitalized_paragraph = capitalize_sentences(input_paragraph)
print("Capitalized Paragraph:")
print(capitalized_paragraph)

In summary, the capitalize_sentences function takes a string as input and returns a new string with the first letter of each sentence capitalized. The function first splits the input string into sentences using the split() string method, and then applies the capitalize() string method to each sentence using a list comprehension. The capitalized sentences are then joined back together into a single string using the join() string method. The code then gets user input, calls the capitalize_sentences function with the user input, and prints the capitalized paragraph to the console.

Conclusions

In conclusion, this article has provided an introduction to some of the most commonly used string methods in Python. We have seen how to use these methods to manipulate strings in various ways, such as removing whitespace, punctuation, and special characters, checking for anagrams, encrypting and decrypting text, parsing URLs, and capitalizing sentences. These string methods are powerful tools that can help you perform complex operations on strings with just a few lines of code. By mastering these methods, you can improve your productivity and write more efficient and effective code. Whether you are a beginner or an experienced programmer, understanding how to work with strings is an essential skill that will serve you well in your programming journey.

Day 3 of 30 days of Python

Blackie — Mon, 11 Mar 2024 00:42:02 +0000

Day 3 - Selection, Conditions and Iterations

Selection 🌵

Selection statements, such as the if statement, allow you to execute different blocks of code based on certain conditions. For example, you can use an if statement to check if a number is positive, negative, or zero, and execute different code depending on the result.

You will need an if or an if, else:
when there is more than one possible path for your program to follow. For example:

print("What’s your name?")
user = input()
if user == "Elizabeth":
  print("Good morning Your Majesty")
else:
  print("Hello", user)

The condition will check if the value of user is equal to the string "Elizabeth".

The expression user == "Elizabeth" will evaluate to either True or False.

This is the if block, i.e. the code that will be executed if the condition is True.

This is the else block, i.e. the code that will be executed if the condition is False.

Only one of these blocks will be executed, depending on the value of the condition.

Relational operators in Python (comparisons)

== equal to

!= not equal to

< less than

<= less than or equal to

> greater than

>= greater than or equal to

Examples:

a == 1 Does a equal 1?

b != c Are b and c different?

d < 3 Is d less than 3?

d <= 3 Is d at most 3?

d > 10 Is d greater than 10?

d >= 10 Is d at least 10?

Projects:

Lucky Number:

lucky = 13
print("Guess my number:")
guess = int(input())
if guess == lucky:
  print("Amazing, you guessed it")
else:
  print("Sorry, it’s not", guess)
  print("My lucky number is", lucky)
print("Nice playing with you")

Questions:

What will happen when you run the above program?
How can you improve the program?
Create a dice game.

Conditions 🌿

Conditions are expressions that evaluate to True or False, and are used in selection statements to determine which block of code should be executed. For example, the condition x > 0 evaluates to True if x is greater than zero, and False otherwise.

Example:

Check if a number is positive, negative, or zero:

x = 10

if x > 0:
    print("x is positive")
elif x < 0:
    print("x is negative")
else:
    print("x is zero")

In this example, the condition x > 0 checks if x is greater than zero. If this condition is True, the code inside the if block is executed, and the message "x is positive" is printed. If the condition is False, the code inside the elif block is checked. In this case, the condition x < 0 checks if x is less than zero. If this condition is True, the message "x is negative" is printed. If neither condition is True, the code inside the else block is executed, and the message "x is zero" is printed.

Project:

Chatterbot

name = input("What is your name?").lower() 

if name == "anakin":
  print("How do you do Anakin!")
else:
  print(f"Nice name, {name}")
print(f"So {name}, is it hot or cold where you are today?")

weather = input().upper()
if weather == "COLD":
  print("You must be freezing!")
elif weather == "HOT":
  print("Drink plenty of water")
else:
  print("I can't advise you on that type of weather.")
print("Do you like the colour blue?")

likes_blue = input().capitalize()
if likes_blue == "Yes":
  print("I like blue too")
print("Have a good day! Bye!")

Questions:

What will happen when you run the code?
How can you improve the program?

Iterations🔂

Iteration statements, such as the for and while loops, allow you to execute a block of code repeatedly until a certain condition is met. For example, you can use a for loop to iterate over a list of items and perform some operation on each item, or use a while loop to repeatedly ask the user for input until they enter a valid value.

while Loop

You will need a while statement:
When your program needs to repeat actions, while a condition is satisfied.

# Get the user's input and store it in the variable "name"
name = input("What’s your name?")

# Use a while loop to repeatedly ask the user for their name until they enter the correct name
while name != "Hedy":
  # Print a message providing feedback to the user
  print("Try again Hedy")

  # Get the user's input again and update the value of "name"
  name = input()

# Print a personalized greeting to the user
print(f"Hello, {name}")

Questions:

What will happen when you run the program?
How can you improve the program?

Project:

Parson's Puzzle: A Parson's Puzzle is designed so that you can move the code around until it provides a logical solution to the problem given.

Your job is to rearrange the lines of code so that the program will:

● Ask for a word to guess

● Check if the word is not equal to Raspberry

● Continue to check if the word is not equal to Raspberry

● When the word is equal to Raspberry, it should display:
“Well done, the word was Raspberry!”

print(f"Well done, the word was {word}!")
print("Try again...")
print("Guess the word")
word = input() 
word = input()
while word != "Raspberry":

for Loop

for x in range(5):
    print(x)

What will the output be when this code is executed?

A for loop is another tool to control the flow of execution in your programs.

A while loop can do everything that a for loop can do.
However, it is more convenient to use a for loop for iterating through sequences.

When you use a for loop you are saying:
“For every element in this sequence, do this.”

for this sequence:
    do this

For loops can be used for many types of sequence, for example:

Letters in a word
Items in a list
Numbers in a range

For Example:

for x in range(5):
    print(x)

range() is the sequence that you are going to iterate through.

range() is a built-in function just like input().
It generates a sequence of numbers.

for x in range(start, end, step):
    print(x)

When you call the range function, you can pass it up to three values:

The start number
The end number
The step

If you only pass one value, then the function will use it as the last number and the sequence will start at 0.

for x in range(5):
    print(x)

When you call the range function, it will generate a sequence of numbers:
0, 1, 2, 3, 4

Note: The end number is not included in the generated sequence, because it is used as the stop point.

x is the variable that is used to iterate through this sequence.

0, 1, 2, 3, 4

Project:

Times table Generator

times_table = 5
answer = 0
print(f"Here is the {times_table} times table")
for x in range(1,11):
    answer = x * times_table
    print(f"{x} times {times_table} is {answer}")

Questions:

Take a look at the code above. Read it carefully and try to make a prediction about the output of this program when it is executed.
In the first iteration, what is the value of x?
Line 4 has the code range(1,11).
Change the values to range(2,22).
What is the second line that is output for display?
What is the final line that is output for display?
Change the values passed in range so that the times table generator will output the 5 times table from 1 to 12.
Introduce an input() to the program to allow the user to enter the times table that they wish to create.

☕ Enjoyed this article? Support my work with a coffee: https://www.buymeacoffee.com/cqvuesleq

Also open for technical writing and frontend dev roles!

Day 2 of 30 days of Python

Blackie — Mon, 04 Mar 2024 09:59:26 +0000

Day 2: Lists and Dictionaries

Mastering lists and dictionaries in Python involves understanding their functionalities, properties, and common operations. Here's a comprehensive breakdown to get you started:

Lists:

Definition: An ordered collection of items enclosed in square brackets []. Elements can be of any data type, including other lists and dictionaries.
Creation:

my_list = [1, "hello", 3.14, [True, False]]

Accessing elements: Use zero-based indexing starting from [0]. Negative indices access from the end ([-1] is the last element).

first_element = my_list[0]  # first_element will be 1
last_element = my_list[-1]  # last_element will be [True, False]

Slicing: Extract a sublist using colon (:) notation. [start:end:step]:
- start (inclusive): index of the first element to include (defaults to 0).
- end (exclusive): index of the element after the last element to include (defaults to the end of the list).
- step: the difference between consecutive elements to include (defaults to 1).

sublist = my_list[1:3]  # sublist will be ["hello", 3.14]

Common operations:
- append(element): Add an element to the end of the list.
- insert(index, element): Insert an element at a specific index.
- remove(element): Remove the first occurrence of an element.
- pop(index): Remove and return the element at a specific index (or the last element by default).
- len(list): Get the length of the list (number of elements).
- sort(): Sort the list in ascending order (modifies the original list).
- reversed(): Return a reversed iterator for the list (doesn't modify the original list).

Exercises:

Print out a list of items in reversed form
Find the sum of the items.
Find the largest of the items in a list.
Find the length of the list.
Remove the odd number from the list.

Solutions

Print out a list of items in reversed form

original_list = [1, 2, 3, 4, 5]
reversed_list = original_list[::-1]

print("Original list:", original_list)
print("Reversed list:", reversed_list)

Output

Original list: [1, 2, 3, 4, 5]
Reversed list: [5, 4, 3, 2, 1]

Find the sum of the items.

original_list = [1, 2, 3, 4, 5]
total = sum(original_list)
print(total)

Output

15

Find the largest of the items in a list.

original_list = [1, 2, 3, 4, 5]
largest = max(original_list)
print(largest)

Output

5

Find the length of the list.

original_list = [1, 2, 3, 4, 5]
length = len(original_list)
print(length)

Output

5

Remove odd numbers from the list

original_list = [1, 2, 3, 4, 5]

even_number = [num for num in original_list if num%2 == 0]
print(even_number)

Output

[2, 4]

Dictionaries:

Definition: An unordered collection of key-value pairs enclosed in curly braces {}. Keys must be unique and immutable (e.g., strings, numbers, tuples), while values can be any data type.
Creation:

my_dict = {"name": "Alice", "age": 30, "hobbies": ["reading", "hiking"]}

Accessing elements: Use the key enclosed in square brackets [] to access the corresponding value.

name = my_dict["name"]  # name will be "Alice"

Common operations:
- get(key, default): Get the value for a key, returning default if the key is not found.
- keys(): Return a view of all keys in the dictionary.
- values(): Return a view of all values in the dictionary.
- items(): Return a view of all key-value pairs as tuples.
- in: Check if a key exists in the dictionary.
- update(dict2): Update the dictionary with key-value pairs from another dictionary (dict2).
- pop(key, default): Remove the key-value pair and return the value, or default if the key is not found.

Exercises:

Print all names, email addresses and the key-value pairs in a dict.
Check if a user exist in a dict.
Update the info in the dict.

Solutions:

Print all names, email addresses and the key-value pairs in a dict.
Check if a user exist in a dict
Update the info in the dict.

Projects

Simon Says: To create this program, define a list called simon_says that contains five different instructions for the user to follow. The program should then prompt the user to pick a number between 0 and 4, and store the user's input in a variable called index. The program should use the value of index to select an instruction from the simon_says list, and then print the instruction to the screen using the print function. The program should display a message that says "Simon says..." followed by the selected instruction.
Sandwich Order: Create a program to calculate a sandwich order and print the total cost.

## Solutions
Simon Says

Sandwich Order

Forem: Blackie

Python Day 13: Creating a Simple Todo App with Django

Python Day 12: Django or Flask

Python Day 11 | Mastering SQL: A Beginner's Guide to Database Management

Introduction

Database Key Terms

SQL

SQL Searches

Data Types

Insert, update, delete

Inserting data

Updating Data

Deleting Data

Solutions:

Python Day 10 - Meme Magic 😍: Building a Custom Meme Generator with Python

Contents

Say Hello Taipy!

Create a meme generator with TaipyGUI:

Bonus Tips: Improve the Layout

Hosting on Taipy Cloud

Conclusion

Python Day 9: Building Interactive Web Apps without HTML/CSS and JavaScript

Introduction

Meet Taipy!

Data and AI Algorithms into Production-Ready Web Apps

Why Taipy?

Explore Apps Built with Taipy

Building Web Apps with Taipy

Project One: Personal Details Generator

Project 2: Image Background Remover 🤖

Conclusions

Don't Forget to ⭐️ the Official Repo

Day 8: File Handling and I/O Operations

Contents

Introduction

Handling Files

Key File Handling Techniques

Open and read a text file

CSV Files

Reading a CSV File

Write to CSV File

Writing a List of Numbers to a CSV File in Python

Step 1: Create a List of Numbers

Step 2: Convert the Numbers to Strings

Step 3: Join the Strings into a Single String

Step 4: Open the File in Write Mode

Step 5: Write the Data to the File

Step 6: Close the File

Conclusion

Day 7: GUIs: Graphical User Interface

Contents

Introduction

Install and Setup Guizero

Project One: Hello GUI

Project Two: Lost Cat

Project Three: Dice Roll Game

Project Four: Create a username generator

Project Five: Create a meme Generator

Project Six: Pop-ups

Project Seven: Calculator App

Project Eight: Tic Tac Toe Game

Summary

References

Day 6 - Object Oriented Programming

Day 6: Object Oriented Programming

Table of Contents

For Example:

Creating A Template for An Object

Creating An Instance of Bank_account

Creating getters for an object

Creating set methods

Inheritance

Polymorphism

Encapsulation

Summary

Day 5 - Subroutines and Scopes

Table of Contents

Introduction

Subroutines

Control Flow