A taste of Python#
Attention
Finnish university students are encouraged to use the CSC Notebooks platform.
Others can follow the lesson and fill in their student notebooks using Binder.
We will start our Python lesson by learning a bit of the basic operations you can perform using Python.
General information#
Sources#
This lesson is inspired by the Programming in Python lessons from the Software Carpentry organization.
About this document#
This is a Jupyter Notebook. This particular notebook is designed to introduce you to a few of the basic concepts of programming in Python. The contents of this document are divided into cells, which can contain Markdownformatted text, Python code, or raw text. You can execute a snippet of code in a cell by pressing Shift + Enter. Try this out with 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 the launch button at the top of this document, using the launch Binder icon at the top of the page, or by typing the following in a terminal window.
$ jupyter lab
This 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, math and functions#
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 by typing 1 + 1
or 5 * 7
and see what you get.
1 + 1
2
5 * 7
35
If you want to edit and rerun some code, simply make changes to the cell and press Shift + Enter to execute the modified code.
Functions#
You can use Python for more advanced math by using a function (funktio). 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.
Let’s try out a few simple examples using functions to find the sine or square root of a value. You can type sin(3)
or sqrt(4)
into the cells below to test this out.
sin(3)

NameError Traceback (most recent call last)
/tmp/ipykernel_280/1532400118.py in <module>
> 1 sin(3)
NameError: name 'sin' is not defined
sqrt(4)

NameError Traceback (most recent call last)
/tmp/ipykernel_280/1103852951.py 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 



Subtraction 



Multiplication 



Division 



Exponentiation 



For anything more advanced, we need to load a module (moduuli) or library (ohjelmakirjasto). For math operations, this module is called math and it can be loaded by typing import math
. Try that below.
import math
Now that we have access to functions in the math module, we can use it by typing the module name, a period (dot), and the the name of the function we want to use. For example, math.sin(3)
. Try this with the sine and square root examples from above.
math.sin(3)
0.1411200080598672
math.sqrt(4)
2.0
Let’s summarize what we’ve just seen with modules:
A module is a group of code items such as functions that are related to one another. Individual modules are often in a group referred to as a library.
Modules can be loaded using
import
. Functions that are part of the modulemodulename
can then be used by typingmodulename.functionname()
. For example,sin()
is a function that is part of themath
module, and used by typingmath.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
. Type this in the cell below to see the value of the contantmath.pi
.
math.pi
3.141592653589793
Check your understanding#
Use the empty Python cell below to calculate the sine of pi. What value do you expect for this calculation? Did you get the expected result?
Show code cell content
# Here's the solution
math.sin(math.pi)
1.2246467991473532e16
Combining functions#
Functions can also be combined. The print()
function returns values within the parentheses as text on the screen. Below, try printing the value of the square root of four.
print(math.sqrt(4))
2.0
You can also combine text with other calculated values using the print()
function. For example, print('Two plus two is', 2+2)
would generate text reading ‘Two plus two is 4’. Combine the print()
function with the math.sqrt()
function in the cell below to produce text that reads ‘The square root of 4 is 2.0’.
print("The square root of 4 is", math.sqrt(4))
The square root of 4 is 2.0
Variables#
A variable (muuttuja) can be used to store values calculated in expressions and used for other calculations. Assigning value to variables is straightforward. To assign a value, you simply type variable_name = value
, where variable_name
is the name of the variable you wish to define. In the cell below, define a variable called temp_celsius
, assign it a value of ‘10.0’, and then print that variable value using the print()
function. Note that you should do this on two separate lines.
temp_celsius = 10.0
print(temp_celsius)
10.0
As we did above, you can combine text and even use some math when printing out variable values. The idea is similar to the examples of adding 2+2 or calculating the square root of four from the previous section. In the cell below, print out the value of temp_celsius
in degrees Fahrenheit by multiplying temp_celsius
by 9/5 and adding 32. This should be done within the print()
function to produce output that reads ‘Temperature in Fahrenheit: 50.0’.
print("Temperature in Fahrenheit:", 9 / 5 * temp_celsius + 32)
Temperature in Fahrenheit: 50.0
Check your understanding#
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.
Show code cell content
# Here's a solution
part1 = "I like"
part2 = "Python!"
print(part1, part2)
I like Python!
Updating variables#
Values stored in variables can also be updated. Let’s redefine the value of temp_celsius
to be equal to 15.0 and print its value in the cells below.
temp_celsius = 15.0
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. Try printing out the value of the variable tempFahrenheit
using the print()
function in the cell below.
print("Temperature in Celsius:", 5 / 9 * (tempFahrenheit  32))

NameError Traceback (most recent call last)
/tmp/ipykernel_280/1178739870.py in <module>
> 1 print("Temperature in Celsius:", 5 / 9 * (tempFahrenheit  32))
NameError: name 'tempFahrenheit' is not defined
Note
One of the interesting things here is that if we define the undefined variable in a cell lower down in the notebook and execute that cell, we can return to the earlier cell and the code should now work. That was a bit of a complicated sentence, so let’s test this all out. First, let’s define a variable called tempFahrenheit
in the cell below and assign it to be equal to 9/5 * temp_celsius + 32
, the conversion factor from temperatures in Celsius to Fahrenheit. Then, return to the cell above this text and run that cell 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 order in which you have run the cells.
tempFahrenheit = 9 / 5 * temp_celsius + 32
Just to check their current values, print out the values of temp_celsius
and tempFahrenheit
in the cell below.
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. Let’s redefine temp_celsius
to be equal to 20.0, and print out the values of temp_celsius
and tempFahrenheit
.
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#
A data type (tietotyyppi) determines the characteristics of data in a program. There are 4 basic data types in Python as shown in the table below.
Data type name 
Data type 
Example 


Whole integer values 


Decimal values 


Character strings 


True/false values 

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.
Let’s define a variable weatherForecast
and assign it the value 'Hot'
. After this, we can check its data type using the type()
function.
weatherForecast = "Hot"
type(weatherForecast)
str
Let’s also check the type of tempFahrenheit
. What happens if you try to combine tempFahrenheit
and weatherForecast
in a single math equation such as tempFahrenheit = tempFahrenheit + 5.0 * weatherForecast
?
type(tempFahrenheit)
tempFahrenheit = tempFahrenheit + 5.0 * weatherForecast

TypeError Traceback (most recent call last)
/tmp/ipykernel_280/585404086.py in <module>
1 type(tempFahrenheit)
> 2 tempFahrenheit = tempFahrenheit + 5.0 * weatherForecast
TypeError: can't multiply sequence by nonint 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.
Check your understanding#
As it turns out, you can do some math with character strings in Python. Define two variables and assign them character string values in the Python cell below. What happens if you try to add two character strings together? Can you subtract them? Which other math operations work for character strings?
Show code cell content
# Here is an example solution
first_variable = "Python"
second_variable = " is cool!"
print(first_variable + second_variable)
print(5 * first_variable)
print(first_variable  second_variable)
Python is cool!
PythonPythonPythonPythonPython

TypeError Traceback (most recent call last)
/tmp/ipykernel_280/3258998038.py in <module>
6 print(first_variable + second_variable)
7 print(5 * first_variable)
> 8 print(first_variable  second_variable)
TypeError: unsupported operand type(s) for : 'str' and 'str'
Character input (optional)#
Python and Jupyter notebooks also let us interact in another way with our code! The builtin input() function reads a line from input and returns it as a string.
Let’s try it out. To start, we can define a varaible place
and assign its value using the input()
function to prompt the user for the location where they are from (e.g., input('Where are you from? ')
). When the cell is run, the user (you) can type in their response. Once place
is defined, we can say something good about where the user is from (e.g., print(place, 'is a nice place!')
).
Warning
Jupyter Notebooks might sometimes get stuck when using the input()
function. If this happens, restart the kernel and run the cell again (Kernel > Restart Kernel…).
Also, we realize these cells will not render properly on the course website, but should work just fine in Binder or using the CSC notebooks. Sorry.
place = input("Where are you from? ")
print(place, "is a nice place!")

StdinNotImplementedError Traceback (most recent call last)
/tmp/ipykernel_280/1312562177.py in <module>
> 1 place = input("Where are you from? ")
2 print(place, "is a nice place!")
~/checkouts/readthedocs.org/user_builds/geopythonsite/envs/stable/lib/python3.7/sitepackages/ipykernel/kernelbase.py in raw_input(self, prompt)
1173 if not self._allow_stdin:
1174 raise StdinNotImplementedError(
> 1175 "raw_input was called, but this frontend does not support input requests."
1176 )
1177 return self._input_request(
StdinNotImplementedError: raw_input was called, but this frontend does not support input requests.
Let’s try another example in the cell below using the similar approach. Ask the user for a temperature in Celsius using the input()
function and print the input value to the screen.
temp_celsius = input("How cold can it be in Vantaa (in degrees Celsius)? ")
print(temp_celsius, "degrees Celsius is quite cold!")

StdinNotImplementedError Traceback (most recent call last)
/tmp/ipykernel_280/689777853.py in <module>
> 1 temp_celsius = input("How cold can it be in Vantaa (in degrees Celsius)? ")
2 print(temp_celsius, "degrees Celsius is quite cold!")
~/checkouts/readthedocs.org/user_builds/geopythonsite/envs/stable/lib/python3.7/sitepackages/ipykernel/kernelbase.py in raw_input(self, prompt)
1173 if not self._allow_stdin:
1174 raise StdinNotImplementedError(
> 1175 "raw_input was called, but this frontend does not support input requests."
1176 )
1177 return self._input_request(
StdinNotImplementedError: raw_input was called, but this frontend does not support input requests.
What is the data type of variable place
? What about the other variable you defined? Check their data types using the cell below.
print(type(place))
print(type(temp_celsius))

NameError Traceback (most recent call last)
/tmp/ipykernel_280/846213833.py in <module>
> 1 print(type(place))
2 print(type(temp_celsius))
NameError: name 'place' is not defined
What happens when you try to convert your Celsius temperature value to Fahrenheit using the equation from earlier in the lesson?
tempFahrenheit = 9 / 5 * temp_celsius + 32