[Linting]: Lint practice stub files (5 / ?)

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

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,15 +16,15 @@ 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 = ','
             self.decimal = '.'
         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,

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

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

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

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):

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.')

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.')

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

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

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,31 +49,31 @@ 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
 
         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:

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

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

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'