diff --git a/info4/kapitel-8/Interpreter/gotointerpreter.py b/info4/kapitel-8/Interpreter/gotointerpreter.py
index 8831586954e918df6e5389d40c01409f438e4929..5699dee3b2965fdef9fcc8915c7aa64d9a488f9c 100644
--- a/info4/kapitel-8/Interpreter/gotointerpreter.py
+++ b/info4/kapitel-8/Interpreter/gotointerpreter.py
@@ -56,13 +56,13 @@ class GOTOInterpreter:
     def process_assignment(self, identifier_token_1):
         identifier_1 = identifier_token_1.v
         if not self.next_nonempty_token('Zuweisung', ':=').k == 'ALLOCATION':
-            self.error_handler.handle_error(":= in Zuweisung erwartet.")
+            self.error_handler.handle_error(':= in Zuweisung erwartet.')
         identifier_token_2 = self.next_nonempty_token('Zuweisung', 'IDENTIFIER (x0, x1, ...) oder NUMBER')
         if identifier_token_2.k == 'NUMBER':
             value_1 = int(identifier_token_2.v)
             self.values.update({identifier_token_1.v: value_1})
-            if not self.next_nonempty_token("Zuweisung", "SEMICOLON").k == 'SEMICOLON':
-                self.error_handler.handle_error("SEMICOLON zum Abschluss einer Zuweisung erwartet.")
+            if not self.next_nonempty_token('Zuweisung', 'SEMICOLON').k == 'SEMICOLON':
+                self.error_handler.handle_error('SEMICOLON zum Abschluss einer Zuweisung erwartet.')
             return self.next_token()
         if not identifier_token_2.k == 'IDENTIFIER':
             self.error_handler.handle_error('IDENTIFIER in Zuweisung erwartet.')
@@ -84,28 +84,28 @@ class GOTOInterpreter:
             self.error_handler.handle_error('NUMBER in Zuweisung erwartet.')
         value_1 = max(0, op(value_2, int(number_token.v)))
         self.values.update({identifier_1: value_1})
-        if not self.next_nonempty_token("Zuweisung", "SEMICOLON").k == 'SEMICOLON':
-            self.error_handler.handle_error("SEMICOLON zum Abschluss einer Zuweisung erwartet.")
+        if not self.next_nonempty_token('Zuweisung', 'SEMICOLON').k == 'SEMICOLON':
+            self.error_handler.handle_error('SEMICOLON zum Abschluss einer Zuweisung erwartet.')
         return self.next_token()
 
     def verify_assignment(self, identifier_token_1):
-        if not self.next_nonempty_token("Zuweisung", ":=").k == 'ALLOCATION':
-            self.error_handler.handle_error(":= in Zuweisung erwartet.")
+        if not self.next_nonempty_token('Zuweisung', ':=').k == 'ALLOCATION':
+            self.error_handler.handle_error(':= in Zuweisung erwartet.')
 
-        identifier_token_2 = self.next_nonempty_token("Zuweisung", "IDENTIFIER (x0, x1, ...) oder NUMBER")
+        identifier_token_2 = self.next_nonempty_token('Zuweisung', 'IDENTIFIER (x0, x1, ...) oder NUMBER')
         if identifier_token_2.k == 'NUMBER':
-            if not self.next_nonempty_token("Zuweisung", "SEMICOLON").k == 'SEMICOLON':
-                self.error_handler.handle_error("SEMICOLON zum Abschluss einer Zuweisung erwartet.")
+            if not self.next_nonempty_token('Zuweisung', 'SEMICOLON').k == 'SEMICOLON':
+                self.error_handler.handle_error('SEMICOLON zum Abschluss einer Zuweisung erwartet.')
             return self.next_token()
 
         if not identifier_token_2.k == 'IDENTIFIER':
-            self.error_handler.handle_error("IDENTIFIER in Zuweisung erwartet.")
-        if self.next_nonempty_token("Zuweisung", "+ oder -").k not in ['PLUS', 'MINUS']:
-            self.error_handler.handle_error("+ oder - in Zuweisung erwartet.")
-        if not self.next_nonempty_token("Zuweisung", "NUMBER").k == 'NUMBER':
-            self.error_handler.handle_error("NUMBER in Zuweisung erwartet.")
-        if not self.next_nonempty_token("Zuweisung", "SEMICOLON").k == 'SEMICOLON':
-            self.error_handler.handle_error("SEMICOLON zum Abschluss einer Zuweisung erwartet.")
+            self.error_handler.handle_error('IDENTIFIER in Zuweisung erwartet.')
+        if self.next_nonempty_token('Zuweisung', '+ oder -').k not in ['PLUS', 'MINUS']:
+            self.error_handler.handle_error('+ oder - in Zuweisung erwartet.')
+        if not self.next_nonempty_token('Zuweisung', 'NUMBER').k == 'NUMBER':
+            self.error_handler.handle_error('NUMBER in Zuweisung erwartet.')
+        if not self.next_nonempty_token('Zuweisung', 'SEMICOLON').k == 'SEMICOLON':
+            self.error_handler.handle_error('SEMICOLON zum Abschluss einer Zuweisung erwartet.')
         return self.next_token()
 
     def process_goto(self, goto_token):
diff --git a/info4/kapitel-8/Interpreter/lexer.py b/info4/kapitel-8/Interpreter/lexer.py
index 1cedea54ed055a3d9a614610f111cb6af4847568..a7fe3c16d952f89ed00d280b6df989e7dd759c2c 100644
--- a/info4/kapitel-8/Interpreter/lexer.py
+++ b/info4/kapitel-8/Interpreter/lexer.py
@@ -25,8 +25,8 @@ class Lexer:
                     new_position = match.span()[1]
                     break
             if self.current_position == new_position:
-                msg = ['Fehler in Zeile ' + str(self.program.count("\n", 0, self.current_position) + 1) + ':',
+                msg = ['Fehler in Zeile ' + str(self.program.count('\n', 0, self.current_position) + 1) + ':',
                        'Unbekannter String: ' + re.compile(r'[^\n]*').match(self.program, self.current_position).group()]
-                raise SyntaxError("\n".join(msg))
+                raise SyntaxError('\n'.join(msg))
             self.current_position = new_position
         return next_token
diff --git a/info4/kapitel-8/Interpreter/loopinterpreter.py b/info4/kapitel-8/Interpreter/loopinterpreter.py
index ea817b00638bfa5d7292ab60c31a23dacd720580..110d9bb23f9edc8a75c0fe72b1938e41a5d68915 100644
--- a/info4/kapitel-8/Interpreter/loopinterpreter.py
+++ b/info4/kapitel-8/Interpreter/loopinterpreter.py
@@ -12,20 +12,20 @@ class ErrorHandler:
         self.interpreter = interpreter
 
     def handle_error(self, message):
-        msg = ["Fehler in Zeile " + str(self.line_number + 1),
-               self.program.split("\n")[self.line_number],
+        msg = ['Fehler in Zeile ' + str(self.line_number + 1),
+               self.program.split('\n')[self.line_number],
                message]
-        raise SyntaxError("\n".join(msg)) from None
+        raise SyntaxError('\n'.join(msg)) from None
 
     def increase_line(self, value):
         self.line_number += value
 
     def handle_break(self):
-        print("BREAK in Zeile " + str(self.line_number))
-        print("Aktueller Zustand:")
+        print('BREAK in Zeile ' + str(self.line_number))
+        print('Aktueller Zustand:')
         for k, v in self.interpreter.values.items():
-            print("Variable " + k + ": " + str(v))
-        user_input = input("Drücke ENTER zum Fotfahren oder schreibe EXIT zum Beenden:")
+            print('Variable ' + k + ': ' + str(v))
+        user_input = input('Drücke ENTER zum Fotfahren oder schreibe EXIT zum Beenden:')
         if user_input.lower() == 'exit':
             raise KeyboardInterrupt
 
@@ -51,36 +51,36 @@ class LOOPInterpreter:
     def process_assignment(self, forbidden_identifiers, identifier_token_1):
         identifier_1 = identifier_token_1.v
         if identifier_1 in forbidden_identifiers:
-            self.error_handler.handle_error("Identifier " + identifier_1 +
-                                            " ist bereits in Loop vorhanden und darf nicht verwendet werden.")
-        if not self.next_nonempty_token("Zuweisung", ":=").k == 'ALLOCATION':
-            self.error_handler.handle_error(":= in Zuweisung erwartet.")
-        identifier_token_2 = self.next_nonempty_token("Zuweisung", "IDENTIFIER (x0, x1, ...) oder NUMBER")
+            self.error_handler.handle_error('Identifier ' + identifier_1 +
+                                            ' ist bereits in Loop vorhanden und darf nicht verwendet werden.')
+        if not self.next_nonempty_token('Zuweisung', ':=').k == 'ALLOCATION':
+            self.error_handler.handle_error(':= in Zuweisung erwartet.')
+        identifier_token_2 = self.next_nonempty_token('Zuweisung', 'IDENTIFIER (x0, x1, ...) oder NUMBER')
         if identifier_token_2.k == 'NUMBER':
             value_1 = int(identifier_token_2.v)
             self.values.update({identifier_token_1.v: value_1})
             return self.next_token()
         if not identifier_token_2.k == 'IDENTIFIER':
-            self.error_handler.handle_error("IDENTIFIER in Zuweisung erwartet.")
+            self.error_handler.handle_error('IDENTIFIER in Zuweisung erwartet.')
         identifier_2 = identifier_token_2.v
         if identifier_2 in forbidden_identifiers:
-            self.error_handler.handle_error("Identifier " + identifier_2 +
-                                            " ist bereits in Loop vorhanden und darf nicht verwendet werden.")
+            self.error_handler.handle_error('Identifier ' + identifier_2 +
+                                            ' ist bereits in Loop vorhanden und darf nicht verwendet werden.')
         if identifier_2 in self.values:
             value_2 = self.values.get(identifier_2)
         else:
             value_2 = 0
-        operator_token = self.next_nonempty_token("Zuweisung", "+ oder -")
+        operator_token = self.next_nonempty_token('Zuweisung', '+ oder -')
         op = None
         if operator_token.k == 'PLUS':
             op = operator.__add__
         elif operator_token.k == 'MINUS':
             op = operator.__sub__
         else:
-            self.error_handler.handle_error("+ oder - in Zuweisung erwartet.")
-        number_token = self.next_nonempty_token("Zuweisung", "NUMBER")
+            self.error_handler.handle_error('+ oder - in Zuweisung erwartet.')
+        number_token = self.next_nonempty_token('Zuweisung', 'NUMBER')
         if not number_token.k == 'NUMBER':
-            self.error_handler.handle_error("NUMBER in Zuweisung erwartet.")
+            self.error_handler.handle_error('NUMBER in Zuweisung erwartet.')
         value_1 = max(0, op(value_2, int(number_token.v)))
         self.values.update({identifier_1: value_1})
         return self.next_token()
@@ -88,26 +88,26 @@ class LOOPInterpreter:
     def verify_assignment(self, forbidden_identifiers, identifier_token_1):
         identifier_1 = identifier_token_1.v
         if identifier_1 in forbidden_identifiers:
-            self.error_handler.handle_error("Identifier " + identifier_1 +
-                                            " ist bereits in Loop vorhanden und darf nicht verwendet werden.")
-        if not self.next_nonempty_token("Zuweisung", ":=").k == 'ALLOCATION':
-            self.error_handler.handle_error(":= in Zuweisung erwartet.")
+            self.error_handler.handle_error('Identifier ' + identifier_1 +
+                                            ' ist bereits in Loop vorhanden und darf nicht verwendet werden.')
+        if not self.next_nonempty_token('Zuweisung', ':=').k == 'ALLOCATION':
+            self.error_handler.handle_error(':= in Zuweisung erwartet.')
 
-        identifier_token_2 = self.next_nonempty_token("Zuweisung", "IDENTIFIER (x0, x1, ...) oder NUMBER")
+        identifier_token_2 = self.next_nonempty_token('Zuweisung', 'IDENTIFIER (x0, x1, ...) oder NUMBER')
         if identifier_token_2.k == 'NUMBER':
             return self.next_token()
 
         if not identifier_token_2.k == 'IDENTIFIER':
-            self.error_handler.handle_error("IDENTIFIER in Zuweisung erwartet.")
+            self.error_handler.handle_error('IDENTIFIER in Zuweisung erwartet.')
         identifier_2 = identifier_token_2.v
         if identifier_2 in forbidden_identifiers:
-            self.error_handler.handle_error("Identifier " + identifier_2 +
-                                            " ist bereits in Loop vorhanden und darf nicht verwendet werden.")
+            self.error_handler.handle_error('Identifier ' + identifier_2 +
+                                            ' ist bereits in Loop vorhanden und darf nicht verwendet werden.')
 
-        if self.next_nonempty_token("Zuweisung", "+ oder -").k not in ['PLUS', 'MINUS']:
-            self.error_handler.handle_error("+ oder - in Zuweisung erwartet.")
-        if not self.next_nonempty_token("Zuweisung", "NUMBER").k == 'NUMBER':
-            self.error_handler.handle_error("NUMBER in Zuweisung erwartet.")
+        if self.next_nonempty_token('Zuweisung', '+ oder -').k not in ['PLUS', 'MINUS']:
+            self.error_handler.handle_error('+ oder - in Zuweisung erwartet.')
+        if not self.next_nonempty_token('Zuweisung', 'NUMBER').k == 'NUMBER':
+            self.error_handler.handle_error('NUMBER in Zuweisung erwartet.')
 
         return self.next_token()
 
@@ -118,7 +118,7 @@ class LOOPInterpreter:
         if identifier_token.v in forbidden_identifiers:
             self.error_handler.handle_error('Identifier ' + identifier_token.v +
                                             ' ist bereits in Loop vorhanden und darf nicht verwendet werden.')
-        if not self.next_nonempty_token("LOOP", "DO").k == 'DO':
+        if not self.next_nonempty_token('LOOP', 'DO').k == 'DO':
             self.error_handler.handle_error('DO in LOOP erwartet.')
 
         if identifier_token.v in self.values:
@@ -135,7 +135,7 @@ class LOOPInterpreter:
             while not end_found:
                 token = self.verify_program(forbidden_identifiers, self.next_token())
                 if token is None or token.k not in ['SEMICOLON', 'END']:
-                    self.error_handler.handle_error("SEMICOLON oder END in LOOP erwartet.")
+                    self.error_handler.handle_error('SEMICOLON oder END in LOOP erwartet.')
                 elif token.k == 'SEMICOLON':
                     continue
                 elif token.k == 'END':
@@ -148,7 +148,7 @@ class LOOPInterpreter:
             while not end_found:
                 token = self.process_program(forbidden_identifiers, self.next_token())
                 if token is None or token.k not in ['SEMICOLON', 'END']:
-                    self.error_handler.handle_error("SEMICOLON oder END in LOOP erwartet.")
+                    self.error_handler.handle_error('SEMICOLON oder END in LOOP erwartet.')
                 elif token.k == 'SEMICOLON':
                     continue
                 elif token.k == 'END':
@@ -158,13 +158,13 @@ class LOOPInterpreter:
         return self.next_token()
 
     def verify_loop(self, forbidden_identifiers, loop_token):
-        identifier_token = self.next_nonempty_token("LOOP", "IDENTIFIER")
+        identifier_token = self.next_nonempty_token('LOOP', 'IDENTIFIER')
         if not identifier_token.k == 'IDENTIFIER':
             self.error_handler.handle_error('IDENTIFIER in LOOP erwartet.')
         if identifier_token.v in forbidden_identifiers:
-            self.error_handler.handle_error("Identifier " + identifier_token.v +
-                                            " ist bereits in Loop vorhanden und darf nicht verwendet werden.")
-        if not self.next_nonempty_token("LOOP", "DO").k == 'DO':
+            self.error_handler.handle_error('Identifier ' + identifier_token.v +
+                                            ' ist bereits in Loop vorhanden und darf nicht verwendet werden.')
+        if not self.next_nonempty_token('LOOP', 'DO').k == 'DO':
             self.error_handler.handle_error('DO in LOOP erwartet.')
 
         forbidden_identifiers.append(identifier_token.v)
@@ -173,7 +173,7 @@ class LOOPInterpreter:
         while not end_found:
             token = self.verify_program(forbidden_identifiers, self.next_token())
             if token is None or token.k not in ['SEMICOLON', 'END']:
-                self.error_handler.handle_error("SEMICOLON oder END in LOOP erwartet.")
+                self.error_handler.handle_error('SEMICOLON oder END in LOOP erwartet.')
             elif token.k == 'SEMICOLON':
                 continue
             elif token.k == 'END':
@@ -184,8 +184,8 @@ class LOOPInterpreter:
 
     def process_program(self, forbidden_identifiers, current_token):
         if current_token is None or current_token.k not in ['IDENTIFIER', 'LOOP']:
-            self.error_handler.handle_error("Keine passende Anweisung gefunden\n" +
-                                            "Erwartet: IDENTIFIER (x0, x1, ...) oder LOOP")
+            self.error_handler.handle_error('Keine passende Anweisung gefunden\n' +
+                                            'Erwartet: IDENTIFIER (x0, x1, ...) oder LOOP')
         elif current_token.k == 'IDENTIFIER':
             current_token = self.process_assignment(forbidden_identifiers, current_token)
         elif current_token.k == 'LOOP':
@@ -194,8 +194,8 @@ class LOOPInterpreter:
 
     def verify_program(self, forbidden_identifiers, current_token):
         if current_token is None or current_token.k not in ['IDENTIFIER', 'LOOP']:
-            self.error_handler.handle_error("Keine passende Anweisung gefunden\n" +
-                                            "Erwartet: IDENTIFIER (x0, x1, ...) oder LOOP")
+            self.error_handler.handle_error('Keine passende Anweisung gefunden\n' +
+                                            'Erwartet: IDENTIFIER (x0, x1, ...) oder LOOP')
         elif current_token.k == 'IDENTIFIER':
             current_token = self.verify_assignment(forbidden_identifiers, current_token)
         elif current_token.k == 'LOOP':
@@ -220,7 +220,7 @@ class LOOPInterpreter:
         token = self.next_token()
         if token is None:
             self.error_handler.handle_error(
-                "Frühzeitiges Ende von " + current_function + "\n" + "Erwartet: " + expected_token)
+                'Frühzeitiges Ende von ' + current_function + '\n' + 'Erwartet: ' + expected_token)
         return token
 
     def interpret(self, program):
@@ -234,13 +234,13 @@ class LOOPInterpreter:
                 current_token = self.process_program(forbidden_identifiers, current_token)
                 if current_token is not None:
                     if not current_token.k == 'SEMICOLON':
-                        self.error_handler.handle_error("Semicolon erwartet")
+                        self.error_handler.handle_error('Semicolon erwartet')
                     current_token = self.next_token()
                     if current_token is None:
-                        self.error_handler.handle_error("Semikolons werden nur zur Trennung und nicht zum " +
-                                                        "Abschluss von Programmen verwendet")
-            if "x0" in self.values:
-                return self.values.get("x0")
+                        self.error_handler.handle_error('Semikolons werden nur zur Trennung und nicht zum ' +
+                                                        'Abschluss von Programmen verwendet')
+            if 'x0' in self.values:
+                return self.values.get('x0')
             return 0
         except KeyboardInterrupt:
             return -1
diff --git a/info4/kapitel-8/Interpreter/test_goto_interpreter.py b/info4/kapitel-8/Interpreter/test_goto_interpreter.py
index bb04283bed7eb3505714a7fc816fd23fd38966d0..568e2a8423a3c2ef16e3edd9cd7fa542b51e8080 100644
--- a/info4/kapitel-8/Interpreter/test_goto_interpreter.py
+++ b/info4/kapitel-8/Interpreter/test_goto_interpreter.py
@@ -4,11 +4,11 @@ from unittest import TestCase
 
 
 def input_continue(prompt):
-    return ""
+    return ''
 
 
 def input_exit(prompt):
-    return "EXIT"
+    return 'EXIT'
 
 
 class GOTOInterpreterTest(TestCase):
diff --git a/info4/kapitel-8/Interpreter/test_loop_interpreter.py b/info4/kapitel-8/Interpreter/test_loop_interpreter.py
index 97330d8ac73d7801a32721f7f001cc4f7b46d127..aaf5b948758e874d4e3ee0e74437ff930bb19838 100644
--- a/info4/kapitel-8/Interpreter/test_loop_interpreter.py
+++ b/info4/kapitel-8/Interpreter/test_loop_interpreter.py
@@ -4,11 +4,11 @@ from unittest import mock
 
 
 def input_exit(prompt):
-    return "EXIT"
+    return 'EXIT'
 
 
 def input_continue(prompt):
-    return ""
+    return ''
 
 
 def init_without_tokens(self, regex_to_token, program):
@@ -29,8 +29,8 @@ class LOOPInterpreterTest(unittest.TestCase):
         self.assertEqual(0, interpret('x0:=x2-6'))
 
     def test_assignment_number(self):
-        self.assertEqual(5, interpret("x0:=5"))
-        self.assertEqual(2, interpret("x0:=2"))
+        self.assertEqual(5, interpret('x0:=5'))
+        self.assertEqual(2, interpret('x0:=2'))
         self.assertEqual(3, interpret('x0:=3'))
 
     def test_assignment_variable(self):
@@ -220,11 +220,11 @@ class LOOPInterpreterTest(unittest.TestCase):
 
     def test_syntax_missing_identifier(self):
         with self.assertRaises(SyntaxError):
-            interpret("x1:=; LOOP x1 DO x2:=2 END")
+            interpret('x1:=; LOOP x1 DO x2:=2 END')
         with self.assertRaises(SyntaxError):
-            interpret("LOOP x1 DO x2:= END")
+            interpret('LOOP x1 DO x2:= END')
         with self.assertRaises(SyntaxError):
-            interpret("LOOP x1 DO x2:=x0+ END")
+            interpret('LOOP x1 DO x2:=x0+ END')
         with self.assertRaises(SyntaxError):
             interpret('LOOP x0 DO LOOP DO x1:=x2+0 END END')
 
diff --git a/info4/kapitel-8/Interpreter/test_while_interpreter.py b/info4/kapitel-8/Interpreter/test_while_interpreter.py
index 2f56a209ca67b41e6431e1206622f6ac62b5ff92..b214f565c245fbfe9e93ec99c8b5978c224e6f4b 100644
--- a/info4/kapitel-8/Interpreter/test_while_interpreter.py
+++ b/info4/kapitel-8/Interpreter/test_while_interpreter.py
@@ -4,7 +4,7 @@ from unittest import mock
 
 
 def str_yes(prompt):
-    return "J"
+    return 'J'
 
 
 class WHILEInterpreterTest(LOOPInterpreterTest):