Merge branch 'master' into master

1 files changed, 95 insertions, 34 deletions

diff --git a/python3.html.markdown b/python3.html.markdown
index 37987582..d09c2819 100644
--- a/python3.html.markdown
+++ b/python3.html.markdown
@@ -6,6 +6,9 @@ contributors:
     - ["Andre Polykanine", "https://github.com/Oire"]
     - ["Zachary Ferguson", "http://github.com/zfergus2"]
     - ["evuez", "http://github.com/evuez"]
+    - ["Rommel Martinez", "https://ebzzry.io"]
+    - ["Roberto Fernandez Diaz", "https://github.com/robertofd1995"]
+    - ["caminsha", "https://github.com/caminsha"]
 filename: learnpython3.py
 ---
 
@@ -39,10 +42,10 @@ Note: This article applies to Python 3 specifically. Check out [here](http://lea
 10 * 2  # => 20
 35 / 5  # => 7.0
 
-# Result of integer division truncated down both for positive and negative.
+# Integer division rounds down for both positive and negative numbers.
 5 // 3       # => 1
-5.0 // 3.0   # => 1.0 # works on floats too
 -5 // 3      # => -2
+5.0 // 3.0   # => 1.0 # works on floats too
 -5.0 // 3.0  # => -2.0
 
 # The result of division is always a float
@@ -70,15 +73,24 @@ not False  # => True
 True and False  # => False
 False or True   # => True
 
-# Note using Bool operators with ints
-# False is 0 and True is 1
+# True and False are actually 1 and 0 but with different keywords
+True + True # => 2
+True * 8    # => 8
+False - 5   # => -5
+
+# Comparison operators look at the numerical value of True and False
+0 == False  # => True
+1 == True   # => True
+2 == True   # => False
+-5 != False # => True
+
+# Using boolean logical operators on ints casts them to booleans for evaluation, but their non-cast value is returned
 # Don't mix up with bool(ints) and bitwise and/or (&,|)
+bool(0)     # => False
+bool(4)     # => True
+bool(-6)    # => True
 0 and 2     # => 0
 -5 or 0     # => -5
-0 == False  # => True
-2 == True   # => False
-1 == True   # => True
--5 != False != True #=> True
 
 # Equality is ==
 1 == 1  # => True
@@ -94,7 +106,10 @@ False or True   # => True
 2 <= 2  # => True
 2 >= 2  # => True
 
-# Comparisons can be chained!
+# Seeing whether a value is in a range
+1 < 2 and 2 < 3  # => True
+2 < 3 and 3 < 2  # => False
+# Chaining makes this look nicer
 1 < 2 < 3  # => True
 2 < 3 < 2  # => False
 
@@ -137,6 +152,12 @@ len("This is a string")  # => 16
 # still use the old style of formatting:
 "%s can be %s the %s way" % ("Strings", "interpolated", "old")  # => "Strings can be interpolated the old way"
 
+# You can also format using f-strings or formatted string literals (in Python 3.6+)
+name = "Reiko"
+f"She said her name is {name}." # => "She said her name is Reiko"
+# You can basically put any Python statement inside the braces and it will be output in the string.
+f"{name} is {len(name)} characters long." # => "Reiko is 5 characters long."
+
 
 # None is an object
 None  # => None
@@ -208,15 +229,11 @@ li[4]  # Raises an IndexError
 # You can look at ranges with slice syntax.
 # The start index is included, the end index is not
 # (It's a closed/open range for you mathy types.)
-li[1:3]   # => [2, 4]
-# Omit the end
-li[2:]    # => [4, 3]
-# Omit the beginning
-li[:3]    # => [1, 2, 4]
-# Select every second entry
-li[::2]   # =>[1, 4]
-# Return a reversed copy of the list
-li[::-1]  # => [3, 4, 2, 1]
+li[1:3]   # Return list from index 1 to 3 => [2, 4]
+li[2:]    # Return list starting from index 2 => [4, 3]
+li[:3]    # Return list from beginning until index 3  => [1, 2, 4]
+li[::2]   # Return list selecting every second entry => [1, 4]
+li[::-1]  # Return list in reverse order => [3, 4, 2, 1]
 # Use any combination of these to make advanced slices
 # li[start:end:step]
 
@@ -273,7 +290,8 @@ a, b, c = (1, 2, 3)  # a is now 1, b is now 2 and c is now 3
 # You can also do extended unpacking
 a, *b, c = (1, 2, 3, 4)  # a is now 1, b is now [2, 3] and c is now 4
 # Tuples are created by default if you leave out the parentheses
-d, e, f = 4, 5, 6
+d, e, f = 4, 5, 6  # tuple 4, 5, 6 is unpacked into variables d, e and f
+# respectively such that d = 4, e = 5 and f = 6
 # Now look how easy it is to swap two values
 e, d = d, e  # d is now 5 and e is now 4
 
@@ -293,16 +311,19 @@ valid_dict = {(1,2,3):[1,2,3]}   # Values can be of any type, however.
 filled_dict["one"]  # => 1
 
 # Get all keys as an iterable with "keys()". We need to wrap the call in list()
-# to turn it into a list. We'll talk about those later.  Note - Dictionary key
-# ordering is not guaranteed. Your results might not match this exactly.
-list(filled_dict.keys())  # => ["three", "two", "one"]
+# to turn it into a list. We'll talk about those later.  Note - for Python
+# versions <3.7, dictionary key ordering is not guaranteed. Your results might
+# not match the example below exactly. However, as of Python 3.7, dictionary
+# items maintain the order at which they are inserted into the dictionary.
+list(filled_dict.keys())  # => ["three", "two", "one"] in Python <3.7
+list(filled_dict.keys())  # => ["one", "two", "three"] in Python 3.7+
 
 
 # Get all values as an iterable with "values()". Once again we need to wrap it
 # in list() to get it out of the iterable. Note - Same as above regarding key
 # ordering.
-list(filled_dict.values())  # => [3, 2, 1]
-
+list(filled_dict.values())  # => [3, 2, 1]  in Python <3.7
+list(filled_dict.values())  # => [1, 2, 3] in Python 3.7+
 
 # Check for existence of keys in a dictionary with "in"
 "one" in filled_dict  # => True
@@ -347,6 +368,8 @@ valid_set = {(1,), 1}
 # Add one more item to the set
 filled_set = some_set
 filled_set.add(5)  # filled_set is now {1, 2, 3, 4, 5}
+# Sets do not have duplicate elements
+filled_set.add(5)  # it remains as before {1, 2, 3, 4, 5}
 
 # Do set intersection with &
 other_set = {3, 4, 5, 6}
@@ -436,8 +459,19 @@ prints:
 """
 for i in range(4, 8, 2):
     print(i)
+
+"""
+To loop over a list, and retrieve both the index and the value of each item in the list
+prints:
+    0 dog
+    1 cat
+    2 mouse
 """
+list = ["dog", "cat", "mouse"]
+for i, value in enumerate(list):
+    print(i, value)
 
+"""
 While loops go until a condition is no longer met.
 prints:
     0
@@ -468,6 +502,26 @@ with open("myfile.txt") as f:
     for line in f:
         print(line)
 
+# Writing to a file
+contents = {"aa": 12, "bb": 21}
+with open("myfile1.txt", "w+") as file:
+    file.write(str(contents))        # writes a string to a file
+
+with open("myfile2.txt", "w+") as file:
+    file.write(json.dumps(contents)) # writes an object to a file
+
+# Reading from a file
+with open('myfile1.txt', "r+") as file:
+    contents = file.read()           # reads a string from a file
+print(contents)
+# print: {"aa": 12, "bb": 21}
+
+with open('myfile2.txt', "r+") as file:
+    contents = json.load(file)       # reads a json object from a file
+print(contents)     
+# print: {"aa": 12, "bb": 21}
+
+
 # Python offers a fundamental abstraction called the Iterable.
 # An iterable is an object that can be treated as a sequence.
 # The object returned by the range function, is an iterable.
@@ -497,8 +551,14 @@ next(our_iterator)  # => "three"
 # After the iterator has returned all of its data, it raises a StopIteration exception
 next(our_iterator)  # Raises StopIteration
 
-# You can grab all the elements of an iterator by calling list() on it.
-list(filled_dict.keys())  # => Returns ["one", "two", "three"]
+# We can also loop over it, in fact, "for" does this implicitly!
+our_iterator = iter(our_iterable)
+for i in our_iterator:
+    print(i)  # Prints one, two, three
+
+# You can grab all the elements of an iterable or iterator by calling list() on it.
+list(our_iterable)  # => Returns ["one", "two", "three"]
+list(our_iterator)  # => Returns [] because state is saved
 
 
 ####################################################
@@ -546,9 +606,9 @@ all_the_args(1, 2, a=3, b=4) prints:
 # Use * to expand tuples and use ** to expand kwargs.
 args = (1, 2, 3, 4)
 kwargs = {"a": 3, "b": 4}
-all_the_args(*args)            # equivalent to foo(1, 2, 3, 4)
-all_the_args(**kwargs)         # equivalent to foo(a=3, b=4)
-all_the_args(*args, **kwargs)  # equivalent to foo(1, 2, 3, 4, a=3, b=4)
+all_the_args(*args)            # equivalent to all_the_args(1, 2, 3, 4)
+all_the_args(**kwargs)         # equivalent to all_the_args(a=3, b=4)
+all_the_args(*args, **kwargs)  # equivalent to all_the_args(1, 2, 3, 4, a=3, b=4)
 
 # Returning multiple values (with tuple assignments)
 def swap(x, y):
@@ -782,6 +842,7 @@ class Superhero(Human):
         # add additional class attributes:
         self.fictional = True
         self.movie = movie
+        # be aware of mutable default values, since defaults are shared
         self.superpowers = superpowers
 
         # The "super" function lets you access the parent class's methods
@@ -789,11 +850,11 @@ class Superhero(Human):
         # This calls the parent class constructor:
         super().__init__(name)
 
-    # overload the sing method
+    # override the sing method
     def sing(self):
         return 'Dun, dun, DUN!'
 
-    # add an additional class method
+    # add an additional instance method
     def boast(self):
         for power in self.superpowers:
             print("I wield the power of {pow}!".format(pow=power))
@@ -816,7 +877,7 @@ if __name__ == '__main__':
     # Calls parent method but uses its own class attribute
     print(sup.get_species())    # => Superhuman
 
-    # Calls overloaded method
+    # Calls overridden method
     print(sup.sing())           # => Dun, dun, DUN!
 
     # Calls method from Human
@@ -871,7 +932,7 @@ class Batman(Superhero, Bat):
 
     def __init__(self, *args, **kwargs):
         # Typically to inherit attributes you have to call super:
-        #super(Batman, self).__init__(*args, **kwargs)      
+        # super(Batman, self).__init__(*args, **kwargs)      
         # However we are dealing with multiple inheritance here, and super()
         # only works with the next base class in the MRO list.
         # So instead we explicitly call __init__ for all ancestors.
@@ -900,7 +961,7 @@ if __name__ == '__main__':
     # Calls parent method but uses its own class attribute
     print(sup.get_species())    # => Superhuman
 
-    # Calls overloaded method
+    # Calls overridden method
     print(sup.sing())           # => nan nan nan nan nan batman!
 
     # Calls method from Human, because inheritance order matters