It’s been a while since I actually sat down and wrote some Python code. So recently I decided to write a small program that:
<ul>
<li>Calculates the number of syllables in a haiku</li>
<li>Tells the user if their haiku has too many syllables or not</li>
<li>Tells the user which line has too many syllables</li>
<li>Writes the haiku and other information to a file</li>
</ul>
Nothing too complex, I just wanted to go ahead and write this because I wanted to write some fun Python code, and at the place I work at, I was told once to give the team’s update in a Haiku. I worked on a Haiku, but to my horror, it turns out that what I wrote wasn’t a haiku.
So I guess I decided to write something that will check if a haiku is actually a haiku! If you want to see the code for this, you can check out the repo on <a href="https://github.com/JB-26/haiku-check-terminal">GitHub</a>.
But how can this be done?
I checked the Python Package index and sure enough, there is a package for checking the number of <a href="https://pypi.org/project/syllables/">syllables</a> there are in a string.
And to make this terminal application look fancy, I decided to use <a href="https://github.com/Textualize/rich">rich</a> because it’s fantastic.
That’s all there is to this application, nothing special!
Let’s take a look at the main function
<pre><code class="language-python">def main():
 """
 The main function for the application
 """
 console = Console()
 console.print(Panel.fit("Welcome to [bold green]Haiku Check![/bold green]"))
 console.print(Panel.fit(
 "[italic yellow]Please type the letters that are highlighted in green to access the functions[/italic yellow]\n[bold green]C[/bold green]heck Haiku\n[bold green]Q[/bold green]uit",
 title="Haiku Check ⛩️", subtitle="By Joshua Blewitt"))
 while True:

 console.print(Panel.fit("[bold yellow]Enter your command[/bold yellow]"))
 choice = input().upper()

 if choice == 'C':
 checkHaiku()
 elif choice == 'Q':
 console.print("Goodbye!")
 break
 else:
 console.print("[bold red]Your command was invalid! Please try again![/bold red]")

if __name__ == "__main__":
 main()
</code></pre>
This main function is more of an excuse to use rich to make a nice looking interface in the terminal.
Next, the more interesting part of the application; actually checking if a user entered haiku, is a haiku.
<pre><code class="language-python">def checkHaiku():
 """
 Checks entered text to find the syllables in each word
 """
 try:
 console = Console()
 console.print("Let's check your haiku!")

 console.print('This program assumes your haiku has three lines, following the 5-7-5 pattern for syllables.')

 console.print('Enter your first line of your haiku')

 firstLine = input()

 firstLineList = firstLine.split()

 firstSyllables = iteratelist(firstLineList, '1')

 console.print(f'The first line had {firstSyllables} syllables')

 console.print("Enter your second line of your haiku")

 secondLine = input()

 secondLineList = secondLine.split()

 secondSyllables = iteratelist(secondLineList, '2')

 console.print(f'The second line had {secondSyllables} syllables')

 console.print("Enter your third line of your haiku")

 thirdLine = input()

 thirdLineList = thirdLine.split()

 thirdSyllables = iteratelist(thirdLineList, '3')

 console.print(f'The third line had {thirdSyllables} syllables')

 if firstSyllables == 5 &#x26; secondSyllables == 7 &#x26; thirdSyllables == 5:
 console.print('[bold green]That is a haiku![/bold green]')
 else:
 console.print('[bold red]That is not a haiku![/bold red]')
 if firstSyllables - 5 &#x3C;= 0:
 pass
 else:
 console.print(f'The first line had {firstSyllables} syllables, the first line needs 5 lines. This line has a difference of {firstSyllables - 5} syllables')
 if secondSyllables - 7 &#x3C;= 0:
 pass
 else:
 console.print(f'The second line had {secondSyllables} syllables, the first line needs 5 lines. This line has a difference of {secondSyllables - 7} syllables')
 if thirdSyllables - 5 &#x3C;= 0:
 pass
 else:
 console.print(f'The second line had {thirdSyllables} syllables, the first line needs 5 lines. This line has a difference of {thirdSyllables - 5} syllables')

 now = datetime.now()
 haikuFile = (f'{now.day} - {now.month} - {now.year} - {now.hour} - {now.minute} - {randomword(5)}')
 console.print(f'[italic yellow]Writing results to text file. File is called {haikuFile}[/italic yellow]')
 file = open(f'{haikuFile}', 'w')
 file.write(f"{firstLine}\n{secondLine}\n{thirdLine}\n\nThe first line had {firstSyllables} syllables\nThe second line had {secondSyllables} syllables\nThe third line had {thirdSyllables} syllables")
 file.close()
 except Exception as e:
 raise e
</code></pre>
There’s a bit to unpack here, so we’ll start with loading in each line of a haiku.
The package that’s used to calculate the syllables states that it estimates the number of syllables in a single word. So if a user enters multiple words, then it won’t work. How do we get around that?
This was my solution to the problem:
<pre><code class="language-python">def iteratelist(linelist, linenum):
 """
 Goes through each item in a list and finds the number of syllables. Returns the total number of syllables
 """

 console = Console()
 table = Table(title=f"Haiku Line {linenum}")
 table.add_column("Word", justify="center", style="cyan")
 table.add_column("Syllables", justify="center", style="cyan")
 totalsyllables: int = 0

 for word in linelist:
 totalsyllables += syllables.estimate(word)
 table.add_row(word, str(syllables.estimate(word)))

 console.print(table)

 return totalsyllables
</code></pre>
This function uses a bit more of rich to create a table, to display the results of the line entered. And there is a for loop to iterate over each word to calculate the syllables. Then, the table is printed to the terminal, while the total number of syllables is returned.
Once we have the total number of syllables for each line, we can begin the logic of checking if each line has the correct number of syllables. If it does, then great! The user will be told that their haiku is correct. If not, the user will be told that their haiku is not a haiku. And, the user will be told which line has the incorrect number of syllables.
Finally, we print the haiku and the number of syllables for each line.
But, the name of the file is made up of the day, month, year, hour, minute, and 5 random letters. This is done by the following function:
<pre><code class="language-python">def randomword(length):
 """
 Generates a random word, based on the length provided
 """
 letters = string.ascii_lowercase
 return ''.join(random.choice(letters) for i in range(length))
</code></pre>
This ensures that each file has a unique name.
And that wraps up the program!
It’s been fun to write some Python again, going to have to think of some more problems that I can solve with Python (or another language).
Thanks for reading!

Checking the number of syllables in a haiku

<img src="https://images.unsplash.com/photo-1611162618071-b39a2ec055fb?ixlib=rb-4.0.3&#x26;q=80&#x26;fm=jpg&#x26;crop=entropy&#x26;cs=tinysrgb&#x26;w=7200" alt="">
This post and project originally started back in February this year, and for some reason I just never finished it. So, roughly three months later, I’ve returned to this project to restart and finish it! Originally, this post was about focusing on social media stats in the United Kingdom. But I realise that wasn’t particularly exciting so I decided to shake things up and grab data from several other countries as well. So this project looks at data from the following countries
<ul>
<li>United Kingdom</li>
<li>United States of America</li>
<li>Japan</li>
<li>South Korea</li>
</ul>
Each data set of each country looks at the same date range; 2013 to 2023. Ten years of data.
The social media landscape has seen some major shakeups over the past few years. From Twitter being bought out, Facebook at the centre of privacy scandals and how businesses use social media (I honestly only have a Twitter account because so many businesses use the platform for customer support - which I think is an awful idea) and the rise of new social networks such as Mastodon.
So I decided to do a little data analysis with Pandas and a few other packages such as <a href="https://bokeh.org/">Bokeh</a> and <a href="https://www.trymito.io/">Mito</a> to get a better picture of the data.
If you want to clone the repo, you can do so <a href="https://github.com/JB-26/social-media-stats">here</a> on GitHub.
The data used in this analysis is from <a href="https://gs.statcounter.com/social-media-stats/">StatCounter</a>.
Let’s jump in!
<h1>Preparing the data</h1>
The data is stored in CSV files, so this will need to be used when creating the dataframes (which will be needed for creating the graphs).
The data would be imported:
<pre><code>uk_df = pd.read_csv("social_media-GB-monthly-201305-202305.csv")
</code></pre>
And then the date column would be converted to be using the 'datetime' data type:
<pre><code>uk_df['Date'] = pd.to_datetime(uk_df['Date'])
</code></pre>
And then the information about the dataframe would be viewed to ensure that the date column was updated:
<pre><code>uk_df.info()
</code></pre>
This process would be repeated for each country.
<h1>UK Data</h1>
Let’s start with the UK first. The data itself does mention some odd social networks that I’ve never heard such as ‘Fark’ (seriously, that was the best name they came up?) and a few other results that either I’ve never heard of or just didn’t really make an impact (I’m looking at you, Google+) so I’ll exclude these when I’m creating graphs.
So, here’s the graph of the data:
<img src="https://github.com/JB-26/social-media-stats/blob/main/uk_data.png?raw=true" alt="">
We can see some interesting points:
<ul>
<li>Facebook remained the most popular network, until a brief drop in 2020 where Twitter and Instagram jumped in popularity</li>
<li>Tumblr briefly saw some popularity in 2014</li>
<li>Pinterest appears to be declining in popularity</li>
<li>Instagram is on the rise, looking to overtake Twitter</li>
<li>Twitter hasn't seen much growth</li>
</ul>
<h1>USA Data</h1>
Let's take a look at how things look in the USA:
<img src="https://github.com/JB-26/social-media-stats/blob/main/usa_data.png?raw=true" alt="">
We can see that:
<ul>
<li>Facebook still remains hugely popular</li>
<li>Pinterest hasn't been as popular in recent years</li>
<li>Twitter and Instagram has seen large increases in popularity over the last few years</li>
<li>Tumblr was birefly popular in 2014</li>
</ul>
<h1>Japan Data</h1>
I was curious at how the social media landscape looked like and see if it was different to the UK and USA. And the results were interesting:
<img src="https://github.com/JB-26/social-media-stats/blob/main/japan_data.png?raw=true" alt="">
We can see that:
<ul>
<li>Facebook was the most popular platform, but then lost ground to Twitter which has become the most popular platform today</li>
<li>Pinterest also saw a brief spike in popularity in 2019</li>
<li>YouTube enjoyed some growth, but it hasn't maintained it</li>
<li>Intagram is on the rise</li>
</ul>
<h1>South Korea Data</h1>
I was also wondering what was popular in South Korea, so I took a look at the data for that as well. And the results were surprising for one reason:
<img src="https://github.com/JB-26/social-media-stats/blob/main/south_korea_data.png?raw=true" alt="">
We can see that:
<ul>
<li>Facebook and Twitter have swapped places in being the most popular platform</li>
<li>Facebook is now the most popular platform</li>
<li>Tumblr remained popular for a few years</li>
<li>YouTube saw some growth recently (and has since lost it)</li>
<li>Instagram isn't as popular as it is in other countries</li>
</ul>
<h1>Combining data</h1>
Although it's interesting to see how the different platforms perform in each country, I decided to create a dataframe that looks at how a specific platform performs across multiple countries. Let's start with Facebook.
<h2>Facebook</h2>
First, I created a new dataframe:
<pre><code>facebook_df = pd.DataFrame()
</code></pre>
Created a new column for a country using an existing dataframe:
<pre><code>facebook_df['uk'] = uk_df['Facebook']
</code></pre>
Which allowed me to create the following graph in Mito:
<img src="https://github.com/JB-26/social-media-stats/blob/main/facebook_combined.png?raw=true" alt="">
We can see that while the platform has done well in South Korea, it isn't popular in Japan. The platform still remains popular in the UK and the USA.
<h2>Twitter</h2>
I did the same with Twitter.
First, create the dataframe:
<pre><code>twitter_df = pd.DataFrame()
</code></pre>
And create a column for the country:
<pre><code>twitter_df['uk'] = uk_df['Twitter']
</code></pre>
Which allowed me to create the following graph in Mito:
<img src="https://github.com/JB-26/social-media-stats/blob/main/twitter_combined.png?raw=true" alt="">
We can see that Twitter is very popular in Japan (and it was at one stage very popular in South Korea). The platform still remains popular in the UK and USA.
<h1>Wrap up</h1>
It's interesting to see how different platforms perform in different countries. It's quite interesting to see how popular Twitter is in Japan, and Instagram slowly increasing in popularity.
There are some gaps such as how Mastodon and TikTok perform in these countries (I'm pretty sure that TikTok would have the lion's share in popularity), so it might be worth revisting this in the future when more data becomes available.
Thanks for reading! 👏

The ever changing landscape of the internet

Exploring Social Media stats around the world with Pandas and Mito

<img src="https://images.unsplash.com/photo-1504868584819-f8e8b4b6d7e3?ixlib=rb-4.0.3&#x26;q=80&#x26;fm=jpg&#x26;crop=entropy&#x26;cs=tinysrgb&#x26;w=7200" alt="">
Hey, welcome back to an update to the F1 Data Science Project! With the new season coming up I was looking at new ways to improve my skills on Data Analysis.
When I was doing some research I discovered something called <a href="https://www.trymito.io/">Mito</a> - a package for Jupyter notebooks. Mito provides tools to analyse files (CSV, excel files and dataframes), transforming data and generates code.
With the new season of F1 starting in a few months, I was thinking of using Mito to perform data analysis on the data I collect. As having a tool that can do majority of the heavy lifting would be beneficial.
So I decided to investigate using Mito and build some graphs with the current F1 data that I have. Mito has <a href="https://docs.trymito.io/">documentation</a> to install and to use Mito.
If you want to see a working example of this with the F1 data, check out this <a href="https://github.com/JB-26/f1-2022-analysis/blob/main/mitosheet_example.ipynb">GitHub</a> page which has some examples of Mito being used.
Installing Mito is quite simple. It can be installed with venv, Docker and Anaconda (although Mito is free to use, there are additional features that are locked behind a paywall).
Let’s jump into using Mito!
<h1>Installing and using</h1>
Mito only supports running in a Jupyter notebook in a web browser. So this means you can’t run Mito in Visual Studio Code for example. I think this is my major issue I have with it. It would be great if this would work in VSC or <a href="https://www.jetbrains.com/dataspell/">DataSpell</a>.
Getting Mito up and running is pretty easy, just by calling the package in a cell on a Jupyter notebook (or by pressing the Mito spreadsheet button in Jupyter notebook). The performance of Mito is great, even when displaying graphs using Plotly.
It might seem odd working within a cell but Mito does offer a fullscreen option, which makes it much easier to use.
When you generate a Mito spreadhseet, it’ll create a unique ID. So when you close Mito and then reopen it later on, it’ll remember what you had opened (such as what dataframes you were using etc). However, you will need to ensure that the dataframes are created so Mito can use them.
<h1>Importing data</h1>
It’s not particular files that can be exported, it’s existing dataframes as well. In the example Mito spreadsheet, there’s both a CSV file and a dataframe.
After importing a set of data into Mito, the code that was used to import it will be pasted in a separate cell. Example:
<pre><code class="language-python">from mitosheet import *; register_analysis("id-olultagqwt");
 
# Imported race-results.csv
import pandas as pd
race_results = pd.read_csv(r'/Users/joshblewitt/Dev/f1-2022-analysis/data/compiled-data/race-results.csv')
</code></pre>
Once it’s imported, you can filter the table, see the type of data for the column and start using the other functionalities of Mito.
Speaking of which…
<h1>Graphs with Plotly</h1>
So an interesting functionality of Mito is that it uses <a href="https://plotly.com/graphing-libraries/">Plotly</a> to generate the graphs. And when you build a graph, the code to generate it is printed out for you in a separate cell. It’s a great opportunity to learn how to do something in Plotly.
Here’s an <a href="https://github.com/JB-26/f1-2022-analysis/blob/main/iframe_figures/figure_13.html">example</a> of a box plot that I created in Mito (you will need to clone the repo and then open it locally for the graph to be displayed!). And here is the code that generated that graph:
<pre><code class="language-python">import plotly.express as px
# Construct the graph and style it. Further customize your graph by editing this code.
# See Plotly Documentation for help: https://plotly.com/python/plotly-express/
fig = px.box(race_results, x='Car', y='PTS', points=False)
fig.update_layout(
 title='Team Performance', 
 xaxis = dict(
 title='Team', 
 showgrid=True
 ), 
 yaxis = dict(
 title='Points', 
 showgrid=True
 ), 
 legend = dict(
 orientation='v'
 ), 
 paper_bgcolor='#FFFFFF'
)
fig.show(renderer="iframe")
</code></pre>
This is by far my most favourite feature of using Mito. The ease of use in creating interactive graphs is a huge plus. Again, the fact that Mito provides you with the code is amazing.
<h1>Managing DataFrames</h1>
Managing DataFrames can be quite tricky normally, but Mito makes it easier to work with DataFrames by providing a wide range of functionality out of the box.
From creating pivot tables, to concatenating additional DataFrames, Mito can handle it. And as always, it shows you the code on how it performed your requested functionality.
Let’s take a look at this example of using a DataFrame to create a pivoted table.
<pre><code class="language-python"># Pivoted raceResults into raceResults_pivot
tmp_df = raceResults[['Race', 'Car', 'PTS']].copy()
pivot_table = tmp_df.pivot_table(
 index=['Car'],
 columns=['Race'],
 values=['PTS'],
 aggfunc={'PTS': ['std']}
)
pivot_table = pivot_table.set_axis([flatten_column_header(col) for col in pivot_table.keys()], axis=1)
raceResults_pivot = pivot_table.reset_index()
</code></pre>
Mito is quite powerful once you start using its range of functionalities!
<h1>Column functions</h1>
Mito is also excellent at managing columns, whether you want to change the data type for a column or filtering the view, Mito can do that.
Here’s an example of filtering the view on the position column and then changing the data type of the column from a string to an integer:
<pre><code class="language-python"># Filtered POS
race_results = race_results[race_results['POS'] == '1']

# Changed POS to dtype int
race_results['POS'] = to_int_series(race_results['POS'])
</code></pre>
And another example of applying a group of filters
<pre><code class="language-python"># Filtered Driver
race_results = race_results[(race_results['Driver'].str.contains('A', na=False, regex=False)) &#x26; (~race_results['Driver'].str.contains('Max', na=False, regex=False))]
</code></pre>
<h1>Spreadsheet formulas</h1>
Similar to Microsoft Excel, you can enter formulas that can be applied to cells in a column.
Here’s an example for the points column, checking where if a cell’s value is greater than 5.
<pre><code class="language-python"># Set formula of PTS
race_results['PTS'] = race_results['PTS'] > 5
</code></pre>
This will show either true or false in the column if the cell meets the condition.
There’s a full list of formulas that can be performed in Mito <a href="https://docs.trymito.io/how-to/interacting-with-your-data/mito-spreadsheet-formulas">here.</a>
<h1>Exporting data</h1>
Much like Excel, you can export the data that you are working on.
Sheets that you have open can be exported to CSV or to an Excel file. Mito also allows you to generate export code to the file type you choose. Here’s an example of exporting several sheets to CSV
<pre><code class="language-python"># Exports 6 to file race_results_export_raceResults_pivot.csv
race_results.to_csv("race_results_export_race_results.csv", index=False)
fastest_laps.to_csv("race_results_export_fastest_laps.csv", index=False)
avgPoints.to_csv("race_results_export_avgPoints.csv", index=False)
avgPoints_transposed.to_csv("race_results_export_avgPoints_transposed.csv", index=False)
raceResults.to_csv("race_results_export_raceResults.csv", index=False)
raceResults_pivot.to_csv("race_results_export_raceResults_pivot.csv", index=False)
</code></pre>
<h1>Wrap up</h1>
And that’s a quick introduction to Mito!
I think the biggest benefit of using Mito is how easy it is to use and how it generates code of what you’re doing (having knowledge of Python and Mito is useful to have before you start using Mito).
Although it’s free to use, the Pro level costs $40 a month, with an enterprise level also being offered.
I’ll be implementing the use of Mito while I’m doing data analysis for the next season of Formula 1!

A new way to supercharge your data analysis work

F1 Data Science Project Part 6 - Improving data analysis with Mito

<img src="https://images.unsplash.com/photo-1555066931-4365d14bab8c?ixlib=rb-4.0.3&#x26;q=80&#x26;fm=jpg&#x26;crop=entropy&#x26;cs=tinysrgb&#x26;w=4800" alt="">
It may be 2023, but that doesn’t mean that I’m too late for <a href="https://adventofcode.com/">Advent of Code 2022</a>! If you don’t know what Advent of Code is, it’s a digital advent calendar that gives programming puzzles instead of chocolate.
If you want to see my repo for this, it’s on my <a href="https://github.com/JB-26/advent-of-code-2022">GitHub</a>.
I’ve always been fond of Advent of Code. It’s a good way to test your knowledge and learn new things about your programming language of choice.
As Advent of Code has completed for the year, I thought I’d share how I solved some of the challenges. Starting with the first three days.
<h1>Day 1 - Calories</h1>
So, the first problem is that, using our puzzle input, we need to figure our which Elf is carrying the most calories. Should be simple enough!
So here is an example of the input
<pre><code class="language-markdown">1000
2000
3000

4000

5000
6000
</code></pre>
The empty line represents a way of separating each Elf’s inventory. So, the first elf is carrying 6000 calories of food. Second elf is carrying 4000 calories. Third elf is carrying 11000 calories and so on.
To figure this out, we need to import the puzzle input into Python!
<pre><code class="language-python">with open('day1Input.txt') as csvFile:
	csv_reader = csv.reader(csvFile)
	elf = []
	for row in csv_reader:
		if row == []:
			elves.append(elf)
			elf = []
		else:
			elf.append(f'{", ".join(row)}')
</code></pre>
This will iterate through each of the values in the puzzle input. Then, if it finds an empty value, that means we’ve found the separator. We then append this list to create a set of nested lists. Each list in the nested list represents each Elf’s inventory.
Now that we have that out of the way, we can crunch some numbers!
<pre><code class="language-python">count = 0
for i in elves:
 count += 1

print(f'Complete! There are {count} elves')

for elf in elves:
 caloriesTotal = 0
 for i in elf:
 caloriesTotal = caloriesTotal + int(i)
 calories.append(caloriesTotal)
print('Before')
print(calories)
calories.sort()
print("Calories list has been sorted!")
print(calories)
</code></pre>
Quite a simple nested for loop. We iterate over the calories in each elf and add them together to create the total number of calories. This total is added to a new list called caloriesTotal. With the completed list, we can sort it. This brings us the value of the Elf with the highest amount of calories.
Part two involves finding the top three Elves and what the total is. This is simple as the list has been sorted so we can find the top three Elves and calculate the total.
<h1>Day 2 - Rock Paper Scissors</h1>
The next puzzle involves Rock Paper Scissors and multiple columns.
This an example input
<pre><code class="language-markdown">A Y
B X
C Z
</code></pre>
The first column is what the opponent will pick. In the above example, A is Rock. The second column is what we should pick in response. In this case, Y is paper. But our response also determines our score. The response we pick has a score and the outcome of the match has a score. So we need to determine what the total score is.
Let’s start by importing our puzzle input in with Python
<pre><code class="language-python">with open('day2Input.txt') as csvFile:
	csv_reader = csv.reader(csvFile, delimiter=' ')
	line_count = 0
	opponentColumn = []
	playerColumn = []
	for row in csv_reader:
		opponentColumn.append(f'{row[0]}')
		playerColumn.append(f'{row[1]}')
</code></pre>
This is incredibly similar to day 1 with a small change, we’re using a delimiter. We know that the columns are separated by a space on each row, so by using the delimiter we can append each value to separate lists.
Moving on, let’s create the logic for calculating the score.
<pre><code class="language-python">for i in opponentColumn:
	numOfRounds += 1

while round &#x3C; numOfRounds:
	print("Playing Rock, Paper, Scissors!")
	print(f"Round - {round}")
	print(f"Opponent picked - {opponentColumn[round]}")
	print(f"You picked - {playerColumn[round]}")

	if opponentColumn[round] == 'A' and playerColumn[round] == 'X':
		print('TIE')
		# shape
		playerScore += 1
		# match result
		playerScore += 3

	if opponentColumn[round] == 'A' and playerColumn[round] == 'Y':
		print('WIN')
		# shape
		playerScore += 2
		# match result
		playerScore += 6

	if opponentColumn[round] == 'A' and playerColumn[round] == 'Z':
		print('LOSE')
		# shape
		playerScore += 3
		# match result
		playerScore += 0

	if opponentColumn[round] == 'B' and playerColumn[round] == 'X':
		print('LOSE')
		# shape
		playerScore += 1
		# match result
		playerScore += 0

	if opponentColumn[round] == 'B' and playerColumn[round] == 'Y':
		print('TIE')
		# shape
		playerScore += 2
		# match result
		playerScore += 3

	if opponentColumn[round] == 'B' and playerColumn[round] == 'Z':
		print('WIN')
		# shape
		playerScore += 3
		# match result
		playerScore += 6

	if opponentColumn[round] == 'C' and playerColumn[round] == 'X':
		print('WIN')
		# shape
		playerScore += 1
		# match result
		playerScore += 6

	if opponentColumn[round] == 'C' and playerColumn[round] == 'Y':
		print('LOSE')
		# shape
		playerScore += 2
		# match result
		playerScore += 0

	if opponentColumn[round] == 'C' and playerColumn[round] == 'Z':
		print('TIE')
		# shape
		playerScore += 3
		# match result
		playerScore += 3

	round += 1

print('Finish!')

print(f'Total score is {playerScore}')
</code></pre>
It’s not the most graceful solution to the problem, but it solves the puzzle! It’s a series of if statements that goes through each possible scenario and assigns points to the total.
Part two of the puzzle reveals that the second column is how the match needs to end; win, tie or lose. So we need to make a few adjustments to what we had wrote
<pre><code class="language-python">while round &#x3C; numOfRounds:
	print("Playing Rock, Paper, Scissors!")
	print(f"Round - {round}")
	print(f"Opponent picked - {opponentColumn[round]}")
	print(f"You picked - {playerColumn[round]}")

	if opponentColumn[round] == 'A' and playerColumn[round] == 'X':
		print('LOSE')
		# shape
		playerScore += 3
		# match result
		playerScore += 0

	if opponentColumn[round] == 'A' and playerColumn[round] == 'Y':
		print('TIE')
		# shape
		playerScore += 1
		# match result
		playerScore += 3

	if opponentColumn[round] == 'A' and playerColumn[round] == 'Z':
		print('WIN')
		# shape
		playerScore += 2
		# match result
		playerScore += 6

	if opponentColumn[round] == 'B' and playerColumn[round] == 'X':
		print('LOSE')
		# shape
		playerScore += 1
		# match result
		playerScore += 0

	if opponentColumn[round] == 'B' and playerColumn[round] == 'Y':
		print('TIE')
		# shape
		playerScore += 2
		# match result
		playerScore += 3

	if opponentColumn[round] == 'B' and playerColumn[round] == 'Z':
		print('WIN')
		# shape
		playerScore += 3
		# match result
		playerScore += 6

	if opponentColumn[round] == 'C' and playerColumn[round] == 'X':
		print('LOSE')
		# shape
		playerScore += 2
		# match result
		playerScore += 0

	if opponentColumn[round] == 'C' and playerColumn[round] == 'Y':
		print('TIE')
		# shape
		playerScore += 3
		# match result
		playerScore += 3

	if opponentColumn[round] == 'C' and playerColumn[round] == 'Z':
		print('WIN')
		# shape
		playerScore += 1
		# match result
		playerScore += 6

	round += 1

print('Finish!')

print(f'Total score is {playerScore} PART TWO')
</code></pre>
Just a small adjustment to the if statements and the puzzle is solved.
I know that this isn’t exactly entertaining, yet…
<h1>Day 3 - Rucksacks</h1>
This was a little tricky. Day 3 did increase the difficulty of the puzzles.
So, the Elves have rucksacks, that have two compartments. And we need to find the item type that appears in both compartments of each rucksack. A rucksack always has the same number of items in each of its two compartments.
So for this example:
<pre><code class="language-markdown">vJrwpWtwJgWrhcsFMMfFFhFp
</code></pre>
We can split this in half to find the two items and that the common character between the two is a lowercase p (the item type)
But each item type has a priority value. Lowercase a to z (1 to 26). Uppercase A to Z (27 to 52).
So we need to find the sum of all the item types across all the rucksacks.
Let’s get started by importing the data:
<pre><code class="language-python">with open('day3Input.txt') as csvFile:
 csv_reader = csv.reader(csvFile)
 line_count = 0
 for row in csv_reader:
 rucksacks.append(f"".join(row))
</code></pre>
And creating our dictionary of the values per item type
<pre><code class="language-python">lettersScore = {
 'a': 1,
 'b': 2,
 'c': 3,
 'd': 4,
 'e': 5,
 'f': 6,
 'g': 7,
 'h': 8,
 'i': 9,
 'j': 10,
 'k': 11,
 'l': 12,
 'm': 13,
 'n': 14,
 'o': 15,
 'p': 16,
 'q': 17,
 'r': 18,
 's': 19,
 't': 20,
 'u': 21,
 'v': 22,
 'w': 23,
 'x': 24,
 'y': 25,
 'z': 26,
 'A': 27,
 'B': 28,
 'C': 29,
 'D': 30,
 'E': 31,
 'F': 32,
 'G': 33,
 'H': 34,
 'I': 35,
 'J': 36,
 'K': 37,
 'L': 38,
 'M': 39,
 'N': 40,
 'O': 41,
 'P': 42,
 'Q': 43,
 'R': 44,
 'S': 45,
 'T': 46,
 'U': 47,
 'V': 48,
 'W': 49,
 'X': 50,
 'Y': 51,
 'Z': 52
}
</code></pre>
I know, it’s not elegant.
And now, for the logic for calculating the sum of the item types in each rucksack
<pre><code class="language-python"># part one
for i in rucksacks:
 firstPartMatch = []
 tempListFull = [*i]
 # slicing strings
 tempListFirst = [*i[:int(len(i) / 2)]]
 tempListSecond = [*i[int(len(i) / 2):]]
 is_looping = True
 for i in tempListSecond:
 for x in tempListFirst:
 if i == x:
 totalSum += lettersScore[x]
 is_looping = False
 break
 if not is_looping:
 break

print(totalSum)
totalSum = 0
</code></pre>
There’s a lot going on in the first few lines so let’s break it down.
In this for loop:
<ul>
<li>tempListFull is created by unpacking an item. This creates a list of the individual characters.</li>
<li>Next we begin splitting the string into two separate lists (tempListFirst and tempListSecond). We use unpacking and slicing. The calculation is the same but the colon is in different places depending on if it’s the first half or the second half of the string we need.</li>
<li>In the next for loop:
<ul>
<li>We iterate each character in both lists. We compare an item from the first half to each character in the second half. If there’s a match, it’ll find the value of that character and add it to the total score.</li>
<li>At this stage, we set a boolean to false. This is important as we need it to break out of the nested for loop.</li>
<li>If the boolean is false, we break out of the nested loop.</li>
</ul>
</li>
</ul>
After the loop is complete, we print out the total sum. Puzzle completed!
Except there is a part two
Now we need to find the matching character against three items.
<pre><code class="language-python">elf_rucksack = []
for i in rucksacks:
 unpacked_item = [*i]
 elf_rucksack.append(unpacked_item)
 if len(elf_rucksack) == 3:
 first_item = elf_rucksack[0]
 second_item = elf_rucksack[1]
 third_item = elf_rucksack[2]
 is_looping = True
 for x in first_item:
 for y in second_item:
 if x == y:
 match_char = x
 for z in third_item:
 if z == x:
 totalSum += lettersScore[x]
 is_looping = False
 break
 break
 if not is_looping:
 elf_rucksack.clear()
 first_item.clear()
 second_item.clear()
 third_item.clear()
 break
print(totalSum)
</code></pre>
Ohhhh boy this looks fun. Let’s break it down.
<ul>
<li>So, we unpack the item from the list and then append it to a new list, elf_rucksack. We keep doing this until there are three items</li>
<li>Once there are three items, we take each item and assign it to either first item, second item or third item.</li>
<li>In the next nested For loops:
<ul>
<li>We check characters from the first two items and try to find a matching character.</li>
<li>If there is a matching character, we move into the next for loop.
<ul>
<li>We compare the matching character to characters in the third item. If there is a match, we use the dictionary to find the score and add it to the total.</li>
</ul>
</li>
<li>Now we break out of the loop (twice)</li>
</ul>
</li>
<li>And use the boolean variable again to break out of the nested loop entirely.</li>
<li>And finally print the total</li>
</ul>
And that is day 3 completed!
<h1>Conclusion</h1>
The first two days were not as challenging as day three. It was good to use slicing and unpacking as part of solving day three as I haven’t used that in a while. I’m not sure if I’ll complete all 25 challenges (as the puzzles do get complex) but I’ll see how many I can solve!

Advent of Code 2022 - days 1, 2 and 3

<img src="https://images.unsplash.com/photo-1600244283510-53b0e34e908d?ixlib=rb-4.0.3&#x26;ixid=MnwxMjA3fDB8MHxzZWFyY2h8NDR8fGZvcm11bGElMjAxfGVufDB8fDB8fA%3D%3D&#x26;auto=format&#x26;fit=crop&#x26;w=900&#x26;q=60" alt="">
The season may have ended, but the analysis hasn’t! (And it will continue with the next season...)
Now we have a full set of results, we can look into performing some deeper analysis.
In case you haven’t cloned the repo to play around with the data, view the repo on GitHub <a href="https://github.com/JB-26/f1-2022-analysis">here</a>. Remember that you will need to have Python <a href="https://python-poetry.org/">Poetry</a> installed for dependency management.
Let’s jump in!
<h2>Average number of points per team</h2>
What would be interesting to see is the average number points for each team, across all the races. Since I have a CSV file of the results of each race, we can use that to calculate the average number of points. So let’s do some initial set up work:
First, load the data and create an empty data frame.
<pre><code>raceResults = pd.read_csv('data/compiled-data/race-results.csv')
raceResults.head()

avgPoints = pd.DataFrame()
avgPoints = avgPoints.assign(Team = '', AvgPoints = '')
avgPoints.head()
</code></pre>
At first, I took this approach for finding the average for each time:
<pre><code>redBull = raceResults.loc[raceResults['Car'] == 'Red Bull Racing RBPT']
redBull.head()
redBull['PTS'].mean()
</code></pre>
And I repeated this for the Ferrari team, as well as Red Bull.
At this point, I thought to myself; there must be a better way of doing this! And there was!
I decided to create an array of the team names, that is used in a for loop.
<pre><code>teamNameArray = ['Ferrari', 'Red Bull Racing RBPT', 'Mercedes', 'McLaren Mercedes', 'Alpine Renault', 'Alfa Romeo Ferrari', 'AlphaTauri RBPT', 'Williams Mercedes', 'Aston Martin Aramco Mercedes', 'Haas Ferrari']
len(teamNameArray)

for i in teamNameArray:
 testRes = round(raceResults.loc[raceResults['Car'] == i]['PTS'].mean(), 2)
 avgPoints.loc[-1] = [i, testRes]
 avgPoints.index = avgPoints.index + 1

avgPoints.sort_values(by='AvgPoints', inplace=True, ascending=False)
</code></pre>
The loop is interesting as it uses the <a href="https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.loc.html?highlight=loc#pandas.DataFrame.loc">loc</a> property to find any row that matches the team name. Then, the ‘round’ function is used when formatting the average calculated from Pandas (set to 2 decimal places). The team name and average score is then added to the data frame (with the index shifted afterwards).
With the data ready, let’s visualise the results with <a href="https://seaborn.pydata.org/">seaborn</a>.
<pre><code>avgSpeedPlotTeam = sns.barplot(x='Team', y='AvgFastestLap', data=avgFastestLapTeam)
avgSpeedPlotTeam.set_xticklabels(avgSpeedPlotTeam.get_xticklabels(), rotation=45, horizontalalignment='right')
</code></pre>
<img src="https://i.imgur.com/7xahoT3.png" alt="">
It’s clear that Red Bull Racing is in a league of their own. However, what’s interesting is that you can ‘group’ the other teams together. Ferrari and Mercedes are close together, and Alpine and McLaren are close together as well and so on for the other teams.
<h2>The average speed for each of the teams</h2>
So, the average points show that Red Bull were clearly performing well throughout the season, but can we say the same for the average speed throughout the season?
The answer, not really. In fact, it was very close!
Let’s build out the data we need:
<pre><code>avgSpeedTeam = pd.DataFrame()
avgSpeedTeam = avgSpeedTeam.assign(Team = '', AvgSpeed = '')
avgSpeedTeam.head()

for i in teamNameArray:
 testRes = round(fastestLap.loc[fastestLap['CAR'] == i]['AVG_SPEED'].mean(), 2)
 avgSpeedTeam.loc[-1] = [i, testRes]
 avgSpeedTeam.index = avgSpeedTeam.index + 1

avgSpeedTeam.sort_values(by='AvgSpeed', inplace=True, ascending=False)
</code></pre>
Similar setup to before, a loop that calculates the average speed for each team and then adds it to the data frame.
And let’s build the graph:
<pre><code>avgSpeedPlotTeam = sns.barplot(x='Team', y='AvgSpeed', data=avgSpeedTeam)
avgSpeedPlotTeam.set_xticklabels(avgSpeedPlotTeam.get_xticklabels(), rotation=45, horizontalalignment='right')
</code></pre>
Which shows…
<img src="https://i.imgur.com/PHZbWCl.png" alt="">
The average speed across the teams are somewhat similar, as opposed to the average number of points across the teams.
<h2>Bonus - Linear Regression</h2>
And for a bonus, I decided to create a graph that shows a line of linear regression.
But to do that, I'd need to merge two data frames together. Which is done like so:
<pre><code>df1 = avgFastestLapTeam
df2 = avgSpeedTeam

mergedDf = pd.merge(df1, df2, on="Team", how="inner")
</code></pre>
(Note that an inner merge was used)
The frames that were merged now have the average fastest lap and the average speed for all the teams. This will be used in creating the graph that shows the line of linear regression.
Now that we have a merged data frame, we can make a plot of linear regression like so:
<pre><code>linearRegFl = sns.lmplot(data=mergedDf, x='AvgFastestLap', y='AvgSpeed')
</code></pre>
<img src="https://i.imgur.com/FSxpK71.png" alt="">
Looks great!
Now I could add a hue to the plot for the teams, which would make sense. However, when this is applied...
<img src="https://i.imgur.com/fEEs8h7.png" alt="">
It doesn't create the line of linear regression. It does tell us that the top scoring teams do have a high average speed and fastest lap.
<h2>Conclusion</h2>
And that wraps up this post on analysing these results, be sure to clone the repo if you want to take a full look at the Jupyter notebook. Plus, the plots have been saved to a folder under the data directory if you want to view them.
Thanks for reading!

Making bar graphs, linear regression and merging with Pandas and Seaborn!

F1 Data Science Project part 5 - analysis with Pandas and Seaborn!

<img src="https://images.unsplash.com/photo-1537029271773-31e5422be11c?ixlib=rb-4.0.3&#x26;ixid=MnwxMjA3fDB8MHxzZWFyY2h8MTV8fGZvcm11bGElMjAxfGVufDB8fDB8fA%3D%3D&#x26;auto=format&#x26;fit=crop&#x26;w=900&#x26;q=60" alt="">
I’m determined to finish this project (what does finished even look like for this project?) by the end of this year. There’s only two races left of the season and there’s already a winner, for both the world champion and constructors.
If you haven't seen the GitHub repo for this yet, be sure to check out the link <a href="https://github.com/JB-26/f1-2022-analysis">here</a>. And remember, you will need <a href="https://python-poetry.org/">Poetry</a> installed first to use the Jupyter notebooks.
So, I decided to update the project with new data and also decided to do something that I have been needing to do for a long time…
Refactor
Yes, there has been a need to refactor a large amount of the Python code. The problem was that whenever I needed to add a new set of race results, I copied the code that took the new race data and added it to the race results data frame. All I had to do was change a few names of variables and a string.
This as you can imagine, the main problems with this are:
<ul>
<li>Mistakes being made when updating variables and strings</li>
<li>It looks super messy</li>
<li>Difficult to read</li>
</ul>
This was done for each race, and it was just turning into a mess. So I decided to refactor the entire Jupyter notebook for race data and fastest lap.
The functions in particular that I have refactored are the following:
Analysis
<pre><code>driver_count = 0

while driver_count &#x3C; len(bahrain_df.index):
 pos = bahrain_df.loc[driver_count, 'Pos']
 driverNo = bahrain_df.loc[driver_count, 'No']
 name = bahrain_df.loc[driver_count, 'Driver']
 car = bahrain_df.loc[driver_count, 'Car']
 laps = bahrain_df.loc[driver_count, 'Laps']
 time = bahrain_df.loc[driver_count, 'Time/Retired']
 points = bahrain_df.loc[driver_count, 'PTS']

 # add row
 race_results.loc[-1] = [pos, name, car, laps, time, points, 'BAHRAIN']
 # shift the index
 race_results.index = race_results.index + 1
 driver_count += 1

race_results.head()
</code></pre>
Fastest lap
<pre><code>driver_count = 0

while driver_count &#x3C; len(fl_bahrain.index):
 time = fl_bahrain.loc[driver_count, 'TIME']
 driverNo = fl_bahrain.loc[driver_count, 'NO']
 name = fl_bahrain.loc[driver_count, 'DRIVER']
 avg_speed = fl_bahrain.loc[driver_count, 'AVG SPEED']
 car = fl_bahrain.loc[driver_count, 'CAR']
 if time == 'DNF':
 driver_count += 1
 else:
 #time = re.sub(r'[^0-9.]', '', time)
 #timeFloat = float(time)
 formattedTime = datetime.strptime(time,'%M:%S.%f')
 formattedTime = formattedTime.strftime('%H:%M:%S.%f')[:-5]
 #finalTime = timeFloat + fastest_lap_bahrain_time.strftime('%M:%S.%f')[:-3]
 # add row
 fastest_lap.loc[-1] = [driverNo, name, car, 'BAHRAIN', formattedTime, avg_speed]
 # shift the index
 fastest_lap.index = fastest_lap.index + 1
 driver_count += 1

# CONVERT FL COLUMN TO TIMEDELTA FORMAT
fastest_lap['FL'] = pd.to_timedelta(fastest_lap['FL'])
fastest_lap.head()

</code></pre>
As you could imagine, having these blocks of code repeated for each race made the Jupyter notebooks hard to read! So refactoring was needed to make it easier and better.
So, let’s dive in with the analysis function first.
<h3>Analysis</h3>
From the code block above, we can see several places where a parameter can be used:
<ul>
<li>The name of the country (in capitals)</li>
<li>The specific race data frame</li>
<li>The data frame for all the race data itself</li>
</ul>
But apart from just taking the code and putting it into a function, I thought it could have the ability to pass in a boolean to change if the user wanted to commit the results to the data frame or just see a preview of the results.
So the function then changed to look like this:
<pre><code>def addRaceData(country_df, country_name, race_results, commit_mode):
 "Adds race data to the race_results data frame."
 driver_count = 0

 print("Adding data for " + country_name)
 try:
 if(commit_mode == True):
 print("Commit mode is set to TRUE - data WILL be added to the race results data frame!")
 while driver_count &#x3C; len(country_df.index):
 pos = country_df.loc[driver_count, 'Pos']
 driverNo = country_df.loc[driver_count, 'No']
 name = country_df.loc[driver_count, 'Driver']
 car = country_df.loc[driver_count, 'Car']
 laps = country_df.loc[driver_count, 'Laps']
 time = country_df.loc[driver_count, 'Time/Retired']
 points = country_df.loc[driver_count, 'PTS']

 # add row
 race_results.loc[-1] = [pos, name, car, laps, time, points, country_name]
 # shift the index
 race_results.index = race_results.index + 1
 driver_count += 1

 print("Race data for " + country_name + " has been added")

 elif(commit_mode == False):
 print("Commit mode is set to FALSE - data will NOT be added to the race results data frame!")
 print("Here's what would've been added to the race results data frame")
 while driver_count &#x3C; len(country_df.index):
 pos = country_df.loc[driver_count, 'Pos']
 driverNo = country_df.loc[driver_count, 'No']
 name = country_df.loc[driver_count, 'Driver']
 car = country_df.loc[driver_count, 'Car']
 laps = country_df.loc[driver_count, 'Laps']
 time = country_df.loc[driver_count, 'Time/Retired']
 points = country_df.loc[driver_count, 'PTS']

 print(pos, name, car, laps, time, points, country_name)
 driver_count += 1

 print("Race data for " + country_name + " has NOT been added")

 except:
 print("ERROR! Double check the arguments provided for the function.\nHave you imported the race data CSV?\nHas the race_results data frame been created?")

</code></pre>
Which is great! However, regardless if a True or False boolean is passed in, I’m repeating the functionality of creating variables. This honestly should only happen once, all that matters is if a new row should be added or not.
So let’s do some more improvements:
<pre><code>def addRaceData(country_df, country_name, race_results, commit_mode):
 "Adds race data to the race_results data frame."
 driver_count = 0

 print("Adding data for " + country_name)
 print("Commit mode is set to " + str(commit_mode))

 try:
 while driver_count &#x3C; len(country_df.index):
 pos = country_df.loc[driver_count, 'Pos']
 driverNo = country_df.loc[driver_count, 'No']
 name = country_df.loc[driver_count, 'Driver']
 car = country_df.loc[driver_count, 'Car']
 laps = country_df.loc[driver_count, 'Laps']
 time = country_df.loc[driver_count, 'Time/Retired']
 points = country_df.loc[driver_count, 'PTS']

 if(commit_mode):
 # add row
 race_results.loc[-1] = [pos, name, car, laps, time, points, country_name]

 else:
 # print row
 print(pos, name, car, laps, time, points, country_name)

 driver_count += 1

 # shift the index
 race_results.index = race_results.index + 1

 except:
 print("ERROR! Double check the arguments provided for the function.\nHave you imported the race data CSV?\nHas the race_results data frame been created?")

</code></pre>
Which looks much better. This function is now easier to read, and we can tell if the user passes in True or False, we can tell what the outcome would be.
And now adding race data looks like this:
<pre><code>addRaceData(bahrain_df, "BAHRAIN", race_results, True)
</code></pre>
Much better!
<h3>Fastest lap</h3>
The fastest lap was a similar situation, a few spots where arguments could be used in the function:
<ul>
<li>The fastest lap for the race</li>
<li>The country name</li>
<li>The fastest lap data frame</li>
</ul>
Here’s the first iteration of the function:
<pre><code>def addFastestLaps(fl_country, country_name, fastest_lap, commit_mode):
 driver_count = 0

 print("Adding data for " + country_name)
 try:
 if(commit_mode==True):
 print("Commit mode is set to TRUE - data WILL be added to the fastest lap data frame!")
 while driver_count &#x3C; len(fl_country.index):
 time = fl_country.loc[driver_count, 'Time']
 driverNo = fl_country.loc[driver_count, 'No']
 name = fl_country.loc[driver_count, 'Driver']
 avg_speed = fl_country.loc[driver_count, 'Avg Speed']
 car = fl_country.loc[driver_count, 'Car']
 if time == 'DNF':
 driver_count += 1
 else:
 #time = re.sub(r'[^0-9.]', '', time)
 #timeFloat = float(time)
 formattedTime = datetime.strptime(time,'%M:%S.%f')
 formattedTime = formattedTime.strftime('%H:%M:%S.%f')[:-5]
 #finalTime = timeFloat + fastest_lap_bahrain_time.strftime('%M:%S.%f')[:-3]
 # add row
 fastest_lap.loc[-1] = [driverNo, name, car, country_name, formattedTime, avg_speed]
 # shift the index
 fastest_lap.index = fastest_lap.index + 1
 driver_count += 1

 # CONVERT FL COLUMN TO TIMEDELTA FORMAT
 fastest_lap['FL'] = pd.to_timedelta(fastest_lap['FL'])
 print("Data for " + country_name + " has been added!")

 elif(commit_mode==False):
 print("Commit mode is set to FALSE - data will NOT be added to the fastest lap data frame!")
 while driver_count &#x3C; len(fl_country.index):
 time = fl_country.loc[driver_count, 'Time']
 driverNo = fl_country.loc[driver_count, 'No']
 name = fl_country.loc[driver_count, 'Driver']
 avg_speed = fl_country.loc[driver_count, 'Avg Speed']
 car = fl_country.loc[driver_count, 'Car']
 if time == 'DNF':
 driver_count += 1
 else:
 #time = re.sub(r'[^0-9.]', '', time)
 #timeFloat = float(time)
 formattedTime = datetime.strptime(time,'%M:%S.%f')
 formattedTime = formattedTime.strftime('%H:%M:%S.%f')[:-5]
 #finalTime = timeFloat + fastest_lap_bahrain_time.strftime('%M:%S.%f')[:-3]
 print(driverNo, name, car, country_name, formattedTime, avg_speed)
 driver_count += 1

 except:
 print("ERROR! Double check the arguments provided for the function.\nHave you imported the race data CSV?\nHas the fastest_lap data frame been created?")

</code></pre>
Similar to the analysis function, I added an additional argument for a commit mode.
And once again I had fallen into the same hole, regardless of if you pass in True or False, the code to create the variables is repeated. So there is room for improvement.
And after some more refactoring:
<pre><code>def addFastestLaps(fl_country, country_name, fastest_lap, commit_mode):
 driver_count = 0

 print("Adding data for " + country_name)
 print("Commit mode is set to " + str(commit_mode))
 try:
 while driver_count &#x3C; len(fl_country.index):
 time = fl_country.loc[driver_count, 'Time']
 driverNo = fl_country.loc[driver_count, 'No']
 name = fl_country.loc[driver_count, 'Driver']
 avg_speed = fl_country.loc[driver_count, 'Avg Speed']
 car = fl_country.loc[driver_count, 'Car']
 # shift the index
 fastest_lap.index = fastest_lap.index + 1
 if time == 'DNF':
 driver_count += 1
 else:
 driver_count += 1
 #time = re.sub(r'[^0-9.]', '', time)
 #timeFloat = float(time)
 formattedTime = datetime.strptime(time,'%M:%S.%f')
 formattedTime = formattedTime.strftime('%H:%M:%S.%f')[:-5]
 #finalTime = timeFloat + fastest_lap_bahrain_time.strftime('%M:%S.%f')[:-3]
 if(commit_mode):
 # add row
 fastest_lap.loc[-1] = [driverNo, name, car, country_name, formattedTime, avg_speed]
 # CONVERT FL COLUMN TO TIMEDELTA FORMAT
 fastest_lap['FL'] = pd.to_timedelta(fastest_lap['FL'])
 else:
 fastest_lap['FL'] = pd.to_timedelta(fastest_lap['FL'])
 print(driverNo, name, car, country_name, formattedTime, avg_speed)

 except:
 print("ERROR! Double check the arguments provided for the function.\nHave you imported the race data CSV?\nHas the fastest_lap data frame been created?")

</code></pre>
That’s much better! And calling this function to add the fastest lap data now looks like this:
<pre><code>addFastestLaps(fl_bahrain, "BAHRAIN", fastest_lap, True)
</code></pre>
Hooray! Much better!
<h3>But things were not quite right, just yet…</h3>
After I updated the functions and tested it on one set of data, I updated the notebook to use the new functions.
But in a few scenarios, my function would fall over (this is why you have try and except statements!)
I was confused, the data frame that held the data for the race was created, and the data frame to hold all the data was populated with data as expected. So what gives?
Case sensitivity
Yes, case sensitivity. Several CSV files were different on the headers. Some were lower case, and some were upper case. The header names are case sensitive when working with Pandas.
So, I updated the CSV files to ensure they are each the same. This meant updating over ten files to ensure that the headers all match. And then it worked, I could export the completed results to a CSV file!
<h3>But things were STILL not quite right…</h3>
I noticed in the fastest lap data frame that the fastest lap column was showing incorrect data. It would display the fastest lap as:
<pre><code>P0DT0H1M34.600S
</code></pre>
Which is unreadable, I wouldn’t be able to use this to make graphs with any meaning.
So, Fastest Lap has a data type of float64, I needed to find a way to show the value in seconds. Thankfully, there was such a way:
<pre><code>fastest_lap['FL'] = fastest_lap['FL'].dt.total_seconds()
</code></pre>
And this fixed it, crisis averted!
<h3>What next?</h3>
The F1 2022 season is ending soon, so afterwards I’ll be preparing plenty of graphs and perform some more analysis. And I plan on using the data in Tableau to create some interactive charts.
There are several teams and drivers that would be interesting to perform some analysis on.
Stay tuned!

From functions, to wrestling with case sensitivity

F1 Data Science Project part 4 - refactor!

Welcome back to part 3 of my small data science project looking at the 2022 season of F1!
This time, I’m going to be looking at the performance of the two Mercedes drivers; <a href="https://www.formula1.com/en/drivers/lewis-hamilton.html">Lewis Hamilton</a> and <a href="https://www.formula1.com/en/drivers/george-russell.html">George Russell</a>. This will be a shorter blog post this week as I am super busy with other things.
As always, be sure to check out the <a href="https://github.com/JB-26/f1-2022-analysis">GitHub</a> repo if you want to take a look at the work done so far.
For those who don’t know, Lewis has been driving with Mercedes for years and is a world champion. Meanwhile, George has been driving for Williams for a few years and is the newest member on the Mercedes team this year.
The Williams team has had a rough few seasons, even scoring as low as zero points in the <a href="https://www.formula1.com/en/results.html/2020/team.html">2020</a> season and were <a href="https://www.bbc.co.uk/sport/formula1/53860010">bought</a> in 2020. Meanwhile, it seemed that Mercedes were unstoppable. Winning countless races and championships.
So I thought it would be interesting to take a look at their performance. It would be interesting to look how George is doing in a better car.
And the results, were interesting to say the least. This season so far hasn’t been going well for Mercedes, in comparison to other seasons. Lewis is struggling to break into the top 5 overall and the team is sitting in third place (and who knows, they could end up in fourth place this season).
George meanwhile, has been consistently been in the top 5 of each race so far. And the difference in points gained in each race can be shown with this graph:
<img src="https://i.imgur.com/VFUhRyT.png" alt="">
Which was generated with the following:
<pre><code># create plot
plot = sns.relplot(data=mercedes_df, kind='line', x='Race', y='PTS', hue='Driver', markers=True)
plot.set_xticklabels(rotation=90)
</code></pre>
And if you wanted to look at the average amount of points gained in each race so far…
<pre><code>mercedes_df.loc[mercedes_df['Driver'] == 'George Russell']['PTS'].mean()

12.0
</code></pre>
<pre><code>mercedes_df.loc[mercedes_df['Driver'] == 'Lewis Hamilton']['PTS'].mean()

7.142857142857143
</code></pre>
…you’d think that George would be outperforming Hamilton. In terms of points gained per race, yes. But if we take a look at the fastest lap and average speed per race…
<img src="https://i.imgur.com/sGrguaQ.png" alt="">
<pre><code># create plot
plot = sns.relplot(data=mercedes_fastest_lap_df, kind='line', x='RACE', y='FL', hue='DRIVER', markers=True)
plot.set_xticklabels(rotation=90)
</code></pre>
<img src="https://i.imgur.com/qy2wZ5x.png" alt="">
<pre><code># create plot
plot = sns.relplot(data=mercedes_fastest_lap_df, kind='line', x='RACE', y='AVG_SPEED', hue='DRIVER', markers=True)
plot.set_xticklabels(rotation=90)
</code></pre>
…they look to be on par with each other.
In most cases, their speed has remained the same in average speed and the fastest lap. There have only been a few moments where Hamilton had the faster lap than his teammate and the reverse can be said for average speed for each race.
So if their performance is close, then how come the point difference is so big? Is it down to skill and George is wanting to impress? Or is it that Mercedes just don’t have the best car this year?
There are still plenty of races left in the current F1 season so I’ll revisit this area towards the end of the year.
Until next time 👋

A quick post on seeing how the newest driver for Mercedes is doing alongside a world champion.

F1 2022 Data Science Part 3 - the performance of Hamilton and Russell (so far)

Welcome back to part 2 of my series on my project about F1 2022 season with Data Science/Analysis! This week, it's a short update as I am very busy with other things on my plate at the moment.
If you want to take a look at the project and clone it for yourself to play around with it, the repo is <a href="https://github.com/JB-26/f1-2022-analysis">here</a>.
So last time, I explored on creating data frames with Pandas and wrestling with the challenge of timing with time delta. At the end of the previous post, I explained how I transformed the fastest lap timings from the F1 website into something workable with time delta.
Problem is, the format is not exactly how I would like it. Here’s a reminder of how it looks:
<pre><code>NO 1.0
FL 0 days 00:01:29.633333333
AVG_SPEED 226.321333
</code></pre>
Trying to put this onto a plot with Seaborn won’t look right. I don’t want to display 0 days 00:01:29.633333 etc for every point, I’d like it to look slightly more readable.
So I decided to do some research.
Turns out, it’s quite easy!
<pre><code># convert column to timedelta
fastest_lap[‘FL’] = pd.to_timedelta(fastest_lap[‘FL’])
# get total seconds
fastest_lap['FL'] = fastest_lap['FL'].dt.total_seconds()
</code></pre>
And the total seconds returns information like this:
<pre><code>NO 1.00
FL 87.74
AVG_SPEED 223.50
</code></pre>
Success! This makes things much easier when it comes to calculating the average and plotting data!
Speaking of plotting, let’s take a look at plotting data with <a href="https://seaborn.pydata.org/index.html">Seaborn</a>. I’ve moved work for plotting data into a new Jupiter notebook as the other notebooks were becoming crowded.
So at first I decided to create a <a href="https://seaborn.pydata.org/generated/seaborn.scatterplot.html?highlight=scatterplot#seaborn.scatterplot">scatterplot</a> to try and plot the fastest lap data from the drivers across all races so far (up until Miami at this time of writing). It initially looked good but there was a problem, the labels on the X axis were overlapping with each other.
<img src="https://i.imgur.com/7Zi4qMk.png" alt="">
So I needed to find a way to rotate the labels. Easier said than done, right? Turns out, not quite.
The first hurdle I found was with this code, viewing the X labels
<pre><code>#define figure size
sns.set(rc={"figure.figsize":(10, 7)}) #width=10, height=7
# create plot
plot = sns.scatterplot(data=fl_df, x='DRIVER', y='FL', hue='RACE')
# no xlabels - weird!
plot.get_xticklabels()
</code></pre>
Which returns the following:
<pre><code>[Text(0, 0, ''),
 Text(0, 0, ''),
 Text(0, 0, ''),
 Text(0, 0, ''),
 Text(0, 0, ''),
 Text(0, 0, ''),
 Text(0, 0, ''),
 Text(0, 0, ''),
 Text(0, 0, ''),
 Text(0, 0, ''),
 Text(0, 0, ''),
 Text(0, 0, ''),
 Text(0, 0, ''),
 Text(0, 0, ''),
 Text(0, 0, ''),
 Text(0, 0, ''),
 Text(0, 0, ''),
 Text(0, 0, ''),
 Text(0, 0, ''),
 Text(0, 0, ''),
 Text(0, 0, '')]
</code></pre>
The list of the labels is blank! That doesn’t look right (maybe it’s a bug with Seaborn?)
So I decided to repopulate the list and then rotate the labels by 90 degrees.
<pre><code>#define figure size
sns.set(rc={"figure.figsize":(10, 7)}) #width=10, height=7
# create plot
plot = sns.scatterplot(data=fl_df, x='DRIVER', y='FL', hue='RACE')
# no xlabels - weird!
plot.get_xticklabels()
# add the xlabels and rotate!
plot.set_xticklabels(fl_df['DRIVER'].tolist(), rotation=90)
</code></pre>
So now the X labels list looks like this:
<pre><code>[Text(0, 0, 'Max Verstappen'),
 Text(1, 0, 'Charles Leclerc'),
 Text(2, 0, 'Carlos Sainz'),
 Text(3, 0, 'Sergio Perez'),
 Text(4, 0, 'George Russell'),
 Text(5, 0, 'Mick Schumacher'),
 Text(6, 0, 'Lewis Hamilton'),
 Text(7, 0, 'Yuki Tsunoda'),
 Text(8, 0, 'Esteban Ocon'),
 Text(9, 0, 'Valtteri Bottas'),
 Text(10, 0, 'Daniel Ricciardo'),
 Text(11, 0, 'Lance Stroll'),
 Text(12, 0, 'Fernando Alonso'),
 Text(13, 0, 'Lando Norris'),
 Text(14, 0, 'Alexander Albon'),
 Text(15, 0, 'Sebastian Vettel'),
 Text(16, 0, 'Kevin Magnussen'),
 Text(17, 0, 'Nicholas Latifi'),
 Text(18, 0, 'Pierre Gasly'),
 Text(19, 0, 'Zhou Guanyu'),
 Text(20, 0, 'Max Verstappen')]
</code></pre>
And the plot looks like this!
<img src="https://i.imgur.com/6JlEMRj.png" alt="">
That’s much better!
I decided to play around with several different setups for a scatter plot…
<img src="https://i.imgur.com/1x0n7Sr.png" alt="">
…with limited success.
The graph above is difficult to read with all the drivers. So maybe instead of looking at the performance of all the drivers, why not focus on one driver?
So in this example, I’ll look at Lando Norris (who drives for McLaren). I decided to take a look at visualising the data.
Here’s a quick example:
<pre><code># Looking at Lando Norris
# get data by specific driver
lando = fl_df.loc[fl_df['DRIVER'] == 'Lando Norris']
lando_plot = sns.catplot(x='RACE', y='AVG_SPEED', data=lando, kind='bar', height=7, aspect=2)
</code></pre>
Which results in the following plot:
<img src="https://i.imgur.com/QzoS1R8.png" alt="">
Looks okay, we can see that Lando’s average speed tends to be above 200 MPH.
But of course, the F1 2022 season is far from over. So as more data becomes available, the more we can learn about specific drivers performance!
And that about wraps it up for this update on the F1 2022 project. Thanks for reading! 👋

Wrestling with Time Delta, rotating X labels in Seaborn and visualisation!

F1 2022 Data Science part two - plotting with Seaborn 🧐

Hi! It’s been a while! 👋
What have I been working on recently? I decided to start on a somewhat long term project which looks at combining Data Science/Analysis with a sport that I’m a fan of; <a href="https://www.formula1.com">Formula 1</a>.
The 2022 season is under way and I thought it would be fun to learn more about Python packages such as <a href="https://pandas.pydata.org">Pandas</a> and <a href="https://seaborn.pydata.org/index.html">Seaborn</a> by using them in a project that I could continually work on and share.
So, in this week’s post, I will be going through a brief introduction to the project and share what I’ve done so far. If you want to take a look at the project, feel free to check it out on <a href="https://github.com/JB-26/f1-2022-analysis">GitHub</a>.
<h2>What’s this project about?</h2>
This project is about looking at several statistics from Formula 1 and performing analysis as well as visualising the data.
Areas that are currently planned are:
<ul>
<li>Fastest lap</li>
<li>Points</li>
<li>Speed</li>
</ul>
This will be looked at drivers and teams.
The analysis/data science will be done with Pandas whilst visualisation will be done with Seaborn.
At the moment, this is very much a work in progress.
<h2>Getting the data</h2>
First things first; data.
Thankfully, Formula 1 has this data available on its <a href="https://www.formula1.com/en/results.html/2022/races.html">website</a>. Although it’s not available to download, copy and pasting it into a CSV file is easy enough. So at the moment, the repo has data for the first three races of the season:
<ul>
<li>Bahrain</li>
<li>Saudi Arabia</li>
<li>Australia</li>
</ul>
The repo has the data for the race and the fastest lap data.
<h2>Starting up - fastest lap analysis</h2>
For the overall analysis, the data will need to live in a DataFrame, let’s
<pre><code>fastest_lap = pd.DataFrame()

fastest_lap = fastest_lap.assign(NO = '', DRIVER = '', RACE = '', FL = '', AVG_SPEED = '')
# rename the column header
#fastest_lap.columns = fastest_lap.columns.str.replace('SPEED', 'AVG SPEED')

fastest_lap.head()
</code></pre>
Let’s put those race statistics into DataFrames with Pandas
<pre><code># example of loading csv data
bahrain_df = pd.read_csv("data/BAHRAIN.csv")
bahrain_df.head()
</code></pre>
Looks good!
Now we have some data, we can move onto one of the more challenging aspects. The fastest lap data from each race.
Something I want to do is to calculate the average fastest lap across all races for each driver.
Let’s take an example from the race in Australia. The fastest lap was done by Charles Leclerc which was 01:20.3. Which we know is 1 minute, 20 seconds and 3 milliseconds. However, Python doesn’t know that. If we were to add this to a column in a DataFrame, it would be treated as an object (so you can’t calculate the mean).
Originally, I went down the route of going with the <a href="https://docs.python.org/3/library/datetime.html">datetime</a> data type. But this didn’t work as I intended so I went with <a href="https://docs.python.org/3/library/datetime.html#timedelta-objects">timedelta</a> instead.
But how do we extract the data and covert it?
<h2>Wrestling with time</h2>
So first, I need to get the data from the previous races, extract them and put them in the ‘fastest_lap’ DataFrame.
We can do this with the following:
<pre><code>driver_count = 0

while driver_count &#x3C; len(fl_australia.index):
	time = fl_australia.loc[driver_count, 'TIME']
	driverNo = fl_australia.loc[driver_count, 'NO']
	name = fl_australia.loc[driver_count, 'DRIVER']
	avg_speed = fl_australia.loc[driver_count, 'AVG SPEED']
	if time == 'DNF':
		driver_count += 1
	else:
		#time = re.sub(r'[^0-9.]', '', time)
		#timeFloat = float(time)
		formattedTime = datetime.strptime(time,'%M:%S.%f')
		formattedTime = formattedTime.strftime('%H:%M:%S.%f')[:-5]
		#finalTime = timeFloat + fastest_lap_bahrain_time.strftime('%M:%S.%f')[:-3]
		# add row
		fastest_lap.loc[-1] = [driverNo, name, 'AUSTRALIA', formattedTime, avg_speed]
		# shift the index
		fastest_lap.index = fastest_lap.index + 1
		driver_count += 1

# CONVERT FL COLUMN TO TIMEDELTA FORMAT
fastest_lap['FL'] = pd.to_timedelta(fastest_lap['FL'])
fastest_lap.head()
</code></pre>
This loop would perform the following:
<ul>
<li>Grab information for the driver (using the index value) and assign to variables</li>
<li>If the time is ‘DNF’, then do nothing</li>
<li>If it has a time, then we use the ‘strptime’ method to convert it to a datetime format.</li>
<li>‘strftime’ method to format the milliseconds</li>
<li>Add the row to the ‘fastest_lap’ DataFrame</li>
<li>Increment the driver count variable by 1</li>
<li>Convert the fastest lap column to a ‘timedelta’ type</li>
</ul>
Originally, I converted the column to a ‘timedelta’ type and then added the data into the DataFrame. But what happened is that once the data was added, the data type for the column changed back to ‘object’. So performing any calculations wouldn’t work. This caught me off guard slightly, I was confused at why it was changing the data type.
Which is why I added the convert column to the ‘timedelta’ format when the while loop had completed, that way I know that the data type for the column will be converted.
<h2>Finding data in the (partially) complete DataFrame</h2>
So, now that we have some data (at this time of writing, data from 3 races) we can actually start doing some calculations of getting the mean of the fastest lap.
But first, let’s actually get the data for a driver. Let’s pick Max Verstappen as an example
<pre><code># get data by specific driver
fastest_lap.loc[fastest_lap['DRIVER'] == 'Max Verstappen']
</code></pre>
Great! This returns only Max’s results from the 3 races that have happened so far. Now, we can add the mean method at the end of this like so:
<pre><code># get data by specific driver
fastest_lap.loc[fastest_lap['DRIVER'] == 'Max Verstappen'].mean()
</code></pre>
And this returns the following:
<pre><code>NO 1.0
FL 0 days 00:01:29.633333333
AVG_SPEED 226.321333
</code></pre>
Great! Now we can see the average fastest lap time and speed for Max!
<h2>Next steps</h2>
The next step is to only get the fastest lap result and then reformat the result to show the hour, minute, second and millisecond value (but only to 1 decimal place). Part of this has been achieved in the while loop shown above.
The next big challenge is visualising the data that has been collected. Seaborn will be used in this and I need to decide on what graph should be used.
Then comes the data science part. I was thinking of building a linear regression model to predict the results of races in the future. This would rely on getting the practice data (as before the main race there are practice sessions to determine where each driver will start at).
<h2>Conclusion</h2>
So that’s a brief introduction to my newest project. If you want to take a look, feel free to clone the repo and have a look around!
Thanks for reading! 👋

Who knew working with time could be so frustrating?

An introduction to my new project, Data Science/Analysis meets the 2022 season of F1! 🏎

<img src="https://images.unsplash.com/photo-1608742213509-815b97c30b36?ixlib=rb-1.2.1&#x26;ixid=MnwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8&#x26;auto=format&#x26;fit=crop&#x26;w=2070&#x26;q=80" alt="Terminal">
I’ve been making CLIs for some time now, but I’ve never really considered on how to improve the user experience of using the CLI.
The CLI I wrote for the video game API is an example of where the user experience isn’t great. I’d best describe it as boring and unimaginative.
That’s where I discovered the Python library <a href="https://github.com/willmcgugan/rich">rich</a>! A package that makes it easy to add style and colour to Terminal output.
You can….
<ul>
<li>Choose from over 16 million colours from Truecolor</li>
<li>Choose all ansi styles (including blink!)</li>
<li>Insert Tables</li>
<li>Insert markdown</li>
<li>Add a progress bar</li>
<li>Insert emojis</li>
</ul>
And more!
It’s just what I need to make CLIs look good and user friendly.
So this week on my blog, I’ll be rewriting the Terminal application that sends requests to my video game API! 🖥
Be sure to check out the new repo <a href="https://github.com/JB-26/python-rich">here</a> and the old repo <a href="https://github.com/JB-26/VideoGameAPIPythonCLI">here</a> (so you can compare if you want)
This won’t be the longest blog post as I’ve covered how this CLI works in a previous <a href="https://joshblewitt.dev/blog/2021-07-13-python-requests/">post</a> so if you want to know how the requests library is used, I suggest reading that post (or look at the repo).
<h2>Starting out - improving the Login process</h2>
The first part of the application is to login and retrieve an authorisation token.
The current user experience is incredibly boring. In fact, it can be difficult to alert the user if the login fails.
With rich, I can use colour to highlight if the login was successful (with green) or unsuccessful (with red).
So we’ll get started with improving this process!
This is how it looks in the old version of the CLI
<img src="https://i.imgur.com/Mty0dLi.png" alt="&#x22;Old menu&#x22;">
Looks pretty bad!
And with using Rich…
<img src="https://i.imgur.com/sucV7hz.png" alt="&#x22;New menu&#x22;">
It’s much improved!
And there’s even an animation when logging in!
This looks much better! The user of colours, animations and panels make the overall experience easier and more appealing to use.
How is this achieved with Rich?
Let’s take a look at using panels and colours first.
<h2>Adding colour and panels to the terminal</h2>
Here’s an example of the panel that’s used to greet the user when they load the application:
<pre><code>console.print(Panel.fit(“Welcome to the Video Game API!”, /style/=“bold cyan”))
</code></pre>
You can even add a title and a subtitle with by using the appropriate arguments:
<pre><code>console.print(Panel.fit(“[italic yellow]Please type the letters that are highlighted in green to access data from the API[/italic yellow]\n[bold green]D[/bold green]isplay games\n[bold green]F[/bold green]ind game\n[bold green]U[/bold green]pdate game\n[bold green]A[/bold green]dd game\n[bold green]De[/bold green]lete game\n[bold green]Q[/bold green]uit”, /title/=“Video Game API - Menu 🎮”, /subtitle/=“By Joshua Blewitt”))
</code></pre>
The Rich library has a Console class that has a print method, which is used to print the display panel.
As you can see from the example above, the panel is it’s own class which has it’s own method called ‘fit’. This takes in the message I want to display and (in this case), the style I want to use.
And for colour:
<pre><code>console.print(“[green]Enter your choice[/green]”)
</code></pre>
Using the same console class (where I have created an object in this case), I can use a HTML like syntax for choosing what colour I want.
It’s not just colour, I can even set the text to be bold or italic.
<pre><code>console.print(“[bold red]Your command was invalid! Please try again![/bold red]”)
</code></pre>
<h2>Adding tables to display information</h2>
Let me show you how showing the results from the API used to look:
<img src="https://i.imgur.com/P5ZWovO.png" alt="&#x22;Old table&#x22;">
And with using Rich, it now looks like:
<img src="https://i.imgur.com/y5FWHgi.png" alt="&#x22;New table&#x22;">
This was achieved by using a table:
<pre><code># make a new table
table = Table(show_header=True, header_style="bold magenta")

# configure table
table = Table(show_header=True, header_style="bold magenta")
table.add_column("ID", style="dim", width=12)
table.add_column("Name", justify="center")
table.add_column("Genre", justify="center")
table.add_column("Platform", justify="center")
table.add_column("Publisher", justify="center")
table.add_column("Year", justify="center")

# decode JSON
json_response = json_data.json()
games = json_response.get('Games')

# iterate through response
for i in range(len(games)):
	new_dict = games[i]['Game']
 # add response to table
 table.add_row(f"{new_dict['ID: ']}", f"{new_dict['Name:']}", f"{new_dict['Genre: ']}",f"{new_dict['Platform:']}",f"{new_dict['Publisher: ']}",f"{new_dict['Year']}")
console.print(table)
</code></pre>
By creating and configuring a new table (plus adding rows), allows us to create a table that makes displaying information from the API way easier to read.
Tables are used across many functions, from displaying games to confirming which game has been deleted.
<h2>Using animations when HTTP requests are being sent.</h2>
One thing that bugged me about the previous CLI is the that there is no indication that something is in progress when logging in or retrieving data from the API.
With Rich, we can use animations to let the user know that their request is in progress.
Here’s an example of an animation being used:
<pre><code># display animation to show user that the credentials are being sent to the api
with console.status("[purple]Logging in...[/purple]") as status:
 r = requests.post(f'{apiUrl}/login', headers=headers_login, data=payload)
</code></pre>
Essentially, while the request is being sent, the animation plays! It looks great in motion (see the GIF above!)
If you want to see all the animations that you can use in Rich, run the following in the terminal:
<pre><code>python -m rich.spinner
</code></pre>
<h2>Other changes and improvements</h2>
One of the biggest changes to this project is that the program is no longer a single file. The functions have been spread across multiple files.
There have been some other smaller changes; such as reducing the amount of declared variables when accessing certain JSON properties.
<h2>Wrap up!</h2>
And that’s how I used Rich to improve the CLI for accessing the Video Game API.
Rich makes it easy to make appealing CLIs. I’m definitely planning on using Rich again when I need to work on a CLI related project.
Thanks for reading! 👍

It’s time to make CLI’s look good with rich!

Making slick looking Python CLI’s with rich ✨

<img src="https://images.unsplash.com/photo-1432821596592-e2c18b78144f?ixid=MnwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8&#x26;ixlib=rb-1.2.1&#x26;auto=format&#x26;fit=crop&#x26;w=2070&#x26;q=80" alt="Desk">
Welcome to part two of my coding problems series. Today, we’ll be looking at an interesting problem that had me scratching my head, it got to a point where I needed to look at the solution to the problem.
However, it was a learning experience which I think I learnt some handy tricks to do in Python.
As always, you can take a look at the repo I have for this problem <a href="https://github.com/JB-26/DailyCodingProblem">here</a> (and be sure to check the commit history!)
Here’s the problem:
<blockquote>
Given a string and a number of lines (k), print the string in zigzag form. 
In zigzag, characters are printed out diagonally from top left to bottom right until reaching the k line, then back up to top right, and so on.
Example: 
Sentence is “thisisazigzag” and k = 4 will print:
t a g
h s z a
I I I z
s g
</blockquote>
I originally thought that was was going to be a problem that I could solve. But the more I thought about it, I realised that this was going to be a difficult problem to solve.
Originally I approached the problem in several ways:
<ul>
<li>Convert the sentence to a list, then iterate over each item in the list with spaces and print them to the console. But I realised that this wasn’t possible as I need to descend and ascend to from the zigzag.</li>
<li>Then I went down the route of concatenating parts of the zigzag to a string. But still needed to think of how to make the zigzag descend and ascend when needed.</li>
</ul>
After several attempts (and several days), I decided to take a look at the answer and I could feel my mind unlock something about programming that I had been working towards for a while.
The biggest obstacle for me on this problem was on how to approach ascending and descending to build the zigzag.
The solution suggested the following
<ul>
<li>Create a list of empty strings which is the length of the sentence that was provided.</li>
<li>Check if descending if the current row through oscillation back to the starting point.</li>
<li>If it’s descending, add spaces, else remove spaces.</li>
</ul>
The part of how to create the list made something click in my brain on understanding programming.
<pre><code>line = [" " for _ in range(sentenceLength)]
</code></pre>
Creating the list using a for statement made a lot of sense. I decided to take another stab at trying to figure out an algorithm for adding and removing spaces. I couldn’t get far as I struggled of getting all the needed characters for each line with the appropriate spacing.
That’s where things get slightly complex.
For calculating the spaces needed, the following algorithm is suggested.
<pre><code># function for getting spaces
def get_spaces(row, desc, k):
 # calculate the maximum space length
 spaceLength = (k - 1) * 2 - 1

 # check if descending (add spaces)
 if desc:
 spaces = spaceLength - row * 2
 # or if ascending (remove spaces)
 else:
 spaces = spaceLength - (k - 1 - row) * 2

 return spaces
</code></pre>
The maximum space length is calculated by:
<ul>
<li>Taking the number of lines (k) and subtracting 1</li>
<li>Multiplying by 2</li>
<li>Subtracting by 1</li>
</ul>
If the descending boolean value was true, then spaces are added. If it’s false, then spaces are removed.
For checking if it’s descending:
<pre><code># function for checking if descending
def is_desc(index, k):
 # back to the starting point - will return true or false
 # compares calculated result to the sentence length - 1
 return index % (2 * (k - 1)) &#x3C; k - 1
</code></pre>
This will take the current row of the zigzag and the number of lines. And calculate if the current row (calculating the remainder, multiplying it by the number of lines minus one) and if that value is less than the number of lines minus one. This will return a boolean.
So, let’s put this all together!
<pre><code># THE PROBLEM
# Given a string and a number of lines (k), print the string in zigzag form.
# In zigzag, characters are printed out diagonally from top left to bottom right until reaching the k line, then back up to top right, and so on.
# Example
# Sentence is "thisisazigzag" and k = 4 will print:
#
# t a g
# h s z a
# i i i z
# s g

# create string
sentence = "thisisazigzag"
# number of lines
k = 4

def zigzag(sentence, k):
 # get sentence length
 sentenceLength = len(sentence)

 for row in range(k):
 i = row
 # creates a list of spaces (strings)
 line = [" " for _ in range(sentenceLength)]

 # this while loop takes the list and populates it with the correct value from the sentence (on both sides of the zigzag)
 while i &#x3C; sentenceLength:
 # check if zigzag is descending or not
 line[i] = sentence[i]
 desc = is_desc(i, k)
 newSpaces = get_spaces(row, desc, k)
 i += newSpaces + 1

 print("".join(line))

# function for getting spaces
def get_spaces(row, desc, k):
 # calculate the maximum space length
 spaceLength = (k - 1) * 2 - 1

 # check if descending (add spaces)
 if desc:
 spaces = spaceLength - row * 2
 # or if ascending (remove spaces)
 else:
 spaces = spaceLength - (k - 1 - row) * 2
 return spaces

# function for checking if descending
def is_desc(index, k):
 # back to the starting point - will return true or false
 # compares calculated result to the sentence length - 1
 return index % (2 * (k - 1)) &#x3C; k - 1

zigzag(sentence, k)
</code></pre>
So that’s the zigzag! I learnt a lot on how to approach a problem. What’s important is that attempting to solve it allowed me to explore different ideas and expand my knowledge.
Trying to solve these problems is a good way of testing on how much you know of a language. It’s all well and good making small applications but these problems challenges your thinking.
Next time, why should you start a blog?
Thanks for reading! 👏

Who knew trying to create a zigzag from a string could be so difficult?

Coding Problems Part 2 - zigzags! 📈

<img src="https://images.unsplash.com/photo-1539627831859-a911cf04d3cd?ixid=MnwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8&#x26;ixlib=rb-1.2.1&#x26;auto=format&#x26;fit=crop&#x26;w=1742&#x26;q=80" alt="Problem solving">
This week, I decided to take a look at solving (or trying to) coding problems!
It's all well and good understanding the syntax and building applications but I wanted to challenge myself by attempting to solve some coding problems. In the first part of this series, I'll be taking a look at some problems and showing you how I solved them. It's good to tackle these sorts of problems, I find it engages you to think and you could learn something new!
If you want to take a look at the code for each of the problems, check out the repo on <a href="https://github.com/JB-26/DailyCodingProblem">GitHub!</a> The language used to solve these problems is Python.
If you solve these problems, please do share your solution!
Let's jump in with the first problem!
<h3>Get products of all elements in an Array</h3>
The problem
<blockquote>
Given an array of integers, return a new array such that each element at index i of the new array is the product of all the numbers in the original array except the one at i
Example: an array of 1, 2, 3, 4, 5 will return 120, 60, 40, 30, 24
</blockquote>
Okay, shouldn't be too bad.
Here's how I solved this problem.
<pre><code>arry = [1,2,3,4,5]
# this will return 120, 60, 40, 30, 24

# function 
def productArray(arry):
 # array for calculations
 calculateArry = []
 arryLength = len(arry)
 print(f"Length of array - {arryLength}")

 for position in arry:
 print("Print integer in position")
 print(position)

 # copy the array
 arryCopy = arry.copy()

 # get the index position of element
 indexPostion = arryCopy.index(position)

 # remove the appropriate element in the array
 arryCopy.pop(indexPostion)

 # length of the copied array
 arryCopyLength = len(arryCopy)

 timesMultiplied = 1
 arryPostion = 0

 print("First calculation!")
 print(f"Value 1 - {arryCopy[arryPostion]}")
 print(f"Value 2 - {arryCopy[arryPostion + 1]}")
 newValue = arryCopy[arryPostion] * arryCopy[arryPostion + 1]

 while timesMultiplied &#x3C; arryCopyLength - 1:
 print(f"Multiplying {newValue} by {arryCopy[arryPostion + 2]}")
 newValue = newValue * arryCopy[arryPostion + 2]
 timesMultiplied += 1
 arryPostion += 1
 
 # add the calculated value to a new array
 calculateArry.append(newValue)

 # return new array
 return calculateArry
 

# call function and print new array
sortedArry = productArray(arry)
print(sortedArry)
</code></pre>
This might be a lot to take in so I'll break it down.
Here's how my thinking went for this:
<ul>
<li>Copy the array to a new array and remove the element that we're using in the for loop. This prevents using the element in the loop in any calculations</li>
<li>Store the length of the copied array in a new variable</li>
<li>Create new variables to track the array position and the number of times multiplied</li>
<li>Do a first calculation of the first two elements and store the result in a variable</li>
<li>In a while loop, multiply the value by other elements in the array (and increment the times multiplied and the array position)</li>
<li>Add the new value to the empty array</li>
<li>After the loop has complete, return the new array!</li>
</ul>
This isn't the best way of solving it. There are much better ways. But I'm glad that I was able to solve it!
<h3>Finding number of smallest elements to the right.</h3>
The problem
<blockquote>
Given an array of integers, return a new array where each element in the new array is the number of smaller elements to the right of that element in the original input array.
Example; [3, 4, 9, 6, 1] returns [1, 1, 2, 1, 0]
</blockquote>
A unique problem involving arrays!
Here's my solution to the problem:
<pre><code>arry = [3, 4, 9, 6, 1]

def smaller_counts(arry):
 smallerArry = []

 for index, i in enumerate(arry):
 counter = 0
 # nested for loop when it reaches the end of the array it stops
 for x in arry[index + 1:]:
 if x &#x3C; i:
 counter += 1
 smallerArry.append(counter)
 
 # return the new array
 return smallerArry
 

# call function
result = smaller_counts(arry)
print (f"Original input - {arry}")
print(f"Result - {result}")
</code></pre>
So, the function creates an empty array to store the result. Then, in a for loop (with using enumerate to get the value and index), I use a nested for loop to loop through the array with a plus one to ensure the loop looks at the next value. This loop won't go out of bounds when looking at the next array if it's the last element in the array.
If the value from the first loop is less than the second value in the nested for loop, the increment the counter value. At the end of the loop, take the value of the counter and append it to the new array (which is then returned).
A good result!
<h3>Locate the smallest window.</h3>
The problem
<blockquote>
Given an array of integers that are out of order, determine the bounds of the smallest window that must be sorted in order for the entire array to be sorted.
The array, [3, 7, 5, 6, 9], should return (1,3)
</blockquote>
This is a problem that I had to look at the answer for. I had a bit of trouble figuring this one out!
<pre><code>array = [3, 7, 5, 6, 9]

def window(array):
 # new variables that are empty
 left, right = None, None

 print(left)
 print(right)

 # sort the array to start with
 s = sorted(array)
 print(f"Unsorted - {array}")
 print(f"Sorted - {s}")

 # range will return a tuple of integers that represent the first and last of the number of elements in the array
 for i in range(len(array)):
 # print the value of i
 print(i)
 # if the element in the original array doesn't match the element in the sorted array AND left is None
 if array[i] != s[i] and left is None:
 # left will equal the index value
 left = i
 elif array[i] != s[i]:
 right = i
 
 #this will return a tuple
 return left, right

# run the function!
result = window(array=array)

print(result)
</code></pre>
Since the result needs to be a tuple, two new variables that have the value of None are created (left and right). The array is then sorted into a new variable, the original array and sorted array will be compared. If the element in the original array doesn't match the element in the sorted array and left is none, then left is equal to the value. However, if the value in the original array doesn't match the value in the sorted array, then right will equal the value.
Once the loop has finished, then return the values of left and right.
I tripped up a few times in trying to figure how to calculate the bounds of the smallest window. However, I learnt from the solution which was good!
And that wraps up this weeks post!
I'll post some more coding problems soon.
Thanks for reading! 👍

Joshua Blewitt

Posts tagged with Python