# A taste of Python¶

We will start our Python lesson by learning a bit of the basic operations you can perform using Python.

## Sources¶

This lesson is inspired by the Programming in Python lessons from the Software Carpentry organization.

## About this document¶

This is a Jupyter Notebook designed to assess your understanding of the basic concepts of programming in Python. The contents of this document are divided into cells, which can contain Markdown-formatted text, Python code, or raw text. You can execute a snippet of code in a cell by pressing **Shift-Enter**. Try this out in the examples below.

### Getting started¶

Presumably if you have made it this far, you have already opened this Jupyter Notebook using Binder, the CSC notebooks server, or on your own computer. If not, you can launch Jupyter Lab by clicking on either of the launch buttons at the top of this document or by typing the following in a terminal window.

$ jupyter labThis should open a new Jupyter Lab session from which you can open this document by navigating its location in the **Files** tab and double clicking on it. After that you should be ready to go.

### Variables, arithmetic and modules¶

We will start our Python lesson by learning a bit of the basic operations you can perform using Python.

## Simple Python math¶

Python can be used as a simple calculator. Remember, you can press **Shift-Enter** to execute the code in the cells below. Try it out and see what you get.

```
[1]:
```

```
1 + 1
```

```
[1]:
```

```
2
```

```
[2]:
```

```
5 * 7
```

```
[2]:
```

```
35
```

If you want to edit and re-run some code, simply make changes to the cell and press **Shift-Enter** to execute the revised code.

## Functions¶

You can use Python for more advanced math by using functions. Functions are pieces of code that perform a single action such as printing information to the screen (e.g., the print() function). Functions exist for a huge number of operations in Python.

```
[3]:
```

```
sin(3)
```

```
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-3-2b5fc2868c51> in <module>()
----> 1 sin(3)
NameError: name 'sin' is not defined
```

```
[4]:
```

```
sqrt(4)
```

```
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-4-317e033d29d5> in <module>()
----> 1 sqrt(4)
NameError: name 'sqrt' is not defined
```

Wait, what? Python can’t calculate square roots or do basic trigonometry? Of course it can, but we need one more step.

## Math operations¶

The list of basic arithmetic operations that can be done by default in Python is in the table below.

Operation | Symbol | Example syntax | Returned value |
---|---|---|---|

Addition | `+` |
`2 + 2` |
`4` |

Subtraction | `-` |
`4 - 2` |
`2` |

Multiplication | `*` |
`2 * 3` |
`6` |

Division | `/` |
`4 / 2` |
`2` |

Exponentiation | `**` |
`2**3` |
`8` |

For anything more advanced, we need to load a *module*.

```
[5]:
```

```
import math
```

```
[6]:
```

```
math.sin(3)
```

```
[6]:
```

```
0.1411200080598672
```

```
[7]:
```

```
math.sqrt(4)
```

```
[7]:
```

```
2.0
```

We can see a few interesting things above:

- A
*module*, also known as a*library*, is a group of code items such as functions that are related to one another. Modules are loaded using`import`

. Functions that are part of the module`modulename`

could then be used by typing`modulename.functionname()`

. For example,`sin()`

is a function that is part of the`math`

module, and used by typing`math.sin()`

with some number between the parentheses. - Within a given Jupyter Notebook the variables you define earlier in the notebook will be available for use in the cells that follow as long as you have already executed the cells.
- Modules may also contain constants such as
`math.pi`

.

```
[8]:
```

```
math.pi
```

```
[8]:
```

```
3.141592653589793
```

```
[9]:
```

```
math.sin(math.pi)
```

```
[9]:
```

```
1.2246467991473532e-16
```

## Combining functions¶

Functions can also be combined

```
[10]:
```

```
print(math.sqrt(4))
```

```
2.0
```

```
[11]:
```

```
print('The square root of 4 is',math.sqrt(4))
```

```
The square root of 4 is 2.0
```

## Variables¶

*Variables* can be used to store values calculated in expressions and used for other calculations.

```
[12]:
```

```
temp_celsius = 10.0
print(temp_celsius)
```

```
10.0
```

```
[13]:
```

```
print('Temperature in Fahrenheit:', 9/5 * temp_celsius + 32)
```

```
Temperature in Fahrenheit: 50.0
```

Above, we also see one common format for good variable naming, separation of words by underscores `_`

(e.g., `temp_celsius`

). This is called *pothole_case_naming*. We’ll see another below.

Use the empty Python cell below to define a variable and print its value to the screen using the `print()`

function. The variable value can be anything you like, and you can even consider defining several variables and printing them out together. Consider using pothole_case_naming for your variable name.

```
[ ]:
```

```
# Place your code on the line(s) below. Note that lines starting with "#" are ignored in Python.
```

## Updating variables¶

Values stored in variables can also be updated.

```
[14]:
```

```
temp_celsius = 15.0
```

```
[15]:
```

```
print('temperature in Celsius is now:', temp_celsius)
```

```
temperature in Celsius is now: 15.0
```

**Warning**

If you try to run some code that accesses a variable that has not yet been defined you will get a `NameError`

message.

```
[16]:
```

```
print('Temperature in Celsius:', 5/9 * (tempFahrenheit - 32))
```

```
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-16-2067e78f4444> in <module>()
----> 1 print('Temperature in Celsius:', 5/9 * (tempFahrenheit - 32))
NameError: name 'tempFahrenheit' is not defined
```

**Note**

One of the cool things here is that if we define the undefined variable in a later cell and execute that cell, we can return to the earlier one and the code should now work. That was a bit of a complicated sentence, so let’s test this all out. First, execute the Python code in the cell below. Then, return to the cell above this text and run it again. See how the error message has gone away? `tempFahrenheit`

has now been defined and thus the cell above no longer generates a `NameError`

when
the code is executed.

Also, the number beside the cell, for example `In [2]`

, tells you the order in which the Python cells have been executed. This way you can see a history of the commands you’ve executed

```
[17]:
```

```
tempFahrenheit = 9/5 * temp_celsius + 32
```

```
[18]:
```

```
print('temperature in Celsius:', temp_celsius, 'and in Fahrenheit:', tempFahrenheit)
```

```
temperature in Celsius: 15.0 and in Fahrenheit: 59.0
```

## Variable values¶

Changing the value of a variable does not affect other variable values.

```
[19]:
```

```
temp_celsius = 20.0
print('temperature in Celsius is now:', temp_celsius, 'and temperature in Fahrenheit is still:', tempFahrenheit)
```

```
temperature in Celsius is now: 20.0 and temperature in Fahrenheit is still: 59.0
```

## Data types¶

There are 4 basic *data types* in Python as shown in the table below.

Data type name | Data type | Example |
---|---|---|

`int` |
Whole integer values | `4` |

`float` |
Decimal values | `3.1415` |

`str` |
Character strings | `'Hot'` |

`bool` |
True/false values | `True` |

The data type can be found using the `type()`

function. As you will see, the data types are important because some are not compatible with one another.

```
[20]:
```

```
weatherForecast = 'Hot'
type(weatherForecast)
```

```
[20]:
```

```
str
```

```
[21]:
```

```
type(tempFahrenheit)
tempFahrenheit = tempFahrenheit + 5.0 * weatherForecast
```

```
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-21-41e07022ce91> in <module>()
1 type(tempFahrenheit)
----> 2 tempFahrenheit = tempFahrenheit + 5.0 * weatherForecast
TypeError: can't multiply sequence by non-int of type 'float'
```

In this case we get at `TypeError`

because we are trying to execute a math operation with data types that are not compatible. There is no way in Python to multpily numbers with a character string.

Use the empty Python cell below to store a value in a variable that is the result of dividing an `int`

value by a `float`

or vice versa. For example, `4 / 2.0`

. After you store the value in the variable, check its type using the `type()`

function. Did you get what you expected? What happens when you divide two `int`

values?

```
[ ]:
```

```
# Place your code on the line(s) below.
```