Code Blocks

The first thing you should learn is that Python does not use a code block demarcated with symbols like other languages. More specifically, code that is local to a construct such as a function or conditional or loop is designated using indentation. Thus, the lines below are indented (by spaces or, gag, tabs) so that the starting characters align for the code body of the construct.

if (expr1):
    print("inside expr1")
    print("still inside expr1")
else:
    print("inside else")
    print("still inside else")
print("in outer level")

Here we see a conditional or if statement. Notice the function call print() is indented. This signals the interpreter that the lines belong to the construct above it. For example, the two print statements that mention expr1 form the code block for the if condition (and executes when the expression evaluates to true). Similarly, the next two print statements form the code block for the else condition. Finally, the non-indented lines are not part of the conditional and thus are executed after either the if or else depending on the expression evaluation.

As you can see, indentation is a key concept to learn when writing Python. Even though it is very simple, making mistakes in indentation can result in code executing that you did not expect or worse errors from the interpreter.

There is one special symbol that you will encounter frequently. Notice the use of the colon (:) in the code above. This symbol is used to terminate a construct and signals the interpreter that the declaration is complete and the body of the code block follows. We use this for conditionals, loops, classes, and functions.

Comments

One of the most fundamental concepts in any programming language is the ability to annotate your source code with non-executable text that not only allows you to make notes among the lines of code but also forms a way to document your source code.

To add comments to your source code, use the pound sign (#). Place at least one at the start of the line to create a comment for that line, repeating the # symbols for each subsequent line. This creates what is known as a block comment as shown. Notice I used a comment without any text to create whitespace. This helps with readability and is a common practice for block comments.

#
# MicroPython for the IOT
#
# Example Python application.
#
# Created by Dr. Charles Bell
#

You can also place comments on the same line as the source code. The compiler will ignore anything from the pound sign to the end of the line. For example, the following shows a common style of documenting variables.

zip = 35012                # Zip or postal code
address1= "123 Main St."  # Store the street address

Arithmetic

You can perform many mathematical operations in Python including the usual primitives but also logical operations and operations used to compare values. Rather than discuss these in detail, I provide a quick reference in Table 4-1 that shows the operation and example of how to use the operation.

Bitwise operations produce a result on the values performed on each bit. Logical operators (and, or) produce a value that is either true or false and are often used with expressions or conditions.

Output to Screen

We’ve already seen a few examples of how to print messages to the screen but without any explanation about the statements shown. While it is unlikely that you would print output from your MicroPython board for projects that you deploy, learning Python is much easier when you can display messages to the screen.

Some of the things you may want to print – as we have seen in previous examples – is to communicate what is going on inside your program. This can include simple messages (strings), but can also include the values of variables, expressions, and more.

As we have seen, the built-in print() function is the most common way to display output text contained within single or double quotes. We have also seen some interesting examples using another function named format(). The format() function generates a string for each argument passed. These arguments can be other strings, expressions, variables, etc. The function is used with a special string that contains replacement keys delimited by curly braces { } (called string interpolation ¹ ). Each replacement key contains either an index (starting at 0) or a named keyword. The special string is called a format string. Let’s see a few examples to illustrate the concept. You can run these yourself either on your PC or your MicroPython board. I include the output so you can see what each statement does.

>>> a = 42
>>> b = 1.5
>>> c = "seventy"
>>> print("{0} {1} {2} {3}".format(a,b,c,(2+3)))
42 1.5 seventy 5
>>> print("{a_var} {b_var} {c_var} {0}".format((3*3),c_var=c,b_var=b,a_var=a))
42 1.5 seventy 9

Notice I created three variables (we will talk about variables in the next section) assigning them different values with the equal symbol (=). I then printed a message using a format string with four replacement keys labeled using an index. Notice the output of that print statement. Notice I included an expression at the end to show how the format() function evaluates expressions.

The last line is more interesting. Here, I use three named parameters (a_var, b_var, c_var) and used a special argument option in the format() function where I assign the parameter a value. Notice I listed them in a different order. This is the greatest advantage of using named parameters; they can appear in any order but are placed in the format string in the position indicated.

As you can see, it’s just a case of replacing the { } keys with those from the format() function, which converts the arguments to strings. We use this technique anywhere we need a string that contains data gathered from more than one area or type. We can see this in the examples above.

Now let’s look at how we can use variables in our programs (scripts).

Variables

Python is a dynamically typed language, which means the type of the variable (the type of data it can store) is determined by context as it is encountered or used. This contrasts with other language such as C and C++ where you must declare the type before you use the variable.

Variables in Python are simply named memory locations that you can use to store values during execution. We store values by using the equal sign to assign the value. Python variable names can be anything you want, but there are rules and conventions most Python most developers follow. The rules are listed in the Python coding standard.²

However, the general, overriding rule requires variable names that are descriptive, have meaning in context, and can be easily read. That is, you should avoid names with random characters, forced abbreviations, acronyms, and similar obscure names. By convention, your variable names should be longer than a single character (with some acceptable exceptions for loop counting variables) and short enough to avoid overly long code lines.

Thus, there is a lot of flexibility in what you can name your variables. There are additional rules and guidelines in the PEP8 standard and should you wish to bring your project source code up to date with the standards, you should review the PEP8 naming standards for functions, classes, and more. See the PEP8 coding guidelines for Python coding at https://www.python.org/dev/peps/pep-0008 for a complete list of the rules and standards.

The following shows some examples of simple variables and their dynamically determined types.

# floating point number
length = 10.0
# integer
width = 4
# string
box_label = "Tools"
# list
car_makers = ['Ford', 'Chevrolet', 'Dodge']
# tuple
porsche_cars = ('911', 'Cayman', 'Boxster')
# dictionary
address = {"name": "Joe Smith", "Street": "123 Main", "City": "Anytown", "State": "New Happyville"}

So, how did we know the variable width is an integer? Simply because the number 4 is an integer. Likewise, Python will interpret “Tools” as a string . We’ll see more about the last three types and other types supported by Python in the next section.

Types

As mentioned, Python does not have a formal type specification mechanism like other languages. However, you can still define variables to store anything you want. In fact, Python permits you to create and use variables based on context and you can use initialization to “set” the data type for the variable. The following shows several examples.

# Numbers
float_value = 9.75
integer_value = 5

# Strings
my_string = "He says, he's already got one."

print("Floating number: {0}".format(float_value))
print("Integer number: {0}".format(integer_value))
print(my_string)

For situations where you need to convert types or want to be sure values are typed a certain way, there are many functions for converting data. Table 4-2 shows a few of the more commonly used type conversion functions. I discuss some of the data structures in a later section.

However, you should use these conversion functions with care to avoid data loss or rounding. For example, converting a float to an integer can result in truncation. Likewise, printing floating-point numbers can result in rounding.

Now let’s look at some commonly used data structures including this strange thing called a dictionary.

Lists

Lists are a way to organize data in Python. It is a free-form way to build a collection. That is, the items (or elements) need not be the same data type. Lists also allow you to do some interesting operations such as adding things at the end, beginning, or at a special index. The following demonstrates how to create a list.

# List
my_list = ["abacab", 575, "rex, the wonder dog", 24, 5, 6]
my_list.append("end")
my_list.insert(0,"begin")
for item in my_list:
  print("{0}".format(item))

Here we see I created the list using square brackets ([]). The items in the list definition are separated by commas. Note that you can create an empty list simply by setting a variable equal to []. Since lists, like other data structures, are objects, there are several operations available for lists such as the following.

• append(x): add x to the end of the list

• extend(l): add all items to the end of the list

• insert(pos,item): insert item at a position pos

• remove(value): remove the first item that matches (==) the value

• pop([i]): remove and return the item at position i or end of list

• index(value): return index of first item that matches

• count(value): count occurrences of value

• sort(): sort the list (ascending)

• reverse(): reverse sort the list

Lists are like arrays in other languages and very useful for building dynamic collections of data.

Tuples

Tuples , on the other hand, are a more restrictive type of collection. That is, they are built from a specific set of data and do not allow manipulation like a list. In fact, you cannot change the elements in the tuple. Thus, we can use tuples for data that should not change. The following shows an example of a tuple and how to use it.

# Tuple
my_tuple = (0,1,2,3,4,5,6,7,8,"nine")
for item in my_tuple:
  print("{0}".format(item))
if 7 in my_tuple:
  print("7 is in the list")

Here we see I created the tuple using parenthesis (). The items in the tuple definition are separated by commas. Note that you can create an empty tuple simply by setting a variable equal to (). Since tuples, like other data structures, are objects, there are several operations available such as the following, including operations for sequences such as inclusion, location, etc.

• x in t: determine if t contains x

• x not in t: determine if t does not contain x

• s + t: concatenate tuples

• s[i]: get element i

• len(t): length of t (number of elements)

• min(t): minimal (smallest value)

• max(t): maximal (largest value)

If you want even more structure with storing data in memory, you can use a special construct (object) called a dictionary.

Dictionaries

A dictionary is a data structure that allows you to store key, value pairs where the data is assessed via the keys. Dictionaries are a very structured way of working with data and the most logical form we will want to use when collecting complex data. The following shows an example of a dictionary.

# Dictionary
my_dictionary = {
  'first_name': "Chuck",
  'last_name': "Bell",
  'age': 36,
  'my_ip': (192,168,1,225),
  42: “What is the meaning of life?”,
}
# Access the keys:
print(my_dictionary.keys())
# Access the items (key, value) pairs
print(my_dictionary.items())
# Access the values
print(my_dictionary.values())
# Create a list of dictionaries
my_addresses = [my_dictionary]

There is a lot going on here! We see a basic dictionary declaration that uses curly braces to create a dictionary . Inside that, we can create as many key, value pairs we want separated by commas. Keys are defined using strings (I use single quotes by convention but double quotes will work) or integers, and values can be any data type we want. For the my_ip attribute, we are also storing a tuple.

Following the dictionary, we see several operations performed on the dictionary from printing the keys, printing all the values, and printing only the values. The following shows the output of executing this code snippet from the Python interpreter.

[42, 'first_name', 'last_name', 'age', 'my_ip']
[(42, 'what is the meaning of life?'), ('first_name', 'Chuck'), ('last_name', 'Bell'), ('age', 36), ('my_ip', (192, 168, 1, 225))]
['what is the meaning of life?', 'Chuck', 'Bell', 36, (192, 168, 1, 225)]
'42': what is the meaning of life?
'first_name': Chuck
'last_name': Bell
'age': 36
'my_ip': (192, 168, 1, 225)

As we have seen in this example, there are several operations (functions or methods) available for dictionaries including the following. Together this list of operations makes dictionaries a very powerful programming tool.

• len(d): number of items in d

• d[k]: item of d with key k

• d[k] = x: assign key k with value x

• del d[k]: delete item with key k

• k in d: determine if d has an item with key k

• d.items(): return a list (view) of the (key, value) pairs in d

• d.keys(): return a list (view) of the keys in d

• d.values(): return a list (view) of the values in d

Best of all, objects can be placed inside other objects. For example, you can create a list of dictionaries like I did above, a dictionary that contains lists and tuples, and any combination you need. Thus, lists, tuples, and dictionaries are a powerful way to manage data for your program.

In the next section, we learn how we can control the flow of our programs.

Conditional Statements

We have also seen some simple conditional statements: statements designed to alter the flow of execution depending on the evaluation of one or more expressions. Conditional statements allow us to direct execution of our programs to sections (blocks) of code based on the evaluation of one or more expressions. The conditional statement in Python is the if statement.

We have seen the if statement in action in our example code. Notice in the example, we can have one or more (optional) else phrases that we execute once the expression for the if conditions evaluate to false. We can chain if / else statements to encompass multiple conditions where the code executed depends on the evaluation of several conditions. The following shows the general structure of the if statement. Notice in the comments how I explain how execution reaches the body of each condition.

if (expr1):
    # execute only if expr1 is true
elif ((expr2) or (expr3)):
    # execute only if expr1 is false *and* either expr2 or expr3 is true
else:
    # execute if both sets of if conditions evaluate to false

While you can chain the statement as much as you want, use some care here because the more elif sections you have, the harder it will become to understand, maintain, and avoid logic errors in your expressions.

There is another form of conditional statement called a ternary operator. Ternary operators are more commonly known as conditional expressions in Python. These operators evaluate something based on a condition being true or not. They became a part of Python in version 2.4. Conditional expressions are a shorthand notation for an if-then-else construct used (typically) in an assignment statement as shown below.

variable = value_if_true if condition else value_if_false

Here we see if the condition is evaluated to true, the value preceding the if is used but if the condition evaluates to false, the value following the else is used. The following shows a short example.

>>> numbers = [1,2,3,4]
>>> for n in numbers:
...   x = 'odd' if n % 2 else 'even'
...   print("{0} is {1}.".format(n, x))
...
1 is odd.
2 is even.
3 is odd.
4 is even.
>>>

Conditional expressions allow you to quickly test a condition instead of a using a multiline conditional statement, which can help make your code a bit easier to read (and shorter).

Loops

Loops are used to control the repetitive execution of a block of code. There are three forms of loops that have slightly different behaviors. All loops use conditional statements to determine whether to repeat execution or not. That is, they repeat as long as the condition is true. The two types of loops are while and for. I explain each with an example.

The while loop has its condition at the “top” or start of the block of code. Thus, while loops only execute the body if and only if the condition evaluates to true on the first pass. The following illustrates the syntax for a while loop. This form of loop is best used when you need to execute code only if some expression(s) evaluate to true. For example, iterating through a collection of things whose number of elements is unknown (loop until we run out of things in the collection).

while (expression):
   # do something here

For loops are sometimes called counting loops because of their unique form. For loops allow you to define a counting variable and a range or list to iterate over. The following illustrates the structure of the for loop. This form of loop is best used for performing an operation in a collection. In this case, Python will automatically place each item in the collection in the variable for each pass of the loop until no more items are available.

for variable_name in list:
  # do something here

You can also do range loops or counting loops. This uses a special function called range() that takes up to three parameters, range([start], stop[, step]), where start is the starting number (an integer), stop is the last number in the series, and step is the increment. So, you can count by 1, 2, 3, etc., through a range of numbers. The following shows a simple example.

for i in range(2,9):
   # do something here

There are other uses for range() that you may encounter. See the documentation on this function and other built-in functions at https://docs.python.org/3/library/functions.html for more information.

Python also provides a mechanism for controlling the flow of the loop (e.g., duration or termination) using a few special keywords as follows.

• break: exit the loop body immediately

• continue: skip to next iteration of the loop

• else: execute code when loop ends (not executed if the loop was stopped with a break statement)

There are some uses for these keywords, particularly break, but it is not the preferred method of terminating and controlling loops. That is, professionals believe the conditional expression or error handling code should behave well enough to not need these options.

Including Modules

Python applications can be built from reusable libraries that are provided by the Python environment. They can also be built from custom modules or libraries that you create yourself or download from a third party. These are often distributed as a set of Python code files (for example, files that have a file extension of .py). When we want to use a library (function, class, etc.) that is included in a module, we use the import keyword and list the name of the module. The following shows some examples.

import os
import sys

The first two lines demonstrate how to import a base or common module provided by Python. In this case, we are using or importing modules for the os and sys modules (operating system and Python system functions).

Functions

Python allows you to use modularization in your code. While it supports object-oriented programming by way of classes (a more advanced feature that you are unlikely to encounter for most Python GPIO examples), on a more fundamental level you can break your code into smaller chunks using functions.

Functions use a special keyword construct (rare in Python) to define a function. We simply use def followed by a name for the function and a comma-separated list of parameters in parentheses. The colon is used to terminate the declaration. The following shows an example.

def print_dictionary(the_dictionary):
    for key, value in the_dictionary.items():
      print("'{0}': {1}".format(key, value))

# define some data
my_dictionary = {
  'name': "Chuck",
  ‘age’: 37,
}

You may be wondering what this strange code does. Notice the loop is assigning two values from the result of the items() function. This is a special function available from the dictionary object.³ The items() function returns the key, value pairs: hence the names of the variables.

The next line prints out the values. The use of formatting strings where the curly braces define the parameter number starting at 0 is common for Python 3 applications. See the Python documentation for more information about formatting strings ( https://docs.python.org/3/library/string.html#format-string-syntax ).

The body of the function is indented. All statements indented under this function declaration belong to the function and are executed when the function is called. We can call functions by name providing any parameters as follows. Notice how I referenced the values in the dictionary by using the key names.

print_dictionary(my_dictionary)
print(my_dictionary['age'])
print(my_dictionary['name'])

This example together with the code above, when executed, generates the following.

$ python3
Python 3.6.0 (v3.6.0:41df79263a11, Dec 22 2016, 17:23:13)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> def print_dictionary(the_dictionary):
...     for key, value in the_dictionary.items():
...       print("'{0}': {1}".format(key, value))
...
>>> # define some data
... my_dictionary = {
...     'name': "Chuck",
...     'age': 41,
... }
>>> print_dictionary(my_dictionary)
'name': Chuck
'age': 41
>>> print(my_dictionary['age'])
41
>>> print(my_dictionary['name'])
Chuck

Now let’s look at the most complex concept in Python – object-oriented programming.

Classes and Objects

You may have heard that Python is an object-oriented programming language . But what does that mean? Simply, Python is a programming language that provides facilities for describing objects (things) and what you can do with the object (operations). Objects are an advanced form of data abstraction where the data is hidden from the caller and only manipulated by the operations (methods) the object provides.

The syntax we use in Python is the class statement, which you can use to help make your projects modular. By modular, we mean the source code is arranged to make it easier to develop and maintain. Typically, we place classes in separate modules (code files), which helps organize the code better. While it is not required, I recommend using this technique of placing a class in its own source file. This makes modifying the class or fixing problems (bugs) easier.

So, what are Python classes? Let’s begin by considering the construct as an organization technique. We can use the class to group data and methods together. The name of the class immediately follows the keyword class followed by a colon. You declare other class methods like any other method except the first argument must be self, which ties the method to the class instance when executed.

Accessing the data is done using one or more methods by using the class (creating an instance) and using dot notation to reference the data member or function. Let’s look at an example. Listing 4-1 shows a complete class that describes (models) the most basic characteristics of a vehicle used for transportation. I created a file named vehicle.py to contain this code.

Listing 4-1. Vehicle class

#
# MicroPython for the IOT
#
# Class Example: A generic vehicle
#
# Dr. Charles Bell
#
class Vehicle:
    """Base class for defining vehicles"""
    axles = 0
    doors = 0
    occupants = 0

    def __init__(self, num_axles, num_doors):
        self.axles = num_axles
        self.doors = num_doors

    def get_axles(self):
        return self.axles

    def get_doors(self):
        return self.doors

    def add_occupant(self):
        self.occupants += 1

    def num_occupants(self):
        return self.occupants

Notice a couple of things here. First, there is a method with the name __init__() . This is the constructor and is called when the class instance is created. You place all your initialization code like setting variables in this method. We also have methods for returning the number of axles, doors, and occupants. We have one method in this class: to add occupants.

Also notice we address each of the class attributes (data) using self.<name>. This is how we can ensure we always access the data that is associated with the instance created and not a global variable or other local variable.

Let’s see how this class can be used to define a family sedan. Listing 4-2 shows code that uses this class. We can place this code in a file named sedan.py.

Listing 4-2. Using the Vehicle class

#
# MicroPython for the IOT
#
# Class Example: Using the generic Vehicle class
#
# Dr. Charles Bell
#
from vehicle import Vehicle

sedan = Vehicle(2, 4)
sedan.add_occupant()
sedan.add_occupant()
sedan.add_occupant()
print("The car has {0} occupants.".format(sedan.num_occupants()))

Notice the first line imports the Vehicle class from the vehicle module. Notice I capitalized the class name but not the file name. This is a very common naming scheme. Next in the code, we create an instance of the class. Notice I passed in 2, 4 to the class name. This will cause the __init__() method to be called when the class is instantiated. The variable, sedan, becomes the class instance variable (object) that we can manipulate, and I do so by adding three occupants then printing out the number of occupants using the method in the Vehicle class.

We can run the code on our PC using the following command. As we can see, it tells us there are three occupants in the vehicle when the code is run. Nice.

$ python ./sedan.py
The car has 3 occupants.

Now, let’s see how we can use the vehicle class to demonstrate inheritance. In this case, we will create a new class named PickupTruck that uses the vehicle class but adds specialization to the resulting class . Listing 4-3 shows the new class. I placed this code in a file named pickup_truck.py. As you will see, a pickup truck is a type of vehicle.

Listing 4-3. Pickup Truck class

#
# MicroPython for the IOT
#
# Class Example: Inheriting the Vehicle class to form a
# model of a pickup truck with maximum occupants and maximum
# payload.
#
# Dr. Charles Bell
#
from vehicle import Vehicle

class PickupTruck(Vehicle):
    """This is a pickup truck that has:
    axles = 2,
    doors = 2,
    __max occupants = 3
    The maximum payload is set on instantiation.
    """
    occupants = 0
    payload = 0
    max_payload = 0

    def __init__(self, max_weight):
        super().__init__(2,2)
        self.max_payload = max_weight
        self.__max_occupants = 3

    def add_occupant(self):
        if (self.occupants < self.__max_occupants):
            super().add_occupant()
        else:
            print("Sorry, only 3 occupants are permitted in the truck.")

    def add_payload(self, num_pounds):
        if ((self.payload + num_pounds) < self.max_payload):
            self.payload += num_pounds
        else:
            print("Overloaded!")

    def remove_payload(self, num_pounds):
        if ((self.payload - num_pounds) >= 0):
            self.payload -= num_pounds
        else:
            print("Nothing in the truck.")

    def get_payload(self):
        return self.payload

Notice a few things here. First, notice the class statement: class PickupTruck(Vehicle) :. When we want to inherit from another class, we add the parentheses with the name of the base class. This ensures Python will use the base class allowing the derived class to use all its accessible data and memory. If you want to inherit from more than one class, you can (called multiple inheritance), just list the base (parent) classes with a comma-separated list.

Next, notice the __max_occupants variable. Using two underscores in a class for an attribute or a method makes that, through convention, the item private to the class.⁴ That is, it should only be accessed from within the class. No caller of the class (via a class variable/instance) can access the private items nor can any class derived from the class. It is always a good practice to hide the attributes (data).

You may be wondering what happened to the occupant methods. Why aren’t they in the new class? They aren’t there because our new class inherited all that behavior from the base class . Not only that, but the code has been modified to limit occupants to exactly three occupants.

I also want to point out the documentation I added to the class. We use documentation strings (strings that use a set of three double quotes before and after) to document the class. You can put documentation here to explain the class and its methods. We’ll see a good use of this a bit later.

Finally, notice the code in the constructor. This demonstrates how to call the base class method, which I do to set the number of axles and doors. We can do the same in other methods if we wanted to call the base class method’s version.

Now, let’s write some code to use this class. Listing 4-4 shows the code we used to test this class. Here, we create a file named pickup.py that creates an instance of the pickup truck, adds occupants, and payload, then prints out the contents of the truck.

Listing 4-4. Using the PickupTruck class

#
# MicroPython for the IOT
#
# Class Example: Exercising the PickupTruck class.
#
# Dr. Charles Bell
#
from pickup_truck import PickupTruck

pickup = PickupTruck(500)
pickup.add_occupant()
pickup.add_occupant()
pickup.add_occupant()
pickup.add_occupant()
pickup.add_payload(100)
pickup.add_payload(300)
print("Number of occupants in truck = {0}.".format(pickup.num_occupants()))
print("Weight in truck = {0}.".format(pickup.get_payload()))
pickup.add_payload(200)
pickup.remove_payload(400)
pickup.remove_payload(10)

Notice I add a couple of calls to the add_occupant() method, which the new class inherits and overrides. I also add calls so that we can test the code in the methods that check for excessive occupants and maximum payload capacity. When we run this code, we will see the results as shown below.

$ python ./pickup.py
Sorry, only 3 occupants are permitted in the truck.
Number of occupants in truck = 3.
Weight in truck = 400.
Overloaded!
Nothing in the truck.

Once again, I ran this code on my PC, but I can run all this code on the MicroPython board and will see the same results.

There is one more thing we should learn about classes: built-in attributes. Recall the __init__() method . Python automatically provides several built-in attributes each starting with __ that you can use to learn more about objects. The following lists a few of the operators available for classes.

• __dict__: Dictionary containing the class namespace

• __doc__: Class documentation string

• __name__: Class name

• __module__: Module name where the class is defined

• __bases__: The base class(es) in order of inheritance

The following shows what each of these attributes returns for the PickupTruck class above. I added this code to the pickup.py file.

print("PickupTruck.__doc__:", PickupTruck.__doc__)
print("PickupTruck.__name__:", PickupTruck.__name__)
print("PickupTruck.__module__:", PickupTruck.__module__)
print("PickupTruck.__bases__:", PickupTruck.__bases__)
print("PickupTruck.__dict__:", PickupTruck.__dict__)

When this code is run, we see the following output.

PickupTruck.__doc__: This is a pickup truck that has:
    axles = 2,
    doors = 2,
    max occupants = 3
    The maximum payload is set on instantiation.

PickupTruck.__name__: PickupTruck
PickupTruck.__module__: pickup_truck
PickupTruck.__bases__: (<class 'vehicle.Vehicle'>,)
PickupTruck.__dict__: {'__module__': 'pickup_truck', '__doc__': 'This is a pickup truck that has:
    axles = 2,
    doors = 2,
    max occupants = 3
    The maximum payload is set on instantiation.
    ', 'occupants': 0, 'payload': 0, 'max_payload': 0, ' _PickupTruck__max_occupants': 3, '__init__': <function PickupTruck.__init__ at 0x1018a1488>, 'add_occupant': <function PickupTruck.add_occupant at 0x1018a17b8>, 'add_payload': <function PickupTruck.add_payload at 0x1018a1840>, 'remove_payload': <function PickupTruck.remove_payload at 0x1018a18c8>, 'get_payload': <function PickupTruck.get_payload at 0x1018a1950>}

You can use the built-in attributes whenever you need more information about a class . Notice the _PickupTruck__max_occupants entry in the dictionary. Recall that we made a pseudo-private variable, __max_occupants. Here, we see how Python refers to the variable by prepending the class name to the variable. Remember, variables that start with two underscores (not one) indicates it should be considered private to the class and only usable from within the class.

Now, let’s see a few examples of Python programs that we can use to practice. Like the previous examples, you can write and execute these either on your PC or on your MicroPython board.

Example 1: Using Loops

This example demonstrates how to write loops in Python using the for loop. The problem we are trying to solve is converting integers from decimal to binary, hexadecimal, and octal. Often with IOT projects, we need to see values in one or more of these formats and in some cases the sensors we use (and the associated documentation) uses hexadecimal rather than decimal. Thus, this example can be helpful in the future not only for how to use the for loop but also how to convert integers into different formats.

#
# MicroPython for the IOT
#
# Example: Convert integer to binary, hex, and octal
#
# Dr. Charles Bell
#

# Create a tuple of integer values
values = (12, 450, 1, 89, 2017, 90125)

# Loop through the values and convert each to binary, hex, and octal
for value in values:
    print("{0} in binary is {1}".format(value, bin(value)))
    print("{0} in octal is {1}".format(value, oct(value)))
    print("{0} in hexadecimal is {1}".format(value, hex(value)))

$ python3 ./conversions.py
12 in binary is 0b1100
12 in octal is 0o14
12 in hexadecimal is 0xc
450 in binary is 0b111000010
450 in octal is 0o702
450 in hexadecimal is 0x1c2
1 in binary is 0b1
1 in octal is 0o1
1 in hexadecimal is 0x1
89 in binary is 0b1011001
89 in octal is 0o131
89 in hexadecimal is 0x59
2017 in binary is 0b11111100001
2017 in octal is 0o3741
2017 in hexadecimal is 0x7e1
90125 in binary is 0b10110000000001101
90125 in octal is 0o260015
90125 in hexadecimal is 0x1600d

$ python3 ./conversions.py 123 hex
123 in hexadecimal is 0x7b

import argparse

# Setup the argument parser
parser = argparse.ArgumentParser()

# We need two arguments: integer, and conversion
parser.add_argument("original_val")
parser.add_argument("conversion")

# Get the arguments
args = parser.parse_args()

if args.conversion == 'bin':
    # do conversion to binary
elif args.conversion == 'oct':
    # do conversion to octal
elif args.conversion == 'hex':
    # do conversion to hexadecimal
else:
    print("Sorry, I don't understand, {0}.".format(args.conversion))

# We need two arguments: integer, and conversion
parser.add_argument("original_val", help="Value to convert.")
parser.add_argument("conversion", help="Conversion options: hex, bin, or oct.")

$ python3 ./conversions.py -h
usage: conversions.py [-h] original_val conversion

positional arguments:
  original_val  Value to convert.
  conversion    Conversion options: hex, bin, or oct.

optional arguments:
  -h, --help    show this help message  and exit

Example 2: Using Complex Data and Files

This example demonstrates how to work with the JavaScript Object Notation⁵ (JSON) in Python. In short, JSON is a markup language used to exchange data. Not only is it human readable, it can be used directly in your applications to store and retrieve data to and from other applications, servers, and even MySQL. In fact, JSON looks familiar to programmers because it resembles other markup schemes. JSON is also very simple in that it supports only two types of structures: 1) a collection containing (name, value) pairs, and 2) an ordered list (or array). Of course, you can also mix and match the structures in an object. When we create a JSON object, we call it a JSON document.

The problem we are trying to solve is writing and reading data to/from files. In this case, we will use a special JSON encoder and decoder module named json that allows us to easily convert data in files (or other streams) to and from JSON. As you will see, accessing JSON data is easy by simply using the key (sometimes called fields) names to access the data. Thus, this example can be helpful in the future not only for how to use read and write files but also how to work with JSON documents.

{"name":"Violet", "age": 6, "breed":"dachshund", "type":"dog"}

parsed_json = json.loads('{"name":"Violet", "age": 6, "breed":"dachshund", "type":"dog"}')
pets.append(parsed_json)

for pet in pets:
  // do something with the pet data

json_file = open("my_data.json", "r")
for pet in json_file.readlines():
  // do something with the pet string

#
# MicroPython for the IOT
#
# Example: Storing and retrieving JSON objects in files
#
# Dr. Charles Bell
#

import json

# Prepare a list of JSON documents for pets by converting JSON to a dictionary
pets = []
parsed_json = json.loads('{"name":"Violet", "age": 6, "breed":"dachshund", "type":"dog"}')
pets.append(parsed_json)
parsed_json = json.loads('{"name": "JonJon", "age": 15, "breed":"poodle", "type":"dog"}')
pets.append(parsed_json)
parsed_json = json.loads('{"name": "Mister", "age": 4, "breed":"siberian khatru", "type":"cat"}')
pets.append(parsed_json)
parsed_json = json.loads('{"name": "Spot", "age": 7, "breed":"koi", "type":"fish"}')
pets.append(parsed_json)
parsed_json = json.loads('{"name": "Charlie", "age": 6, "breed":"dachshund", "type":"dog"}')
pets.append(parsed_json)

# Now, write these entries to a file. Note: overwrites the file
json_file = open("my_data.json", "w")
for pet in pets:
    json_file.write(json.dumps(pet))
    json_file.write("
")
json_file.close()

# Now, let's read the JSON documents then print the name and age for all of the dogs in the list
my_pets = []
json_file = open("my_data.json", "r")
for pet in json_file.readlines():
    parsed_json = json.loads(pet)
    my_pets.append(parsed_json)
json_file.close()

print("Name, Age")
for pet in my_pets:
    if pet['type'] == 'dog':
        print("{0}, {1}".format(pet['name'], pet['age']))

$ more my_data.json
{"age": 6, "breed": "dachshund", "type": "dog", "name": "Violet"}
{"age": 15, "breed": "poodle", "type": "dog", "name": "JonJon"}
{"age": 4, "breed": "siberian khatru", "type": "cat", "name": "Mister"}
{"age": 7, "breed": "koi", "type": "fish", "name": "Spot"}
{"age": 6, "breed": "dachshund", "type": "dog", "name": "Charlie"}

$ python ./rw_json.py
Name, Age
Violet, 6
JonJon, 15
Charlie, 6

for pet in my_pets:
    print(json.dumps(pet, sort_keys=True, indent=4))

{
    "age": 6,
    "breed": "dachshund",
    "name": "Violet",
    "type": "dog"
}
{
    "age": 15,
    "breed": "poodle",
    "name": "JonJon",
    "type": "dog"
}

Example 3: Using Functions

This example demonstrates how to create and use functions. Recall functions are used to help make our code more modular. Functions can also be a key tool in avoiding duplication of code. That is, we can reuse portions of code repeatedly by placing them in a function. Functions are also used to help isolate code for special operations such as mathematical formulae.

The problem we’re exploring in this example is how to create functions to perform calculations. We will also explore a common computer science technique called recursion⁶ where a function calls itself repeatedly. I will also show you the same function implemented in an iterative manner (typically using a loop). While some would advise avoiding recursion, recursive functions are a bit shorter to write but can be more difficult to debug if something goes wrong. The best advice I can offer is that almost every recursive functions can be written as iterative functions and novice programmers should stick to iterative solutions until they gain confidence using functions.

def fibonacci_iterative(count):
    i = 1
    if count == 0:
        fib = []
    elif count == 1:
        fib = [1]
    elif count == 2:
        fib = [1,1]
    elif count > 2:
        fib = [1,1]
        while i < (count - 1):
            fib.append(fib[i] + fib[i-1])
            i += 1
    return fib

def fibonacci_recursive(number):
    if number == 0:
        return 0
    elif number == 1:
        return 1
    else:
        # Call our self counting down.
        value = fibonacci_recursive(number-1) + fibonacci_recursive(number-2)
        return value

#
# MicroPython for the IOT
#
# Example: Fibonacci series using recursion
#
# Calculate the Fibonacci series based on user input
#
# Dr. Charles Bell
#

# Create a function to calculate Fibonacci series (iterative)
# Returns a list.
def fibonacci_iterative(count):
    i = 1
    if count == 0:
        fib = []
    elif count == 1:
        fib = [1]
    elif count == 2:
        fib = [1,1]
    elif count > 2:
        fib = [1,1]
        while i < (count - 1):
            fib.append(fib[i] + fib[i-1])
            i += 1
    return fib

# Create a function to calculate the nth Fibonacci number                                                                                               (recursive)
# Returns an integer.
def fibonacci_recursive(number):
    if number == 0:
        return 0
    elif number == 1:
        return 1
    else:
        # Call our self counting down.
        value = fibonacci_recursive(number-1) + fibonacci_recursive(number-2)
        return value

# Main code
print("Welcome to my Fibonacci calculator!")
index = int(input("Please enter the number of integers in the series: "))

# Recursive example
print("We calculate the value using a recursive algoritm.")
nth_fibonacci = fibonacci_recursive(index)
print("The {0}{1} fibonacci number is {2}."
      "".format(index, "th" if index > 1 else "st", nth_fibonacci))
see_series = str(input("Do you want to see all of the values in the series? "))
if see_series in ["Y","y"]:
    series = []
    for i in range(1,index+1):
        series.append(fibonacci_recursive(i))
    print("Series: {0}: ".format(series))

# Iterative example
print("We calculate the value using an iterative algoritm.")
series = fibonacci_iterative(index)
print("The {0}{1} fibonacci number is {2}."
      "".format(index, "th" if index > 1 else "st", series[index-1]))
see_series = str(input("Do you want to see all of the values in the series? "))
if see_series in ["Y","y"]:
    print("Series: {0}: ".format(series))

print("bye!")

Execute the Code

Recall from Chapter 3, when we want to move code to our MicroPython board, we need to create the file and then copy it to the MicroPython board and then execute it. I will show you how to do this on macOS in this section. An example of how to do it on Windows 10 is shown in example 4.

When you plug your MicroPython board into a USB port on your PC, the flash drive will appear in your Finder and on your desktop. Figure 4-1 shows an example on macOS.

Figure 4-1. MicroPython board Flash Drive Mounted

We now need to copy the fibonacci.py file to the flash drive. On macOS, open the flash drive and then drag the files onto the drive. You should see something like Figure 4-2 when you’ve copied the file.

Figure 4-2. Files Copied to the MicroPython board Flash Drive

Notice I annotated the image to show the file . Notice also we see the MicroPython files boot.py and main.py. We will not modify the main.py file to run our example because we don’t want the program to run every time we boot the device. Instead, we will run the code from the REPL console.

Open a REPL console using a terminal window. You should see the welcome message from MicroPython followed by the RELP prompt (>>>). From the REPL prompt, issue the following code statement.

import fibonnaci

This code imports the fibonnaci.py file we just copied and when it does, it executes the code. So, it’s like we ran it on our PC from the Python console. Go ahead and test the program by requesting the twelfth value in the Fibonacci series. You should see output shown in Figure 4-3.

Figure 4-3. Output of Fibonacci Example (MicroPython board)

Notice I responded to the query to show the entire series. Notice also that we see the code has exercised both versions of the function we wrote: iterative and recursive. Finally, we see that the values or output of both functions is the same data.

Note

If you do not yet have a MicroPython board, you can run the code from your PC with the command, python ./fibonacci.py. You will see similar output as shown in the figure.

If you run the code again, just press CTRL-D to do a soft reset then issue the import statement again. This will rerun the entire code. Or, if you want to run one of the functions, you can call it again by importing it using the code below. Figure 4-4 shows how this would look when executed on the MicroPython board.

from fibonacci import fibonacci_iterative
fibonacci_iterative(6)
from fibonacci import fibonacci_recursive
fibonacci_recursive(6)

Figure 4-4. Experimenting with the Fibonacci Functions

Once imported this way, you can run the functions again. Go ahead and try them with different values to show how they behave. Recall, the functions were implemented differently – the iterative version returns the list and the recursive version returns only the last or nth value.

When you’re done experimenting with the example, remember to close the terminal and eject the drive for the flash before you unplug it.

Example 4: Using Classes

This example ramps up the complexity considerably by introducing an object-oriented programming concept: classes. Recall from earlier that classes are another way to modularize our code. Classes are used to model data and behavior on that data. Further, classes are typically placed in their own code module (file) that further modularizes the code. If you need to modify a class, you may need only change the code in the class module.

The problem we’re exploring in this example is how to develop solutions using classes and code modules. We will be creating two files: one for the class and another for the main code.

3 = III
15 = XV
12 = XII
24 = XXIV
96 = LXLVI
107 = CVII

# Private dictionary of roman numerals
__roman_dict = {
    'I': 1,
    'IV': 4,
    'V': 5,
    'IX': 9,
    'X': 10,
    'XL': 40,
    'L': 50,
    'XC': 90,
    'C': 100,
    'CD': 400,
    'D': 500,
    'CM': 900,
    'M': 1000,
}

#
# MicroPython for the IOT
#
# Example: Roman numerals class
#
# Convert integers to roman numerals
# Convert roman numerals to integers
#
# Dr. Charles Bell
#

class Roman_Numerals:

    # Private dictionary of roman numerals
    __roman_dict = {
        'I': 1,
        'IV': 4,
        'V': 5,
        'IX': 9,
        'X': 10,
        'XL': 40,
        'L': 50,
        'XC': 90,
        'C': 100,
        'CD': 400,
        'D': 500,
        'CM': 900,
        'M': 1000,
    }                                                                                              

    def convert_to_int(self, roman_num):
        value = 0
        for i in range(len(roman_num)):
            if i > 0 and self.__roman_dict[roman_num[i]] > self.__roman_dict[roman_num[i - 1]]:
                value += self.__roman_dict[roman_num[i]] - 2 * self.__roman_dict[roman_num[i - 1]]
            else:
                value += self.__roman_dict[roman_num[i]]
        return value

    def convert_to_roman(self, int_value):
        # First, get the values of all of entries in the dictionary
        roman_values = list(self.__roman_dict.values())
        roman_keys = list(self.__roman_dict.keys())
        # Prepare the string
        roman_str = ""
        remainder = int_value
        # Loop through the values in reverse
        for i in range(len(roman_values)-1, -1, -1):
            count = int(remainder / roman_values[i])
            if count > 0:
                for j in range(0,count):
                    roman_str += roman_keys[i]
                remainder -= count * roman_values[i]
        return roman_str

from roman_numerals import Roman_Numerals

#
# MicroPython for the IOT
#
# Example: Convert roman numerals using a class
#
# Convert integers to roman numerals
# Convert roman numerals to integers
#
# Dr. Charles Bell
#

from roman_numerals import Roman_Numerals

roman_str = input("Enter a valid roman numeral: ")
roman_num = Roman_Numerals()

# Convert to roman numberals
value = roman_num.convert_to_int(roman_str)
print("Convert to integer:        {0} = {1}".format(roman_str, value))

# Convert to integer
new_str = roman_num.convert_to_roman(value)
print("Convert to Roman Numerals: {0} = {1}".format(value, new_str))

print("bye!")

Execute the Code

In this example, we will see how to copy the code to our MicroPython board on Windows 10. Like the last example, we will first create the files on our PC, connect the MicroPython board, copy the files, and then execute them.

When you connect your MicroPython board on Windows 10, the drive will show in the file explorer as shown in Figure 4-5.

Figure 4-5. MicroPython board Flash Drive Mounted (Windows 10)

If you haven’t created the files, do that now. When ready, we’ll copy them to the MicroPython board. Rather than use the file explorer, I chose to demonstrate how to copy the files from a console (command prompt). Open a console and then change to the drive letter shows in your file explorer . Next, copy the files roman_numerals.py and roman.py to the drive. Figure 4-6 shows an example of copying the files.

Figure 4-6. Copying the File to the MicroPython board Flash Drive (Console)

Now, we’re ready to connect to the MicroPython board and run the code. Recall one of the ways to connect to the board is to use PuTTY on Windows. Figure 4-7 shows the PuTTY console. Notice I chose COM3 and serial connection . Recall, you can find the COM port from the Device Manager. When ready, click Open.

PuTTY will open the REPL console when the connection is made. You should see the welcome message from MicroPython followed by the RELP prompt (>>>). From the REPL prompt, issue the following code statement.

import roman

This code imports the roman.py file we just copied and when it does, it executes the code, which if you recall will call the code in the roman_numerals.py code module. Once again, issuing the import is like how we ran it on our PC from the Python console.

Figure 4-7. Connecting with PuTTy (Windows 10)

Once you issue the import statement, the code will execute. Go ahead and try it out. Start with the value LXLIV, which is SSS in Roman numerals . Figure 4-8 shows what the output will look like.

Figure 4-8. Executing the Roman Numerals Example

You can also experiment with importing the code and executing it again from the terminal or just eject the drive, reset the board, and reconnect to run it again with other values.

When you’re done executing the example, remember to close the terminal and eject the drive for the flash before you unplug it.

__roman_str = ""
...
def __init__(self, name):
        self.name = name

roman_str = input("Enter a valid roman numeral: ")
roman_num = Roman_Numerals(roman_str)