[読書] Python クックブック 第2版 読んでみる。第1章-その2

間があいたけど、第1章-その２。結構、勉強になることあるよね。
肩肘張らず、楽しく、ゆる～くがモットーです。

---

1.13 文字列の一部にアクセスする
structモジュールを使う。サンプルの方法は3だとエラー。

ドキュメントから
3.x
This module performs conversions between Python values and C structs represented as Python bytes objects.
2.x
This module performs conversions between Python values and C structs represented as Python strings.

ほう、バイト型にですか。

view plainprint?

1. >>> baseformat = "5s 3x 8s 8s"  
2. >>> numremain = len("123456781234567812345678")-struct.calcsize(baseformat)  
3. >>> format = "%s %ds" % (baseformat, numremain)  
4. >>> leading, s1, s2, trailing = struct.unpack(format, b"123456781234567812345678")  
5. >>> s1  
6. b'12345678'  
7. >>> s2  
8. b'12345678'  
9. >>> leading  
10. b'12345'  
11. >>> trailing  
12. b''  
13. >>>   
14.   
15.   
16. くっつける  
17. >>> struct.pack(format,leading, s1, s2, trailing)  
18. b'12345\x00\x00\x001234567812345678'  

>>> baseformat = "5s 3x 8s 8s"
>>> numremain = len("123456781234567812345678")-struct.calcsize(baseformat)
>>> format = "%s %ds" % (baseformat, numremain)
>>> leading, s1, s2, trailing = struct.unpack(format, b"123456781234567812345678")
>>> s1
b'12345678'
>>> s2
b'12345678'
>>> leading
b'12345'
>>> trailing
b''
>>> 


くっつける
>>> struct.pack(format,leading, s1, s2, trailing)
b'12345\x00\x00\x001234567812345678'

---

1.14 インデントの変更

例外の部分を3に合わせて

view plainprint?

1. def addSpace(s,numAdd):  
2.  """行頭に指定数の空白を付与する。"""  
3.  white=" "*numAdd  
4.  return white + white.join(s.splitlines(True))  
5.      
6. def numSpace(s):  
7.  """各行の行頭にあるスペース数を、リスト形式で戻す"""  
8.  return [len(line)-len(line.lstrip()) for line in s.splitlines()]  
9.   
10.   
11. def delSpace(s,numDel):  
12.  """行頭から指定したスペース分をスライスした（除去した行を返す）"""  
13.  if numDel > min(numSpace(s)):  
14.   raise ValueError("removing more spaces than there are")  
15.  return '\n'.join([ line[numDel:] for line in s.splitlines() ])  
16.   
17.    
18. def unIndntBlock(s):  
19.  """一番インデントの小さいものに合わせて成形する"""  
20.  return delSpace(s,min(numSpace(s)))  

def addSpace(s,numAdd):
 """行頭に指定数の空白を付与する。"""
 white=" "*numAdd
 return white + white.join(s.splitlines(True))
   
def numSpace(s):
 """各行の行頭にあるスペース数を、リスト形式で戻す"""
 return [len(line)-len(line.lstrip()) for line in s.splitlines()]


def delSpace(s,numDel):
 """行頭から指定したスペース分をスライスした（除去した行を返す）"""
 if numDel > min(numSpace(s)):
  raise ValueError("removing more spaces than there are")
 return '\n'.join([ line[numDel:] for line in s.splitlines() ])

 
def unIndntBlock(s):
 """一番インデントの小さいものに合わせて成形する"""
 return delSpace(s,min(numSpace(s)))

試してみる。
空白が3,2,4個行頭にあるとする。
>>> s=' Hello\n world!\n goodbye'
>>> min(numSpace(s))
2
>>> print(unIndntBlock(s))
Hello
world!
goodbye
>>>
各行の行頭からスペースが2個削除。

---

1.15 タブとスペースの変換

スペースをタブに変更する。
サンプルだとダブルバイトが入ると変になったので、str.encode()のlen()を取得するように変更してみた。

view plainprint?

1. def unexpand(astring, tablen=2):  
2.     import re  
3.     #スペースと非スペースに切断する。  
4.     pices = re.split(r'( +)', astring.expandtabs(tablen))  
5.     #全体の長さを初期化  
6.     lensofar = 0  
7.     for i,piece in enumerate(pices):  
8.         #要素の長さ  
9.         thislen = len(str.encode(piece))  
10.         #全体の長さ  
11.         lensofar += thislen  
12.         if piece.isspace():  
13.             #要素の長さをタブ1個のスペース数で割る。余りがタブに出来ない分なのでスペースになる。  
14.             numblanks = thislen % tablen  
15.             numtabs = (thislen - numblanks + tablen - 1)//tablen  
16.             pices[i] = '\t'*numtabs + ' '*numblanks  
17.     return ''.join(pices)  

def unexpand(astring, tablen=2):
    import re
    #スペースと非スペースに切断する。
    pices = re.split(r'( +)', astring.expandtabs(tablen))
    #全体の長さを初期化
    lensofar = 0
    for i,piece in enumerate(pices):
        #要素の長さ
        thislen = len(str.encode(piece))
        #全体の長さ
        lensofar += thislen
        if piece.isspace():
            #要素の長さをタブ1個のスペース数で割る。余りがタブに出来ない分なのでスペースになる。
            numblanks = thislen % tablen
            numtabs = (thislen - numblanks + tablen - 1)//tablen
            pices[i] = '\t'*numtabs + ' '*numblanks
    return ''.join(pices)

2個の空白があえばタブにする。
>>> unexpand("1234 567   890  あ あ   い")
'1234 567\t 890\tあ あ\t い'

---

1.18 一度に複数のパターンを置換する

view plainprint?

1. import re  
2. def multiple_replace(txt,adict):  
3. #1.辞書の内容にメタキャラが含まれる可能性がるので、escapeする。  
4. #mapでキーを取りだし|で結合。検索パターンの作成。  
5. rx = re.compile('|'.join(map(re.escape,adict)))  
6. #引数はマッチオブジェクト  
7. def one_xlat(match):  
8. return adict[match.group(0)]  
9. #検索にヒットするたびに、マッチオブジェクトを引数に関数をコールバック。  
10. return rx.sub(one_xlat,txt)  

import re
def multiple_replace(txt,adict):
#1.辞書の内容にメタキャラが含まれる可能性がるので、escapeする。
#mapでキーを取りだし|で結合。検索パターンの作成。
rx = re.compile('|'.join(map(re.escape,adict)))
#引数はマッチオブジェクト
def one_xlat(match):
return adict[match.group(0)]
#検索にヒットするたびに、マッチオブジェクトを引数に関数をコールバック。
return rx.sub(one_xlat,txt)

まず、検索パターンを作成する。縦棒で検索文字列をつなぎ、compileする。
そして、re.subに置換文字列の代わりに、コールバック関数を渡す。
こうした場合re.subではマッチが起きるたびにコールバック引数オブジェクトをコールする。
その際、コールバック引数オブジェクトへの唯一の引数は、re.MatchObjectインスタンスが自動的に渡される。

簡単な例だと、以下な感じ。
>>> import re
>>> rx = re.compile('a|b|c')
>>> def hoge(match):
return "x"

>>> print(rx.sub(hoge,'abc45'))
xxx45
>>> def hoge(match):
print(match.group(0))
return "x"

>>> print(rx.sub(hoge,'abc45'))
a
b
c
xxx45
>>>

multiple_replaceはコールされるたびに、正規表現の再計算とone_xlat補助関数の再定義が走るので、
クロージャ・アプローチの方が良い。
元サンプルの可変長引数 *argsは不要というか、結局辞書化する必要が出てくるしなぁ。
dictに*args,**kwdsと2個渡すところでエラーになったので辞書だけにした。

view plainprint?

1. import re  
2. def make_xlat(**kwds):  
3. adict = dict(**kwds)  
4. rx = re.compile('|'.join(map(re.escape ,adict)))  
5. def one_xlat(match):  
6. return adict[match.group(0)]  
7. def xlat(text):  
8. return rx.sub(one_xlat, text)  
9. return xlat  

import re
def make_xlat(**kwds):
adict = dict(**kwds)
rx = re.compile('|'.join(map(re.escape ,adict)))
def one_xlat(match):
return adict[match.group(0)]
def xlat(text):
return rx.sub(one_xlat, text)
return xlat

動かしてみよう。
>>> adict={
"Larry Wall":"Hoge",
"creator":"killer",
"Perl":"World",
}
>>> text="Larry Wall is the creator of Perl"

こうでも良いし。
>>> fnc=make_xlat(**adict)
>>> fnc(text)
'Hoge is the killer of World'
>>>

こうしてもいいわけね。
>>> fnc=make_xlat(Perl="World",the="ssss")
>>> fnc(text)
'Larry Wall is ssss creator of World'
>>>

置換方法にバリエーションを持たせたい->（単語単位）場合に置換したいとか。
クラス化して継承を利用する。

view plainprint?

1. import re  
2. """ 
3. 基底クラス 
4. """  
5. class make_xlat():  
6. def __init__(self, **kwds):  
7. self.adict = dict(**kwds)  
8. self.rx = self.make_rx()  
9. def make_rx(self):  
10. return re.compile('|'.join(map(re.escape,self.adict)))  
11. def one_xlat(self,match):  
12. return self.adict[match.group(0)]  
13. def __call__(self,text):  
14. return self.rx.sub(self.one_xlat,text)  

import re
"""
基底クラス
"""
class make_xlat():
def __init__(self, **kwds):
self.adict = dict(**kwds)
self.rx = self.make_rx()
def make_rx(self):
return re.compile('|'.join(map(re.escape,self.adict)))
def one_xlat(self,match):
return self.adict[match.group(0)]
def __call__(self,text):
return self.rx.sub(self.one_xlat,text)

view plainprint?

1. import make_xlat  
2. import re  
3. """ 
4. 派生クラス 
5. """  
6. class make_xlat_by_wh_word(make_xlat.make_xlat):  
7. def make_rx(self):  
8. return re.compile(r'\b%s\b' % r'\b|\b'.join(map(re.escape,self.adict)))  

import make_xlat
import re
"""
派生クラス
"""
class make_xlat_by_wh_word(make_xlat.make_xlat):
def make_rx(self):
return re.compile(r'\b%s\b' % r'\b|\b'.join(map(re.escape,self.adict)))

単語単位にマッチしているので、PerlsはWorldに置換されない。
>>> fnc=make_xlat_wh_word.make_xlat_by_wh_word(**adict)
>>> fnc(text)
'Hoge is the killer of Perls'

---

1.24 一部の文字列のみ大文字小文字無関係にする

strを継承したクラスを作成。

view plainprint?

1. class iStr(str):  
2.     """ 
3.     str継承。検索と比較は大文字小文字を無視。 
4.     """  
5.     def __init__(self,*args):  
6.         self._lowered = str.lower(self)  
7.     def __repr__(self):  
8.         return '%s(%s)' % (type(self).__name__,str.__repr__(self))  
9.     def __hash__(self):  
10.         return hash(self._lowered)  
11.     def lower(self):  
12.         return self._lowered  

class iStr(str):
    """
    str継承。検索と比較は大文字小文字を無視。
    """
    def __init__(self,*args):
        self._lowered = str.lower(self)
    def __repr__(self):
        return '%s(%s)' % (type(self).__name__,str.__repr__(self))
    def __hash__(self):
        return hash(self._lowered)
    def lower(self):
        return self._lowered

strのメソッドをラップ。

view plainprint?

1. def _make_case_insensitive(name):  
2.     str_meth = getattr(str,name)  
3.     def x(self,other,*args):  
4.         try: other = other.lower()  
5.         except(TypeError ,AttributeError ,ValueError ): pass  
6.         return str_meth(self._lowered,other,*args)  
7.     #Python2.4 late add x.func_name=name  
8.     x.func_name=name  
9.     setattr(iStr, name, x)  

def _make_case_insensitive(name):
    str_meth = getattr(str,name)
    def x(self,other,*args):
        try: other = other.lower()
        except(TypeError ,AttributeError ,ValueError ): pass
        return str_meth(self._lowered,other,*args)
    #Python2.4 late add x.func_name=name
    x.func_name=name
    setattr(iStr, name, x)

case insensitiveとして扱うものを属性に追加

view plainprint?

1. for name in 'eq lt le gt ne contains'.split():  
2.     _make_case_insensitive('__%s__' % name)  
3.   
4. for name in 'count endswith find index rfind rindex startswith'.split():  
5.     _make_case_insensitive(name)  

for name in 'eq lt le gt ne contains'.split():
    _make_case_insensitive('__%s__' % name)

for name in 'count endswith find index rfind rindex startswith'.split():
    _make_case_insensitive(name)

こうなるものが、
>>> HOGE="Test"
>>> HOGE.startswith("t")
False

こうなるよと。
>>> FOO=iStr("Test")
>>> FOO.startswith("t")
True

このレシピは、ケースインセンシティブなコンテナ型などを作る際に応用が利く。

ケースインセンシティブなリスト。iListの各itemがiStrでラップされるだけ。

view plainprint?

1. class iList(list):  
2.  def __init__(self,*args):  
3.   self[:] = self  
4.  wrap_each_item = iStr  
5.  def __setitem__(self,i,v):  
6.   if isinstance(i,slice): v = map(self.wrap_each_item,v)  
7.   else: v = self.wrap_each_item(v)  
8.   list.__setitem__(self,i,v)  
9.  def append(self,item):  
10.   list.append(self,self.wrap_each_item(item))  
11.  def extend(self,seq):  
12.   list.extend(self,map(self.wrap_each_item,seq))  

class iList(list):
 def __init__(self,*args):
  self[:] = self
 wrap_each_item = iStr
 def __setitem__(self,i,v):
  if isinstance(i,slice): v = map(self.wrap_each_item,v)
  else: v = self.wrap_each_item(v)
  list.__setitem__(self,i,v)
 def append(self,item):
  list.append(self,self.wrap_each_item(item))
 def extend(self,seq):
  list.extend(self,map(self.wrap_each_item,seq))

>>> WARA=iList()
>>> WARA
[]
>>> WARA.append("a")
>>> WARA.append("b")
>>> WARA.append("c")
>>>
>>> WARA
[iStr('a'), iStr('b'), iStr('c')]
>>> WARA.append("A")
>>> WARA
[iStr('a'), iStr('b'), iStr('c'), iStr('A')]
>>>
>>> WARA.count("a")
2
>>>

[Python][翻訳]続・関数デコレータ

前回に続いて、Ariel OrtizのBlogからの翻訳ネタ。
初心者にも理解しやすい素敵な内容。

内容に少しでもオカシイところがあれば、 それは私の責です。
原文あたって下さいませ。突っ込みもお願いします。
More On Function Decorators

---

More On Function Decorators

前回の投稿で、Pythonでどのように、関数デコレータを使うか２，３の例をあげたが、これらの例は、未だかなり制限されて例示されている。まず第一に、その関数は一つだけの位置引数を受け取ってデコレートされると仮定していた。もし、2つ以上の位置引数や、一つかそれ以上のキーワード引数をとる関数をデコレートしたい場合、何ができるだろう？
第二に、任意の特別な方法で設定するデコレータを許可していなかった。 では、その動作を変える事が出来るように、どうやってデコレータ自身に入力引数を渡せばよいのだろう？

今から、もう少し複雑な例で詳しく説明する。その例は、上記のいずれの制限も持たない、もっと一般的な関数デコレータをどの様に定義するのか？について、より良い知見を与えてくれるだろう。

 NOTE:ここで例示する、すべてのPythonコードはPython3に基づいている。
ソースコードの全文は以下。

デコレートされた関数が実行中にraiseする、一つか、それ以上の種類の例外に対して、「例外の飲み込み」ができる関数デコレーターが欲しいとする。

もし、特定の一つの例外が実際に生成されたら、例外が実行スタックを伝播して、プログラム終了の原因になることを許可する代わりに、返されるデフォルト値を指定できるようにしたい。デコレーターのクライアントは、基本的に、明示的なtry節を書くための努力をしなくてもよくなる。

どのようにこれが動くか、デモンストレートするために、我々にはこれのような関数があるとしよう。：

view plainprint?

1. def divide(dividend=0, divisor=1):  
2.     return dividend / divisor  

def divide(dividend=0, divisor=1):
    return dividend / divisor

この関数を呼んだ場合、ZeroDivisionError と TypeErrorの、最低２つの例外が発生する可能性がある。最初の例外はdivisorパラメーターがゼロの時に発生する。
２番目の例外は、２つのパラメータのどれかが、数値タイプではない時、２つより多いパラメータが送られた時、存在しないキーワードパラメーターを使おうとした場合、に発生する。

例としては

view plainprint?

1. >>> divide(1, 2)  
2. 0.5  
3.   
4. >>> divide(1, 0)  
5. Traceback (most recent call last):  
6.   File "<stdin>", line 1, in <module>  
7.   File "<stdin>", line 2, in divide  
8. ZeroDivisionError: int division or modulo by zero  
9.   
10. >>> divide("hello")  
11. Traceback (most recent call last):  
12.   File "<stdin>", line 1, in <module>  
13.   File "<stdin>", line 2, in divide  
14. TypeError: unsupported operand type(s) for /: 'str'   
15. and 'int'   
16.   
17. >>> divide(whatever=1)  
18. Traceback (most recent call last):  
19.   File "<stdin>", line 1, in <module>  
20. TypeError: divide() got an unexpected keyword   
21. argument 'whatever'  

>>> divide(1, 2)
0.5

>>> divide(1, 0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in divide
ZeroDivisionError: int division or modulo by zero

>>> divide("hello")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in divide
TypeError: unsupported operand type(s) for /: 'str' 
and 'int' 

>>> divide(whatever=1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: divide() got an unexpected keyword 
argument 'whatever'

我々の”例外飲み込み”デコレーターは２つのキーワードパラメータを受け取る。

* exceptions:一つの例外クラスまたは、いくつかの例外クラスを含む一つのタプル。これらは”飲み込まれる”べき例外をあらわしている。
それ以外の全ての例外は通常通り、伝播する。もし、明示的な指定がなければ、デフォルトはBaseException（Pythonの例外階層のルート）。
* default: もし、指定した例外が発生した場合に返される値。明示的な指定がなければ、デフォルトはNoneである。

さあ、３つの使用例を見てみよう。
Example 1: もし、ゼロ除算がおこなわれたら、0を返す。

view plainprint?

1. @swallow(exceptions=ZeroDivisionError, default=0)  
2. def divide(dividend=0, divisor=1):  
3.     return dividend / divisor  

@swallow(exceptions=ZeroDivisionError, default=0)
def divide(dividend=0, divisor=1):
    return dividend / divisor

Example 2:もし、ZeroDivisionErrorか、TypeErrorが発生したら、0を返す。

view plainprint?

1. @swallow(  
2.     exceptions=(ZeroDivisionError, TypeError),   
3.     default=0)  
4. def divide(dividend=0, divisor=1):  
5.     return dividend / divisor  

@swallow(
    exceptions=(ZeroDivisionError, TypeError), 
    default=0)
def divide(dividend=0, divisor=1):
    return dividend / divisor

Example 3:二つの、デコレーターを連鎖させる。そうすることで、それぞれの指定した例外に、独自のデフォルト値を持たせることができる。

view plainprint?

1. @swallow(exceptions=TypeError, default='Huh?')  
2. @swallow(exceptions=ZeroDivisionError, default=0)  
3. def divide(dividend=0, divisor=1):  
4.     return dividend / divisor  

@swallow(exceptions=TypeError, default='Huh?')
@swallow(exceptions=ZeroDivisionError, default=0)
def divide(dividend=0, divisor=1):
    return dividend / divisor

これが、最後の例における、デコレートされたdivide関数を使う方法だ。

view plainprint?

1. >>> divide(1, 2)  
2. 0.5  
3. >>> divide(1, 0)  
4. 0  
5. >>> divide("hello")  
6. 'Huh?'  

>>> divide(1, 2)
0.5
>>> divide(1, 0)
0
>>> divide("hello")
'Huh?'

”例外飲み込み”デコレーターを実装するために、我々はどのように@構文が動くのか、よく見なければならない。@記号の後に、評価時に呼び出し可能なオブジェクトを生成する一つの式を、実際に指定する必要がある。この呼び出し可能なオブジェクトを効果的に呼ぶと、唯一の引数として、デコレートされる関数を受け取る。そして同じ関数か、いくつかの新しい呼び出し可能なものを返す。

@記号の後ろの式は、一般的には関数の名前（デコレータ関数）だけだが、１）と２）も、また可能だ。
１）__call__メドッドの実装を含んだ、一つの新しいクラスのインスタンス。
２）他の関数の呼び出し。
これらの両方のオプションで、インプットパラメータを介して指定することにより、デコレーターに追加の情報を渡すことができる。

__call__ メソッドを定義した、クラスを使う最初の実装は、次のようにして実現できる。

view plainprint?

1. class swallow:  
2.       
3.     class helper:  
4.           
5.         def __init__(self, outer, fun):  
6.             self.outer = outer  
7.             self.fun = fun              
8.               
9.         def __call__(self, *args, **kwargs):  
10.             try:  
11.                 return self.fun(*args, **kwargs)  
12.             except self.outer.exceptions:  
13.                 return self.outer.default  
14.       
15.     def __init__(self,   
16.                  default=None,   
17.                  exceptions=BaseException):  
18.         self.default = default  
19.         self.exceptions = exceptions  
20.           
21.     def __call__(self, fun):                              
22.         return swallow.helper(self, fun)  

class swallow:
    
    class helper:
        
        def __init__(self, outer, fun):
            self.outer = outer
            self.fun = fun            
            
        def __call__(self, *args, **kwargs):
            try:
                return self.fun(*args, **kwargs)
            except self.outer.exceptions:
                return self.outer.default
    
    def __init__(self, 
                 default=None, 
                 exceptions=BaseException):
        self.default = default
        self.exceptions = exceptions
        
    def __call__(self, fun):                            
        return swallow.helper(self, fun)

どうやってこれが、動くか理解しよう。コードは以下。

view plainprint?

1. @swallow(exceptions=ZeroDivisionError, default=0)  
2. def divide(dividend=0, divisor=1):  
3.     return dividend / divisor  

@swallow(exceptions=ZeroDivisionError, default=0)
def divide(dividend=0, divisor=1):
    return dividend / divisor

上記は、基本的に以下と同じものである。

view plainprint?

1. def divide(dividend=0, divisor=1):  
2.     return dividend / divisor       
3. divide = swallow(exceptions=ZeroDivisionError,default=0).__call__(divide)  

def divide(dividend=0, divisor=1):
    return dividend / divisor     
divide = swallow(exceptions=ZeroDivisionError,default=0).__call__(divide)

上記のコードの最後の行で、我々のニーズに応じて、”例外飲み込み”クラスの一つのインスタンスが作られ、初期化されている。
それから、__call__ メソッドがまさしく同じインスタンス上で実行される。それは順番に新しいswallow.helperネストクラスを作成し、返す。

その最終的な効果として、divide変数は、この特定のクラスのインスタンスを参照する。

swallow.helperクラスはいくつでも引数、キーワード引数を受ける __call__ メソッドを実装している。
それゆえに、このクラスのインスタンスは、効果的に、必要に応じた任意の引数をとる、どんな任意の関数でもデコレートすることができる。
__call__メソッド自身は、全ての作業を行うtry節を含んでいる。
デコレートされた関数を呼び出し、返される値を送り返す。
指定された例外以外が、キャッチされた場合には、指定されたデフォルト値を返す。
swallow と swallow.helper クラスのインスタンス変数を使うことで、仕事をする為の全ての変数が便利に格納され、共有される事に注意してほしい。

”例外の飲み込み”デコレーターの２通り目の実装方法としては、関数定義（及びそれに対応するlexicalクロージャー）だけで記述することができる。
それはとても短いものだが、最初は理解する事が少し難しいかもしれない。

view plainprint?

1. def swallow(default=None, exceptions=BaseException):  
2.     def helper1(fun):  
3.         def helper2(*args, **kwargs):  
4.             try:  
5.                 return fun(*args, **kwargs)  
6.             except exceptions:  
7.                 return default  
8.         return helper2  
9.     return helper1  

def swallow(default=None, exceptions=BaseException):
    def helper1(fun):
        def helper2(*args, **kwargs):
            try:
                return fun(*args, **kwargs)
            except exceptions:
                return default
        return helper2
    return helper1

見てきたように、swallow関数はデコレータに設定する為の、二つの入力パラメータをとって、
@構文が期待するように、ただ、ネストされた関数、helper1を返す。
helper1関数は、そのただ一つの引数としてデコレートされた関数を伴って、直ぐに呼ばれる。そして、その結果としてhelper2関数を返す。
これは、もし、私たちが関数fをデコレートする場合、変数fはhelper2への参照を保持することを意味する。
だから今、fが呼ばれる度に、helper2が呼ばれて、前述したようにtry節が、自身のjobを正確に実行する。

Note
1 例外の飲み込み、特定の状況下においては便利になるが、見境なくこのテクニックを使うのは避けるべきだ。
具体的には、コードのデバッグが困難になる。

2 呼び出し可能なオブジェクトは__call__という名前の特別な属性を含んでいる。もし、xが呼び出し可能なオブジェクトならば
構文
x(arg1, arg2, arg3) は
x.__call__(arg1, arg2, arg3) と等しい。
呼び出し可能なオブジェクトは、ユーザー定義関数、ビルトイン関数、ビルトインオブジェクトのメソッド、クラスインスタンスのメソッドと、自身の__call__メソッドで定義もしくは継承したクラスのインスタンスを含んでいる。

3 もし、*args や **kwargs ノーテーションに親しくなければ、Pythonチュートリアルで詳細をチェックすること。

---

正直、これは勉強になった。Thunks Ariel Ortiz!
訳がおかしいところは随時修正していこう・・・

[Python][翻訳]関数デコレータ

Pythonの関数デコレータについて調べていたところ、
Dive Into Python 3 Appendix.C 「ここからどこへ進むのか」にて、Ariel Ortizによる 関数デコレータ、続関数デコレータ が紹介されていた。
早速見てみると、分かり易くて初学者には良いなと思った。
どうせ、記憶力がない私のこと、何度も忘れて見に行くことを考えると、
一度、勉強がてら、翻訳しておこかなぁ？と思い、
作者のAriel Ortizに翻訳とブログへの掲載・コメント
許可を求めたところ「OK」とのお返事を頂きました。

Ariel Ortizのブログページ ProgrammingBits

英語もPythonもアレな私が翻訳しているので、少しでもオカシイところがあれば、
それは私の責です。原文をあたって下さいませ。突っ込みお願いします。

---

関数デコレーター

プログラミング言語Pythonは、デコレーターと呼ばれる興味深い
シンクタックス上の機能を備えている。

どうやって、そしてどうしてPythonのでデコレーター
を使うのか？さあ、例題を1個使って説明しよう。

NOTE:ここで例示する、すべてのPythonコードはPython3に基づいている。
ソースコードの全文は以下。
http://programmingbits.pythonblogs.com/gallery/27/function_decorators.py

再帰関数を使って、フィボナッチ数を計算したいとする。
次の関数定義で、うまくいく。(1)

view plainprint?

1. def fib(n):  
2.     if n in (0, 1):  
3.         return n  
4.     else:  
5.         return fib(n - 1) + fib(n - 2)  

def fib(n):
    if n in (0, 1):
        return n
    else:
        return fib(n - 1) + fib(n - 2)

これで異なる入力値で関数をテストすることができる。

>>> fib(0)
0
>>> fib(1)
1
>>> fib(4)
3
>>> fib(10)
55
>>> fib(30)
832040
>>> fib(35)
9227465

あなたが、正確にこれらサンプルをPython shellにタイプしたならば
入力値が大きいほど、結果を得るのに時間がかかることに気がついただろう。

高速に動かすために、memoizationと呼ばれるテクニックを使うことができる。
memoizeされた関数は、特定の入力値に該当する結果を、キャッシュに格納する。
呼び出しの後、前回の入力値に対する計算結果として、結果をリターンすると共に、
キャッシュに格納する。すなわち、再び計算するのを避けるのだ。

このことは、特定のパラメータでの関数コールにかかる主要コストは、
次に同じパラメータでよばれた関数に最初にかかるコストを、
肩代わりしていることになる。

fib関数を直接変更するかわりに、再利用可能なmemoizing関数を書くほうがよいだろう。

view plainprint?

1. def memoize(f):  
2.     cache = {}  
3.     def helper(x):  
4.         if x not in cache:              
5.             cache[x] = f(x)  
6.         return cache[x]  
7.     return helper  

def memoize(f):
    cache = {}
    def helper(x):
        if x not in cache:            
            cache[x] = f(x)
        return cache[x]
    return helper

memoize関数は別のhelper関数をラップしている。
そしてパラメータ f として受け取った関数に追加機能をする。

helper関数は実際にレキシャルクロージャーだ。レキシャルクロージャーとは、関数自身が作成された時の、自身のスコープ内にある変数を記憶している関数オブジェクトである。

このケースでいうと、helperは変数 fとcache（関数オブジェクトと辞書をそれぞれ保持する）を覚えていて最後の行では、memoize関数の呼び出し元にhelper lexicalクロージャーを返している。


以下のコードをタイプしてみると
fibをコールしたときに、すぐにスピードがアップしていることに気がつくだろう。

すごく初期のコール時でさえも、スピードアップを認めることができる。
何故なら、直ぐにfibの内部に再帰呼び出しを積み上げるからだ。

>>> fib = memoize(fib)
>>> fib(50)
12586269025

最初の行はfibをmemoizeでデコレートしていると読むことができる。
何故なら、これはPythonにおける、共通のプログラミングのイディオムのようなもので、
それを単純に利用するために、特別なデコレータシンクタックスがある。
このシンクタックスはJavaのアノテーションにインスパイアされたもので、
デコレートされる関数の定義の前に、@につづけてデコレータ関数の名前を記述する。

別の言い方をすると、このPythonのシンクタックスは

view plainprint?

1. @some_decorator  
2. def some_function():  
3.     # function body.  

@some_decorator
def some_function():
    # function body.

以下と同じ意味である。

view plainprint?

1. def some_function():  
2.     # function body...  
3. some_function = some_decorator(some_function)  

def some_function():
    # function body...
some_function = some_decorator(some_function)

ほとんどの場合は
@ノーテーションの方が読みやすくエラーになりにくいと同意すべきだろう。

フィボナッチ、memoization関数の例で、Pythonデコレーターを
利用するために、次のように書き直さなくてはならないだろう。

view plainprint?

1. def memoize(f):  
2.     # 前出のコード...  
3.   
4. @memoize   
5. def fib(n):  
6.     # 前出のコード  

def memoize(f):
    # 前出のコード...
 
@memoize 
def fib(n):
    # 前出のコード

memoize関数は典型的な関数デコレータが持っているべき一般的な構造をみせてくれる。
一つの関数 f をインプットパラメータとして受け取り、関数 f に追加の責務（出来ること）を追加する
別の関数を戻り値とするのだ。

Pythonデコレータの別の面白い点としては、2つ以上のそれを連結することができるというものだ。
それでは、 デコートされた関数が呼ばれる前と、戻り値を返す前にメッセージを出力するような
トレース・デコレータを加えるためにサンプルを拡張してみよう。

view plainprint?

1. def memoize(f):  
2.     # 前出のコード...  
3.    
4. def trace(f):  
5.     def helper(x):  
6.         call_str = "{0}({1})".format(f.__name__, x)  
7.         print("Calling {0} ...".format(call_str))  
8.         result = f(x)  
9.         print("... returning from {0} = {1}".format(  
10.               call_str, result))  
11.         return result  
12.     return helper  
13.   
14. @memoize  
15. @trace  
16. def fib(n):  
17.     # 前出のコード...  

def memoize(f):
    # 前出のコード...
 
def trace(f):
    def helper(x):
        call_str = "{0}({1})".format(f.__name__, x)
        print("Calling {0} ...".format(call_str))
        result = f(x)
        print("... returning from {0} = {1}".format(
              call_str, result))
        return result
    return helper
 
@memoize
@trace
def fib(n):
    # 前出のコード...

@memoizeと@traceはfibの直前に定義している。
さっそく、fibを実行してみると最初にmemoizeデコレータが呼ばれる。それからtraceデコレータが呼ばれ
最後に、オリジナルのfibコードが呼ばれる。例を確認してみよう。

>>> fib(5)
Calling fib(5) ...
Calling fib(4) ...
Calling fib(3) ...
Calling fib(2) ...
Calling fib(1) ...
... returning from fib(1) = 1
Calling fib(0) ...
... returning from fib(0) = 0
... returning from fib(2) = 1
... returning from fib(3) = 2
... returning from fib(4) = 3
... returning from fib(5) = 5
5

Pythonは関数デコレータとして使用されることを意図した、3種類のビルトイン関数を持っている。

• classmethod: デコレータメソッドが、クラスメソッドであることを指す為に使用される。SmalltalkやRubyのそれに似ている。

• staticmethod: デコレータメソッドが、スタティックメソッドであることを指す為に使用される。C++、C#やJAVAのそれに似ている。

• property: オブジェクトのプロパティを取得、設定、削除するために使用される。

Python3.0は関数をデコレータするだけでなく、クラスをデコレートすることも許可することは、注意しておく価値がある。
うまくいけば、こんどのポストでこれらの特定種類のデコレータについて書くために時間を取るつもりだ。。

Notes
(1) 再帰を用いたフィボナッチ数列の実装はとても効率が悪いのは、知っている。
だけど、それが私の意図だ。
遅さを体感できるよう、私は単純なアルゴリズムがほしかった。

---

以上です。アホな私にも理解できたような気がする。分かりやすいです。
続・関数デコレータも読も。

6/11 修正

[読書] Python クックブック 第2版 読んでみる。第1章-その1

内容は2.x系向けに書かれてる。3.x系ではどうするの？と考えながら読んでみるなどする。
いつも通り、間違ってても、車輪の再発明になっても気にしない。娯楽なので。
作戦：ガンガンいこうぜ。




1.3 オブジェクトが文字列のようなものかテストする

Python2では文字列の方が、Unicode型と非Unicode型があり、スーパクラスとしてbasestring型があった。
これをisinstance()に渡すと、Unicodeか否かの判別ができた。
basestringデータ型　はPython3にはないので、素直にisinstance(anobj,str)でよい。


1.6 文字列の連結

Pythonの文字列はイミュータブル。Javaで文字列を+連結するのと同じ問題を孕む。
''.joinを使うのが正解だよね。



1.8 文字列にキャラクタセットの文字が含まれるか調べる

itertools.ifilter() はPython 3では 標準ビルトイン関数 filter() になっている

書き変えてみる

view plainprint?

1. def containsAny2(seq, aset):  
2.   for item in filter(aset.__contains__,seq):  
3.   return True  
4.  return False  

def containsAny2(seq, aset):
  for item in filter(aset.__contains__,seq):
  return True
 return False

not の結果がemptyだとTrueが戻ることを利用。

view plainprint?

1. def containsAll(seq,aset):  
2.  return not set(aset).difference(seq)  

def containsAll(seq,aset):
 return not set(aset).difference(seq)

>>> not set()
True
>>> not set('a')
False


>>> not ''
True
>>> not 'a'
False

Python 3 では Python 2 の string.maketrans とそっくりのスタティックメソッド maketrans がバイト列型に加わっている。
そしてユニコード文字列型にも maketrans スタティックメソッドが追加された。
これはユニコード文字列型の translate に渡せる辞書を返す。

調査対象文字列に、任意の文字列を1つでも含むか？

view plainprint?

1. def containsAny(astr,strset):  
2.  notrans = str.maketrans('','',astr)  
3.  return len(strset) != len(strset.translate(notrans))  

def containsAny(astr,strset):
 notrans = str.maketrans('','',astr)
 return len(strset) != len(strset.translate(notrans))

1.9 文字列クラスのtranslateメソッドを簡単に使う。

クロージャーを使ったラッパを作っているが、3.xではサンプルは動かない。
練習がてらユニコード文字列の maketransメソッドを使ったコードを書いてみた。

削除とkeepを2者択一にしてたりして機能縮小版。とりあえず。

view plainprint?

1. def translator(frm='',to='',delete='',keep=None):  
2.  if len(to) == 1:  
3.   to = to * len(frm)  
4.  if keep is not None:  
5.   trans = str.maketrans('','',keep)  
6.  else:  
7.   trans = str.maketrans(frm,to,delete)  
8.     
9.  def translate(s):  
10.   if keep is not None:  
11.    return s.translate(str.maketrans('','',s.translate(trans)))  
12.   else:  
13.    return s.translate(trans)  
14.  return translate  

def translator(frm='',to='',delete='',keep=None):
 if len(to) == 1:
  to = to * len(frm)
 if keep is not None:
  trans = str.maketrans('','',keep)
 else:
  trans = str.maketrans(frm,to,delete)
  
 def translate(s):
  if keep is not None:
   return s.translate(str.maketrans('','',s.translate(trans)))
  else:
   return s.translate(trans)
 return translate

a,dをbに変換して、数字だけ削除
>>> import string
>>> test = translator(frm='ad',to='b',delete=string.digits)
>>> test('aaaaaccccdddd123456789')
'bbbbbccccbbbb'

数字だけ残す
>>> test = translator(frm='ad',to='b',keep=string.digits)
>>> test('aaaaaccccdddd123456789')
'123456789'
>>>

ダブルバイト。愛は嘘なり。
>>> test = translator(frm='愛',to='嘘',delete=string.digits)
>>> test('愛愛愛123456789')
'嘘嘘嘘'
>>>

[読書]Head First Python 読んでみる。 Chapter3

Chapter3は File & Exception : Dealing with Errors.


全章通じてそうだけど、小さな例題アプリを少しづつ、お話と共に作りながら進んでいく形式。
いつもながらこのHead Firstのやり方はうまい。猫でもわかるようになっている。

ただ、猫でない人にとっては冗長、そういう人は対象読者ではないにしても。

英語を読み進めるスピードが遅いのと、オンラインで読んでいるせいもあって
だんだん、面倒になってきたぞ。どんどん飛ばして読んでもいいのだが。。うーむ。

この内容ならこの章は２～３ページでいいじゃない。というのは野暮なのでしょう。たぶん。

もうちょっと頑張ってみよう。

[読書]Head First Python 読んでみる。 Chapter2

Head First Python　読んでみる。 Chapter2


読書記録としてはWikiの方がよいのだろうけど、続かなそうなので。。
この心理的作用はなんだんだろう？お手軽だから？うーん。

Chapter 2 はモジュール作成から配布を中心に、名前空間など書いてある。
この段階からPyPIの使い方が書かれているのは良いことなんだと思う。

• How to distribution the own Python Modules.
• How to use the Python Package Index ("PyPI"). Registration, Upload Module, Update Module.
• Python Name Space. Main name space is known __main__.
  

1. A module is a text file that contains Python code.
2. We can use the distribution utilities to turn own module into a shareable package.
3. The setup.py program provides metadata about your module and is used
   to build, install, and upload your packaged distribution.
4. The range() BIF can be used with 'for' to iterate a fixed number of times.
5. Including end=’’ as a argument to the print() BIF switches off its automatic inclusion of a new-line on output.
6. Arguments to your functions are optional if you provide them with a default value.

[読書]Head First Python 読んでみる。 Chapter1

Head FirstシリーズのPython版が出ていたので読んでみるなど。

まだ翻訳版は出ていない？っぽいので原書で。英語出来ないのにw

Head Firstシリーズは「学習」に重点を置いていて、如何に効率的に理解させて記憶に残すか？
を考えて作られている本。絵が一杯で楽しいんだけど、その分冗長でちんたら進むので、飽きてしまう事も。

所謂、リファレンスではないので初学者向け。「浅く、広くPythonに触れてみる」といったところ。
ちゃんとするなら、ネズミ本。Apple AppsStoreで600円だし。




Chapter1
Meet Python : Everyone Loves Lists.

IDLEの使い方
Python のList
For Loop
BIFｓ instance()
Function
再帰

など。小気味よく読了。
後半の章ではGoogle App Engine を用いてWebアプリつくったりもしていて期待出来そう。

なんだけど、とある事情で今月中に読み終えないといけず、496 Pages もあるからなぁ。
単純日割りで24page/day。英語が最大のネックか。