Forem: Duncan Ndegwa

CSS Flexbox

Duncan Ndegwa — Fri, 27 Feb 2026 06:50:26 +0000

Introduction to CSS Flexbox

Flexbox (Flexible Box Layout) is a CSS layout model designed to arrange elements in a single row or column efficiently.

It helps with:

Aligning items horizontally and vertically
Distributing space between items
Creating responsive layouts
Handling dynamic content sizes

Flexbox works best for one-dimensional layouts (row OR column).

Prerequisites

To follow along with this tutorial it is assumed that you have a basic knowledge of HTML.

Install a text editor such as Vs Code, Sublime text, notepad, or any other text editor you are comfortable with.

Basic Terminology

Before using Flexbox, understand these key terms:

Flex Container – The parent element that holds flex items
Flex Items – The children inside the flex container
Main Axis – The primary direction (row or column)
Cross Axis – The perpendicular direction to the main axis

Creating a Flex Container

A flexbox always consists of:

A Flex Container - The parent (container) element, where the display property is set to flex or inline-flex
One or more Flex Items - The direct children of the flex container automatically becomes flex items

<html>
<head>
<style>
.container {
  display: flex;
  background-color: DodgerBlue;
}

.container div {
  background-color: #f1f1f1;
  margin: 10px;
  padding: 20px;
  font-size: 30px;
}
</style>
</head>
<body>

<div class="container">
  <div>Item 1</div>
  <div>Item 2</div>
  <div>Item 3</div>
</div>

</body>
</html>

CSS Flex Container Properties

The flex container element can have the following properties:

display - Must be set to flex or inline-flex
flex-direction - Sets the display-direction of flex items
flex-wrap - Specifies whether the flex items should wrap or not
flex-flow - Shorthand property for flex-direction and flex-wrap
justify-content - Aligns the flex items when they do not use all available space on the main-axis (horizontally)
align-items - Aligns the flex items when they do not use all available space on the cross-axis (vertically)
align-content - Aligns the flex lines when there is extra space in the cross axis and flex items wrap

CSS flex-direction Property

The flex-direction property specifies the display-direction of flex items in the flex container.
This property can have one of the following values:

row (default)
column
row-reverse
column-reverse

Example

The column value displays the flex items vertically (from top to bottom):

<!DOCTYPE html>
<html>
<head>
<style>
.container {
  display: flex;
  flex-direction: column;
  background-color: DodgerBlue;
}

.container div {
  background-color: #f1f1f1;
  width: 100px;
  margin: 10px;
  padding: 10px;
  text-align: center;  
  font-size: 30px;
}
</style>
</head>
<body>

<div class="container">
  <div>1</div>
  <div>2</div>
  <div>3</div>  
</div>

</body>
</html>

CSS flex-wrap Property

The flex-wrap property specifies whether the flex items should wrap or not, if there is not enough room for them on one flex line.

This property can have one of the following values:

nowrap (default)
wrap
wrap-reverse ### Example The wrap value specifies that the flex items will wrap if necessary:

<!DOCTYPE html>
<html>
<head>
<style>
.container {
  display: flex;
  flex-wrap: wrap;
  background-color: DodgerBlue;
}

.container div {
  background-color: #f1f1f1;
  width: 100px;
  margin: 10px;
  padding: 10px;
  text-align: center;  
  font-size: 30px;
}
</style>
</head>
<body>

<div class="container">
  <div>1</div>
  <div>2</div>
  <div>3</div>  
  <div>4</div>
  <div>5</div>
  <div>6</div>  
  <div>7</div>
  <div>8</div>
  <div>9</div>  
</div>

</body>
</html>

Result

Conclusion

In this article, we learned that Flexbox is a one-dimensional CSS layout system used to arrange items in rows or columns.
We understood the difference between a flex container and flex items.
We explored properties like flex-direction and flex-wrap.
Flexbox makes alignment and responsive design much easier.

Working with GitHub API in Python

Duncan Ndegwa — Fri, 15 Aug 2025 09:28:39 +0000

This article will be an introduction to understanding GitHub API. We will build a repository summarizer using Python. We will also request information related to Python projects on GitHub using the GitHub API.

When fetching information from the web, we usually request for complete web pages, and extract information by parsing the HTML scripts. Similarly, an Application Programming Interface (API) performs the same operation in a more efficient way.

This tutorial will teach you how to create a self-contained application that generates a summary based on the information it obtains through the API.

GitHub is a website where programmers can contribute to various open-source projects.

In this article, we will request information related to Python projects on GitHub using the Github API. We will also summarize information that we've obtained using the API.

Prerequisites

As a prerequisite, you must have a little understanding of Python to follow the tutorial along.

Objectives

In this article we will go through:

Using an API call to request data.
Installation of requests library.
Keeping track of an API response.
Using the response dictionary.
Summing up the top repositories.

Requesting data using an API call

GitHub's web API allows you to make API requests for a range of data.

Type the following into your web browser URL bar and press Enter to see how an API call appears like:

https://api.github.com/search/repositories?q=language:python&sort=stars

Let's examine the parts of the API call:

https://api.github.com/ - sends the request to the GitHub web server that handles API calls.
search/repositories - is the endpoint that informs the API to search across all of GitHub repositories.
? - indicates that an argument is about to be passed.
q=- the character q stands for query.
language:python - that queries repositories that use only Python as their main language.
&sort=stars - the projects are sorted by the number of stars they have gotten.

Upon fetching the API data, the response will look like:

{
  "total_count": 7668509,
  "incomplete_results": false,
  "items": [
    {
      "id": 54346799,
      "node_id": "MDEwOlJlcG9zaXRvcnk1NDM0Njc5OQ==",
      "name": "public-apis",
      "full_name": "public-apis/public-apis",
      --snip--

NOTE: The output above shows only the first few lines of the response.
Let's examine the output:

In the second line of the result, you can see that GitHub has detected a total of 7668509 Python projects.

We know the request was successful if the value for incomplete results is false.

The key items holds a list of objects that contains information of the Python-based projects on GitHub. Let's try to explore more information by parsing the API's output using Python. ### Installing requests The requests package enables us to request data from the website and evaluate the result easily using a Python program. Run the following command to install requests:

pip install --user requests

Visit this link, if this is your first time using pip for installing packages.

Processing an API response

To fetch the most starred Python projects on GitHub, we'll start writing a program that will make an API call and evaluate the data as shown:

import requests

# Create an API request 
url = 'https://api.github.com/search/repositories?q=language:python&sort=stars'
response = requests.get(url)
print("Status code: ", response.status_code)
# In a variable, save the API response.
response_dict = response.json()
# Evaluate the results.
print(response_dict.keys())

Let's understand the code snippet above:

We begin by importing the requests module.
Then, we use the requests package to make the API call to the particular url using get().
The API response is saved by a variable called response.
The status_code attribute of the response object indicates if the request was complete.
A successful API call returns the status_code 200, while an unsuccessful one returns 500.
Then, we use the json() function to convert the information from JSON format to a Python dictionary.
We store the converted JSON in response_dict. Then, we print the keys from response_dict, which are as follows:

Status code: 200
dict_keys(['items', 'total_count', 'incomplete_results'])

Using the response dictionary

Now, let's make a report that sums up all the information.
Here, we will be calculating the total number of available repositories with language as Python, and fetch all the keys under items as shown:

print("Total repos:", response_dict['total_count'])
# find total number of repositories
repos_dicts = response_dict['items']
print("Repos found:", len(repos_dicts))
# examine the first repository
repo_dict = repos_dicts[0]
print("Keys:", len(repo_dict))
for key in sorted(repo_dict.keys()):
 print(key)

Let's understand the code snippet above:

The value linked with the total_count reflects the count of GitHub Python projects available.
The value of items is a list of dictionaries, each providing information about a single Python repository.
The list of dictionaries is then saved in repos_dicts.
We select the first item from repos_dicts to look more closely at the information given about each repository.
Finally, we print the all of keys of an item. Output:

Status code: 200
Total repos: 7694326
Repos found: 30
Keys: 74
archive_url
archived
assignees_url
--snip--
url
watchers
watchers_count

The GitHub API gets back a range of data for every repository like:

status_code as 200.
Total number of repos as 7694326.
Total number of repos found as 30.
Each repository repo_dict having 74 keys. You may get a sense of the type of information you can get about a repository by observing these keys. Let's have a look at what some of the keys in repos dict entail:

# Find out more about the repositories.
repos_dicts = response_dict['items']
print("Repositories found:", len(repos_dicts))
# Examine the first repository.
repo_dict = repos_dicts[0]
print("\nThe following is some information regarding the first repository:")
print('Name:', repo_dict['name'])  #print the project's name
print('Owner:', repo_dict['owner']['login'])  #use the key owner and the the key login to get the dictionary describing the owner and the owner’s login name respectively.
print('Stars:', repo_dict['stargazers_count'])  #print how many stars the project has earned
print('Repository:', repo_dict['html_url'])  #print URL for the project’s GitHub repoitory
print('Created:', repo_dict['created_at'])  #print when it was created
print('Updated:', repo_dict['updated_at'])  #show when it was last updated
print('Description:', repo_dict['description']) #print the repository’s description

Output:

Status-code: 200
Total repos: 7588335
Repositories found: 30

The following is some information regarding the first repository:
Name: public-apis
Owner: public-apis
Stars: 144904
Repository: https://github.com/public-apis/public-apis
Created: 2016-03-20T23:49:42Z
Updated: 2021-07-31T13:15:51Z
Description: A collective list of free APIs

Examining the output:

You can observe that the most popular Python repository on GitHub is public-apis.
Owner of the repository is public-apis.
It has been starred more than 140,000 times.
Project was created on the date of 2016 March.
Project description of public-apis is collective collection of open APIs. ### Summing up the top repositories We'll try to analyze more than one repository. Let's create a loop that prints specified information about each of the repositories supplied by the API call:

 --snip--
# Find out more about the repositories.
repos_dicts = respons_dict['items']
print("Repositories found:", len(repos_dicts))
print("\nListed details on each repository:")
for repos_dict in repos_dicts:   #loop through all the dictionaries in repos_dicts.
    print('\nName:', repos_dict['name'])
    print('Owner:', repos_dict['owner']['login'])
    print('Stars:', repos_dict['stargazers_count'])
    print('Repository:', repos_dict['html_url'])
    print('Description:', repos_dict['description'])

We print the name of each project, its owner, the number of stars it has, its GitHub URL, and the project's description inside the loop:

Name: public-apis
Owner: public-apis
Stars: 144910
Repository: https://github.com/public-apis/public-apis
Description: A collective list of free APIs
Name: system-design-primer
Owner: donnemartin
Stars: 139818
Repository: https://github.com/donnemartin/system-design-primer
Description: Learn how to design large-scale systems.
--snip--
Name: Python
Owner: TheAlgorithms
Stars: 113616
Repository: https://github.com/TheAlgorithms/Python
Description: All Algorithms implemented in Python

Conclusion

In this tutorial, we have gone over the following:

Using an API call to request data.
Installing requests.
Processing an API response.
Using the response dictionary.
Summing up the top repositories. You can check out the full code here. Happy coding. ### Further reading
How to use GitHub API in Python?.

Getting Started with Loops and Standard Inputs in Python

Duncan Ndegwa — Fri, 08 Aug 2025 05:38:56 +0000

As a programmer, many programs that you'll write will solve an end user's problem. You will always want to get some data from the user. This article will explain how to handle user input and how to use while loops.

Prerequisites

Python installed on your computer.
Basic Python knowledge.

Objectives

In this article we will go through:

How the input() function works
Using int() to accept numerical input
Introduction to while loops
Using the while loop with the else statement
Exiting the while loop using break
Removing all instances of specific values from a list using a while loop
Filling a dictionary with user input using a while loop

How the input() function works

The input() function halts the execution of a program and waits for the user to key in some data. When Python receives the user's input, it stores the input in the variable that you choose to work with.

For example, let's create a program that accepts a user's name and prints back the name.

name = input("Please enter your name: ")
print(name)
#output
#Please enter your name: John
#John

The input() function takes in one argument, that is, the instruction you want the user to see. In this example, Python executes the first line and requests the user to input his/her name. The program execution will halt and wait for the user to input his/her name and continue after pressing ENTER key on the keyboard. The name of the user is then loaded in the variable name, then print(name) displays the user's name back.

Using int() to accept numerical input

Any text the user input using the input() function, is interpreted as a string. If you only need to print out the input then using the input() function is sufficient. Using the input directly as a numerical value throws an exception. Consider the example below:

amount = input("Please enter your amount? ")
rate=0.056
interest= amount*rate
print("Your interest is : ")
print(interest)

The example above throws an error because Python interprets the input amount as a string. Python can't multiply a string and float.

To solve the above problem we use the int() function which informs Python to use the input as a numeric value. The int() function converts the string to integer, shown below:

amount = input("Please enter your amount? ")
amount=int(amount)
rate=0.056
interest= amount*rate
print("Your interest is : ")
print( interest)

Output:

Please enter your amount? 9000
Your interest is : 
504.0

When we input 9000 in the above example, Python interprets it as a string. The amount is then converted to an integer using the int() function. Now Python calculates the value of the interest.

Introducing while loops

In python, a while loop executes a given block of code provided that certain condition remains true.

Syntax:

while expression:
 statement(s)

The following while loop counts from 10 to 15:

count = 10
while (count <=15):
 print ('The count is:', count)
 count = count + 1 #add 1 to count
#output
#The count is: 10
#The count is: 11
#The count is: 12
#The count is: 13
#The count is: 14
#The count is: 15

The while loop continues to execute if the value of count is equal to or less than 15.

Using else statement with while loop

When you use the else statement in a while loop, it will only execute when the condition becomes false.

The example below involves both the else statement and the while statement.

count = 10
while (count <=15):
 print ('The count is:', count)
 count = count + 1
else:
 print(count, " is not less than 5")

The above program prints a number less or equal to 15, otherwise the else block executes.

Results:

The count is: 11
The count is: 12
The count is: 13
The count is: 14
The count is: 15
16 is not less than 15

Using break to exit a loop

Use the break statement to exit a while loop without executing any remaining code in the loop. With the break statement you can control which lines of your program will execute or not.

Syntax:

while expression:
 #code for while loop
 if_expression:
 break
 #code for while loop
# code outside of while loop

Example:

i = 1
while i < 11:
 if i == 6:
 break
 print(i)
 i = i + 1
print('Bye')
#output
#1
#2
#3
#4
#5
#Bye

Removing all instances of specific values from a list using a while loop

The remove() method only removes a single value from a list. We remove all occasions of a value from a list using the while loop.

Say we have a list of employees and the name John appears more than once. We can remove all instances of the name John using the while loop. The while loop executes until John is no longer in the list as illustrated below:

employees = ['Mary', 'John', 'Paul', 'John', 'Yusuf', 'John'] #list containing many instances of 'John'
print(employees) # ['Mary', 'John', 'Paul', 'John', 'Yusuf', 'John']
while 'John' in employees:
 employees.remove('John')
print(employees) #['Mary', 'Paul', 'Yusuf']

Filling a dictionary with user input using a while loop

We use the while loop to prompt the users to enter as much input as we need. Let's create a program that accepts the username and the name of the mountain that each user likes to climb. Since we want to connect each response with a particular user, we will store data in a dictionary.

responses = {} # define an empty dictionary
# Set a flag to show that polling is active.
polling_active = True
while polling_active:
# Prompt for the person's name and response.
 name = input("\nEnter your name? ")
 response = input("Enter the name of the mountain you would like to climb? ")
 responses[name] = response # Store the response in the dictionary:
 # Find out if anyone else is going to take the poll.
 repeat = input("Please refer another person? (yes/ no) ")
 if repeat == 'no':
 polling_active = False
print("\n....Poll Results...")
for name, response in responses.items():
 print(name + " wishes to climb " + response + ".") # print results of the poll

When you execute this program and enter some responses, the output should look like this:

Enter your name? Peter
Enter the name of the mountain you would like to climb? Everest
Please refer another person? (yes/ no) yes
Enter your name? John
Enter the name of the mountain you would like to climb? Turin
Please refer another person? (yes/ no) no
....Poll Results...
Peter wishes to climb Everest.
John wishes to climb Turin.

Conclusion

Now that you have learned how to use the input() function and while loops, try implementing them in your Python programs.

Happy coding!

How to Store Your Python Functions into Modules

Duncan Ndegwa — Fri, 08 Aug 2025 05:34:21 +0000

In Python, you can save the definitions of functions in a file called a module. It is possible to import module definitions into your program file.

We can save our Python functions in their own file, which is a module, then the module is imported to the main program.

To have the module available within the current program, an import statement is used to transfer it to the running program.

When separate files are used to store functions, the program's code details are hidden and a higher level of logic for the program code is attained.

Storing your functions in different files has the following advantages:

The functions can be re-used in other different programs.
It is easier to share the files in which the functions are stored, without having to share an entire program.
Through importing functions, one is able to use function libraries that other programmers have written.

We can import these modules in different ways, such as:

Importing an entire module.
Importing specific functions.
Using as to give a function an alias.
Using as to give a module an alias.
Importing all functions in a module.

Prerequisites

In order to follow through with this article, a clear understanding of Python modules is required.

Importing an entire module

The first step is to create a module, which is a file that has an ending of .py and containing the program you want to import to your main program.

Below is a module with the function make-bread().
This is the file bread.py:

def make_bread(height, *garnish);
""" summarrize the bread we are about to make"""
print("\Making a "+ str(height) + "-inch bread with the following garnish :")
for garnish in garnishes;
print("-" + garnish)

We can have another separate file making_breads.py whose storage directory is similar to that of bread.py. The file make_breads.py imports the module and calls the file make_bread() twice.

This is the file, making_breads.py:

import bread

bread.make_bread(11,'basil')
bread.make_bread(14,'garlic flakes', 'oregano', 'rolled oat flakes')

A command from the line import bread opens and copys all the functions from the program in the file bread.py.

Abstraction of the data from the user takes place such that one does not understand what happens in the background.

All one needs to know is that any function that is defined in bread.py will be made available in the file make_breads.py.

We call a function from an imported module by entering the module name imported and the function name separated by a dot.

The result of the program will be similar whether a module is imported or not.

The output should be as follows:

Making a 11-inch bread with the following garnish:
-basil

Making a 14-inch bread with the following garnish:
-garlic flakes
-oregano
-rolled oat flakes

Syntax of importing an entire module:

import module_name
module_name.name_of_function()

All functions within the module name are imported without an exception.

Importing specific function

You can as also import just a specific function from a module.

The syntax when importing a specific function:

from module_name import name_of_function

Importing various specific functions from a module is made possible by separating the function's name with a comma:

from module_name import first-function, second_function, third_function

From the file make_bread.py we import the specific functions we are using which are:

from bread import make_bread
make_bread(11,'basil')
make_bread(14,'garlic flakes', 'oregano', 'rolled oat flakes')

Note: Anytime we call the function using this syntax, we do not use the dot notation since the function was explicitly imported in the import declaration. We only call it by name any time we need to use the function.
This is a better option when you are not required to import an entire module and all the functions won't be put into use.

Giving a function an alias using 'as'

An alias is used mainly when the function name is too long or when the function name is similar to another name in the program.

If in any of the instances occur, we use an alias that is an alternate name similar to that of the function.

The general syntax of using an alias is as shown below:

from module_name import function_name as fn

From the function make_bread() we give an alias mb(). We use mb as the function name since the keyword renames the function to the alias.

from bread import make_bread as mb
mb(11,'basil')
mb(14,'garlic flakes', 'oregano', 'rolled oat flakes')

The import statement renames the function name to the alias. In this case, the function make_bread() is renamed as mb().

Anytime we need to call the function make_bread() we can use the alias mb() and the program will still run the function make_bread().

The alias avoids any confusion with another function that might be written in the program as make_bread().

Giving a module an alias using 'as'

An alias of a module can be given based on the module name. Providing an alias for a module makes it easier to call the module's function.

The syntax when giving a module an alias:

import name_of_module as nm

We can call bread.make_bread() more precisely as b.make_bread() as shown in the example below:

import bread as b
b.make_bread(11,'basil')
b.make_bread(14,'garlic flakes', 'oregano', 'rolled oat flakes')

Giving an alias to a module does not change the function names, instead they retain their original names.

Using the alias name for the module is not only concise but also enables you to concentrate on the informative names of the function, thus, redirecting your attention from the name of the module.

These function names will tell you what the function does, to enable the readability of your code rather than using the full name of the module.

Importing all functions in a module

To import all the functions in a module we use the asterisk (*) in the import statement. The asterisk gives a command that all the function should be copied into the program file.

The syntax of importing all functions in a module is as follows:

from name_of_module import *

Functions can be called without using the dot notation.

In instances where we are working with large modules that you did not write, it is not appropriate to use this approach.

from bread import *
make_bread(11,'basil')
make_bread(14,'garlic flakes', 'oregano', 'rolled oat flakes')

If several functions are saved under the same name, the code will not import the functions separately. Instead, it will overwrite all the functions.

Errors and the unexpected output may result due to the matching of the function names and other existing names in the function.

Conclusion

In the tutorial above we have been able to look at how easy and important it is to import functions and modules.

We have looked at:

Importing an entire module that is an entire module and all its properties.
Importing a specific function, when that is the only function that is needed.
Using as to give a function an alias, that is giving a shorter or simpler name for the function and using as to implement that change.
Using as to give a module an alias we used the alias to simplify the module name or make it different.
Importing all functions in a module we imported all the functions in a module regardless of whether they are being used and we use an asterisk.

I hope you find this tutorial helpful!

Happy coding!

Working with Lists and Dictionaries in Python

Duncan Ndegwa — Thu, 07 Aug 2025 07:36:03 +0000

Lists and dictionaries are one of the most often used data structures in Python for data storage and arrangement. This tutorial will explain how to carry out access, modify operations, etc., on lists and dictionaries.

Prerequisites

To follow along with this tutorial, you will require some knowledge of Python.

Creating a list

Lists enable you to store a set of items in place. Lists take the form of arrays in other languages like Java.

A list in Python is created using the following syntax:

listname = [item1, item2, item3, ...]

The following is an example of a list of cars:

cars = ['Volvo', 'Subaru', 'Skyline', 'Ford']

print(cars) # ['Volvo', 'Subaru', 'Skyline', 'Ford']

Accessing elements in a list

You can access elements in a list using the square bracket notation. Indices begin at 0, not 1, hence the first item in a list takes index 0, not 1.

The syntax for accessing elements in a list is shown below.

listname = [item1,item2,item3]
print(listname[indexvalue])

The following code requests for the cars at index 0 and 3:

cars = ['Volvo', 'Subaru', 'Skyline', 'Ford']

print(cars[0]) # Volvo
print(cars[3]) # Ford

Python has a unique way of getting the last item in a list. If you print an item at index -1, Python gives back the last item in the list. Indices -2,-3, and -4 gives the second last, third last, and fourth last item respectively.

cars = ['Volvo', 'Subaru', 'Skyline', 'Ford']

print(cars[-1])   # Ford

Changing elements in a list

To alter an item in the list, we can assign a new value using square bracket notation.

For instance, in our list of cars, the second item is Subaru. Let’s change the value to Suzuki.

cars = ['Volvo', 'Subaru', 'Skyline', 'Ford']

print(cars)      # ['Volvo', 'Subaru', 'Skyline', 'Ford']
cars[1]='suzuki' 
print(cars)      # ['Volvo', 'Suzuki', 'Skyline', 'Ford']

Adding elements to a list

To add new elements at the end of the list, use the .append() method.

For example, let’s add Audi to our list of cars.

cars = ['Volvo', 'Subaru', 'Skyline', 'Ford'] 

cars.append('Audi') # adds 'Audi' at the end of the list
print(cars)         # ['Volvo', 'Subaru', 'Skyline', 'Ford', 'Audi']

You can also use the .insert() method to add a new item at any position in your list, by specifying the position and value of the new item.

Let’s take a look at this example:

cars = ['Volvo', 'Subaru', 'Skyline', 'Ford']

cars.insert(2,'Audi') # adds 'Audi' at the beginning of the list (at index 2)
print(cars)           # ['Volvo', 'Subaru', 'Audi', 'Skyline', 'Ford']

All the other values in the list are shifted to the right.

Removing elements from a list

If the location of an item that you want to do away with is well known, you can use the del statement.

Example:

cars = ['Volvo', 'Subaru', 'Skyline', 'Ford']
del cars[0]
print(cars) # ['Subaru', 'Skyline', 'Ford']

The first car, i.e. Volvo is removed from the list.

If the value of the item you want to remove is known, use the .remove() method.

To illustrate this, let’s remove the item Subaru from our list of cars.

cars = ['Volvo', 'Subaru', 'Skyline', 'Ford']

cars.remove('Subaru') # removes Subaru from the list
print(cars)           # ['Volvo', 'Skyline', 'Ford']

NOTE: When a value appears more than once in a list, the .remove() method only deletes the first occurrence of the value.

Sorting a list

Sorting is organizing your list by some basis, e.g. reverse order, ascending order, or alphabetical order.

To sort a list, use the .sort() method. To understand this better, let's arrange our list of cars alphabetically.

cars = ['Volvo', 'Subaru', 'Skyline', 'Ford']

cars.sort()  # arranges the list alphabetically
print(cars)  # ['Ford', 'Skyline', 'Subaru', 'Volvo']

The .reverse() method is used to reverse the order of the list. For instance, let's print our list of cars in reverse.

cars = ['Volvo', 'Subaru', 'Skyline', 'Ford']

cars.reverse()
print(cars)    # ['Ford', 'Skyline', 'Subaru', 'Volvo']

NOTE: .reverse() doesn’t sort alphabetically backward. It just reverses the order of the list.

Slicing a list

To derive a segment, you need to specify the index of the first element and where to stop slicing.

In Python, we use a colon(:) as a slicing operator. Slicing follows the following syntax.

list_name[Index_start:Index_end]

For example, when you request [0:3], Python returns the items at index 0, 1, and 2.

To illustrate this, let's take a look at the following code.

cars = ['Volvo', 'Subaru', 'Skyline', 'Ford', 'Isuzu']

print(cars[0:3]) # ['Volvo', 'Subaru', 'Skyline']

When you exclude the starting index in a slice, Python automatically begins the slice at the start of the list. Similarly, if you omit the last index, Python returns all elements in the list from the first one.

cars = ['Volvo', 'Subaru', 'Skyline', 'Ford', 'Isuzu']

print(cars[:3]) # ['Volvo', 'Subaru', 'Skyline']
print(cars[3:]) # ['Ford', 'Isuzu']

Looping through a list

To perform an action to each element in a list, we can use the for loop.

For instance, let’s assume we have a list of cars and we want to pull out each name in the cars list.

cars = ['Volvo', 'Subaru', 'Skyline', 'Ford', 'Isuzu']  # initiate the list

for car in cars:
    print(car)

# Volvo
# Subaru
# Skyline
# Ford
# Isuzu

The line: for car in cars, tells Python to pull a car from the cars list and save it in the variable car. The line: print (car), then prints the name that was stored in the variable car. This line is re-executed for each item.

Dictionaries

In Python, a dictionary is a group of key:value pairs where each key is linked to a value. A dictionary is enclosed with curly brackets {}, with a series of key:value pairs inside.

A dictionary follows the following syntax:

dict_name={
    key:value,
    key:value}

Example:

stock_1={
    'type':'Volvo',
    'color':'Black'
}

print(stock_1) # {'type': 'Volvo', 'color': 'Black'}

Accessing values in a dictionaries

You can access values using the square brackets notation. To get a value, place its related key inside the square brackets as shown below.

stock_1={
    'type':'Volvo',
    'color':'Black'
}

print(stock_1['type'])  # Volvo

Adding items to a dictionary

To add a new item into a dictionary, give a value to a new key. Let’s add a new key: year to our stock_1 dictionary, and assign it the value 2014.

stock_1={
    'type':'Volvo',
    'color':'Black'
}

print(stock_1)        # prints the initial dictionary
stock_1['year']=2014  # Adding a new key:value
print(stock_1)        # returns the modified dictionary

Changing values in a dictionary

You can change a value in a dictionary by referring to its key name.

For example, let’s change the value of the year in our stock_1 dictionary from 2014 to 2021.

stock_1={
    'type':'Volvo',
    'color':'Black',
    'year':2014
}

stock_1['year']=2021  # change the value of year from 2014 to 2021
print(stock_1)        # {'type': 'Volvo', 'color': 'Black', 'year': 2021}

Removing key:value pairs from dictionaries

To remove a key:value pair you can use the del statement. Give the key you're trying to remove and the name of the dictionary to the del statement. For instance, let’s remove the key color in our stock_1 dictionary.

stock_1={
    'type':'Volvo',
    'color':'Black',
    'year':2014
}

del stock_1['color']   # removes the key `color` and its value `Black`
print(stock_1)         # {'type': 'Volvo', 'year': 2014}

Python removes the key color and its related value Black. The rest of the dictionary remains intact.

Looping through a dictionary

To access everything stored in a dictionary, you can loop through the dictionary using a for loop.

Assuming we have the names and models stored in a cars dictionary, we can access the name and model of each car using a for loop as follows:

cars={
    'Volvo':'V90',
    'Skyline':'R32',
    'Subaru':'2019WRX'
}

for name, model in cars.items():   # method `item()` returns a list of key value pairs
    print(name, ":", model)

# Volvo : V90
# Skyline : R32
# Subaru : 2019WRX

In the example above, the for loop stores the key in the variable name and its value in the variable model.

Conclusion

In this tutorial, we have gained an understanding of lists and dictionaries on how to:

Access, alter and remove elements in both lists and dictionaries.
Loop through dictionaries and lists.
Sort and slice a list.

Happy coding!

Files and Exceptions in Python

Duncan Ndegwa — Thu, 07 Aug 2025 07:32:04 +0000

Files are identified locations on a disk where associated data is stored. Working with files will make your programs fast when analyzing masses of data. Exceptions are special objects that any programming language uses to manage errors that occur when a program is running.

In this tutorial, we'll learn about file operations in Python. These operations include reading, writing, and appending to a file. We will also learn about handling the ZeroDivisionError and FileNotFoundError exception.

Prerequisites

Have some basic knowledge of the Python coding language.

Reading from a file

When working with data from a text file, you must first read it into memory. To read a file, you must have a file that exists.

Let's create a text file containing a list of years from 2020 to 2022 using an editor and save it in the same folder that stores our Python files as years.txt.

The years.txt file should have the following text:

2022
2021
2020

Below is a program that opens the above file, reads it and prints the data in the file:

with open('years.txt') as file_object:
    contents = file_object.read()
    print(contents)

The name of the file to be opened is passed to the open() function as its only argument. Python looks for the years.txt file in the folder, where our Python file is stored.

The open() function returns an object representing the file (years.txt) which is then stored in variable file_object.

The keyword with closes the file when access to it is no longer need.

The read() method is used to read the whole data in the file and store it in contents.

We get the following results after we run the above code:

2022
2021
2020

Working with the contents of a file

Now, you have learned how to read a file into memory, let's try doing something with that data.

Let's create a single line holding all the digits in the years.txt file without white spaces in it as shown below:

with open('years.txt') as file_object:
    lines = file_object.readlines()
yrs_string = '' # create a variable yrs_string to hold the digits of years
for line in lines: # create a loop that adds each line of digits to yrs_string
     yrs_string += line.rstrip() #.rstrip() removes the newline character from each line
print(yrs_string) # print this string
print(len(yrs_string)) # print how long the string is 
 # OUTPUT
 # 209020702089
 # 12

NOTE: Python treats all text in a text file as a string. If you read a number from a file and you want to carry out arithmetic operations, convert it to float using the float() function or integer using the int() function.

Writing to a file

One of the simplest ways to save data, is to write to a file. The output will still be even after we close the terminal having our program's outputs.

When writing text to a file, we use the open() function with two arguments - the first argument is the filename, while the second argument is the mode in which you want to open the file.

There are four modes in which you can open a file:

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

Writing to an empty file

If the file you are writing does not exist at all, the open() function auto-generates the file.

For example:

with open('student.txt', 'w') as file_object:
    file_object.write("My name is Felix.")

The above code doesn't print the output on the terminal, but when you open the student.txt file, you will see one line:

My name is Felix.

NOTE: When opening a file in 'w' mode and the file exists, Python will delete the file before returning the file object.

Appending to a file

To add data into a file, open it in append mode. Any data you write will be placed at the end of the file.

Let's add some lines in the student.txt file:

with open('student.txt', 'a') as file_object: #’a’ argument to open the file for appending
      file_object.write("I am 6 years old\n")
      file_object.write("I love playing games\n")

The new student.txt file looks like this:

My name is Felix.
I am 6 years old
I love playing games

Exceptions

Exceptions are unique objects that Python uses to control errors that occur when a program is running. Exceptions errors arise when correct syntactically Python programs produce an error.

Python creates an exception object whenever these mistakes occur. When we write code that deals with the exception, our programs will continue running, even if an error is thrown. If we don't, our programs will stop executing and show a trace-back, which is very hard for a user to understand.

Python uses the try-except-finally block to control exceptions. A try-except block informs Python how to act when an exception emerges. Our programs will continue to execute even if things go wrong.

Handling the ZeroDivisionError exception

Let's run a program that divides a number by zero. We know it is impractical, but let's see what Python does:

print(6/0)

When we run the above code Python gives the following trace-back:

Traceback (most recent call last):
  File “C:\Users\ADMIN\PycharmProject\pythonProject\main.py”, line 1, in <module>
 print(6/0)
ZeroDivisionError: division by zero

Since Python cannot divide a number by zero, it reports an error in the trace-back as ZeroDivisionError, which is an exception object. This kind of object responds to a scenario where Python can't do what we asked it to.

If you think an error might occur, use the try-except block to control the exception that may be raised.

To handle the ZeroDivisionError exception, use a try-except block like this:

try:
    print(6/0)
except ZeroDivisionError:
    print("You can’t divide by zero!") # You can’t divide by zero!

Handling the FileNotFoundError exception

Errors will always arise when working with files that are missing. Python may fail to retrieve a file, if you have written the wrong spelling of the filename, or the file does not exist.

We handle this situation by applying the try-except block.

For example, the program below tries to read a file that doesn't exist on my computer:

filename 'John.txt'
with open(filename) as f_obj:
    contents = f_obj.read()

Since Python can not read a file that does not exist, it raises an exception:

Traceback (most recent call last):
  File “C:\Users\ADMIN\PycharmProject\pythonProject\main.py”, line 2, in <module>
 with open(filename) as f_obj:
FileNotFoundError: [Errno 2] No such file or directory: ‘john.txt’

Since Python can not find the file, we are opening it creates an exception that is the FileNotFoundError exception.

In this example, the open() function creates the error. To solve this error, use the try block just before the line, which involves the open() function:

filename = 'John.txt'
try:
    with open(filename) as f_obj:
        contents = f_obj.read()
except FileNotFoundError:
    msg = "Sorry, the file "+ filename + "does not exist."
    print(msg) # Sorry, the file John.txt does not exist.

Conclusion

In this article, we have learned how to:

Read from a file
Work with a file contents
Write to a file
Handle the ZeroDivisionError exception
Handle the FileNotFoundError exception

Visualizing repositories using Pygal

Duncan Ndegwa — Sat, 02 Aug 2025 11:47:27 +0000

Pygal allows us to create a range of graphs and charts. In this article, you'll learn how to construct a visualization that shows the comparative Python's prominence works on github.com. We'll create an interactive bar chart, where the height of each bar will represent the sum of stars earned by the project. By clicking a bar, you'll be sent to the project's GitHub page.

Prerequisites

Some knowledge of Python
Knowledge on Web APIs
Pip installed

Installing pygal

To install Pygal, run the command below;

pip install pygal

You can visit Pygal's official site for more information on the installation of Pygal.

The pygal gallery

The Pygal gallery is a collection of charts that Pygal can generate.

To grasp more of the chart types that can be generated by Pygal, read over to the documentation tab on the chart type page
Additionally, you can examine how the visualizations are created by exploring the source code for each.

Visualizing repositories

Since we'll want to incorporate more than one repository in our visualization. Let's design a loop that displays particular data about each of the repositories obtained by the API query, so we can incorporate them all in the visualization.
To achieve this, run the code below:

import requests
url = 'https://api.github.com/search/repositories?q=language:python&sort=stars' # Initiate an API request.
request = requests.get(url)
print("Status code:", request.status_code)
respons_dict = request.json()  # In a variable, save the API response.
print("Total repos:", respons_dict['total_count'])
# Examine the repository's details.
repos_dicts = respons_dict['items']
print("Repos found:", len(repos_dicts))
print("\nSelected info about each repository:")
for repos_dict in repos_dicts:   #go through all the dictionaries in repos_dicts.
    print('name-:', repos_dict['name'])  #write the name of the project
    print('owner-:', repos_dict['owner']['login']) #show the owner of the project
    print('stars-:', repos_dict['stargazers_count'])#print the number of stars the project has
    print('repo-:', repos_dict['html_url'])  # print the link to the project's repository
    print('Description-:', repos_dict['description']) # print the description of the project

We print the owner of each project, its name, the number of stars it has, the project's description, and its GitHub URL inside the loop. Click here to see the output of the above code.

Let's construct a visual representation of the current popularity of Python works on GitHub since we have some relevant data. We will create a bar chart: the tally of stars the project has earned will be represented by the height of each bar.
To get this done, you can run the code below:

import requests
import pygal
from pygal.style import LightColorizedStyle as LCSe, LightenStyle as LSe
#  Start an API request.
url = 'https://api.github.com/search/repositories?q=language:python&sort=star'
request = requests.get(url)
print("Status  code:", request.status_code)
# In a variable, save the API response.
response_dictionary = request.json()
print("Total-repos:", response_dictionary['total_count'])
# Investigate the repository's contents.
repos_dicts = response_dictionary['items']
names, stars = [], []
for repos_dict in repos_dicts:
    names.append(repos_dict['name'])
    stars.append(repos_dict['stargazers_count'])
# Construct a visual picture
our_style = LSe('#333366', base_style=LCSe)
chart = pygal.Bar(style=our_style, x_label_rotation=45, show_legend=False)
chart.title = 'Python Works with the Most Stars on GitHub'
chart.x_labels = names
chart.add('', stars)
chart.render_to_file('py_repos.svg')

To begin, we import pygal as well as the Pygal styles that we'll require for the chart. We'll keep printing the status of the API request return and the total amount of repositories detected to see if the API call was successful.

First, we generate two blank lists to house the data that will be used in the chart. We’ll use the name, and the number of stars of each project to label and determine the height of the bars respectively. The name of each work, as well as the amount of stars it has, are added to these lists inside the loop.

Next, we create a style based on a blue colored tint using the LightenStyle class (alias LSe).In order to use the LightColorizedStyle class(alias LCSe), we additionally give the base style parameter. After that, we create a simple chart with Bar() and provide it our_style.We further give two extra style arguments: we rotate the labels 45 degrees along the x-axis (x label rotation=45) and conceal the legend since we're just showing one series on the graph (show legend=False). The x labels property is assigned to the list names, and the graph is given a title.

We give an empty string for the label once we load the data since we don't require this data series to be tagged. Below is the graph that resulted:

Refining Pygal Charts

Let's fine-tune the look of our graph. First, reorganize the code somewhat by establishing a configuration object that includes all of our adjustments to pass to Bar():

import requests
import pygal
from pygal.style import LightColorizedStyle as LCSe, LightenStyle as LSe
#  Start an API request.
url = 'https://api.github.com/search/repositories?q=language:python&sort=star'
request = requests.get(url)
print("Status  code:", request.status_code)
# In a variable, save the API response.
response_dictionary =request.json()
print("Total-repos:", response_dictionary['total_count'])
# Investigate the repository's contents.
repos_dicts = response_dictionary['items']
names, stars = [], []
for repos_dict in repos_dicts:
    names.append(repos_dict['name'])
    stars.append(repos_dict['stargazers_count'])
# Construct a visual picture
our_style = LSe('#333366', base_style=LCSe)
myconfig = pygal.Config()   # make an instance of Pygal’s Config class
myconfig.x_label_rotation = 45    # set the  attribute x_label_rotation to 45
myconfig.show_legend = False    #set the attribute show_legend to false
myconfig.title_font_size = 23   #choose the text size for the heading of the chart
myconfig.label_font_size = 13   # choose the text size for the minor label (The minor labels are the project names along the x-axis)   
myconfig.major_label_font_size = 17 #set the text size for the major label(The major labels are just the labels on the y-axis)
myconfig.truncate_label = 15  #To reduce the length of long project names to 15 characters, employ truncate label.
myconfig.show_y_guides = False  #set show_y_guides to False hide the horizontal lines on the graph
myconfig.width = 1000   #Choose a custom width for the graph so that it takes up maximum browser area
chart = pygal.Bar(myconfig, style=our_style)  #make an instance of Bar, and pass myconfig and style as arguments, respectively
chart.title = 'Python Projects with the Most Stars on GitHub'
chart.x_labels = names
chart.add('', stars)
chart.render_to_file('py_repos.svg')

The restyled chart is shown below:

Customizing Tooltips

Floating a mouse above a single bar displays data it represents. This is known as a tooltip, and it usually displays the tally of stars that a project possesses. Let's make a custom tooltip to display the descriptions of each project.

Let's have a look at an example that uses the first three projects plotted singly with custom labels for each bar. Rather than passing a list of values to add(), we'll pass a list of dictionaries with the code below:

import pygal
from pygal.style import LightColorizedStyle as LCSe, LightenStyle as LSe
our_style = LSe('#333366', base_style=LCSe)
chart = pygal.Bar(style=our_style, x_label_rotation=45, show_legend=False)
chart.title = 'Projects in Python '
chart.x_labels = ['public-apis', 'system-design-primer', 'Python']
plot_dictoinaries = [
 {'value': 144904, 'label': 'Description of public-apis.'},
 {'value': 139818, 'label': 'Description of system-design-primer.'},
 {'value': 113616, 'label': 'Description of Python.'},
 ]
chart.add('', plot_dictoinaries)
chart.render_to_file('bar_desc.svg')

We create a plot_dictionaries list with three dictionaries: one for the public_apis work, the other for system_design_primer work, and the last one for Python. There are two keys in every dictionary: value and label. Pygal calculates the height of each bar using the number linked with value, and it creates the tooltip for each bar using the string connected with label. The first dictionary, for instance, will generate a bar indicating a project with 144904 stars, with the tooltip "Description of public-apis."

The add() function requires a string and a list. We pass the list of dictionaries containing the bars (plot dictionaries) to add(). Pygal has a default tooltip that contains the number of stars, besides the customized tooltip we gave it.

One of the tooltips is shown below:

Including Clickable Links in Our Charts

Each bar in the chart can also be used as a redirect to a webpage, thanks to Pygal. We simply add one line of code to our code to enable this feature, utilizing the dictionary we've built up for each project. We create a new key-value pair for each project’s plot_dictionary using the key xlink:

import requests
import pygal
from pygal.style import LightColorizedStyle as LCSe, LightenStyle as LSe
#  Initiate an API request
url = 'https://api.github.com/search/repositories?q=language:python&sort=star'
request = requests.get(url)
print("Status-code:", request.status_code)
# In a variable, save the API response.
response_dictionary = request.json()
print("Total repos:", response_dictionary['total_count'])
# Investigate the repository's contents.
repository_dicts = response_dictionary['items']
names, plot_dictionaries = [], []
for repository_dict in repository_dicts:
   names.append(repository_dict['name'])
   plot_dictionary = {
   'value': repository_dict['stargazers_count'],
   'label': repository_dict['description'],
   'xlink': repository_dict['html_url'],
   }
plot_dictionaries.append( plot_dictionary)
# Construct a visual picture
our_style = LSe('#333366', base_style=LCSe)
chart = pygal.Bar(style=our_style, x_label_rotation=45, show_legend=False)
chart.title = 'Most-Starred Python Works on GitHub'
chart.x_labels = names
chart.add('',  plot_dictionaries)
chart.render_to_file('py_rs.svg')

Here is the output of the above code:

Pygal converts each bar into an active link by using the URL connected with 'xlink.' Any of the bars in the chart can be clicked to view the GitHub site for that project in a separate tab in your browser.

Conclusion

In this tutorial, we have seen how to:

Install Pygal
Visualize repositories
Refining Pygal Charts
Add Custom Tooltips
Add Clickable Links to Our Graphs

Visualizing Random Walks in Python

Duncan Ndegwa — Sat, 02 Aug 2025 11:36:32 +0000

In this article, we'll use Python to collect data for a random walk and then use matplotlib to visualize the results. A random walk is a route with no predefined way that is determined by a sequence of random choices made totally at random. A random walk could be compared to the path a cockroach may follow if it lost its mind and takes each walk differently.

Prerequisites

Have some basic knowledge of Python programming language
Have Python and matplotlib installed in your machine.
Have some basic understanding of matplotlib

Creating the RWalk() Class

To design a random walk, we'll construct an RWalk class that generates random choices on the basis the trek should go in. Three characteristics are required for the class: a single variable to record the amount of instances in the path, and two arrays to hold the x- and y- data of each step in the trek. The RWalk class will only have two functions:__init__() and fil_walk(), which will determine the steps in the trek. Let's construct a file named rwalk.py and begin with the __init__() function as illustrated below:

from random import choice
class RWalk():
 """RWalk class that generates random choices."""

 def __init__(self, number_of_points=500):
 """characteristics of the trek"""
 self.number_of_points = number_of_points

 # Each move begin at (0, 0).
 self.xvalues = [0]
 self.yvalues = [0]

Here we fix the default number of marks in the trek to 500, which is sufficient to form some intriguing sequences but fairly small to build walks rapidly. Then we build two lists to keep track of the x- and y-estimates, and we begin each trek at (0, 0).

Choosing Directions

To supply our trek with locations and calculate the route of each move, we'll use the fil walk()function, as illustrated below. The code below should be added to the file we created initially that is r_walk.py.

def fil_walk(self):
"""determine all the marks in the trek."""

 # Continue walking until you reach the required distance. 
 while len(self.xvalues) < self.number_of_points:

 # Choose a route and how far you want to go in that way.
 x_route = choice([1, -1])
 x_length = choice([0, 1, 2, 3, 4])
 x_move = x_route * x_length

 y_route = choice([1, -1])
 y_length = choice([0, 1, 2, 3, 4])
 y_move = y_route * y_length

 # discard walks that go nowhere.
 if x_move == 0 and y_move == 0:
   continue

 # determine the succeeding x and y co-ordinates.
  succeeding_x = self.xvalues[-1] + x_move
  succeeding_y = self.yvalues[-1] + y_move

 self.xvalues.append( succeeding_x)
 self.yvalues.append( succeeding_y)

We begin by creating a loop that will continue to execute until the path is supplied with the right set of points. This function's major component instructs Python on how to generate four random possibilities.
To select a result for x_route, use choice([1, -1]), which yields 1 for right movement and 1 for left movement. Then choice([0, 1, 2, 3, 4]) instructs Python how far to advance in that way (x_length)
by generating a random integer among 0 and 4.
We compute the distance of each movement in the x and y route by multiplying x_route * x_length and y_route * y_length respectively.
If the results for x_move are +ve, pushes walk to the right, if -ve push walk to the left, 0 indicates an upright step.
If the results for y_move are +ve indicates move upwards, while -ve implies move downwards, and 0 implies a horizontal move.
The path pauses when both x_move and y_move are 0, but we keep the loop continuing to avoid this.

We calculate the value in y_move to the last value supplied in yvalues to get the succeeding_y value for our trek, and we do the same for the xvalues. We attach these data to xvalues and yvalues soon we obtain them.

Plotting the Random Walk

Here we will create a new file and name it visual_rw.py and save it in the same directory we saved rwalk.py and write the following code:

import matplotlib.pyplot as pylt
from r_walk import RWalk
# create a random walk
 rwalk = RWalk()
rwalk.fil_walk()

pylt.scatter(rwalk.xvalues, rwalk.yvalues, s=14) # s is size of dots
pylt.show()

The first step here is to import pyplot and RWalk. Then we make a random trek and save it in rwalk, ensuring to call fil_walk() on it. Finally, we provide the x and yvalues from the walk to scatter() and select a suitable dot diameter.
When we execute the file visual_rw.py we should be able to see something like the figure below:

Styling the Walk

Coloring the Points

We'll use a colormap to display the sequence of the spots along the walk, then eliminate the black frame of each dot to reveal the color of the dots. We send a list with the location of each point to the c parameter to color the spots as per their arrangement in the trek. The list only comprises the values 1 to 5000, as seen here, since the dots are plotted in sequence:

import matplotlib.pyplot as pylt
from r_walk import RWalk
#create a random walk
 rwalk = RWalk()
rwalk.fil_walk()

p_numbers = list(range(rwalk.number_of_points)) #point numbers
 pylt.scatter(rwalk.xvalues, rwalk.yvalues, c=p_numbers, cmap=plt.cm.Blues,
 edgecolor='none', s=14)
pylt.show()

First, we build a list of values corresponding to the amount of points in the path using range() function. Then we put them in a list called p_numbers, which we'll use to color every spot on the trek. We use the Blues colormap, supply p_numbers to the c parameter, and then edgecolor=none to remove the black accent around every spot.
The result of the above program is shown below:

Plotting the Starting and Ending Points

Once the main sequence has been mapped, we can map the initial and last spots separately. To ensure the terminal points stand out, we'll enlarge them broader and color them distinctively, as illustrated below.
Put this code just above the pylt.show() in the file visual_rw.py

# map the initial and terminal points.
 pylt.scatter(0, 0, c='green', edgecolors='none', s=110)
 pylt.scatter(rwalk.xvalues[-1], rwalk.yvalues[-1], c='red', edgecolors='none',
 s=110)

We paint spot (0, 0) in green with a greater size (s=110) than the other points to identify the beginning. The last x and yvalues in the trek are plotted in red with a size of 110 to indicate the end destination.
When the above code is executed, you should be able to identify where the walk starts and terminates.

Adding Plot Points

To offer us additional stuff to deal with, let's raise the number of dots. To achieve so, when creating an RWalk occurrence, we raise the number of number_of_points and alter the diameter of every dot when displaying the plot, as illustrated here:

import matplotlib.pyplot as pylt
from r_walk import RWalk
#create a random walk
 rwalk = RWalk(50000)
rwalk.fil_walk()

p_numbers = list(range(rwalk.number_of_points)) #point numbers
 pylt.scatter(rwalk.xvalues, rwalk.yvalues, c=p_numbers, cmap=plt.cm.Blues,
 edgecolor='none', s=1)
pylt.show()

This sample generates a random walk with 50,000 spots and depicts every spot with a width of s=1. As demonstrated in the figure below, the consequent walk is feathery and cloud-like.

Conclusion

In this tutorial we have learned how to:

Creating the RWalk() Class
Choosing Directions
Plotting the Random Walk
Coloring the Points
Plotting the Starting and Ending Points
Adding Plot Points

Happy coding!

A Dive into CSS Selectors

Duncan Ndegwa — Mon, 20 Feb 2023 09:23:19 +0000

What are selectors in CSS

Selectors are used to locate or find HTML elements based on their name, id, class, attributes, and many more.

Prerequisites

To follow along with this tutorial it is assumed that you have a basic knowledge of HTML.

Install a text editor such as Vs Code, Sublime text, notepad, or any other text editor you are comfortable with.

CSS selectors

To understand what selectors are, first, let's look at the syntax of CSS:

p {
    text-align: center;
}

In the above css syntax p is the selector. The braces {} defines the declaration block. Inside the braces is the name of the property and its value separated by a colon. In CSS each declaration is ended using a semicolon.

The `element` Selector

For example, you can select all <h1> in a HTML page to have a text color red and be aligned at the center using the following code:

h1 {
    text-align: center;
    color: black;
}

In the above, all headers using the tag <h1> will be colored black and center-aligned.

The `id` Selector

This selector is used to select a specific element based on the id attribute of a HTML element. Changes will only occur on the element with the id.
The hash character (#) followed by the id name of the element is used to select the specific element.
Let's have a look at the code below:

<!DOCTYPE html>
<html lang="en">
<head>
    <!-- insert CSS code here -->
    <style> 
        #line1{
            color: blue;
            text-align: center;
        }
    </style><!-- end of CSS code -->
</head>
<body>
<p id="line1">This is a css selector</p> <!-- The css style will on apply to this line -->
<p>Only the paragraph with the id is selected</p>    
</body>
</html>

If you run the above code, you will notice that the css style will on apply to the paragraph with the id #line1.

The `class` Selector

This selector locates HTML element with specific class attributes. The dot(.) character followed by the class name of the element is used to find elements with a certain class. To understand this better let us examine the code below when run:

<!DOCTYPE html>
<html lang="en">
<head>
    <!-- insert CSS code here -->
    <style> 
        .line1{
            color: green;
            text-align: center;
        }
    </style><!-- end of css code -->
</head>
<body>
   <h1 class="line1"> CLASS SELECTOR</h1>

   <p>This selector locates HTML elements with specific class attributes.</p>

   <p class="line1">This is a css selector</p> <!-- The css style will on apply to this line -->


   <h1>CSS style will only affect the named class</h1>    
</body>
</html>

When you run the above code, you will find that only specific elements are affected by the class selector.

Grouping selectors

In case you have similar styles defined using different selectors like the one below:

h1 {
    text-align: center;
    color: black;
}
div {
    text-align: center;
    color: black;
}
p {
    text-align: center;
    color: black;
}

It is always better to group them to reduce the size of your code. To group them use a comma to separate the selectors as illustrated below:

h1, div, p {
    text-align: center;
    color: black;
}

NOTE: The id and class names should never start with a number.

Conclusion

In this article we have learned the following:

What are selectors?
Different types of selectors.
How to group selectors

Thanks for Reading

Let us connect on Twitter and LinkedIn
Want to see what I am working on? Check out my GitHub

Automating Notepad and Excel applications in Python

Duncan Ndegwa — Wed, 25 May 2022 06:41:19 +0000

Automating Notepad and Excel applications in Python

Introduction

Performing repetitive tasks over and over again can be pretty boring and tiresome. Most humans like to be challenged and thereafter rewarded for complex tasks that make them grow in their skill set. This is where automation comes in. Automating repetitive tasks saves one precious time for other important things. Armed with a little knowledge in Python programming however one can have the computer automatically do these tasks for you efficiently and effectively.

In the windows platform, different tasks can be automated using Python scripts, these tasks include launching notepad, reading and writing data in an excel spreadsheet. To approach automation with Python you will need to understand what automation is, and what python is. Automation describes a variety of technologies that reduce human intervention in the process by determination of decision criteria, sub-process, related action, and how they are related. On the other hand, Python is a high-level versatile programming language with friendly, approachable syntax, and a tone of libraries that can be utilized in task automation.

In this article, we will learn how to automate boring stuff in windows using the Pywinauto module. Pywinauto is a bundle of Python modules for automating the Microsoft Windows GUI(Graphic user interface). It allows you to send your input action to windows dialogue and control.

Introduction
Table of contents
Prerequisites
Applications of Automation
Installation of Pywinauto
Automating notepad
Automating Excel with Pywinauto
Python automation tools
Conclusion

Prerequisites

To follow along, the reader must have a good knowledge of Python.

Areas where automation can be used

Let's take a look at some of the most common automation scenarios before going on:

Service from an automated support center: - Various firms or organizations give assistance centers where customers may ask problems by email, SMS,, or other means and receive a fast response.
Auto-filling a form: - Automated scripts can easily handle the tedious work of filling out online forms and restoring forgotten credentials, among other things.
Quick Climate reports: - You may also check the weather simply and quickly, but it is more efficient if it is delivered to you automatically. As a result, this is a case of automation in which you are automatically notified of daily weather updates.
Automatic mail triggers daily:- This is useful if you have to send an attachment every day. This can be readily managed with an automatic script that runs every day. ### Installation of Pywinauto Command to install Pwinauto:

pip install pywinauto

To validate yout installation run this code snippet below:

from pywinauto.application import Application
app = Application(backend="uia").start("notepad.exe") # open notepad app
app.UntitledNotepad.type_keys("%FX")

This should start up your notepad application on the windows interface.
After this installation and validation, we will jump to notepad automation which is the simple technique, followed by excel automation where we will read data from a spreadsheet and write data to the excel cells.

Automating notepad

This example will give us an insight into how pywinauto functions by looking at functionalities like starting an application, maximizing and minimizing the application, and writing text in a notepad application. To begin, let us first import the relevant fields and launch notepad using the start method of the application imported.

from pywinauto import application
ap = application.Application ()
ap.start('Notepad.exe')

When the above code is executed notepad application is launched. Let's add some text on the opened notepad application. The message we intend to display is passed as a string in the text area inside the type_key()s method.

text_message = "Hello, this is a sample text for python automation"
dlg.typekeys(text_message, with_spaces = True)

We can use the is_maximize () method to maximize the notepad window as in most cases when notepad is started its window is not in full screen always.

#maximize the notepad window 
 if dlg.is_maximized () == False:
    dlg.maximize()

Output :

Automating Excel with Pywinauto

Here we will learn how we can map and write data on excel files automatically. First, we commence by accessing the excel spreadsheet.

program_path = r"C:Program Files (x86)Microsoft OfficerootOffice16EXCEL.exe"  #exel application path
file_path = r"C:Users\Desktop\mysample.xlsx"  # .xlsx file location

We now open our .xlsx file through excel.exe.

app = application.Application(backend= "uia"). start(r'{} "{}"'.format(program_path, file_path))

As we did with notepad, we must now choose the window mysample.xlxs that we need to deal with. Then print the results.

print(app.windows())

We can either select () index window or directly get it by passing the name.

dlg = app['mysample.xlsx-Excel']

We will now read data automatically from an excel sheet and print it in a sentence.

We have data entries in cell A1, B1, and C1 hence the automation id of cell A1 is A1 and that of D1 is D1. The code used to read the data and write the findings in a statement is:

tXt = ""
for j in range 65, 65 + 5):
    ex_id = str (chr(j)) + str (1)
dlg.child_window(auto_id = ex_id).click_input()
ein = dlg.child_window(auto_id=ex_id)
ein.click_input()
txt+=(ein.legacy_properties()['Value'])
txt+=" "
print("Text read from mysample.xlsx is:",(txt))

Result :

The text read from mysample.xlsx is: student name admission number year of study

The automation id we making for each cell is inside the for loop, dlg. child_window () is used to get specific elements where automation id is passed as a parameter. Then we do a mouse click to grab that element using click input (). legacy_properties()['value'] is then used to read data in the specific cell.
We will now write data in cell A4:

write_data = "John Doe"
window = dlg.child_window(auto_id="A4")
window.click_input()
window.type_keys(write_data, with_spaces=True)

Output:

Here the string we need to write is write_data. We then grab the element and click on it using the click input. To write data in cell A4 we use the type_keys method that takes two parameters, the string to be written, and check for spaces in the typed data.

Python automation tools

Python has a variety of tools, libraries, and frameworks that will aid you in your coding journey. Below we will take a look at a few important tools for automating your computerized jobs.

Smtplib

The smtplib tool is an amazing resource for handling your emails. It utilizes the Simple Mail Transfer Protocol(SMTP), which is easily compatible with most major email providers, like Gmail.

Selenium

This package allows you to control the website browser activities from Python. You can read more about Selenium from the official documentation here

Beautifull Soup

This module is used for obtaining data in HTML and XML files. You can read more about Beautiful Soup from the official documentation here

Conclusion

In this tutorial we have learned what Pywinauto is, and how to automate both notepad and excel. We have also looked at a few Python automation tools like selenium,smtlib, etc. You can discover further about different concepts from here.

Modern Python for everyone: Mastering Modern Python the Right Way

Duncan Ndegwa — Thu, 03 Mar 2022 19:41:00 +0000

Mastering Modern Python the Right Way

Everyone wants to know the best way to learn to code Python nowadays. For as many reasons as there are to learn Python, there is probably an equivalent number of ways to learn Python. You can already tell because this is a listicle and not a tweet, but the best method to learn Python does not have a single answer.

There’s no one best way – there’s only the best way to learn Python that’s good for your specific circumstance. If you’re an experienced coder, the best way for you to learn Python will be vastly different from the best way to learn Python for beginners.

In this article I will address 5 specific circumstances you might find yourself in, and explain the best way to learn Python for you.

1 Learn Python For Free

You can find free/freemium options to learn Python just about anywhere online, but I love Exercism and freeCodeCamp as the best ways to learn Python for free. Why? Because each offers a unique way of teaching that suits each unique circumstance.

2 Learn Python on Your Own

Maybe you hate paying for things and you don’t want interactive courses. Sometimes you just have to go your own way, and learning Python is no excuse. If that’s the case, the best way to learn Python on your own is by relying on YouTube tutorials and lectures.

Youtube isn’t just for influencers and conspiracy theorists, it’s actually an excellent resource for accessing video lectures from a multitude of professional programmers who were once just like you trying to learn the language.

There are so many amazing, talented, kind-hearted individuals who have posted unbelievable amounts of content for free on YouTube. The hard part of course is digging it all up, watching in the right order, and motivating yourself to actually try out some of the things you see.

3 Learn Python the Fun Way

After a long day of work, the last thing I want to do is spend my time listening to dull lectures as my eyes begin to blur letters and numbers together. In fact, what I like to do is curl up on the couch and play some games.

Codewars has created one of the most innovative ways to learn and practice coding, in my opinion. Supporting dozens of languages, you’ll train your mind and sharpen your skills by completing “Kata’s”, which are real-time competitions between you and other coders all over the world.

Code your way through the ranks while you accrue honor, insight into optimized coding techniques, and gain collaborative wisdom from the bustling community currently surrounding the game.

It does require you to prove an understanding of the language you’ll be training with and this will determine what level you’ll start competing at. It’s not a practical option for those new to coding, but for programmers looking to skill up, this is without a doubt one of the coolest ways to learn Python, as well as train the other languages you know.

4 Learn Python to Get a Certificate

If you’re the kind of person who wants or needs proof of your python expertise, whether for personal satisfaction or as a job requirement, your best bet is to get a certificate.

Sites like lux academy offer courses run by actual institutions.

conclusion

Visit my github profile here and twitter

Python 101:Introduction to modern Python

Duncan Ndegwa — Sat, 19 Feb 2022 08:56:25 +0000

Python is among the most popular programming languages in the world. It is ranked high in different StackOverflow programming surveys each year. This article helps beginners familiarize themselves with the basic concepts of Python. According to the official documentation, Python is a high-level and general-purpose programming language.

Introduction

It is a preferred programming language for many developers due to its wide range of libraries. Individuals can use these libraries to create complex applications rather than building everything from scratch. Other reasons why developers love Python is because of its simplicity, flexibility, and versatility. Today, Python is being used in upcoming fields such as machine learning and artificial intelligence.

What you will learn

In this tutorial, you will learn how to define and use the following elements:

Variables
Methods
Loops
Lists and Arrays
Classes

Prerequisites

For simplicity, we will be using IDLE (Integrated Development and Learning Environment) in this tutorial. IDLE is the default Python code editor and compiler. You can download it from here. Also, note that this tutorial is based on Python 3.9 rather than the 3.6 version.

Understanding variables

Variables are simply declarations that are used to store certain values. For instance, the variable name can hold the value of John Smith. Several rules need to be considered when declaring variable names. For starters, a variable name cannot begin with a number.

2name = incorrect #incorrect

name = correct #correct

Variable names are case sensitive. This means that the variable school is not the same as School.

Variables can hold different data types. This includes strings, integers, Booleans, long, lists, and arrays.

In Python, we do not need to declare the data type while writing a variable. This is because the code is compiled and interpreted later. The compiler will throw an error in case there is a mismatch in the data types.

Let’s talk about the different data types.

Strings

Strings are usually presented in a text format. We will declare a string variable, as shown below.

name = “john”
school = “Alliance Francaise”

When we run print(name), the output will be john.

Integers

These variables hold numeric values, as shown below.

math = 90
chemistry = 100
biology = 70

We can find the total of the variables above using the following statement.

print(math+chemistry+biology)

The total is 260.

A TypeError is thrown when you try to add a string to an integer, as shwon below.

var1 = "30" #string
var2 = 20 #integer
print(var1+var2)#type error

We can sum var1 and var2 by converting var1 to an integer using the int() function. The following code will execute successfully.

var1 = "30" #string
var2 = 20 #integer
print(int(var1)+var2) # Output: 50

Make sure that the variable stores a value that can be converted to an integer before using the int() method.

Booleans

There are only two Boolean values: True and False. In other words, something can either be true or false. We declare these values, as shown below. Please note that Python is case sensitive.

isOn = True
isChecked = False

A bool() method can help convert a value to a boolean. The code snippets below showcase how a bool() function can be used.

print(bool("abc")) #returns True
print(bool(0))  #returns False

The bool() function returns False when there are no parameters.

Float

This data type consists of numbers that have a decimal place. A perfect example of a float variable is highlighted below.

Bmi = 45.7

Understanding lists

Lists allow us to store numerous elements in a particular variable. For instance, we can have a list that stores all the student names in a class. We use [] to define a list.

students = [] #list example

Elements in a list are usually separated by a comma, as shown below.

students = [“john”, “Mary Thomas”, “John Smith”]

Each element in the above students list has an index. By default, the first index is 0. So the item at index [0] is john, while the value at index 1 is Mary Thomas. A list of integers will look as follows.

student_marks = [90, 78, 90, 78]

We can access different list functionalities using built-in functions. For instance, to add a value to the student_marks list, we use the append function.

student_marks.append("Guardian Angel")
print(student_marks)

The above function adds Guardian Angel at the end of the student_marks list.

When we print the list it shows:

#output
[90, 78, 90, 78, 'Guardian Angel']

We use len(student_marks) to determine the length of the list. We use the remove() function to delete something from the list. For instance, we can remove 90 from the student_mark list as shown below.

student_marks.remove(90)
print(student_marks)

In lists, negative indices allow us to count elements starting from the last one. For instance, the element with an index of -1 in the above student_marks list is "Guardian Angel". The second last element 78 has an index of -2.

Understanding functions or methods

Methods are quite critical in programming. They help store reusable code. This means that a person can call already declared methods rather than writing statements from scratch repeatedly. This saves significant time, that can be invested in other productive activities.

In Python, we use the def keyword to declare a function. An example of a python method is shown below.

def readData():
    print('success')

The above function prints success when it’s invoked. We can also pass data to a method, perform some calculations, and return the results. This is demonstrated in the code snippet below.

def calculateTotal(chem, bio):
    return chem+bio
print(calculateTotal(90,80))

The calculateTotal method takes in two parameters (chem, bio). The function then returns the sum of the two values. It is important to take note of the data types when passing parameters. For instance, the calculateTotal method will not work when we pass in a string as a parameter. This is because the program cannot sum up an integer and a string. As shown above, we can call the calculateTotal method directly from our print statement.

print(calculateTotal(90,80))

The return keyword ensures that the method returns a result after execution.

Note that a function can also call another method. This is illustrated below.

def readData(chem, bio):
    return chem+bio
def getTotal():
    print(readData(90,80)) #calls the readData method
getTotal()

Understanding loops

Loops are critical because they allow us to iterate through lists, check for different conditions, and continuously execute various statements. The main loops are for and while.

For loops As noted, we can use a for loop to iterate through a list, as shown below:

student_list = [“John Doore”,”Matu Smith”]
for x in student_list:
    print(x)

The for loop above will print every item in the student_list.

While loops A while loop can help us check for a particular condition. For instance, while something is true specific statements can be executed. Here is an example of a while loop in action.

isChecked = false
while isChecked == true:
    print('Hallo there')

Note that the while loop above will be executed indefinitely until isChecked is set to false. You can press ctrl+c to stop the loop.

Classes

Classes are a vital component of object-oriented programming. When creating a class, you must use the class keyword. Other elements are then nested in the class. Here is an example of a Python class.

class Farmer: # a class with the name farmer
    name = "John" # A variable
    produce = "1000kgs" # A variable
farmer = Farmer() #instatiating the class as an object. 
print(farmer.name) # accessing the properties of the Farmer class.

Classes can help as group things with similar characteristics. We can also assign values to class variables using the init function.

class Farmer:
  def __init__(self, farmername, produce):

    self.farmername = farmername
    self.produce = produce
farmer = Farmer("Carry Sminson", "10,000kgs")
print(farmer.farmername, farmer.produce)

In the above Farmer class, the self keyword represents an instance of an object. In other words, it allows us to access the different methods and attributes defined in the class.

You can also declare a method in a class and use it later, as shown below.

class Farmer:
  def __init__(self, farmername, produce):
    self.farmername = farmername
    self.produce = produce
  def printDetails(self): # Method
      print(self.farmername, self.produce)
farmer = Farmer("Carry Sminson", "10,000kgs")
farmer.printDetails()

Conclusion

We have learned how to define and use variables, methods, classes, loops, and lists from this tutorial. You can learn more about other concepts from here. The secret to becoming a Python expert is to regular practice.

Happy coding!

Forem: Duncan Ndegwa

CSS Flexbox

Introduction to CSS Flexbox

Prerequisites

Basic Terminology

Creating a Flex Container

CSS Flex Container Properties

CSS flex-direction Property

Example

CSS flex-wrap Property

Result

Conclusion

Working with GitHub API in Python

Prerequisites

Objectives

Requesting data using an API call

Processing an API response

Using the response dictionary

Conclusion

Getting Started with Loops and Standard Inputs in Python

Prerequisites

Objectives

How the input() function works

Using int() to accept numerical input

Introducing while loops

Using else statement with while loop

Using break to exit a loop

Removing all instances of specific values from a list using a while loop

Filling a dictionary with user input using a while loop

Conclusion

How to Store Your Python Functions into Modules

Prerequisites

Importing an entire module

Importing specific function

Giving a function an alias using 'as'

Giving a module an alias using 'as'

Importing all functions in a module

Conclusion

Working with Lists and Dictionaries in Python

Prerequisites

Creating a list

Accessing elements in a list

Changing elements in a list

Adding elements to a list

Removing elements from a list

Sorting a list

Slicing a list

Looping through a list

Dictionaries

Accessing values in a dictionaries

Adding items to a dictionary

Changing values in a dictionary

Removing key:value pairs from dictionaries

Looping through a dictionary

Conclusion

Files and Exceptions in Python

Prerequisites

Reading from a file

Working with the contents of a file

Writing to a file

Writing to an empty file

Appending to a file

Exceptions

Handling the ZeroDivisionError exception

Handling the FileNotFoundError exception

Conclusion

Further reading

Visualizing repositories using Pygal

Prerequisites

Installing pygal

The pygal gallery

Visualizing repositories

Refining Pygal Charts

Customizing Tooltips

Including Clickable Links in Our Charts

Conclusion

Further reading

Visualizing Random Walks in Python

Prerequisites

Creating the RWalk() Class

The `element` Selector

The `id` Selector

The `class` Selector