
# This line is a comment where I explain that my next line of python code prints Hello world!
print("Hello world!")

Hello world!


# next line assigns the integer value 2 to the variable x
x = 2
# print the value of x
print(x)
# print the value of x + 3
print(x + 3)
# print the value of x - 1
print(x - 1)

# if we divide an integer, we get a float
print(x / 3)

# we can also have strings (either inside single quotes ' or double quotes ")
string_one = 'this is a '
string_two = "test string"
# strings can be combined using +
print(string_one + string_two)

2
5
1
0.6666666666666666
this is a test string


# here is how to check the type of a variable
print(type(x))

<class 'int'>


# as I told you, if we divide an integer, we get a float
print(type(x / 3))

<class 'float'>


# define an empty list
my_list = []
print("This is my empty list: ", my_list)

# each line adds the element inside parenthesis to the end of the list
my_list.append(200)
my_list.append("abc")
my_list.append(1.4)

print("This is my_list after appending elements: ", my_list)

print("The first element I have appended to my list is: ", my_list[0])
print("After that, I have appended: ", my_list[1])
print("If I don't remember how long my list is, I can use index -1 to get the last element: ", my_list[-1])

This is my empty list:  []
This is my_list after appending elements:  [200, 'abc', 1.4]
The first element I have appended to my list is:  200
After that, I have appended:  abc
If I don't remember how long my list is, I can use index -1 to get the last element:  1.4


# We can modify the list by replacing one element
my_list[1] = "6000"
print("Here is my list now: ", my_list)

# We can check how long the list is
print("My list has lenght: ", len(my_list))

# We can modify the list by removing one element
second = my_list.pop(1) # pop returns the element at the given index and removes it from the list
print("Popped list element: ", second)
print("Now this is my list: ", my_list)

Here is my list now:  [200, '6000', 1.4]
My list has lenght:  3
Popped list element:  6000
Now this is my list:  [200, 1.4]


my_tuple = (1, 2, 3, 'a', 'b', 'c')
print("My tuple has lenght: ", len(my_tuple))
print("The fourth element in my tuple is: ", my_tuple[3])


# We can define an empty dictionary
my_dict = {}

# We can add the key "my_first_key" associated with the integer value 1
my_dict["my_first_key"] = 1

# Keys can also be integers. Here we associate 3 to a string value
my_dict[3] = "the value associated to integer 3 is this string"

# Values can be any data type. Here the value is a list
my_dict["another_key"] = [1, 2, 3]

# We can print all the keys
print(my_dict.keys())

# We can print all the values
print(my_dict.values())

# We can print the entire dictionary
print(my_dict)


x = 10
if x > 15:
    print("x is greater than 15")
elif x > 10:
    print("x is greater than 10 but less than or equal to 15")
else:
    print("x is less than or equal to 10")


# Define a list of numbers
numbers = [1, 2, 3, 4, 5]

# Now iterate over all the element in the list
for num in numbers:
    # and for each of them, I print it
    print(num)


# Define a variable to have value 0
count = 0

# while the value of my variable is below 5, ...
while count < 5:
    # ...print the value of my variable
    print(count)
    # ...and add 1 to my variable
    count += 1
    # ...and then go up again and check if the value of my variable is still below 5

# if the value of my variable is 5 or more, we are done
print("Done!")


# Iterate over all the numbers from 0 to 10 (not including 10), ...
for num in range(10):
    # ...and if the number is 5,
    if num == 5:
        # ..then exit the loop
        break
    # ...if the number is a multiple of 2,
    if num % 2 == 0:
        # ...then continue without doing anything
        continue
    # next line is printed only if we are still inside the loop and the number is odd
    print(num)

else:
    # this line would only be printed if the for loop has finished without encountering break
    print("Loop completed successfully")


# here I define a function
# the function name is greet
# the function takes name as parameter
# I expect the parameter to be a string (name: str)
# I expect the function to return a string (-> str:)
# This explanation should better be in a docstring!
def greet(name: str) -> str:
    """
    This text inside the triple quotes is a type of comment, called docstring.
    A docstring should tell what the function does. Here, for example, we want
    to say that this function greets the user by name. Then we can specify the
    parameters and return of this function like this:
    :param name: str, a string with the name of the person we want to greet
    :return: a string with our greetings to the person
    ------------
    Example
    ------------
    >>> greet(name="Adam")
    Hello, Adam!
    """
    return f"Hello, {name}!"


# Let's call the function
print(greet("John"))


# We can also save the returned value of the function
my_greetings_message = greet("Michael")
print(my_greetings_message)  # Output: Hello, Michael!


# A function with default parameter set to "Guest"
# and no types specified
def greet_my_guest(name="Guest"):
    return f"Hello, {name}!"

# If a parameter has default value, we can use it in default mode
print(greet_my_guest())    # Output: Hello, Guest!

# But we can also specify a different value
print(greet_my_guest(name="Juha"))    # Output: Hello, Juha!


def my_generator():
    """
    This is a generator function that yields three values: 1, 2, and 3.
    :return: an integer
    """
    yield 1
    yield 2
    yield 3

# Create a generator object
gen = my_generator()

# When you call next() on the generator object, the code inside the generator function is executed
# until it encounters a yield statement. At that point, the value yielded by the yield statement is returned.
# to iterate over the generator. Subsequent calls to next(gen) resume execution from where it was paused
# until the next yield statement is encountered.
print(next(gen))  # Output: 1
print(next(gen))  # Output: 2
print(next(gen))  # Output: 3


def fibonacci():
    """
    A generator to generate an infinite sequence of Fibonacci numbers
    """
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

# Create a generator object
fib_gen = fibonacci()

# Print the first 10 Fibonacci numbers
for _ in range(10):
    print(next(fib_gen))


# Define a clas
class Car:
    # Class attribute
    wheels = 4

    # Constructor method (initializer)
    def __init__(self, make: str, model: str, year: int):
        # Instance attributes
        self.make = make
        self.model = model
        self.year = year

    # Instance method
    def drive(self):
        return f"{self.make} {self.model} is driving."

    # Instance method
    def honk(self):
        return "Beep! Beep!"

# Create two objects (instances) of the Car class,
# passing arguments to the constructor to initialize their attributes.
my_car = Car("Toyota", "Corolla", 2020)
your_car = Car("Honda", "Civic", 2018)

# Access attributes of an the object using dot notation (object.attribute).
print(my_car.make)  # Output: Toyota
print(your_car.year)  # Output: 2018

# Call methods of an object using dot notation (object.method()).
print(my_car.drive())  # Output: Toyota Corolla is driving.
print(your_car.honk())   # Output: Beep! Beep!

# Class attributes can also be accessed with dot notation
print(Car.wheels)  # Output: 4


# This code looks for a file named filename.txt, opens it in read mode ('r'),
# and iterates over its lines, printing each line to the console
with open('filename.txt', 'r') as file:
    for line in file:
        print(line.strip())  # strip() removes leading/trailing whitespace and newline characters


# next line imports the library needed to work with JSON objects
import json

# This code looks for a file named data.json, opens it in read mode ('r'),
# then deserializes it from JSON to a string
with open('data.json', 'r') as file:
    data = json.load(file)

# Print the parsed JSON data
print(data)


# next line imports the library networkx and assigns it the alias nx
import networkx as nx

# Create an undirected graph, that initially is empty
G = nx.Graph()

# Add nodes to our undirected graph
G.add_node(1)
G.add_nodes_from([2, 3])

# Add edges to our undirected graph
G.add_edge(1, 2)
G.add_edges_from([(2, 3), (1, 3)])

# Print graph information
print("Nodes:", G.nodes())
print("Edges:", G.edges())

Introduction to Jupyter¶

1. What is Jupyter?¶

2. How to work on a *.ipynb file¶

Aalto Jupyter Hub (strongly recommended)¶

Another option is installing Jupyter yourself (your own responsibility):¶

3. How to submit programming exercises in this course¶

4. Using Python in Jupyter¶

Python data types¶

Lists, tuples, and dictionaries¶

Control flow in python¶

Loops in python¶

Functions¶

Generators¶

Classes and objects¶

How to read data from files and how to use Python libraries¶