4.3.7.1. Booleans¶

A boolean is a value that indicates truthness of something. You can think of it as a toggle: either “on” or “off”, “one” or “zero”, “true” or “false”. In fact, the only possible values of the boolean (or bool) type in Python are:

• True
• False

You can combine booleans with boolean operators:

• and
• or

>>> print(True and True)
True
>>> print(True and False)
False
>>> print(False and False)
False
>>> print(True or True)
True
>>> print(True or False)
True
>>> print(False or False)
False

4.3.7.2. Numbers¶

The interactive interpreter can also be used as a calculator. For instance, say we wanted to compute a multiple of 21:

>>> print(21 * 2)
42

We saw here the print statement again. We passed in the result of the operation 21 * 2. An integer (or int) in Python is a numeric value without a fractional component (those are called floating point numbers, or float for short).

The mathematical operators compute the related mathematical operation to the provided numbers. Some operators are:

• * — multiplication
• / — division
• + — addition
• - — subtraction
• ** — exponent

Exponentiation is read as x**y is x to the yth power:

You can combine floats and ints:

>>> print(3.14 * 42 / 11 + 4 - 2)
13.9890909091
>>> print(2**3)
8

Note that operator precedence is important. Using parenthesis to indicate affect the order of operations gives a difference results, as expected:

>>> print(3.14 * (42 / 11) + 4 - 2)
11.42
>>> print(1 + 2 * 3 - 4 / 5.0)
6.2
>>> print( (1 + 2) * (3 - 4) / 5.0 )
-0.6

4.3.9.1. Import Statement¶

When the interpreter encounters an import statement, it imports the module if the module is present in the search path. A search path is a list of directories that the interpreter searches before importing a module. The from…import Statement Python’s from statement lets you import specific attributes from a module into the current namespace. The from…import has the following syntax − from modname:

import name1[, name2[, … nameN]]

When the interpreter encounters an import statement, it imports the module if the module is present in the search path. A search path is a list of directories that the interpreter searches before importing a module.

4.3.9.2. The from … import Statement¶

Python’s from statement lets you import specific attributes from a module into the current namespace. The from … import has the following syntax:

::

from module1 import name1[, name2[, … nameN]]

4.3.11.1. Comparision¶

Computer programs do not only execute instructions. Occasionally, a choice needs to be made. Such as a choice is based on a condition. Python has several conditional operators:

>   greater than
<   smaller than
==  equals
!=  is not

Conditions are always combined with variables. A program can make a choice using the if keyword. For example:

>>> x = int(input("Guess x:"))
>>> if x == 4:
...    print('You guessed correctly!')
...    <ENTER>

In this example, You guessed correctly! will only be printed if the variable x equals to four (see table above). Python can also execute multiple conditions using the elif and else keywords.

>>> x = int(input("Guess x:"))
>>> if x == 4:
...     print('You guessed correctly!')
... elif abs(4 - x) == 1:
...     print('Wrong guess, but you are close!')
... else:
...     print('Wrong guess')
... <ENTER>

4.3.11.2. Iteration¶

To repeat code, the for keyword can be used. For example, to display the numbers from 1 to 10, we could write something like this:

>>> for i in range(1, 11):
...    print('Hello!')

The second argument to range, 11, is not inclusive, meaning that the loop will only get to 10 before it finishes. Python itself starts counting from 0, so this code will also work:

>>> for i in range(0, 10):
...    print(i + 1)

In fact, the range function defaults to starting value of 0, so the above is equivalent to:

>>> for i in range(10):
...    print(i + 1)

We can also nest loops inside each other:

>>> for i in range(0,10):
...     for j in range(0,10):
...         print(i,' ',j)
... <ENTER>

In this case we have two nested loops. The code will iterate over the entire coordinate range (0,0) to (9,9)

4.3.12.1. Lists¶

see: https://www.tutorialspoint.com/python/python_lists.htm

Lists in Python are ordered sequences of elements, where each element can be accessed using a 0-based index.

To define a list, you simply list its elements between square brackest []:

>>> >>> names = ['Albert', 'Jane', 'Liz', 'John', 'Abby']
>>> names[0] # access the first element of the list
'Albert'
>>> names[2] # access the third element of the list
'Liz'

You can also use a negative index if you want to start counting elements from the end of the list. Thus, the last element has index -1, the second before last element has index -2 and so on:

>>> names[-1] # access the last element of the list
'Abby'
>>> names[-2] # access the second last element of the list
'John'

Python also allows you to take whole slices of the list by specifing a beginning and end of the slice separated by a colon ::

>>> names[1:-1] # the middle elements, excluding first and last
['Jane', 'Liz', 'John']

As you can see from the example above, the starting index in the slice is inclusive and the ending one, exclusive.

Python provides a variety of methods for manipulating the members of a list.

You can add elements with append:

>>> names.append('Liz')
>>> names
['Albert', 'Jane', 'Liz', 'John', 'Abby', 'Liz']

As you can see, the elements in a list need not be unique.

Merge two lists with extend:

>>> names.extend(['Lindsay', 'Connor'])
>>> names
['Albert', 'Jane', 'Liz', 'John', 'Abby', 'Liz', 'Lindsay', 'Connor']

Find the index of the first occurrence of an element with index:

>>> names.index('Liz')
2

Remove elements by value with remove:

>>> names.remove('Abby')
>>> names
['Albert', 'Jane', 'Liz', 'John', 'Liz', 'Lindsay', 'Connor']

Remove elements by index with pop:

>>> names.pop(1)
'Jane'
>>> names
['Albert', 'Liz', 'John', 'Liz', 'Lindsay', 'Connor']

Notice that pop returns the element being removed, while remove does not.

If you are familiar with stacks from other programming languages, you can use insert and pop:

>>> names.insert(0, 'Lincoln')
>>> names
['Lincoln', 'Albert', 'Liz', 'John', 'Liz', 'Lindsay', 'Connor']
>>> names.pop()
'Connor'
>>> names
['Lincoln', 'Albert', 'Liz', 'John', 'Liz', 'Lindsay']

The Python documentation contains a `full list of list operations <>`_.

To go back to the range function you used earlier, it simply creates a list of numbers:

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(2, 10, 2)
[2, 4, 6, 8]

4.3.12.2. Sets¶

Python lists can contain duplicates as you saw above:

>>> names = ['Albert', 'Jane', 'Liz', 'John', 'Abby', 'Liz']

When we don’t want this to be the case, we can use a set:

>>> unique_names = set(names)
>>> unique_names
set(['Lincoln', 'John', 'Albert', 'Liz', 'Lindsay'])

Keep in mind that the set is an unordered collection of objects, thus we can not access them by index:

>>> unique_names[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  TypeError: 'set' object does not support indexing

However, we can convert a set to a list easily:

>>> unique_names = list(unique_names)
>>> unique_names
['Lincoln', 'John', 'Albert', 'Liz', 'Lindsay']
>>> unique_names[0]
'Lincoln'

Notice that in this case, the order of elements in the new list matches the order in which the elements were displayed when we create the set (we had set([‘Lincoln’, ‘John’, ‘Albert’, ‘Liz’, ‘Lindsay’]) and now we have [‘Lincoln’, ‘John’, ‘Albert’, ‘Liz’, ‘Lindsay’]). You should not assume this is the case in general. That is, don’t make any assumptions about the order of elements in a set when it is converted to any type of sequential data structure.

You can change a set’s contents using the add, remove and update methods which correspond to the append, remove and extend methods in a list. In addition to these, set objects support the operations you may be familiar with from mathematical sets: union, intersection, difference, as well as operations to check containment. You can read about this in the Python documentation for sets.

4.3.12.3. Removal and Testing for Membership in Sets¶

One important advantage of a set over a list is that access to elements is fast. If you are familiar with different data structures from a Computer Science class, the Python list is implemented by an array, while the set is implemented by a hash table.

We will demonstrate this with an example. Let’s say we have a list and a set of the same number of elements (approximately 100 thousand):

>>> import sys, random, timeit
>>> nums_set = set([random.randint(0, sys.maxint) for _ in range(10**5)])
>>> nums_list = list(nums_set)
>>> len(nums_set)
100000

We will use the timeit Python module to time 100 operations that test for the existence of a member in either the list or set:

>>> timeit.timeit('random.randint(0, sys.maxint) in nums', setup='import random; nums=%s' % str(nums_set), number=100)
0.0004038810729980469
>>> timeit.timeit('random.randint(0, sys.maxint) in nums', setup='import random; nums=%s' % str(nums_list), number=100)
0.3980541229248047

The exact duration of the operations on your system will be different, but the take away will be the same: searching for an element in a set is orders of magnitude faster than in a list. This is important to keep in mind when you work with large amounts of data.

4.3.12.4. Dictionaries¶

One of the very important data structures in python is a dictionary also referred to as dict.

A dictionary represents a key value store:

>>> person = {'Name': 'Albert', 'Age': 100, 'Class': 'Scientist'}
>>> print("person['Name']: ", person['Name'])
person['Name']:  Albert
>>> print("person['Age']: ", person['Age'])
person['Age']:  100

You can delete elements with the following commands:

>>> del person['Name'] # remove entry with key 'Name'
>>> person
{'Age': 100, 'Class': 'Scientist'}
>>> person.clear()     # remove all entries in dict
>>> person
{}
>>> del person         # delete entire dictionary
>>> person
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  NameError: name 'person' is not defined

You can iterate over a dict:

>>> person = {'Name': 'Albert', 'Age': 100, 'Class': 'Scientist'}
>>> for item in person:
...   print(item, person[item])
...   <ENTER>
Age 100
Name Albert
Class Scientist

4.3.12.5. Dictionary Keys and Values¶

You can retrieve both the keys and values of a dictionary using the keys() and values() methods of the dictionary, respectively:

>>> person.keys()
['Age', 'Name', 'Class']
>>> person.values()
[100, 'Albert', 'Scientist']

Both methods return lists. Notice, however, that the order in which the elements appear in the returned lists (Age, Name, Class) is different from the order in which we listed the elements when we declared the dictionary initially (Name, Age, Class). It is important to keep this in mind: you can’t make any assumptions about the order in which the elements of a dictionary will be returned by the `keys()` and `values()` methods.

However, you can assume that if you call keys() and values() in sequence, the order of elements will at least correspond in both methods. In the above example Age corresponds to 100, Name to ‘Albert, and Class to Scientist, and you will observe the same correspondence in general as long as `keys()` and `values()` are called one right after the other.

4.3.12.6. Counting with Dictionaries¶

One application of dictionaries that frequently comes up is counting the elements in a sequence. For example, say we have a sequence of coin flips:

>>> import random
>>> die_rolls = [random.choice(['heads', 'tails']) for _ in range(10)]
>>> die_rolls
['heads', 'tails', 'heads', 'tails', 'heads', 'heads', 'tails', 'heads', 'heads', 'heads']

The actual list die_rolls will likely be different when you execute this on your computer since the outcomes of the die rolls are random.

To compute the probabilities of heads and tails, we could count how many heads and tails we have in the list:

>>> counts = {'heads': 0, 'tails': 0}
>>> for outcome in coin_flips:
...   assert outcome in counts
...   counts[outcome] += 1
...   <ENTER>
>>> print('Probability of heads: %.2f' % (counts['heads'] / len(coin_flips)))
Probability of heads: 0.70
>>> print('Probability of tails: %.2f' % (counts['tails'] / sum(counts.values())))
Probability of tails: 0.30

In addition to how we use the dictionary counts to count the elements of coin_flips, notice a couple things about this example:

1. We used the assert outcome in counts statement. The assert statement in Python allows you to easily insert debugging statements in your code to help you discover errors more quickly. assert statements are executed whenever the internal Python __debug__ variable is set to True, which is always the case unless you start Python with the -O option which allows you to run optimized Python.
2. When we computed the probability of tails, we used the built-in sum function, which allowed us to quickly find the total number of coin flips. sum is one of many built-in function you can read about here.

4.3.19.1. GUIZero¶

Install guizero with the following command:

sudo pip3 install guizero

For a comprehensive tutorial on guizero, click here.

4.3.19.2. Kivy¶

You can install Kivy on OSX as followes:

brew install pkg-config sdl2 sdl2_image sdl2_ttf sdl2_mixer gstreamer
pip install -U Cython
pip install kivy
pip install pygame

A hello world program for kivy is included in the cloudmesh.robot repository. Which you can fine here

• https://github.com/cloudmesh/cloudmesh.robot/tree/master/projects/kivy

To run the program, please download it or execute it in cloudmesh.robot as follows:

cd cloudmesh.robot/projects/kivy
python swim.py

To create stand alone packages with kivy, please see:

-  https://kivy.org/docs/guide/packaging-osx.html

4.3.25.1. pypi¶

Link: pypi

The Python Package Index is a large repository of software for the Python programming language containing a large number of packages [link]. The nice think about pipy is that many packages can be installed with the program ‘pip’.

To do so you have to locate the <package_name> for example with the search function in pypi and say on the commandline:

pip install <package_name>

where pagage_name is the string name of the package. an example would be the package called cloudmesh_client which you can install with:

pip install cloudmesh_client

If all goes well the package will be installed.

4.3.25.2. Alternative Installations¶

The basic installation of python is provided by python.org. However others claim to have alternative environments that allow you to install python. This includes

• Canopy
• Anaconda
• IronPython

Typically they include not only the python compiler but also several useful packages. It is fine to use such environments for the class, but it should be noted that in both cases not every python library may be available for install in the given environment. For example if you need to use cloudmesh client, it may not be available as conda or Canopy package. This is also the case for many other cloud related and useful python libraries. Hence, we do recommend that if you are new to python to use the distribution form python.org, and use pip and virtualenv.

Additionally some python version have platform specific libraries or dependencies. For example coca libraries, .NET or other frameworks are examples. For the assignments and the projects such platform dependent libraries are not to be used.

If however you can write a platform independent code that works on Linux, OSX and Windows while using the python.org version but develop it with any of the other tools that is just fine. However it is up to you to guarantee that this independence is maintained and implemented. You do have to write requirements.txt files that will install the necessary python libraries in a platform independent fashion. The homework assignment PRG1 has even a requirement to do so.

In order to provide platform independence we have given in the class a “minimal” python version that we have tested with hundreds of students: python.org. If you use any other version, that is your decision. Additionally some students not only use python.org but have used iPython which is fine too. However this class is not only about python, but also about how to have your code run on any platform. The homework is designed so that you can identify a setup that works for you.

However we have concerns if you for example wanted to use chameleon cloud which we require you to access with cloudmesh. cloudmesh is not available as conda, canopy, or other framework package. Cloudmesh client is available form pypi which is standard and should be supported by the frameworks. We have not tested cloudmesh on any other python version then python.org which is the open source community standard. None of the other versions are standard.

In fact we had students over the summer using canopy on their machines and they got confused as they now had multiple python versions and did not know how to switch between them and activate the correct version. Certainly if you know how to do that, than feel free to use canopy, and if you want to use canopy all this is up to you. However the homework and project requires you to make your program portable to python.org. If you know how to do that even if you use canopy, anaconda, or any other python version that is fine. Graders will test your programs on a python.org installation and not canpoy, anaconda, ironpython while using virtualenv. It is obvious why. If you do not know that answer you may want to think about that every time they test a program they need to do a new virtualenv and run vanilla python in it. If we were to run two instals in the same system, this will not work as we do not know if one student will cause a side effect for another. Thus we as instructors do not just have to look at your code but code of hundreds of students with different setups. This is a non scalable solution as every time we test out code from a student we would have to wipe out the OS, install it new, install an new version of whatever python you have elected, become familiar with that version and so on and on. This is the reason why the open source community is using python.org. We follow best practices. Using other versions is not a community best practice, but may work for an individual.

We have however in regards to using other python version additional bonus projects such as

• deploy run and document cloudmesh on ironpython
• deploy run and document cloudmesh on anaconde, develop script to generate a conda packge form github
• deploy run and document cloudmesh on canopy, develop script to generate a conda packge form github
• deploy run and document cloudmesh on ironpython
• other documentation that would be useful

4.3.25.3. Autoenv: Directory-based Environments¶

Link: Autoenv <https://pypi.python.org/pypi/autoenv/0.2.0>

If a directory contains a .env file, it will automatically be executed when you cd into it. It’s easy to use and install.

This is useful for

• auto-activating virtualenvs
• project-specific environment variables

To use it add the ENV you created with virtualenv into .env file within your project directory:

$ echo "source ~/ENV/bin/activate" > yourproject/.env
$ echo "echo 'whoa'" > yourproject/.env
$ cd project
whoa

To install it on Mac OS X use Homebrew:

$ brew install autoenv
$ echo "source $(brew --prefix autoenv)/activate.sh" >> ~/.bash_profile

To install it using pip use:

$ pip install autoenv
$ echo "source `which activate.sh`" >> ~/.bashrc

To install it using git use:

$ git clone git://github.com/kennethreitz/autoenv.git ~/.autoenv
$ echo 'source ~/.autoenv/activate.sh' >> ~/.bashrc

Before sourcing activate.sh, you can set the following variables:

• AUTOENV_AUTH_FILE: Authorized env files, defaults to ~/.autoenv_authorized
• AUTOENV_ENV_FILENAME: Name of the .env file, defaults to .env
• AUTOENV_LOWER_FIRST: Set this variable to flip the order of .env files executed

Autoenv overrides cd. If you already do this, invoke autoenv_init within your custom cd after sourcing activate.sh.

Autoenv can be disabled via unset cd if you experience I/O issues

with certain file systems, particularly those that are FUSE-based (such as smbnetfs).