Toc pitfalls (ssciwr#7)

* set structure

* add mutability

* more pitfalls

* more

* more

Author: iulusoy

Material_Part4_Pitfalls/README.md

@@ -0,0 +1,20 @@
+# Pitfalls: Common ways to introduce bugs in your Python code
+
+## Instantiation of mutable default keyword arguments in function calls
+
+Default arguments are only evaluated once: At the time the function is created. If you provide a mutable default keyword argument and then change it in the function, the next time the function is called without that keyword the default will point to the same address as in the first call; but the argument will have already changed, so the default in the first call and the default in the second call are different. Solution: Only provide non-mutable default arguments. See the [example](./mutable_default.py).
+
+## Naming the module
+
+A source of errors can be naming a module the same as another module that is imported, in this example the module is named `math.py` but also imports math from the standard Python library; and function calls using methods from the math module will fail, as Python will look for those in the `math.py` file. Solution: Name your module file different than the modules that you are importing. See the [example](./math.py).
+
+## Exhausting iterators
+
+Iterators and generators can be exhausted, meaning you can only use them once. Solution: If you create an iterator or a generator and you need it more than once you need to save it first. As in the [example](./exhaust_iterators.py) provided, the iterator is created using `zip`, and can be saved in a `list`.
+
+## Variable assignment in different scopes
+
+Assigning a variable within a function shadows any assignment that may have happened in an outer scope. Solution: Pass the variable as an argument into the inner scope or use the return value of a new assignment. See the [example](assignment.py).
+
+## Closure variable binding
+Python uses late binding, resulting that in closures variables are only looked up once the inner function is called. Solution: Make sure the referenced variables are either passed to the inner function or is set correctly in the surrounding scope. See the [example](closure.py).

Material_Part4_Pitfalls/assignment.py

@@ -0,0 +1,23 @@
+
+mylist = [1, 2, 3]
+
+def myfunc():
+    mylist.append("x")
+
+myfunc()
+print(mylist)
+
+mylist2 = [1, 2, 3]
+
+def myfunc2():
+    mylist2 += "x"
+
+# myfunc2()
+print(mylist2)
+
+def myfunc3():
+    mylist3 = "x"
+    return mylist3
+
+mylist2 += myfunc3()
+print(mylist2)

Material_Part4_Pitfalls/closure.py

@@ -0,0 +1,12 @@
+def make_multiplier_of(n):
+    mylist = []
+    for i in n:
+        def multiplier(j):
+            return i * j
+        mylist.append(multiplier)
+    return mylist
+
+times_x = make_multiplier_of(list(range(5)))
+
+for times in times_x:
+    print(times(2))

Material_Part4_Pitfalls/exhaust_iterators.py

@@ -0,0 +1,11 @@
+days = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"]
+lunch = ["Pizza", "Salad", "Pasta", "Sushi", "Sandwich"]
+
+menu = zip(days, lunch)
+# menu = list(zip(days, lunch))
+
+print(list(menu))
+
+
+for item in menu:
+    print("On {} we offer {} for lunch.".format(item[0], item[1]))

Material_Part4_Pitfalls/math.py

@@ -0,0 +1,6 @@
+from math import radians, sin
+
+
+rads = radians(90)
+
+print(sin(rads))

Material_Part4_Pitfalls/mutable_default.py

@@ -0,0 +1,47 @@
+import time
+from datetime import datetime
+
+
+def ingredients1(ingredient, all_ingredients=[]):
+    all_ingredients.append(ingredient)
+    print(all_ingredients)
+
+
+def ingredients2(ingredient, all_ingredients=None):
+    if all_ingredients is None:
+        all_ingredients = []
+    all_ingredients.append(ingredient)
+    print(all_ingredients)
+
+def myfunc(a={"b": 0}):
+    a["b"] += 5
+    print(a)
+
+def display_time(time_to_print=datetime.now()):
+    print(time_to_print.strftime('%B %d, %Y %H:%M:%S'))
+
+if __name__=="__main__":
+    # method 1
+    # a list is mutable
+    print(ingredients1.__defaults__)
+    ingredients1("flour")
+    print(ingredients1.__defaults__)
+    ingredients1("sugar")
+    print(ingredients1.__defaults__)
+    ingredients1("butter")
+    # method 2
+    # None is not mutable
+    print(ingredients2.__defaults__)
+    ingredients2("flour")
+    print(ingredients2.__defaults__)
+    ingredients2("sugar")
+    print(ingredients2.__defaults__)
+    ingredients2("butter")
+    # a dictionary is mutable
+    myfunc()
+    myfunc()
+    display_time()
+    # default argument only evaluated once
+    print(display_time.__defaults__)
+    time.sleep(1)
+    display_time()

Material_Part5_BetterCoding/README.md

@@ -0,0 +1,11 @@
+# Better coding
+
+## Why you should run code in your module only if `__name__` is `"__main__"`
+
+Always encapsulate your module's content in functions/classes and have all function calls and instantiations contained after the statement
+```
+if __name__ == "__main__"
+```
+**Why?** Because, if you import your code as a module, all code that is not contained in a function or class will be run. Now, if you directly run the module,`__name__` will be set to `"__main__"`. But if the module is imported, `__name__` is set to the module's name. See the examples [module1.py](module1.py) and [module2.py](module2.py).
+
+**Task:** Run the code in `module1.py` and `module2.py` and see what is run upon import and how `__name__` changes.

Material_Part5_BetterCoding/module1.py

@@ -0,0 +1,13 @@
+
+
+print("This will always be printed.")
+
+def print_name():
+    print("Module one is {}".format(__name__))
+
+if __name__ == "__main__":
+    print("Runs as main")
+    print_name()
+else:
+    print("Runs as import")
+    print_name()

Material_Part5_BetterCoding/module2.py

@@ -0,0 +1,5 @@
+import module1
+
+print("Running module 2 as {}".format(__name__))
+
+module1.print_name()

README.md

@@ -29,5 +29,5 @@ Course date: Nov 8th 2022, 9:00AM - 1:00PM
 1. [PEP recommendations](Material_Part1_PEP/README.md)
 1. [Linting](Material_Part2_Linter/README.md)
 1. [Code formatting](Material_Part3_Formatter/README.md)
-1. Write better code: Examples
-1. Write better code: Pitfalls
+1. Write better code: [Pitfalls](Material_part4_Pitfalls)
+1. Write better code: [Examples](Material_part5_Examples)