Pythonの基本（データ型）

● in演算子

オブジェクト内の要素に対し存在有無を判定する

hoge = [ 1, 2, 3 ]
2 in hoge ※Trueとなる

hoge = [ 1, [ 4, 5, 6 ], 3 ]
4 in hoge                                          ※Falseとなる
[ 4, 5, 6 ] in hoge                                  ※Trueとなる
4 in hoge[1]                                    ※Trueとなる

hoge = { 'a':1, 'b':2, 'c':3 }
'b' in hoge ※Trueとなる(辞書型の場合はキーを判定する)

● not in演算子

オブジェクト内の要素に対し存在有無を判定する

hoge = [ 1, 2, 3 ]
2 not in hoge ※Falseとなる

● スライス演算子

・書式 [ 開始位置 : 終了位置 : ステップ ]

hoge = [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
hoge[ 4:8 ] ※「5, 6, 7, 8」となる
hoge[-1] ※9となる

hoge[ 4:8 ] = [ 'bar' ]                                ※hogeは、「1, 2, 3, 4, 'bar', 9」となる
hoge[ : -1 ]                      ※hogeは、「12345678」となる
hoge[ : : 2 ]                      ※hogeは、「13579」となる ※第1、第2引数を省略しているので、最初から最後までの文字列で1文字飛ばし
hoge[ : : -1]                                ※hogeは、「987654321」となる ※逆に並べる事ができる
'ほげほげほげ'[0:2]                 ※'ほげ'となる
【メモ】
    スライスではないが、[]で文字の一部を抜き出せます。
    a = 'hoge'
    a[2]                                ※「g」となる。【注意】スライスと違って文字の置換はできません！

● isinstance演算子

・書式 isinstance(変数, 型)

if isinstance(obj, bool):
print('bool型です')

if isinstance(obj, int):
print('int型です')

if isinstance(obj, float):
print('float型です')

if isinstance(obj, complex):
print('complex型です')

if isinstance(obj, list):
print('list型です')

if isinstance(obj, tuple):
print('tuple型です')

if isinstance(obj, range):
print('range型です')

if isinstance(obj, str):
print('str型です')

if isinstance(obj, set):
print('set型です')

if isinstance(obj, frozenset):
print('frozenset型です')

if isinstance(obj, dict):
print('dict型です')

hoge = [ 1, 2, 3 ]
foo = tuple( hoge ) ※タプル型に変換
foo = set( hoge ) ※セット型に変換

hoge = ( 1, 2, 3 )
foo = list( hoge ) ※リスト型に変換
foo = set( hoge ) ※セット型に変換

hoge = { 1, 2, 3 }
foo = list( hoge ) ※リスト型に変換
foo = tuple( hoge ) ※タプル型に変換

hoge = { 'a':1, 'b':2, 'c':3 }
    foo = list( hoge )                                     ※リスト型に変換(キーの配列となる)
    foo = tuple( hoge )                                ※タプル型に変換(キーの配列となる)
    foo = set( hoge )                                     ※セット型に変換(キーの配列となる)

● リスト型のデータは[]の中で値をカンマ区切りで表記します。

hoge = list() ※空のリスト型を宣言

hoge = [ 1, 2, 3 ]
foo = [ 'hoge', 'foo', 'bar' ]

bar = [ 1,[ 'hoge', 'foo' ], 2 ]

bar[0] ※1となる
bar[1][0] ※hogeとなる

また、関数 len でリストの要素数を取り出せます。
>>> len(hoge) ※3となる

● 値の追加するには[append][extend]メソッドを使用する

hoge = [ 1, 2, 3 ]
hoge.append(4) ※[1, 2, 3, 4]となる
hoge.extend( [ 5, 6 ] ) ※[1, 2, 3, 4, 5, 6]となる（配列を追加する）

● 値を削除するには[remove][clear]メソッドを使用する

hoge = [ 1, 2, 3 ]
hoge.remove(1) ※[2, 3]となる
hoge.clear() ※配列を全て削除

【メモ】四則演算を使用した配列の定義は危険！

[悪い例]

arr = [[0]*3]*5
上記のarrの内容は[[0,0,0],[0,0,0],[0,0,0],[0,0,0],[0,0,0]]となる
しかし、arr[1][2] = 1 とすると以下の様に意図しない箇所まで値が代入されてしまう。

[[0,0,1],[0,0,1],[0,0,1],[0,0,1],[0,0,1]]

[良い例]

arr = [[0 for i in range(3)] for j in range(5)] ※for文を利用する
この定義の仕方で、arr[1][2] = 1 とすると以下の様に意図した通りになる

[[0,0,0],[0,0,1],[0,0,0],[0,0,0],[0,0,0]]

● タプル型のデータは()の中で値をカンマ区切りで表記します。

要素1つのタプル型を作成するには、要素の後ろにカンマを追記する
※タプル型は後から要素の追加、削除ができないので注意！

hoge = tuple() ※空のタプル型を宣言

hgoe = ( 1, 2, 3 )
foo = ( 'hoge', )

bar = ( 1, ( 'hoge', 'foo' ), 3 )

bar[0] ※1となる
bar[1][1] ※fooとなる

● セット型のデータは{}の中で値をカンマ区切りで表記します。

セット型は要素の重複ができません。

hoge = set() ※空のセット型を宣言

hoge = { 1, 2, 3 }
foo = { 'hoge', 'foo' }

bar = { 1, ( 'hoge', 'bar' ), 3 }

for i in bar:
print(i) ※要素を確認できる

● 値の追加するには[add]メソッドを使用する

hoge = { 1, 2, 3 }
hoge.add(4) ※{1, 2, 3, 4}となる

● 値を削除するには[remove][clear]メソッドを使用する

hoge = { 1, 2, 3 }
hoge.remove(1) ※{2, 3}となる
hoge.clear() ※配列を全て削除

● 集合演算

hoge = { 1, 2, 3, 4}
foo = { 4, 5, 6 }

hoge | foo                                               ※{1, 2, 3, 4, 5, 6}となる
hoge.union( foo )                                ※{1, 2, 3, 4, 5, 6}となる（上記と同じ和集合）
hoge & foo                                              ※{4}となる
hoge.intersection( foo )                    ※{4}となる(上記と同じで共通部分を取得)
hoge - foo                                               ※{1, 2, 3}となる
hoge.difference( foo )                        ※{1, 2, 3}となる(上記と同じ差集合)
foo - hoge                                               ※{5, 6}となる
foo.difference( hoge )                        ※{5, 6}となる(上記と同じ差集合)

【メモ】タプル型の様に後から値を変更できないようにするには[frozenset]を使用する

hoge = frozenset( { 1, 2, 3 } )

● セット型のデータは{}の中でキー：値をカンマ区切りで表記します。

hoge = {} ※空の辞書型を宣言
hoge = dict() ※空の辞書型を宣言（どっちでも良い）

hoge = { 'a':1, 'b':2, 'c':3 }
foo = { 1:2, 2:3, 3:4 } hoge['b'] ※2となる

hoge = { 'a':1, 'b':[ 1, 2, 3 ], 'c':3 }
hoge['b'][1] ※2となる

【メモ】

辞書のキーは動的になると困るため、リスト型ではエラーとなりますが、
タプル型は静的なので定義が可能です。
d = {(1,2):'hoge',(3,4):'foo'}

● 値の取得(キーが存在しなくてもエラーとならない)

hoge = { 'a':1, 'b':2, 'c':3 }

hoge.get( 'b' )                                ※2となる
hoge.get( 'd' )                                ※NULLとなる
hoge.get( 'd', 4 )                            ※4となる（NULLだった場合の値を第2引数に設定）
hoge.setdefault( 'd', 4 )              ※4となる（NULLだった場合の値を第2引数に設定し、さらにhoge{'d':4}を追加する）

● リスト形式で内容を取り出す

hoge = { 'a':1, 'b':2, 'c':3 }

hoge.items()
※dict_items([('a', 1), ('c', 3), ('b', 2)])
※内部的にキーと値のタプル型を組みとしたリストを生成する

l = list( hoge.items() )
※[('b', 2), ('c', 3), ('a', 1)]
※この状態でデータとして扱えます

hoge.values()
※dict_values([2, 3, 1]) 内部的に値のリストを生成する

v = list( hoge.values() )
※[2, 3, 1] この状態でデータとして扱えます

hoge.keys()
※dict_keys(['b', 'c', 'a']) 内部的にキーのリストを生成する

k = list( hoge.keys() )
※['b', 'c', 'a'] この状態でデータとして扱えます

【メモ】for文ならリスト型に変換しなくても参照できます

for k in hoge.keys(): print(k) ※キーが順に表示される

for k, v in hoge.items():
print('キーは：{0}'.format(k) + '、値は：{0}'.format(v))
※[k]にキー、[v]に値が格納される

【注意】

辞書型は登録の順番は保持されません。
順番を保持させたい場合は OrderedDict を使用します。
例）
from collections import OrderedDict
o = OrderedDict()

後は通常の辞書型として処理できます。