コンテナ

# -*- coding: utf-8 -*-

# 特殊メソッド __getitem__ __setitem__ __delitem__
# を定義すると添字表記が出来るようになる
class A:
    def __getitem__(self, index):
        return "get item %d" % index
    def __setitem__(self, index, value):
        print "set item", index, value
    def __delitem__(self, index):
        print "del item", index

# 特殊メソッド __setslice__ __getslice__ を定義すると
# スライスが出来るようになる
class B(A):
    def __setslice__(self, i, j, sequence):
        print "set slice", i, j, sequence
    def __getslice__(self, i, j):
        return "get slice %d %d" % (i, j)

b = B()

print b[0]
b[1] = "123"
del b[2]
b[0:1] = "abc"
print b[2:4]

詳細はドキュメントで

• 3.4 特殊メソッド名
• 3.4.5 コンテナをエミュレートする
• 3.4.6 シーケンス型エミュレーションで使われるその他のメソッド
• 5.3.2 添字表記 (subscription)

文字列

# -*- coding: utf-8 -*-

# 文字列の生成
s = "abc"
s = 'abc'
s = """abc
def"""
s = '''abc
def'''

# 複数行にまたがる場合は \ (バックスラッシュ文字) を使う
# 改行は文字列の中に含まれない
s = "abc\
def"
s = ("abc"
"def")

# 接頭文字 (r, R, u, U, ur, UR, Ur, uR)
s = r"abc\ndef"  # raw文字列 (エスケープシーケンスもそのままの文字になる)
s = R"abc"
s = u"abc"  # Unicode文字列
s = U"abc"
s = ur"abc"  # Unicode & raw
s = UR"abc"
s = Ur"abc"
s = uR"abc"

# 文字列の結合 (文字列リテラルどうしなら + なしでも結合できる)
s = "abc" " def " + s + "abc" + " def"
s = "abc" * 3  # s = "abc" + "abc" + "abc" と同じ

# 文字列フォーマットの操作 (d, i, o, u, x, X, e, E, f, F, g, G, c, r, s, %)
# 結果は "abc, 123, 456.789000"
s = "%s, %d, %f" % ("abc", 123, 456.789)

# 変換フラグ文字 ("#", "0", "-", " ", "+")
# 結果は "'001', '1   ', ' 1,-1', '+1', '456.789'"
s = "'%03d', '%-4d', '% d:% d', '%+d', '%.3f'" %(1, 1, 1,-1, 1, 456.789)

# 指定した位置の文字を取得する
s = s[0]

# スライスする
s = "abcdefg0123456789"[0:10]
# s[i:j:k]: s の i 番目から j 番目まで、k 毎のスライス
s = "abcdefg"[0:7:2]  # "aceg" となる

# 文字列が存在するか調べる
b = "ac" in s
b = "ac" not in s

# 長さを取得する
i = len(s)

# 最大の要素を取得する
s = max("abcdefg")  # "g" が返される 

# 比較する
b = "abc" == "def"
i = cmp("abc", "def")

# 最小の文字を取得する
s = min("abcdefg")  # "a" が返される 

# for文で処理する
for c in s:
    print c

# 文字列型の継承
class A(str):
    pass

文字列メソッド

# 分割してリストで返す
ls = "ab cd ef".split()

# 大文字に変換した文字列を返す
s = "hello".upper()

# 小文字に変換した文字列を返す
s = "HELLO".lower()

# 前後の空白を除去した文字列を返す
s = " hello ".strip()

# 最初の文字を大文字に変換した文字列を返す
s = "hello".capitalize()

# 全てのタブ文字を空白で展開された文字列を返す
s = " hello".expandtabs(4)

# ユニコードに変換する
us = "hello".decode("utf-8")

# エンコードする
s = "hello".encode("shift-jis")

# シーケンスを結合する
s = " ".join(["hello", "world"])  # "hello world" となる

# 文字列が引数で終わっているか調べる
b = "img.jpg".endswith(".jpg")

# 引数で始まっているか調べる
b = "abcde".startswith("abc")

# 英数文字かか調べる
b = "hello123".isalnum()

# 英文字か調べる
b = "hello".isalpha()

# 数字か調べる
b = "123".isdigit()

# 小文字か調べる
b = "hello123".islower()

# 大文字か調べる
b = "HELLO123".isupper()

# 空白文字か調べる
b = "   ".isspace()

# 引数が出現する回数を返
i = "a12b12c12d12e".count("12")

# 引数の出現位置を取得する(存在しないなら -1)
i = "abcdefg".find("e")

# 置き換える
s = "a,b,c,d,e".replace(",", "1")

文字列の連結は
リストに文字列を追加し
文字列メソッドのjoinで文字列に変換する

ls = []

for i in range(100):
    ls.append(str(i))

s = "".join(ls)

詳細はドキュメントで

• 3.6 シーケンス型 str, unicode, list, tuple, buffer, xrange
• 3.6.1 文字列メソッド
• 3.6.2 文字列フォーマット操作
• 2.4.1 文字列リテラル
• 2.4.2 文字列リテラルの結合 (concatenation)
• 4.1 string -- 一般的な文字列操作
• 4.5 StringIO -- ファイルのように文字列を読み書きする
• 2.1.5 明示的な行継続
• 4.5 StringIO -- ファイルのように文字列を読み書きする
• 4.6 cStringIO -- 高速化された StringIO

ファイルの読み書きをする

組み込み関数openなどでファイルオブジェクトを生成し
readやwriteメソッドで読み書きする
with文を使用すると自動的にファイルをクローズしてくれる

# -*- coding: utf-8 -*-

# ファイルに書き込む
with open("file", "w") as f:
    f.write("ハロー")

# ユニコードの場合はエンコードしてからファイルに書き込む
with open("file", "w") as f:
    us = u"ハロー"
    f.write(us.encode("utf-8"))

# ファイルを読み込む
with open("file", "r") as f:
    print f.read()

# for文を使い１行ずつファイルを読み込む
with open("file", "r") as f:
    for line in f:
        print line

# ファイルオブジェクトを継承する
class A(file):
    pass

エンコーディングを指定してファイルの読み書きする場合は
codecsモジュールを使う

# -*- coding: utf-8 -*-

import codecs

with codecs.open("shift-jis-file", "w", "shift-jis") as f:
    f.write(u"ハロー")

with codecs.open("shift-jis-file", "r", "shift-jis") as f:
    for line in f:
        print line

バイナリデータのファイルを読み書きする場合は
arrayモジュールを使う

import array
import os.path

with open("binary-file", "wb") as f:
    a = array.array("B", [1,2,3,4,5])
    a.tofile(f)

with open("binary-file", "rb") as f:
    a = array.array("B")
    a.fromfile(f, os.path.getsize(f.name))
    print a

with文を使用するには特殊メソッド__enter__と__exit__をクラスに定義し
コンテキストマネージャ型にしなければならない

class A:
    def __enter__(self):
        print "enter"
    def __exit__(self, exc_type, exc_val, exc_tb):
        print "exit"

with A() as a:
    print "hello"

詳細はドキュメントで

• 2.1 組み込み関数
• open(filename[, mode[, bufsize]])
• 3.9 ファイルオブジェクト
• 4.8 codecs -- codec レジストリと基底クラス
• 5.6 array -- 効率のよい数値アレイ
• 3.10 コンテキストマネージャ型
• __enter__()
• __exit__(exc_type, exc_val, exc_tb)
• 3.4 特殊メソッド名

セット

# -*- coding: utf-8 -*-

# セットを生成する
st = set()
st = set([1,2,3,3])

# セットに追加する
st.add(4)

# セットの要素を削除する
st.remove(2)

# セットを結合する
st = st.union([4,5,6])

# セットの長さを取得する
length = len(st)

# セット内に要素が存在するか調べる
b = 1 in st

# セットをfor文で処理する
for v in st:
    print v

# セット型を継承する
class A(set):
    pass

詳細はドキュメントで

• 3.7 set（集合）型 -- set, frozenset
• 2.1 組み込み関数
• set([iterable])

マップ

# -*- coding: utf-8 -*-

# マップを生成する
dic = {}
dic = {"a": 1, "b": 2, "c": 3}
dic = dict()
dic = dict({"a": 1, "b": 2, "c": 3})
dic = dict(a=1, b=2, c=3)

# 要素を追加する
dic["d"] = 4

# 値を取得する
obj = dic["d"]
obj = dic.get("e", "hello")  # "d"が無い場合"hello"を返す

# popで取得する
obj = dic.pop("d")

# キーの値を更新する
dic["c"] = 30
dic.update(c=40, a=10)

# 要素を削除する
del dic["a"]

# 要素を全て削除する
dic.clear()

# キーのリストを取得する
ls = dic.keys()

# 値のリストを取得する
ls = dic.values()

# (キー,値)のタプルのリストを取得する
ls = dic.items()

# 長さを取得する
length = len(dic)

# キーが存在するか調べる
b = "d" in dic
dic.has_key("d")

# for文で処理する
for key in dic:
    print key
for value in dic.itervalues():
    print value
for key, value in dic.iteritems():
    print key, value

# マップ型を継承する
class A(dict):
    pass

詳細はドキュメントで

• 3.8 マップ型
• 2.1 組み込み関数
• map(function, list, ...)

イテレータ型

クラスに特殊メソッド__iter__とnextメソッドを定義すると
forおよびin文を使えるようになる

class A:
    i = -1
    li = [1, 2, 3]
    def __iter__(self):
        self.i = -1
        return self
    def next(self):
        try:
            self.i += 1
            return self.li[self.i]
        except:
            raise StopIteration()

a = A()

for v in a:
    print v

print 1 in a

詳細はドキュメントで

• 3.5 イテレータ型
• __iter__()
• next()
• 3.4 特殊メソッド名

リスト

# -*- coding: utf-8 -*-

# 生成する
ls = []
ls = [0] * 3
ls = [1, "abc", [1,2,3]]

# シーケンスから生成する
ls = list()
ls = list("hello") # ['h', 'e', 'l', 'l', 'o'] となる

# 数値のリストを生成する
ls = range(10)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] となる
ls = xrange(10)

# ジェネレータから生成する
ls = [i for i in range(10) if i % 2 == 0]

# 複数のイテレータ型から生成する
ls = zip(range(3), range(3, 6))  # [(0, 3), (1, 4), (2, 5)] となる

# 要素を追加する
ls.append(12)

# 指定した位置に要素を挿入する
ls.insert(0, "ab")

# 要素を入れ替える
ls[2] = "456"

# 要素を範囲で入れ替える
ls[3:5] = [7, 8, 9]

# 要素を取得する
obj = ls[0]

# スライスする
ls = ls[0:10]

# popで要素を取得する
obj = ls.pop(3)

# 最大の要素を取得する
obj = max(ls)

# 最小の要素を取得する
obj = max(ls)

# 要素を削除する
del ls[1]

# 要素を範囲で削除する
del ls[2:7]

# 引数と同じ要素を削除する
ls.remove("ab")

# 要素を全てクリアする
del ls[:]

# 結合する
ls = ls + [45, 76, 0] + ls + ["hello", "world"]

# 指定した回数リストを結合する
ls = ls * 3  # ls = ls + ls + ls と同じ

# 拡張する
ls.extend(["er", "yu", "", "bn"])

# 長さを取得する
i = len(ls)

# 引数の位置を取得する
i = ls.index("hello")

# 引数が存在する数を取得する
i = ls.count("hello")

# 要素が存在するか調べる
b = 1 in ls
b = 1 not in ls

# フィルタする
def ls_filter(obj):
    if obj:
        return obj
ls = filter(ls_filter, ls)

# ソートする
ls.sort()

# 並びを反転させる
ls.reverse()

# for文で処理する
for v in ls:
    print v

# リスト型を継承する
class A(list):
    pass

bisectモジュールを使うと順序を保ったまま
リストに要素を追加できる

# -*- coding: utf-8 -*-

import bisect
import random

ls = []

# ランダムに数値を追加する
for i in random.sample(range(100), 10):
    bisect.insort_left(ls, i)

print ls

# 実行するとキレイに並んだリストが表示される
# [15, 17, 24, 29, 36, 57, 68, 73, 79, 84]

詳細はドキュメントで

• 3.6 シーケンス型 str, unicode, list, tuple, buffer, xrange
• 3.6.4 変更可能なシーケンス型
• 2.1 組み込み関数
• len(s)
• list([sequence])
• filter(function, list)
• max(s[, args...][key])
• min(s[, args...][key])
• range([start,] stop[, step])
• xrange([start,] stop[, step])
• zip([iterable, ...])
• 5.5 bisect -- 配列二分法アルゴリズム