言語処理のための Python チートシート (1) [ver.0.02]
基本
コードの基本的な体裁
# -*- coding: utf-8 -*- ソースコードの文字コードの指定
処理...
if __name__ == '__main__':
処理... # 他のスクリプトのモジュールとして読み込まれた時は実行されない
コメント、標準出力
# "#"から行末まではコメント
"""
引用符3つで囲んでもコメントにできる
(本来は複数行で文字列リテラルを記述する記法)
"""
print 'aaa' # 標準出力(改行が末尾に挿入される)
print 'aaa', # 標準出力(改行を末尾に挿入しない)
モジュールのインポート
import math # math モジュールをインポートする
math.log(10) #-> 2.302585092994046
math.tanh(0.5) #->0.46211715726000974
from math import log # math モジュールから関数 log のみをインポートする
log(10) #-> 2.302585092994046
tanh(0.5) # NameError
from math import * # [非推奨] math モジュールからすべての名前をインポートする
e #-> 2.718281828459045 (名前が衝突しやすい)
変数
some_int = 5 # intなどの型の指定は不要 (動的型付け)
a, b, c = 5, 7, 3 # 一度に複数の変数に代入
x = y = z = 0
a, b = b, a # スワップもこれでOK
type(some_int) # 変数の型が返る (この場合は<type 'int'>)
some_str = str(some_int) # 型変換 (str型の'5'が代入される)
some_int = some_int + 1 # これと
some_int += 1 # これは同じ (複合演算子による代入)
some_int++ # これはPythonではできない (Syntax Error)
データ型
よく使うもの
int |
整数 |
42, 0, -1 |
float |
浮動小数点 |
3.14, 0.0, -5.0 |
str |
文字列 |
'dog', 'd', '1' |
unicode |
ユニコード文字列 |
u'日本語', u'あ' |
list |
リスト |
[42, 'text', 'text', True] |
tuple |
タプル |
(42, 'text', 'text', True) |
set |
集合 |
{42, 'text', True} |
dict |
辞書 |
{'id': 42, 'name': 'text', 'is_student': True} |
数値
(2 + 3) * (4 - 5) #-> -5
(2.0 + 3) * (4 - 5) #-> -5.0
1 / 2 #-> 0
1 / 2.0 #-> 0.5
10 % 3 #-> 1 (割り算の余り)
2 ** 10 #-> 1024 (累乗)
文字列
基本
some_str = 'Python' # 二重引用符「"」で囲んでも同じ
some_str[0] #-> 'P'
some_str[1] #-> 'y'
some_str[-1] #-> 'n'
some_str[-2] #-> 'o'
some_str[2:4] #-> 'th'
some_str[2:] #-> 'thon'
some_str[:2] #-> 'Py'
some_str[:-2] #-> 'Pyth'
some_str[::2] #-> 'Pto'
some_str[::-1] #-> 'nohtyP'
some_str[2:99] #-> 'thon' (エラーにはならない)
len(some_str) # 6 (文字列の長さ)
'Python' + ' 2.7' #-> 'Python 2.7'
'*' * 10 #-> '**********'
ユニコード文字列の扱い
some_ja_unicode = u'いろは'
some_ja_unicode #-> u'\u3044\u308d\u306f'
some_ja_unicode[2] #-> u'\u306f' (printすると「は」)
len(some_ja_unicode) #-> 3
some_ja_ascii = 'いろは'
some_ja_ascii #-> '\xe3\x81\x84\xe3\x82\x8d\xe3\x81\xaf'
some_ja_ascii[2] #-> '\x84' (printすると「�」(文字化け))
len(some_ja_ascii) #-> 9
some_ja_ascii.decode('utf-8') #-> u'\u3044\u308d\u306f'
検索、置換
s = 'Hello, world!'
s.find(',') #-> 5
s.find('a') #-> -1
s.replace('world', 'universe') #-> 'Hello, universe!'
s.replace('Japan', 'universe') #-> 'Hello, world!'
分割、結合
tsv = '012345\tJohn\tUnited States\tMale'
tsv.split('\t') #-> ['012345', 'John', 'United States', 'Male']
word_list = ['This', 'is', 'a', 'pen']
' '.join(word_list) #-> 'This is a pen'
さまざまな操作
header = ' -*- text -*- \n'
header.strip() #-> '-*- text -*-'
header.rstrip('\n') #-> ' -*- text -*- '
header.strip('-* \n') #-> 'text'
s = 'Computer science'
s.startswith('C') #-> True
s.startswith('c') #-> False
s.endswith('e') #-> True
s.upper() #->'COMPUTER SCIENCE'
s.lower() #-> 'computer science'
フォーマット
'{} is {}'.format('Taro', 255) #-> 'Taro is 255'
'{1} is {0}'.format('Taro', 255) #-> '255 is Taro'
'{name} is {id}'.format(name='Taro', id=255) #-> 'Taro is 255'
'{:.2f}'.format(0.5) #-> '0.50'
'{:5.2f}'.format(0.5) #-> ' 0.50'
'{:.2%}'.format(0.5) #-> '50.00%'
リスト
作成、内包表記
[1, 2, 3, 4] #-> [1, 2, 3, 4]
list((1, 2, 3, 4)) #-> [1, 2, 3, 4]
list("1234") #-> ['1', '2', '3', '4']
(1, 2, 3, 4) #-> (1, 2, 3, 4)
tuple([1, 2, 3, 4]) #-> (1, 2, 3, 4)
range(5) #-> [0, 1, 2, 3, 4]
range(1,5) #-> [1, 2, 3, 4]
range(0,5,2) #-> [0, 2, 4]
l = [1, 2, 3, 4]
[x * x for x in l] #-> [1, 4, 9, 16]
[x * x for x in l if x % 2 == 0] #-> [4, 16]
[x * x if x % 2 == 0 else 0 for x in l] #-> [0, 4, 0, 16]
基本
some_list = ['a', 'b', 'c', 'd']
some_tuple = ('a', 'b', 'c', 'd')
some_list[0] #-> 'a'
some_list[-1] #-> 'd'
some_list[4] # IndexError
some_list[1:3] #-> ['b', 'c'] (cf. スライス)
len(some_list) #-> 4
[1, 2, 3] + [4, 5] #-> [1, 2, 3, 4, 5]
[1, 2, 3] * 3 #-> [1, 2, 3, 1, 2, 3, 1, 2, 3]
要素の検索
l = ['a', 'b', 'c', 'd']
'a' in l #-> True
l.index('b') #-> 1
l.index('e') # ValueError
要素の挿入、削除、逆転 (タプルでは不可)
l = ['a', 'b']
# 以下の操作はいずれも l そのものを変更する
l.append('c') # l が ['a', 'b', 'c'] に
l.extend(['d', 'e']) # l が ['a', 'b', 'c', 'd', 'e'] に
l.remove('c') # l が ['a', 'b', 'd', 'e'] に
del l[0] # l が ['b', 'd', 'e'] に
l.insert(1, 'a') # l が ['b', 'a', 'd', 'e'] に
l.reverse() # l が ['e', 'd', 'a', 'b'] に
組み込み関数いろいろ
l = [3, -1, 4, 1, -5]
sorted(l) #-> [-5, -1, 1, 3, 4]
sorted(l, reverse=True) #-> [4, 3, 1, -1, -5]
sorted(l, key=(lambda x:x**2), reverse=True) #-> [-5, 4, 3, -1, 1]
min(l) #-> -5
max(l) #-> 4
max(l, key=lambda x:x**2) #-> -5
map(lambda x:x**2, l) #-> [9, 1, 16, 1, 25] (各要素に関数を適用して返す)
filter(lambda x:x>0, l) #-> [3, 4, 1] (各要素に関数を適用し、Trueを返す値のみを返す)
reduce(lambda x,y:x-y, l) #-> 4 (先頭から要素を2つずつとってきて関数を適用することを繰り返す)
集合
作成、内包表記
{1, 2, 1, 2, 3} #-> set([1, 2, 3])
set([1, 2, 1, 2, 3]) #-> set([1, 2, 3])
set("entertainment") #-> set(['a', 'e', 'i', 'm', 'n', 'r', 't'])
l = [2, 1, 0, 1, 2]
{x**2 for x in l} #-> set([0, 1, 4])
1つの集合に対する操作
p = {'a', 'b', 'c'}
len(p) #-> 3
'a' in p #-> True
# 以下の操作はいずれも p を変更する
p.add('d') #-> set(['a', 'c', 'b', 'd'])
p.update(['b', 'd', 'e']) #-> set(['a', 'c', 'b', 'e', 'd'])
p.remove('a') #-> set(['c', 'b', 'e', 'd'])
p.remove('h') # KeyError
p.discard('h') #-> set(['c', 'b', 'e', 'd']) (削除する要素がなくてもエラーにならない)
2つの集合に対する操作 (集合演算)
a = {1, 2, 3, 4, 5}
b = {2, 4, 6, 8, 10}
a | b #-> set([1, 2, 3, 4, 5, 6, 8, 10]) (和集合)
a & b #-> set([2, 4]) (積集合)
a - b #-> set([1, 3, 5]) (差集合)
a ^ b #-> set([1, 3, 5, 6, 8, 10]) (XOR)
c = {1, 2, 3}
c < a #-> True
c <= a #-> True
a < a #-> False
辞書
作成、内包表記
{'One': 1, 'Two': 2, 'Three': 3} #-> {'Three': 3, 'Two': 2, 'One': 1}
dict(One=1, Two=2) #-> {'Two': 2, 'One': 1}
dict([('One', 1), ('Two', 2)]) #-> {'Two': 2, 'One': 1}
dict(zip(['One', 'Two'], [1, 2])) #-> {'Two': 2, 'One': 1}
l = ['Small', 'Medium', 'Large']
{word[0]: word for word in l} #-> {'S': 'Small', 'M': 'Medium', 'L': 'Large'}
要素の取得
some_dict = {'One': 1, 'Two': 2, 'Three': 3}
some_dict['One'] #-> 1
some_dict['Zero'] # KeyError
some_dict.get('One') #-> 1
some_dict.get('Zero') #-> None
some_dict.get('Zero', 0) #-> 0
some_dict.keys() #-> ['Three', 'Two', 'One']
some_dict.values() #-> [3, 2, 1]
some_dict.items() #-> [('Three', 3), ('Two', 2), ('One', 1)]
some_dict.iteritems() #-> <dictionary-itemiterator object at ...>
'One' in some_dict #-> True
1 in some_dict #-> False
1 in some_dict.values() #-> True
len(some_dict) #-> 3
要素の追加、変更、削除
d = {'One': 1, 'Two': 2, 'Three': 3}
# 以下の操作はいずれも d そのものを変更する
d['Four'] = 4 # d が {'Four': 4, 'Three': 3, 'Two': 2, 'One': 1} に
d['One'] = 1.0 # d が {'Four': 4, 'Three': 3, 'Two': 2, 'One': 1.0} に
del d['One'] # d が {'Four': 4, 'Three': 3, 'Two': 2} に
基本的な構文
if による条件分岐
if 式1:
式1 が True の時の処理...
elif 式2: # 省略可能、繰り返し可能
以前のすべての式が False で 式2 が True の時の処理...
else: # 省略可能
以前のすべての式が False の時の処理...
条件式の例
a < b
a <= b
a == b # オブジェクトの場合は「値が等しいか」
a is b # aとbが「同じオブジェクトか」
a != b
a < b < c # a < b and b < c としなくてもよい
a is None
a is not None
a in [1, 2, 4] # リストなどに要素が含まれるか
a > 0 and b > 0 # 論理積
a > 0 or b > 0 # 論理和
not a > 0 # 否定
for によるイテレーション
for x in iterable:
処理...
else: # 省略可能、ふだんは使わない
イテレートが終了したときの処理 (ただし break された時は実行されない)
iterable の例
# iterable # xに順に入る値
[1, 2, 3] # 1, 2, 3
{'a': 1, 'b': 2, 'c': 3} # 'a', 'c', 'b'
{'a': 1, 'b': 2, 'c': 3}.values() # 1, 3, 2
{'a': 1, 'b': 2, 'c': 3}.items() # ('a', 1), ('c', 3), ('b', 2) (要素の数だけメモリを確保)
{'a': 1, 'b': 2, 'c': 3}.iteritems() # ('a', 1), ('c', 3), ('b', 2) (メモリを大量に確保しない)
'Python' # 'P', 'y', 't', 'h', 'o', 'n'
u'もじれつ' # u'も', u'じ', u'れ', u'つ'
xrange(1000000) # 0, 1, 2, ..., 999999
enumerate(['a', 'b', 'c']) # (0, 'a'), (1, 'b'), (2, 'c')
while による繰り返し
while 条件式:
条件式が True のあいだ繰り返す処理
else: # 省略可能、ふだんは使わない
条件式が最初から False のときの処理
繰り返しなどで使う文
break # ループを中断する
continue # 次のイテレーションに移る
pass # 何もしない
関数定義
def some_function(arg1, arg2, arg3=default_value):
処理...
return some_value # 戻り値 (あれば)
# 以下4つの呼び出しはすべて同じ
some_function(value1, value2, value3)
some_function(arg1=value1, arg2=value2, arg3=value3)
args = (value1, value2, value3)
kwargs = {"arg1": value1, "arg2": value2, "arg3": value3}
some_function(*args)
some_function(**kwargs)
ラムダ式
L1 = lambda x:x**2.0 # 引数を2乗して返す関数
L2 = lambda seq:seq[0] # シーケンスの先頭要素を返す関数
L1(256) #-> 65536.0
L2('abc') #-> 'a'
# map や sort で使うと便利
map(lambda x:x**2, [1, 2, 3, 4]) #-> [1, 4, 9, 16]
try による例外処理
try:
例外が起こりそうな処理...
except Exception as e: # 繰り返し可能
クラス Exception の例外が起こった時の処理 (例外オブジェクトがeに入る)...
else: # 省略可能
例外が起こらなかった時の処理...
finally: # 省略可能
例外の有無にかかわらず実行する処理...
クラス定義
定義の例 (継承なし)
class Person(object):
def __init__(self, name, age, height):
self.name = name
self.age = age
self.height = height
def greet(self):
print "My name is " + self.name + "!"
定義の例 (継承あり)
class Student(Person):
def __init__(self, name, age, height, school):
Person.__init__(self, name, age, height)
self.school = school
def greet(self):
print "I'm a student of " + self.school + "!"