1-1 Python IDEs

VS Code, Spyder, PyCharm

For the development of larger data science projects, the package management platform Anaconda and the development and runtime environments Spyder, Visual Studio Code or PyCharm can be used, which provide extensive functionality for package management, software development and presentation.

Visual Studio Code

Microsoft's Visual Studio Code is a minimalist development environment that supports different programming languages ​​across platforms, including Python. The appropriate support is installed here through extensions. In particular, the Jupyter extension was installed for this tutorial in order to be able to structure the code into code blocks and run them separately in the interactive console. Development in Visual Studio Code is folder-based, i.e. you create a folder and scripts that belong together in it.

Spyder

Spyder is a Python development environment used primarily in data analysis projects. The current Spyder version 5.x has a modernized and more user-friendly interface compared to the previous version 4.0. Development in Spyder is project or folder based, meaning you can organize multiple Python scripts either in a project or as a loose collection in a folder.

2-2 Run a Python script

To run a Python program from Python source code, you need a Python interpreter. Development environments for Python such as Visual Studio Code, Spyder, PyCharm or Jupyter Notebook contain a Python interpreter and support the coding workflow with syntax highlighting, debugging functionality, etc.

A development environment such as the depicted Visual Studio Code typically has a default configuration of views / panels that support the development process: a file or project browser, a source code editor with syntax-highlighting and auto-completion, different panels for output, problems, console etc. You can run the entire script, or, if it is structured in code cells, you can run only the selected cells.

2-4 Statements and comments

A Python program is made up of statements and comments. Statements are: variable declarations, assignments, calculations, conditional statements, loops, function calls.

Comments

Python comments improve the comprehensibility of source code. Single-line comments begin with a "#" symbol followed by text. Multi-line comments must be surrounded by three double quotation marks at the beginning and end. If your Python script respects the usual programming conventions (variable and functions are named as what they are or do), it is sufficient to comment function definitions and complex parts of the code.

# Single-line comment
# Another comment

"""
Mult-line
comment
"""

Indentation

Python uses indentation and spaces to define blocks of code, i.e. to indicate related commands. Related code blocks typically appear in multiline commands such as in if-else, in loops, functions or classes. For example, the print-statements following the colon in line 2 belong to the if-part of an if-else statement and must be indented with the same number of spaces. The default number of spaces used for indentation is 4, but any number of spaces can be used, for example 2 or 3 is also allowed.

# Correct: line 3 and 4 are indented
if 4 > 0:
    print("Positive!") 
    print("4 is greater than 0") 
else:
    print("Negative!") 

# Incorrect: line 4 is indented
# only with 3 spaces
if 4 > 0:
    print("Positive!") 
   print("4 is greater than 0") 
else:
    print("Negative!") 

3-1 Declare variables

Variables are named memory locations in which the program's data is stored,for example name, year, x, y. The value of a variable can be changed and overwritten. Python has a built-in type inference, meaning that variables are declared as soon as they are assigned a value, e.g. x = 1, name = "HS KL".

Syntax

# Assignments: one per row
varname = varvalue
# Assignments: multiple per row
# Assignments: use comma as separator
varname1, varname2 = varvalue1, varvalue2

Example

Define variables by assigning values

# name has data type String
name = "HS KL"   
# jahr has data type Integer
jahr = 2022          
# Assignments: one per row
x = 1
y = 2
# or multiple per row
x, y = 1, 2 # x = 1, y = 2
# Print variable values to standard output
print(name, "\n", jahr, "\n", x, y)

The data type (integer, floating point number, string, etc.) of the variable is assigned automatically by Python and can be found out using the type statement.

3-2 Declare constants

A constant is a named memory space whose value should not be reassigned. Different from C and Java, Python has no syntactic support for constants such as a const keyword or preventing reassignment. Common practice is to use a variable with capital letters as constant, or to define all needed constants in a separate Python script, so as to make sure that their value is not reassigned accidentally.

Syntax

# Assignments: one per row
CONSTNAME = constvalue
# Assignments: multiple per row
# Assignments: use comma as separator
CONST1, CONST2 = constval1, constval2

Example

Define constants in their own module

Here we create a file myconstants.py in folder mypkg, where all our constants will be stored.

# mypkg/myconstants.py
MY_PI = 3.14
MY_E = 2.71

# myscript.py
from mypkg import myconstants
print(myconstants.MY_PI)

Yet another workaround for using constants in Python is to define a tuple data structure that contains the needed constants, as described in section 7-2.

3-3 Data types and typecasting

Python uses internally data types for integers (int), floating point numbers (float), truth values ​​(bool), characters and character strings (str), as well as data structures for lists and sets. Different from C or Java, there is no data type double, instead, floats are stored using double precision (64 bit).

The data type of a variable is usually specified implicitly when a value is assigned, but it can also be specified explicitly by typecasting if required, by writing the desired data type in front of the name of the value and enclosing it in parentheses, e.g. x = float(5) or x = str("Hello!").

Syntax

# Specify data type explicitly
varname = datatype(varvalue)
# Find out data type of varname
type(varname)

Example 1

Numeric variables and typecasting

# Data type of variable x ... 
# ... is implicitly int
x = 5
print(type(x)) # Output: class'int'
# Data type of variable x ... 
# ... is set explicitly to float
x = float(5) 
print(type(x)) # Output: class'float'

Example 2

String variables

The data type String describes texts or sequences of characters. For a string x you get the first element with x[0], the last element with x[-1], the characters from i inclusive to j exclusive with x[i:j].

x = "Hello!"
print(x[0]) # H
print(x[-1]) # !
print(x[1:6]) # ello!
print(x[-4:-1]) # llo
print(len(x)) # length = 6
x = " Hello from Kaiserslautern "
print(x.strip()) # Strip blank spaces

3-4 Operators and calculations

Calculations are performed by linking variables to expressions using operators (+, -, *, /, %, ...), taking into account the priority of the operators.

Python has operators for abbreviating assignment (+=, *= etc.), comparison operators (==, !=, >, <, >=, <= ) and logical operators (&&, ||, !). When evaluating an expression that involves comparison or logical operators, the result is one of the boolean values, i.e. True or False.

Example 1

Calculate expressions using different operators

In this synthetic example we calculate expressions using different operators: abbreviating assignment (+=, *=), modulo (%), division (/) and integer division (//).

a, b, c = 25, 3, 0 # a = 25, b = 3, c = 0
# Abbreviating assignment
a += 1 # a = 26
b *= 2 # b = 6
# Modulo-operator
c = 17 % 5; # c = 2
# Division with and without rest
res = a / b + a // b  # res = 4.33 + 4 = 8.33
print("a = %d, b = %d, res = %.2f" % (a, b, res));
# Comparison and logical operators
cond1 =  (a == (b + 20)) # True: 26 = 6 + 20
cond2 = (a < b) # False: 26 is not less than 6
cond = cond1 and cond2
print(cond1, cond2, cond) # True False False

Example 2

Calculate the area of a triangle with sides a, b, c

Here we calculate the area of a triangle with sides a, b, c. We need the sqrt-function from math package to calculate the square root of an expression.

import math
a, b, c = 10, 20, 20
S = (a + b + c) / 2
F = math.sqrt(S*(S-a)*(S-b)*(S-c))
print("Area =", F)

4-1 Output with print()

In Python, output to the console is done using the print function, which has two optional parameters: sep and end, used to specify a separator for the objects and an end character. For formatted output, variables can be inserted into a formatting character string using format characters, in a C-like style.

Syntax

Print a list of objects with separator and end

print(object1, ...,  objectn, sep = ';', end = '');

Formatted output (C-Style)

print(formatting_string % (variable_list))

Formatted output with print and format

print(formatting_string.format(variable_list))

Example 1

Output objects using sep and end

# Output: 5;20.5 // 5:20.5
x, y = 5, 20.5
print(x, y, sep=';', end=' // ')
print(x, y, sep=':')

Example 2

Formatted output

Each data type has appropriate formatting characters: %d or %i for int (integers), %f for float (single-precision floating-point), %lf for double (double-precision floating-point).

# Output: x=5, y=20.5, sum=25.50
x, y = 5, 20.5
sum = x + y
# (1) Formatted output of a text
print("x=" + str(x) + " y=" + str(y) + " sum=" + str(sum)) 
# (2) Formatted output with placeholder (C-Style)
print("x=%d, y=%.1f, sum=%.2f" % (x, y, x + y))
# (3) Formatted output with format
print("x={0:d}, y={1:.1f}, sum={2:.2f}".format(x, y, x+y))

4-2 Input with input()

Input from the Python command console or in a Jupyter Notebook cell is done using the "input()" function. The command x = input() creates an input field, and whatever you type in it is stored in the variable x. In order to interprete input as a specific data type, it must be converted using an appropriate function (e.g. int() or str()).

Syntax

input()

# Print prompt text, then read input in next line
print(prompt_text)
var = datatype(input()) 
# Prompt text and input in same line 
var = datatype(input(prompt_text))  

Example 1

Prompt text and input on different lines

In this example, two numbers are entered, one integer and one float.

# Read input from console
print("Enter an integer number")
x = int(input())  
print("Enter a decimal number")
y = float(input())
# Formatted output
print("Your input: x = %d, y = %f" % (x, y))

Example 2

Prompt text and input in same line

This is the same example as before, written in a more concise form.

# Read the input from console
x = int(input("Enter a number: "))  
y = float(input("Enter another number:"))
# Formatted output
print("Your input: x = %d, y = %f" % (x, y))

5-1 If-else statement

The if-else statement is a multiline statement that is executed as follows:
if condition1 is true, then execute statements1,
else if condition2 is true, then execute statements2,
and so on.
The elif keyword in Python means: "if the previous conditions don't apply, try this condition" and the else keyword catches everything that isn't caught by the previous conditions.

Syntax

If-else Statement

if condition1:
    statements1 
elif condition2:
    statements2 
[...] # Add elif-branches as needed 
else:
    default_statements 
print('Done!')

Example

Calculate an interest rate depending on amount of money

What interest rate is calculated for amount = 20000?

amount, rate = 10000.0, 0.0
if amount > 50000:
    rate = 1.0
elif amount > 10000:
    rate = 0.5
elif amount > 0:
    rate = 0.2
else :
    rate = -0.2
print(rate)

5-2 Match case-statement

The match-case statement is used when there are many different cases and the implementation via if-elif-elif-elif...else statement would be cumbersome. It is similar to the switch-case statement provided by C-like languages, with additional support for matching patterns, hence the different name.

Syntax

match-case

The match-case statement compares the value of an expression to the values or patterns specified in the different case-blocks. From all the specified cases, only the first matching case is executed. A match statement usually contains a default case specified with underscore, that is executed when none of the cases match.

match expr:
    case value1:
        # Do something
    case value2:
        # Do something else
    [...] # More cases
    case _:
        # Provide a default case

Example

Print a text message according to user input

In this example the user is asked to make a choice by typing a number. The program then prints a message according to the number that has been entered.

ch = int(input("Enter a choice: 1, 2 or 3: ")) 
match ch:
    case 1:
        print("First choice")
    case 2:
        print("Second choice")
    case 3:
        print("Third choice")
    case _:
        print("Invalid choice!")

6-1 While Loop

A while loop allows statements to be executed repeatedly, as long as an execution condition is met.

Syntax

while condition :
  statements

Example 1

Print list of students

The counter variable that is queried (here: "i") in the condition must incremented explicitly in the loop body (here: i+=1), else the loop condition will be always true and the execution of the loop will not stop until your script runs out of memory.

students = ["John Doe", "Jane T.", "Mad Max"] 
i = 0
while i < len(students):
    print(students[i])
    i+=1

Example 2

Calculate sum of first numbers using while

n = 5
sum = 0 # This variable will store the sum
i = 1 # Initialize counting variable i
while i <= 5:
    sum += i # Add counting variable to sum
    i += 1 # Increment counting variable
print("Sum = ", sum)

Example 3

Infinite loop stopped with break

counter = 1
while (True):
    print(counter,  ':')
    counter += 1
    if (counter == 10):
        break

6-2 For-Loop

For loops are used to iterate over the elements of a sequence (list, tuple, set, etc.). The syntax of the for loop requires to use the member operator "in".

C-like for loops that specify a start and end condition and an increment for a counter variable must be rewritten in Python using the range() function, as in the example below. This type of for loop is used less often in Python, since you often work with objects and, as in Example 1, you can use the in operator to iterate over the elements of a list or set.

Syntax

# Using iterator
for element in list:
    statements
# Using a counter variable and range()
for i in range(n):
    statements

Example 1

Print list of students

students = ["John Doe", "Jane T.", "Mad Max"] 
for std in students: 
    print("Student: " +  std) 

Example 2

Calculate sum 1 + 2 + ... + 5

n = 6
sum = 0
for i in range(1,n):
    sum += i
print("Sum = ", sum)

Example 3

For-loop with continue

With continue you can skip loop steps depending on a condition. In this example, we skip all students whose names start with 'J'.

students = ["John Doe", "Jane T.", "Mad Max"] 
for std in students: 
    if (std.startswith('J')):
        continue
    print(std) 

8-1 Define and use functions

A function first is defined by using the keyword def, followed by a function name (here: my_func) and a comma-separated list of parameters that is surrounded by round brackets. Parameters can be positional or keyword parameters. A function then is used / called where needed by specifying its name and a list of arguments.

Syntax

Definition and usage of a function

# Define the function my_func
def my_func(param_1, param_2, ... param_n):    
    # TODO: here goes the function body  
# Use the function my_func      
my_func(arg_1, arg_2, ..., arg_n)
my_func(param_n = arg_n, ..., param_1 = arg_1)

Example: Function for prettifying output

Function separator_line()

In this example we define a function separator_line() for prettifying console output. The function has three parameters: symbol1, symbol2 and n, so that we can create separator lines with different symbols and different lengths.

# Define the function separator_line
def separator_line(symbol1, symbol2, n):  
    print(symbol1*n, end = '')
    print(symbol2*n, end = '')
    print(' ')   
# Use the function separator_line      
separator_line('<', '>', 4)	# Output: <<<>>> 
separator_line('*', '*', 3) # Output: ******

Positional and keyword arguments

In Python, function parameters are specified using position and / or keyword:
1. By position means: by providing argument values in the correct position of the list. In this case, number and order of the arguments must match the parameter list: separator_line('<', '>', 4).
2. By keyword means: by providing parameter name - parameter value pairs, then the order can be switched: separator_line(symbol1='<', symbol2='>', n=4).

Variable scope

Any variable defined within a function is a local variable: it can be used only within that function. Variables defined outside functions are called global variables, they can be used in any function.
A global variable defined outside a function must be refered using the global-keyword within the function, so that it can be used there.

Example

Global and local variables

This example defines a function counter(), that counts how often it has been called. When calling the function the first time, it prints "1. Call", the second time, it prints "2. Call" and so on.
Line 1: The variable count is initialized with 0. It is a global variable, because it is defined outside the function body.
Line 3: In the function body, refer to the global variable using the keyword global. This way, you can change the value of the global variable in the function.
Line 4: Now we can change the value of the global variable count by incrementing it.

count = 0 # Global variable
def counter(param1 = '.Call'):
    global count # Declare count as global
    count = count + 1
    print(count, param1)

counter() # Output: 1. Call
counter() # Output: 2. Call
counter() # Output: 3. Call

8-2 Functions with return value

Functions with return value calculate a new non-null value from their input parameters and return this value via the keyword "return". This value can be used in the calling function in further calculations. Many mathematical and statistical functions are of this type, they take one or more parameters as input and return a value, such as the sin-function: y = sin(x) or the two-dimensional function from the next example.

Syntax

Function with return value

# Define the function my_func
def my_func(param_1, param_2, ... param_n):    
    # TODO: enter your statements here  
    ret = calculation involving param1 ... 
    return ret
# Use the function my_func      
ret1 = my_func(arg_1, arg_2, ..., arg_n)
ret2 = my_func(arg_1, arg_2, ..., arg_n)

Example: Define a mathematical function

f(x,y) = sin(pi*x)*exp(-y), if x < 0
            cos(pi*x)*exp(-y), if x > 0

In this example we define a mathematical function that returns different combinations of sin- and exp-function, depending on the sign of its first parameter x. The parameters x and y must be numbers: this function will not work for parameters x, y that are lists.

# (1) Define the function f
from numpy import pi, sin, cos, exp
def f(x, y) :
    z = 0
    if x > 0: 
        z = sin(pi*x)*exp(-y)
    elif x < 0:
        z = cos(pi*x)*exp(-y)
    return z
# (2) Use the function f
z1 = f(1/4, 0); print("z1 = ", z1) #  z1 = 0.70
z2 = f(1/2, 1); print("z2 = ", z2) # z2 = 0.36
z3 = f(0, 0); print("z3 = ", z3)   # z3 = 0
print ("z=", z) # Error, z is not defined!

In Python, if a function should accept list parameters, you must vectorize it first using NumPy's vectorize.

import numpy as np 
# Use vectorized form of function f
fvec = np.vectorize(f)
z = fvec([pi/4, pi/2], [1, 2]); print(z)

Lambda functions

Lambda functions are a type of inline functions that can be defined in just one line and used for small code fragments . Assume you need the function f(x) = sin(2*x)*exp(-x) repeatedly in your code. Instead of writing a multi-line regular function definition with def, you can just write the following one-line lambda function:

import math
f = lambda x: math.sin(2*x)*math.exp(-x)
y1 = f(1.57); y2 = f(2);
print(y1, y2)

8-3 Docstrings: Function comments

Functions should be commented using docstrings, so as to provide the necessary information about what the function does and how to use it. In Python, docstrings are created by enclosing a documentation text in three double quotes in the second line of the function definition, that is, after the colon. This docstring is read by the Python help system, and when you type help(function_name), is printed to standard output.

Syntax

Docstring

The general syntax for a docstring includes: (1) a short description of what the function does and (2) the role and data types of the parameters and return value.

# Define the function my_func
def my_func(param_1, param_2, ... param_n):    
    '''
    This function does this and that ... 
    @param param1: represents this and that 
    @return ret: the return value represents ... 
    '''   
    # TODO: enter your statements here  
    ret = calculation involving param1 ... 
    return ret

Example

Python Docstring, Doxygen-style

In this example we write a docstring for the function separator_line() and specify the parameters with Doxygen annotations.

# Define the function separator_line
def separator_line(symbol1, symbol2, n):  
    '''
    This function creates a separator line with 
    n times symbol1 and n times symbol2
    @param symbol1 (str): first symbol
    @param symbol2 (str): second symbol
    @param n (int): number of repetitions
    '''   
    print(symbol1*n, end = '')
    print(symbol2*n, end = '')
    print(' ')   
# Get help on the function
help(separator_line)

8-4 Annotations

As an advanced feature, Python allows to add additional information to functions via annotations. Annotations can be used to specify the required data types for function parameters and return values. They do not enforce a given data type and are used only as a hint to the programmer. The annotations of a function are printed using the syntax function_name.__annotations__.

How to write annotations:
Parameter annotations: After each parameter, write a colon, followed by the annotation .
Return value annotation: After the parameter list, write an arrow "->", followed by the annotation.
The annotations must be a valid Python expressions.

Example

Function with annotations

In this example, we use annotations to specify the expected data type of the parameters and return value of a function to_currency(). Specifically, we use the name of the required data type as annotation, but we could have also used string constants, for example
def to_currency(amount: "integer", curr: "string") -> "string":

# Define the function
def to_currency(amount: int, curr: str) -> str:
    '''
    Function returns amount formatted as currency
    @param amount: amount of money as integer
    @param currency: currency as string
    @return Returns amount + currency as string
    '''   
    return str(amount) +  curr

# Use the function
print(to_currency(1000, '$'))
print(to_currency(1000, '€'))
# Show the annotations
print(to_currency.__annotations__)

Output in Visual Studio Code is as shown in the screenshot.

9-2 Class inheritance in Python

With class inheritance we can define classes that inherit all the methods and properties of another class.

The class that is inherited from is called the base class. The class that inherits properties and methods from the base class is called a subclass. In Python, a subclass is defined by placing the base class name in parentheses after the class name.

Example

Student inherits from Person

Persons have a name and a birth date. Students are Persons, that additionally have a semester, indicating in which term of their study they are.

(1) Define base class and subclass

How do we map this knowledge with classes and inheritance? We define a base class Person with attributes name and birthdate and a subclass Student with attribute semester. Since the subclass inherits the properties and functions of its base class, we do not have to redefine name and birthdate in the subclass, only the additional property semester and the additional method inc_semester().

• * Line 2-9: Define base class Person. The to_string()-method of the base class Person takes as parameter a label and builds a string output from the properties of the Person.
• * Line 11-19: Define subclass Student. In line 11, the initialization method of the base class is called with super.__init__(). In line 13, the property semester is set, which only belongs to the subclass.
• * Line 17-19: Define the to_string() method of class Student. Note that we have a to_string()-method in both base class and subclass. The method to_string() defined in the subclass calls the base class method with the same name using the super()-keyword and then appends the semester attribute to the string.

# Define base class Person
class Person: 
    def __init__(self, name, birthdate):
        self.name = name
        self.birthdate = birthdate
    def to_string(self, label):
        mystr = label + ": " + self.name
        mystr += ", Birth date: " + self.birthdate
        return mystr
# Define subclass Student      
class Student(Person): 
    def __init__(self, name, birthdate, semester):
        super().__init__(name, birthdate)
        self.semester = semester
    def inc_semester(self):
        self.semester += 1
    def to_string(self, label):
        mystr = super().to_string(label)
        return  mystr + ", Sem: " + str(self.semester)

(2) Use base class and subclass

After we have defined base class and subclass, we can use them to create new Persons and Students and manipulate their data.

# Use base class and subclass
pers1 = Person("Alice First", "01.01.1980")
# P1: Alice First, Birth date: 01.01.1980
print(pers1.to_string("P1"))
std1 = Student("Bob Second", "01.02.1990", 1) 
# S1: Bob Second, Birth date: 01.02.1990, Semester: 1
print(std1.to_string("S1")) 
std1.inc_semester();
print(std1.to_string("S1"))