Adapt whitespace to conform with PEP-8 recommendations

Author: timhoffm

tutorials/learnpython.org/en/Generators.md

@@ -17,7 +17,7 @@ Here is a simple example of a generator function which returns 7 random integers
               yield random.randint(1, 40)
       
           # returns a 7th number between 1 and 15
-          yield random.randint(1,15)
+          yield random.randint(1, 15)
       
       for random_number in lottery():
              print("And the next number is... %d!" %(random_number))
@@ -33,7 +33,7 @@ Hint: Can you use only two variables in the generator function? Remember that as
     a = 1
     b = 2
     a, b = b, a
-    print(a,b)
+    print(a, b)
 
 will simultaneously switch the values of a and b.
 

tutorials/learnpython.org/en/Input and Output.md

@@ -31,20 +31,20 @@ this is especially used to input integers. The advantage of input() over raw_inp
 Here we make use split() and map() functions
 
     #give two integers in first line and more than two integers in third line
-    a,b=map(int,raw_input().split()
-    array=raw_input().split()
-    sum=0
+    a, b = map(int, raw_input().split())
+    array = raw_input().split()
+    sum = 0
     for each in array:
-        sum=sum+int(each)
-    print a,b,sum #prints first two integers from first line and sum of integers of second line
+        sum = sum + int(each)
+    print(a, b, sum)  # prints first two integers from first line and sum of integers of second line
 
 ###Output formatting
 You might have already noticed that print statement automatically inserts a new line. The use of comma like in the above code prints the values in a single line separated by a space.
 The sys module provides various functions for output formatting but here we learn how to use basic knowledge of formatting to output in our required way. Lets see a few examples to learn output formatting
 
-    a=5
-    b=0.63
-    c="hello"
-    print "a is : %d, b is %0.4f,c is %s" %(a,b,c)
+    a = 5
+    b = 0.63
+    c = "hello"
+    print "a is : %d, b is %0.4f,c is %s" % (a,b,c)
 
 The output must be self explanatory.

tutorials/learnpython.org/en/Map, Filter, Reduce.md

@@ -51,25 +51,25 @@ Python already blesses us with the ```round()``` built-in function that takes tw
 
     circle_areas = [3.56773, 5.57668, 4.00914, 56.24241, 9.01344, 32.00013]
 
-    result = list(map(round, circle_areas, range(1,7)))
+    result = list(map(round, circle_areas, range(1, 7)))
 
     print(result)
 
 See the beauty of ```map()```? Can you imagine the flexibility this evokes?
 
-The ```range(1,7)``` function acts as the second argument to the ```round``` function (the number of required decimal places per iteration). So as ```map``` iterates through ```circle_areas```, during the first iteration, the first element of ```circle_areas```, ```3.56773``` is passed along with the first element of ```range(1,7)```, ```1``` to ```round```, making it effectively become ```round(3.56773, 1)```. During the second iteration, the second element of ```circle_areas```, ```5.57668``` along with the second element of ```range(1,7)```, ```2``` is passed to ```round``` making it translate to ```round(5.57668, 2)```. This happens until the end of the ```circle_areas``` list is reached.
+The ```range(1, 7)``` function acts as the second argument to the ```round``` function (the number of required decimal places per iteration). So as ```map``` iterates through ```circle_areas```, during the first iteration, the first element of ```circle_areas```, ```3.56773``` is passed along with the first element of ```range(1,7)```, ```1``` to ```round```, making it effectively become ```round(3.56773, 1)```. During the second iteration, the second element of ```circle_areas```, ```5.57668``` along with the second element of ```range(1,7)```, ```2``` is passed to ```round``` making it translate to ```round(5.57668, 2)```. This happens until the end of the ```circle_areas``` list is reached.
 
-I'm sure you're wondering: "What if I pass in an iterable less than or more than the length of the first iterable? That is, what if I pass ```range(1,3)``` or ```range(1, 9999)``` as the second iterable in the above function". And the answer is simple: nothing! Okay, that's not true. "Nothing" happens in the sense that the ```map()``` function will not raise any exception, it will simply iterate over the elements until it can't find a second argument to the function, at which point it simply stops and returns the result.
+I'm sure you're wondering: "What if I pass in an iterable less than or more than the length of the first iterable? That is, what if I pass ```range(1, 3)``` or ```range(1, 9999)``` as the second iterable in the above function". And the answer is simple: nothing! Okay, that's not true. "Nothing" happens in the sense that the ```map()``` function will not raise any exception, it will simply iterate over the elements until it can't find a second argument to the function, at which point it simply stops and returns the result.
 
-So, for example, if you evaluate ```result = list(map(round, circle_areas, range(1,3)))```, you won't get any error even as the length of ```circle_areas``` and the length of ```range(1,3)``` differ. Instead, this is what Python does: It takes the first element of ```circle_areas``` and the first element of ```range(1,3)``` and passes it to ```round```. ```round``` evaluates it then saves the result. Then it goes on to the second iteration, second element of ```circle_areas``` and second element of ```range(1,3)```, ```round``` saves it again. Now, in the third iteration (```circle_areas``` has a third element), Python takes the third element of ```circle_areas``` and then tries to take the third element of ```range(1,3)``` but since ```range(1,3)``` does not have a third element, Python simply stops and returns the result, which in this case would simply be ```[3.6, 5.58]```. 
+So, for example, if you evaluate ```result = list(map(round, circle_areas, range(1, 3)))```, you won't get any error even as the length of ```circle_areas``` and the length of ```range(1, 3)``` differ. Instead, this is what Python does: It takes the first element of ```circle_areas``` and the first element of ```range(1,3)``` and passes it to ```round```. ```round``` evaluates it then saves the result. Then it goes on to the second iteration, second element of ```circle_areas``` and second element of ```range(1,3)```, ```round``` saves it again. Now, in the third iteration (```circle_areas``` has a third element), Python takes the third element of ```circle_areas``` and then tries to take the third element of ```range(1,3)``` but since ```range(1,3)``` does not have a third element, Python simply stops and returns the result, which in this case would simply be ```[3.6, 5.58]```. 
 
 Go ahead, try it.
 
     # Python 3
 
     circle_areas = [3.56773, 5.57668, 4.00914, 56.24241, 9.01344, 32.00013]
 
-    result = list(map(round, circle_areas, range(1,3)))
+    result = list(map(round, circle_areas, range(1, 3)))
 
     print(result)
 
@@ -81,7 +81,7 @@ To consolidate our knowledge of the ```map()``` function, we are going to use it
     # Python 3
 
     my_strings = ['a', 'b', 'c', 'd', 'e']
-    my_numbers = [1,2,3,4,5]
+    my_numbers = [1, 2, 3, 4, 5]
 
     results = list(zip(my_strings, my_numbers))
 
@@ -94,7 +94,7 @@ Onto our own custom ```zip()``` function!
     # Python 3
 
     my_strings = ['a', 'b', 'c', 'd', 'e']
-    my_numbers = [1,2,3,4,5]
+    my_numbers = [1, 2, 3, 4, 5]
 
     results = list(map(lambda x, y: (x, y), my_strings, my_numbers))
 

tutorials/learnpython.org/en/Multiple Function Arguments.md

@@ -15,15 +15,15 @@ It is possible to declare functions which receive a variable number of arguments
         print("Third: %s" % third)
         print("And all the rest... %s" % list(therest))
 
-The "therest" variable is a list of variables, which receives all arguments which were given to the "foo" function after the first 3 arguments. So calling `foo(1,2,3,4,5)` will print out:
+The "therest" variable is a list of variables, which receives all arguments which were given to the "foo" function after the first 3 arguments. So calling `foo(1, 2, 3, 4, 5)` will print out:
 
     def foo(first, second, third, *therest):
         print("First: %s" %(first))
         print("Second: %s" %(second))
         print("Third: %s" %(third))
         print("And all the rest... %s" %(list(therest)))
 
-    foo(1,2,3,4,5)
+    foo(1, 2, 3, 4, 5)
 
 It is also possible to send functions arguments by keyword, so that the order of the argument does not matter, using the following syntax. The following code yields the following output: 
 ```The sum is: 6
@@ -62,13 +62,13 @@ def bar(a, b, c):
 
 
 # test code
-if foo(1,2,3,4) == 1:
+if foo(1, 2, 3, 4) == 1:
     print("Good.")
-if foo(1,2,3,4,5) == 2:
+if foo(1, 2, 3, 4, 5) == 2:
     print("Better.")
-if bar(1,2,3,magicnumber = 6) == False:
+if bar(1, 2, 3, magicnumber=6) == False:
     print("Great.")
-if bar(1,2,3,magicnumber = 7) == True:
+if bar(1, 2, 3, magicnumber=7) == True:
     print("Awesome!")
 
 Expected Output
@@ -91,11 +91,11 @@ def bar(a, b, c, **kwargs):
 
 
 # test code
-if foo(1,2,3,4) == 1:
+if foo(1, 2, 3, 4) == 1:
     print("Good.")
-if foo(1,2,3,4,5) == 2:
+if foo(1, 2, 3, 4, 5) == 2:
     print("Better.")
-if bar(1,2,3,magicnumber = 6) == False:
+if bar(1, 2, 3, magicnumber=6) == False:
     print("Great.")
-if bar(1,2,3,magicnumber = 7) == True:
+if bar(1, 2, 3, magicnumber=7) == True:
     print("Awesome!")

tutorials/learnpython.org/en/Partial functions.md

@@ -13,11 +13,11 @@ This code will return 8.
 
     from functools import partial
 
-    def multiply(x,y):
+    def multiply(x, y):
             return x * y
 
     # create a new function that multiplies by 2
-    dbl = partial(multiply,2)
+    dbl = partial(multiply, 2)
     print(dbl(4))
 
 An important note:  the default values will start replacing variables from the left.  The 2 will replace x.
@@ -32,7 +32,7 @@ Tutorial Code
 -------------
 #Following is the exercise, function provided:
 from functools import partial
-def func(u,v,w,x):
+def func(u, v, w, x):
     return u*4 + v*3 + w*2 + x
 #Enter your code here to create and print with your partial function
 
@@ -45,7 +45,7 @@ success_msg('Good job!')
 Solution
 --------
 from functools import partial
-def func(u,v,w,x):
+def func(u, v, w, x):
     return u*4 + v*3 + w*2 + x
 
 p = partial(func,5,6,7)

tutorials/learnpython.org/en/Variables and Types.md

@@ -51,7 +51,7 @@ Simple operators can be executed on numbers and strings:
 Assignments can be done on more than one variable "simultaneously" on the same line like this
 
     a, b = 3, 4
-    print(a,b)
+    print(a, b)
 
 Mixing operators between numbers and strings is not supported: