What is Anaconda?

If you intend to use lots of scientific packages, you can install Anaconda or Miniconda as an alternative. numpy / scipy / sympy / tensorflow / ... usually work out of the box with Anaconda, especially on Windows.

• conda is the package manager used by Anaconda, pulling packages from anaconda.org

Installation

Jupyter Notebooks are the "classic" notebooks and Jupyter Labs is the new IDE-like successor of them.

pip install jupyter jupyterlab

# or, if that doesn't work
python -m pip install jupyter jupyterlab

Usage

You may want to open *.ipynb notebook files directly within VS Code or PyCharm. Alternatively, you can start a stand-alone instance in the browser from the command line.

python -m juypter notebook [--notebook-dir <path>]
python -m jupyter lab [--notebook-dir <path>]

Try it now

📜 ./python/m02_jupyter_introduction.ipynb

What do we notice here?

• There are no semicolons ;
• There are no types
• There are no braces { } but blocks that are started by a colon :
• There are no parentheses ( ) around the expressions
• A list - one of many built-in types in Python - is initialized with square brackets [ ]
  ... actually, there are no arrays in Python
• The for and if syntax is slightly different
• Comments are written with the hashtag symbol #

Python is dynamically-typed

Unlike Java, you can re-assign values of different types to the same variable as you wish. **

x = 1416787301
x = "is"
x = True

** Speaking in the notion of "tags" and "names", this means that you can freely re-assign the "tag" or "name" to point to a different location.

my_int = 5
my_float = 3.141
my_complex = 1 + 2j

# there are also some useful ways to write numbers
speed_of_light = 299_792_458
us_national_debt = 28.9e+12
ascii_symbol = 0x3f
input_bitmask = 0b1011_1001

# ./python/m04_arbitrary_precision_integers.py

lightyear_to_meter = 9_460_730_472_580_800
min_milky_way_diameter = 170_000 * lightyear_to_meter

min_milky_way_diameter_plus_one = min_milky_way_diameter + 1

print("Woooooow, the milky way is at least", min_milky_way_diameter, "meters in diameter!")
print("Adding one meter on that, we are at", min_milky_way_diameter_plus_one, "meters.")

# > Woooooow, the milky way is at least 1608324180338736000000 meters in diameter!
# > Adding one meter on that, we are at 1608324180338736000001 meters.

# ./python/m04_mathematical_expressions.py

x = 10.5
y = -3

print("x + y =", x + y)                  # addition
print("x - y =", x - y)                  # subtraction
print("x * y =", x * y)                  # multiplication

print("x / y =", x / y)                  # normal division
print("x // y =", x // y)                # integer division
print("x % y =", x % y)                  # modulo

print("abs(y) =", abs(y))
print("int(x) =", int(x))                # convert to integer
print("float(y) =", float(y))            # convert to float
print("complex(x, y) =", complex(x, y))  # convert to complex

print("pow(x, 3) =", pow(x, 3))          # exponentiation
print("x ** 3 =", x ** 3)                # exponentiation (alternative syntax)

# ./python/m04_mathematical_functions.py

# we use function from this built-in package
import math

print("sqrt(16) =", math.sqrt(16))
print("5! =", math.factorial(5))
print("log(e) =", math.log(math.e))
print("sin(pi / 2) =", math.sin(math.pi / 2))

first_string = "Hello World"
second_string = 'Hello Python'

multi_line_strings = """This can even
hold line breaks
now"""

String Conversion

Many types in Python can be converted to a string with str() - similar to .toString() in Java.
As seen in the example, if you concatenate a string with a non-string, you even have to. **

// ./java/M04_StringConversion.java#L3-L4

int num = 42;
System.out.println("The number is " + num);

# ./python/m04_string_conversion.py

num = 42
print("The number is " + str(num))

# alternative, which ONLY works for print()
print("The number is", num)

# print("The number is " + num)
# 💥 TypeError: can only concatenate str (not "int") to str

# ./python/m04_boolean_expressions.py

x = True
y = False

print("x or y =", x or y)    # logical or
print("x and y =", x and y)  # logical and
print("not x =", not x)      # logical not

Bitwise Expressions

You can also perform binary computations with bitwise operators.
Find them all at docs.python.org/3/library/stdtypes.html#bitwise-operations-on-integer-types

# ./python/m04_bitwise_expressions.py

port    = 0b1011_1011
bitmask = 0b0010_0000

is_bit_set = port & (bitmask >> 1)

# we learn more about formatting in the next module ...
print("dec:", is_bit_set)
print(f"bin: {is_bit_set:08b}")

# > dec: 16
# > bin: 00010000

# ./python/m05_list_operations.py#L1-L15

numbers = [1, 2, 3, 4, 5]
names = ["Janine", "Ali", "Alice"]
mixed = [1, 2, "Max", 3.141]


names[0]                # get element by index
names[0] = "Peter"      # set element at index

names[-1]               # use negative indexes to count from the end

names.append(-5)        # add element to the end of the list
names.insert(1, "Bob")  # add element at specific index

names.remove(-5)        # remove the first occurrence from the list
del names[0]            # remove by index

What do we notice here?

• Collections in Python are allowed to contain mixed types of data

# ./python/m05_list_operations.py#L18-L26

"Alice" in names        # check for existence
"Mario" not in names    # ... and non-existence

numbers.count(1)        # the number of times this item is in the list
len(numbers)            # total number of elements in the list

# merge two lists into one
merged = [1, 2, 3] + [4, 5, 6]

pair = ("Jonas", 12)  # create a tuple
pair[0]               # get element by index, similar to lists

💡 Tuples are always immutable!

You can NOT modify, append, or delete anything from them after you created one.

# pair[1] = 13
# 💥 TypeError: 'tuple' object does not support item assignment

# pair.append(123)
# 💥 AttributeError: 'tuple' object has no attribute 'append'

However, you can convert tuples to lists.

numbers = (10, 11, 12)
list(numbers)

# and back again ...
letters = ["A", "B", "C"]
tuple(letters)

# ./python/m05_destructuring.py

x, y = 1, 2
print(x, y)

# > 1 2


numbers = [1, 2, 3]
x, y, z = numbers

print(x, y, z)

# > 1 2 3


pair = ("Jonas", 12)
name, age = pair

print(name, age)

# > Jonas 12

What do we notice here?

• Actually, whenever you use a comma , in such contexts, a tuple is used implicitly.

# ./python/m05_dict_operations.py

grades = {
    "math": 2,
    "programming": 1,
    "literature": 3
}

# alternative syntax
grades = dict(math=2, programming=1, literature=3)


grades["math"]             # get elements by key
grades["math"] = 5         # set elements by key
grades["electronics"] = 4  # add a new element

# remove an element (will raise an error if the key does not exist)
if "math" in grades:
    del grades["math"]

grades.keys()              # get all the keys as a list
grades.values()            # get all the values as a list

# ./python/m05_set_operations.py#L1-L10

numbers = {1, 1, 2, 3, 5}  # notice how the '1' is only appended once after all

numbers.add(7)             # add new elements
numbers.add(1)             # add elements that already exist (no effect)

1 in numbers               # check for existence (much faster than with lists)

# remove elements (will raise an error if the element does not exist)
if 2 in numbers:
    numbers.remove(2)

💡 You can NOT retrieve elements by index from a set!

# numbers[0]
# 💥 TypeError: 'set' object is not subscriptable

You must iterate over them or convert the set to a list with list(elements)

# ./python/m05_set_operations.py#L12-L14

# iterate over set elements
for val in numbers:
    print(val)

# ./python/m05_set_arithmetic.py

a = {1, 2, 3, 4, 5}
b = {4, 5, 6, 7, 8}

print("a | b =", a | b)  # union
print("a & b =", a & b)  # intersection
print("a - b =", a - b)  # difference

# > a | b = {1, 2, 3, 4, 5, 6, 7, 8}
# > a & b = {4, 5}
# > a - b = {1, 2, 3}

# ./python/m06_input.py#L1-L2

name = input("Please enter your name: ")
print("Your name is", name)

💡 Don't forget data type conversions!

# ./python/m06_input.py#L4-L11

# this function will always give you a string
number = input("Please enter a number: ")

as_int = int(number)
as_float = float(number)

print(as_int, as_float)

# ./python/m06_output.py#L1-L14

pi = 3.141

print(pi)
print()
print("The value of pi is", pi)

# > 3.141
# >
# > The value of pi is 3.141

print("I hate: ", end="")
print("line breaks")

# > I hate: line breaks

# ./python/m06_output.py#L17-L19

print(f"The value of pi is {pi} and the value of tau is {2 * pi}")

# > The value of pi is 3.141 and the value of tau is 6.282

# ./python/m06_number_formatting.py

pi = 3.14159265359
print(pi)

# > 3.14159265359

print(f"{pi:.0f}")     # no decimal places
print(f"{pi:.2f}")     # two decimal places
print(f"{pi:.3e}")     # scientific notation

# > 3
# > 3.14
# > 3.142e+00

ratio = 0.25
print(f"{ratio:.1%}")  # percentage

# > 25.0%

# ./python/m06_file_io.py#L3-L11

filename = "m06_file_io.txt"

with open(filename, "w+") as f:
    f.write("Hello\n")
    f.write("File!\n")

with open(filename, "r") as f:
    for line in f.read().splitlines():
        print(line)

What do we notice here?

• Python has no switch expression, you have to make a cascade of if / elif / else statements *

* Actually, if you are using Python 3.10 or newer, there are the new match and case statements now.

What do we notice here?

• Reading from user input is done with input() and can also output a prompt
• The while loop also exists in Python
• We use an explicit integer division // in Python, but use a normal division / in Java

# unlike Java, a division will alwasy give you a float data type
assert 5 / 2 == 2.5

# unless you want an explicit integer division
assert 5 // 2 == 2

* assert will raise an AssertionError if the condition is False - use it to check assumptions in your code.

What do we notice here?

• Iteration over a list of elements is quite similar in Java and python

What do we notice here?

• Python only supports the x in y syntax with a for loop
• To replicate the behavior you might know, you have to use range(start, stop),
  which will give you numbers from start to stop - 1

💡 Actually, range() will give you an iterator!

If you really want the numbers in a list, you have to convert the result.

# iterators only allow getting the next element with next()
range(5, 8)

# lists allow arbitrary access by index
list(range(5, 8))

# ./python/m07_sequence_slicing.py#L1-L5

numbers = [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

numbers[5:8]   # give me a new COPY of the list, starting at index 5, and ending at index 7

# > [15, 16, 17]

The following variants are supported:

• a[start:stop:step]
• a[start:stop]
• a[start:]
• a[:stop]
• a[:]

The stop index is always exclusive, i.e. the element at index stop is not part of the resulting slice.

numbers = [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

# ./python/m07_sequence_slicing.py#L7-L14

numbers[1:]    # all except the 1st item    > [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
numbers[:3]    # the first three items      > [10, 11, 12]

numbers[:-1]   # all except the last item   > [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
numbers[-2:]   # the last two items         > [19, 20]

numbers[::2]   # every 2nd item             > [10, 12, 14, 16, 18, 20]
numbers[1::2]  # every 2nd, but start at 2  > [11, 13, 15, 17, 19]

This also works with strings because they are just a list of characters.

# ./python/m07_sequence_slicing.py#L17-L20

name = "Hello World"
name[1:-1]

# > 'ello Worl'

# ./python/m07_sequence_reversing.py

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# iterator that iterates the list in reverse order
reversed(numbers)

# reverse the list in-place
numbers.reverse()

# slice a reversed copy of the elements
numbers[::-1]

# ./python/m07_sequence_sorting.py

numbers = [1, -10, 20, 11, 19, 0, -5, -1000, 100, 7]

# get a sorted list of the elements
sorted(numbers)
sorted(numbers, reverse=True)

# sort the list in-place
numbers.sort()
numbers.sort(reverse=True)

What do we notice here?

• Our loop iterates over two values now - enumerate() creates tuples for us here

💡 List Comprehension

List comprehensions map each value in a list to a new value and thus create a new list. *

[x for x in sequence]

# ./python/m07_price_tax.py#L11-L12

prices = [12.3, 5.2, 8.7, 1.2, 8.0]
gross = [price * 1.2 for price in prices if price > 8]

* Python offers a lot of features for functional programming, like map / filter / reduce / zip / all / any / ...

What do we notice here?

• Functions are defined with def
• Python does not have any access modifiers nor the static keyword
• You don't have to specify any types on the function parameters - this is called duck-typing

You can specify argument names explicitly - and even change their order.

# ./python/m08_rectangle_functions.py#L17-L18

area(a=2, b=5)
area(b=5, a=2)

You can specify default values for arguments.

# ./python/m08_function_differences.py#L1-L12

def function_with_default_args(x, y, name="Unknown User", factor=1.2):
    result = x * y * factor
    print(f"Hello {name}, your result is {result}")


function_with_default_args(1, 2)
function_with_default_args(1, 2, name="Mario")
function_with_default_args(1, 2, factor=10)

# > Hello Unknown User, your result is 2.4
# > Hello Mario, your result is 2.4
# > Hello Unknown User, your result is 20

# ./python/m08_function_differences.py#L15-L30

def function_with_two_return_values(radius):
    pi = 3.14159

    circumference = 2 * pi * radius
    area = pi * radius ** 2

    return circumference, area


c, a = function_with_two_return_values(5)

print("circumference", c)
print("area", a)

# > circumference 31.4159
# > area 78.53975

Constructors

• There is only one constructor that is called __init__ with a mandatory self parameter
• Python does not support constructor overloading or method overloading
• We don't explicitly define the class properties first_name and last_name,
  but you create them on-the-fly in the constructor or elsewhere

Functions and methods

• What makes a function a method is only governed by the explicit self parameter
• You must always use self. if you want to access class properties
• There are no access modifiers and there is also no final in Python

Static methods

• A static method needs the @staticmethod decorator and omits the self parameter
• A static method just means that it won't access any class properties

Instantiation

• Creating a new object works similar, but you omit the new keyword
• The main method in Python is actually a condition - we will learn more in the next modules

What do we notice here?

• There is no interface type in Python, instead we use a normal class and inhert from it
• Methods are overridden without an explicit annotation - they are always replaced
• No type checks are enforced by Python, try removing Shape or renaming the area() method ...

# ./python/m09_shapes_duck_typing.py

class Circle:
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14159 * self.radius * self.radius


class Square:
    def __init__(self, length):
        self.length = length

    def area(self):
        return self.length * self.length


shapes = [Circle(5), Square(10)]
for shape in shapes:
    print(shape.area())

The Main "Function"

The __main__ condition that you write, will only evaluate to True when that script is executed directly.

# ./python/m10_multiple_scripts/main.py#L5-L6

if __name__ == "__main__":
    print("This will only run if you specifically started the interpretor on this file.")

With that, you mainly differentiate if a script is run directly, or being imported.
Upon import, the __main__ condition of the importee will evaluate to False.

# ./python/m10_multiple_scripts/imports.py

import main

# you might also want to try out these:
# import script
# from main import test_variable

if __name__ == "__main__":
    print("The value of the test variable is:", main.test_variable)

Dependencies are usually listed in a requirements.txt file and are installed with pip. *

python -m pip install -r requirements.txt

Running Python Modules

You run modules when your code consists of multiple files.

When you run a module, your root package is loaded into the import path of the interpreter.
Thus, on each import statement you write, packages and modules will be found and imported.

python -m pip install <package-name>

Compute and show a parabola with numpy and matplotlib

# ./python/m11_numpy_demo.py

import matplotlib.pyplot as plt
import numpy as np

# get 1000 numbers between -5 and 5
xs = np.linspace(-5, 5, 1000)

# apply a function on this numpy array
ys = xs ** 2 - 1

# show a figure
plt.plot(xs, ys)
plt.show()

Read a tabular dataset with pandas

# ./python/m11_pandas_demo.py

import pandas as pd

# quickly read a csv file
df = pd.read_csv("https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data")
print(df)

If you ever need help, type help - use the resources mentioned in the beginning - or, ask Google.

help(sorted)

# > Help on built-in function sorted in module builtins:
# >
# > sorted(iterable, /, *, key=None, reverse=False)
# >     Return a new list containing all items from the iterable in ascending order.
# >
# >     A custom key function can be supplied to customize the sort order, and the
# >     reverse flag can be set to request the result in descending order.

And also try out this one.