1-2 Python IDEs

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.

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.

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.

2-2 Run a Python program

To run a Python program from Python source code, you need a Python interpreter. Development environments for Python such as Spyder, Visual Studio Code, 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, Comments, Indentation

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

Comments

Python comments serve to improve the readability and comprehensibility of source code, they are not executed by the system. 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.

# 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 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 x = input() command creates an input field, and whatever you type in it is stored in the variable x. If the input is to be interpreted as a specific data type, it must be converted using an appropriate function (e.g. int() or str()). Example: In the following example, two whole numbers are entered and formatted for checking.

Syntax

# 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

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

Example 2

Prompt text and input in same line

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

5-1 If-else Statement

The if-else statement is a multiline statement that reads 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 is just like: "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 
elif conditions3:
    statements3 
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 Switch-case like statement

The switch-case statement provided by C-like languages offers support for situations where you have many different cases and the implementation via if-elif-elif-elif...else statement would be cumbersome. Python has no similar support for many case distinctions. In Python, as a workaround for switch-case, you can use function wrappers for dictionaries or, in newer Python versions, the more general concept of regular expression matching.

Syntax

Switch-case via a dictionary

def switch_case(argument):
    switch_dict = {
        case1: label1,
        case2: label2,
        case3: label3,
    }
    return (switch.get(argument, default_label))

Example

Text output depending on choice

def switch_case(argument):
    switch = {
        1: 'First Choice',
        2: 'Second Choice',
        3: 'Third Choice',
    }
    return (switch.get(argument, 'Default: Invalid'))
case = switch_case(2) 
print(case) # Output: Second Choice
case = switch_case(100)
print(case) # Output: Default: Invalid

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 the sum 1 + 2 + ... + 5

sum = 0
i = 1
while i <= 5:
    print(str(i) + "+")
    sum += i
    i += 1
print("Summe = " + str(sum))

Example 3

Infinite loop stopped with break

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

5-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

sum = 0
for i in range(1,6):
    print(str(i) + "+")
    sum += i
print("Sum = " + str(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 Functions with empty parameter list

A function with empty parameter list is simply a named group of statements, that is defined once and can be called multiple times.

Syntax

A function is defined by the keyword def and a function name (here: my_func), round brackets () to indicate the empty parameter list, and a colon, followed by the statements defining the function. Important: the statements of the function body must be indented.

# (1) Define the function my_func
def my_func(): 
    # TODO: Enter your statements here
    statement1 
    statement2 

# (2) Use the function my_func
my_func()	# Function call

Example

Function separator_line()

An useful example of a function with empty parameter list is the function separator_line(), that creates a separator line to be used for embellishing console output.

# Define the function separator_line
def separator_line(): 
    print("<<<", end = ' ')
    print(">>>", end = '\n')

# Use the function separator_line
separator_line()	# Output: <<<>>>
print("Hello!")
separator_line()	# Output: <<<>>>

8-2 Function with non-empty parameter list

A function is first defined by using the keyword def, followed by a function name (here: my_func) and a comma-separated parameter list that is surrounded by round brackets. A function is then used ("called") by specifying its name and a list of arguments.

Syntax

Definition and usage of a function with non-empty parameter list

# Define the function my_func
def my_func(param_1, param_2, ... param_n):    
    # TODO: enter your statements here  
# 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 separator_line() with parameters

The previous example of a separator line function to be used for embellishing console output can be generalized using 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: ******

8-3 Function with return value

A function can also return data/parameters as a return value, these can be used further in the calling function in calculations or outputs. In order for a function to return a value, the keyword "return" is used.

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 1

Function with 2 parameters

This example shows how to define an user-defined function f(x,y) = sin(x)*exp(-y). Important: x and y must be real values, the function will not work for parameters x, y that are lists, so f(list1, list2) will generate an error. In Python, if a function should accept list parameters, you must vectorize it first using NumPy's vectorize.

# Define the function f
from numpy import pi, sin, exp
def f(x, y) :
    return sin(x)*exp(-y)
# Use the function f
z = f(pi/4, 1); print(z)
# Use vectorized form of function f
fvec = np.vectorize(f)
z = fvec([pi/4, pi/2], [1, 2]); print(z)

Example 2

Calculate volume of a cone

This example shows how to write a function volume_cone() that calculates the volume of a cone. Known: The volume of a cone is calculated using the formula V = PI*r^2*h/3, where r is the radius and h the height of the cone. So our function has two parameters, r and h and returns the volume.

import math
# Define the function volume_cone()
def volume_cone(r, h): 
    v = math.pi * math.pow(r,2) * h / 3
    return v
# Use the function volume_cone()
r = float(input("Enter radius:")); # Ask user to enter radius
h = float(input("Enter height:")); # Ask user to enter height
print("Volume of cone = ", volume_cone(r, h))

Lambda functions

Lambda functions are a type of inline functions used for small code fragments that can be defined in just one line. 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 could just write the following 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-4 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 function comment aka docstring should include: (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 1

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 repetitions of symbol1 and n repetitions of 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)

Example 2

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__.

def to_currency(amount: int, curr: str) -> str:
    return str(amount) +  curr

print(to_currency.__annotations__)
print(to_currency(10, '$'))

9-2 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"))