Program Parts

As you’ve seen, there aren’t many required parts for a Python program. Most programing languages require you to create, at the very least, a main function of some sort. For the Arduino it is the loop() function. In C++, it is main(). Python does not have that. It jumps right into executing whatever commands it finds as it steps through the file. However, this does not mean that it’s entirely linear. I discuss functions and classes later in the workshop, but just know that the interpreter scans through the file and builds whatever functions and classes it finds before executing the other commands. This is one of the things that make Python so easy to learn. It simply doesn’t have quite as rigid of framework as you would find in most other languages.

Oh, and for you programming language purists, Python walks the line between a scripting language, where everything is executed through the interpreter, and a programming language . Some of the code is compiled into executables like C and C++. In fact, as we start to build modules, this is exactly what happens. However, in this book, we usually run it through the interpreter.

Indentation

As we work through the workshop, our programs become more complex. In particular, we’re going to start working with code blocks, which are commands that are grouped together to execute in a function or a loop, or as part of a condition. This kind of structure is critical to writing effective programs.

All programming languages have syntax for formatting code blocks. C-based languages, including Java, use curly brackets {} to contain a code block. Python does not do this. Python uses indentation. Blocks of code are indented to indicate that they are a related block. If a line in a block is not properly indented, you’ll get an error. This is one of the key reasons that we use IDLE. It automatically manages indentations . That doesn’t mean that you, as a user, can’t botch the program; it just means this type of error is greatly reduced.

As we progress through the workshop, you’ll see the importance of indentation. In the meantime, just know it’s important.

Finally, I want to make a brief note about indentation and editors. Text editors use different forms of indentation . Some use tab characters while others use two or four spaces. You are not able to see what is being used because these are invisible characters. This causes no end of frustration when you move from one editor to another. The better editors allow you to choose how you want the tab key to work (with a tab character or with a number of spaces, usually four). By default, IDLE uses four spaces.

Comments

Commenting code has become more important over time. It is an area where programmers are notoriously deficient. They use comments , but they are frequently cryptic or make assumptions about knowledge of the program that may not hold true for someone who picks up the code later. This would be less of an issue if they were any better about other forms of documentation. But, alas, they are not.

My lamentations aside, commenting is important, especially as you’re learning. So, get into the habit of using comments. Use them to explain what you’re doing or to enter small notes regarding logic.

A comment in Python is any line that begins with #. Python ignores everything following the # to the end of the line; for example:

In the preceding code, I added two comment lines to our hello_world.py program . I also added a blank line to help make the code a little easier to read. If you were to save and run this program, you would get exactly the same output that you did before.

You can also create a comment block using triple quotation marks, """. The Python compiler ignores any code between sets of these marks. You open and close the block with them. This allows you to write as much information as you’d like over multiple lines. This notation is frequently used for title blocks at the beginning of a file.

It is a good habit to simply outline your code with comments before you write it. Before you start writing, think about what you need your code to do and how you will go about doing it. Create a flow chart or simply write down the steps that you will take to accomplish your goal. Then translate this into a series of comments in your file before you write any actual code. This helps you structure the problem in your mind and improves your overall flow. If you identify a step that you are repeating, you likely have a candidate for a function. If you find that you are referencing a structured concept (like robot) that you want to imbue with special properties and functionality, you’ve got a class. Later, I discuss functions and classes in further detail.

Strings

A string is a collection of one or more characters contained within quotes. Quotes are how you indicate a string. For instance, “100” is a string; 100 is a number (an integer to be more accurate). You can use double or single quotation marks (just remember what you used). You can nest one type of quotes within another, but you will get an error, or worse, unexpected results, if you cross your quotes.

Here’s an example of double quotes:

Here’s an example of single quotes:

Here’s an example of single quotes inside double quotes:

Here’s an example of double quotes inside single quotes:

Triple quotes are used to span multiple lines within a string .

Here’s an example of triple quotes:

You can use single quotes as apostrophes if you escape them first. Escaping a character simply means you are telling the interpreter to view a character as a string character rather than a functional one.

Here’s an example of escaping quotes:

You can do this to the entire string by making it a raw string. In this next example, '/n' is used to move to a new line.

Here’s an example of a raw string:

Numbers

Numbers in Python come in a few flavors, the most common of which are integers and floats. An integer is a whole number , whereas a float is a decimal. Python also uses a Boolean type that has a value of one or zero. These are frequently used as a flag or state, where one means “on” and zero means “off.” A Boolean is a subclass of integers and are treated as integers when performing operations.

As you might expect, you can perform mathematical operations with number types. Generally, if you perform arithmetic with one type, the result is that type. Math using integers usually results in an integer. However, if you perform division with integers, the result is a float. Math with floats result in a float. If you perform arithmetic with both types, the result is a float.

Adding two integers results in an integer.

Adding two floats result in a float.

Adding a float and an integer results in a float.

Subtraction and multiplication work the same way.

Division always results in a float.

The ** operator results in the first number raised to the power of the second.

There is one catch with Python floats, however. The interpreter sometimes produces a seemingly arbitrary number of decimal places. This has to do with how floating-point notation is stored in Python and how math is done within the interpreter .

For more information about this anomaly, go to https://docs.python.org/3/tutorial/floatingpoint.html .

Lists

A list is a collection of items in a particular order. In other languages, they are generally known as arrays . You can put anything you want in a list. The values stored in a list don’t have to be of the same data type. However, if you mix data types in a list, make sure that you know which type you are getting when you use it.

You worked with lists when you worked with strings. A string is essentially a list of characters. As such, indexing and slicing work with lists, as well.

A list is created using square brackets [].

Like strings, lists are zero indexed. This means the first element in a list is at position 0, the second is at position 1, and so forth. You can access the individual elements of a list by calling its index or location within the list.

Lists can also be sliced. When a list is sliced, the result is a new list containing the subset of the original list.

It is easy to add, change, and remove members of a list using slicing and concatenation.

This example adds members to a list.

This example changes members in a list.

This example removes the members of a list.

Assign list members to variables:

There are a number of methods automatically included in lists. For example, you can force the first letter of a name to be capitalized.

As I mentioned, a list can contain any type of data , including other lists. In fact, when we start working with computer vision, we will frequently use lists of lists to hold image data.

Lists are a very powerful and important aspect of Python. Visit https://docs.python.org/3/tutorial/introduction.html#lists to spend some time exploring lists.

Tuples

You’re going to hear the term tuple a lot when working with Python. A tuple is simply a special kind of list that cannot be changed. Think of a tuple as a list of constants, or a constant list. You declare a tuple using parentheses rather than square brackets.

Tuples are immutable, which means that once a tuple has been created, it cannot be changed. To change the contents of a tuple, a new tuple must be created. This is done using the same slicing techniques we used for strings and lists.

Note that we used list notation when slicing the tuple, colors[0:2] rather than colors(0:2). The result of the slice is still a tuple.

A tuple , however, can be replaced.

They can also be replaced with an empty tuple.

Dictionaries

A dictionary is similar to a list except that it allows you to name your items in the list. This is done using key/value pairs. The key becomes the index for the value. This allows you to add some meaningful structure to your lists. They are useful for holding a list of parameters or properties.

A dictionary is declared using curly brackets rather than square brackets.

You work with dictionaries in much the same way as you would an array. Except rather than providing an index number, you provide the key to access an element.

Of course, a dictionary wouldn’t be all that useful if you weren’t able to update and manipulate the values contained within. Making changes to a dictionary is similar to making changes to a list. The only real difference is that you use the key rather than the position to access the various elements.

To update a value , use the key to reference the value to be changed.

A key/value pair can be removed with the del statement.

A dictionary can be copied with the copy method of the dictionary class. To access the copy method, start with the name of the dictionary and add .copy() to the end.

To append one dictionary to the end of another, use the update method.

None Type

There is a special data type that is very important when working with classes and objects imported from other sources. This is the none type , which is an empty placeholder. It is used when we want to declare an object but define it later. It is also used to empty an object. You will see the none type in action later in this chapter, when we discuss classes. In the meantime, know that it exists and that it is essentially an empty placeholder.

if Statements

The if statement allows you to test for a condition before you execute a block of code. The condition can be any value or equation that evaluates to either true or false.

This next piece of code loops through the robots list and determines whether the robot is Nomad.

Again, note the indentation as you type. IDLE indents another level after each line that ends in a colon, which should be every line that denotes a new block, such as loop statements and conditionals.

It’s important to also note how we test for equality. A single equals sign means assignment. Double equals signs tell the interpreter to compare for equality.

You can also use and and or to test for multiple conditions .

Comparisons are also frequently used to determine if an object exists or contains a value. Essentially, a condition evaluates to true if it does not evaluate to false, 0, or none. This is very handy when you want to execute a piece of code only if an object exists, such as when you initialize sensors or connections through a serial port or network.

Loops

When you work with robotics, there are times that you want to repeat a block of code. Whether to perform a set of instructions on a collection of objects, or to execute a block of code for long as a condition exists, you need to use a loop.

Loops allow you to repeat a block of code to perform the tasks multiple times. There are two flavors of loops: the for loop and the while loop. Each provides a specific functionality that is crucial to writing efficient programs.

Defining a Function

To define your own function , you create the name of the function and a block of code that contains the operations you want to perform. The definition starts with the def keyword, followed by the name of the function, parentheses, and a colon.

Let’s create a simple function:

In this code, we created a simple function that simply prints the message “Hello World”. Now, whenever we want to print that message, we simply call that function.

To make things a little more interesting, we can provide the function with data to use. These are called arguments .

Passing Arguments

Frequently, we want to give information to the function to work with or on. To provide the information, we give the function one or more variables in which to store this information, called arguments.

Let’s create a new function that greets the user.

Here we created a new function called hello_user. We told it to expect to receive two pieces of information: the user’s first name and last name. The variable names in the function definition contain the data we want to use. The function simply prints the greeting using the two arguments that we provide.

Default Values

You can create a default value for an argument by simply assigning a value as you declare the function.

Note that the second time we called the function, we did not include a value. So, the function simply used the default value we assigned when we created the function.

Return Values

Sometimes we don’t just want the function to do something on its own. Sometimes we want it to give a value back to us. This is helpful to move a common calculation to a function, or if we want the function to validate that it ran correctly. Many built-in functions and those from external libraries return a 1 if the function succeeded and 0 if it failed.

To return a value , simply use the return keyword followed by the value or variable that you want to return. Keep in mind that return exits the function and provides the value to the line that called the function. So, make sure that you don’t do anything after the return statement .

A return statement can return more than one value. To return more than one value, separate each one with a comma. The function puts the values into a tuple that can be parsed by the calling code.

Importing and Using Modules

Importing modules is easy. As you’ve seen, you simply use the import keyword followed by the name of the module. This loads all the functions of that module for your use. Now, to use one of the functions from the module, you need to enter the module name followed by the function.

Some packages are very large, and you may not want to import the entire thing. If you know the specific function you need in your program, you can import only that part of the module.

This imports the sqrt function from the math module. If you import just the function, you will not need to prefix the function with the module name.

Lastly, you can provide an alias for the modules and functions that you import. This becomes very handy when you import a module with a fairly long name. In this example, I’m just being lazy:

Built-in Modules

The core Python libraries provide a lot of functionality for basic programs. However, there is a lot more functionality available, written by other developers and researchers. But before we go off into the wonderful world of third-party modules, let’s look at what comes with Python.

Open an IDLE instance and type the following:

You should get output that looks something like this:

This is a list of the modules that are built into Python and are available for use right now.

To get more information about a module, you can use the help() function . It lists all the modules currently installed and registered with Python. (Note that I had to truncate the list for printing.)

You can also use the help() function to get information on a specific module. First, you need to import the module. Again, the following listing was truncated for brevity.

You can learn a lot more about these built-in modules on the Python documentation site at https://docs.python.org/3/py-modindex.html .

Extended Modules

In addition to the built-in modules that you get with every Python installation, there are countless extensions that you can add called packages. Fortunately, the good folks at Python have provided a method to learn about third-party packages. Visit https://pypi.python.org/pypi for more information.

Once that is done, you’re ready to use PIP . Keep in mind that you’ll run PIP from the terminal, not from within the Python shell.

For this demonstration, we’ll install a package used for plotting mathematical formulas. matplotlib is a very popular package for visualizing data using Python. The actual use of this package is outside the scope of this workshop. For more information on using matplotlib, check out their website at https://matplotlib.org .

To install a new package, type

This installs the matplotlib library for your use.

Custom Modules

If you have several functions that you use all the time (generally referred to as helper functions), you might save them in a file called myHelperFunctions.py. You can then use the import command to make these functions available in another program.

Generally speaking, you save your custom module file to be imported in the same file location as the program that you are working on. This is the easiest and best way to make sure that the compiler can find the file. It is possible to save the file elsewhere, but then you either include the full path for the file or make changes to the system path variables. For now, keep any module files that you create in your working directory (the same location as the program that you are working on). This helps you avoid any additional heartache.

In the shell window , you should see this:

Creating a Class

Before you delve in and start writing code, I suggest you take a little time to plan what you’re about to build. This doesn’t need to be an extensive plan that flushes out every detail, but it is good to have at least a rough outline of what you’re going to build before you build it.

Blank Lines

Leaving blank lines between code blocks for logical, visual separation is just a good idea. It makes your code easier to read.

Commenting

Write comments in your code . Do it frequently and be verbose. When you come back to read your code later (for debugging or to reuse it for another project), you will want to know what you were thinking when the code was written, and what you were trying to do with it.

If your code ever makes it out into the wild, where other people read or review it, they will need the comments, too. Python is a community, and code is shared frequently. Well-commented and described code is greatly appreciated.

Naming Conventions

How you name your variables, functions, and classes is a personal decision. Do what is most comfortable for you. Python is a case-sensitive language. Using a capital letter in one place and not another creates two different variables and endless hours of frustration.

Common variable names are not addressed in the style guide, although the convention is to use mixed-case naming. Mixed-case names start with a lowercase character, but each word in the name is capitalized; for example, myRobots.

Functions and modules should be lowercase. To make them easier to read, use underscores between words. So our hello world function is named hello_world.

Classes should be named using CapWords. As the name implies, CapWords capitalizes the first letter of every word, including the first character in the name. This style is more commonly known as camel case .

Finally, lists and other collections should be pluralized. This is an indicator that the variable represents more than one object. For instance, robots is a list of robots. If we were addressing an individual item in the list, it would look something like this: