Sourcery Starbot ⭐ refactored sudharsan2020/python-mastery

Data/stocksim.py

@@ -51,8 +51,7 @@ def read_history(filename):
 
 # Format CSV record
 def csv_record(fields):
-    s = '"%s",%0.2f,"%s","%s",%0.2f,%0.2f,%0.2f,%0.2f,%d' % tuple(fields)
-    return s
+    return '"%s",%0.2f,"%s","%s",%0.2f,%0.2f,%0.2f,%0.2f,%d' % tuple(fields)
 
 class StockTrack(object):
     def __init__(self,name):

Solutions/1_1/art.py

@@ -6,7 +6,7 @@
 chars = '\|/'
 
 def draw(rows, columns):
-    for r in range(rows):
+    for _ in range(rows):
         print(''.join(random.choice(chars) for _ in range(columns)))
 
 if __name__ == '__main__':

Solutions/2_6/cta.py

@@ -7,24 +7,11 @@
 
 tracemalloc.start()
 
-if True:
-    # Part (b)
-    import reader
-    rows = reader.read_csv_as_dicts('../../Data/ctabus.csv',
-                                    [sys.intern, sys.intern, sys.intern, int])
-else:
-    # Part (d) - Challenge
-    import colreader
-    rows = colreader.read_csv_as_columns('../../Data/ctabus.csv', 
-                                         [sys.intern, sys.intern, sys.intern, int])
-
-# --------------------------------------------------
-# Question 1:  How many bus routes are in Chicago?
-# Solution: Use a set to get unique values. 
-
-routes = set()
-for row in rows:
-    routes.add(row['route'])
+# Part (b)
+import reader
+rows = reader.read_csv_as_dicts('../../Data/ctabus.csv',
+                                [sys.intern, sys.intern, sys.intern, int])
+routes = {row['route'] for row in rows}
 print(len(routes), 'routes')
 
 # --------------------------------------------------

Solutions/3_3/reader.py

@@ -23,6 +23,5 @@ def read_csv_as_instances(filename, cls):
     with open(filename) as f:
         rows = csv.reader(f)
         headers = next(rows)
-        for row in rows:
-            records.append(cls.from_row(row))
+        records.extend(cls.from_row(row) for row in rows)
     return records

Solutions/3_5/reader.py

@@ -23,6 +23,5 @@ def read_csv_as_instances(filename, cls):
     with open(filename) as f:
         rows = csv.reader(f)
         headers = next(rows)
-        for row in rows:
-            records.append(cls.from_row(row))
+        records.extend(cls.from_row(row) for row in rows)
     return records

Solutions/3_5/tableformat.py

@@ -32,13 +32,13 @@ class HTMLTableFormatter(TableFormatter):
     def headings(self, headers):
         print('<tr>', end=' ')
         for h in headers:
-            print('<th>%s</th>' % h, end=' ')
+            print(f'<th>{h}</th>', end=' ')
         print('</tr>')
 
     def row(self, rowdata):
         print('<tr>', end=' ')
         for d in rowdata:
-            print('<td>%s</td>' % d, end=' ')
+            print(f'<td>{d}</td>', end=' ')
         print('</tr>')
 
 def create_formatter(name):
@@ -49,7 +49,7 @@ def create_formatter(name):
     elif name == 'html':
         formatter_cls = HTMLTableFormatter
     else:
-        raise RuntimeError('Unknown format %s' % name)
+        raise RuntimeError(f'Unknown format {name}')
     return formatter_cls()
 
 

Solutions/3_6/reader.py

@@ -23,6 +23,5 @@ def read_csv_as_instances(filename, cls):
     with open(filename) as f:
         rows = csv.reader(f)
         headers = next(rows)
-        for row in rows:
-            records.append(cls.from_row(row))
+        records.extend(cls.from_row(row) for row in rows)
     return records

Solutions/3_6/tableformat.py

@@ -32,13 +32,13 @@ class HTMLTableFormatter(TableFormatter):
     def headings(self, headers):
         print('<tr>', end=' ')
         for h in headers:
-            print('<th>%s</th>' % h, end=' ')
+            print(f'<th>{h}</th>', end=' ')
         print('</tr>')
 
     def row(self, rowdata):
         print('<tr>', end=' ')
         for d in rowdata:
-            print('<td>%s</td>' % d, end=' ')
+            print(f'<td>{d}</td>', end=' ')
         print('</tr>')
 
 def create_formatter(name):
@@ -49,7 +49,7 @@ def create_formatter(name):
     elif name == 'html':
         formatter_cls = HTMLTableFormatter
     else:
-        raise RuntimeError('Unknown format %s' % name)
+        raise RuntimeError(f'Unknown format {name}')
     return formatter_cls()
 
 

Solutions/3_7/tableformat.py

@@ -38,13 +38,13 @@ class HTMLTableFormatter(TableFormatter):
     def headings(self, headers):
         print('<tr>', end=' ')
         for h in headers:
-            print('<th>%s</th>' % h, end=' ')
+            print(f'<th>{h}</th>', end=' ')
         print('</tr>')
 
     def row(self, rowdata):
         print('<tr>', end=' ')
         for d in rowdata:
-            print('<td>%s</td>' % d, end=' ')
+            print(f'<td>{d}</td>', end=' ')
         print('</tr>')
 
 def create_formatter(name):
@@ -55,7 +55,7 @@ def create_formatter(name):
     elif name == 'html':
         formatter = HTMLTableFormatter
     else:
-        raise RuntimeError('Unknown format %s' % name)
+        raise RuntimeError(f'Unknown format {name}')
     return formatter()
 
 

Solutions/3_8/tableformat.py

@@ -39,13 +39,13 @@ class HTMLTableFormatter(TableFormatter):
     def headings(self, headers):
         print('<tr>', end=' ')
         for h in headers:
-            print('<th>%s</th>' % h, end=' ')
+            print(f'<th>{h}</th>', end=' ')
         print('</tr>')
 
     def row(self, rowdata):
         print('<tr>', end=' ')
         for d in rowdata:
-            print('<td>%s</td>' % d, end=' ')
+            print(f'<td>{d}</td>', end=' ')
         print('</tr>')
 
 class ColumnFormatMixin:
@@ -66,7 +66,7 @@ def create_formatter(name, column_formats=None, upper_headers=False):
     elif name == 'html':
         formatter_cls = HTMLTableFormatter
     else:
-        raise RuntimeError('Unknown format %s' % name)
+        raise RuntimeError(f'Unknown format {name}')
 
     if column_formats:
         class formatter_cls(ColumnFormatMixin, formatter_cls):

Solutions/5_4/typedproperty.py

@@ -1,7 +1,7 @@
 # typedproperty.py
 
 def typedproperty(name, expected_type):
-    private_name = '_' + name
+    private_name = f'_{name}'
 
     @property
     def value(self):

Solutions/6_1/structure.py

@@ -12,8 +12,7 @@ def __setattr__(self, name, value):
         if name.startswith('_') or name in self._fields:
             super().__setattr__(name, value)
         else:
-            raise AttributeError('No attribute %s' % name)
+            raise AttributeError(f'No attribute {name}')
 
     def __repr__(self):
-        return '%s(%s)' % (type(self).__name__,
-                           ', '.join(repr(getattr(self, name)) for name in self._fields))
+        return f"{type(self).__name__}({', '.join(repr(getattr(self, name)) for name in self._fields)})"

Solutions/6_2/structure.py

@@ -16,8 +16,7 @@ def __setattr__(self, name, value):
         if name.startswith('_') or name in self._fields:
             super().__setattr__(name, value)
         else:
-            raise AttributeError('No attribute %s' % name)
+            raise AttributeError(f'No attribute {name}')
 
     def __repr__(self):
-        return '%s(%s)' % (type(self).__name__,
-                           ', '.join(repr(getattr(self, name)) for name in self._fields))
+        return f"{type(self).__name__}({', '.join(repr(getattr(self, name)) for name in self._fields)})"

Solutions/6_3/structure.py

@@ -17,11 +17,10 @@ def __setattr__(self, name, value):
         if name.startswith('_') or name in self._fields:
             super().__setattr__(name, value)
         else:
-            raise AttributeError('No attribute %s' % name)
+            raise AttributeError(f'No attribute {name}')
 
     def __repr__(self):
-        return '%s(%s)' % (type(self).__name__,
-                           ', '.join(repr(getattr(self, name)) for name in self._fields))
+        return f"{type(self).__name__}({', '.join(repr(getattr(self, name)) for name in self._fields)})"
 
     @classmethod
     def set_fields(cls):

Solutions/6_4/structure.py

@@ -7,11 +7,10 @@ def __setattr__(self, name, value):
         if name.startswith('_') or name in self._fields:
             super().__setattr__(name, value)
         else:
-            raise AttributeError('No attribute %s' % name)
+            raise AttributeError(f'No attribute {name}')
 
     def __repr__(self):
-        return '%s(%s)' % (type(self).__name__,
-                           ', '.join(repr(getattr(self, name)) for name in self._fields))
+        return f"{type(self).__name__}({', '.join(repr(getattr(self, name)) for name in self._fields)})"
 
     @classmethod
     def create_init(cls):

Solutions/7_3/structure.py

@@ -10,11 +10,10 @@ def __setattr__(self, name, value):
         if name.startswith('_') or name in self._fields:
             super().__setattr__(name, value)
         else:
-            raise AttributeError('No attribute %s' % name)
+            raise AttributeError(f'No attribute {name}')
 
     def __repr__(self):
-        return '%s(%s)' % (type(self).__name__,
-                           ', '.join(repr(getattr(self, name)) for name in self._fields))
+        return f"{type(self).__name__}({', '.join(repr(getattr(self, name)) for name in self._fields)})"
 
     @classmethod
     def from_row(cls, row):
@@ -54,17 +53,18 @@ def validate_attributes(cls):
             setattr(cls, name, validated(val))
 
     # Collect all of the field names
-    cls._fields = tuple([v.name for v in validators])
+    cls._fields = tuple(v.name for v in validators)
 
     # Collect type conversions. The lambda x:x is an identity
     # function that's used in case no expected_type is found.
-    cls._types = tuple([ getattr(v, 'expected_type', lambda x: x)
-                   for v in validators ])
+    cls._types = tuple(
+        getattr(v, 'expected_type', lambda x: x) for v in validators
+    )
 
     # Create the __init__ method
     if cls._fields:
         cls.create_init()
 
-    
+
     return cls
 

Solutions/7_4/structure.py

@@ -10,11 +10,10 @@ def __setattr__(self, name, value):
         if name.startswith('_') or name in self._fields:
             super().__setattr__(name, value)
         else:
-            raise AttributeError('No attribute %s' % name)
+            raise AttributeError(f'No attribute {name}')
 
     def __repr__(self):
-        return '%s(%s)' % (type(self).__name__,
-                           ', '.join(repr(getattr(self, name)) for name in self._fields))
+        return f"{type(self).__name__}({', '.join(repr(getattr(self, name)) for name in self._fields)})"
 
     @classmethod
     def from_row(cls, row):
@@ -54,20 +53,20 @@ def validate_attributes(cls):
             setattr(cls, name, validated(val))
 
     # Collect all of the field names
-    cls._fields = tuple([v.name for v in validators])
+    cls._fields = tuple(v.name for v in validators)
 
     # Collect type conversions. The lambda x:x is an identity
     # function that's used in case no expected_type is found.
-    cls._types = tuple([ getattr(v, 'expected_type', lambda x: x)
-                   for v in validators ])
+    cls._types = tuple(
+        getattr(v, 'expected_type', lambda x: x) for v in validators
+    )
 
     # Create the __init__ method
     if cls._fields:
         cls.create_init()
 
-    
+
     return cls
 
 def typed_structure(clsname, **validators):
-    cls = type(clsname, (Structure,), validators)
-    return cls
+    return type(clsname, (Structure,), validators)

Solutions/7_5/mymeta.py

@@ -2,11 +2,11 @@
 
 class mytype(type):
     @staticmethod
-    def __new__(meta, name, bases, __dict__):
+    def __new__(cls, name, bases, __dict__):
         print("Creating class :", name)
         print("Base classes   :", bases)
         print("Attributes     :", list(__dict__.keys()))
-        return super().__new__(meta, name, bases, __dict__)
+        return super().__new__(cls, name, bases, __dict__)
 
 class myobject(metaclass=mytype):
     pass

Solutions/7_6/structure.py

@@ -5,13 +5,13 @@
 
 class StructureMeta(type):
     @classmethod
-    def __prepare__(meta, clsname, bases):
+    def __prepare__(cls, clsname, bases):
         return ChainMap({}, Validator.validators)
 
     @staticmethod
-    def __new__(meta, name, bases, methods):
+    def __new__(cls, name, bases, methods):
         methods = methods.maps[0]
-        return super().__new__(meta, name, bases, methods)
+        return super().__new__(cls, name, bases, methods)
 
 class Structure(metaclass=StructureMeta):
     _fields = ()
@@ -21,11 +21,10 @@ def __setattr__(self, name, value):
         if name.startswith('_') or name in self._fields:
             super().__setattr__(name, value)
         else:
-            raise AttributeError('No attribute %s' % name)
+            raise AttributeError(f'No attribute {name}')
 
     def __repr__(self):
-        return '%s(%s)' % (type(self).__name__,
-                           ', '.join(repr(getattr(self, name)) for name in self._fields))
+        return f"{type(self).__name__}({', '.join(repr(getattr(self, name)) for name in self._fields)})"
 
     @classmethod
     def from_row(cls, row):
@@ -66,20 +65,20 @@ def validate_attributes(cls):
             setattr(cls, name, validated(val))
 
     # Collect all of the field names
-    cls._fields = tuple([v.name for v in validators])
+    cls._fields = tuple(v.name for v in validators)
 
     # Collect type conversions. The lambda x:x is an identity
     # function that's used in case no expected_type is found.
-    cls._types = tuple([ getattr(v, 'expected_type', lambda x: x)
-                   for v in validators ])
+    cls._types = tuple(
+        getattr(v, 'expected_type', lambda x: x) for v in validators
+    )
 
     # Create the __init__ method
     if cls._fields:
         cls.create_init()
 
-    
+
     return cls
 
 def typed_structure(clsname, **validators):
-    cls = type(clsname, (Structure,), validators)
-    return cls
+    return type(clsname, (Structure,), validators)