Python Workshop for Beginners

So, you want Python to do something very functional but do not feel like writing heaps of code to achieve that functionality? Then look no further, this guide will teach you exactly how to do that by utilising Python Packages. Python Packages are collections of handwritten scripts that will increase the capabilities of the programming language exponentially! Python Packages can be found online with the official distribution repository being the Python Package Index (PyPI). This is an excellent repository of packages for the programming language with over a quarter of a million unique packages available to download. Each and every one will improve the potential of Python, all you need to do is install the right one for you.

It is important to have the same Python version to the particular package. Also having pip, setup tools and wheel projects installed and up-to-date will allow the easiest installation method. Pip is the standard package-management system used to install and manage software packages written in Python. Wheel projects are a pre-built distribution format that provides faster installation.

The code in this guide will demonstrate that these packages in combination with Python means you can produce intricate Mandelbrot images from just three lines of code which you can see below. The Mandelbrot set is an interesting way of seeing how complex functions behave under repeated iterations and looks very beautiful. This would take numerous codes of line to create without utilising external packages.

For Deeper Information Click Here

Chapter 5 - Crafting Codes

5.0 Chapter Overview

In this chapter we show off some of the coding muscles we have been building throughout this python journey. By the end of this chapter you will be able to create graphical user inputs, generate animations using the Turtle Standard library and access data from real world data at utilise it to drive decisions in your codes. So without further ado let's build some practical codes!

5.1 Swell Python Scripts with the Turtle Library

The scripts in this guide all use functionality from the Turtle Standard Library. This is pre-installed into Python by default and is a graphical library. In this guide we will be making geometric shapes with Python. Then the last script in this guide will generate a turtle race! Perfect for an afternoon coding session. Thus, this guide will ease you into the first steps of coding with an objective.

Think of the turtle library as a whiteboard with a small robot turtle situated on top of it. This robot turtle leaves a pen line behind itself whenever it moves. The size and dimensions of this pen line can be pre-decided in code. Also, the robot turtle can be controlled by code. Thus, by commanding the robot turtle to move you can draw lines all over the board. This white board is a pop-up window which is white unless otherwise specified. All of this can be seen in the image below.

Code for the Turtle race is below. It has been extensively commented with depth to explain the inner workings. Copy and paste it into your Python Programming Window, write it out or download the code from the bottom section and open it using the Python IDLE Shell. Either way it will run on any default install of Python.

#As it is traditional to do so all the extra functionality desired for this turtle race is imported at the start.
#All the particular functionality utilised will comes pre-installed on a default installation of Python.
import time
import turtle
from turtle import Turtle
from random import randint

#Setting up the pop-up window! And placing the title words in the centre top of the Python Turtle Graphics Window
#The function turtle.penup() effectively is lifting the robot turtle off the page and moving it, thus no pen line
window = turtle.Screen()
window.title("Turtle Racing Occuring in this Pop-Up Window!")
turtle.bgcolor("Green")
turtle.color("White")
turtle.speed(0)
turtle.penup()
turtle.setpos(-420, 260)
turtle.write("Come one, Come all! It is Turtle Racing Time!", font=("Arial", 30, "bold"))
turtle.penup()

#Adding some dirt to the base, This is similar to the star example above using the turtle.begin_fill() and is similar to drawing with a CNC machine.
#The starting point is decided on, the turtle is put onto the page and then movement commands are given to the robot turtle. 
turtle.setpos(-280, 225)
turtle.color('Brown')
turtle.begin_fill()
turtle.pendown()
turtle.forward(520)
turtle.right(90)
turtle.forward(445)
turtle.right(90)
turtle.forward(520)
turtle.right(90)
turtle.forward(445)
turtle.end_fill()

#Create a finishing line! Every turtle race needs one
#This used the turtle.stamp() functionality which when set like below let's you stamp white squares  
stamp_size = 20
square_size = 15.5
finish_line = 180

turtle.color('white')
turtle.shape('square')
turtle.shapesize(square_size / stamp_size)
turtle.penup()

#Now to make the finish line look checkered! It uses two loops to fill fourteen white stamp sections of colour

for i in range(14):
    turtle.setpos(finish_line, (211 - (i * square_size * 2)))
    turtle.stamp()

for j in range(14):
    turtle.setpos(finish_line   square_size, ((211 - square_size) - (j * square_size * 2)))
    turtle.stamp()

#And with all the above the field is now set!
#Now it is time to get our robot turtle competitors ready!
#Robot Turtle Number One, aka Franklin. Think of below as the stat blocks for the starting location and colour of turtles.

turtle1 = Turtle()
turtle1.speed(0)
turtle1.color("Black")
turtle1.shape("turtle")
turtle1.penup()
turtle1.goto(-275, 140)
turtle1.pendown()

#Turtle Number Two, aka Sonik (possibly a hedgehog in disguise)

turtle2 = Turtle()
turtle2.speed(0)
turtle2.color("Yellow")
turtle2.shape("turtle")
turtle2.penup()
turtle2.goto(-275, 60)
turtle2.pendown()

#Turtle Number Three, aka Michelangelo

turtle3 = Turtle()
turtle3.speed(0)
turtle3.color("lightblue")
turtle3.shape("turtle")
turtle3.penup()
turtle3.goto(-275, -20)
turtle3.pendown()

#Turtle Number Four, aka Crush

turtle4 = Turtle()
turtle4.speed(0)
turtle4.color("Orange")
turtle4.shape("turtle")
turtle4.penup()
turtle4.goto(-275, -110)
turtle4.pendown()

#And with that our competitors are on the Field!

#Pauses the game for three seconds so that all the turtles and all the bets can be wagered ready for the race!
time.sleep(3)

#This loop decides the end of the race. The end of the race happens once i reaches 145 iterations.  
#Most races will be over by this point. Movement speed of the turtles is also decided here
#If you wanted to program in an unfair advantage this is the spot to do it. 

for i in range(145):
    turtle1.forward(randint(1,5))
    turtle2.forward(randint(1,5))
    turtle3.forward(randint(1,5))
    turtle4.forward(randint(1,5))

#Finally a simple and easy way to get out of window is coded in below. By clicking anywhere on the window
#You can exit the application

turtle.exitonclick()

Roll up and be ready! It is time for some racing to go down using the Python script we made above. Check out all the swell action in an epic race caught with multiple screen captures seen below. As you can see there was a close victory by the turtle in yellow today! 

Let us set our codes free into the world wide web and design codes which access real world data! This real-world data will represent the current reality of the world around us. Application Programming Interface requests is the method that allows this to occur in Python Scripts. Application Programming Interface is often shortened to API. Data from the web can tell us the exact weather situation of any place on the globe, it can be used to tell us the location of faces on an image we provide or it could tell us the number of astronauts currently floating far far out there in space. Any information freely accessible on the World Wide Web is literally within our capacity to utilise inside our Python codes. 

There is numerous API online that are free to use so long as you create an account with their system. This is to stop their system being overloaded or made vulnerable. Thus, when we request information from API set up in this manner we need to provide some kind of input, most commonly an API key. In this case we will utilise OpenWeatherMap API for the following script. OpenWeatherMap API can be found at this location. This API will give us live information on the weather anywhere on the globe. To recreate this script you will need to make your own free account on this website. Once you have made an account and confirmed your email address you will be given an API key. The API key given to me you can see in the below screen capture.

Also, for the next script we will install another Python Package from PyPI called PyOWM. This is a Python Wrapper Library for OpenWeatherMap web APIs. It will give more functionality to Python particularly allowing for quick and easy consumption of OpenWeatherMap API data in a human-friendly fashion. To install the latest version of PyOWM Python Package you would type directly into the Command Prompt the below.

pip install pyowm

By pressing the enter key you will execute this line which will install PyOWM onto your system. Below you can see the installation of the Python Package PyOWM in the Command Prompt. An easy install that took less than a minute. PyOWM comes from the Python Package Index found in this location. Once this is done we are ready to get into our code! 

Now we have all the preparation sorted let's get into whipping up the Python script. Seen below is a Python script which depending on whether it has rained recently will turn on or off the sprinkler system.  It has been extensively commented so that you can follow step by step. You can either type out the code in your Python Programming Window, copy and paste it there or download the code from the bottom section and open it using the Python IDLE Shell.  

#Imagine that this script is run every morning, informing you what the weather will be
#and telling you whether you need to turn the sprinklers on or off. A future
#step would be to turn the sprinklers on or off automatically.

#Start by importing PyOWM (this is what we installed before using the pip installer).
import pyowm

#Now we can use the functionality gained from PyOWM in our code.

#To access the OpenWeatherMapAPI we must have a API Key which is sent
#with our request to use data from OpenWeatherMap
#This is done by using the function owm=pyowm.OWM() and our unique APIkey.
owm = pyowm.OWM('a0c664323ffe4b57a627f7585eea0748')

#Now we can decide the location of the weather data we desire. You can also use
#latitude and longitude to decide location. The world is your oyster.
city = 'Glasgow'

#Now we utilise the functionality provided by PyOWM to get the weather at our
#desired location
loc = owm.weather_manager().weather_at_place(city)

#Below is an example of using latitude and longitude to get weather data from
#OpenWeatherMap API. Uncomment below and comment above to make this run.
#use the latitude and longitude values of your choice.
#loc = owm.weather_manager().weather_at_coords(34, 150)

#Below gives a variable name to the data we have pulled from OpenWeatherAPI
weather = loc.weather

#To see the raw data that you have pulled from the API uncomment the two lines below
#print(weather)

#Below is taking the data we desire from the OpenWeatherAPI and grabbing only what we desire
temp = weather.temperature(unit='celsius')
status = weather.detailed_status

#Cleaning up the tenp data is done below so we have just the average value
cleaned_temp_data = (int(temp['temp']))

#Print the weather details to Python IDLE shell in a human readable manner
print('The temperature today in', city,'is',cleaned_temp_data,'degrees celsius.')
print('The day today will have',status,'.')

#Now to decide whether to inform the human to turn sprinklers on or off.

#The Status variable is a class string variable. Uncomment what is below to demonstrates
#this. Thus means we can search it looking for the string 'rain' inside of it.
#print(type(status)) 

#Using an if statement we can decide whether to sprinkler or not to sprinkler.
#This is done by searching for rain in status or anything rain-esque.

if 'rain' in status or 'thunderstorm' in status or 'drizzle' in status or 'snow' in status:

    print('No need for sprinklers today. Time to turn them off.')
    
else:
    
    print('Sprinklers are needed today. Time to turn them on.')

#In a future video I'll dive into the specifics of automating real life sprinklers from Python code. 

What this script prints out can be see below in the Python IDLE Shell. The code was run twice from the Python Programming Window with the only difference between the two altering the target city. The first time the code was run the location was set to Newcastle Australia (the location of Core Electronics). Thankfully today is a nice sunny day so sprinklers were necessary to keep our grass green. The second time running the code the city was changed to Glasgow in Scotland. Thus, the program received the weather information for Glasgow. Naturally, it was raining so sprinklers were not necessary. The correct sprinkler reminders were accurately printed to the Python IDLE Shell as well as a message about the local temperature and status of weather.

#Using the import * means we are importing everything inside the designated library
#Thus the line below imports all functionality from Tkinter library.
from tkinter import *

#This creates a GUI tk() Variable called calc.
calc=Tk()

#This function gives the window a name.
calc.title('Adding and Subtracting Calculator')

#Set the size of the GUI Window.
calc.geometry("720x180")

#Make our GUI a little more pleasing to the eye by altering the background colours.
calc['bg']="powder blue"

#Below is creating Labels on inside our GUI window. This is so users can
#understand how to use this calculator. The Labels are given a location on the window
#and also text is decided and made bold if important.
FirstLabel=Label(calc, text='First Number', font=('bold'))
FirstLabel.place(x=40, y=20)

SecondLabel=Label(calc, text='Second Number', font=('bold'))
SecondLabel.place(x=40, y=88)

ThirdLabel=Label(calc, text='Or')
ThirdLabel.place(x=358, y=83)

FourthLabel=Label(calc, text='Result', font=('bold'))
FourthLabel.place(x=556, y=52)

#This creates entry locations for the user to type numbers into the calculator. Also, a place
#for the result to be displayed is created.
FirstNumber=Entry()
FirstNumber.place(x=120, y=52)

SecondNumber=Entry()
SecondNumber.place(x=120, y=120)

ResultNumber=Entry()
ResultNumber.place(x=520, y=83)

#Below is the user-created function which will run whenever the Add button is clicked.
#First, we start by defining the function and giving it a name. All code of this function
#will be indented.
def add():

#Whenever this function is run initially we clear the result location. This is to stop
#number from stacking up and thus displaying the wrong result.
    ResultNumber.delete(0, 'end')

#Now it grabs the numbers from the first and second entry window. It also double-checks
#that the data by converting the data inputted into an integer type.
    First = int(FirstNumber.get())
    Second = int(SecondNumber.get())

#Here is the actual calculation occurring. Addition of both the numbers inputted    
    Calculation = First   Second

#Now you can display the number underneath the Result label.     
    ResultNumber.insert(END, str(Calculation))

#Same process is done below for the subtraction function.    
def sub():
    ResultNumber.delete(0, 'end')
    First = int(FirstNumber.get())
    Second = int(SecondNumber.get())
    Calculation = First - Second
    ResultNumber.insert(END, str(Calculation))

#Now that the functionality has been coded, we can create buttons that reference
#the above functionality. These buttons are also given a location on the window.
Button1=Button(calc, text='Add', command=add)
Button1.place(x=310, y=80)

Button2=Button(calc, text='Subtract', command=sub)
Button2.place(x=390, y=80)

#This is a way of creating an infinite loop. The application will run, wait for
#events to occur and process the events so long as the window is not closed.
#Another way to make an infinite loop would be creating while True infinite loop.
calc.mainloop()

For Deeper Information Click Here

Chapter 6 - Where to Go From Here

6.0 Chapter Overview

Now we have now covered all the foundations you need to springboard into the powerhouse programming language of Python. We have gone through from early steps of understanding interfaces all the way up to writing intricate scripts that utilise all kinds of unique functionality and live data. It has been a fantastic adventure creating this python workshop, I personally have had a ton of fun putting them together and producing them for you. But this is by no means the end and hope you perceive this workshop as a springboard onto future projects and a means for other daring python spelunking escapades.

6.1 Where to Find Further Knowledge and Inspiration

There are a lot of places to go from here which is one of the blessing of Python. If you are interested in furthering your Python education, I have linked several teaching platforms below.

• Google IT Automation with Python
• Codecademy
• Learn Python
• Crash Into Python
• The Hitchhikers Guide to Python
• Cipher Hacking with Python
• Cipher Mysteries
• 6 Hour Python Odyssey by Mosh

If you are interested in inspiration for a Python project a great place to start is with a piece of physical hardware (like a Raspberry Pi 4 Model B which is totally programable using Python) and find a well-documented, interesting project and mimic it. There are loads of cool projects on Instructables, Hackaday and at our Core Electroncs Projects Page. Doing this will really allow your Python codes to come alive! If you want to learn more about Raspberry Pi Hardware, we have a whole Raspberry Pi Workshop to immerse yourself in knowledge.

6.2 Where to Find Help

If your interesting in bringing Python to your personal maker projects we have numerous great guides and projects on our Core Electronics page. And if you want help with your own projects or get stuck in a Workshop our Core Electronics Forum is the best way to get in touch with us. We are always happy to give a helping hand. Google is also a lifesaver for speedy solutions. I will be continuously adding content and modifying this workshop to make it the best experience possible. As always if you have any questions, queries or things to add please let us know your thoughts!

And with that it brings us to the conclusion of the Core Electronics Python Workshop. I hope you have got something out of it and has made you excited to program. Thanks for going on the journey with me and be sure to share this workshop with a friend if you found it useful! Until next time, stay cozy.