update chpt 01 & 02

Author: zjkang

.gitignore

@@ -1 +1,2 @@
 .DS_Store
+!**/__pycache__/

python/fluent_python/01-data-model/frenchdeck.doctest

@@ -0,0 +1,54 @@
+>>> from frenchdeck import FrenchDeck, Card
+>>> beer_card = Card('7', 'diamonds')
+>>> beer_card
+Card(rank='7', suit='diamonds')
+>>> deck = FrenchDeck()
+>>> len(deck)
+52
+>>> deck[:3]
+[Card(rank='2', suit='spades'), Card(rank='3', suit='spades'), Card(rank='4', suit='spades')]
+>>> deck[12::13]
+[Card(rank='A', suit='spades'), Card(rank='A', suit='diamonds'), Card(rank='A', suit='clubs'), Card(rank='A', suit='hearts')]
+>>> Card('Q', 'hearts') in deck
+True
+>>> Card('Z', 'clubs') in deck
+False
+>>> for card in deck:  # doctest: +ELLIPSIS
+...   print(card)
+Card(rank='2', suit='spades')
+Card(rank='3', suit='spades')
+Card(rank='4', suit='spades')
+...
+>>> for card in reversed(deck):  # doctest: +ELLIPSIS
+...   print(card)
+Card(rank='A', suit='hearts')
+Card(rank='K', suit='hearts')
+Card(rank='Q', suit='hearts')
+...
+>>> for n, card in enumerate(deck, 1):  # doctest: +ELLIPSIS
+...   print(n, card)
+1 Card(rank='2', suit='spades')
+2 Card(rank='3', suit='spades')
+3 Card(rank='4', suit='spades')
+...
+>>> suit_values = dict(spades=3, hearts=2, diamonds=1, clubs=0)
+>>> def spades_high(card):
+...     rank_value = FrenchDeck.ranks.index(card.rank)
+...     return rank_value * len(suit_values) + suit_values[card.suit]
+
+Rank test:
+
+>>> spades_high(Card('2', 'clubs'))
+0
+>>> spades_high(Card('A', 'spades'))
+51
+
+>>> for card in sorted(deck, key=spades_high):  # doctest: +ELLIPSIS
+...      print(card)
+Card(rank='2', suit='clubs')
+Card(rank='2', suit='diamonds')
+Card(rank='2', suit='hearts')
+...
+Card(rank='A', suit='diamonds')
+Card(rank='A', suit='hearts')
+Card(rank='A', suit='spades')

python/fluent_python/01-data-model/frenchdeck.py

@@ -0,0 +1,24 @@
+import collections
+
+Card = collections.namedtuple('Card', ['rank', 'suit'])
+
+# python3 -m doctest frenchdeck.doctest -v
+
+# python的special methods(magic method)的使用例子
+# 支持sequence的操作
+# __getitem__ delegates to the [] operator
+
+
+class FrenchDeck:
+    ranks = [str(n) for n in range(2, 11)] + list('JQKA')
+    suits = 'spades diamonds clubs hearts'.split()
+
+    def __init__(self):
+        self._cards = [Card(rank, suit) for suit in self.suits
+                                        for rank in self.ranks]
+
+    def __len__(self):
+        return len(self._cards)
+
+    def __getitem__(self, position):
+        return self._cards[position]

python/fluent_python/01-data-model/vector2d.doctest

@@ -0,0 +1,12 @@
+>>> from vector2d import Vector
+>>> v1 = Vector(2, 4)
+>>> v2 = Vector(2, 1)
+>>> v1 + v2
+Vector(4, 5)
+>>> v = Vector(3, 4)
+>>> abs(v)
+5.0
+>>> v * 3
+Vector(9, 12)
+>>> abs(v * 3)
+15.0

python/fluent_python/01-data-model/vector2d.py

@@ -0,0 +1,55 @@
+"""
+vector2d.py: a simplistic class demonstrating some special methods
+
+It is simplistic for didactic reasons. It lacks proper error handling,
+especially in the ``__add__`` and ``__mul__`` methods.
+
+This example is greatly expanded later in the book.
+
+Addition::
+
+    >>> v1 = Vector(2, 4)
+    >>> v2 = Vector(2, 1)
+    >>> v1 + v2
+    Vector(4, 5)
+
+Absolute value::
+
+    >>> v = Vector(3, 4)
+    >>> abs(v)
+    5.0
+
+Scalar multiplication::
+
+    >>> v * 3
+    Vector(9, 12)
+    >>> abs(v * 3)
+    15.0
+
+"""
+
+
+import math
+
+class Vector:
+
+    def __init__(self, x=0, y=0):
+        self.x = x
+        self.y = y
+
+    def __repr__(self):
+        return f'Vector({self.x!r}, {self.y!r})'
+
+    def __abs__(self):
+        return math.hypot(self.x, self.y)
+
+    def __bool__(self):
+        return bool(abs(self))
+
+    def __add__(self, other):
+        x = self.x + other.x
+        y = self.y + other.y
+        return Vector(x, y)
+
+    def __mul__(self, scalar):
+        return Vector(self.x * scalar, self.y * scalar)

python/fluent_python/02-array-seq/array-seq-01.py

@@ -0,0 +1,74 @@
+"""
+List Comprehensions and Generator Expressions
+
+built-in sequences
+- container sequences: list, tuple, collections.deque
+- flat sequences: str, bytes, array.array
+
+memory diagram for tuple and array (Figure 2-1, page 23)
+
+- mutable sequences: list, bytearray, array.array, collections.deque
+- immutable sequences: tuple, str, bytes
+
+Built-in concrete sequence types do not subclass the Sequence and MutableSequence
+abstract base classes (ABCs), but they are virtual subclasses, rigistered with those ABCs
+(Chapter 13)
+
+List Comprehensions
+
+Generator Expressions
+save memory because it yields items one by one using iterator protocol instead of
+building a whole list just to feed another constructor
+
+https://github.com/fluentpython/example-code-2e/tree/master/02-array-seq
+https://github.com/fluentpython/example-code-2e/blob/master/02-array-seq/array-seq.ipynb
+"""
+
+from collections import abc
+issubclass(tuple, abc.Sequence) # True
+issubclass(list, abc.MutableSequence) # True
+
+import array
+a=array.array('d',[1,2,3])
+# >>> a
+# array('d', [1.0, 2.0, 3.0])
+
+
+symbols = '$¢£¥€¤'
+codes = []
+for symbol in symbols:
+    codes.append(ord(symbol))
+codes
+
+symbols = '$¢£¥€¤'
+codes = [ord(symbol) for symbol in symbols]
+codes
+
+# assignment expression (walnut operator)
+codes = [last := ord(c) for c in x]
+last
+
+symbols = '$¢£¥€¤'
+beyond_ascii = [ord(s) for s in symbols if ord(s) > 127]
+beyond_ascii
+
+beyond_ascii = list(filter(lambda c: c > 127, map(ord, symbols)))
+beyond_ascii
+
+colors = ['black', 'white']
+sizes = ['S', 'M', 'L']
+tshirts = [(color, size) for color in colors for size in sizes]
+tshirts
+
+
+# Initializing a tuple and an array from a generator expression
+symbols = '$¢£¥€¤'
+tuple(ord(symbol) for symbol in symbols)
+
+import array
+array.array('I', (ord(symbol) for symbol in symbols))
+
+colors = ['black', 'white']
+sizes = ['S', 'M', 'L']
+for tshirt in ('%s %s' % (c, s) for c in colors for s in sizes):
+    print(tshirt)

python/fluent_python/02-array-seq/array-seq-02.py

@@ -0,0 +1,48 @@
+"""
+Tuples As Records VS Are Not Just Immutable Lists
+
+- Tuples used as records (unnamed)
+- Tuples as Immutable Lists
+
+To evaluate a tuple literal, Python compiler generates bytecode for a tuple constant
+in one operation
+
+Given a tuple t, tuple(t) simply returns a reference to the same t. There is no need to copy.
+"""
+
+# Tuples used as records
+lax_coordinates = (33.9425, -118.408056)
+city, year, pop, chg, area = ('Tokyo', 2003, 32_450, 0.66, 8014)
+traveler_ids = [('USA', '31195855'), ('BRA', 'CE342567'), ('ESP', 'XDA205856')]
+
+for passport in sorted(traveler_ids):
+    print('%s/%s' % passport)
+
+
+for country, _ in traveler_ids:
+    print(country)
+
+
+# Tuples as Immutable Lists
+a = (10, 'alpha', [1, 2])
+b = (10, 'alpha', [1, 2])
+a == b # True
+
+b[-1].append(99) # (10, 'alpha', [1, 2, 99])
+a == b # False
+
+
+# an object is only hashable if its value cannot ever change.
+# An unhashable tuple cannot be inserted as a dict key or a set element
+def fixed(o):
+    try:
+        hash(o)
+    except TypeError:
+        return False
+    return True
+
+
+tf = (10, 'alpha', (1, 2))  # Contains no mutable items
+tm = (10, 'alpha', [1, 2])  # Contains a mutable item (list)
+fixed(tf) # True
+fixed(tm) # False

python/fluent_python/02-array-seq/array-seq-03.py

@@ -0,0 +1,85 @@
+"""
+Sequence unpacking and sequence patterns
+
+edge cases:
+  [record] with only one record in list
+  (record,) with only one record in tuple
+
+- Sequence unpacking
+- Pattern Matching with Sequences
+    - Instances of str, byte, and bytearray are not handled as sequences in the context of match/case
+    - Unlike unpacking, patterns do NOT destructure iterables that are not sequences (e.g., iterators)
+    - case [name, _, _, (lat, lon) as coord]: # bind any part of a pattern with a variable using the as keyword
+    - case [name, *_, (float(lat), float(lon))]:
+"""
+
+# -- Sequence unpacking --
+# Using * to grab excess items
+lax_coordinates = (33.9425, -118.408056)
+latitude, longitude = lax_coordinates  # unpacking
+latitude
+
+t = (20, 8)
+divmod(*t) # (2, 4)
+quotient, remainder = divmod(*t)
+
+import os
+_, filename = os.path.split('/home/luciano/.ssh/id_rsa.pub')
+filename
+
+a, b, *rest = range(5)
+a, b, rest # (0, 1, [2, 3, 4])
+
+a, b, *rest = range(2)
+a, b, rest # (0, 1, [])
+
+a, *body, c, d = range(5)
+a, body, c, d # (0, [1, 2], 3, 4)
+
+*head, b, c, d = range(5)
+head, b, c, d # ([0, 1], 2, 3, 4)
+
+
+# Unpacking with * in function calls and sequence literals
+def fun(a, b, c, d, *rest):
+    return a, b, c, d, rest
+
+
+fun(*[1, 2], 3, *range(4, 7)) # (1, 2, 3, 4, (5, 6))
+*range(4), 4 # (0, 1, 2, 3, 4)
+[*range(4), 4] # [0, 1, 2, 3, 4]
+{*range(4), 4, *(5, 6, 7)} # {0, 1, 2, 3, 4, 5, 6, 7}
+
+
+# -- Pattern Matching with Sequences --
+# match/case sequence handlings
+# sequence pattern can be tuples or lists or any combination of nested tuples and lists.
+metro_areas = [
+    ('Tokyo', 'JP', 36.933, (35.689722, 139.691667)),
+    ('Delhi NCR', 'IN', 21.935, (28.613889, 77.208889)),
+    ('Mexico City', 'MX', 20.142, (19.433333, -99.133333)),
+    ('New York-Newark', 'US', 20.104, (40.808611, -74.020386)),
+    ('São Paulo', 'BR', 19.649, (-23.547778, -46.635833)),
+]
+
+def main():
+    print(f'{"":15} | {"latitude":>9} | {"longitude":>9}')
+    for record in metro_areas:
+        match record:
+            case [name, _, _, (lat, lon)] if lon <= 0:
+                print(f'{name:15} | {lat:9.4f} | {lon:9.4f}')
+main()
+#                 |  latitude | longitude
+# Mexico City     |   19.4333 |  -99.1333
+# New York-Newark |   40.8086 |  -74.0204
+# São Paulo       |  -23.5478 |  -46.6358
+
+
+# Instances of str, byte, and bytearray are not handled as sequences in the context of match/case
+# match tuple(phone):
+#     case ['1', *rest]:
+#         ...
+#     case ['2', *rest]:
+#         ...
+#     case ['3' | '4', *rest]:
+#         ...