diff --git a/examples/fibonacci2.py b/examples/fibonacci2.py index f2c4749..bfe611c 100644 --- a/examples/fibonacci2.py +++ b/examples/fibonacci2.py @@ -1,7 +1,7 @@ """Fibonacci iterator""" class Fib: - """iterator that yields numbers in the Fibanocci sequence""" + """iterator that yields numbers in the Fibonacci sequence""" def __init__(self, max): self.max = max diff --git a/examples/ordereddict.py b/examples/ordereddict.py index f81696a..552c5e8 100644 --- a/examples/ordereddict.py +++ b/examples/ordereddict.py @@ -12,48 +12,93 @@ # from collections import MutableMapping -from itertools import zip_longest as _zip_longest class OrderedDict(dict, MutableMapping): + 'Dictionary that remembers insertion order' + # An inherited dict maps keys to values. + # The inherited dict provides __getitem__, __len__, __contains__, and get. + # The remaining methods are order-aware. + # Big-O running times for all methods are the same as for regular dictionaries. + + # The internal self.__map dictionary maps keys to links in a doubly linked list. + # The circular doubly linked list starts and ends with a sentinel element. + # The sentinel element never gets deleted (this simplifies the algorithm). + # The prev/next links are weakref proxies (to prevent circular references). + # Individual links are kept alive by the hard reference in self.__map. + # Those hard references disappear when a key is deleted from an OrderedDict. def __init__(self, *args, **kwds): + '''Initialize an ordered dictionary. Signature is the same as for + regular dictionaries, but keyword arguments are not recommended + because their insertion order is arbitrary. + + ''' if len(args) > 1: - raise TypeError('expected at most 1 arguments') - if not hasattr(self, '_keys'): - self._keys = [] + raise TypeError('expected at most 1 arguments, got {0}'.format(len(args))) + try: + self.__root + except AttributeError: + self.__root = root = _Link() # sentinel node for the doubly linked list + root.prev = root.next = root + self.__map = {} self.update(*args, **kwds) def clear(self): - del self._keys[:] + 'od.clear() -> None. Remove all items from od.' + root = self.__root + root.prev = root.next = root + self.__map.clear() dict.clear(self) def __setitem__(self, key, value): + 'od.__setitem__(i, y) <==> od[i]=y' + # Setting a new item creates a new link which goes at the end of the linked + # list, and the inherited dictionary is updated with the new key/value pair. if key not in self: - self._keys.append(key) + self.__map[key] = link = _Link() + root = self.__root + last = root.prev + link.prev, link.next, link.key = last, root, key + last.next = root.prev = _proxy(link) dict.__setitem__(self, key, value) def __delitem__(self, key): + 'od.__delitem__(y) <==> del od[y]' + # Deleting an existing item uses self.__map to find the link which is + # then removed by updating the links in the predecessor and successor nodes. dict.__delitem__(self, key) - self._keys.remove(key) + link = self.__map.pop(key) + link.prev.next = link.next + link.next.prev = link.prev def __iter__(self): - return iter(self._keys) + 'od.__iter__() <==> iter(od)' + # Traverse the linked list in order. + root = self.__root + curr = root.next + while curr is not root: + yield curr.key + curr = curr.next def __reversed__(self): - return reversed(self._keys) - - def popitem(self): - if not self: - raise KeyError('dictionary is empty') - key = self._keys.pop() - value = dict.pop(self, key) - return key, value + 'od.__reversed__() <==> reversed(od)' + # Traverse the linked list in reverse order. + root = self.__root + curr = root.prev + while curr is not root: + yield curr.key + curr = curr.prev def __reduce__(self): + 'Return state information for pickling' items = [[k, self[k]] for k in self] + tmp = self.__map, self.__root + del self.__map, self.__root inst_dict = vars(self).copy() - inst_dict.pop('_keys', None) - return (self.__class__, (items,), inst_dict) + self.__map, self.__root = tmp + if inst_dict: + return (self.__class__, (items,), inst_dict) + return self.__class__, (items,) setdefault = MutableMapping.setdefault update = MutableMapping.update @@ -62,22 +107,51 @@ class OrderedDict(dict, MutableMapping): values = MutableMapping.values items = MutableMapping.items - def __repr__(self): + def popitem(self, last=True): + '''od.popitem() -> (k, v), return and remove a (key, value) pair. + Pairs are returned in LIFO order if last is true or FIFO order if false. + + ''' if not self: - return '{0}()'.format(self.__class__.__name__,) + raise KeyError('dictionary is empty') + key = next(reversed(self) if last else iter(self)) + value = self.pop(key) + return key, value + + def __repr__(self): + 'od.__repr__() <==> repr(od)' + if not self: + return '{0}()'.format(self.__class__.__name__) return '{0}({1})'.format(self.__class__.__name__, repr(list(self.items()))) def copy(self): + 'od.copy() -> a shallow copy of od' return self.__class__(self) @classmethod def fromkeys(cls, iterable, value=None): + '''OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S + and values equal to v (which defaults to None). + + ''' d = cls() for key in iterable: d[key] = value return d def __eq__(self, other): + '''od.__eq__(y) <==> od==y. Comparison to another OD is order-sensitive + while comparison to a regular mapping is order-insensitive. + + ''' if isinstance(other, OrderedDict): - return all(p==q for p, q in _zip_longest(self.items(), other.items())) + return len(self)==len(other) and \ + all(p==q for p, q in zip(self.items(), other.items())) return dict.__eq__(self, other) + + def __ne__(self, other): + '''od.__ne__(y) <==> od!=y. Comparison to another OD is order-sensitive + while comparison to a regular mapping is order-insensitive. + + ''' + return not self == other diff --git a/generators.html b/generators.html index f54da49..6597ae8 100644 --- a/generators.html +++ b/generators.html @@ -217,7 +217,7 @@ def build_match_and_apply_functions(pattern, search, replace):
  1. build_match_and_apply_functions() is a function that builds other functions dynamically. It takes pattern, search and replace, then defines a matches_rule() function which calls re.search() with the pattern that was passed to the build_match_and_apply_functions() function, and the word that was passed to the matches_rule() function you’re building. Whoa.
  2. Building the apply function works the same way. The apply function is a function that takes one parameter, and calls re.sub() with the search and replace parameters that were passed to the build_match_and_apply_functions() function, and the word that was passed to the apply_rule() function you’re building. This technique of using the values of outside parameters within a dynamic function is called closures. You’re essentially defining constants within the apply function you’re building: it takes one parameter (word), but it then acts on that plus two other values (search and replace) which were set when you defined the apply function. -
  3. Finally, the build_match_and_apply_functions() function returns a list of two values: the two functions you just created. The constants you defined within those functions (pattern within matchFunction, and search and replace within applyFunction) stay with those functions, even after you return from build_match_and_apply_functions(). That’s insanely cool. +
  4. Finally, the build_match_and_apply_functions() function returns a list of two values: the two functions you just created. The constants you defined within those functions (pattern within the match_rule() function, and search and replace within the apply_rule() function) stay with those functions, even after you return from build_match_and_apply_functions(). That’s insanely cool.

If this is incredibly confusing (and it should be, this is weird stuff), it may become clearer when you see how to use it. diff --git a/iterators.html b/iterators.html index 5179037..b14131a 100644 --- a/iterators.html +++ b/iterators.html @@ -26,7 +26,7 @@ body{counter-reset:h1 6}

[download fibonacci2.py] 

class Fib:
-    """iterator that yields numbers in the Fibanocci sequence"""
+    """iterator that yields numbers in the Fibonacci sequence"""
 
     def __init__(self, max):
         self.max = max
@@ -79,7 +79,7 @@ class PapayaWhip:  ①
 
 

 class Fib:
-    """iterator that yields numbers in the Fibanocci sequence"""  ①
+    """iterator that yields numbers in the Fibonacci sequence"""  ①
 
     def __init__(self, max):                                      ②

 
    
@@ -104,7 +104,7 @@ class Fib:
 >>> fib.__class__              ③
 <class 'fibonacci2.Fib'>
 >>> fib.__doc__                ④
-'iterator that yields numbers in the Fibanocci sequence'
+'iterator that yields numbers in the Fibonacci sequence'
  1. You are creating an instance of the Fib class (defined in the fibonacci2 module) and assigning the newly created instance to the variable fib. You are passing one parameter, 100, which will end up as the max argument in Fib’s __init__() method.
  2. fib is now an instance of the Fib class. diff --git a/native-datatypes.html b/native-datatypes.html index a0e365b..fbcfc87 100644 --- a/native-datatypes.html +++ b/native-datatypes.html @@ -323,7 +323,7 @@ ValueError: list.index(x): x not in list >>> is_it_true([]) ② no, it's false >>> is_it_true(['a']) ③ -yes, it's true +yes, it's true >>> is_it_true([False]) ④ yes, it's true
      diff --git a/your-first-python-program.html b/your-first-python-program.html index 51b2a4b..9c6fbd1 100644 --- a/your-first-python-program.html +++ b/your-first-python-program.html @@ -81,7 +81,7 @@ if __name__ == "__main__":

      ☞In some languages, functions (that return a value) start with function, and subroutines (that do not return a value) start with sub. There are no subroutines in Python. Everything is a function, all functions return a value (even if it’s None), and all functions start with def.

      -

      The approximate_size function takes the two arguments — size and a_kilobyte_is_1024_bytes — but neither argument specifies a datatype. In Python, variables are never explicitly typed. Python figures out what type a variable is and keeps track of it internally. +

      The approximate_size() function takes the two arguments — size and a_kilobyte_is_1024_bytes — but neither argument specifies a datatype. In Python, variables are never explicitly typed. Python figures out what type a variable is and keeps track of it internally.

      ☞In Java and other statically-typed languages, you must specify the datatype of the function return value and each function argument. In Python, you never explicitly specify the datatype of anything. Based on what value you assign, Python keeps track of the datatype internally.

      @@ -90,7 +90,7 @@ if __name__ == "__main__":

      Python allows function arguments to have default values; if the function is called without the argument, the argument gets its default value. Futhermore, arguments can be specified in any order by using named arguments. -

      Let’s take another look at that approximate_size function declaration: +

      Let’s take another look at that approximate_size() function declaration: 

      def approximate_size(size, a_kilobyte_is_1024_bytes=True):
      @@ -136,7 +136,7 @@ SyntaxError: non-keyword arg after keyword arg

      Writing Readable Code

      I won’t bore you with a long finger-wagging speech about the importance of documenting your code. Just know that code is written once but read many times, and the most important audience for your code is yourself, six months after writing it (i.e. after you’ve forgotten everything but need to fix something). Python makes it easy to write readable code, so take advantage of it. You’ll thank me in six months.

      Documentation Strings

      -

      You can document a Python function by giving it a documentation string (docstring for short). In this program, the approximate_size function has a docstring: +

      You can document a Python function by giving it a documentation string (docstring for short). In this program, the approximate_size() function has a docstring: 

      def approximate_size(size, a_kilobyte_is_1024_bytes=True):
     """Convert a file size to human-readable form.