diff --git a/exercises/practice/largest-series-product/.meta/example.py b/exercises/practice/largest-series-product/.meta/example.py
index a7bbde3b0e..c3e8298f2f 100644
--- a/exercises/practice/largest-series-product/.meta/example.py
+++ b/exercises/practice/largest-series-product/.meta/example.py
@@ -2,22 +2,22 @@
 from operator import mul
 
 
-def slices(series, length):
+def slices(series, size):
 
-    if not length <= len(series):
-        raise ValueError("span must be smaller than string length")
-    elif not 0 < length:
-        raise ValueError("span must be greater than zero")
+    if not size <= len(series):
+        raise ValueError('span must be smaller than string length')
+    elif not 0 < size:
+        raise ValueError('span must be greater than zero')
     elif not all(item.isdigit() for item in series):
-        raise ValueError("digits input must only contain digits")
+        raise ValueError('digits input must only contain digits')
 
     numbers = [int(digit) for digit in series]
 
-    return [numbers[i:i + length]
-            for i in range(len(numbers) - length + 1)]
+    return [numbers[idx:idx + size]
+            for idx in range(len(numbers) - size + 1)]
 
 
-def largest_product(series, length):
-    if length == 0:
+def largest_product(series, size):
+    if size == 0:
         return 1
-    return max(reduce(mul, slc) for slc in slices(series, length))
+    return max(reduce(mul, slice) for slice in slices(series, size))
diff --git a/exercises/practice/ledger/.meta/example.py b/exercises/practice/ledger/.meta/example.py
index 0fd89b6b21..46e8e3c9f6 100644
--- a/exercises/practice/ledger/.meta/example.py
+++ b/exercises/practice/ledger/.meta/example.py
@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 from datetime import datetime
 
-ROW_FMT = u'{{:<{1}}} | {{:<{2}}} | {{:{0}{3}}}'
+ROW_FMT = '{{:<{1}}} | {{:<{2}}} | {{:{0}{3}}}'
 
 
 def truncate(s, length=25):
@@ -16,7 +16,7 @@ def __init__(self, locale, currency, columns):
         if locale == 'en_US':
             headers = ['Date', 'Description', 'Change']
             self.datefmt = '{0.month:02}/{0.day:02}/{0.year:04}'
-            self.cur_fmt = u'{}{}{}{}'
+            self.cur_fmt = '{}{}{}{}'
             self.lead_neg = '('
             self.trail_neg = ')'
             self.thousands = ','
@@ -24,7 +24,7 @@ def __init__(self, locale, currency, columns):
         elif locale == 'nl_NL':
             headers = ['Datum', 'Omschrijving', 'Verandering']
             self.datefmt = '{0.day:02}-{0.month:02}-{0.year:04}'
-            self.cur_fmt = u'{1} {0}{2}{3}'
+            self.cur_fmt = '{1} {0}{2}{3}'
             self.lead_neg = '-'
             self.trail_neg = ' '
             self.thousands = '.'
@@ -33,15 +33,15 @@ def __init__(self, locale, currency, columns):
         self.headers = fmt.format(*headers)
         self.cur_symbol = {
             'USD': '$',
-            'EUR': u'€',
+            'EUR': '€',
         }.get(currency)
 
     def number(self, n):
         n_int, n_float = divmod(abs(n), 100)
         n_int_parts = []
         while n_int > 0:
-            n_int, x = divmod(n_int, 1000)
-            n_int_parts.insert(0, str(x))
+            n_int, idx = divmod(n_int, 1000)
+            n_int_parts.insert(0, str(idx))
         return '{}{}{:02}'.format(
             self.thousands.join(n_int_parts) or '0',
             self.decimal,
diff --git a/exercises/practice/linked-list/.meta/example.py b/exercises/practice/linked-list/.meta/example.py
index 5fcc303c66..280509f244 100644
--- a/exercises/practice/linked-list/.meta/example.py
+++ b/exercises/practice/linked-list/.meta/example.py
@@ -1,8 +1,8 @@
 class Node:
-    def __init__(self, value, succeeding=None, prev=None):
+    def __init__(self, value, succeeding=None, previous=None):
         self.value = value
         self.succeeding = succeeding
-        self.prev = prev
+        self.prev = previous
 
 
 class LinkedList:
@@ -56,6 +56,6 @@ def __len__(self):
 
     def __iter__(self):
         current_node = self.head
-        while (current_node):
+        while current_node:
             yield current_node.value
             current_node = current_node.succeeding
diff --git a/exercises/practice/luhn/.meta/example.py b/exercises/practice/luhn/.meta/example.py
index 1380d8c930..32a4dbc48b 100644
--- a/exercises/practice/luhn/.meta/example.py
+++ b/exercises/practice/luhn/.meta/example.py
@@ -2,7 +2,7 @@ class Luhn:
     def __init__(self, card_num):
         self.card_num = card_num
         self.checksum = -1
-        digits = card_num.replace(" ", "")
+        digits = card_num.replace(' ', '')
         length = len(digits)
         if digits.isdigit() and length > 1:
             self.checksum = 0
diff --git a/exercises/practice/markdown/.meta/example.py b/exercises/practice/markdown/.meta/example.py
index 88ccf980ad..1c9d04cf9e 100644
--- a/exercises/practice/markdown/.meta/example.py
+++ b/exercises/practice/markdown/.meta/example.py
@@ -54,7 +54,7 @@ def parse_line(line, in_list, in_list_append):
 
     list_match = re.match(r'\* (.*)', result)
 
-    if (list_match):
+    if list_match:
         if not in_list:
             result = '<ul>' + wrap(list_match.group(1), 'li')
             in_list = True
diff --git a/exercises/practice/matrix/.meta/example.py b/exercises/practice/matrix/.meta/example.py
index 3aae9ed4b7..3c89844bee 100644
--- a/exercises/practice/matrix/.meta/example.py
+++ b/exercises/practice/matrix/.meta/example.py
@@ -1,7 +1,7 @@
 class Matrix:
-    def __init__(self, s):
-        self.rows = [[int(n) for n in row.split()]
-                     for row in s.split('\n')]
+    def __init__(self, matrix_string):
+        self.rows = [[int(number) for number in row.split()]
+                     for row in matrix_string.split('\n')]
         self.columns = [list(tup) for tup in zip(*self.rows)]
 
     def row(self, index):
diff --git a/exercises/practice/minesweeper/.meta/example.py b/exercises/practice/minesweeper/.meta/example.py
index 53ff051b83..4ebbc8413b 100644
--- a/exercises/practice/minesweeper/.meta/example.py
+++ b/exercises/practice/minesweeper/.meta/example.py
@@ -15,26 +15,26 @@ def annotate(minefield):
             high = min(index2 + 2, row_len + 2)
             counts = minefield[index1][low:high].count('*')
 
-            if(index1 > 0):
+            if index1 > 0:
                 counts += minefield[index1 - 1][low:high].count('*')
-            if(index1 < col_len - 1):
+            if index1 < col_len - 1:
                 counts += minefield[index1 + 1][low:high].count('*')
             if counts == 0:
                 continue
 
             board[index1][index2] = str(counts)
-    return ["".join(row) for row in board]
+    return [''.join(row) for row in board]
 
 
 def verify_board(minefield):
     # Rows with different lengths
     row_len = len(minefield[0])
     if not all(len(row) == row_len for row in minefield):
-        raise ValueError("The board is invalid with current input.")
+        raise ValueError('The board is invalid with current input.')
 
     # Unknown character in board
     character_set = set()
     for row in minefield:
         character_set.update(row)
     if character_set - set(' *'):
-        raise ValueError("The board is invalid with current input.")
+        raise ValueError('The board is invalid with current input.')
diff --git a/exercises/practice/nucleotide-count/.meta/example.py b/exercises/practice/nucleotide-count/.meta/example.py
index 83de60a0cb..e79a6a7ec7 100644
--- a/exercises/practice/nucleotide-count/.meta/example.py
+++ b/exercises/practice/nucleotide-count/.meta/example.py
@@ -15,4 +15,4 @@ def nucleotide_counts(strand):
 
 def _validate(abbreviation):
     if abbreviation not in NUCLEOTIDES:
-        raise ValueError('{} is not a nucleotide.'.format(abbreviation))
+        raise ValueError(f'{abbreviation} is not a nucleotide.')
diff --git a/exercises/practice/ocr-numbers/.meta/example.py b/exercises/practice/ocr-numbers/.meta/example.py
index 17f1e8bbed..bc926487ef 100644
--- a/exercises/practice/ocr-numbers/.meta/example.py
+++ b/exercises/practice/ocr-numbers/.meta/example.py
@@ -3,8 +3,8 @@
 
 
 def split_ocr(ocr):
-    return [[ocr[i][NUM_COLS * j:NUM_COLS * (j + 1)] for i in range(NUM_ROWS)]
-            for j in range(len(ocr[0]) // NUM_COLS)]
+    return [[ocr[idx][NUM_COLS * jam:NUM_COLS * (jam + 1)] for idx in range(NUM_ROWS)]
+            for jam in range(len(ocr[0]) // NUM_COLS)]
 
 
 ALL = ['    _  _     _  _  _  _  _  _ ',
@@ -23,21 +23,21 @@ def convert(input_grid):
     lines = [input_grid[start:end]
              for start, end in zip(split_indices[:-1], split_indices[1:])]
 
-    return ",".join(convert_one_line(line) for line in lines)
+    return ','.join(convert_one_line(line) for line in lines)
 
 
 def convert_one_line(input_grid):
     if len(input_grid) != NUM_ROWS:
-        raise ValueError("Number of input lines is not a multiple of four")
+        raise ValueError('Number of input lines is not a multiple of four')
 
     if len(input_grid[0]) % NUM_COLS:
-        raise ValueError("Number of input columns is not a multiple of three")
+        raise ValueError('Number of input columns is not a multiple of three')
 
     numbers = split_ocr(input_grid)
     digits = ''
-    for n in numbers:
+    for num in numbers:
         try:
-            digits += str(OCR_LIST.index(n))
+            digits += str(OCR_LIST.index(num))
         except ValueError:
             digits += '?'
     return digits
diff --git a/exercises/practice/octal/.meta/example.py b/exercises/practice/octal/.meta/example.py
index 9cf4365fcf..86000ee4d3 100644
--- a/exercises/practice/octal/.meta/example.py
+++ b/exercises/practice/octal/.meta/example.py
@@ -1,11 +1,11 @@
 def parse_octal(digits):
     digits = _validate_octal(digits)
-    return sum(int(digit) * 8 ** i
-               for (i, digit) in enumerate(reversed(digits)))
+    return sum(int(digit) * 8 ** idx
+               for (idx, digit) in enumerate(reversed(digits)))
 
 
 def _validate_octal(digits):
-    for d in digits:
-        if not '0' <= d < '8':
-            raise ValueError("Invalid octal digit: " + d)
+    for digit in digits:
+        if not '0' <= digit < '8':
+            raise ValueError("Invalid octal digit: " + digit)
     return digits
diff --git a/exercises/practice/palindrome-products/.meta/example.py b/exercises/practice/palindrome-products/.meta/example.py
index d74e737f74..f656ff1852 100644
--- a/exercises/practice/palindrome-products/.meta/example.py
+++ b/exercises/practice/palindrome-products/.meta/example.py
@@ -3,16 +3,15 @@
 
 
 def largest(min_factor, max_factor):
-    return get_extreme_palindrome_with_factors(max_factor, min_factor, "largest")
+    return get_extreme_palindrome_with_factors(max_factor, min_factor, 'largest')
 
 
 def smallest(max_factor, min_factor):
-    return get_extreme_palindrome_with_factors(max_factor, min_factor, "smallest")
+    return get_extreme_palindrome_with_factors(max_factor, min_factor, 'smallest')
 
 
 def get_extreme_palindrome_with_factors(max_factor, min_factor, extreme):
-    palindromes_found = palindromes(max_factor, min_factor,
-                                    reverse=(extreme == "largest"))
+    palindromes_found = palindromes(max_factor, min_factor, reverse=(extreme == 'largest'))
     factor_pairs = None
     for palindrome in palindromes_found:
         factor_pairs = ((factor, palindrome // factor)
@@ -30,12 +29,12 @@ def get_extreme_palindrome_with_factors(max_factor, min_factor, extreme):
 
 
 def reverse_num(number):
-    reversed = 0
+    reversed_nums = 0
     while number > 0:
-        reversed *= 10
-        reversed += (number % 10)
+        reversed_nums *= 10
+        reversed_nums += (number % 10)
         number //= 10
-    return reversed
+    return reversed_nums
 
 
 def num_digits(number):
@@ -50,23 +49,23 @@ def palindromes(max_factor, min_factor, reverse=False):
     most of the palindromes just to find the one it needs.
     """
     if max_factor < min_factor:
-        raise ValueError("min must be <= max")
+        raise ValueError('min must be <= max')
 
     minimum = min_factor ** 2
     maximum = max_factor ** 2
 
-    def gen_palindromes_of_length(num_digits, reverse=reverse):
+    def gen_palindromes_of_length(digit_count, reverse=reverse):
         """Generates all palindromes with `nd` number of digits that are
         within the desired range.
         Again, if `reverse` is True, the palindromes are generated in
         reverse order.
         """
-        even_nd = (num_digits % 2 == 0)
+        even_nd = (digit_count % 2 == 0)
 
-        min_left_half = max(10 ** (int(ceil(num_digits / 2)) - 1),
-                            minimum // (10 ** (num_digits // 2)))
-        max_left_half = min((10 ** int(ceil(num_digits / 2))) - 1,
-                            maximum // (10 ** (num_digits // 2)))
+        min_left_half = max(10 ** (int(ceil(digit_count / 2)) - 1),
+                            minimum // (10 ** (digit_count // 2)))
+        max_left_half = min((10 ** int(ceil(digit_count / 2))) - 1,
+                            maximum // (10 ** (digit_count // 2)))
 
         current_left_half = min_left_half if not reverse else max_left_half
 
@@ -74,7 +73,7 @@ def make_palindrome(left_half, even_nd=False):
             right_half = (reverse_num(left_half)
                           if even_nd
                           else reverse_num(left_half // 10))
-            return (left_half * (10 ** (num_digits // 2))) + right_half
+            return (left_half * (10 ** (digit_count // 2))) + right_half
 
         if not reverse:
             while current_left_half <= max_left_half:
diff --git a/exercises/practice/parallel-letter-frequency/.meta/example.py b/exercises/practice/parallel-letter-frequency/.meta/example.py
index 0244d35864..5a16fb31c1 100644
--- a/exercises/practice/parallel-letter-frequency/.meta/example.py
+++ b/exercises/practice/parallel-letter-frequency/.meta/example.py
@@ -2,14 +2,10 @@
 from collections import Counter
 from threading import Lock, Thread
 from time import sleep
-import sys
-if sys.version[0] == '2':
-    from Queue import Queue
-else:
-    from queue import Queue
+from queue import Queue
 
-total_workers = 3  # Maximum number of threads chosen arbitrarily
 
+TOTAL_WORKERS = 3  # Maximum number of threads chosen arbitrarily
 
 class LetterCounter:
 
@@ -30,8 +26,7 @@ def count_letters(queue_of_texts, letter_to_frequency, worker_id):
         sleep(worker_id + 1)
         line_input = queue_of_texts.get()
         if line_input is not None:
-            letters_in_line = Counter([x for x in line_input.lower() if
-                                       x.isalpha()])
+            letters_in_line = Counter(idx for idx in line_input.lower() if idx.isalpha())
             letter_to_frequency.add_counter(letters_in_line)
         queue_of_texts.task_done()
         if line_input is None:
@@ -40,17 +35,17 @@ def count_letters(queue_of_texts, letter_to_frequency, worker_id):
 
 def calculate(list_of_texts):
     queue_of_texts = Queue()
-    [queue_of_texts.put(line) for line in list_of_texts]
+    for line in list_of_texts:
+        queue_of_texts.put(line)
     letter_to_frequency = LetterCounter()
     threads = []
-    for i in range(total_workers):
-        worker = Thread(target=count_letters, args=(queue_of_texts,
-                                                    letter_to_frequency, i))
+    for idx in range(TOTAL_WORKERS):
+        worker = Thread(target=count_letters, args=(queue_of_texts, letter_to_frequency, idx))
         worker.start()
         threads.append(worker)
     queue_of_texts.join()
-    for i in range(total_workers):
+    for _ in range(TOTAL_WORKERS):
         queue_of_texts.put(None)
-    for t in threads:
-        t.join()
+    for thread in threads:
+        thread.join()
     return letter_to_frequency.value
diff --git a/exercises/practice/pascals-triangle/.meta/example.py b/exercises/practice/pascals-triangle/.meta/example.py
index 676791e640..70f3aec1dd 100644
--- a/exercises/practice/pascals-triangle/.meta/example.py
+++ b/exercises/practice/pascals-triangle/.meta/example.py
@@ -3,10 +3,10 @@ def rows(row_count):
         return None
     elif row_count == 0:
         return []
-    r = []
-    for i in range(row_count):
-        rn = [1]
-        for j in range(i):
-            rn.append(sum(r[-1][j:j+2]))
-        r.append(rn)
-    return r
+    row_list = []
+    for idx in range(row_count):
+        ronald = [1]
+        for edx in range(idx):
+            ronald.append(sum(row_list[-1][edx:edx+2]))
+        row_list.append(ronald)
+    return row_list
diff --git a/exercises/practice/perfect-numbers/.meta/example.py b/exercises/practice/perfect-numbers/.meta/example.py
index cc8a63008c..3a3494817f 100644
--- a/exercises/practice/perfect-numbers/.meta/example.py
+++ b/exercises/practice/perfect-numbers/.meta/example.py
@@ -1,3 +1,4 @@
+import math
 
 def divisor_generator(number):
     """Returns an unordered list of divisors for n (1 < number).
@@ -6,7 +7,7 @@ def divisor_generator(number):
     :return: list of int divisors
     """
 
-    for index in range(2, int(number ** 0.5) + 1):
+    for index in range(2, int(math.sqrt(number)) + 1):
         if number % index == 0:
             yield index
             if index * index != number:
@@ -21,13 +22,13 @@ def classify(number):
     """
 
     if number <= 0:
-        raise ValueError("Classification is only possible for positive integers.")
+        raise ValueError('Classification is only possible for positive integers.')
 
     aliquot_sum = sum(divisor_generator(number)) + (1 if number > 1 else 0)
 
     if aliquot_sum < number:
-        return "deficient"
+        return 'deficient'
     elif aliquot_sum == number:
-        return "perfect"
+        return 'perfect'
     else:
-        return "abundant"
+        return 'abundant'
diff --git a/exercises/practice/phone-number/.meta/example.py b/exercises/practice/phone-number/.meta/example.py
index 4d9b7f8d61..02b8e13b8b 100644
--- a/exercises/practice/phone-number/.meta/example.py
+++ b/exercises/practice/phone-number/.meta/example.py
@@ -10,42 +10,44 @@ def __init__(self, number):
         self.subscriber_number = self.number[-4:]
 
     def pretty(self):
-        return f"({self.area_code})-{self.exchange_code}-{self.subscriber_number}"
+        return f'({self.area_code})-{self.exchange_code}-{self.subscriber_number}'
 
     def _clean(self, number):
-        preprocess = re.sub(r"[() +-.]", "", number)
+        preprocess = re.sub(r'[() +-.]', '', number)
 
         if any(item for item in preprocess if item.isalpha()):
-            raise ValueError("letters not permitted")
+            raise ValueError('letters not permitted')
 
         if any(item for item in preprocess if item in punctuation):
-            raise ValueError("punctuations not permitted")
+            raise ValueError('punctuations not permitted')
 
         return self._normalize(preprocess)
 
     def _normalize(self, number):
         if len(number) < 10:
-            raise ValueError("incorrect number of digits")
+            raise ValueError('incorrect number of digits')
 
         if len(number) > 11:
-            raise ValueError("more than 11 digits")
-
-        if len(number) == 10 or len(number) == 11 and number.startswith("1"):
-            if number[-10] == "0":
-                raise ValueError("area code cannot start with zero")
-            elif number[-10] == "1":
-                raise ValueError("area code cannot start with one")
-            elif number[-7] == "0":
-                raise ValueError("exchange code cannot start with zero")
-            elif number[-7] == "1":
-                raise ValueError("exchange code cannot start with one")
+            raise ValueError('more than 11 digits')
+
+        if len(number) == 10 or len(number) == 11 and number.startswith('1'):
+            if number[-10] == '0':
+                raise ValueError('area code cannot start with zero')
+            elif number[-10] == '1':
+                raise ValueError('area code cannot start with one')
+            elif number[-7] == '0':
+                raise ValueError('exchange code cannot start with zero')
+            elif number[-7] == '1':
+                raise ValueError('exchange code cannot start with one')
             else:
-                valid = number[-10] in "23456789" and number[-7] in "23456789"
+                valid = number[-10] in '23456789' and number[-7] in '23456789'
 
         else:
             valid = False
-            if number[0] in "023456789":
-                raise ValueError("11 digits must start with 1")
+            if number[0] in '023456789':
+                raise ValueError('11 digits must start with 1')
 
         if valid:
             return number[-10:]
+
+        return None # [Pylint]: R1710;
diff --git a/exercises/practice/point-mutations/.meta/example.py b/exercises/practice/point-mutations/.meta/example.py
index 9284ef178a..b55235a7d2 100644
--- a/exercises/practice/point-mutations/.meta/example.py
+++ b/exercises/practice/point-mutations/.meta/example.py
@@ -1,2 +1,2 @@
 def hamming_distance(strand1, strand2):
-    return sum(x != y for (x, y) in zip(strand1, strand2))
+    return sum(idx != edx for (idx, edx) in zip(strand1, strand2))
diff --git a/exercises/practice/poker/.meta/example.py b/exercises/practice/poker/.meta/example.py
index 7c4dd91b20..e650f143cd 100644
--- a/exercises/practice/poker/.meta/example.py
+++ b/exercises/practice/poker/.meta/example.py
@@ -4,26 +4,26 @@ def best_hands(hands):
 
 def allmax(iterable, key=None):
     result, maxval = [], None
-    key = key or (lambda x: x)
-    for x in iterable:
-        xval = key(x)
+    key = key or (lambda idx: idx)
+    for idx in iterable:
+        xval = key(idx)
         if not result or xval > maxval:
-            result, maxval = [x], xval
+            result, maxval = [idx], xval
         elif xval == maxval:
-            result.append(x)
+            result.append(idx)
     return result
 
 
 def hand_rank(hand):
-    hand = hand.replace("10", "T").split()
-    card_ranks = ["..23456789TJQKA".index(r) for r, s in hand]
-    groups = [(card_ranks.count(i), i) for i in set(card_ranks)]
+    hand = hand.replace('10', 'T').split()
+    card_ranks = ['..23456789TJQKA'.index(idx) for idx, _ in hand]
+    groups = [(card_ranks.count(idx), idx) for idx in set(card_ranks)]
     groups.sort(reverse=True)
     counts, ranks = zip(*groups)
     if ranks == (14, 5, 4, 3, 2):
         ranks = (5, 4, 3, 2, 1)
     straight = (len(counts) == 5) and (max(ranks) - min(ranks) == 4)
-    flush = len(set([s for r, s in hand])) == 1
+    flush = len({idx for _, idx in hand}) == 1
     return (9 if counts == (5,) else
             8 if straight and flush else
             7 if counts == (4, 1) else
diff --git a/exercises/practice/pov/.meta/example.py b/exercises/practice/pov/.meta/example.py
index cd0608480f..9747d985e3 100644
--- a/exercises/practice/pov/.meta/example.py
+++ b/exercises/practice/pov/.meta/example.py
@@ -2,9 +2,9 @@
 
 
 class Tree:
-    def __init__(self, label, children=[]):
+    def __init__(self, label, children=None):
         self.label = label
-        self.children = children
+        self.children = children if children is not None else []
 
     def __dict__(self):
         return {self.label: [member.__dict__() for member in sorted(self.children)]}
@@ -57,7 +57,7 @@ def from_pov(self, from_node):
             for child in tree.children:
                 stack.append(child.add(tree.remove(child.label)))
 
-        raise ValueError("Tree could not be reoriented")
+        raise ValueError('Tree could not be reoriented')
 
 
 
@@ -69,8 +69,8 @@ def path_to(self, from_node, to_node):
         while path[-1] != to_node:
             try:
                 tree = stack.pop()
-            except IndexError:
-                raise ValueError("No path found")
+            except IndexError as error:
+                raise ValueError('No path found') from error
             if to_node in tree:
                 path.append(tree.label)
                 stack = tree.children
diff --git a/exercises/practice/pov/pov.py b/exercises/practice/pov/pov.py
index bee51ec0c6..21dbe4b90b 100644
--- a/exercises/practice/pov/pov.py
+++ b/exercises/practice/pov/pov.py
@@ -2,9 +2,9 @@
 
 
 class Tree:
-    def __init__(self, label, children=[]):
+    def __init__(self, label, children=None):
         self.label = label
-        self.children = children
+        self.children = children if children is not None else []
 
     def __dict__(self):
         return {self.label: [c.__dict__() for c in sorted(self.children)]}
diff --git a/exercises/practice/prime-factors/.meta/example.py b/exercises/practice/prime-factors/.meta/example.py
index 8820dd14dc..4224b7e735 100644
--- a/exercises/practice/prime-factors/.meta/example.py
+++ b/exercises/practice/prime-factors/.meta/example.py
@@ -1,11 +1,11 @@
 def factors(value):
-    factors = []
+    factor_list = []
     divisor = 2
     while value > 1:
         while value % divisor == 0:
-            factors.append(divisor)
+            factor_list.append(divisor)
             value /= divisor
 
         divisor += 1
 
-    return factors
+    return factor_list
diff --git a/exercises/practice/protein-translation/.meta/example.py b/exercises/practice/protein-translation/.meta/example.py
index 8206aac605..e8c2ac29b5 100644
--- a/exercises/practice/protein-translation/.meta/example.py
+++ b/exercises/practice/protein-translation/.meta/example.py
@@ -1,25 +1,25 @@
-CODONS = {'AUG': "Methionine", 'UUU': "Phenylalanine",
-          'UUC': "Phenylalanine", 'UUA': "Leucine", 'UUG': "Leucine",
-          'UCU': "Serine", 'UCC': "Serine", 'UCA': "Serine",
-          'UCG': "Serine", 'UAU': "Tyrosine", 'UAC': "Tyrosine",
-          'UGU': "Cysteine", 'UGC': "Cysteine", 'UGG': "Tryptophan",
-          'UAA': "STOP", 'UAG': "STOP", 'UGA': "STOP"}
+CODONS = {'AUG': 'Methionine', 'UUU': 'Phenylalanine',
+          'UUC': 'Phenylalanine', 'UUA': 'Leucine', 'UUG': 'Leucine',
+          'UCU': 'Serine', 'UCC': 'Serine', 'UCA': 'Serine',
+          'UCG': 'Serine', 'UAU': 'Tyrosine', 'UAC': 'Tyrosine',
+          'UGU': 'Cysteine', 'UGC': 'Cysteine', 'UGG': 'Tryptophan',
+          'UAA': 'STOP', 'UAG': 'STOP', 'UGA': 'STOP'}
 
 
 def of_codon(codon):
     if codon not in CODONS:
-        raise ValueError('Invalid codon: {}'.format(codon))
+        raise ValueError(f'Invalid codon: {codon}')
     return CODONS[codon]
 
 
 def proteins(strand):
-    proteins = []
+    protein_list = []
     for codon in map(of_codon, _chunkstring(strand, 3)):
         if codon == 'STOP':
             break
-        proteins.append(codon)
-    return proteins
+        protein_list.append(codon)
+    return protein_list
 
 
-def _chunkstring(string, n):
-    return (string[i:n + i] for i in range(0, len(string), n))
+def _chunkstring(string, number):
+    return (string[idx:number + idx] for idx in range(0, len(string), number))
diff --git a/exercises/practice/proverb/.meta/example.py b/exercises/practice/proverb/.meta/example.py
index 9a68b5e4a9..ec434ec7ce 100644
--- a/exercises/practice/proverb/.meta/example.py
+++ b/exercises/practice/proverb/.meta/example.py
@@ -1,7 +1,7 @@
 def proverb(rhyme_items):
     if not rhyme_items:
-        return ""
-    phrases = ['For want of a {0} the {1} was lost.'.format(el1, el2)
-               for el1, el2 in zip(rhyme_items, rhyme_items[1:])]
-    phrases.append('And all for the want of a {0}.'.format(rhyme_items[0]))
+        return ''
+    phrases = [f'For want of a {element_1} the {element_2} was lost.'
+               for element_1, element_2 in zip(rhyme_items, rhyme_items[1:])]
+    phrases.append(f'And all for the want of a {rhyme_items[0]}.')
     return '\n'.join(phrases)
diff --git a/exercises/practice/pythagorean-triplet/.meta/example.py b/exercises/practice/pythagorean-triplet/.meta/example.py
index 5b80c30a26..40b91444b2 100644
--- a/exercises/practice/pythagorean-triplet/.meta/example.py
+++ b/exercises/practice/pythagorean-triplet/.meta/example.py
@@ -1,30 +1,33 @@
-from math import sqrt, ceil
-try:
-    # Python 3
-    from math import gcd
-except ImportError:
-    # Python 2
-    from fractions import gcd
+from math import sqrt, ceil, gcd
 
 
 def triplets_in_range(start, end):
-    for b in range(4, end + 1, 4):
-        for x, y, z in primitive_triplets(b):
-            a, b, c = (x, y, z)
-            while a < start:
-                a, b, c = (a + x, b + y, c + z)
-            while c <= end:
-                yield [a, b, c]
-                a, b, c = (a + x, b + y, c + z)
+    for limit in range(4, end + 1, 4):
+        for x_pos, y_pos, z_pos in primitive_triplets(limit):
+            alpha = x_pos
+            beta = y_pos
+            gamma = z_pos
+
+            while alpha < start:
+                alpha = alpha + x_pos
+                beta = beta + y_pos
+                gamma = gamma + z_pos
+
+            while gamma <= end:
+                yield [alpha, beta, gamma]
+
+                alpha = alpha + x_pos
+                beta = beta + y_pos
+                gamma = gamma + z_pos
 
 
 def euclidian_coprimes(limit):
-    mn = limit // 2
-    for n in range(1, int(ceil(sqrt(mn)))):
-        if mn % n == 0:
-            m = mn // n
-            if (m - n) % 2 == 1 and gcd(m, n) == 1:
-                yield m, n
+    mean = limit // 2
+    for idx in range(1, int(ceil(sqrt(mean)))):
+        if mean % idx == 0:
+            member = mean // idx
+            if (member - idx) % 2 == 1 and gcd(member, idx) == 1:
+                yield member, idx
 
 
 def primitive_triplets(limit):
@@ -32,12 +35,18 @@ def primitive_triplets(limit):
     (https://en.wikipedia.org/wiki/Pythagorean_triple#Generating_a_triple)
     for more information
     """
-    for m, n in euclidian_coprimes(limit):
-        m2, n2 = m * m, n * n
-        a, b, c = m2 - n2, 2 * m * n, m2 + n2
-        if a > b:
-            a, b = b, a
-        yield a, b, c
+    for member_1, member_2 in euclidian_coprimes(limit):
+        calc_1 = member_1 ** 2
+        calc_2 = member_2 ** 2
+
+        alpha = calc_1 - calc_2
+        beta = 2 * member_1 * member_2
+        gamma = calc_1 + calc_2
+
+        if alpha > beta:
+            alpha, beta = beta, alpha
+
+        yield alpha, beta, gamma
 
 
 def triplets_with_sum(number):