漢斯張 Hans Chang

python有簡單的語法來使用function decorators，但有可能造成一些不想要的副作用，例如可能會把help給覆蓋。

def trace(func):
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        print(f'{func.__name__}({args!r}, {kwargs!r}) -> {result!r}')
        return result
    return wrapper

@trace
def fibonacci(n):
    """Return the n-th Fibonacci number"""
    if n in (0, 1):
        return n
    return (fibonacci(n - 2) + fibonacci(n -1))

# @trace 等於是 fibonacci = trace(fibonacci)

fibonacci(4)

help(fibonacci)

import pickle
pickle.dumps(fibonacci)

fibonacci((0,), {}) -> 0
fibonacci((1,), {}) -> 1
fibonacci((2,), {}) -> 1
fibonacci((1,), {}) -> 1
fibonacci((0,), {}) -> 0
fibonacci((1,), {}) -> 1
fibonacci((2,), {}) -> 1
fibonacci((3,), {}) -> 2
fibonacci((4,), {}) -> 3
Help on function wrapper in module __main__:

wrapper(*args, **kwargs)

Traceback (most recent call last):
  File "C:/Users/hans/Desktop/item 26.py", line 22, in 
    pickle.dumps(fibonacci)
AttributeError: Can't pickle local object 'trace..wrapper'

在wrapper function加上wraps可以修好help跟pickle

from functools import wraps

def trace(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        print(f'{func.__name__}({args!r}, {kwargs!r}) -> {result!r}')
        return result
    return wrapper

help(fibonacci)
print(pickle.dumps(fibonacci))

Help on function fibonacci in module __main__:

fibonacci(n)
    Return the n-th Fibonacci number

b'\x80\x04\x95\x1a\x00\x00\x00\x00\x00\x00\x00\x8c\x08__main__\x94\x8c\tfibonacci\x94\x93\x94.'

def move(period, speed):
    for _ in range(period):
        yield speed

def pause(delay):
    for _ in range(delay):
        yield 0

def animate():
    for delta in move(4, 5.0):
        yield delta
    for delta in pause(3):
        yield delta
    for delta in move(2, 3.0):
        yield delta

def render(delta):
    print(f'Delta: {delta:.1f}')
    # Move the imgaes onscreen
    ...

def run(func):
    for delta in func():
        render(delta)

run(animate)

想像我們在螢幕上用不同速度輪播不同照片來做成動畫，有的時候也會在中間暫停一下。

Delta: 5.0
Delta: 5.0
Delta: 5.0
Delta: 5.0
Delta: 0.0
Delta: 0.0
Delta: 0.0
Delta: 3.0
Delta: 3.0

改用yield from不僅是看起來更簡潔，重點是可以獲得更佳的運算效能。

def animate_composed():
    yield from move(4, 5.0)
    yield from pause(3)
    yield from move(2, 3.0)

run(animate_composed)

使用print()時通常是輸出所謂human readable字串，但有時會反而會造成困擾

print(5)
#5
print('5')
#5

int_value = 5
str_value = '5'
print(f'{int_value} == {str_value} ?')
#5 == 5 ?

我們可能分不清這個變數是字串’5’還是數值「5」。

另外有些字元可能不是printable，故print會看不到東西。

這時候可以改用rerp()，會改成所謂的printable representation的輸出。

a = '\x07'
print(a)
#
print(repr(a))
#'\x07'

Python有一個eval()可以把representation轉回成變數，但要知道eval()很容易造成問題，不該輕易使用。

b = eval(repr(a))
assert a == b

print(repr(5))
#5
print(repr('5'))
#'5'
print(f'{int_value}r != {str_value}r')
#5r != 5r

一些自訂的object預設的print()輸出可能會不如預期

class OpaqueClass:
    def __init__(self, x, y):
        self.x = x
        self.y = y


obj = OpaqueClass(1, 'foo')
print(obj)

<main.OpaqueClass object at 0x037C9088>

我們可以用__repr__來設計repr()的預設行為，另外format string也可以用{}r來輸出
printable representation

class BetterClass:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __repr__(self):
        return f'BetterClass({self.x!r}, {self.y!r})'


obj = BetterClass(2, 'bar')
print(obj)

BetterClass(2, ‘bar’)

class BetterClass2:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __repr__(self):
        return f'BetterClass2({self.x!r}, {self.y!r})'
    def __str__(self):
        return f'in __str__ {self.x}, {self.y}'
    

obj = BetterClass2(3, 'bar')
print(obj)
print(repr(obj)

in __str__ 3, bar

BetterClass2(3, ‘bar’)

另外__str__可以設計print()的行為。

若__str__沒有修改，但有__repr__修改，print()會呼叫它。

obj = OpaqueClass(4, 'baz')
print(obj.__dict__)

{‘x’: 4, ‘y’: ‘baz’}

若不能修改物件，我們可以改用__dict__來得到物件的成員所組成的dict

stock = {
    'nails': 125,
    'screws': 35,
    'wingnuts': 8,
    'washers': 24,
}

def get_batches(count, size):
    return count // size

comprehensions是python常用的一個功能，可以快速生成list, dict, set等變數。但有時會出現一些重覆的計算…

order = ['screws', 'wingnuts', ' clips']

found = {name: get_batches(stock.get(name, 0), 8)
         for name in order
         if get_batches(stock.get(name, 0), 8)}
print(found)

{‘screws’: 4, ‘wingnuts’: 1}

現在我們可以用assignment expressions( :=，又稱walrus operator)來減少這些重覆語句的出現。

found = {name: batches for name in order
         if (batches := get_batches(stock.get(name, 0), 8))}

print(found)

不過要小心assignment expressions可能會汙染comprehensions外的scope，所以本書只建議在if的區域使用assignment expressions。

half = [(last := count // 2) for count in stock.values()]
print(last)
#12
print(batches)
#0

但實際上if區域的變數也是會汙染，書中的建議原因不太確定為何。

例如list之類有序的容器可以用sort這個方法來做排序，但若是其中的物件沒辨法比較時(沒有實作< operator)會產生Error，這時用用key傳入一個function回傳可比較的物件來代替。

class Tool:
    def __init__(self, name, weight):
        self.name = name
        self.weight = weight

    def __repr__(self):
        return f'Tool({self.name!r}, {self.weight})'


tools = [
    Tool('level', 3.5),
    Tool('hammer', 1.25),
    Tool('screwdriver', 0.5),
]

tools.sort()

TypeError: ‘<‘ not supported between instances of ‘Tool’ and ‘Tool’

我們可以用一個lamda function來讓Tool物件以name元素來做排序。

tools.sort(key=lamda x: x.name)
print(tools)

[Tool(‘hammer’, 1.25), Tool(‘level’, 3.5), Tool(‘screwdriver’, 0.5)]

或是回傳一個tuple，sort會依照順序來做比較。

tools = [
    Tool('sander', 4),
    Tool('drill', 4),
    Tool('circular saw', 0.5),
]

tools.sort(key=lambda x: (x.weight, x.name))
print(tools)

Tool(‘circular saw’, 0.5), Tool(‘drill’, 4), Tool(‘sander’, 4)]

另外可以用reverse參數或是負號來做反向排序

tools.sort(key=lambda x: (x.weight, x.name), reverse=True)
print(tools)

[Tool(‘sander’, 4), Tool(‘drill’, 4), Tool(‘circular saw’, 0.5)]

tools.sort(key=lambda x: (-x.weight, x.name), reverse=True)
print(tools)

[Tool(‘circular saw’, 0.5), Tool(‘sander’, 4), Tool(‘drill’, 4)]

Effective PYTHON 2rd

在使用dictionary時，若key值不存在時會產生KeyError，我們有四種方式可以處理。

counters = {
    'key1': 1,
    'key2': 2
}

key = 'key0'


#法一:
#先檢查key值是否存在
if key in counters:
    count = counters[key]
else:
    count = 0

counters[key] = count + 1


#法二:
#用try/except處理KeyError
try:
    count = counters[key]
except KeyError:
    count = 0

counters[key] = count+1


#法三:
#使用get
count = counters.get(key, 0)
counters[key] = count + 1


#法四:
#使用setdefault
counters.setdefault(key, 0)
counters[key] += 1

get會把第一個引數當作key回傳對應的value，若key不存在不會丟出KeyError而是會回傳第一個引數的值，在此例中就會回傳0。若是沒有第二個引數會回傳None，在此例中應該比較推薦用get的用法。

而setdefault則會把value直接用第二個引數修改。通常是適合用在value是container的狀況，但書中建議這種情況可能要考慮用defaultdic來代替一般的dictionary。

key = 'key0'
votes = {
    'key1': ['Bob', 'Alice'],
    'key2': ['Coco']
}

names = votes.get(key)
if names is None:
    votes[key] = names = []

#或是用 := (Walrus Operator, assignment expression)
if (names := votes.get(key)) is None:
    votes[key] = names = []

#這種情況用setdefault最簡潔
names = votes.setdefault(key, [])

這本書不如“鳳凰計畫”有名，但我認為就算看過“鳳凰計畫”的人也還是很值得一讀。這本書會把“鳳凰計畫”裡面提到的「三步工作法」詳盡說明，但這本書所提的devops並沒有明確指出要用的流程或是工具，比較偏概念還有各公司採用的devops元素作簡介。

再對本書內容介紹前，我先以自己的解讀做總結。

1. 自動化開發——bug, feature, 需求的自動化管理。並非只有coding的流程，所有高層主管以及客戶提出的需求都要有自動化的紀錄與追蹤。這樣才能統計所有的意見實行的狀況與成果。
2. 自動化測試與部署——這是大部分人所以為的devops，但只有這個部分是沒有辦法達成devops的精神
3. 自動化監控——除了監控以外，還要能提供客觀的方式來做評估產品。
4. 部署後自動化測試——這也可算是監控的一部分，但自動化的測試可以提供更可靠且客觀的評估。更激烈的手段如“搗亂猴”，甚至主動內部攻擊來做測試。
5. 將上述步驟以程式化自動執行，反覆循環執行並改進。
6. 創造由上而下的devops文化，而非只是任命或雇用devops工程師。

目前大部份的devops可能都只關注在第二點，但實際上要從一到五點重覆循環改進才是真正的devops精神。

三步工作法其實是有很多抽象的概念與文化，自動化也只是手段之一。所以我認為最最重要的點還是第六點，要達成的最好方法就是推薦你的同事或主管來閱讀這本書。