初心者向け - 静かなる名辞

list, tuple, dict, setの基本的な使い方、相違点、使い分け、応用など

2019-08-09T00:05:31+09:00

はじめに

　pythonでよく使う組み込みのコレクション型には、list, tuple, dict, setなどがあります。ただ、なんとなく使っている、いつもlist、それぞれ微妙に使い勝手が違って困る、という人も多いと思います。そこで、これらについて解説します。

はじめに
コレクション型ってなに？
listについて
- 基本
- 内包表記
tupleについて
- 基本
- 応用
dict
set
まとめ

コレクション型ってなに？

　とりあえず、「コレクション型」という用語は公式に使われているものではなく、便宜的にそう読んでいるだけなので注意してください。「中にオブジェクトを格納できる型（クラス）」程度の意味です。

　ドキュメントによれば、pythonの主要な組み込み型には以下のような区別があります。

主要な組み込み型は、数値、シーケンス、マッピング、クラス、インスタンス、および例外です。
組み込み型 — Python 3.7.4 ドキュメント

（なお、上のページはつらつらと読むとそれだけで勉強になります。この記事を読んで物足りないと思った人におすすめです。）

　さて、タイトルに含めた4つのうち、listとtupleはシーケンス、dictはマッピングです。setはどれにも当てはまりません。

　シーケンス、マッピングという言葉の意味は、なんとなくわかる人も多いと思います。シーケンスは順番があって連続的に、あるいはインデックスを指定したりしてアクセス可能なもの、マッピングはシーケンスと異なって順番を持ちませんが、dictのように任意のキーと値の対応付けを記録可能なものです（というか、基本的にdictとその亜種しかないと思います）。

　こういう「コレクション型」はpythonでプログラミングをする上ではとても重要なので、とりあえず組み込みの主だったものはすべて覚えておきましょう。どんなコードでも何らかの形で利用していたりするので、知らないと困ります。

listについて

基本

　コレクション型の中でもっとも代表的なのはlist（リスト）ですね。色々な場面で汎用的に使われます。初心者の方はとりあえずlistを覚えて、慣れないうちはなんでもlistで書くと良いと思います。

　リテラル*1で書く場合はこんな感じです。

>>> print(lst1)  # 空のリスト
[]
>>> lst2 = [1, 2, 3]
>>> print(lst2)
[1, 2, 3]

　要素を末尾に追加したければ、appendが使えます。

>>> lst1.append(4)
>>> lst2.append(5)
>>> print(lst1)
[4]
>>> print(lst2)
[1, 2, 3, 5]

　逆にlist以外でappendが使えるものはあまり（というか恐らくまったく）ありません。ついでに書いておくと、numpyやpandasにもappendがありますが、あれはあれでまた違った挙動になります。

　「拡張」というか、listを含む他のコレクション型など*2の中身をまとめて突っ込みたいときは、extendというメソッドが使えます。

>>> lst1.extend(lst2)
>>> print(lst1)
[4, 1, 2, 3, 5]

　あとは普通にインデックスで要素を取得したり、for文に渡してループしたりもできます。

>>> print(lst1[0])
4
>>> for x in lst1:
...     print(x)
... 
4
1
2
3
5

　インデックスで要素を削除したい場合はdel文で行えます。また、pop（こちらもインデックスで指定し、除去した要素を返す）, remove（こちらはオブジェクトの値が一致するものを除去）などで取り除くこともできます。

>>> del lst1[3]
>>> print(lst1)
[4, 1, 2, 5]

　ただ、あまり使っているのを見ませんね。これをやるとインデックスが狂う上、ループと組み合わせると面倒くさい問題もあります。

【python】listをforループで回してremoveしたら思い通りにならない - 静かなる名辞

　append以外でlistの長さが減るような処理は積極的にやらない、という傾向が強いのではないでしょうか。

　listは「ミュータブルなシーケンス」という分類になり、実はとてもたくさんの操作が行えます。すべてはカバーできないので、ここ↓を見てください。

組み込み型 — Python 3.7.4 ドキュメント | シーケンス型 --- list, tuple, range

　繰り返しになりますが、これを読むととても勉強になります。

内包表記

　listといえばリスト内包表記というくらいよく使われるものです。

>>> print([x + 100 for x in range(5)])
[100, 101, 102, 103, 104]

　難しいものではないので、慣れましょう。

tupleについて

基本

　tuple（タプル）はlistの中身を一切変更できなくしたような使い勝手です。

>>> tup1 = ()  # 空のtuple
>>> tup2 = (1, 2, 3)
>>> print(tup1)
()
>>> print(tup2)
(1, 2, 3)

　注意しないといけないのは、外側の丸括弧()はtupleの本質ではないという点です。カンマがあればtupleは作れます。

>>> tup2 = 1, 2, 3
>>> tup2
(1, 2, 3)

　え、カンマなんかあちこちで使うじゃん（関数の引数リストとか）と思うと思いますが、原則的には「他の構文とみなせないときはtupleとみなす」というルールです。なんかややこしいですね。

　では丸括弧は何か？　というと、数式で(a + b) * 2とかやるときの丸括弧と同じで、評価の順番を決めているだけです。これがあることで、関数の引数リストなどの他の構文と混同されないようにtupleを表すことができます。

　このことを知らないと、要素数1つのtupleを作りたいとき、こういうものを書いてしまいます。

>>> this_is_not_tuple = (4)
>>> print(type(this_is_not_tuple), this_is_not_tuple)
<class 'int'> 4

　要素数1のtupleは、下のようにしてください。

>>> this_is_tuple = (4, )
>>> print(type(this_is_tuple), this_is_tuple)
<class 'tuple'> (4,)

応用

　中身の変更できないtupleなんか何に使えるんだと思われるかもしれませんが、tupleのようなイミュータブル（変更不可能）なオブジェクトはhashableという大切な性質を持っています。後述のdictやsetのキー、要素にしたいとき、データをtupleで表現するということがよく行われます。

　tupleには内包表記はありません。内包表記的なことをしたい場合は、ジェネレータ式と組み合わせて以下のように書くと手っ取り早いでしょう。

>>> tuple(x - 100 for x in range(5))
(-100, -99, -98, -97, -96)

dict

基本

　dict（ディクトと呼びますが、辞書という訳の方が一般的です）はキーと値の対応付けを保持します。

　リテラルではこう書きます。

>>> dct1 = {}  # 空のdict
>>> dct2 = {"hoge":0, "fuga":1}
>>> print(type(dct1), dct1)
<class 'dict'> {}
>>> print(dct2)
{'hoge': 0, 'fuga': 1}

　{キー:値, ...}という感じの構文です。簡単ですね。

　値の追加には普通は代入を使います。また、累積代入文なども使えます。

>>> dct2["piyo"] = 2
>>> print(dct2)
{'hoge': 0, 'fuga': 1, 'piyo': 2}
>>> dct2["piyo"] += 999
>>> print(dct2)
{'hoge': 0, 'fuga': 1, 'piyo': 1001}

　削除はdel文でいいのですが、あまり使わないでしょう。

　直接for文などに渡すと、キーだけが出てきます。

>>> for x in dct2:
...     print(x)
... 
hoge
fuga
piyo

　keys, values, itemsというメソッドでそれぞれキー、値、キーと値のペアを取り出せます。必要に応じて活用してください。

>>> for k in dct2.keys():
...     print(k)
... 
hoge
fuga
piyo
>>> for v in dct2.values():
...     print(v)
... 
0
1
1001
>>> for k, v in dct2.items():
...     print(k, v)
... 
hoge 0
fuga 1
piyo 1001

組み込み型 — Python 3.7.4 ドキュメント

重要な性質

　dictにはいくつか覚えておかないといけない性質があります。

　まず、tupleのところでも述べたとおり、キーにはimmutableなオブジェクトしか使えません。

>>> dct3 = {[1, 2]:3}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>> dct3 = {(1, 2):3}
>>> print(dct3)
{(1, 2): 3}

　また、基本的には順番の概念はない、ということも知っておく必要があります。伝統的なPythonでは、辞書のキー・値の順番は適当にシャッフルされていました（内部的には意味があったのですが、割愛）。

# Python 3.5で実行
>>> d = {"hoge":123, "fuga":456, "piyo":789}
>>> print(d)
{'fuga': 456, 'hoge': 123, 'piyo': 789}

　最近のPython*3では順番を保持しますが、それでもappendのような順序を前提としたオペレーションは弱いので、扱いは以前とさほど変わりません。

# Python 3.6で実行
>>> d = {"hoge":123, "fuga":456, "piyo":789}
>>> print(d)
{'hoge': 123, 'fuga': 456, 'piyo': 789}

　まだあります。上で書いたkeys, values, itemsはとても便利ですが、これらは辞書ビューオブジェクトという集合っぽいオブジェクトで、しかもリアルタイムで辞書の中身を反映してくれます。ただし、ループ中にいじったりすると意図しない結果になったり、エラーが出たりします。

ループで辞書の要素を削除しようと思ったらRuntimeError: dictionary changed size during iteration - 静かなる名辞

　便利ですが、扱いには少し気をつけた方が良いのが辞書です。

内包表記

　dictにも内包表記があります。書き方はリスト内包表記と辞書のリテラルを混ぜた感じです。

>>> dct4 = {i:i**2 for i in range(5)}
>>> print(dct4)
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

　まあ、これといって難しいことはないかと。

眷属たち

　dictには覚えておくと便利な標準の亜種がいくつかあります。collectionsモジュールから使えます。

　筆頭はdefaultdictでしょう。これはキーの初期値を適当に設定できるもので、データの集計などで威力を発揮します。

# 長さの異なる文字列ごとにグルーピングする処理
>>> lst = ["a", "b", "ab", "abc", "bcd"]
>>> d = {}  # defaultdictを使わない場合
>>> for x in lst:
...     l = len(x)
...     if l in d:
...         d[l].append(x)
...     else:
...         d[l] = [x]
... 
>>> print(d)
{1: ['a', 'b'], 2: ['ab'], 3: ['abc', 'bcd']}
# defaultdictを使う場合
>>> from collections import defaultdict
>>> d = defaultdict(list)
>>> for x in lst:
...     l = len(x)
...     d[l].append(x)    # d[l]がなければ勝手に空のリストを初期値にしてくれる
... 
>>> print(d)
defaultdict(<class 'list'>, {1: ['a', 'b'], 2: ['ab'], 3: ['abc', 'bcd']})

　他の使い方はdictとほぼ同じです。

　また、Counterは引数の頻度を勝手に集計してくれます。これも辞書の眷属みたいなものです。

>>> from collections import Counter
>>> lst = [1, 1, 2, 3, 4, 3, 2, 5]
>>> cnt = Counter(lst)
>>> print(cnt)
Counter({1: 2, 2: 2, 3: 2, 4: 1, 5: 1})
>>> print(cnt[0])
0
>>> print(cnt[1])
2

　このあたりを知っているかどうかでコードのクオリティが変わるので、覚えておきましょう。
collections --- コンテナデータ型 — Python 3.7.4 ドキュメント

set

基本

　トリを飾るのはsetです（セットとも呼びますが、表記するときは集合型とするかsetとそのまま書くかのどちらかです）。

　setは数学的な集合を表現できます。あるいは、dictをkeyだけにしたようなものと考えてもいいでしょう（内部ではどちらもハッシュテーブルを使っています）。

　リテラルで書くとき注意しないといけないのは、空のsetをリテラルで表現する手段が基本的にないということです。コンストラクタを使ってset()で作ります（これまで触れていませんでしたが、list(), tuple(), dict()でそれぞれ空のコレクションを作れます）。

>>> s1 = set()
>>> print(s1)
set()
>>> s2 = {1, 2, 3}
>>> print(s2)
{1, 2, 3}

　集合なので、要素は重複しません。強制的に1つにまとめられます。これを利用して、list→setに変換してユニークな要素の数を数えるというテクニックもよく使われます。

>>> s3 = {1, 2, 3, 3}
>>> print(s3)
{1, 2, 3}
>>> lst = [1, 2, 3, 3]
>>> print(len(set(lst)))
3

　集合なので、様々な演算が行なえます。

>>> s1 = {1, 2, 3, 4}
>>> s2 = {3, 4, 5, 6}
>>> print(s1 & s2)  # AND
{3, 4}
>>> print(s1 | s2)  # OR
{1, 2, 3, 4, 5, 6}
>>> print(s1 - s2)  # 引き算
{1, 2}
>>> print(s2 - s1)
{5, 6}
>>> print(s1 ^ s2)  # 排他的論理和
{1, 2, 5, 6}

　集合型を使う場面というのはこういう演算を使うことを期待している場合で、逆にそれ以外だと上のように「重複を除く」などで使う可能性がある以外には、あまり使いみちはありません。

　要素の追加はaddメソッドを使います。取り除くときはremoveかdiscardを使うことになるでしょう（存在しない要素に対して行った場合にエラーになるかどうかだけが異なります）。listの操作とはまったく互換性がないので、注意してください。appendは使えません。

>>> s = set()
>>> s.add(1)
>>> print(s)
{1}
>>> s.discard(1)
>>> print(s)
set()

組み込み型 — Python 3.7.4 ドキュメント

　dictのキーと同じく、中に入れられるのはimmutable（厳密にはhashableであればよいが）だけです。

>>> s = {[1, 2, 3], [4, 5, 6]}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

内包表記

　setには内包表記があります。めったに使わないのですが、dictの内包表記と間違えて書かないために覚えておく必要があります。

>>> s = {i**2 for i in range(5)}
>>> print(s)
{0, 1, 4, 9, 16}

frozenset

　これも知っておいた方が良いでしょう。

　集合の中に集合を入れる、あるいはsetを辞書のキーにする、という場面がたまにあります。でも、setはmutableなので、そのままでは使えません。

>>> s = {{1, 2, 3}, {4, 5, 6}}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'set'

　この場合、frozensetが使えます。これも組み込み型です。listに対するtupleだと思えば良いでしょう。

>>> s = {frozenset({1, 2, 3}), frozenset({4, 5, 6})}
>>> print(s)
{frozenset({1, 2, 3}), frozenset({4, 5, 6})}

まとめ

　Pythonの基本的なコレクション型4つについて説明してみました。

　この記事の内容程度のことを知っておくと、コーディングがはかどります。

*1:これも説明が難しい概念ですが、わからなければ頑張って調べてください。この記事では触れません。

*2:iterableなら何でもいいのですが、iterableが何であるのかについてもこの記事では触れません。

*3:3.6でCPythonの実装が変わり、3.7から正式な言語仕様になりました

TypeError: list indices must be integers or slices, not ***等の原因と対処法

2019-07-21T05:01:28+09:00

はじめに

　pythonを触り始めたばかりの人は、よくこんなエラーに遭遇すると思います。

TypeError: list indices must be integers or slices, not ***

　***の部分はfloatだったりlistだったりstrだったりといろいろありますが、とにかくこんなエラーです。

　また、次のも見たことがあるかもしれません。

TypeError: slice indices must be integers or None or have an __index__ method

　これはスライス（:を使ってリストの特定範囲だけ抜き出すやつ）を使ったときに出てきます。まあ、似たようなものです。

　この記事ではこういうエラーの原因と対処法について説明します。

原因

　さて、簡単にこのエラーを再現してみましょう。

>>> lst = [0, 1, 2, 3]
>>> lst["hoge"]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: list indices must be integers or slices, not str

　出ましたね。

　今回は***の部分はstrになっていますが、これは「indices」（[]の中に入るもの）として渡されたものが文字列で、でもlistのindicesは整数かスライスじゃないとだめだよ、というエラーです。

　また、スライスについても同様で、このように再現できます。

>>> lst["fuga":]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: slice indices must be integers or None or have an __index__ method

　もうある程度は気づいたと思いますが、[]（添字表記と言ったりします）の中に入れられるものは型が決まっています。そして、それ以外の型のオブジェクトを入れるとエラーになります。

対処法

　上述のような理由で出てくるので、はっきり言って対処法はケースバイケースです。なので、状況に応じてデバッグをする必要があります。

　とりあえず、変数を使っているようなケースでは、printしてみましょう。一番単純なデバッグです。

>>> for i in "hoge":  # エラーになってしまう
...     print(lst[i])
... 
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
TypeError: list indices must be integers or slices, not str
>>> for i in "hoge":
...     print(type(i), i)  # iの型と値をprintするコードを追加
...     print(lst[i])
... 
<class 'str'> h  # str型のhが渡っていることがわかる
Traceback (most recent call last):
  File "<stdin>", line 3, in <module>
TypeError: list indices must be integers or slices, not str

　これを見ればなんとなくわかることもありますが、もう少し想像力が必要なケースも多いでしょう。

　ありがちなのは、インデックスでループさせたつもりだったけど元のリストをループさせていたとかでしょうか。

>>> s = ["hoge", "fuga"]
>>> for i in s:
...     print(s[i])
... 
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
TypeError: list indices must be integers or slices, not str

　pythonのforはループ対象から1つずつ要素を取り出す、という動作をします（他の言語のforeachなどを想像されるとわかりやすいかもしれません）。

　この場合は、以下のように書きます。

>>> s = ["hoge", "fuga"]
>>> for i in range(len(s)):  # rangeとlenを組み合わせてインデックスを作る
...     print(s[i])
... 
hoge
fuga
>>> for x in s:  # 単にこれも可
...     print(x)
... 
hoge
fuga

　rangeは「0から引数の整数-1のイテラブル（ループで要素を取り出して使えるもの）を作るクラス」、lenは「イテラブルの長さを取得する関数」ですね。下の方法の方がスマートですが、インデックスを使った複雑なループでは上の方法にも分があるケースがあります。

　あるいは、「割り算や掛け算の結果をインデックスに使ってしまった」場合も、こういうエラーは起こりえます。特に割り算には注意です。

>>> lst = list(range(10))
>>> lst
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> for i in range(10):
...     print(lst[i/2])
... 
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
TypeError: list indices must be integers or slices, not float

　「整数/整数」は浮動小数点数を返します。整数で結果を得たいときは//を使うか、int, math.floor, math.ceil, roundなどを使って丸めてください。

math --- 数学関数 — Python 3.7.4 ドキュメント
 組み込み関数 — Python 3.7.4 ドキュメント

>>> for x in range(10):
...     print(lst[x//2])
... 
0
0
1
1
2
2
3
3
4
4

　また、掛け算はどちらかのオペランドが浮動小数点数なら結果も浮動小数点数になりますので、やはりint型への変換が必要になります。

似たようなもの

　大半のイテラブルは添字表記で整数型しか使えません。

>>> (0,1,2)["hoge"]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: tuple indices must be integers or slices, not str
>>> "hoge"["hoge"]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: string indices must be integers

　対処の方針は同じです。

　辞書のつもりでリストを作成していた、あるいはsetを作成していたというケースもありそうです。そういったケースでは、そもそも添字表記の対象とするオブジェクトの作り方が間違っていないのかというところから見直す必要があります。

まとめ

　わかってしまえばなんてことはないエラーなのですが、ぱっと見なにを言っているのかよくわからないので戸惑う、ということも初心者の方にはありがちだと思います。とにかくlistや大半のイテラブルは添字表記に整数、またはスライス（これも整数しか受け付けません）しか受け付けない、そこに整数以外が入るとエラーになる、ということを理解してコードを書くことが大切だと思います。

TypeError: '***' object is not subscriptableの対処法

2019-06-25T01:33:31+09:00

はじめに

　Pythonを始めてからしばらく時間が経って、ある程度自力で複雑なプログラムを書くようになると、タイトルのようなエラーに遭遇することが多いと思います。

　このエラーが出たときは、たいていはロジックに問題があります。一概に通用する対処法がないので、地道にデバッグをするのが基本です。

　ただ、見慣れない単語が並んでいると思考が停止してしまう人も多いと思います。そこで、大まかな意味と対処法を書いておこうと思います。

はじめに
原因
対処
まとめ

原因

　まず、subscriptというのは添字のことです。subscriptionという形にすると添字表記という訳になり、これはlistやdictやstrなどから要素を取り出す、あれのことです。

>>> a = [0, 1, 2]
>>> a[0]  # これが添字表記
0
>>> d["hoge"]  # これも添字表記
0
>>> "hoge"[0]  # これも添字表記
'h'

　Pythonの型には、添字表記に対応しているものと対応していないものがあります。上であげたlist, dict, strはすべて添字表記に対応しています。一方、対応していないものの代表例はint, floatなどの数値型です。

>>> i = 0
>>> i[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not subscriptable
>>> j = 0.1
>>> j[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'float' object is not subscriptable

　「int型/float型のオブジェクトに対して添字表記を使うことはできませんよ」と言ってくれている訳です。これがこのエラーの出る原因です。

対処

　さて、こういうエラーですので、様々なシチュエーションで出てくる可能性がある、ということはなんとなくわかると思います。

　ありがちなのは、listのlist（俗に言う二次元配列）を作ったつもりで、うまくいっていないみたいなケースでしょうか。

>>> lst = [[0,1], 2, 3] # うまく要素が入っていない
>>> for i in range(2):
...     for j in range(2):
...         print(lst[i][j])
... 
0
1
Traceback (most recent call last):
  File "<stdin>", line 3, in <module>
TypeError: 'int' object is not subscriptable

　他にも、listみたいなものが返ってくるつもりで書いた関数が実際にはlist以外のものを返していた、みたいなパターンもあるかもしれません。

>>> def pow_lst(lst):
...     result = [x**2 for x in lst]  # returnするのを忘れた
... 
>>> pow_lst([0,1,2,3])[0]  # なにも返さなければNoneというオブジェクトが返る
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'NoneType' object is not subscriptable

　とにかく色々なケースで出てくるので、対処法としては、

エラーメッセージを見て、どの行で出てきたのかを突き止める
添字表記を使おうとしたオブジェクトがどんな型なのかを覚えておく
それが自分のコーディング意図と一致しているのかを調べる
場合によっては添字表記を分解し、printデバッグなどをすることで原因を究明する。つまり、たとえば以下のようにする。

# 変更前
result = 何らかの関数など()[0]  # ここでエラーが出たとする

# 変更後
tmp = 何らかの関数など()
print(tmp, type(tmp))
result = tmp[0]

　頑張って検証すればなんとかなることが多い印象ですので、トライしてみてください。

まとめ

　基本的ですが、こういうところで戸惑う人が減るようにと解説を書いてみました。お役に立てれば幸いです。

【python】print関数を使いこなそう

2019-03-18T03:00:56+09:00

ぼくたちは本当のprintを知らない

　pythonのprint関数については、たかがprintと思っている人も多いと思いますが、しかしオプションをすべて言える人はあまりいないと思います。把握しておくと出力の細かい制御をしたいとき役立ちます。

　そこで、printの使いこなしについて書きます。なお、念のために先に断っておくと、新し目のpython3のprint関数の話です。python2のprint文とはまったく異なります。

printのオプション

　ドキュメントによると以下の引数を取ります。

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
組み込み関数 — Python 3.7.3rc1 ドキュメント

　*objectsは任意個のオブジェクトをprintできることを示します。sep=' 'は、オブジェクトの区切り文字が半角スペースになるということです。これは*objectsに渡したオブジェクトの数-1個表示されます。また、end='\n'は行末に何を置くかを指定しており、デフォルトは改行です。これは行末に1つだけ置かれます。

　特殊なのはfile引数とflush引数です。file引数は出力ストリームに対応し、デフォルトのsys.stdoutはいわゆる標準出力です。任意のファイルオブジェクトを与えられるので、ファイルに書き込むといった用途に使えます。flushはいわゆる出力バッファのフラッシュの挙動になります。何もしなければ標準出力は改行時にフラッシュされますが、これをTrueにするとprintを呼ぶたびにフラッシュされるようになります。

sepの使い方

　何も指定しないと半角スペースになるので、次のような見慣れた挙動になります。

>>> print(1, 2, 3)
1 2 3

　空の文字列にすることで間を詰めることが可能です。

>>> print(1, 2, 3, sep="")
123

　あるいは好きな文字列を渡すことも可能です。

>>> print(1, 2, 3, sep=",")
1,2,3
>>> print(1, 2, 3, sep="***")
1***2***3

　リストの要素を適当な区切り文字で区切って表示したいというような場合、str.joinで頑張るより、リストのアンパックとprintのsep引数を組み合わせて使った方がスマートだったりします。

>>> l = [1, 2, 3]
>>> print(",".join(map(str, l)))  # こちらの場合は型変換も必要
1,2,3
>>> print(*l, sep=",")  # これだけ
1,2,3

　裏を返せば表示形式はすべて__str__任せになるので、細かい出力フォーマットは指定できないということでもあるのですが、簡易的に使いたい場合はsepの方が便利です。

endの使い方

　改行させたくないときにendを空文字列にする、というのがよくあるユースケースです。

>>> for x in range(4):
...     print(x)
... 
0
1
2
3
>>> for x in range(4):
...     print(x, end="")
... 
0123

　最後に一回改行するために、もう一回printを呼ぶと良いと思います。

　プログレスバー的な進捗表示を簡単にやりたいとき重宝しますが、それっぽく見せるためには後述のflush引数も併用する必要があります。

fileの使い方

　fileはたとえばファイル出力に使えます。

>>> with open("hoge.txt", "w") as f:
...     for x in range(4):
...         print(x, file=f)
... 
>>> (ctrl-dでpythonを終了)
$ cat hoge.txt
0
1
2
3

　その気になればcsvファイルの文字列を手動で作って吐き出すといった用途に使えます。あるいはソケットを叩いたりするのにも使えると思います。ただ、濫用しすぎないことをおすすめします（通常は他に良い方法がある）。

flushの使い方

　flushは前述した通りendと組み合わせると便利です。

>>> import time
>>> for _ in range(10):
...     print("*", end="")
...     time.sleep(0.5)
... 
**********

　進捗表示をやりたくてこんなコードを書く人も多いと思いますが、これは期待通り動作しないと思います。確かに最終的な結果は同じでも、5秒ほどしてから出力が一気に出てくるという挙動になるはずです。これはsys.stdoutが改行されるまでフラッシュされないからです。

　flush=Trueで解決します。

>>> import time
>>> for _ in range(10):
...     print("*", end="", flush=True)
...     time.sleep(0.5)
... 
**********

　これでおよそ0.5秒おきに1つずつ表示されるはずです。

本当のprintを理解したあとの感想

　print一つとっても、意外といろいろな使い方があるということがわかるかと思います。出力の制御にけっこう使えます。

　こういう仕様はすべて公式ドキュメントに書いてあります。ドキュメントに普段から慣れ親しんでおくと、スムーズにコーディングできる、行き詰まったとき打開策が思い浮かぶ、ライバルと差が付けられる、といった利益があります。ドキュメントを読むのに慣れていない方は、printなど単純なものから読んでみると楽しいと思います。

【python】引数のデフォルト値は定義時評価なので注意

2018-11-06T01:55:06+09:00

はじめに

　pythonでは関数の引数にデフォルト値を設定することができます。

　この機能を使うと、引数が与えられなかったときの挙動を定義することができ、とても便利です。

>>> def f(x="hoge"):
...     print(x)
... 
>>> f("aiu")
aiu
>>> f(x="aiu")
aiu
>>> f()
hoge

　ただし、デフォルト値にlistやdictなどのmutableな型を使うと容易にハマります。それについて説明します。

ハマる例

　デフォルト値に空のリストを追加したとします。

>>> def g(x, l=[]):
...     l.append(x)
...     return l
... 
>>> g(10)
[10]
>>> g(20)
[10, 20]

　さっそくおかしな感じになっています。lが呼び出しのたびに更新されていないようです。そのせいで、前の値が残ってしまうようです。

検証

　listを継承したクラスを作り、コンストラクタが呼ばれるとメッセージを表示するようにします。

>>> class mylist(list):
...     def __init__(self, *args, **kargs):
...         print("__init__ of mylist")
...         list.__init__(self, *args, **kargs)
... 
>>> l = mylist()
__init__ of mylist
>>> l
[]
>>> l.append(1)
>>> l
[1]

　__init__にメッセージを挟んだ以外は何もいじっていないので、元のlistと同様に扱えます。

　このインスタンスをデフォルト値にしてみます。

>>> def h(x, l=mylist()):
...     l.append(x)
...     return l
... 
__init__ of mylist
>>> h(10)
[10]
>>> h(20)
[10, 20]

　なんということでしょう、defが実行されたタイミングで評価されて、それっきりです。

解説と対策

　これは、実はドキュメントにも説明がある事項です。

重要な警告: デフォルト値は 1 度だけしか評価されません。デフォルト値がリストや辞書のような変更可能なオブジェクトの時にはその影響がでます。
4. その他の制御フローツール — Python 3.6.5 ドキュメント

　要するに「仕様」ということですね。

　対策は、これも上のページに書いてあることですが、デフォルト値はNoneにしておき、都度関数の中でインスタンス化することです。

>>> def i(x, l=None):  # ここは定義時評価
...     if l is None:  # ここは実行時評価
...         l = []
...     l.append(x)
...     return l
... 
>>> i(10)
[10]
>>> i(20)
[20]
>>> i(10, l=[-10, 0])
[-10, 0, 10]

　わかってしまえば簡単な話ですが、気づかないと大変なミスをやらかすので注意してください。

　逆に、これを利用してクロージャもどきとして使ったり、難読コードを書くことも可能です（やらないけど）。

まとめ

　再帰的にリストを処理するような関数を書くとき、def f(l=[]):のように書きたくなってしまいますが、バグを産むので注意してください。
　

【python】missing 1 required positional argument: 'self'などの対処法

2018-10-05T23:34:18+09:00

はじめに

　pythonに不慣れな方は、よくタイトルのようなエラーを見かけると思います。

　実際には、このエラーはTypeErrorで、全体は以下のようなものです。

TypeError: メソッドの名前 missing 1 required positional argument: 'self'

　では、どうしてこのエラーは出るのでしょうか。そして、どうすれば良いのでしょうか。

　簡単に解説していきます。なおpython3を使っていることを前提とします。

クラスをインスタンス化していない

　このエラーは、なんとなくエラーの文面だけ見ると、引数を渡してあげれば良いのかな？　というような気がします。実際、引数を要求する関数を引数無しで呼び出すとほぼ同じエラーが出ます。

>>> def f(a):
...     pass
... 
>>> f()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: f() missing 1 required positional argument: 'a'

　だけど、ライブラリやモジュールのドキュメントをのぞいてもselfという引数に関する記載はなかったりします

　実は、このエラーにはpythonのクラスの言語仕様が関係しています。

　pythonでは、通常のメソッドでは第一引数にオブジェクトのインスタンスそのもの（Javaでいうthis）が渡されてやってくる、という仕様になっています。

　たとえば次のようなコードを試しに実行してみます。

test_hoge.py

class Hoge:
    def print_hoge():
        print("hoge")

h = Hoge()
h.print_hoge()

実行結果

Traceback (most recent call last):
  File "test_hoge.py", line 6, in <module>
    h.print_hoge()
TypeError: print_hoge() takes 0 positional arguments but 1 was given

　print_hoge()は1つも引数を取らない関数として定義されているのに、1つ渡されています、というエラーが出ます。ここで渡されているものがインスタンス自身です。

　インスタンス自身を受け取る名前は、実はどんな名前でも構わないのですが、慣習的にpythonでは「self」を使います。さっきのコードをselfを受け取るように書き換えましょう。

test_hoge.py

class Hoge:
    def print_hoge(self):
        print("hoge")

h = Hoge()
h.print_hoge()

実行結果

hoge

　無事実行できるようになりました。よかったね、という話なのですが、これを今度はインスタンス化しないで呼んでみましょう。

test_hoge.py

class Hoge:
    def print_hoge(self):
        print("hoge")

Hoge.print_hoge()

実行結果

Traceback (most recent call last):
  File "test_hoge.py", line 5, in <module>
    Hoge.print_hoge()
TypeError: print_hoge() missing 1 required positional argument: 'self'

　はい、エラーが再現しました。このような状況になっていた訳ですね。

対策

　このエラーに遭遇した場合、大抵はインスタンス化して使うべきクラスを不適切にインスタンス化せずに使っていたというケースだと思います。インスタンス化してあげましょう。上の例の、ちゃんと実行できるコードを再掲します。

class Hoge:
    def print_hoge(self):
        print("hoge")

h = Hoge()  # この行でインスタンス化
h.print_hoge()

　ただし、自作クラスで「インスタンス自身なんか処理に使わないから、クラスのまま呼べるようにしたい」という場合もあると思います。その場合は、@staticmethodとメソッド宣言の前に付けてあげるとスタティックメソッドを定義できます。
　（「@staticmethod」そのものは特別な記述子とかではなく、pythonでは一般的に使われるデコレータという機能で実装されています。詳細はドキュメントやヘルプを参照してください）

class Hoge:
    @staticmethod  # これによってスタティックメソッドになる
    def print_hoge():
        print("hoge")

Hoge.print_hoge()

　ただし、これはつまるところただの関数と何も違いません。スタティックメソッドを使うメリットはかなり限られた場面にしかありません。だいたい、pythonではクラスを入れ物的に使うということをあまりしません（通常はトップレベル関数として定義し、モジュールで管理する）。本当にそのスタティックメソッド必要？　と考え直す視点は常に持っておいた方が良いです。

　なお、似たようなデコレータに@classmethodというというものもありますが、これは第一引数に「クラス自身」が渡されるというもので、スタティックメソッドとはまた別物です。間違えないようにしてください。

色々なパターン

　これに似ているパターンが幾つかあると思うので、カバーしておきます。

引数を受け取るメソッド

　このようなケースです。

test_hoge.py

class Hoge:
    def print_hoge(s):
        print("hoge", s)

h = Hoge()
h.print_hoge("fuga")

実行結果

Traceback (most recent call last):
  File "test_hoge.py", line 6, in <module>
    h.print_hoge("fuga")
TypeError: print_hoge() takes 1 positional argument but 2 were given

　この記事をここまで読んできた皆さんは、もうどうすれば良いかおわかりだと思います。

正しいコード

class Hoge:
    def print_hoge(self, s):
        print("hoge", s)

h = Hoge()
h.print_hoge("fuga")

まとめ

　pythonのクラス周りは他の言語と比べてちょっと独特ですが、「通常のメソッドではインスタンス自身が暗黙的に第一引数に渡される」というルールさえ理解してしまえば、むしろわかりやすいと言えます。「thisが自動的にインスタンス自身を表すキーワードとして機能する」という魔法がない分、一貫性があってすっきりしているからです。

　ただ、理解するまではタイトルのようなエラーにはよく遭遇すると思います。早く覚えてこんなエラーは出さないようにしましょう。

python環境構築まとめ

2018-06-05T03:46:39+09:00

概要

　pythonの環境構築に悩む人たちのために、環境構築についてまとめておきます。

概要
はじめに
覚えておいてほしい大切なこと
pythonをやるのに向いたOS
生のシステムのpythonを使う（システムに直接インストールしてそのまま使う）
パッケージマネージャについて
仮想環境編
- 定石
- venv
- virtualenv
- pyenv
- anaconda
- その他の仮想環境
- 結論
まとめ

はじめに

　pythonは最近よく流行っているスクリプト言語ですが、残念ながら環境構築のとっつきづらさは他の言語の比ではないと思います*1。初心者が変な環境を作ってトラブルの元になる・・・というのもよくあることなので、この際まとめておこうと思いました。

　さて、まず大前提として、メインで使うpythonはpython3系にします。今からpython2系を学習する意味はほとんどないからです。

　また、この記事では環境構築に際して使う各ツールの操作手順については述べません。それぞれの構築方法についてご自身で検索していただければ良いと思います。日本語Web圏におおむね十分な情報があります*2。

覚えておいてほしい大切なこと

　「自分でよくわからない／把握できない環境は作らない」

　これが基本です。

　ネットには無責任に「○○が良いですよ～」と書いてしまう人はたくさんいます。それを真に受けて、使い方もよくわからないツールを落としてきて入れ、記事に書いてある操作手順通りにインストールし、インストールはできたけど使用開始とほぼ同時に早速ハマる……というどうしようもないことをする初心者の方も一定数います。

　むやみにツールを入れないでください。入れるなら、入れる前に目的と使い方くらいは理解しておきましょう。そうしないと扱いきれません。

　実際、何も知らない初心者が、ネットの記事に書いてあるコマンドをコピペしてpyenvやanacondaを導入し、扱いきれなくて挫折する……という悲劇がたくさん起きています。

pyenvが必要かどうかフローチャート - Qiita
Pythonの環境管理ツール良し悪し - Zopfcode

python import errorに関連する質問・回答の検索結果(1ページ目)｜teratail

　できるだけそういう事態になりそうな展開は回避し、単純な環境で構築してから他のツールに手を出した方が、失敗しづらいはずです。

pythonをやるのに向いたOS

　ご存知の通り、pythonはマルチプラットフォームなスクリプト言語です。しかしどうしても、OSによって向き不向きがあるようです。

windows

　おすすめ度：☆3
　率直に言って、おすすめできません。windowsだと余計な苦労が増えます。上級者は普通に使いこなせると思いますが、初心者向けではありません。

　それでも一時期に比べれば、wheelで入るライブラリも増えたし、UNIXに依存するライブラリというのもないので、簡単になった方です。エラーメッセージが出たときに、根気よく検索して対処できる人向けです。

　Bash on Ubuntu on Windowsは使ったことがないのでわかりません。ごめんなさい。

Mac OS

　おすすめ度：☆2
　これも、あまりおすすめしません。使い勝手自体はwindowsよりはマシですが、Web情報はwindowsより少なかったりします。Mac特有のハマり方があるので*3、少ない英語情報を必死に探って自己解決できる人でないとしんどいと思います。

　初心者は避けた方が無難です。「pythonでプログラミングを勉強したい！」と思ったとき、いきなりMacを買う理由はないということです。

linux系

　おすすめ度：☆4
　windows, macよりはおすすめです。初心者はlinux系を使えば良いと思います（pythonをやるついでにlinuxの勉強も出来て一石二鳥です）。ただ、まったく経験がないと敷居が高いのも事実です。

　windowsマシンの上に仮想マシン（後で述べるpython仮想環境とは別物です）で入れれば、環境ぶっ壊しちゃっても作り直せば良いだけで、とても気楽です。

　linux系にはディストリビューションがいろいろありますが、デファクトスタンダードはubuntuです。このことは、「ubuntu python 環境構築」とか検索すれば幾らでも記事が出てくる、ということを意味します。他のディストリビューションはそこまで強くないので、手を出すのは中級者以上になってからで良いと思います。

その他のOS

　そんなの使いたがる人はこの記事を読んでいないと思いますが・・・。

　FreeBSD使いの人はいるかもしれませんね。頑張ってください。応援しています。

　Android、iPhoneなどのスマホ・タブレットに入れたがる人も時々います。対応した実装もあるといえばあるのですが、あまり使いやすいものではありませんから、素直にノートパソコンを買った方が有利です。

Web上実行環境

　OSではありませんが、実はWeb上でpython（に限らずいろいろな言語）を実行できるサービスがあります。たとえばWandboxなんてどうでしょう。

[Wandbox]三へ( へ՞ਊ ՞)へﾊｯﾊｯ

　こういった環境は、勉強とか、ちょっとした動作チェックには重宝します。それ以上でもそれ以下でもないのですが、とりあえず取っ掛かりとしてはありです。簡単に試してみたい、というときはここに入門書の内容などを打ち込んでいくと良いと思います。

結論

　今使ってるwindowsマシンにVirtualBoxかVMWare Playerを落としてきて、ubuntuを入れましょう。

生のシステムのpythonを使う（システムに直接インストールしてそのまま使う）

　さて、ubuntuを入れた方はターミナルで「python」と打つといきなりpythonが立ち上がると思います。今どきのUNIX系OS（事実上linux+Mac）であれば最初からpythonが入っているので、それが使える訳です。

　これをそのまま使う、というのは選択肢の一つです。ただ、2018年6月現在では、まだシステムデフォルトのpythonがpython2系のシステムがほとんどだと思います。できればpython3系を使いたいので、これはボツです。もしデフォルトがpython3系のシステムにあたったら、しばらくはそれを使って基本的な構文や機能の勉強をやれば良いと思います。

　システムのpythonがpython2系だけどpython3系を使いたい、という場合、システムにpython3をインストールすることができます。この場合、python2を消したり、置き換えたりはせず、python2とpython3を共存させるようにするのが無難です。python2はシステムの中で使っているプログラムがいろいろあるので、消してしまうとOSがまともに動かなくなります。

　また、python2系がデフォルトだけど、python3系も一緒に入っている、というシステムもあります（最近のubuntuはそうだったはずです）。これはしめたもので、そのまま使えばインストールの手間が省けますし、インストールで事故る確率も減らせます。ただし、pipなどは自分で入れてやる必要があったりするようです*4。

　おそらく、python2とpython3が共存する環境では、「python」とターミナルに打ち込むと平然とpython2が立ち上がってくるはずです。そういうときは、慌てずに「python3」と打ち込みます。そうすると（ちゃんとインストールされていれば）python3が立ち上がるので、使うことができます。

　また、パッケージマネージャのpipも、（インストールされていれば）「pip」と打つとpython2に対応するpipが立ち上がってくるはずです。同様にpip3と打てばpip3が立ち上がるので、こちらを使います。パッケージマネージャについては次章で詳しく述べます。

パッケージマネージャについて

　パッケージマネージャは、主に外部ライブラリなどを管理するためのツールです。

　2018年6月現在では、間違いなくpipがスタンダードです。大抵のものがpipで入ります。というか、pipで入らないものは他のパッケージマネージャでも扱えないので、pip以外を使う意味がまったくありません（というか、そもそも存在しているの？　レベル）。

　例外として、anaconda（あとで述べます）を使う人はcondaというanaconda独自のツールを使う必要があります。

　また、pipで扱えない、ソースコードで配布されているだけのパッケージも存在します。そういうものはsetup.pyなど*5を使って環境に入れます。大抵はパッケージのreadmeとかで親切に説明してくれているので、その通りにやれば良いです。

　さて、pipと一口に言っても、実はコマンドの打ち方はいろいろあります。

　もしインストール手順などで「pip install ○○」と指示されていたら、それは「自分の環境に合った方法でpipを使って入れろ」ってことです。この通りコマンドを打っても、ほぼ入りません。

　以下に大まかな傾向を書いておきますが、あくまでも参考情報です。極論すれば、pip自体のありかがわかって、権限の問題が解決できれば、コマンドの細かい違いはどうでも良いことです。でも、使い分ける上ではこれらは重要です。

sudo pip

　これは普通はシステムのpythonにインストールする場合です（そういう認識で構いません。普通にaptとかでインストールすると権限が必要な場所に入ると思います）。

　sudoはunix系のコマンドであり、windowsだとsudoはないので、なにか違う方法で同様のことを実現する必要があります*6。また、python2とpython3を使い分けていれば「sudo pip3」というのもありえます。

　ただのpip。仮想環境を使うと、これで済むと思います。逆に、仮想環境を使っていないとただのpipで済む場面はあまりないとも言えます。

pip2、pip3

　システムに異なるバリエーションのpythonを複数インストールして、仮想環境等を使わずに使い分ける場合、区別のために数字付きのpipコマンドを使うことになります。インストール先にもよりますが、sudoを付ける必要があるかもしれません。また、python3.5とpython3.6を使い分けたい、という場合、pip3.5とpip3.6を使い分けます。面倒くさいですね。

　自分が使っているpythonに入れるにはどれを使えば良いのか、把握しておきましょう。

「pipでインストールしたのに使えません！」
「違うpythonに入れてるみたいですね！」

　というやり取りは、割と頻繁に目にします。

仮想環境編

　この章はあんまり書きたくはないのですが・・・。

　システムのpython（インストールしたままのpython）を使うと、ミスって環境をぶっ壊してしまうリスクがあります。管理もいろいろ面倒です。そこで、仮想環境を使うと良いですよ、ということがいろいろなところで言われています*7。

　ぶっちゃけた話、仮想環境を作るのは初心者にはコストが高いです。ネットで調べてその通り打ち込むだけといえば、その通りなのですが、それでもけっこうハマりどころがあります。なので、入門書程度の内容をやっている間は、仮想環境は要らないと思います。pipでライブラリをがつがつ入れたくなったときに、検討してみてください。

　また、げんなりすることに、仮想環境は何種類もあります。互換性もないし、使い方も違うしで、どれを選べば良いのかよくわかりませんよね。安心してください。ある程度定石があります。

定石

　venvかvirtualenvのどちらかを使う。

　これで良いと思います。それぞれについては追って説明します。

venv

　おすすめ度：☆5　
　最近のスタンダードです。が、実は次節のvirtualenvがpython3.3で標準モジュールとして取り入れられたものと解釈して、ほとんど間違いありません。

　venvはシステムにインストールされているpython3.3以上に依存します。というか、python3.3以上のpythonが環境に入っていれば、自動的に使えます（よほど変な環境構築をしていない限り）。なので、最近のubuntuならこれを使えば良いですし、自分でpython3を入れてvenv、というのもありです。

　特に使いづらいとかもなく、普通に使えます。

virtualenv

　おすすめ度：☆4　
　一昔前のスタンダードでした。venvがpython3.3に入って以降は存在意義が薄くなっていますが、システムにpython2系しかなく、というかそもそも使うのがpython2系だけです、みたいな状況で使うのは今でもありです。

　これは外部ライブラリなので、pipでインストールする必要があります。

　また、venvでできなくてvirtualenvでできることとして、pythonインタプリタ本体のバージョンを切り替える操作があります。複数のバージョンを共存させたい場合は、システムのpythonにvirtualenvを入れ、あとは好きなところに複数バージョンのpythonを入れ、仮想環境を作るといった使い方ができます。

pyenv

　おすすめ度：☆3　
　一昔前にちょっと流行っていました。未だに記事をたくさん見かけますが、今から使いたいかと言われると、正直イヤです。venvでいいと思います。

　長所はpythonに依存しないことです。そのかわり、シェルスクリプトに依存します。当然windowsでは動きません。これを欠点と呼ぶかは悩みますが（記事の最初でwindowsは斬って捨ててる訳だし）、とにかくそういう特徴があります。

anaconda

　おすすめ度：☆3
　anacondaは有名ですね。環境構築の手間が省けて、統計や機械学習用のライブラリまで丸ごと入れられる、という奴です。しかし、個人的には☆3を付けます。

　anacondaの最大の利点は、condaという独自のパッケージ管理システムを持つことで、オリジナルのpipと比べてもパッケージのインストールや仮想環境の操作が容易であることです。

　一方、欠点は、パッケージ管理周りがpipとはまったく別物なので、anaconda独自のハマりどころがたくさんある、ということです。ハマると面倒ですし、ちょっとマイナーな話題だとWebに情報があるかも怪しい、githubにissue上がっててもcloseしないまま何ヶ月も放置されてる、といった具合です。

onoz000.hatenablog.com

　端的にいうと、確かにanacondaの開発は頑張ってはいるけど、パーフェクトというほどの完成度ではないので、anacondaを使うと問題がややこしくなるケースというのが一定数存在します。どう判断するかは人によりますが、私は最初からpipを使った方がマシだと思います。

　それでも、環境構築のことは何も知らない人が、手軽に統計とか機械学習を試すためにあると思えは、anacondaは弁護できます。実際、numpyとかscipyとかcythonとかmatplotlibとかsklearnとかを自分でインストールしようとすると、それはそれで一筋縄ではいかないので、「その辺のライブラリをさっさと使いたいんです、授業が/研究が/研修が済んだらもうpythonなんか触らないんです」という状況であれば、anacondaはありです。

　逆に、長くpythonを使い続ける、いろいろなライブラリを入れたりして愛用していく、のであれば、やめた方が良いと個人的には思います。多少手間がかかっても、自分で普通に環境構築して、pipを使ったインストールに慣れた方が良いです。

　申し訳ありませんが、そういう認識です。

その他の仮想環境

　採点はしません。

virtualenvwrapper

　名前の通り、virtualenvのラッパーです。使い勝手が改善されているらしいですが、使ったことがないのでわかりません。ごめんなさい。

　生virtualenvを使いづらいと感じたことは特にないので、これを使うならvirtualenvで良いと思います。まあ、最終的には好みの問題ですが、多少コマンドが打ちやすくなるとかのために不安要素を増やすかというと、Noです。

pyenv-virtualenv

　pyenvでvirtualenvwrapperに相当するものです。これも恐らく要らないと思います。

pyvenv

　venvの別名。あまりにpyenvと紛らわしいため（だと思います）、非推奨にされたそうです。

venv --- 仮想環境の作成 — Python 3.7.4 ドキュメント

conda

　これはanacondaの管理ツールです。「conad install ○○」とかやって使うそうです。見た目はpipっぽいですが、中身はまったくの別物。

pipenv

　これは比較的新し目のツールです。pipとvirtualenvを統合したという、ちょっと触れ込みだけでは想像がつかないもの。まだ試していませんが、そのうち試してみます。

結論

　venvかvirtualenvのどちらかを使う。

　最初に言いたいことはまとめたので、特に追加で言うことはないです。

まとめ

　この記事に書いてあることをどこまで信頼するかは、あなた自身で決めてください。私は何も保証しません。それはあなたの責任です。

　この記事の内容自体はそんなに外していないとは思います。しかし、人によって考え方の違いもありますし、環境構築に正解なんてありません。究極的には動けば良いのです。せいぜい一つの指針にしてください。

　あと、間違いにお気づきになられた識者の方は、ご遠慮無くご指摘いただけると大変助かります。

*1:もちろん、探せばもっとひどい言語はあるだろうけど。スクリプト言語の平均よりは明らかに悪いという程度の意味

*2:信用に足る記事があるかはまた別ですが・・・新し目でまともそうなものを選ぼう、としか言えません

*3:というかライブラリとかがMacまでしっかり考えて作られていない・・・Macのパッケージマネージャもいまいちpythonに優しくない・・・

*4:参考：Ubuntu環境のPython - python.jp

*5:distutilsなどという。参考：distutils --- Python モジュールの構築とインストール — Python 3.7.4 ドキュメント

*6:もしかしたらただのpipかもしれないし、管理者権限でやる必要があるかもしれない。インストール先等で変わってきます

*7:仮想環境とは何ぞや、という基本的なことについてはこちらを参照：仮想環境 - python.jp

【python】listをforループで回してremoveしたら思い通りにならない

2018-06-02T16:34:15+09:00

　forループでループ対象のリストから要素を削除してしまったりすると、まったく想定と違った結果になってしまうことがあります。

　pythonプログラミングを始めたばかりの人がよくハマるトラブルです。日本語Web圏にはイマイチよくまとまった記事がないようなので、まとめておきます。

問題の概要

　たとえば、0から9のリストから偶数だけ取り出そうとして、こんなコードを書いてみます。

>>> lst = [0,1,2,3,4,5,6,7,8,9]
>>> for x in lst:
...     if x%2 != 0:
...         lst.remove(x)
... 
>>> lst
[0, 2, 4, 6, 8]

　一見すると上手く動いているようです。調子に乗って、今度は3の倍数を取り出そうとしてみます。

>>> lst = [0,1,2,3,4,5,6,7,8,9]
>>> for x in lst:
...     if x%3 != 0:
...         lst.remove(x)
... 
>>> lst
[0, 2, 3, 5, 6, 8, 9]

　おかしくなった。なぜでしょう？　forがちゃんと動いていない？　という感じで、ハマります。

原因

　こういうときはforのループごとにxに代入されている値をprintしてみると、どんなことになっているのかよくわかります。

>>> lst = [0,1,2,3,4,5,6,7,8,9]
>>> for x in lst:
...     print(x)
...     if x%2 != 0:
...         lst.remove(x)
... 
0
1
3
5
7
9
>>> lst
[0, 2, 4, 6, 8]
>>> lst = [0,1,2,3,4,5,6,7,8,9]
>>> for x in lst:
...     print(x)
...     if x%3 != 0:
...         lst.remove(x)
... 
0
1
3
4
6
7
9
>>> lst
[0, 2, 3, 5, 6, 8, 9]

　なんてことでしょう、ちゃんと動いていない！

　・・・これはドキュメントにも書いてある、pythonのれっきとした仕様です。

注釈ループ中でのシーケンスの変更には微妙な問題があります (これはミュータブルなシーケンス、すなわちリストなどでのみ起こります)。どの要素が次に使われるかを追跡するために、内部的なカウンタが使われており、このカウンタは反復のたびに加算されます。このカウンタがシーケンスの長さに達すると、ループは終了します。このことから、スイート中でシーケンスから現在の (または以前の) 要素を除去すると、(次の要素のインデクスは、すでに取り扱った現在の要素のインデクスになるために) 次の要素が飛ばされることになります。（※筆者強調）　同様に、スイート中でシーケンス中の現在の要素以前に要素を挿入すると、現在の要素がループの次の週で再度扱われることになります。こうした仕様は、厄介なバグにつながります。

8. 複合文 (compound statement) — Python 3.7.3 ドキュメント

　インタプリタの内部では、カウンタで管理しているんですね。削除しようとして失敗するのは、それが原因です。

回避策

　とりあえず、公式ドキュメントにはこのような方法が記載されています。

for x in a[:]:
    if x < 0: a.remove(x)

　ここで[:]というのは範囲指定なしのスライスです。これはこのように機能します。

>>> lst = [0,1,2,3,4,5,6,7,8,9]
>>> lst[:]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

　まったく無意味な気がしますが、実は両者は別のオブジェクトになっています。

　id()関数で確認してみます。

>>> id(lst)
140603063055816
>>> id(lst[:])
140603063055048

　つまり、[:]は中身の同じコピーを作ることができます。こうすればループの対象のリストは変更されないので、問題なくループを回せるという訳ですね。

　でもこういうコードはちょっとかっこ悪いので、内包表記を使った方がベターです。

>>> lst = [0,1,2,3,4,5,6,7,8,9]
>>> [x for x in lst if x%3 == 0]  # 条件の反転に注意（残すものの条件を指定する）
[0, 3, 6, 9]
>>> lst  # 上のコードは新しいリストを作る。元のリストは変わらない
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> lst = [x for x in lst if x%3 == 0]  # 再代入するとlstの値が変わる（ただし別のオブジェクトになる）
>>> lst
[0, 3, 6, 9]

　どうしても同じオブジェクトをいじらないといけない、というシチュエーションも稀にありますが、そうでなければ内包表記などを使って新しくリストを作る、という発想で書いた方が簡単ですし、へんなバグも生みません。

　余談ですが、pythonではlist.remove()はあまり使わないメソッドです。他にもlist.pop()やlist.insert()などリストを操作するメソッドはたくさんありますが、これらをforループと組み合わせて書くような操作は、大抵の場合は内包表記などで代用できます。そして、その方が元のリストを壊さないので、バグが発生する余地が減ります*1 *2。

　なので、初心者の方はあまりこういったものに頼らず、まずは内包表記から覚えるか、内包表記がとっつきづらければ空listにappendしていく方法を使うのが良いと思います。

>>> lst = [0,1,2,3,4,5,6,7,8,9]
>>> result = []
>>> for x in lst:
...     if x%3 == 0:
...         result.append(x)
... 
>>> result
[0, 3, 6, 9]

　これはappendで書く場合の例です。実はリスト内包表記とほとんど同じようなことをやっているのですが、最初はこちらの方が読みやすいかもしれません。

まとめ

　pythonってけっこう直感的じゃない仕様があるので、「なんで！？」と思うこともままありますね。でも、どうせ慣れれば、そういう仕様は使わないで済ませられるようになってくるので、大丈夫です。

　基本的には「listをforループで回すときは、回しているlist自体はいじらないで処理する」ことを心がけるようにしましょう。この考え方が大切です。

*1:この考え方はけっこう重要です。こういうオブジェクトの状態を変更する操作を破壊的操作といいますが、これはよく把握していないとわかりづらいバグを生みやすいです

*2:他にも、特にlist.remove()はけっこうコストが高い（該当する要素が見つかるまで線形探索する）という理由があり、嫌われがちなメソッドです

【python】辞書で同じキーに複数の値を登録する

2018-04-24T00:25:24+09:00

　ちょっとしたTips。

　辞書（dict）は通常、一つのキーには一つの値しか登録できない。代入しても上書きされる。

>>> d = {}
>>> d["hoge"] = 1
>>> d
{'hoge': 1}
>>> d["hoge"] = 2
>>> d
{'hoge': 2}

　こういうときどうすれば良いのかというと、値をリスト等にしておいて、そのリストにappendしていけば良い。どのように使いたいかにもよるのだが、大抵はこれで用が済む。

　defaultdictを使うと面倒な初期化処理が省けて便利。

>>> from collections import defaultdict
>>> d = defaultdict(list)
>>> d["hoge"].append(1)
>>> d["hoge"].append(2)
>>> d
defaultdict(<class 'list'>, {'hoge': [1, 2]})
>>> d["hoge"]
[1, 2]

　別にlistじゃなくても、setだろうがdictだろうが何でも指定できる。tupleも指定はできるが、変更できないと何の役にも立たない。

>>> d = defaultdict(set) # setの場合
>>> d["hoge"].add(1) # setの場合はaddを使う
>>> d["hoge"].add(1)
>>> d["hoge"].add(2)
>>> d["hoge"]
{1, 2} # 重複しないことに注目
>>> d = defaultdict(dict) # dictの場合
>>> d["hoge"][1] = 1
>>> d["hoge"][2] = 2
>>> d["fuga"][-1] = -1
>>> d["fuga"][-2] = -2
>>> d
defaultdict(<class 'dict'>, {'hoge': {1: 1, 2: 2}, 'fuga': {-2: -2, -1: -1}}) # よくわからないけど何でもできそう

　参考：
8.3. collections — コンテナデータ型 — Python 3.6.5 ドキュメント

　mutableなコレクション型を辞書の値にしておく、という発想があればそれほど難しい話ではない。

【python】pythonでscanf的なことをする

2018-04-10T15:59:57+09:00

　一年以上前にこんな記事を書きました。

　これはこれで今読み返すと面白い（香ばしい）記事ですが、真剣にpythonでscanfと同じことをしたくてアクセスしてきた人には役に立たないという問題点がありました。

　そこで、pythonでscanfと同じことをする方法について真面目な記事を書いておきます。

何はともあれ入力を受け取る
文字列操作
正規表現を使う
parseライブラリを使う
まとめ
printf編

　なお、本記事では次のコマンドで実行できる対話的インタプリタの出力を掲載します。返り値の文字列をそのまま出していますが、標準出力から出力したいときはprintを使ってください。

$ python

何はともあれ入力を受け取る

　python2ではraw_input、python3ではinputという関数があり、標準入力からのキー入力を受け取ることができます。

　python2の場合

>>> s = raw_input()
hoge
>>> s
'hoge'

　python3の場合

>>> s = input()
hoge
>>> s
'hoge'

　この受け取った文字列を加工することで、なんとか所要を達するのが基本的なアプローチ方法になります。

文字列操作

　pythonには文字列の操作方法がいろいろあり、また文字列操作関数（メソッド）もいろいろあります。多すぎて網羅しきれないので、よく使うものだけまとめておきます。

>>> s = "hoge fuga" # 文字列の定義
>>> s[0] # 0文字目を取り出す
'h'
>>> s[-1] # 一番最後の文字を取り出す
'a'
>>> s[:4] # 0から3文字目を取り出す
'hoge'
>>> s[2:7] # 0から6文字目を取り出す
'ge fu'
>>> s.split(" ") # 半角スペースでsplitする
['hoge', 'fuga']
>>> s.replace("g", "G") # 文字列を置換する
'hoGe fuGa'
>>> s.isnumeric() # 数字の文字列かどうかを判定する
False

　なお、pythonはC言語と違って、「char型」というものはありません。1文字でもすべて「1文字の文字列」という扱いになります。

　このような文字列操作を型変換と組み合わせて使うことで、かなり色々なことができます。

>>> s = "1 1.5 1,5" # 文字列の定義
>>> splitted_s = s.split(" ") # とりあえずsplit
>>> splitted_s # splitした結果を表示
['1', '1.5', '1,5']
>>> d1 = int(splitted_s[0]) # splitした結果の0番目をint型にする 
>>> d1
1
>>> f1 = float(splitted_s[1]) # splitした結果の1番目をfloat型にする
>>> f1
1.5
>>> f2 = float(splitted_s[2].replace(",", ".")) # splitした結果の2番目をfloat型にする
>>> f2
1.5

　こういった処理をループなどと組み合わせて頑張れば、大抵のことは実現可能です。でも実際にやってみると頑張るのはなかなか辛いので、scanfのようなものがほしくなるのかもしれません。

正規表現を使う

　たとえば、こんな入力をした場合どうでしょう？

>>> s = "1, 1.5, 2, 2.5:hoge"

　この場合、一回のsplitで綺麗にsplitすることはできません。何回かに分けて繰り返しsplitするというのも一つの考え方ですが、こういう場合は正規表現を使うと簡単です。正規表現は標準ライブラリのreモジュールで使えます。

>>> s = "1, 1.5, 2, 2.5:hoge"
>>> import re
>>> re.split(r",\s+|:", s)
['1', '1.5', '2', '2.5', 'hoge']

　一発で綺麗にsplitできましたね。re.splitは区切り文字列の正規表現パターンと文字列を渡すと、それを探してそこで切ってくれます。

　",\s+|:"というパターンの意味を簡単に説明すると、「カンマの後にスペースが続く OR コロン1つ」を区切り文字として使うという意味です。見た目よりは簡単な内容を表しているのがおわかり頂けるでしょう。それでいて、けっこう色々な表現ができます。

　正規表現はプログラミングをやるなら覚えておいて損はしないので、まだ使ったことがない人も使えそうな機会がある度に積極的に使って、少しずつでも覚えていくことをおすすめします。

parseライブラリを使う

　正規表現で複雑なsplitなどが簡単にできると言っても、けっきょく型変換は自分でやるしかないのが実情でした。これではscanfには及びません。

　そこで、parseというライブラリを使うことができます。これは外部ライブラリなので、pipで入れる必要があります。

$ pip install parse

　※具体的なインストール方法は環境によって異なります。自分の環境でライブラリを入れる方法を確認した上で、正しい方法でインストールしてください。

　さっそく使ってみましょう。次のように使うことができます。

>>> parse.parse("{:d} hoge {:f}", "1024 hoge 11.19")[0]
>>> import parse
>>> s = input()
hoge 1024.20.48, 56
>>> parse.parse("hoge {:d}.{:f}, {:d}", s)
<Result (1024, 20.48, 56) {}>

　{:d}や{:f}がC言語でいうところのフォーマット文字列であり、scanfというかsscanfのように使うことができます。当然結果は型変換済みです。

　resultというオブジェクトが返っていますが、このオブジェクトはリストのようにインデックスでアクセスすることが可能です。

>>> result = parse.parse("hoge {:d}.{:f}, {:d}", s)
>>> result[0]
1024
>>> result[1]
20.48
>>> result[2]
56

　あるいは、結果を辞書のような形で格納することもできます。次のようにフォーマットを指定します。

>>> result = parse.parse("hoge {var1:d}.{var2:f}, {var3:d}", s)
>>> result["var1"]
1024
>>> result["var2"]
20.48
>>> result["var3"]
56

　なお、これらのリスト（厳密にはtuple）と辞書には、result.fixed, result.namedでアクセス可能です。

　parseライブラリはとても色々なことができます。より詳しく知りたい方は、parseライブラリの公式ページを読んでみてください。

GitHub - r1chardj0n3s/parse: Parse strings using a specification based on the Python format() syntax.

まとめ

　pythonにはそのままのscanfはありませんが、色々な手段で同じ目的を達することができます。最初は覚えるのが大変ですが、慣れてくると色々なことが簡単にできるのに気づいてくるはずです。Let's enjoy Python!

printf編

　兄弟記事です。よろしければこちらも御覧ください。

www.haya-programming.com

【python】pythonでprintf的なことをする

2018-04-10T15:58:11+09:00

　一年以上前にこんな記事を書きました。

　これはこれで今読み返すと面白い（香ばしい）記事ですが、真剣にpythonでprintfと同じことをしたくてアクセスしてきた人には役に立たないという問題点がありました。

　そこで、pythonでprintf的なことをする方法をまとめておきます。

概要
%演算子を使った記法
str.format()メソッド
f文字列
まとめ
scanf編

$ python

概要

　pythonでprintfのようなことをする方法は、3つあります。

%演算子を使った記法
str.format()メソッド
f文字列

　なんで3つもあるんでしょうねぇ・・・。困ったものです。

　とりあえず1つずつ説明していきます。

%演算子を使った記法

　一番昔からあり、最新のpythonでも使える方法です。なのでpythonのバージョンに依存せず使えるというメリットがあります。デメリットとしては、ちょっとわかりづらくトラブルの原因にもなること、柔軟性に劣ることが挙げられます。

　これは次のように使います。

>>> "hoge %s" % "fuga"
'hoge fuga'

　いかにもprintf的です。色々な例を示してみます。

>>> "hoge %s %s" % ("fuga", "piyo") # 複数渡すことができる
'hoge fuga piyo'
>>> "hoge %(fuga)s %(piyo)s" % {"fuga":"piyo", "piyo":"fuga"} # 辞書を使うと名前を指定して渡せる
'hoge piyo fuga'
>>> "hoge %d %03d" % (10, 20) # intもばっちり
'hoge 10 020'
>>> "hoge %.3f" % float(1/3) # floatも同様
'hoge 0.333'

　この%はあくまでも文字列オブジェクトに対する演算子操作であることに注意してください。

　こうして見るとよさそうですが、複雑なことをしようとすると色々なトラブルが起こるらしいので、近年は次に説明するformatメソッドなどを使うことが公式ドキュメントなどでも推奨されています。

　もっと詳しく知りたい方は、公式ドキュメントを参照してください。

4. 組み込み型 — Python 3.6.9 ドキュメント

str.format()メソッド

　これはpythonの文字列オブジェクトに標準で実装されているメソッドです。python2.6以上で使えます。

　使い方は簡単です。

>>> "hoge {}".format("fuga")
'hoge fuga'

　最初はprintfや上の%演算子とはフォーマットが異なるのに戸惑うでしょう。formatメソッドでは"{}"でくくられた範囲をフォーマットとして解釈します。

　formatメソッドでも上と同様のことができます。

>>> "hoge {} {}".format("fuga", "piyo") # 複数渡す
'hoge fuga piyo'
>>> "hoge {fuga} {piyo}".format(fuga="piyo", piyo="fuga") # 名前を指定
'hoge piyo fuga'
>>> "hoge {0} {0} {1}".format("fuga", "piyo") # こういうこともできる。indexを指定すると便利
'hoge fuga fuga piyo'
>>> "hoge {0:10.3f}".format(1.4) # 文字列幅と精度を指定している
'hoge      1.400'

　こちらの方が柔軟性が高いのと、メソッドなので通常のオブジェクト指向の延長上で捉えることができ、%演算子ほど場当たり的な側面がありません。なので、この方法を積極的に覚えていくことをおすすめします。

　なお、公式ドキュメントはこちらです。
組み込み型 — Python 3.7.4 ドキュメント

f文字列

　f文字列は一番新しい方法です。python3.6から導入されました。

　%演算子にしろstr.format()メソッドにしろ、ちょっと記述が冗長という欠点がありました。それを補ったのがf文字列です。これは文字列の中で直接式の値を評価し、それを文字列に変換して出力することができます。

　これを使うためには、文字列リテラルの先頭にfを付けます。

>>> f"{1+1}"
'2'

　簡潔な感じです。こういう使い方もできます。

>>> a = "hoge"
>>> f"{a}"
'hoge'

　関数だって呼び出せます。

>>> def pow2(x):
...     return x*x
... 
>>> b = 10
>>> f"{pow2(b)}"
'100'

　表示フォーマットも指定できます。formatのときと同じような書き方です。

>>> f"{1/3:.3f}"
'0.333'

　なかなか凄いですね。でも、個人的にはちょっとトリッキーすぎて使いづらい気が・・・。

　公式ドキュメントはここです。

2. 字句解析 — Python 3.6.9 ドキュメント

2019/08/22追記
　この記事を書いてから月日が過ぎ、近年は少し事情が変わってきたのかなと思うようになりました。

　なんだかんだで簡潔に書けるのがf文字列の良いところです。また、最近のPython環境は3.6以降が標準になってきたので（何かと美味しい機能が3.6以降で増えたので）、f文字列の互換性の問題もあまり気にならなくなってきました。

　今後はf文字列でいいかなという感じもします。

まとめ

　printf的なことをする3種類の方法を紹介しました。

　どの方法が良いのか？　については、

歴史的使命を終えつつある%演算子を使った記法
現役バリバリなのでおすすめのsrt.format()メソッド
まだよくわからないf文字列

　という感じで、まずはsrt.format()メソッドを使いこなせるようになることを推奨します。もちろん他の方法を使ってはいけないということではないので、少しずつ覚えていくのがおすすめです。

2019/08/22追記
　新し目のPythonしか触らないという前提であれば、f文字列から覚えてもいいと思います。記述量が減らせて楽です。

scanf編

　兄弟記事です。よろしければこちらも御覧ください。

www.haya-programming.com

【python】dictのkeyとvalueを入れ替える話色々

2018-01-29T18:30:48+09:00

　dictのkeyとvalueを入れ替えたい、誰でも一度はそう思うのではないだろうか。

　方法は何種類かある。それらについて説明する。

　あと、この話は簡単なようで実は罠の宝庫。その辺もちょっと説明しておく。

for文で書く
リスト内包表記で書く
辞書内包表記
罠の説明
- 罠1：valueがmutableだとできない（TypeError: unhashable type: ～）
- 罠2：複数のkeyが同じvalueに刺さってるとき（エラーは出ないが悲しい結果になる）
まとめ

for文で書く

　誰でも思いつく方法。

>>> d = {"a":"あ","i":"い"}
>>> result = {}
>>> for k,v in d.items():
...     result[v] = k
... 
>>> result
{'あ': 'a', 'い': 'i'}

　d.items()は次のようなものを返す。

>>> d.items()
dict_items([('a', 'あ'), ('i', 'い')])

　dict_itemsは辞書ビューオブジェクト。詳細については公式ドキュメントを確認してほしい。形としては、中のtupleのlist通りのものが返るので、forで素直に処理すれば良い。これが基本中の基本。

リスト内包表記で書く

　上でも触れたように、d.items()で辞書ビューオブジェクトが返る。

>>> d = {"a":"あ","i":"い"}
>>> d.items()
dict_items([('a', 'あ'), ('i', 'い')]) 
# こんな形 -> [('a', 'あ'), ('i', 'い')]

　実は、この形のiterableをdictのインスタンス生成時に渡してやると、ちゃんと元の辞書になる。

>>> dict(list(d.items())) # 1回リストにしてみても大丈夫！
{'a': 'あ', 'i': 'い'}

　これを応用して、次のように書くことができる。

>>> dict([(v,k) for k,v in d.items()])
{'a': 'あ', 'i': 'い'}

　まあ、単にkeyとvalueを入れ替えたいだけなら次の辞書内包表記の方が気軽だけど。この方法は2つのリストがあって、合体させて辞書にしたいみたいなとき、zipと組み合わせて使うと威力を発揮したりする。

辞書内包表記

　なんとこんな簡単に書ける。

>>> {v:k for k,v in d.items()}
{'a': 'あ', 'i': 'い'}

　辞書内包表記という。なんだか不思議だけど、こうやって書くことができる。

罠の説明

　基本的な方法は上で説明した通りなのだけど、この話にはたくさん罠があるので、それについて説明する。

罠1：valueがmutableだとできない（TypeError: unhashable type: ～）

　mutableとは値（内部状態）を変更できるオブジェクトのこと。

　普段はあまり意識しない概念だが、たとえばpython世界では数字の1はmutableではなくimmutableで、数字の1のオブジェクトを上書きしようとしても2になったり3になったりは絶対にしない。1+1という演算を行うと、新しく数字の2のオブジェクトが生成されて返される*1。

　一方、たとえばlistでは要素をappendしても同じオブジェクトのまま内部状態が上書きされて、結果的に要素が1つ増える。こういうのがmutable*2。

　immutableなオブジェクトの例を挙げると、

int
float
str
tuple

　こんな連中がそう。

　mutableなオブジェクトの例は、

list
set
dict

　大体イメージが掴めただろうか？

　さて、辞書のkeyとvalueを入れ替える話に戻る。

　結論から言うと、mutableなオブジェクトは辞書のkeyにはできない。たとえば、listをkeyに使おうとするとこんなエラーが返ってくる。

>>> {[1,2,3]:1}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

　そりゃ、辞書のキーがほいほい書き換わったら困るもんな。だけど、valueにはmutableは普通に使えるので、

>>> d = {123:[1,2,3]}
>>> {v:k for k,v in d.items()}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 1, in <dictcomp>
TypeError: unhashable type: 'list'

　こんな悲しい目に遭う。対策は適当なimmutableに変換してやること。リストならtupleにするのが良いだろう。

>>> d = {123:[1,2,3]}
>>> {tuple(v):k for k,v in d.items()}
{(1, 2, 3): 123}

　じゃあvalueもdictだったらどうしよう？　リストとstrが入り混じってたりしたら？　そんなややこしいdictのkeyとvalueを入れ替えようとするくらいなら、処理フローを抜本的に見直した方が良いだろう。絶対もっとマシな書き方がある。

罠2：複数のkeyが同じvalueに刺さってるとき（エラーは出ないが悲しい結果になる）

　さて、ここまで説明してきたような方法は、実はkeyとvalueが1対1で対応しているときしか使えない。数学用語でいう単射。

　複数のvalueが同じkeyに刺さってる場合・・・は、まあ、dictの性質上あり得ないが、複数のkeyが同じ値に刺さる場合はままある。これのkeyとvalueを入れ替えてひっくり返したからといって、dictの性質上、複数のvalueが同じkeyに刺さることはあり得ない。どうなるのか？

>>> d = {"あ":"a", "い":"i", "ア":"a", "イ":"i"}
>>> {v:k for k,v in d.items()}
{'a': 'あ', 'i': 'イ'}

　いずれかの値1つに決まる。こういうのはロジックエラーの温床になって怖いけど、辞書の仕様上仕方ない。

　ちなみにどれに決まるかは、ドキュメントでも定義されておらずランダムだと思う*3。

　これの解決方法は、どんな形で結果を得たいかによって変わってくる。普通は何らかのcollectionにvalues（入れ替える前のkeys）を格納してあげたいことが多いと思う。その場合は、こんな風に書ける。簡潔に書くためにdefaultdictを使い、default_factory（要するにデフォルト値を生成するもん）にはsetを使ってみた。一応defaultdictのドキュメントを貼っておく。

8.3. collections — コンテナデータ型 — Python 3.3.6 ドキュメント

>>> from collections import defaultdict
>>> d = {"あ":"a", "い":"i", "ア":"a", "イ":"i"}
>>> result = defaultdict(set)
>>> for k,v in d.items():
...     result[v].add(k)
... 
>>> result
defaultdict(<class 'set'>, {'a': {'ア', 'あ'}, 'i': {'い', 'イ'}})

　こればっかりは内包表記で書こうとしても上手く行かない。for文を回して愚直に付け加えていく必要がある（と思う）。

まとめ

　意外と考えることが多くて面倒くさい。安直に入れ替えようとする前に、keyとvalueを入れ替えて本当に大丈夫かどうかは良く検討する必要はある。自分で構造をよく理解していないような辞書に対してやってはいけない。

*1:実際には高速化のためにオブジェクトをキャッシュしたり、色々忙しいことをしているらしいが

*2:厳密な説明じゃないと思うが、ご了承いただきたい

*3:でも何回回しても同じ結果になるので、内部的には「順番」はあるんだと思う。たぶん最後に入ることになる値