カテゴリー: Python

ジェネレータの性格を持ったクラスを定義することができる。例を示す：

class Reverse:
    def __init__(self, data):
        self.data = data
        self.index = len(data)

    def __iter__(self):
        return self

    def __next__(self):
        if self.index == 0:
            raise StopIteration
        self.index = self.index - 1
        return self.data[self.index]

このクラス定義で__next__メソッドがあることが重要である。このメソッドがnext関数の定義をなしている（これはクラスの__str__メソッドがそのクラスの固有のprint関数の定義になっていることと同じである）。__iter__メソッドも同様にiter関数を定義するものであるが今は何もしない。
結果は

>>> s = Reverse('flog')
>>> next(s)
'g'
>>> next(s)
'o'
>>> next(s)
'l'
>>> next(s)
'f'
>>> next(s)
Traceback (most recent call last):
  File "<pyshell#6>", line 1, in 
    next(s)
  File "<pyshell#0>", line 11, in __next__
    raise StopIteration
StopIteration
>>> 

となる。

• イテレータとは、プログラミング言語において配列やそれに類似する集合的データ構造（コレクションあるいはコンテナ）の各要素に対する繰り返し処理の抽象化である。 … 実際のプログラミング言語では、オブジェクトまたは文法などとして現れる。 JISでは反復子（はんぷくし）と翻訳されている。

Pythonに即してみると：

>>> a='abcd'

>>> for a in a:
	print(a)
a
b
c
d
>>> 

より基本的なイテレータはiter関数を使うものである：

>>> d=dict([(1,'one'),(2,'two')])
>>> d
{1: 'one', 2: 'two'}
>>> it = iter(d.items())
>>> next(it)
(1, 'one')
>>> next(it)
(2, 'two')
>>> next(it)
Traceback (most recent call last):
  File "<pyshell#7>", line 1, in 
    next(it)
StopIteration
>>> 

• ジェネレータは、プログラムにおいて、数列の各要素の値などを次々と生成（ジェネレート）し他の手続きに渡す、という機能を持っている手続きである。つまりイテレータを生成する手続きである。大事なことはジェネレータは要請がある毎に一つ一つ要素を生成することである。

「Pythonチュートリアル」（Guido van Rossum著）で示した例：

def reverse(data):
    for index in range(len(data)-1, -1, -1):
        yield data[index]

for char in reverse('golf'):
    print(char)

ジェネレータを一行で書くこともできる。

>>> g = (x**2 for x in range(5))
>>> g
<generator object <genexpr> at 0x0000000002ED07C8>
>>> next(g)
0
>>> next(g)
1
>>> 

ジェネレータは大きなファイルを要請のある毎に読むなどのとき便利な機能である。例をみよ。

 

二つの辞書の結合を議論して三つの方法があることがわかった。

今回はたまたま二つの辞書でキーが同じものがあったときの振る舞いを調べる：
例題

>>> d1=dict()
>>> d1['one'] = 'イチ'
>>> d1['two'] = 'ニ'
>>> d2=dict()
>>> d2['one'] = 'ヒトツ'
>>> d2['three'] = 'サン'
>>> d=dict(**d1, **d2)
Traceback (most recent call last):
  File "<pyshell#7>", line 1, in 
    d=dict(**d1, **d2)
TypeError: type object got multiple values for keyword argument 'one'
>>> d=dict(list(d1.items()) + list(d2.items()))
>>> print(d)
{'one': 'ヒトツ', 'two': 'ニ', 'three': 'サン'}
>>> d1.update(d2)
>>> print(d1)
{'one': 'ヒトツ', 'two': 'ニ', 'three': 'サン'}
>>> 

• 形式d=dict(**d1, **d2)ではエラーになる。
• 形式d=dict(list(d1.items()) + list(d2.items()))では上書きされる。
• 形式d1.update(d2)では予想したしたように上書きされる。

辞書の結合を議論した。「ばらす」演算子（**）を使った以下のような方法を紹介した。

d = dict(**d1, **d2)

これはスマートに見える方法であるが、万能ではない。

例を示す：

>>> d1 = dict()
>>> d1[1]='one'
>>> d1[2]='two'
>>> d2=dict()
>>> d2[3]='three'
>>> d2[4]='four'
>>> d=dict(**d1, **d2)
Traceback (most recent call last):
  File "<pyshell#6>", line 1, in 
    d=dict(**d1, **d2)
TypeError: keywords must be strings
>>

つまりキーが文字列以外のときは上記の方法は使えないことになる。

d1.update(d2)

とする方法もあるが、d1が書き換えられてしまうので面白くない。

以下のような関数はどうだろうか

def dict_merge(d1, d2):
    """二つの辞書d1,d2を結合して新たな辞書d
を返す関数"""
    d = dict()
    for key, item in d1.items():
        d[key] = item
    for key, item in d2.items():
        d[key] = item

    return d

d1=dict()
d1[1] = 'one'
d1[2] = 'two'
print(d1)
d2=dict()
d2[3] = 'three'
d2[4] = 'four'
print(d2)

d = dict_merge(d1, d2)
print(d)

追記：
コマンドで書ける：

d=dict(list(d1.items()) + list(d2.items()))

 

Pythonでは可変長の引数を持つ関数を作ることができる。

例

def func( *arg, **kwarg):
    print(type(arg), arg)
    print(type(kwarg), kwarg)

func(1, 2, 3, k1=10, k2=20, k3=30)

結果の出力：

<class 'tuple'> (1, 2, 3)
<class 'dict'> {'k1': 10, 'k2': 20, 'k3': 30}
>>>

このように「ばらす」演算子（*）、（**）を使う。*argでは位置が固定されている実引数をタプルの形で引き取ることができ、**kwargでは、キーつきの引数を辞書の形で引き取ることができる。キー引数は文字列になっていることに注意。

 

二つの辞書があるときそれらを結合して新たな辞書を作る方法：

>>> d=dict(k1=1, k2=2, k3=3, k4=4)
>>> print(d)
{'k1': 1, 'k2': 2, 'k3': 3, 'k4': 4}
>>> d1=dict(k1=1, k2=2)
>>> d2=dict(k3=3, k4=4)
>>> d=dict(**d1,**d2)
>>> print(d)
{'k1': 1, 'k2': 2, 'k3': 3, 'k4': 4}
>>> 

「ばらす」演算子（**）で辞書{‘k1’:1}はキー引数k1=1の形に展開される。文字列が引数名に変わることに注意。こうしてdictの引数にキー引数を与えて、二つの辞書を統合することができる。

さて、前問を拡張して以下のように問題を考える。

整数値が三つあり、先の二つの整数の和と第三の整数との加法、減法、乗法、除法を表現することを考える

表現1

a<-3     整数値を入れる箱を用意しaというラベルを貼る。そして3を入れる
b<-2　   整数値を入れる箱を用意しbというラベルを貼る。そして2を入れる
c<-5
(a+b)+c?　   
(a+b)-c?
(a+b)Xc?
cが0ならば
    cが0です！
そうでなければ
    (a+b)÷c?

括弧は演算の優先順序が高いことを示す。
表現2

a<-3     整数値を入れる箱を用意しaというラベルを貼る。そして3を入れる
b<-2　   整数値を入れる箱を用意しbというラベルを貼る。そして2を入れる
c<-5
t<-a+b   整数を入れる箱を用意しtというラベルを貼る。a+bの結果をしまう。
t+c?　   
t-c?
tXc?
cが0ならば
    cが0です！
そうでなければ
    t÷c?

このようにすると無駄な計算をしないで表現できる。
 

前の問題をより汎用性を高めるために、例外があるかどうか考える。

整数3と整数2の加法、減法、乗法、除法を表現することを考える：

表現1

a<-3     整数値を入れる箱を用意しaというラベルを貼る。そして3を入れる
b<-2　   整数値を入れる箱を用意しbというラベルを貼る。そして2を入れる
a+b?　   ラベルaの箱にある整数とラベルbの箱にある整数の和は？
a-b?
aXb?
a÷b?

bの値が0であるときである。このときa÷bは問題となる。それを指摘し計算はしないとしよう。
表現2

a<-3     整数値を入れる箱を用意しaというラベルを貼る。そして3を入れる
b<-2　   整数値を入れる箱を用意しbというラベルを貼る。そして2を入れる
a+b?　   ラベルaの箱にある整数とラベルbの箱にある整数の和は？
a-b?
aXb?
bが0ならば
    bが0です！
そうでなければ
    a÷b?

表現2では例外の扱いもしてありより汎用性が高いものとなっている。

プログラミング教育で最初に考えなければならないことは何か？

「それは順序立てて物事を表現する」ことであると思われるが、この表現に汎用性があることが大事である。この汎用性のある表現をアルゴリズムという。

例えば整数3と整数2の加法、減法、乗法、除法を表現することを考える：

表現１

3+2?
3-2?
3X2?
3÷2?

そして3が5に、2が4になったときには

5+4?
5-4?
5X4?
5÷4?

と表現できる。

この表現では最初の数値を変えたときは全てを書き直す必要がある。

表現２

a<-3     整数値を入れる箱を用意しaというラベルを貼る。そして3を入れる
b<-2　   整数値を入れる箱を用意しbというラベルを貼る。そして2を入れる
a+b?　   ラベルaの箱にある整数とラベルbの箱にある整数の和は？
a-b?
aXb?
a÷b?

この表現では最初の数値を変えたときは、その部分の変更だけで済む。

汎用性が増したことになる。

 

 

今回は音を出してみた。スピーカーが必要だが今回は梅沢無線で購入した圧電スピーカー（二個で170円）を使った。MicroBitはアナログ・デジタル変換によってデジタル信号をアナログに変換して出力するポートを３つ持っている。今回はp0ポートを使った。

使ったプログラム：

import music

while True:
    music.play(music.PYTHON)
    #music.play(music.BADDY)

music.PYTHONはMicroBitに登録されている音サンプルで、モンティ・パイソン（Monty Python）のテーマ曲でそれを繰り返す。圧電スピーカーは低音はブザーのようにしか聞こえないが高音はそれなりに聞ける。