Forem: Simon Chalder

Part Ten: PIP, External Modules and GitHub

Simon Chalder — Tue, 13 Dec 2022 19:47:51 +0000

Welcome to part ten. In this series I hope to introduce the basics of coding in Python for absolute beginners in an easy to follow and hopefully fun way. In this final article we will look at how to install and use a package manager, import modules from an online repository, and take a look at some modules which may be of interest to land based workers and students.

"Most of you are familiar with the virtues of a programmer. There are three, of course: laziness, impatience, and hubris." - Larry Wall

Sharing Is Caring

So, why would we want to use someone else's code? That's cheating isn't it? No, not at all! In fact, sharing our code encourages some rather fantastic things - the free sharing of experience and knowledge, and people coming together to collaborate on projects.

People share their code online for a number of reasons. Firstly there is the bragging rights to say that 'x number of people have downloaded or subscribed to my project this month'. Others have taken existing projects and re-written them is a way that they feel is better and wish to share it with the world. Some use their code as a resume for coding jobs.

Whatever the reason, sharing code online for free is a great thing to do and it's even become an online movement. So how do we do it? There are several online repositories where we can upload and store our code for all to see and use. The largest and most well known is GitHub, now owned by Microsoft, but there are others such as GitLab etc. In order to upload code or use other people's modules we need to be part of the GitHub community. Unless you have ethical issues with Microsoft products (some people do), you can go to GitHub's signup page and create an account so do that first if you do not already have one.

OK, now that's out of the way we can now take a look at the millions of coding projects currently being hosted on the site. In the search bar type 'python' and hit enter to see what we can find. At the time of writing there are 2,725,251 code repositories with the tag 'python'. That's a lot of projects! Let's go back to the search bar and this time search for 'pandas'. At the top of the search results you should see 'pandas-dev/pandas', click on the link.

What you are looking at is the GitHub repository page for the 'Pandas' project. Unfortunately 'pandas' has nothing to do with the clumsy black and white bears. Instead it is a powerful tool for data analysis.

So let's say we have read the project introduction and we like what we read. How do we use this module with our code? If we scroll down the page we will eventually come to the 'Where to get it?' section. You won't see any installer files to download here, instead there are two options; one for 'conda' and one for 'pip'. Conda and pip are package managers for Python and we can use them to install, modify or uninstall packages found in online repositories.

For this article, I am going to be using 'pip' (short for PIP Installs Packages) so we need to install that first. Take a look at this page and look for installation instructions for your operating system. Open up a shell prompt on your device and copy and paste the commands shown on the pip website to install pip.

To check if pip is installed correctly, open up a command prompt and type the following and press enter:

pip -V

If you see 'pip' followed by a version number, you are good to go.

Installing Packages With PIP

Now that we have pip installed we can install our first online module. In your command prompt type the following and then press enter:

pip install pandas

You should see something similar to the image below:

We can check to see if the module installed properly as well as get a list of all installed modules with the following command:

pip list

You may have noticed that pip also installed something called 'numpy'. This is another module which deals with mathematical operations and is required by pandas in order for it to function properly. This is known as a dependency and pip handles this automatically.

To install any module with pip use the following syntax pip install [module]. If you are unsure of the module name you can look for it in pip with the following command pip search [module]. We can also remove installed modules with pip uninstall [module].

Importing Installed Modules

If we go back to our IDE and open a new project, we should now be able to import 'pandas' as though it was a built in module:

import pandas

We can confirm this is working with the dir() function:

print(dir(pandas))

All being well we should get the following output:

['ArrowDtype', 'BooleanDtype', 'Categorical', 'CategoricalDtype', 'CategoricalIndex', 'DataFrame', 'DateOffset', 'DatetimeIndex', 'DatetimeTZDtype', 'ExcelFile', 'ExcelWriter', 'Flags', 'Float32Dtype', 'Float64Dtype', 'Float64Index', 'Grouper', 'HDFStore', 'Index', 'IndexSlice', 'Int16Dtype', 'Int32Dtype', 'Int64Dtype', 'Int64Index', 'Int8Dtype', 'Interval', 'IntervalDtype', 'IntervalIndex', 'MultiIndex', 'NA', 'NaT', 'NamedAgg', 'Period', 'PeriodDtype', 'PeriodIndex', 'RangeIndex', 'Series', 'SparseDtype', 'StringDtype', 'Timedelta', 'TimedeltaIndex', 'Timestamp', 'UInt16Dtype', 'UInt32Dtype', 'UInt64Dtype', 'UInt64Index', 'UInt8Dtype', '__all__', '__builtins__', '__cached__', '__deprecated_num_index_names', '__dir__', '__doc__', '__docformat__', '__file__', '__getattr__', '__git_version__', '__loader__', '__name__', '__package__', '__path__', '__spec__', '__version__', '_config', '_is_numpy_dev', '_libs', '_testing', '_typing', '_version', 'annotations', 'api', 'array', 'arrays', 'bdate_range', 'compat', 'concat', 'core', 
'crosstab', 'cut', 'date_range', 'describe_option', 'errors', 'eval', 'factorize', 'from_dummies', 'get_dummies', 'get_option', 'infer_freq', 'interval_range', 'io', 'isna', 'isnull', 'json_normalize', 'lreshape', 'melt', 'merge', 'merge_asof', 'merge_ordered', 'notna', 'notnull', 'offsets', 'option_context', 'options', 'pandas', 'period_range', 'pivot', 'pivot_table', 'plotting', 'qcut', 'read_clipboard', 'read_csv', 'read_excel', 'read_feather', 'read_fwf', 'read_gbq', 'read_hdf', 'read_html', 'read_json', 'read_orc', 'read_parquet', 'read_pickle', 'read_sas', 'read_spss', 'read_sql', 'read_sql_query', 'read_sql_table', 'read_stata', 'read_table', 'read_xml', 'reset_option', 'set_eng_float_format', 'set_option', 'show_versions', 'test', 'testing', 'timedelta_range', 'to_datetime', 'to_numeric', 'to_pickle', 'to_timedelta', 'tseries', 'unique', 'util', 'value_counts', 'wide_to_long']

That's a lot of methods! Pandas is a very large project with over 2750 people contributing to the code! This brings me to my next point - there is nothing to stop you being one of those people. Collaborating with others on projects and contributing your time and skills can be immensely rewarding. Even as a beginner, many projects will have tasks that you will be able to complete. If you have the time and want to try it out, look for a project you are interested (probably a large project to begin with) and get in touch!

So how do we use pandas for data analysis or numpy for some mathematical operations? What about all of those other modules?

This is where the step by step tutorials end and the free learning begins. At this point you are now capable of finding, installing and using any number of online modules and projects. However, each of these modules has methods which do different things and expect different input from the developer. To learn how to use them you need to do two things - read the documentation, and experiment. Never be afraid to simply install a module and have a play around to see what it can do.

From here you can choose to take your coding journey in any number of directions; want to study data science for ecology - no problem, guess wildlife populations in the future with machine learning - go for it! The only limit now is your imagination and the time you wish to devote to coding.

If you would prefer to work on your own projects but would like to upload your code and store it in GitHub then follow this link for a guide of how to do it.

"I have run into many coders, photographers, writers, who don't think of themselves as makers. But, I submit that making is any time you use your point of view to make something from nothing" - Adam Savage

GitHub Safari

To end the series, I am going to take a stroll through the GitHub repositories and highlight a few repositories that may be of interest in the land and wildlife field. If any of these spark your interest, install them with pip and try them out. Maybe you could even become one of their contributors!

1. Numpy

GitHub Page
Official Documentation

What is it?

Numpy is a Python module which allows you to perform scientific computing and numeric operations in your project.

Why is it interesting?

Aside from providing methods for various types of scientific calculations, one of numpy's big draws is it allows us to create three dimensional arrays (lists). What this means is lists within lists which allow us to make data structures similar to spreadsheets which can be very useful when working with actual spreadsheet or comma separated value datasets.

If you have an interest in scientific computing or just like the numpy project they are actively looking for contributors! Follow this link to offer your services for everything from writing code, administration and even graphic design.

Pandas

GitHub Page
Official Documentation

What is it?

Pandas is a powerful module for data analysis in Python. It allows us to work easily with large datasets with features for things like handling missing data, grouping and modifying data, and merging multiple data sets together. It requires numpy to work but as a result it works seamlessly with numpy's arrays.

Why is it interesting?

Pandas is an essential tool in data sciences and is used extensively in fields such as ecology. It is also used for processing data for use in machine learning / A.I. Pandas can be useful for anyone who wants to analyse any kind of dataset.

Matplotlib

GitHub Page
Official Documentation

What is it?

Matplotlib is an extensive module for visualising data in Python. It allows for the creation and display of many types of static and animated graphs.

Why is it interesting?

Graphs can be useful for all manner of professions and projects as a way of conveying data quickly and easily. Instead of exporting your data to something like Excel or another graphing software, simply do it all in Python.

Tkinter Designer and Custom Tkinter

GitHub Page - Tkinter Designer
GitHub Page - Custom Tkinter

What is it?

Tkinter is a Python framework for creating graphical user interfaces (GUI) for your applications. If you want to make a project which has user input boxes, buttons, labels, drop-down menus etc. Tkinter can make that happen. Tkinter designer and Custom Tkinter are two modules which allow you to easily create your own GUI.

Why is it interesting?

A GUI can be a lot more enticing for a user to engage with over using a command line app. Tkinter Designer makes it possible to design your GUI using only drag and drop components (you still have to code functionality into those buttons and other stuff). If you want more granular control, Custom Tkinter allows you to code your own GUI from scratch which is not nearly as hard as it sounds.

GeoPandas

GitHub Page
Official Documentation

What is it?

GeoPandas enables the working of geospacial data in Python and also allows for the plotting of that data in a similar fashion to using GIS software.

Why is it interesting?

Similar to pandas, geopandas has its own special data structures for dealing with geospacial data such as coordinates and geometry data. This means you can get up and running much quicker and utilising geopandas suite of methods will allow you to manipulate and plot your data to your hearts content.

Google Maps API

GitHub Page
Official Documentation

What is it?

Simply put, this is Google's official Maps API (Application Programming Interface). Think of it just like a module which provides pre-made methods which enable you to interact with Google Maps in your application. In order to use the API you do need to sign up for a Google account if you don't already have one and then generate an API key (a unique ID so Google knows who is using its servers).

Why is it interesting?

The API allows you to access all data found in Google Maps. That includes location lookup, directions, distance measurements, elevation data, and more. You can run a query through the API with as little as 4 lines of code, so why not give it a go?

Conclusion

Well that's it. The end.

If you have read all of the series, all the way to the end, you have my undying gratitude and thanks. If you only read some of it, then you still have my thanks and I hope you were able to take something away from it.

Here is a quick recap of what we covered:

Variables - what they are and how to use them
Data Types - what common kinds of data does Python support
Data Structures - lists, tuples and dictionaries and how we can store multiple pieces of data in a single variable
Flow Control - how we can use logic to let our code perform some decision making for us
Loops - making our code work hard for us to perform repetitive tasks quickly and easily
Functions - chunks of code we can write once and recall whenever we need them
Error Handling - dealing with those tricky and unpredictable users
Classes and Objects - creating blueprints for our objects and then generating objects from the blueprints in true OOP style
Files and Modules - how we can create our own reusable modules for use in the future to save us a lot of time
GitHub and External Modules - how we can use code written by others in our projects and how we can get involved by contributing to those projects

My intention with this series was not to get you to a professional developer level (although with further study, why not?), more I wanted to introduce the world of coding to those who maybe never saw a need for it or who thought it was beyond their reach.

If the series helped you at all, please consider telling a friend. Any comments and constructive feedback are always appreciated.

Thank you.

Simon.

Part Nine: Python Files and Modules

Simon Chalder — Sat, 10 Dec 2022 18:24:29 +0000

Welcome to part nine. In this series I hope to introduce the basics of coding in Python for absolute beginners in an easy to follow and hopefully fun way. In this article we will look at the basics of importing and using modules in our code.

"But while you can always write 'spaghetti code' in a procedural language, object-oriented languages used poorly can add meatballs to your spaghetti." - Andrew Hunt

Modules

Simply put, a module is a Python file containing classes, methods, or functions we would like to use in our code.

Why is that useful?

If we have written projects using classes or functions which handle a particular thing such as displaying graphs, performing calculations, getting user input etc, we can save that code in its own Python file and keep it in our own code library for use in the future. Think back to article six where we made some basic calculator functions. They looked like this:

def add(num1, num2):
    print(num1 + num2)

def sub(num1, num2):
    print(num1 - num2)

def div(num1, num2):
    print(num1 / num2)

def mul(num1, num2):
    print(num1 * num2)

Now, perhaps we think we may write another project in the future which requires a calculator, instead of writing out all of our functions again we can save this code in its own module.

We save this code in a new file as 'calc.py' and place it in the same folder as our new project file. We can name our modules anything we like as long as we remember to give it the '.py' extension at the end.

We can now start our new project as normal. To import the module we first place the module file in the same folder as our new project file.

├── project_folder
│   ├── new_project.py
│   ├── calc.py

Next, we write the following at the beginning of the new project file:

import calc

Now to access our functions in our new project we simply use the [modulename].[functionname]. For example:

import calc

print(calc.add(14, 28))

# Output
42

Note that for example, if we only needed access to the division method for our project we can import only what we need:

from calc import div

However, when we call a function this way, we omit the name of the module:

add(14, 28)

# Output
42

Classes in Modules

Let's now place our calculator in its own class:

class calculator:
    def add(num1, num2):
        return num1 + num2

    def sub(num1, num2):
        return num1 - num2

    def div(num1, num2):
        return num1 / num2

    def mul(num1, num2):
        return num1 * num2

To access the methods in our class, we need to include the class name in our method call so the syntax would be [modulename].[classname].[methodname]:

import calc

print(calc.calculator.sub(29, 6))

# Output
3

Module Aliases

Some module names can be quite long or complicated. To make things easier to read we can import a module under a different name or alias. Say we had named our calculator module 'calculator.py', we can give it an alias when importing it to make it easier to work with:

import calculator as cal

Now whenever we need to refer to the calculator module, we simply use 'cal' instead:

print(cal.add(12,8)

# Output
20

Module Attributes

As well as classes, methods and functions, modules can also be used to store variables and data structures:

# calc.py

num1 = 10
num2 = 18

To access these variables we simply use [modulename].[variable]:

# project.py

result = calc.num1 + calc.num2
print(result)

# Output
28

Lists, tuples and dictionaries can be accessed in the same manner:

# calc.py

my_list = [12, 33, 109, 45]

# project.py

print(calc.my_list[2])

# Output
109

Viewing the contents of a module

Python has a built in function called dir() which allows us to view the contents of a module or object. This can be useful when we are unsure if a particular object or module contains the data we require. The dir() function will return the contents as a list and so to see it we must either print to the screen or use the returned data in a function.

Let's use our calc module to test this. We can add a couple of variables to our 'calc.py' file as well:

num1 = 10
num2 = 18

def add(num1, num2):
        return num1 + num2

def sub(num1, num2):
    return num1 - num2

def div(num1, num2):
    return num1 / num2

def mul(num1, num2):
    return num1 * num2

We now print the returned results of our dir() function:

print(dir(calc))

We get the following output:

['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'add', 'div', 'mul', 'num1', 'num2', 'sub']

What we have is a list of everything available to our module. Ignore everything with '__' either side and we can see the names of our functions as well as our 2 variables there too.

No great surprise right? I mean, we created the module so we know what's in it. However, where this becomes useful is when we deal with modules we did not create. This can be Python's built in modules and those written by other people.

Python's Built In Modules

"One man’s crappy software is another man’s full time job." - Jessica Gaston

Python ships with all manner of built in, handy modules. Here is a list if you would like to have a read through some of them.

We will cover a couple of them here so you can see how to use them but I encourage you to read around and try out as many as you can.

To begin let's look at the math module (boooooo maths!). Now, maybe your saying to yourself 'but I hate maths, what would I want to use that for?'. Well, the answer is quite simply that it does all of the hard work for you so you don't need to be a maths genius to work with numbers.

Firstly, go to the page linked above and scroll down to the 'math' module and click the link. What you will see is a list of all of the methods which are part of the 'math' module.

Let's import the math module to get started:

import math

Simple enough. Scrolling down the methods page, I can see the pow() method. This method accepts 2 arguments, the first is our number, and the second is the power we wish to raise our number to. To call the method we simply use [modulename].[methodname]. So for example 3 to the power of 3 (3x3x3) is:

result = math.pow(3, 3)
print(result)

# Output
27

Next let's try the square root method - sqrt(). Looking at the documentation, this method accepts a single argument and returns the square root of that argument:

result = math.sqrt(64)
print(result)

# Output
8

Other methods of note in the math module are conversions for degree to radians and visa versa, trigonometric methods for calculating angles such as tree heights, and a method for returning pi for circumference and other circular calculations.

We can see the other methods which form the math module by using our dir() built in function:

print(dir(math))

We get the following list as output:

['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'cbrt', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'exp2', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 
'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp']

Looking through the list we can see the 'pow' and 'sqrt' methods we used as well as all of the others.

For our second example, we will take a look at the random module. You may recall way back in my loops article that for the challenge, I generated some random numbers. Well, here is how we can do that.

Again we begin by importing the random module:

import random

If we look through the methods available in the random module we will see randrange(). This method returns a random number between a set range. It accepts 2 arguments, the first is the lowest possible random number, the second is the highest. So for example if we want a random number between 1 and 100 we could do the following:

result = random.randrange(1, 100)
print(result)

# Output
23

Finally, let's take a look at the random choice method - choice(). This method accepts a single argument which can be a list or tuple. The method will then randomly select one of the list items and return it:

my_list = [1,22,57,86,12]

result = random.choice(my_list)
print(result)

# Output
57

Again let's take a look at this module with our dir() function:

print(dir(random))

We get this list as an output:

['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', '_ONE', '_Sequence', '_Set', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos', '_bisect', '_ceil', '_cos', '_e', '_exp', '_floor', '_index', '_inst', '_isfinite', '_log', '_os', '_pi', '_random', '_repeat', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom', '_warn', 'betavariate', 'choice', 'choices', 'expovariate', 'gammavariate', 'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'normalvariate', 'paretovariate', 'randbytes', 'randint', 'random', 'randrange', 
'sample', 'seed', 'setstate', 'shuffle', 'triangular', 'uniform', 'vonmisesvariate', 'weibullvariate']

Conclusion

Hopefully this has started to demonstrate that many common things we may need for our projects are already contained in Python's built in modules which saves us the time of having to code this ourselves every time. By using our own modules, we can re-use our code in future projects to save us some time there too. In addition, we can now start to break up our code into separate files with each module having a particular purpose. We then simply import those files into our main project file to use their code. This has the advantage of making the code modular so that we know exactly where to look to work on a specific part of the application even if our project becomes very large overall.

In the next and final article, I want to demonstrate how you can import other people's modules into your code from the internet as well as taking a look at some modules which are likely to be of use to the land based sector.

As always, thank you for reading and I look forward to seeing you next time.

Simon.

Part Eight: Classes and Objects

Simon Chalder — Thu, 08 Dec 2022 15:35:18 +0000

"I used to be enamoured of object-oriented programming. I'm now finding myself leaning toward believing that it is a plot designed to destroy joy." — Eric Allman

Welcome to part eight. In this series I hope to introduce the basics of coding in Python for absolute beginners in an easy to follow and hopefully fun way. In this article we will look at the basics of using classes and objects to make modular code which is easier to work with.

Classes, Objects, and this thing called 'Object Orientated Programming'

If you have been reading around the subject matter, or maybe just browsing coding sites online, you may have come across the term 'object orientated programming' being thrown around. So what is it and why should you care?

Up to now we have been writing what might be termed 'procedural' or 'functional' code where the interpreter starts at the top and works down line by line in a single Python file. Now don't get me wrong, you can accomplish a lot with this style of coding, and many times this may be all we need to accomplish our goals. However, the downside of this kind of coding rears its head when our applications start to get bigger and more complex. Simple applications or 'scripts' as they are often referred to, tend to set out to accomplish a single task. But what if we want our application to do several things? Using procedural coding we would end up with 'monolithic code' which means just a single, giant file with hundreds or even thousands of lines of code. When our code files get too big they become difficult to keep track of and when we have problems it makes it much harder to determine where the problem is arising from.

Into the breach steps object orientated programming (from here on out I will refer to it as 'OOP' as it takes a long time to type!). In OOP, as the name suggests, we use objects in our code. We will come onto what objects are and how to make them shortly. However, using objects and their associated classes (more on this in a little while), we can break our code down into more manageable chunks and make it all more modular.

Classes and objects allow us to group together related variables and functions into specialist tools which we can use to accomplish a task.

Let's say we decide to write an application which does the following things:

Connect to the internet and navigate to a web page or database which hosts wildlife datasets
Download the required dataset
Open or read the data file
Perform some calculations with the data
Display the result in the form of a graph

Writing this in a single file with all of the associated variables and functions required might make for a pretty large file which is then difficult to work with. However, we could use classes and objects to break this application down into its component parts to make it easier to work with. We could have a class that deals with connecting to the internet, another which deals with downloading a file, and so on. This means if there is an issue in the code we know exactly where to look for the problem.

Classes and Objects

There is no discussion about OOP unless we talk about the objects and classes themselves. What are they? What do they do? OOP requires some different thinking and can be hard to understand at first. Try to understand on a conceptual level what is happening first and worry about the syntax after.

OK here goes.

Imagine we want to create a paper form so that we can record details about a company vehicle. We want a standardised form so we pay a printing company to make up a pad full of the uncompleted forms we have designed. In coding terms, a class is like the pad of printed forms, it is a template from which we will make all of our objects. Every form has fields such as the name of the person completing the form, the date, vehicle registration, mileage etc. When we fill out all of the fields on the form and tear it off the pad we now have an object - a completed version of the paper form which contains unique information about that vehicle.

Here is an example of the form (class):

my_vehicle_form:
    make = 
    model = 
    mileage = 
    doors = 
    colour =

When we fill it in, we now have a a completed version of the form with all of its associated fields but this one also has values for the fields making it a unique copy based on the form template which looks like this:

land_rover:
    make = land rover
    model = defender
    mileage = 88625
    doors = 5
    colour = green

By doing this we have taken the form template (the class) and made an object from it which contains the details above. We could also make another object from the same class template:

pickup:
    make = Ford
    model = ranger
    mileage = 12688
    doors = 3
    colour = blue

Now we have 2 objects created from the same class. The class always remains the way we have created it, it is the template all objects of that class will be cast from just like a mould or rubber stamp. We can go on to make any number of objects from a class. We can also have as many classes as we like for lots of different purposes.

Creating a Class

Creating a class in Python is not that different from the example above. We simply use the keyword class followed by the name of the class we want to make and then a ':'.

class my_first_class:

Next, we move to the next line down and indent to write code inside the class:

class my_first_class:
    # write code here

So what goes inside our classes? Classes can have their own variables known predictably as 'class variables' or 'attributes', as well as their own functions known as 'methods'.

Let's look at creating some attributes first. We will use our vehicle example from above. First, we create our class and then we add attributes in our indented code in the same way as we create a normal variable. Note that here we are giving the class predetermined attributes that will apply to all objects made from it, in other words all objects made from our vehicle class will be blue and have 5 doors. We will cover giving new objects their own attributes later on.

class vehicle:
    colour = "blue"
    doors = 5

Our class template is now ready to be used to create an object, so lets do that.

To create an object from a class we name our object and then assign it to the class using [object name] = [class name]:

my_truck = vehicle

We have now created a new object named my_truck from the vehicle class.

Let's talk about inheritance

Here is the whistle-stop explanation of inheritance, a subject which could be the topic of a series of articles itself.

By 'inheritance' I'm not referring to that rich uncle you're hoping will leave his fortune to you. In coding, inheritance refers to the way that objects 'inherit' attributes and methods from their class template.

Whichever attributes and methods are written in the class are passed down to an object when it is created. If those attributes have values assigned to them, the values are also passed down. Keep this concept in mind as we move forward.

We have now created our object which we named my_truck from the vehicle class. Our object inherits all of the attributes its template class had so our object also has 'colour' and 'doors' attributes. Because our class had values assigned to those attributes, our newly created object will also have its colour attribute set to a value of 'blue' and a doors attribute of '5'.

To access an attribute, we use the name of the object followed by a '.' and then the name of the attribute:

print(my_truck.colour)

# Output
'blue'

print(my_truck.doors)

# Output
5

Note that if our class attributes have values we can also access them directly:

print(vehicle.colour)

# Output
'blue'

We can create classes with pre-assigned values to act as a kind of reference but most of the time this is not what we want (more on this later). In the above example, every object we create from the 'vehicle' class will be the same - it will have a colour set to 'blue' and doors set to '5'. What if our next vehicle is red and has 3 doors?

What we need is a way to pass data to an object as we are creating it so the object is unique and not a simple clone of the class template.

'self' and __init__()

No, those aren't typos in the title. They are concepts we need to understand in order to work with classes and objects effectively. At this point I'm not going to lie, this may require reading through a few times and probably using some other sources to understand. So buckle up kids, here we go!

Let's tackle __init__() first. When we want to create an object that is unique, we need a way to give it unique values for its attributes at the time of its creation. To do this we use what is known as a 'constructor'. In Python __init__() is the constructor and is simply a function which runs when an object is created. Don't be put off by those weird '__' lines either side of the name, this is just how Python recognises what it does. Just like the functions we have already come across, it accepts arguments. Those arguments are then used to give values to the object's attributes.

With me so far?

OK, this brings us to 'self'. Consider the example below:

my_name = "Harry"

class my_class:
   my_name = "Helen"

my_object = my_class

Here we have an object my_object which is created from the my_class class and as such inherits its attributes. We also have an unrelated variable my_name. This means in this code we have 3 variables named my_name. One is the standard variable, another is in the class attribute, and another in the object's attribute. As you can imagine this gets confusing and when we try to access my_name, Python is not sure which of the 3 possible versions we are referring to. To solve this we use 'self' to indicate we are referring to the attribute in the object and not the class or some other variable with the same name.

Let's put this all together to try and demonstrate this a little better. First let's create our class using a constructor like we discussed above. We can also name a couple of attributes. Note that we can leave the attribute values blank to create empty attributes we can then fill with a constructor.

class my_class:
   def __init__():
       name = 
       age =

We now need to give our constructor some arguments which will be used to assign values to the attributes when our object is created. If we simply put 2 arguments in the brackets of __init__(), Python will not know if we wish to change the value of the object's attribute or some other with the same name:

class my_class:
   def __init__(name, age):
       name = name
       age = age

Therefore we must use 'self' to indicate we are dealing with the created object and not another part of the code. For this purpose, 'self' must always be the first argument we give to our constructor, even if no other arguments are given. Let's now add 'self.' before the attribute names. In this manner, 'self' is basically a place holder for the name of the object, whatever that might be when we create it:

class my_class:
   def __init__(self, name, age):
       self.name = name
       self.age = age

When we come to create our object we now pass our arguments but we ignore 'self', we do not need to pass a value for that:

my_object = my_class("Jack", 34)

Our object my_object has now been created from the my_class template and it has been assigned the name attribute equal to 'Jack' and an age attribute equal to '34'.

At this point, you may have a headache and be questioning why you decided to try this coding nonsense to begin with. It can be difficult to understand at first, but the best way to gain an understanding is to practice examples of creating classes and objects, so let's do that now.

A Practice Example

Here is an example to help reinforce the OOP principles we have covered so far.

Let's create a new class called 'mammal'. Inside the class, we define our constructor and give it the argument 'self':

class mammal:
    def __init__(self):

Now let's choose some attributes for our mammals:

class mammal:
    def __init__(self, colour, diet, habitat, offspring):
        self.colour = colour
        self.diet = diet
        self.habitat = habitat
        self.offspring = offspring

Now we have our class set up let's make some objects from the class. Each argument is used to assign a value to the relevant attribute. When we create the fox object, the first argument we pass - 'red-brown' is assigned to fox.colour, 'carnivore' is assigned to fox.diet and so on. Remember in the class template, 'self' is just a placeholder for the names of the objects we will create:

fox = mammal('red-brown', 'carnivore', 'farmland', 2)

rabbit = mammal('grey-brown', 'herbivore', grassland', 10)

We now have 2 unique objects created from the mammal class which each have their own values for their attributes. Let's test it to make sure:

print(fox.colour)

# Output
'red-brown'

print(rabbit.diet)
'herbivore'

For the visual learners amongst us, here is a visual example to try to show things more clearly.

The whole 'self' thing can take a bit of getting used to but hopefully you are beginning to see how we create classes and then objects from those classes.

Methods

A method is simply a function which belongs to a class. Class methods are inherited by any object that is made from them just like attributes. To create a method we write it just like a normal function except indented in the class. Here is an example:

class say_something:
    def speak_word(word):
        print(word + "!")

To call a class method we use the following syntax - [class/object].[method]()

So to call our method from the example above we would use:

speak = say_something

speak.speak_word("Hello")

# Output
'Hello!'

Methods, just like normal functions, accept arguments. In the example above we pass the argument 'word' when calling the method.

Class Methods vs Object Methods

Methods can be called both from the original class and from objects made from that class. For example we can create the following class and object from the class:

class greeting:
    def __init__(self, greeting):
        self.greeting = greeting

    def say_greeting(self):
        print(self.greeting)

my_object = greeting("Hello!")

We can now call 2 versions of the say_greeting() method - 1 from the class and 1 from the method. Remember class methods can be called directly but are also inherited by all objects made from that class:

greeting.say_greeting()

# Output
'' # the greeting class has no pre-coded value for the 'greeting' attribute

my_object.say_greeting()

# Output
'Hello!'

So why is this important? We can use classes in different ways. We can use them in the normal fashion as we have seen above, as templates from which to create objects. However, we can also use 'static classes' to create a kind of reference or toolkit.

Static classes are not used to create objects and as such do not pass on inherited attributes or methods.

So what's the point of them?

Well, remember the calculator application we made in the function article? We could make a class which holds our calculation methods and then simply call them when required.

class calculator:
    def add(num1, num2):
        return num1 + num2

    def sub(num1, num2):
        return num1 - num2

    def div(num1, num2):
        return num1 / num2

    def mul(num1, num2):
        return num1 * num2

Effectively what we have done here is to make our own built in function like print(), or float(), which we can use any time we need it. We do not need to create an object from the calculator class in order to access its methods. However, we must ensure we use the name of the class when calling it e.g. calculator.add().

result = calculator.add(23, 5)
print(result)

# Output
28

In addition, we can save this class in its own Python file to be imported and used in any future projects which might require it. I will cover how to do this in a future article.

As you have probably figured out, there is a lot to learn with classes and objects. The good news is if you can understand the basics, you can do an incredible amount with that level of knowledge. Remember you don't need to know everything and you don't need to be at the standard of a professional developer to write great applications.

Challenge

I know your head is probably hurting at this point but the best way to understand this stuff is through practice. I'm going to set a challenge to test your use of classes and objects. Hopefully nothing too intense. Take your time and think it through. Unlike other challenges, I will place one possible solution after the challenge in this article so that if you get completely stuck you can go through it step by step. However, I strongly encourage you to try and work it out yourself first.

Let's write an application to put some of this into practice. We will write code that will take input about the details of a piece of land, perform some analysis and then output some (hopefully) useful data.

Here is what the code must do:

Create a class for a piece of farmland called 'farmland'
Inside your new class create some attributes with short but appropriate names for:
- Total area
- Unharvested cereal headland
- Winter bird food
- Flower rich field margins
- Winter stubble
Define 4 class methods to calculate each payment type. Each method should accept the size in hectares of that land type and the current payment rate from the Countryside Stewardship scheme. Current rates can be found here.
Create an object from your class and pass as arguments the total area of the land (hectares) as well as the size of any areas of cereal headland, winter bird food etc. You can simply enter these values when you create the object or get them through user input, your choice.
Calculate the relevant totals and print out the results for that piece of land.
BONUS - make the application run on a loop so that multiple pieces of land can be analysed until the user decides they have done enough.
BONUS - make another class based on another land type such as wetland, woodland etc and incorporate this into your application.

Solution

Here is one possible solution to the challenge above. Remember, there are usually several different ways of tackling problems in programming. If your answer is different, but it works, then well done!

We begin by creating the farmland class, defining the constructor, and setting attributes. It is certainly valid to create an argument for each payment rate, but I have combined them into a single argument which will be a list. The benefit of this is if I want to change the rates in the future they are all together rather than spread out amongst the code:

class farmland:
        def __init__(self, total_area, cereal, birds, margins, stubble, rates):
            self.total_area = total_area
            self.cereal = cereal
            self.birds = birds
            self.margins = margins
            self.stubble = stubble
            self.rates = rates

Next we define class methods for each payment type. Each method calculates the total of the relevant payment rate multiplied by the area of that land type. Remember I have used a list for the rates, hence rates[0], rates[1] etc.

def cereal_headland_calc(self):
            return self.rates[0] * self.cereal

        def winter_bird_food_calc(self):
            return self.rates[1] * self.birds

        def flower_rich_margins_calc(self):
            return self.rates[2] * self.margins

        def winter_stubble_calc(self):
            return self.rates[3] * self.stubble

Also remember to include 'self' as an argument here as we will be calling this method from the object and not the class. Next, we create another method to display the results. Each of the above calculation methods is called and the result stored in a variable which is then printed to the screen as a string:

def show_results(self):
            cereal_calc = self.cereal_headland_calc()
            bird_calc = self.winter_bird_food_calc()
            margins_calc = self.flower_rich_margins_calc()
            stubble_calc = self.winter_stubble_calc()

            print("Results for Farmland Analysis:\n")
            print("Total Area: " + str(self.total_area))
            print("Potential Unharvested Cereal Headland Payment    - £" + str(cereal_calc))
            print("Potential Winter Bird Food Payment               - £" + str(bird_calc))
            print("Potential Flower Rich Field Margin Payment       - £" + str(margins_calc))
            print("Potential Winter Stubble Payment                 - £" + str(stubble_calc))

We are now done with our class. Outside of our class, we can now create a function to get data from the user:

def get_input():
        area_input = float(input("Enter Total Area (ha): "))
        cereals_input = float(input("Enter Unharvested Cereal Headland Area (ha): "))
        birds_input = float(input("Enter Winter Bird Food Area (ha): "))
        margins_input = float(input("Enter Flower Rich Field Margin Area (ha): "))
        stubble_input = float(input("Enter Overwinter Stubble Are (ha): "))
        return area_input, cereals_input, birds_input, margins_input, stubble_input

Before we call our get_input() function, we need to set the rates for the potential payments:

cs_farm_rates = [640, 640, 628, 493]

To get our user input, we call get_input() and assign the returned values to some variables:

area_input, cereals_input, birds_input, margins_input, stubble_input = get_input()

If we now create an object from our class we can call the show_results() method from that object:

new_land = farmland(area_input, cereals_input, birds_input, margins_input, stubble_input, cs_farm_rates)

new_land.show_results()

Up to now the full application looks like this. Make a note of the indentation to ensure the correct code is included or excluded from our class and function:

class farmland:
        def __init__(self, total_area, cereal, birds, margins, stubble, rates):
            self.total_area = total_area
            self.cereal = cereal
            self.birds = birds
            self.margins = margins
            self.stubble = stubble
            self.rates = rates

        def cereal_headland_calc(self):
            return self.rates[0] * self.cereal

        def winter_bird_food_calc(self):
            return self.rates[1] * self.birds

        def flower_rich_margins_calc(self):
            return self.rates[2] * self.margins

        def winter_stubble_calc(self):
            return self.rates[3] * self.stubble

        def show_results(self):
            cereal_calc = self.cereal_headland_calc()
            bird_calc = self.winter_bird_food_calc()
            margins_calc = self.flower_rich_margins_calc()
            stubble_calc = self.winter_stubble_calc()

            print("Results for Farmland Analysis:\n")
            print("Total Area: " + str(self.total_area))
            print("Potential Unharvested Cereal Headland Payment    - £" + str(cereal_calc))
            print("Potential Winter Bird Food Payment               - £" + str(bird_calc))
            print("Potential Flower Rich Field Margin Payment       - £" + str(margins_calc))
            print("Potential Winter Stubble Payment                 - £" + str(stubble_calc))

    def get_input():
        area_input = float(input("Enter Total Area (ha): "))
        cereals_input = float(input("Enter Unharvested Cereal Headland Area (ha): "))
        birds_input = float(input("Enter Winter Bird Food Area (ha): "))
        margins_input = float(input("Enter Flower Rich Field Margin Area (ha): "))
        stubble_input = float(input("Enter Overwinter Stubble Are (ha): "))
        return area_input, cereals_input, birds_input, margins_input, stubble_input

    cs_farm_rates = [640, 640, 628, 493]

    area_input, cereals_input, birds_input, margins_input, stubble_input = get_input()

    new_land = farmland(area_input, cereals_input, birds_input, margins_input, stubble_input, cs_farm_rates)

    new_land.show_results()

If we now run this code and enter some values we are presented with output similar to the image below:

That last result shows we need to round the total to 2 decimal places. We can do this in the following way by altering our code with the round() built in function. The number after the comma represents the number of decimal places:

def cereal_headland_calc(self):
        return round(self.rates[0] * self.cereal, 2)

    def winter_bird_food_calc(self):
        return round(self.rates[1] * self.birds, 2)

    def flower_rich_margins_calc(self):
        return round(self.rates[2] * self.margins, 2)

    def winter_stubble_calc(self):
        return round(self.rates[3] * self.stubble, 2)

The final part of the challenge is to make the app loop until the user decides to quit. To do this, we simply indent the entire code inside of a while loop with some flow control at the end. The finished application should now look like this:

run = True
while run == True:    
    class farmland:
        def __init__(self, total_area, cereal, birds, margins, stubble, rates):
            self.total_area = total_area
            self.cereal = cereal
            self.birds = birds
            self.margins = margins
            self.stubble = stubble
            self.rates = rates

        def cereal_headland_calc(self):
            return round(self.rates[0] * self.cereal, 2)

        def winter_bird_food_calc(self):
            return round(self.rates[1] * self.birds, 2)

        def flower_rich_margins_calc(self):
            return round(self.rates[2] * self.margins, 2)

        def winter_stubble_calc(self):
            return round(self.rates[3] * self.stubble, 2)

        def show_results(self):
            cereal_calc = self.cereal_headland_calc()
            bird_calc = self.winter_bird_food_calc()
            margins_calc = self.flower_rich_margins_calc()
            stubble_calc = self.winter_stubble_calc()

            print("Results for Farmland Analysis:\n")
            print("Total Area: " + str(self.total_area))
            print("Potential Unharvested Cereal Headland Payment    - £" + str(cereal_calc))
            print("Potential Winter Bird Food Payment               - £" + str(bird_calc))
            print("Potential Flower Rich Field Margin Payment       - £" + str(margins_calc))
            print("Potential Winter Stubble Payment                 - £" + str(stubble_calc))

    def get_input():
        area_input = float(input("Enter Total Area (ha): "))
        cereals_input = float(input("Enter Unharvested Cereal Headland Area (ha): "))
        birds_input = float(input("Enter Winter Bird Food Area (ha): "))
        margins_input = float(input("Enter Flower Rich Field Margin Area (ha): "))
        stubble_input = float(input("Enter Overwinter Stubble Are (ha): "))
        return area_input, cereals_input, birds_input, margins_input, stubble_input

    cs_farm_rates = [640, 640, 628, 493]

    area_input, cereals_input, birds_input, margins_input, stubble_input = get_input()

    new_land = farmland(area_input, cereals_input, birds_input, margins_input, stubble_input, cs_farm_rates)

    new_land.show_results()

    run_again = input("Perform another analysis 'y' or 'n'?")
    if run_again.upper() == 'Y':
        run = True
    else:
        run = False

If you want to add analysis for a different land type, you simply need to create another class with appropriate methods and rates. This is one of the advantages of OOP, we can create modular classes and objects where all of the related code is together in one place.

I hope all of this made sense and you are starting to see things more clearly. If not, please use as many online sources as you can until you find one which explains it best. If you are lucky enough to know someone with experience of OOP you may benefit from them going through it with you. As I have mentioned, these can be tricky concepts to grasp at first and they can also be difficult to express in a way which is easy for the learner. Hang in there though and practice as much as you need. Take your time and consult as many sources and learning materials as necessary.

Conclusion

That was a tough one to get through but we are nearly a the end of the series. In the next article I am going to talk about importing your own (and other people's) files and modules into your projects.

Thank you as always for reading and I look forward to any constructive feedback you may have on this article or the series as a whole. Keep practising and I look forward to seeing you next time.

Simon.

Part Seven: Error Handling

Simon Chalder — Mon, 05 Dec 2022 09:00:00 +0000

"There are two ways to write error-free programs; only the third one works." - Alan Perlis

Welcome to part seven. In this series I hope to introduce the basics of coding in Python for absolute beginners in an easy to follow and hopefully fun way. In this article we will look at writing code once but being able to use it as many times as we like without writing it out every time, but first let's take a look at the solution for the challenge set in part six.

Solution to part six's challenge

Here are a couple ways this could be accomplished. If your method was different but still worked - congratulations! If you struggled, have a look at the examples below and if you have time, have another go at it.

Example 1 - putting the whole thing inside a while loop

run = True

while run == True:

    def add(num1, num2):
        result = num1 + num2
        print(result)

    def sub(num1, num2):
        result = num1 - num2
        print(result)

    def div(num1, num2):
        result = num1 / num2
        print(result)

    def mul(num1, num2):
        result = num1 * num2
        print(result)

    choice = input("Enter 'add', 'sub', 'div' or 'mul'")

    number1 = input("Enter first number: ")
    number1 = int(number1)
    number2 = input("Enter second number: ")
    number2 = int(number2)

    if choice == 'add':    
        add(number1, number2)
    elif choice == 'sub':
        sub(number1, number2)
    elif choice == 'div':
        div(number1, number2)
    elif choice == 'mul':
        mul(number1, number2)
    else:
        print("Choice not recognised, please run application again")

    run_again = input("Perform another calculation? ")
    if run_again == 'y' or run_again == 'Y':
        run = True
    else:
        run = False

Example 2 - using recursion

def calculator():
    def add(num1, num2):
        result = num1 + num2
        print(result)

    def sub(num1, num2):
        result = num1 - num2
        print(result)

    def div(num1, num2):
        result = num1 / num2
        print(result)

    def mul(num1, num2):
        result = num1 * num2
        print(result)

    choice = input("Enter 'add', 'sub', 'div' or 'mul'")

    number1 = input("Enter first number: ")
    number1 = int(number1)
    number2 = input("Enter second number: ")
    number2 = int(number2)

    if choice == 'add':    
        add(number1, number2)
    elif choice == 'sub':
        sub(number1, number2)
    elif choice == 'div':
        div(number1, number2)
    elif choice == 'mul':
        mul(number1, number2)
    else:
        print("Choice not recognised, please run application again")

    run_again = input("Perform another calculation? ")
    if run_again == 'y' or run_again == 'Y':
        calculator()
    else:
        pass

calculator()

"Any fool can use a computer. Many do." - Ted Nelson

User Input Problems

All being well, you should have an application which can take input from a user, perform simple calculations, and run multiple times as needed.

Perhaps you came across this issue when you were writing your code but if not consider the following situation. Where we ask for user input, for example, the first and second numbers, what if the user didn't enter a number but a string instead? What if they inputted a boolean value or maybe no value at all and simply pressed enter.

Unfortunately, whether accidentally or intentionally, users won't always do what we think they will. Therefore, we need to try and anticipate potential pitfalls and put code in place to avoid crashing our applications.

Error Handling - reducing the chance of an incorrect input

Let's work through our calculator example and see where we can anticipate users causing problems. For the remainder of this article I will be referring to my first example but feel free to adapt this to your own solutions.

We will start at line number 21 in my example where we ask the user to choose a type of calculation to perform:

choice = input("Enter 'add', 'sub', 'div' or 'mul'")

This will work well as long as the user types exactly what we have asked for. However, a user wanting to perform addition may type 'Add', 'ADD', or make a typo such as 'ads'. This input is stored in a variable which is compared in an if / else statement starting on line 28. Anything other than 'add' here will throw an error.

So how can we overcome this? The first possible step would be change what we are asking for. Instead of asking the user to type a string of 3 characters which they may misspell, we could simply ask for a number:

choice = input("Enter 1 to add, 2 to subtract, 3 to divide or 4 to multiply")

Now the user only has to enter one character which reduced the chances of errors.

We could also use a letter instead of a number:

choice = input("Enter 'A' to add, 'S' to subtract, 'D' to divide or 'M' to multiply")

However, this raises the issue of did the user use upper or lower case? To solve this, we can convert any letter the user gives us to upper case, before the if statement looks at it, to ensure no matter what is typed it will be upper case. To do this we use a built in Python function - upper(). The upper method is technically a method and not a function but we will get into methods in another article. Here's how we use it, we can call upper.() on a variable by using it after a '.' at the end of the variable name:

string_variable = "goose"
string_variable.upper()
print(string_variable)

# Output
'GOOSE'

So in our calculator example, we simply add upper() to the end of our choice input line to convert the input to upper case:

choice = input("Enter 'A' to add, 'S' to subtract, 'D' to divide or 'M' to multiply").upper()

Converting Data Types

Moving on to line 23, we already have some error handling in place here. Because the input() function returns a string it means that we cannot take number inputs from it directly. When the user gives the input - 23 as a number, the input function records this as the string "23". This is no good for performing calculations as we can only do this with integers or floats.

To solve this, we used the int() function to convert the string from the user input into an actual integer we can use in calculations:

number1 = input("Enter first number: ")
number1 = int(number1)

However, what if the user wanted to calculate decimal numbers? Inputting a decimal number currently will throw a value error as we are trying to convert a float to an integer.

While we could examine the float to try and see if it contains a '.' and then use flow control to then convert to an integer or a float depending on the result.....it's just easier to convert everything to a float and work solely in decimal numbers:

number1 = input("Enter first number: ")
number1 = float(number1)

Now decimal numbers can be handled without issue and any integers can still be used but will just be displayed with '.0' after them.

Using Functions and Flow Control

The final method for error handling I am going to look at here is using functions and flow control to account for anything the user throws at you which you did not account for.

In our example, we have some flow control which checks the choice variable against some criteria to determine the calculation type to be performed. We check for predetermined answers but if anything else is found, we exit the flow control and proceed to ask if the user wishes to run the application again. In addition, regardless of what the user enters, it is not validated until after they have entered their 2 numbers.

One way of solving this is to re-write our code into functions and then call them as needed. This will require us to re-arrange or 're-factor' our code so take your time and go through line by line if you have any issues understanding what is happening.

First we take our code which asks the user for 2 numbers and make it into a function which returns those numbers:

def get_nums():
        number1 = input("Enter first number: ")
        number1 = int(number1)
        number2 = input("Enter second number: ")
        number2 = int(number2)
        return number1, number2

Now, we take the flow control code which assesses which calculation we wish to perform and make another function which can call itself if we cannot validate the user's input. We can cut and paste our user input line from above and put it at the start of this function. Now the calculation choice input is validated before we get the user's numbers:

def calc_choice():
        choice = input("Enter 'A' to add, 'S' to subtract, 'D' to divide or 'M' to multiply").upper()
        if choice == 'A':
            num1, num2 = get_nums()    
            add(num1, num2)
        elif choice == 'S':
            num1, num2 = get_nums()    
            sub(num1, num2)
        elif choice == 'D':
            num1, num2 = get_nums()    
            div(num1, num2)
        elif choice == 'M':
            num1, num2 = get_nums()    
            mul(num1, num2)
        else:
            print("Choice not recognised, please run application again")
            calc_choice()

Finally, now that all of our functions have been defined, we need to call our calc_choice() function to get things started. We must remember that a function must be defined before it can be called so we must make sure our code is arranged appropriately.

Here is what this would look like all together. We will go through it to explain how it works:

run = True

while run == True:

    def add(num1, num2):
        result = num1 + num2
        print(result)

    def sub(num1, num2):
        result = num1 - num2
        print(result)

    def div(num1, num2):
        result = num1 / num2
        print(result)

    def mul(num1, num2):
        result = num1 * num2
        print(result)

    def get_nums():
        number1 = input("Enter first number: ")
        number1 = float(number1)
        number2 = input("Enter second number: ")
        number2 = float(number2)
        return number1, number2

    def calc_choice():
        choice = input("Enter 'A' to add, 'S' to subtract, 'D' to divide or 'M' to multiply").upper()
        if choice == 'A':
            num1, num2 = get_nums()    
            add(num1, num2)
        elif choice == 'S':
            num1, num2 = get_nums()    
            sub(num1, num2)
        elif choice == 'D':
            num1, num2 = get_nums()    
            div(num1, num2)
        elif choice == 'M':
            num1, num2 = get_nums()    
            mul(num1, num2)
        else:
            print("Choice not recognised, please run application again")
            calc_choice()

    calc_choice()

    run_again = input("Perform another calculation? ")
    if run_again == 'y' or run_again == 'Y':
        run = True
    else:
        run = False

Here is how this application will run:

Line 1: The variable run is created and set to True
Line 3: A while loop looks at run and if it is True runs its indented code
Lines 5-44: 5 functions are defined
Line 46: The calc_choice() function is called and runs its code
The user is asked for input 'A','S','D' or 'M' and this is stored in the variable choice after being converted to upper case
Flow control looks at the value of choice and if it matches one of the set conditions get_nums() is called and the returned values stored in variables called num1 and num2
The appropriate calculation function is called using num1 and num2 as arguments
If choice does not meet any of the set conditions, the else statement runs and calls calc_choice() again. Go back to step 5
If a calculation has been performed we move to line 48 where the user is asked if they want to go again
Flow control compares the user's answer to step 9. If the answer is 'y' or 'Y' then the while loop from step 2 runs again. If the answer is ANYTHING else, run from step 1 is set to False and the loop will not run again causing the application to exit

Final Tweaks

The only other thing we could do with this code is to shorten the final bit of flow control using the upper() method:

run_again = input("Perform another calculation? ").upper()
    if run_again == 'Y':
        run = True
    else:
        run = False

All together, this would look like this:

run = True

while run == True:

    def add(num1, num2):
        result = num1 + num2
        print(result)

    def sub(num1, num2):
        result = num1 - num2
        print(result)

    def div(num1, num2):
        result = num1 / num2
        print(result)

    def mul(num1, num2):
        result = num1 * num2
        print(result)

    def get_nums():
        number1 = input("Enter first number: ")
        number1 = float(number1)
        number2 = input("Enter second number: ")
        number2 = float(number2)
        return number1, number2

    def calc_choice():
        choice = input("Enter 'A' to add, 'S' to subtract, 'D' to divide or 'M' to multiply").upper()
        if choice == 'A':
            num1, num2 = get_nums()    
            add(num1, num2)
        elif choice == 'S':
            num1, num2 = get_nums()    
            sub(num1, num2)
        elif choice == 'D':
            num1, num2 = get_nums()    
            div(num1, num2)
        elif choice == 'M':
            num1, num2 = get_nums()    
            mul(num1, num2)
        else:
            print("Choice not recognised, please run application again")
            calc_choice()

    calc_choice()

    run_again = input("Perform another calculation? ").upper()
    if run_again == 'Y':
        run = True
    else:
        run = False

Using the second example I gave at the start we could also solve this with recursion:

def calc_app():

    def add(num1, num2):
        result = num1 + num2
        print(result)

    def sub(num1, num2):
        result = num1 - num2
        print(result)

    def div(num1, num2):
        result = num1 / num2
        print(result)

    def mul(num1, num2):
        result = num1 * num2
        print(result)

    def get_nums():
        number1 = input("Enter first number: ")
        number1 = float(number1)
        number2 = input("Enter second number: ")
        number2 = float(number2)
        return number1, number2

    def calc_choice():
        choice = input("Enter 'A' to add, 'S' to subtract, 'D' to divide or 'M' to multiply").upper()
        if choice == 'A':
            num1, num2 = get_nums()    
            add(num1, num2)
        elif choice == 'S':
            num1, num2 = get_nums()    
            sub(num1, num2)
        elif choice == 'D':
            num1, num2 = get_nums()    
            div(num1, num2)
        elif choice == 'M':
            num1, num2 = get_nums()    
            mul(num1, num2)
        else:
            print("Choice not recognised, please run application again")
            calc_choice()

    calc_choice()

    run_again = input("Perform another calculation? ").upper()
    if run_again == 'Y':
        calc_app()
    else:
        pass

calc_app()

Again, take your time here and go through line by line until you have a good handle on what is happening. If your solution to the challenge was significantly different from mine, try applying error handling to your own code to see how you can avoid users catching you out.

Challenge

The challenge this time is not really a challenge. We have come a long way since part one, you have learned data types, data structures, flow control, loops, functions, and now error handling. My hope is that you are now starting to think of your own projects and maybe you have already started some of them. For now I would like you to consolidate your coding knowledge and go back through everything you have learned. If you have the time, try a simple project or 2 to help you understand all of the concepts and how they work together. If you have come this far, you have gone from crawl to walk and now you are starting to run. Remember what sparked your interest in coding to begin with and keep it fun.

Conclusion

We have covered some difficult subject matter so far. Some of these concepts can be difficult for a beginner to understand (I know some are definitely hard to explain). I hope if you have struggled or are struggling, that you persist and stick with it as the rewards will be numerous when you have that 'eureka!' moment.

What I am building towards with this series is to get you to a point where you can write modular, object orientated code which will enable you to contribute to your field and community or write useful software for your daily life. You won't be a professional developer by the end, but you don't need to be, you work in land based industry not Facebook.

The concepts get harder as we go from here and I will do my best to explain them as clearly as I can. However, if it doesn't click right away do not be disheartened, it's perfectly normal. Keep referring to as many sources as needed until you find the one that explains it in the right terms, we all learn differently.

The next article will look at classes and objects, and then on to some object orientated programming principles. This marks the end of what could be considered 'beginner' coding so if you have got this far give yourself a well deserved pat on the back!

Thank you for reading, constructive criticism is always welcome. I look forward to seeing you next time.

Simon.

Part Six: Functions

Simon Chalder — Sat, 03 Dec 2022 15:27:34 +0000

"Measuring programming progress by lines of code is like measuring aircraft building progress by weight." - Bill Gates

Welcome to part six. In this series I hope to introduce the basics of coding in Python for absolute beginners in an easy to follow and hopefully fun way. In this article we will look at writing code once but being able to use it as many times as we like without writing it out every time, but first let's take a look at the solution for the challenge set in part five.

Solution to part five's challenge

In this challenge we have a list of integers named code_list and we need to loop through this list comparing each list item to the secret code.

To do this we need to use a loop which will iterate through each item and then a nested if / else statement to do the comparing. We could use a while loop as we know we have 1000 codes to loop through but an easier way is to use a for loop:

for code in code_list:
    if code == safe_code:
        print("Safe cracked, code was: ")
        print(code)
    else:
        pass

We can also print our output on a single line by converting our integer into a string:

for code in code_list:
    if code == safe_code:
        print("Safe cracked, code was: " + str(code))
    else:
        pass

What is str()? Well, I'm glad you asked, it's a method and those are the topic of this article.

Functions

Up to this point I have mentioned functions in passing, but what are they exactly?

I want to introduce you to an important concept in programming which is D.R.Y. or 'Don't Repeat Yourself'. What this means is that we should never be writing the same piece of code over and over in our applications - it looks messy, makes the code more difficult to read, and uses more memory when the application is ran. However, there are many times when we need our code to do something multiple times. Consider the following example which does not adhere to the DRY principle:

print("Instructions for fitting wall shelves")
print("Fit 8mm drill bit into drill")
print("Drill 4 x 25mm holes in wall")
print("Insert rawl plugs into holes")
print("open bag of screws")
print("Screw item to wall")

print("Instructions for fitting medicine cabinet")
print("Fit 8mm drill bit into drill")
print("Drill 4 x 25mm holes in wall")
print("Insert rawl plugs into holes")
print("open bag of screws")
print("Screw item to wall")

OK, it's a bit of a silly example, but we can see our application needs to use 2 sets of almost identical instructions. To improve on this we can use a function to make most of the instructions repeatable and then simply recall our function each time we need it rather than typing out everything multiple times. Python comes with some built in functions and we have used some of them already. However, we will be writing our own functions from scratch to improve our code.

Creating a Function

First we must define (create) our function. We define a function with the following syntax:

In this case we will name it 'instructions' so as to give an idea of what it will do. Once we have defined our function and given it a name, we then move to the next line down, indent, and then write the code we want to run when the function is called.

def instructions():
    print("Fit 8mm drill bit into drill")
    print("Drill 4 x 25mm holes in wall")
    print("Insert rawl plugs into holes")
    print("open bag of screws")
    print("Screw item to wall")

Now instead of typing all of the instructions for each task we simply use (call) our function. To call a function, simply write its name followed by brackets '()':

print("Instructions for fitting wall shelves")
instructions()

print("Instructions for fitting medicine cabinet")
instructions()

Each time we call our instructions(), it runs the code we wrote inside the function when we defined it. So now writing this...

instructions()

...is the equivalent of writing this:

print("Fit 8mm drill bit into drill")
print("Drill 4 x 25mm holes in wall")
print("Insert rawl plugs into holes")
print("open bag of screws")
print("Screw item to wall")

Giving our functions some input

Using functions allows us to avoid writing the same lines of code over and over which helps us adhere to DRY coding. However, functions can be even more useful when we give them some input so work with.

Consider the following function:

def print_name():
    print("Sarah")

This function will print the name 'Sarah' any time we call it. This means we don't have to repeat this line in our code, but it also means we can only print 'Sarah' using this function. What if we wanted to print another name? We could make a new function for each name and call them individually when we need them. Or, we can create a function which accepts input known as 'arguments' so that the function knows which name we want it to print.

What is an argument?

By argument, I don't mean shouting at your code (we've all been there though, no judgement). In coding terms, arguments are pieces of input which we feed into a function to allow it to process that input and provide a useful output. Going back to our name printing function, we can modify it to accept an argument which we will call 'name'. We place our arguments in between the brackets when we define our function:

def print_name(name):
    print(name)

Our name argument is effectively like a variable, a placeholder with a title for whatever we assign to it. The function above will now expect a single input (also known as a 'parameter' - don't get bogged down by the terminology) called 'name' when we call it. Whatever we pass to the function will be stored under 'name' inside the function. In this case the function will print whatever we pass to it as 'name'. Arguments work with any data type.

To pass an argument to a function, we add it between the brackets when calling it. To print a name we could pass a string or the contents of a variable:

# Define the function
def print_name(name):
    print(name)

# Call the function
print_name("Floyd")

# Output
'Floyd'

# Using the same function as above

my_name = "Tina"

print_name(my_name)

# Output
'Tina'

Note - once we have defined a function with an argument, it will expect an argument to be given when we call it. Calling the function with no argument will result in an error but there are some ways around this which I will discuss near the end of this article.

A quick note about scope

"A good programmer is someone who always looks both ways before crossing a one-way street." - Doug Linder

Functions can do all manner of things instead of printing names to the screen. That includes creating and modifying variables and data structures. These operate in the same way as normal except that they exist only inside the function when it is called. Consider the following code:

def my_func():
    name = "Joe"
    print(name)

When this function is called it creates a variable called 'name'. This variable exists only for the time this function is running and the indented code is not accessible outside of the function. For example, if we tried to run the following we would receive an error:

def my_func():
    name = "Joe"
    print(name)

print(name)

This is because our print statement is trying to access a variable called 'name', however, the error is telling us that there is no variable of that name defined as it exists only inside the function.

This is an example of something called scope and it comes into play a lot in more advanced topics. However, for now all we need to know is that scope is a one way street. We can go with the flow but we cannot go against it.

Scope is an important subject, particularly as your applications become more complex and ambitious. For more information on scope follow this link.

Passing more than one argument

As you may have guessed, functions can have more than a single argument. In fact, they can have any number of arguments but we must ensure we pass them the same number of inputs when we call them.

Here is an example of a function which takes 2 arguments to join 2 strings - note the arguments are separated by a comma ',':

def full_name(first, last):
    print(first + " " + last)

Now when we call this function, we must ensure we pass 2 pieces of input:

full_name("Bill", "Smith")

# Output
'Bill Smith'

Note that the order of the arguments matters here. Passing the arguments in a different order when calling the function would alter the output:

full_name("Smith", "Bill")

# Output
'Smith Bill'

Time for a practice example

Let's make a simple calculator application using functions to reinforce how they work.

We will define 4 separate function for addition, subtraction, division and multiplication which will each accept 2 numbers as arguments. Each function will then print the result of that operation between the 2 numbers:

def add(num1, num2):
    print(num1 + num2)

def sub(num1, num2):
    print(num1 - num2)

def div(num1, num2):
    print(num1 / num2)

def mul(num1, num2):
    print(num1 * num2)

Let's test out the addition function by calling it and passing any 2 numbers as arguments:

add(43, 65)

# Output
108

Make sure your output performs as expected and play around with the other functions to test their outputs too. If you are mathematically inclined you could try creating some more complicated functions.

It's time we talked about recursion

"To understand recursion, you must first understand recursion" - old nerd joke

Recursion, recursion, recursion, recursion... where to start? OK, enough bad jokes, recursion is where a function calls itself. Remember when we discussed loops and we looked at infinite loops - a loop with no way to break the cycle which will go on forever. Recursion can be kind of the same thing with functions. Consider the following function:

def my_func(count):   
    if count > 0 :       
        print(count)
        my_func(count)

my_func(10)

Passing any argument greater than 0 would produce an infinite cycle of function calls as there is no way to break out of the loop and my_func() will keep calling itself.

Just like loops, we need a way to break the cycle:

def my_func(count):   
    if count > 0 :       
        print(count)
        my_func(count -1)

my_func(10)

Recursion can be used as a tool for accomplishing some tasks, but unless you are confident it is the only way to go and you can create functions capable of breaking the cycle, it is best avoided.

Arbitrary and Default Arguments

I want to touch briefly on how we address not knowing how many arguments our function will receive or when at least 1 of the function's arguments will be the same every time it is called.

It is always best to plan our functions so that we know what they will receive as arguments each time. However, there may come a time when this is not possible. For example, with our name printing function, some people use middle names and some do not so our function as written above would not be able to deal with that.

To overcome this we use what are known as 'arbitrary arguments' or *args for short. When we define our function we tell it we do not know how many arguments to expect by writing a '*' before the argument name. For our name printing function, it would look like this:

def print_name(*name):

When we use arbitrary arguments, the input given to our function is converted to a tuple (remember those?). We can then use the entire tuple, or slice it to get just the parts we want:

# Using the entire tuple

def print_name(*name):
    print(name)

print_name("Billy", "Ray", "Smith")

# Output
('Billy', 'Ray', 'Smith')

# Slicing just what we want - the middle name

def print_name(*name):
    print(name[1])

print_name("Billy", "Ray", "Smith")

# Output
'Ray'

In the case where a function will always accept the same argument we can use what are called 'default arguments'. Again going back to our name printing function, perhaps the last name of everyone will be the same. In this case rather than type out the last name as an argument each time we can set it as a default when defining the function:

def print_name(first, middle, last="Smith"):
    print(first + " " + middle + " " + last)

If we now call our function we only need to pass 2 arguments instead of 3 as the last name is already set:

print_name("Billy", "Ray")

# Output
Billy Ray Smith

Uh oh! A friend of the family has arrived who has a different last name to everyone else, what do we do? Easy! We can override the default by simply passing a new argument when calling the function:

def print_name(first, middle, last="Smith"):
    print(first + " " + middle + " " + last)

print_name("Peggy", "Sue", "Jones")

# Output
Peggy Sue Jones

Python's built in functions

As I mentioned at the start of the article, Python comes with some built in functions to handle common tasks for us. We have already used one of them a lot - the print() function. The print function, prints to the screen or terminal whatever we pass it as an argument in the brackets. Now that you know a little about functions, this should make a little more sense. Other built in functions work in a similar way - we call the function name and then pass arguments in the brackets. For an idea of how a built in function works, you can't beat the official Python documentation. Here are some examples of some other built in Python functions:

bin() - accepts an integer argument and returns it in binary
float() - accepts an integer or string and converts it to a float
int() - similar to float() but returns an integer
len() - returns the length (number of items) of a list or tuple

Returning Values

The final topic for this article is about functions returning values. So far we have been getting our functions to print their results to the screen as this is the simplest way to show they are working as expected. However, what if we wanted to actually use the output of a function for something else? Maybe we want to store the result in a variable to use later, or perhaps use it as the input for another function? To do this we use a new key word return. Returning a value from a function changes its scope and makes it available to use outside of the function.

We will stick to the name printing function for simplicity but now instead of printing a name we will return it:

def print_name(name):
    return name

Now we call the function as before:

print_name("John")

Nothing happened right? What is happening behind the scenes is that the function ran and sent back the value of name but nobody was listening - we had not written any code to do anything with it. Let's store that returned value in a variable so we can see it and use it. To do that we assign the value of a variable to our function call:

my_name = print_name("John")

Now whatever is returned by calling this function is stored in our variable. You can verify it has worked by printing your variable if you like.

We can return multiple values from a function and store them in multiple variables. Values will be assigned to the variables in the same order they are returned:

def print_name(first, last):
    return first, last

first_name, last_name = print_name("John", "Smith")

OK, let's take it up a notch. We will define one function which will get a name from a user, and another which will take the returned value and print the name to the screen. First we define our 2 functions:

def get_name():
    name = input("What is your name? ")
    return name

def print_name(name):
    print(name)

Now we simply need to call the print function to make it all work. We can now store the value of get_name in a variable and then pass it on to print_name as an argument:

my_name = get_name()

print_name(my_name)

We can now get any name from a user and then print whatever that name happens to be. We can also shorten this code even further by removing my_name all together. Remember that calling a function will run that code at that point. Well, that includes inside the argument brackets of a function call! We can achieve the same result as before by instead using:

print_name(get_name())

When print name is called it looks for an argument to be passed. Instead of a variable, there is a function call instead. It will run that function there and then and whatever result is returned that is what it will use as the argument.

Challenge

For this challenge, all I want you to do is use what you have learned about flow control, loops and functions to improve on the calculator application we made earlier. In its current state, the calculator is pre-written and uses only arguments we have written into the code. It also completes only one calculation before exiting.

To improve the calculator application have a go at the following tasks:

Take input from the user about what kind of calculation they would like to do
Ask for 2 numbers from the user and then pass these as arguments to the relevant function. Hint - you may need to convert the data you receive to something more usable using a built in Python function.
Display the results and then ask the user if they would like to perform another calculation
If the user answers 'yes', loop back to the start of the application and run it again. If they answer 'no', exit the application.

By now I hope that you are starting to get a better feel for the concepts that we have covered so far and that you are using other resources online to improve your learning. As such I will not be walking you through this challenge's answer step by step but rather I will simply post 1 possible solution you could use. Remember, there is nearly always multiple ways of accomplishing your goal in coding. Good luck, I know you can do it!

Conclusion

We have now covered 3 important concepts in programming - flow control, loops, and functions. By using these building blocks you can now write some pretty sophisticated applications. There is another level though, something which many modern programmers aspire to do efficiently and elegantly - Object Orientated Programming (OOP).

I will be getting into the basics of OOP in a future article. However, before that I want to discuss some other topics which I hope will help you learn and overcome some difficulties. The next article will be discussing the subject of error handling. So, please keep your solution to the calculator challenge as we will be using it to demonstrate error handling next time.

Once again, thank you for reading, constructive feedback is always appreciated and I look forward to seeing you next time!

Simon.

Part Five: Loops

Simon Chalder — Sun, 27 Nov 2022 20:37:16 +0000

"The definition of insanity is doing the same thing over and over and expecting different results." - Albert Einstein

Welcome to part five. In this series I hope to introduce the basics of coding in Python for absolute beginners in an easy to follow and hopefully fun way. In this article we will look at some of the ways we can design code which will make repetitive tasks quick and easy, but first let's take a look at the solution for the challenge set in part four.

Solution to part four's challenge

To solve the challenge, we need to use what we have learned about flow control, taking user input, and concatenation. The first task is to collect 3 pieces of information from the user - a first name, last name and their age. We will store each of these pieces of data in it's own variable.

first_name = input("First Name: ")
last_name = input("Last Name: ")
age = input("Age: ")

We now have first name, last name and age stored in separate variables. We are now asked to make some decisions based on their age to determine if they are old enough to do a certain activity. Our decision making will need something to compare the user's age to, so we make a fourth variable and assign the minimum age for our activity.

min_age = 18

Finally, to make our decision, we use an 'if / else' statement using our variables.

if age >= min_age:
    print("Hello " + first_name + " " + last_name + ", you are " 
    age + " and therefore old enough to vote in the UK where the 
    minimum age is " + min_age)
else:
    print("Sorry " + first_name + " " + last_name + ", you are " 
    age + " and therefore NOT old enough to vote in the UK where 
    the minimum age is " + min_age)

Loops

Loops as their name implies, are a way of running a piece of code again and again without the need to type everything out each time. For example, say I have a list of 100 animals and I want to print out each animal on the list. I could do it with a print statement for each item on the list:

my_list = ["badger", "woodcock", "pheasant", "pinemarten"...etc..]
print(my_list[0])
print(my_list[1])
print(my_list[2])
# ... and so on.

However, that's over 100 lines of code just to print a list! Apart from being time consuming to write, this would not be very fast or efficient from a software writing perspective.

A better way is to use a loop. Loops are a standard thing across programming languages and Python sports the usual two forms - 'while loops' and 'for loops'.

While Loops

Let's look at while loops first. Going back to our list printing problem, we can use a while loop to do the hard work for us. While loops work like this:

Do something for as long as a condition is valid

Let's put this into practice so it makes more sense. Our while loop will keep doing something (in this case printing out list items) until our condition is no longer met.

Here is the loop we will use. Have a read line by line and see if you can get a feel for how this is going to work. If not, don't worry I am going to go through each part below.

i = 0
while i < 100:
    print(my_list[i])
    i += 1

When this code runs the following happens:

The loop checks the value of i which starts at '0' and compares it to our condition which is i must be less than 100. As long as we meet this condition (i = 0 so is less than 100) we run the indented code below.
The code then prints the item in my_list with an index equal to i which is 0, so we print the first list item.
We then add 1 to i so it changes from 0 to 1.
The loop then runs again but this time i is equal to 1 which is still less than 100 so we run the indented code again.
The code prints the list item with the index of i which is now 1 and so we print the 2nd list item
We add 1 to i making it now 2
The loop runs again with i now equal to 2 and so on....

Let's go through it line by line.

Our variable i is effectively a counter to keep track of how many times we have run through the loop. You will often see this variable named 'i' or 'x' but in theory you can use any name you like:

i = 0 # remember the first index of a list is 0

OK, we have set our index variable to 0. Now we form our loop and set our condition to keep running through the loop.

while i < 100:

Starting with the keyword while we say that while the value of i is less than 100 - keep running the indented code below the loop statement. Instead of 'i < 100' we could also use our other operators such as greater than (>), equal to (==), greater than or equal to (>=) etc.

    print(my_list[i])
    i += 1

In this example our code prints a list item with an index equal to i which starts at 0. After the print statement, we increase i by adding 1 to it. The code += is a short hand for adding 1 to something and is short for i = i + 1. We could increase our variable by any amount such as i +=5 to increase in increments of 5. We can also count backwards using -=.

The whole thing would look like the following:

my_list = ["badger", "woodcock", "pheasant", "pinemarten"...etc..]

i = 0
while i < 100:
    print(my_list[i])
    i += 1

# Output
'badger'
'woodcock'
'pheasant'
'pinemarten'
# etc etc.

While loops are excellent for using where we must keep something going until a condition changes but there is a better way to loop through data structures such as lists and tuples - the 'for loop'.

For Loops

A for loop will automatically loop through a string, list, tuple etc even if we do not know how many items it contains. Whereas using a while loop requires us to set a condition for how many times we want to run the loop, the for loop does this for us. For loops effectively work in the following way:

For each item in this string/list/tuple etc - do something

Let's go back to our animal list and take a look at using a for loop. Again, take a look at it first and see if you can see how it will work.

my_list = ["badger", "woodcock", "pheasant", "pinemarten"...etc..]

for x in my_list:
    print(x)

A lot more compact isn't it? We do not need to create a counter variable or set the number of times to run through the loop, the for loop handles this for us. Each time the loop runs the following is happening:

The for loop automatically starts with the first list item at index 0 and stores the value of this item ('badger') in the variable x.
The loop then prints the value of x which is 'badger' to the screen.
The for loop now automatically moves to the next list item at index 1 and stores this item value in x ('woodcock').
The loop prints the value of x which is now 'woodcock' and so on....

Let's run through line by line:

for x in my_list:

We start with the keyword for. Next x is the name of a variable that exists only inside of the for loop. This variable could equally have been named animal, species or anything else we wanted. Each time the loop runs, the value of the item in my_list is stored in x.

print(x)

For each time through the loop, it prints the value of x which will be equal to the next list item each time through the list.

A Note on infinite loops and the 'Do While' loop

Whenever we use loops in our code we must be careful not to use loops which cannot satisfy the condition we set and therefore cannot end because we have not given a way to meet the condition. Consider the following loop:

i = 0
while i < 10:
    print(i)

This looks harmless enough right? Look closer, how will this loop end? We have not included a way to increment our index variable and so it's value will always be 0. Our condition states that while i is less than 10 the loop will continue to run. What we have created here is an 'infinite loop'. While in this example, we can simply press CTRL + C to exit out of the application, in more complex applications this can lead to all available memory being used up and the device will crash or freeze. Always make sure your loop is able to reach it's exit condition.

If you go on to code using other programming languages, you may come across another type of loop which is not natively part of Python - the do while loop. The do while loop is the same as a while loop with one key difference. A normal while loop has a condition which is checked at the start of the loop meaning if that condition is not met, the loop will never run. However, the do while loop puts this condition check at the end of the loop meaning the code contained in the loop will always run at least once.

Do while loops can be approximated with workarounds in Python but for now I wouldn't worry about them, I just wanted to make you aware of what they are and how they work.

Exercise

Let's try putting loops into practice to show what they can do. Remember when we discussed slicing strings? I gave the example of writing code which would sort through livestock ID codes to give us data about the kinds of animals we had and their numbers. Well, let's write it now! Not only will this task use what we have learned using loops but it also introduces a new concept - using if / else statements with loops.

In this task you should imagine yourself in the role of a farmer or livestock manager taking inventory of their stock. You are presented with a list of ID tags which give each animal a letter determining their type and a unique ID number. The letters tell us the animal type as follows:

'B' - Bull
'H' - Heffer
'P' - Boar
'S' - Sow
'R' - Ram
'E' - Ewe

We need to write code which will analyse the list and determine 3 things:

How many animals of all types do we have?
How many of each type do we have?
How many total males and females of all species do we have?

In order to get you started I am going to generate the list for you. Delete any unwanted code from your IDE or create a new file. Copy and paste the following into the file:

import random

letters = ['B', 'H', 'P', 'S', 'R', 'Y']
stock = []
i = 0
while  i < 1000:
    letter = random.choice(letters)
    num = random.randint(100, 1000)
    stock.append(letter + str(num))
    i +=1

Don't worry how this works for now, just know that it is using a loop to generate a random list of codes for us to work with. As such, each time you run the code the list will be different so just bear that in mind if you get differing results.

So, we have our livestock list. Now we need to sort through it to determine what we have. If you feel confident then by all means have a go at solving this yourself using what you have learned. If not, or you want to follow along instead then read on.

Let's look at the problem first. We have a list of ID tags, each tag is comprised of a letter and a series of numbers. The numbers don't concern us, we are more interested in the letters as they denote the type of animal with that ID. We need to therefore loop through the list looking at the letter at the start of each item and then count the number of times each letter appears. To start, let's create variables to count each animal type:

bull = 0
heffer = 0
boar = 0
sow = 0
ram = 0
ewe = 0

Next we will create our loop which will do all of the hard work for us. This list is relatively small but in real life scenarios we could be dealing with lists with tens or even hundreds of thousands of items and making loops is a big time saver!

for count in stock:
    if count[0] == 'B':
        bull += 1
    elif count[0] == 'H':
        heffer += 1
    elif count[0] == 'P':
        boar += 1
    elif count[0] == 'S':
        sow += 1
    elif count[0] == 'R':
        ram += 1
    elif count[0] == 'E':
        ewe +=1
    else:
        pass

Yikes, that's a big loop! Well, yes but break it down line by line to simplify it. We have created a for loop and every time this loop runs we ask the question - is the first character (count[0]) of each list item equal to 'B'. If the answer is yes then we add 1 to our bull total. If the answer is no, we move to the next else / if statement which asks - is the first character of the list item equal to 'H'? Again, if the answer is yes we add 1 to our heffer total. If not we move onto the next option and so on. If we get all of the way through the loop and the list item has not been equal to any of our questions we reach the else statement and we move onto the next item.

Now to check if this has worked, we can print out our totals.

print("Total Bulls")
print(bull)
print("Total Heffers")
print(heffer)
print("Total Boars")
print(boar)
print("Total Sows")
print(sow)
print("Total Rams")
print(ram)
print("Total Ewes")
print(ewe)

All being well, you should see something like this in your output (remember each list is randomised so the numbers will be different):

For an additional challenge, see if you can find a way to print the above figures in a more concise way like 'Total Bulls: 176'.

Next let's get a grand total for the number of animals we have and print this out below. This one should be easy for you:

grand_total = bull + heffer + boar + sow + ram + ewe
print("Total animals")
print(grand_total)

HINT: Maybe there is a way to create a line break between our species totals and grand total?

Finally, lets get our total males / females. Again, this should be fairly straight forward.

males = bull + boar + ram
females = heffer + sow + ewe
print("Total Males")
print(males)
print("Total Females")
print(females)

If your code is right you should have something like this in your output at the end (I included line breaks in mine):

Umm, guys... we just wrote an application which could have been useful for something and accomplished a real world task! We are past the boring beginner stuff and we are now moving into subjects which enable us to deliver real solutions to real problems. With a bit of practice and imagination, we can begin to write software which can actually help ourselves and others. Getting totals for each animal type is just the tip of the iceberg of what we can do with out data now we have the ability to loop through it (known in programming as 'iterating'). If you are so inclined then I would encourage you to continue to add functionality to our code in order to manipulate the data in new and interesting ways.

Challenge

The challenge for next time is to write some code which will crack the code for an imaginary safe - all perfectly legal I assure you! I will give you a list of possible codes. All you need to do is run through the list until you find the right code to unlock the safe.

Here is the list of codes to get you started:

import random

code_list = []
i = 0
while i < 1000:
    num = random.randint(10000, 99999)
    code_list.append(num)
    i += 1
safe_code = random.choice(code_list)

The above code generates a list of 1000 possible codes to try and also picks one of those codes to be the actual safe code so you can't see it and cheat!

So, in summary write code which does the following:

Combs through the list of possible codes and tries to match each one to the actual safe code.
If the code matches print out something like "Safe cracked - code was 35865".
If the safe code does not match then the code should do nothing and run the loop again until the correct code is found.

A Note On Password Cracking In Real Life

Although we are just having fun here, this is basically a simplified version of brute force password cracking used by hackers to get into accounts. If you would like to check if the password you use for your online accounts is likely to be on a list of compromised passwords then you can create a similar application to the challenge above which does just that. Simply Google 'RockYou password list' and download this list or any other similar list. You can then import the file using Python (I will leave that up to you to discover how) and then check your password string against those in the list. If it's on the list, it's probably time to change it!

In case you are wondering, these password lists are used by penetration testers to make sure software and websites are secure and they are perfectly legal to download and use. However, if you are unsure then please check all applicable laws where you live before downloading anything.

Conclusion

Now we have begun to add flow control and loops to our code, I hope you are now starting to see that we are able to create useful applications that actually do something! I also hope that this is beginning to open your eyes to the possibilities when making your own projects. Take some time to become familiar with flow control and loops and then start to think of how they could be utilised in your own work or study to create applications to save time and work. In the next article, I will be discussing functions and methods which enable us to create re-usable chunks of code which can be inserted into our applications without needing to re-write everything each time.

Thank you for reading. As always, constructive feedback is always appreciated and I look forward to seeing you in part six.

Simon.

Part Four: Flow Control

Simon Chalder — Wed, 23 Nov 2022 17:46:45 +0000

"Nothing is more difficult, and therefore more precious, than to be able to decide." - Napoleon Bonaparte

Welcome to part four. In this series I hope to introduce the basics of coding in Python for absolute beginners in an easy to follow and hopefully fun way. In this article we will look at some of the ways we can use logical states to allow our code to make decisions in Python, but first let's take a look at the solution for the challenges set in part three.

Solutions to part three's challenges

Task 1

# Create a list and name it my_list
my_list = ["leaf", 98, False, "red kite", 4.68]
# Append your name as a string to the end of the list
my_list.append("Simon")
# Delete the 3rd item in your list
del my_list[2]
# Substitute the 1st and 2nd items in your list with different 
# items
my_list[0:2] = ["flower", 26]
# Delete the entire list
del my_list

Task 2

# Create a tuple and name it my_tuple
my_tuple = (1, 2, 3, 4, 5)
# Try to append, delete or change values in my_tuple and note any # errors or messages Python gives you
"TypeError: 'tuple' object does not support item assignment"
# Tuples cannot be changed once they are created!

Task 3

#Create a dictionary and name it my_dict. In it, create the keys 
# "genus", "species", "habitat" and "diet" and give them some 
# appropriate values
my_dict = {'genus' : "Cervus", 'species' : "elaphus", 'habitat' : "woodland", 'diet' : "herbivore"}
# Add a new key "Lifespan" and give it an appropriate value
my_dict['Lifespan' : 20]
# Delete the genus key and value
del my_dict[genus]

Time for a new toy!

Up to this point we have been using IDLE to run and test our code. IDLE comes bundled with Python and is a great way to test lines of code and to try things out. So far, we have been running our code one line at a time and seeing what will happen. As we move now into slightly more advanced topics, we will be writing multiple lines of code before running the whole thing. While IDLE is capable of doing this, I feel it is beneficial for the learner to see everything laid out in the proper format. In addition, setting out our code in the proper way is essential for making the code human readable and in some instances it is also necessary for Python to understand our code. To this end we are now going to use a new tool - the IDE or 'Integrated Development Environment'. The IDE will allow us to write multiple lines of code, save our code in a Python file and then run the file. Many IDEs also come with handy features such as syntax highlighting and auto-completion but more on those shortly.

Choosing an IDE

There are many IDEs out there which will allow you to write and run Python applications. Some are free, some you have to paid for (just use a free one!), but they all work in a similar way. Developers are fussy creatures and everyone has their individual preferences. In time you can experiment with several and choose the one you like best but for now I am going to give you a choice of two:

First off, we have Visual Studio Code by Microsoft. Visual Studio Code is a desktop application (they are working on an online version) which works with basically any programming language and has the ability the download plugins in order to make it look and run exactly how you want. To download VS Code follow this link to download and install from the official site. There are downloads for Windows, Mac and Linux and it is also available through many Linux package managers. After installing and opening VS Code you should be presented with something similar to the following image:

To begin, either click 'New File' on the welcome screen or open the 'File' menu in the top left and select 'New File'. A small dialog window should now open asking you to name your file. Whatever name you choose make sure the file has the extension '.py' at the end so VS Code knows it is a Python file. Make a note of where you save your file, it may be a good idea to create a new folder to keep your code files separate.

Once your new Python file is created you should be presented with a blank page and a flashing cursor all ready to go.

Before we do anything look for the 'Extensions' icon on the left side of the window and click it or press Ctrl + Shift + X to open the Extensions pane. In the search bar at the top of the pane type 'python' which should show all of the available Python plugins available. Near the top of the list should be a plugin named 'Python' with the subtitle 'IntelliSense (Pylance)' by Microsoft. Click the little blue 'Install' button to add this plugin to VS Code. This plugin is gives us features such as syntax highlighting and autocompletion.

Some other optional plugins you can search for and install would be:

Pylance
Rust Syntax Highlighting

The second IDE option I am going to suggest is replit.com. Replit is an IDE for writing Python (and other languages) but it is entirely online based with nothing to download or install. Simply go to the link above and create a free account to get started. You will then be taken to the dashboard screen which will look something like the following:

Click the '+ Create' button in the top left to get started and you will be greeted with 'Create a Repl' popup. Select 'Python' from the available templates and then give your project a name before clicking 'Create Repl'. You should then see a screen similar to the following:

The screen is divided into two panes, our code writing pane on the left and the terminal or output on the right. On the left of the screen you will see some file names. Ignore all of the packager files, we won't be touching them. Instead note 'main.py', this is the current open file and the one we will using to write our code.

Phew! IDEs are an entire topic in of themselves but we should hopefully be at a point where we can start coding in this new environment.

Taking it for a spin

Let's try out our new IDE to get a feel for how it works.

In your open Python file type the following using your own name. Press enter at the end of each line to start another:

name = "Simon"
print(name)

So...nothing happened, not yet anyway. In order to run our file we need to:

In VS Code either locate the small forward arrow icon in the top right and click the button or press Ctrl + F5.
In Replit simply press the green 'Run' button at the top of the screen

You should now see your name printed to the screen. In VS Code the terminal will appear at the bottom of the screen and with Replit it will be in the right side pane.

So what exactly is happening when we press 'Run' in the IDE? Python is known as an 'interpreted language' which is a fancy way of saying it runs code line by line. Python comes bundled with an interpreter that allows Python files to be run on your device. When we run the file, the interpreter starts at line 1 and reads left to right. If no errors are found then that line is stored to memory or the code executed and the interpreter moves on the the next line. This process repeats until all lines of code have been ran and the programme will end. For this reason in long Python files the interpreter may get most of the way through the code, running as it goes, before finding an error near the end and failing.

The other type of language available are the 'compiled languages' such as C, C++ and Java. Compiled languages use a separate piece of software known as a compiler to go through the entire file, converting everything into machine readable code before attempting to run the file.

Generally speaking, interpreted languages such as Python tend to make it easier to create smaller scripts or applications and their development time is often quicker as you do not need to wait for a compiler to convert the whole file to run it. However, once compiled language files are compiled they are generally faster to run and are used in cases where speed is a key factor.

For more information on interpreted vs compiled languages follow this link.

A quick note on Python files

Python files can also be ran outside of the IDE in a couple of different ways.

Firstly, locate the folder where your Python file is stored in your device's file explorer. We can simply double click on them like any other executable file. However, what you may find with this is that a window appears on the screen and then immediately disappears. This is because our code has nothing to stop it running to the end and it is not waiting for anything to happen so it closes down.

A better way, particularly if our file will produce output to the terminal is to actually open the file in our device's terminal. In windows click the Windows / Start Menu and type 'cmd' and hit enter. On Mac or Linux search for 'Terminal' and open. Navigate to the folder containing your Python file and type the following depending on your devices operating system:

Windows - python .\python_file_name.py
Mac / Linux - python ./python_file_name.py

Flow Control - Is it this or that?

Finally, we get to the subject of this article's discussion. There comes a time in every coder's journey where we need our code to make some decisions for itself. In order to do this we need to have some kind of control state. The control state may be a variable or the output from another piece of code and it could represent boolean values, a number, a string or pretty much anything we can check to determine if it is one thing or another. We then look at that state and depending on what we see at that time we go in one direction or another. Essentially, we ask a multi choice question in our code - does the value of this thing we have selected match one of these values? If the answer is yes then we will run a piece of code associated with that value. If not, we can run code in the event that none of our answers match.

In coding, to make these decisions we use the 'If / Else Statement'. Consider the following example where we have a variable - state, which contains boolean data (True or False). We use an if statement to check the value of state and then run some code depending on the outcome.

state = True

if state == True:
    # run this code if the answer is yes
else:
    # otherwise run this instead if the answer is no

If state is equal to 'True' then the answer to our question is yes (True) and the first indented code block will run

If state is equal to anything else then the result will be no (False) and the second code block will run

In the above example, state is equal to 'True' so the value of the state variable matches our question - does state have the booelan value 'True'? - yes it does! Had state had the value 12, 4.6, "otter", False, or anything other than 'True' the answer to our question would be no, our if statement code would not run and we would default to our wrong answer code instead.

There are some key points to go through here so let's break the if statement down line by line:

if state == True:

Our statement begins with the keyword if. Remember those protected keywords used by Python, this is another one of them and it can't be used for variables names or similar. We then say which control state we are going to be checking, in this case a variable named state. What follows are 2 '==' signs which in code mean 'equal to'. Finally, we say what we are comparing our control statement to, in this case the value 'True'. We then end the line with a colon ':' to let Python know to look for indented code below. In English what this line says is:

if my variable named 'state' has a value equal to 'True' then do what comes next

    #run this code if the answer is yes

If our if statement is true, that is state is indeed equal to True then we run the code found indented from the if statement. Indentation or offsetting code from the margins is a frequently used formatting convention in coding and the subject of a furious debate which I won't get into here. Suffice to say we can either indent our code using the Tab key or using 4 spaces. Any indented code immediately following the if statement line will be ran ONLY if the if statement is true.

else:

So what if the if statement is not True? In that case we move down to the 'else statement'. The else statement is not compared to anything because it is our default and covers any outcome other than that tested in the if statement. So again, in plain English we can see the if / else statement as:

if this value is equal to this value then run the indented code that comes next:
    #Some code here
Else, for any other outcome run this indented code instead:
    #Some other code here

The indented code in the else statement will always run unless the if statement turns out to be true.

Time for a hands on example. In your chosen IDE delete any code you already have and create a variable called chance and set it equal to 'True' (capital 'T' and no quotation marks).

chance = True

Underneath on the next line write the following if statement and press enter:

if chance == True:

We have now created our if statement to check if chance is equal to 'True'. On the line under the if statement indent your cursor using either the tab key or 4 spaces and write the following and hit enter:

    print("It's True!")

On the next line write our else statement and press enter. Make sure the else statement is not indented and is all the way to the left:

else:

Finally, on the last line write the code to run if the else statement comes into play, again indent this line with tab or 4 spaces:

    print("It's False!")

All together we should have the following:

chance = True
if chance == True:
    print("It's True!")
else:
    print("It's False!"

Run the code, what output do you get? Hopefully you should see "It's True!" printed to the console. If not, double check for typos and make sure you are indented correctly.

"There are two ways to write error-free programs; only the third one works." - Alan Perlis

So at this point, our code is making decisions based on the state of a value. So what? Well, being able to make decisions means we can write software which can alter how it works based on the outcome of certain factors which means we can anticipate different use cases to make sure our application can handle anything we throw at it.

Now let's take a look at what happens if state is not True, what happens then? Go back into your code and change the value of state to 'False' or anything other than 'True'. Run the code again and check the output. If all is working properly you should see "It's False" displayed in the terminal.

Hopefully this is making sense, so let's try a more useful example. Clear your code from your IDE window and start with the following line:

guess = input("Guess a number between 1 and 5: ")

This line uses another inbuilt Python method to get input from the user of the application and store it in a variable named guess. We can also use this to print some text on the screen to tell the user what we want from them. So we will get a number entered by the user, now to check if they have guessed our secret number correctly. Under the first line write the following if statement:

if guess == 3:
    print("Correct! You Win!")
else:
    print("Incorrect, you lose!")

Run the code and try it out, enter a number and see if the code behaves as expected.

Variations of the If Statement

We can alter the way our if statements work with a few tweaks.

First lets look at some of the other operators we can use instead of '==' equals to:

Not equal to - !=
Greater than - >
Less than - <
Greater than or equal to - >=
Less than or equal to - <=

Example 1

if 12 != 6:
    print("True!")
else:
    print("False!")
# Output
True! # 12 is not equal to 6

Example 2

if 64 < 32:
    print("True!")
else:
    print("False!")
# Output
False! # 64 is is not less than 32

Example 3

if 128 <= 128:
    print("True!")
else:
    print("False!")
# Output
True # 12 is equal to or less than 128

Multiple Operators

As well as the operators we have already looked at such as '==' '!=', '>' etc we can also combine multiple operators to get more specific about what we are looking for. To combine operators we use the keywords and / or. When using and both if statements must be True for the result to be True. When using or only one needs to be True.

Example using and - 12 is both greater than 10 and less than 15

number = 12
if number > 10 and < 15:
    print("Maybe it's 12")
else:
    print("Could be anything!")

Example using or - 64 is not less than 10 but is greater than 60

number = 64
if number < 10 or > 60:
    print("Looks good")
else:
    print("Could be anything!")

Else If

A final addition to the way we can make decisions with if statements is with the use of the 'Else If' statement. Essentially this allows us to add more than 2 outcomes for our decision making. If the if statement is False then Python will check each else if statement for a True outcome before finally defaulting to the else statement. The syntax for an else if statement is elif followed by the condition to be met:

animal = "sheep"

if animal == "cow":
    print("It's a cow!")
elif animal = "sheep":
    print("It's a sheep!")
else:
    print("I don't know what it is!")

# Output
"It's a sheep!"

In the above example, Python checks our if statement to see if animal is equal to "cow" but this returns false so it moves down to the else if statement and checks animal to see if it is equal to "sheep' which it is and so returns True. As Python has found a True statement, the indented code under the 'elif' statement is run. The rest of the if / else statement is not run and the code will continue under the if / else statement.

Pass and Break

The final thing I want to discuss in this article is the use of pass or break. Sometimes in our if / else statements there can be an outcome where we do not want anything to happen if a statement is true.

Firstly, using the pass statement will move down to the next part of the if / else statement without doing anything

state = "Undecided"

if state = True:
    print("True")
elif state = "Undecided":
    pass
else:
   print("Not sure")
# Output
"Not sure"

In this example when state is found to be equal to "Undecided" the indented code is run. However, the pass statement moves Python on to the next part of the statement which is the else statement.

The break keyword is similar to the pass keyword except using break will cause Python to jump out of the if / else statement all together and continue on from the next line.

state = "Undecided"

if state = True:
    print("True")
elif state = "Undecided":
    break
else:
   print("Not sure")

print("must have used the break statement")
# Output
"must have used the break statement"

So why do we care about all this if / else stuff?

The ability to check values and act upon them is fundamental to software development. Consider the following uses for if / else statements in applications:

Checking the input a user gives us to make sure it is the right data type and matches our requirements. For example, if we ask for a user's name we want to ensure they have actually typed something and not just pressed Enter with a blank name. We can also check they have not entered numbers, inappropriate words etc.
When using datasets we can go through all of the values in a large spreadsheet or file and check that each value is formatted properly, is the correct data type and if we find missing values we can flag these or enter replacement values automatically.
When sending data or files over the internet we can check a variable containing an http response status code which tells us if the data or file has been received correctly.

The use cases of 'check if this is a certain way and then do something if it is' are almost endless. I definitely recommend spending some time with this topic to get to grips with it fully.

Challenge

Task

For this task I am going to set you a challenge but I am not going to give step by step points to accomplish it.

My challenge is to create a Python application using everything you have learned so far which is able to do the following:

Ask the user for first and last name as well as their age
Look at the age given by the user and perform some decision making to decide if they are old enough to do something where you live - vote, drink, drive etc.
Print out to the terminal a sentence along the lines of "Hello , you are and you [can/cannot] do [activity]!"
For an extra challenge, give yourself more decisions to make so check if the person is eligible to do several activities which require them to be a certain age.

Take your time and go back over the article if you get stuck. You can do it!

Conclusion

With the addition of 'Else If' statements we can begin to make quite complex decision making which can account for a variety of possible outcomes. Along with our new found ability to take user input we can now start to make applications that can actually do something useful. Flow control marks the point where we move from total beginner subject matter to things which get a little more complicated. All this means is that you may need to spend a little more time with things and do some extra practice to get a good understanding of things. Learning to code is not about memorising syntax it is about learning how things work on a conceptual level and then putting all of the pieces together to create something amazing. Keep going and make the most of all of those great coding resources online if you are struggling.

So far we have made code that will run and then stop when it is done. What if we could make an app which would be able to run again and again if needed until we are finished with it or maybe it could do something really repetitive many times really quickly? Well, good news that is the subject of the next article - loops! Thank you for reading and I look forward to seeing you in part five.

Simon.

Part Three: Data Structures

Simon Chalder — Sun, 20 Nov 2022 11:54:45 +0000

Welcome to part three. In this series I hope to introduce the basics of coding in Python for absolute beginners in an easy to follow and hopefully fun way. In this article we will look at some of the ways we can store multiple values in a single variable in Python, but first let's take a look at the solution for the challenges set in part two.

“Failure is the condiment that gives success its flavour.” – Truman Capote

Solution to part two's challenges

Task 1

1. 40
2. 336
3. -84
4. 15
5. # Python knows BIDMAS rules so we can solve this with either:
num2 + num1 * num3 / (num1 - num2)

# Or we can use brackets to seperate the multiplication and division from the addition and subtraction
num2 + (num1 * num3) / (num1 - num2)

Answer: 30.25 (result is a float)

Task 2

animal = "Crayfish"
plant = "Honeysuckle"
habitat = "woodland"

1. answer = animal[0]
'C'
2. answer = habitat[-1]
't'
3. answer = animal[4:8] OR animal[4:] OR animal[-4:]
'fish'
4. answer = plant[0:5] OR plant[:5]
5. answer = habitat[-4:8] OR habitat[-4:]

Data Structures

Why do we care about data structures?

Data structures allow us to store data in an organised manner so that it can later be retrieved easily. Examples of data structures in coding projects include:

The basket containing order items in an online store
Creating a list of customers and performing an action for each customer such as sending an email
Collect survey or study results in a list so as to be able to easily visualise or export your results

So far we have looked at using variables to contain a single value. However, we are also able to store multiple values in a single variable. Python offers 3 flavours for this, the first of which is the list. Lists can store any number of items and accept all data types so mixed type lists are possible.

Lists

"I love the way a list makes a big hodgepodge of things simmer down and behave." - Blue Balliett

A list is a way to store multiple values in a single variable. Theoretically there is a limit to the number of values or items we can store in a Python list, this source suggests 536,870,912 but in practical terms, let's just say they can hold more items than you will ever reasonably need to worry about. So what can we put in our lists? Well for starters:

Integers
Strings
Floats
Boolean
Other lists (yes lists within lists!)

We can mix and match our data types to create lists with all manner of items together in the same variable.

We can create a list by giving it a name just like a variable and then after our '=' sign we tell Python this is a list using '[]' square brackets. We can create an empty list by just using empty square brackets or we can add items when we create the list. Our list items go between the square brackets and are separated by a comma.

my_empty_list = []

list_of_biomes = ["tundra", "arctic", "jungle", "desert"]

random_list = ["orange", 33, "blue", False, 6.85]

Lists operate in much the same way as strings. Whereas strings assign an index to each character, a list assigns an index to each list item. In the following example we create a list in IDLE named mammals and use it to store some string values.

mammals = ["Red Squirrel", "Hare", "Barn Owl", "Pine Marten"]

We can now access values in the list in the same way we sliced characters in a string using the index number. Just like strings, items in a list start at index 0.

animal = mammals[1]
print(animal)
Hare

Each of these items in our list is a string and as such we can delve deeper into the list, extracting string characters from list items. To do this we use 2 sets of square brackets, the first determining the list item and the second the character in the string

In this example we slice the 4th character of the first string item.

mammals = ["Red Squirrel", "Hare", "Barn Owl", "Pine Marten"]
letter = mammals[0][4]
S

Lists can also contain other lists. In this next example, the 4th item in my_list is another list of integers. Placing lists within lists is known as 'nesting'.

my_list = [2, 4, 6, [3, 5, 7,], 8]

To access a value in the nested list we once again use 2 sets of square brackets. Just like with getting individual characters from list items, the first bracket contains the index of the list item. The second brackets contain the index of the nested list's item.
For example, if we wanted the 2nd character of the nested list (located at item 4 in my_list) we would use the following:

nested_character = my_list[3, 1]
print(nested_character)
5

OK, great but what if we want to change our list by changing, adding or removing items?

To change an item in a list, we assign a value in much the same way as declaring a variable.

mammals = ["Red Squirrel", "Hare", "Barn Owl", "Pine Marten"]
mammals[1] = "Osprey"
print(mammals)
['Red Squirrel', 'Osprey', 'Barn Owl', 'Pine Marten']

In the above example, the 2nd item in the list is changed from "Hare" to "Osprey".

We can also change several items at once. In this next example we change the 3rd and 4th items to different items.

mammals = ["Red Squirrel", "Hare", "Barn Owl", "Pine Marten"]
mammals[2:4] = ["Elephant", "Tiger"]
print(mammals)
['Red Squirrel', 'Osprey', 'Elephant', 'Tiger']

A brief and passing introduction to methods

Whoa, hang on there! What's this method thing you're trying to sneak in?

We will get into functions and methods in the future but for now just know that a method is a chunk of pre-written code built into Python that performs a certain repeatable action. We have actually already been using one of Python's built in methods. Remember the print() code we wrote to show the contents of our variable? The print method came with Python so we did not have to figure out how to get our output onto the screen from scratch. Methods are huge time savers and as we go on you will see a lot more of what they can do. Anyway, back to lists...

The append() method allows us to add items to the end of a list easily. The syntax for using this is list_name.append(thing we want to append). The next example shows how we would add an item to a list in this manner

mammals = ["Red Squirrel", "Hare", "Barn Owl", "Pine Marten"]
new_item = "Badger"
mammals.append(new_item)
print(mammals)
["Red Squirrel", "Hare", "Barn Owl", "Pine Marten", "Badger"]

As well as appending a variable to a list such as mammals.append(new_item) we can also append the value directly mammals.append("Badger").

We can remove items from a list or delete an entire list using the delete.() method. Again the index value works in the same manner as slicing and we can give a range of index numbers or count backwards.

mammals = ["Red Squirrel", "Hare", "Barn Owl", "Pine Marten"]
del mammals[2]
print(mammals)
["Red Squirrel", "Hare", "Pine Marten"]

Tuples

Tuples are very similar to lists, except once it is created we cannot alter the items it contains. tuples are created much like lists but using round brackets rather than square brackets. Tuples, like lists can contain any data type including other lists and tuples.

my_tuple = (12, 4.2, "Giraffe", False)

We can access tuple items using index numbers in the same way as lists.

my_tuple = (12, 4.2, "Giraffe", False)
my_tuple[0]
12

However, unlike lists we cannot modify the contents of a tuple using methods.

Dictionaries

"Baldrick, believe me, eternity in the company of Beelzebub and all his hellish instruments of death will be a picnic compared to five minutes with me and this pencil if we can't replace this dictionary." - Blackadder

In Python, dictionaries are collections of data organised into key : value pairs. This allows us to retrieve values by referencing the key to which that value is assigned. Dictionaries are created using curly brackets '{}'.

my_dictionary = {1: "Rabbit", 2: "Fox", 3: "Sheep"}

Accessing values in dictionaries is accomplished by using the key rather than an index number. In the above example if we wanted to access the value associated with the '2' key we would use:

print(my_dictionary[2])
Fox

Keys do not have to be numbered or have any relation to one another at all

my_dictionary = {'name': "Simon", 17: 4.67, 'pig': True}
print(my_dictionary['name')
Simon
print(my_dictionary[17)
4.67
print(my_dictionary['pig')
True

Dictionary values can be modified in much the same fashion as lists using the key for reference

Example 1

my_dictionary = {1: "Rabbit", 2: "Fox", 3: "Sheep"}
my_dictionary[2] = "Cow"
print(my_dictionary)
{1: "Rabbit", 2: "Cow", 3: "Sheep"}

Example 2

my_dictionary = {'name': "Simon", 17: 4.67, 'pig': True}
my_dictionary['name'] = "Percy"
print(my_dictionary)
{'name': "Percy", 17: 4.67, 'pig': True}

To add key : value pairs to a dictionary we use the same method as changing an item. If the key does not already exist then it will be created.

my_dictionary = {1: "Rabbit", 2: "Fox", 3: "Sheep"}
my_dictionary[4] = "Badger"
print(my_dictionary)
{1: "Rabbit", 2: "Fox", 3: "Sheep", 4: "Badger"}

We also remove items using the del() method in the same way as with a list.

my_dictionary = {1: "Rabbit", 2: "Fox", 3: "Sheep"}
del my_dictionary[1]
print(my_dictionary)
{2: "Fox", 3: "Sheep", 4: "Badger"}

Finally, just like lists and tuples, dictionaries can have nested items including other dictionaries

my_dictionary = {1: 'One', 2: 'Two', 3: {'a': 'A', 'b': 'B'}, 4: 'four'}

Accessing nested dictionary items is done in the same way as nested lists except we use the keys instead of index numbers for the parent dictionary and the nested item. In the following example we want the nested dictionary from key '3' and the item value from key 'b' in the nested dictionary.

my_dictionary = {1: 'One', 2: 'Two', 3: {'a': 'A', 'b': 'B'}, 4: 'four'}
nested_item = my_dictionary[3]['b']
print(nested_item)
'B'

Take some time to make sure this all makes sense and practice creating and manipulating your own lists, tuples and dictionaries.
Python data structures and their associated methods are a topic well worth taking the time to learn. I have only briefly touched on what is possible here. To learn more follow this link and see if you can solve the following problem:

Task 1

Create a list and name it my_list
Give your list several items of different data types e.g. strings, integers, floats etc.
Append your name as a string to the end of the list
Delete the 3rd item in your list
Substitute the 1st and 2nd items in your list with different items
Delete the entire list

Task 2

Create a tuple and name it my_tuple
Try to append, delete or change values in my_tuple and note any errors or messages Python gives you

Task 3

Create a dictionary and name it my_dict. In it, create the keys "genus", "species", "habitat" and "diet" and give them some appropriate values
Add a new key "Lifespan" and give it an appropriate value
Delete the "genus key and value

Conclusion

Hopefully, you are starting to see potential uses for data structures in your own projects. If not, don't worry you will get plenty of practice using them in the future. In the next article I am going to discuss flow control which enables our code to make decisions based on logical states. We will also be moving away from IDLE and using a new - tool the developers IDE! Exciting times ahead. I look forward to seeing you in part four. As always, constructive feedback is always appreciated. Thanks.

Simon.

Part Two: Data Types

Simon Chalder — Sat, 19 Nov 2022 18:34:03 +0000

Welcome to part two. In this series I hope to introduce the basics of coding in Python for absolute beginners in an easy to follow and hopefully fun way. In this article we will look at some of the types of data we can use in Python, but first let's take a look at the solution for the challenge set in part one.

"In the spirit of science, there really is no such thing as a ‘failed experiment.’ Any test that yields valid data is a valid test." – Adam Savage

Solution to part one's challenge

The way we can put 2 variables together and print them on the same line is through something called 'concatenation'. This fancy sounding term simply means to stick 2 things together and we do it with the '+' sign. Like many tasks in coding there are several different ways of doing the same thing so here are a few ways of accomplishing this task

Option 1

genus = "Pinus" 
species = "sylvestris"
solution = genus + species
print(solution)
# Output
Pinussylvestris

Option 2

genus = "Pinus" 
species = "sylvestris"
print(genus + species)
# Output
Pinussylvestris

Option 3 including ways to add a space

genus = "Pinus" #we could add a space here - "Pinus "
species = "sylvestris" #We could add it here " sylvestris"
solution = genus + " " + species # Or here
print(genus + " " + species)#Or here
# Output
Pinus sylvestris

Concatenation is a useful tool for formatting output or just for combining more than one value. Consider the following example:

sci_name = "Ursus arctos horribilis"
location = "Northern America"
colour = "Brown"
age = 20
sentence = "Grizzly bears, also known as " + sci_name + " are found in " + location + ". They are usually " + colour " in colour, and live to around " + age " years old"
print(sentence)
#Output
"Grizzly bears, also known as Ursus arctos horribilis are found in Northern America. They are usually Brown in colour, and live to around 20 years old"

Remember to pay attention to your quotation marks. I would highly recommend playing around in IDLE with concatenation. For more information see this link.

Some other things we can put in variables

We have now declared our first variables (a fancy term for creating a variable and giving it a value). Not all that impressive, so what else can we do with variables? As we have already learned, variables can be used to hold many different types of data. Data types are an important concept in coding. Multiplying 2 variables which contain numbers would work, but doing the same with a number variable and another which contained only text might produce unexpected results or fail all together.

There are many data types which Python can work with but for simplicity the basic, commonly used types are:

Integers - Integers or 'int' for short are whole numbers, positive or negative e.g. 12, 458, -2537 etc.
Strings - String or 'str' for short represent text and are always surrounded by either 'single' or "double" quotation marks.
Floats - Floats are decimal numbers e.g. 23.6, -945.00023.
Boolean - Booleans represent one of 2 values either 'True' or 'False'.

So we could create the following kinds of variables:

my_name = "Simon" # String
count = 100 # Integer
measurement = 685.48 # Float
is_raining = True # Boolean

Why do we care about data types?

The projects we choose to make will inevitably contain different types of data. Everything from the names of plants, animals, places (strings), to survey numbers and population counts (integers), to map coordinates, correlation coefficients or fuel prices (floats). In order to get the expected results from our projects we must ensure we are using the correct data types. Understanding data types and how they interact with each other is essential when working on projects with several different types of data.

Numerical Data

"Arithmetic is being able to count up to twenty without taking off your shoes." - Mickey Mouse

Let's say we have declared (created) a variable num1 and assign a value of 10 (num1 = 10). We can now perform arithmetic operations (+,-,*,/) using our variable. Firstly we can perform simple calculations using a single variable. In IDLE type num1 + 2 and press Enter. We see the result of 12 displayed. If we type num1 again we can see that the value of the variable has not changed, rather we have simply performed a calculation using its value.

Other mathematical operations we can perform include '-' for subtraction (num1 - 3), '*' for multiplication (num1 * 2), and '/' for division (num1 / 2).

We can also perform calculations using multiple variables:

This is all well and good but performing calculations this way gives us no way of storing the result. We may wish to perform other calculations on the result or we may wish to display it in a way other than printing to the terminal or IDLE. The solution is to store the result of our calculation in another variable. To do this we use the syntax result = num1 + num2.

A quick note on variable names.

In the above example we do not need to call our variable 'results' - we could call it anything we wish such as 'chicken' or 'sdjhdkjh'. However, when naming variables it is good practice to give them a name which reflects what they contain or are used for. It can be tempting to name variables things like 'x' or 'y' but when we begin to write longer applications it can quickly become confusing as to what these variables are for. When naming things in Python there are certain conventions we should follow. Some of these conventions make our code easier to read and some forbid the use of protected words which Python reserves for other purposes.

For example we may need to create a variable to store the total number of birds recorded during a point survey. If we simply name the variable 'result' or 'total' this could become confusing later - which result or total is this referring to? So we would choose something suitable such as bird_survey_total. We could also have named it birdsurveytotal but this is harder to read. In Python one of the naming conventions when naming variables is to use snake case (it is Python after all) which means to use an underscore '_' where a space would normally sit. Therefore, bird_survey_total would be easier to read and would follow the correct naming convention.

If you recall the previous discussion about data types we saw boolean values can be True or False. Note the capitalised first letter - 'True' and 'False' are reserved names in Python and we cannot use them to name things. You can try this in IDLE. Declare a variable named 'True' and try to give it a value - Python will give you an error to remind you not to do this.

There is more to learn with this topic and something we all get better at with practice. If you would like to know more follow this link and try to see which of the following variable names would follow Python naming conventions:

number_of_foxes
numberOfFoxes
_numberoffoxes
Number_Of_Foxes
number_of_foxes!
NUMBER_OF_FOXES

What about Floats?

Floats, just like integers can be used with mathematical operators and can be combined with integers in calculations. Be aware however that the output from such calculations will be a float, even if the result is a whole number.

num1 = 5
num2 = 3.6
num3 = num1 * num2
print(num3)
#Output
18.0 # This result is a float despite being a whole number

...and Booleans?

Boolean values represent a state - something is True or False, On or Off, 0 or 1. Booleans will come into their own in the future when we discuss flow control where we can check the state of a boolean and then perform actions depending on that state. Below is a simplified example.

bool = True
if bool is True - do this
if bool is False - do this instead

Strings

Just like numerical data, working with strings of text is an important part of coding. To recap, a string is anything inside 'single' or "double" quotations.

'Lorem ipsum' is a string
"Lorem ipsum" is a string
"12345" is a string
'34.68' is a string
Lorem ipsum is NOT a string - no quotation marks
12345 is an integer and NOT a string

We can use single and double quotations together for grammatical purposes but we must ensure that we pay attention to the kind of quotations used. For example the following would be correct:

"It's raining outside"

However this would produce an error:

'It's raining outside'

Can you see why? Python takes everything in between the same kind of quotes as a string. In the second example Python read 'It' as a string because it is surrounded by single quotes and everything after that as a separate thing. Enclosing the text in a different quotation style allows Python to treat the whole text as a string. Another example would be using double quotes inside singles such as:

'tell her I said "hello" please'
# This would work.

However, if we instead used:

'tell her I said 'hello' please'

This would produce a string containing 'tell her I said ' and another containing ' please' as well as giving an error message.

Mixed Data Types

Care must be taken to ensure the correct data type is used. For example, multiplying 6 and 3 will produce a result of 9. What about multiplying 6 (an integer) and "3" (a string)? Try it in IDLE for yourself, was it what you expected? In this case we have literally taken the string "3" and printed it 6 times. Perhaps this is what we wanted but we must ensure we are aware of the type of data we are using.

Slicing

"No matter how thin you slice it, it's still baloney" - Al Smith

We already know that printing the variable shows us the contents of that variable but what if we only want to know part of the contents? Perhaps we need to know the 3rd character in a string as an identifier or maybe the last 2 characters are important. To do this we use a technique known as slicing. Despite sounding like something a hacker would do in some dodgy action movie, slicing simply means breaking down a string into individual characters and then slicing out the bits we want.

Why would we care about slicing?

Suppose we have an application which tracks livestock numbers. Each animal is identified by a letter "C" for cow, "S" for sheep, or "P" for pig followed by a unique ID number. A sheep in the database may have the ID "S-2468" for example. By using slicing we can read the first character from the ID string value and determine what kind of animal it is. We can also poll all records and sort them by their string's first character to determine how many of each animal are represented. Slicing can be a powerful and time saving tool when used properly.

Indexing

Each character in a string is represented by a number (the index). Computers count in a slightly different way to most of us in that instead of starting with 1 they use 0. Therefore when we are doing our slicing we need to remember that the first character in a string is represented by the index 0 not 1. For example, if we had the string "Apple", Python would read the characters and give them the following index numbers:

In order to retrieve the correct character we simply tell Python the index number of the character we want. To do this we use the name of the variable containing the string followed by square brackets and inside these brackets we place the index number of the required character. It is important here to note that slicing takes a copy of the required character and the string being sliced remains unaffected. Also of note is that spaces are included as characters in strings so slicing a character which is a space will return " ".

In the above example we have a word variable containing the string "Apple". We slice character number 1 from the word variable and store it in a new variable named letter. This gives us the letter 'p' - remember, we begin the count from 0 and so character 1 is actually the 2nd letter in the string. If we had wanted the first character we would have used word[0].

In the same way that we count the 1st character as 0 we can also count backwards. Say we had a string named phrase which contained a long sentence of 80 characters, if we wanted to know the last character in the string we could use phrase[79] (remember the string has 80 characters but numbers start at 0 so the last number will always be 1 less than the total), however we may not know the total characters and a simpler way to do this is to use phrase[-1]. Using minus numbers allows us to count backwards in the same manner as going forwards. So, [-2] would be the 2nd to last character and so no.

So now we know how to extract single characters from strings. What about if we want a range of characters? The process is similar to getting a single character but we give Python a start and end position for our slice. The syntax here is variable_name[start:end]. It is important to note that the end character number is NOT included. If we use our "Apple" string example, we want to get the 1st character through to the 3rd character.

Although 'A' is 0, 'p' is 1 and 'p' is 2 we must slice up to 3 in order for character 2 to be included.

Slicing to the end of a string can be done even if we do not know the string's length by simply leaving a blank space. For example, to include everything from the 2nd character onwards we would use word[1:]. To include everything from the start of the string to the 4th character we would use word[:4].

For more information on slicing follow this link.

Time for a challenge! Here are some tasks to go through to get some practice using mathematical operators as well as some string slicing.

Task 1:

Create 3 variables - num1 equal to 12, num2 equal to 28 and num3 equal to -3. Use these variables to calculate the following:

num1 + num2
num1 * num2
num2 * num3
num1 - num3
Bonus - try to solve the following using Python. What data type is the answer?

Task 2:

Create 3 variables - animal equal to "Crayfish", plant equal to "Honeysuckle", and habitat equal to "woodland".

In a new variable store the following. Print the new variable to verify it is correct.

The 1st character from animal
The last character from habitat
The characters 'fish' from animal
the characters 'Honey' from plant
The last 4 characters from habitat

Conclusion

We have now covered variable creation and some of the types of data we can store in our variables. We have also gone over how to do basic mathematics with numbers and how to slice and manipulate text. In the next article we will look at data structures, that is, a way that we can store more than one value in a variable and even turn our variables into miniature databases. I will continue to leave small challenges to try and get you thinking and practising these topics. However, I will be intentionally asking you to solve problems for which the solution involves things we have not fully covered. The reason for this is that as you go on to make your own projects you will get stuck. It happens to everyone, even the professionals and a common joke is that developers are nothing more than expert Googlers!

When you do get stuck it is important to try and get yourself unstuck and learning where to find help and information is key. I will likely devote an entire article to this in the future but a good starting point is the official Python documentation or to search for the exact issue you are having such as "python string will not print". This will usually get you on the right track and usually someone has had the exact same issue as you. More on this in the future.

Thanks for reading. Constructive criticism is always appreciated. I look forward to seeing you in part 3.

Simon

Part One: Getting Started

Simon Chalder — Fri, 18 Nov 2022 16:29:52 +0000

"Programmer? I barely knew her!" - Unknown

What's it all about and why should I care?

Fair question.

At some point in your student or working career you may have been told that you should "learn to code". Well, what is learning to code? What is code? Is coding different to programming? Why should you even care?

Writing code, computer programming, or writing software are all terms which are often used interchangeably and essentially mean the same thing - giving a computer a set of written instructions. Just like instructing a human worker or volunteer, the amount of instruction and the complexity of those instructions can be determined by the task we need the worker, or in this case, computer to perform. Just like their human counterparts, computers will produce poor results if they are given poor instructions.

So why bother learning to code? Computers are tools which allow us to perform complex or repetitive tasks quickly and reliably. There are things we may wish to do such as collate survey results, examine geospacial data, or compare population numbers over time. In some cases we can get by using common software packages such as spreadsheets but perhaps our spreadsheet software does not allow us to display our data the correct way or does not work well with the type of data we are using. Maybe we need software to do something niche or bespoke and a readily available, off the shelf solution does not exist. In some situations, having the ability to write simple scripts (a small, usually simple application) or applications which will do a specific task for us can save us a great deal of time learning how to use a commercial software package.

Here are some examples of simple software applications which you could write:

Comb through large datasets to find what you need and then manipulate that data in any way you wish
Produce custom graphs and visualisations from your data to show others
Write a script which will automatically go out onto the internet and retrieve data from websites or databases. No browser required!
Use machine learning to make future predictions based on historical data

My intention with this series is not to take you from novice to professional developer but to give you a taste of the possibilities that writing your own code can bring. How far you wish or need to take it from there is completely up to you.

"Yes! Get on with it!" - Monty Python

Ok, enough waffle lets start coding. A quick online search for programming languages will bring back a frighteningly large list of results. Fortunately we are only going to focus on one - Python. Python, like all programming languages has its pros and cons. However, it is generally seen as a good language for beginners to get to grips with and as a bonus is used extensively in the data science and machine learning fields. Additionally, if you follow the principles of python, that is an object orientated approach (more on this later), then you will be able to pick up other programming languages easily. The way each language is written (the syntax) is slightly different from language to language but they mostly follow the same core concepts.

First things first we need to install Python on the device you will be using (preferably something with a keyboard). The Python website contains download links for Windows and Mac, simply select the relevant link, download and install. For Linux users, you may already have python installed with your distribution - type python -V into the terminal. If you see a version number you are good to go. If not follow instructions to install via your package manager. It's a good idea to bookmark the Python site as the documentation there can be very helpful when making your own projects.

Python should be installed and ready to go. To begin, open your device's application list or perform a search for 'IDLE' and open the application. If all is going well up to this point you should see something similar to the image below:

IDLE stands for 'Interactive Development Learning Environment' and it is essentially a way for us to try out code without worrying about breaking anything. So lets type something and see what happens. In the text window of IDLE click to get a cursor and type your name, then press Enter.

Yikes! Red text! Traceback what...? What's a NameError? Why is Python angry at me? Well, firstly Python isn't angry, in fact it is trying to help us. The error message we received is telling us that Python did not understand the code we typed. Specifically, the message tells us which bit of the code it did not understand (in this case line 1) and the kind of error (NameError) gives us information as to what the problem may be. Error messages are not to be feared and you will see them a lot, particularly in the beginning.

Variables - The Coder's Magic Box

Let's try typing our name again but this time type name = and then your name but make sure your name is in either single or double quotations. For example I would type name = "Simon" and press Enter.

Wait, nothing happened. Or did it? What we did here was to create a variable called 'name' and give it a value, in this case your name. A variable is a placeholder for a value and we use the '=' sign to assign values. We can imagine a variable to be a box. We give the box a name or label so that we can find it and refer to it when we need it. However, this is no ordinary box, it can stretch to hold anything from a single number or letter, to a sentence, a list of values or even an entire application spanning hundreds or even thousands or lines of code! In this instance we called our box 'name' and it contained a single word - your name.

A quick note on 'white space' and comments

White space is all of the spaces and gaps in your code and they are ignored by Python. We wrote name = "Simon" but we could equally have written name="Simon" and Python would read both of these the same. Code is written using certain conventions which make it more human readable and allow others to more easily see and understand our code.

Comments are denoted by a '#' symbol and anything written after this symbol for the remainder of the line is ignored by Python. Comments allow us to make notes in our code as a reminder to ourselves or to help explain what that part of the code is doing to anyone who reads it.

Our code:

# This is a comment - Python ignores this, it's just for us

name = "Simon" # Everything after the '#' is a comment

What Python sees:

name="Simon"

Variables are one of the key building blocks we use when writing code. A simplified way of looking at a computer program would be to say that we are 'doing things with variables to produce some kind of result'.

So, we created this name variable and it contains your name. So where did it go? Python looked at this variable and has stored it in memory. For as long as your IDLE application is open on your device this variable will exist. When the application is closed everything held in that part of the memory will be lost. We can of course store data more permanently but that is a subject for another day. How can we check to see if Python has stored our name variable? Go back to IDLE and simply type the name of the variable - name and press Enter. There is our name displayed on the screen! Python recognises the name of the variable and shows us the contents of the box.

What if we now wanted to give name a different value? Easy, we simply assign a new value with the '=' sign name = "new name" and press Enter. If we now type name and press Enter, we will see the new value has replaced the old value. Another way of showing the contents of our variables is to use print(). We will get into exactly what print() is later but for now just know that it will print to the screen (not your paper printer) whatever we place inside the brackets. For example:

Putting it all together

We now know what a variable is and how to create them, but what can we do with them? Variables aren't too exciting on their own, but what we can do with them is much more interesting. In the next part of the series I will introduce you to some of the things we can put into variables other than words as well as some ways we can interact with them. Until then, keep playing with IDLE (you can't break anything!). Try using print() to display different variable names.

Want a challenge? See if you can learn how to display multiple variables on the same line. Bonus points for figuring out how to put a space between the names).

genus = "Pinus" # Declare these variables
species = "sylvestris"
print(#write your code here between the brackets)
# Output
Pinus sylvestris

Conclusion - the first step on the journey

"The cool thing about being famous is travelling. I have always wanted to travel across seas, like to Canada and stuff." - Britney Spears

In this first part of this series of articles, I wanted to write about a very important aspect of learning to code - why do it? Nearly all learning endeavours are destined to fail if we are not motivated to learn. Coding like most things is very difficult to learn if you are not interested in the subject matter. My aim with this series is simply to open your eyes to the possibilities and hopefully spark your imagination as to what can be accomplished. To this end I encourage you to look around, search online for 'python projects' and see the types of projects people are making and then think how you could use similar projects for your own work or studies. There are many great teaching resources out there and you would do well to try a few to see which one works best for you. In the meantime, thank you for reading and I look forward to seeing you in part two.

Simon