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

exercises/practice/go-counting/.meta/example.py

@@ -1,7 +1,7 @@
 
-BLACK = "B"
-WHITE = "W"
-NONE = ""
+BLACK = 'B'
+WHITE = 'W'
+NONE = ''
 STONES = [BLACK, WHITE]
 DIRECTIONS = [(0, 1), (0, -1), (1, 0), (-1, 0)]
 
@@ -12,23 +12,25 @@ def __init__(self, board):
         self.width = len(self.board[0])
         self.height = len(self.board)
 
-    def valid(self, x, y):
-        return x >= 0 and x < self.width and y >= 0 and y < self.height
-
-    def walk(self, x, y,
-             visited_territory=[],
-             visited_coords=[],
-             visited_stones=[]):
-        if not (x, y) in visited_coords and self.valid(x, y):
-            s = self.board[y][x]
-            if s in STONES:
-                if s not in visited_stones:
-                    return (visited_territory, visited_stones + [s])
+    def valid(self, width, height):
+        return self.width > width >= 0 and self.height > height >= 0
+
+    def walk(self, width, height, visited_territory=None, visited_coords=None, visited_stones=None):
+        # Pylint gives W0102 warning if list used as default argument, because list is mutable.
+        visited_territory = [] if visited_territory is None else visited_territory
+        visited_coords = [] if visited_coords is None else visited_coords
+        visited_stones = [] if visited_stones is None else visited_stones
+
+        if (width, height) not in visited_coords and self.valid(width, height):
+            stone = self.board[height][width]
+            if stone in STONES:
+                if stone not in visited_stones:
+                    return (visited_territory, visited_stones + [stone])
             else:  # s is empty
-                for d in DIRECTIONS:
-                    visited = self.walk(x + d[0], y + d[1],
-                                        visited_territory + [(x, y)],
-                                        visited_coords + [(x, y)],
+                for direction in DIRECTIONS:
+                    visited = self.walk(width + direction[0], height + direction[1],
+                                        visited_territory + [(width, height)],
+                                        visited_coords + [(width, height)],
                                         visited_stones)
                     visited_territory = visited[0]
                     visited_stones = visited[1]
@@ -50,12 +52,12 @@ def territory(self, x, y):
 
     def territories(self):
         owners = STONES + [NONE]
-        result = dict([(owner, set()) for owner in owners])
+        result = {owner:set() for owner in owners}
         visited = set()
-        for y in range(self.height):
-            for x in range(self.width):
-                if not (x, y) in visited:
-                    owner, owned_territories = self.territory(x, y)
+        for row in range(self.height):
+            for column in range(self.width):
+                if not (column, row) in visited:
+                    owner, owned_territories = self.territory(column, row)
                     result[owner].update(owned_territories)
                     visited.update(owned_territories)
 

exercises/practice/grade-school/.meta/example.py

@@ -2,7 +2,7 @@
 
 
 class School:
-    def __init__(self,):
+    def __init__(self):
         self.db = {}
         self.add = []
 

exercises/practice/grains/.meta/example.py

@@ -1,10 +1,10 @@
 def square(number):
     if number == 0:
-        raise ValueError("square must be between 1 and 64")
+        raise ValueError('square must be between 1 and 64')
     elif number < 0:
-        raise ValueError("square must be between 1 and 64")
+        raise ValueError('square must be between 1 and 64')
     elif number > 64:
-        raise ValueError("square must be between 1 and 64")
+        raise ValueError('square must be between 1 and 64')
 
     return 2 ** (number - 1)
 

exercises/practice/grep/.meta/example.py

@@ -27,7 +27,7 @@ def format_lines(matched_lines, flags, files):
     result = []
 
     for file_name, line_number, line in matched_lines:
-        line_result = ""
+        line_result = ''
 
         if len(files) > 1:
             line_result += file_name + ':'
@@ -46,7 +46,7 @@ def grep(pattern, flags, files):
     matched_lines = []
 
     for file_name in files:
-        with open(file_name) as f:
+        with open(file_name, encoding='utf-8') as f:
             for line_number, line in enumerate(f.readlines(), start=1):
                 if matches(line, pattern, flags):
                     matched_lines.append((file_name, line_number, line))

exercises/practice/hamming/.meta/example.py

@@ -1,5 +1,5 @@
-def distance(s1, s2):
-    if len(s1) != len(s2):
-        raise ValueError("Strands must be of equal length.")
+def distance(strand_a, strand_b):
+    if len(strand_a) != len(strand_b):
+        raise ValueError('Strands must be of equal length.')
 
-    return sum(a != b for a, b in zip(s1, s2))
+    return sum(a_part != b_part for a_part, b_part in zip(strand_a, strand_b))

exercises/practice/hangman/.meta/example.py

@@ -1,6 +1,6 @@
-STATUS_WIN = "win"
-STATUS_LOSE = "lose"
-STATUS_ONGOING = "ongoing"
+STATUS_WIN = 'win'
+STATUS_LOSE = 'lose'
+STATUS_ONGOING = 'ongoing'
 
 
 class Hangman:
@@ -10,24 +10,24 @@ def __init__(self, word):
         self.word = word
         self.masked_word = ''
         self.guesses = []
-        for i in self.word:
+        for _ in self.word:
             self.masked_word += '_'
 
     def guess(self, char):
         if self.status != STATUS_ONGOING:
-            raise ValueError("The game has already ended.")
+            raise ValueError('The game has already ended.')
 
         self.update_remaining_guesses(char)
         self.update_masked_word()
         self.update_status()
 
     def update_masked_word(self):
         self.masked_word = ''
-        for i in self.word:
-            if i not in self.guesses:
+        for idx in self.word:
+            if idx not in self.guesses:
                 self.masked_word += '_'
             else:
-                self.masked_word += i
+                self.masked_word += idx
 
     def update_remaining_guesses(self, char):
         if char not in self.word or char in self.guesses:

exercises/practice/hangman/hangman.py

@@ -1,8 +1,8 @@
 # Game status categories
 # Change the values as you see fit
-STATUS_WIN = "win"
-STATUS_LOSE = "lose"
-STATUS_ONGOING = "ongoing"
+STATUS_WIN = 'win'
+STATUS_LOSE = 'lose'
+STATUS_ONGOING = 'ongoing'
 
 
 class Hangman:

exercises/practice/hexadecimal/.meta/example.py

@@ -1,10 +1,10 @@
 from functools import reduce
 
 
-def hexa(hex_str):
-    hex_str = hex_str.lower()
-    if set(hex_str) - set('0123456789abcdef'):
+def hexa(hex_string):
+    hex_string = hex_string.lower()
+    if set(hex_string) - set('0123456789abcdef'):
         raise ValueError('Invalid hexadecimal string')
-    digits = [ord(c) - ord('a') + 10 if c in 'abcdef' else ord(c) - ord('0')
-              for c in hex_str]
-    return reduce(lambda x, y: x * 16 + y, digits, 0)
+    digits = [ord(letter) - ord('a') + 10 if letter in 'abcdef' else ord(letter) - ord('0')
+              for letter in hex_string]
+    return reduce(lambda var_1, var_2: var_1 * 16 + var_2, digits, 0)

exercises/practice/house/.meta/example.py

@@ -1,4 +1,4 @@
-parts = [('lay in', 'the house that Jack built.'),
+PARTS = [('lay in', 'the house that Jack built.'),
          ('ate', 'the malt'),
          ('killed', 'the rat'),
          ('worried', 'the cat'),
@@ -13,14 +13,11 @@
 
 
 def verse(verse_num):
-    v = ['This is {}'.format(parts[verse_num][1])]
-    v.extend(['that {0} {1}'.format(*parts[i])
-              for i in range(verse_num - 1, -1, -1)])
-    return ' '.join(v)
+    verse = [f'This is {PARTS[verse_num][1]}']
+    verse.extend(['that {0} {1}'.format(*PARTS[idx])
+              for idx in range(verse_num - 1, -1, -1)])
+    return ' '.join(verse)
 
 
 def recite(start_verse, end_verse):
-    result = []
-    for verse_num in range(start_verse-1, end_verse):
-        result.append(verse(verse_num))
-    return result
+    return [verse(verse_num) for verse_num in range(start_verse-1, end_verse)]

exercises/practice/isogram/.meta/example.py

@@ -1,3 +1,3 @@
 def is_isogram(string):
-    characters_lower = [c.lower() for c in string if c.isalpha()]
+    characters_lower = [char.lower() for char in string if char.isalpha()]
     return len(set(characters_lower)) == len(characters_lower)

exercises/practice/kindergarten-garden/.meta/example.py

@@ -1,20 +1,20 @@
 class Garden:
 
     STUDENTS = [
-        "Alice",
-        "Bob",
-        "Charlie",
-        "David",
-        "Eve",
-        "Fred",
-        "Ginny",
-        "Harriet",
-        "Ileana",
-        "Joseph",
-        "Kincaid",
-        "Larry",
+        'Alice',
+        'Bob',
+        'Charlie',
+        'David',
+        'Eve',
+        'Fred',
+        'Ginny',
+        'Harriet',
+        'Ileana',
+        'Joseph',
+        'Kincaid',
+        'Larry',
     ]
-    PLANTS = {"C": "Clover", "G": "Grass", "R": "Radishes", "V": "Violets"}
+    PLANTS = {'C': 'Clover', 'G': 'Grass', 'R': 'Radishes', 'V': 'Violets'}
 
     def __init__(self, diagram, students=None):
         students = sorted(students or self.STUDENTS)
@@ -25,10 +25,10 @@ def __init__(self, diagram, students=None):
             stop = start + 2
             self.cups.setdefault(student, [])
             self.cups[student].extend(
-                self.PLANTS[p] for p in front[start:stop]
+                self.PLANTS[plant] for plant in front[start:stop]
             )
             self.cups[student].extend(
-                self.PLANTS[p] for p in back[start:stop]
+                self.PLANTS[plant] for plant in back[start:stop]
             )
 
     def plants(self, student):

exercises/practice/knapsack/.meta/example.py

@@ -4,9 +4,9 @@ def maximum_value(maximum_weight, items):
 
     for weight in range(1, maximum_weight + 1):
         for index, item in enumerate(items, 1):
-            if item["weight"] <= weight:
-                value = item["value"] + \
-                        totals[weight - item["weight"]][index - 1]
+            if item['weight'] <= weight:
+                value = item['value'] + \
+                        totals[weight - item['weight']][index - 1]
 
                 value_without_item = totals[weight][index - 1]
                 totals[weight][index] = max(value, value_without_item)