Python3 – lambda式

2016-06-26 / tau / コメントする

概要

ラムダ式(lambda式)は、無名の小さな関数を定義する。

print((lambda x, y: x + y)(2, 3)) # 5

1	print((lambda x, y: x + y)(2, 3)) # 5

lambda式の用法

lambda式は式として扱われるため、以下のような用い方が可能。

リストの内包表記

lst = [(lambda x: x*2), (lambda x: x*3), (lambda x: x*4)]
for func in lst:
  print(func(2))

# 実行結果
# 4
# 6
# 8

lst = [(lambda x: x*2), (lambda x: x*3), (lambda x: x*4)]

for func in lst:

print(func(2))

# 実行結果

# 4

# 6

# 8

Python3 – 関数

2016-06-26 / tau / コメントする

基本形

関数の定義は”def”で始める
関数名と引数の後にコロン”:”を置く
関数の内容にはインデントを入れて書く

def add(a, b):
  print(a + b)

add(2, 3) # 5

def add(a, b):

print(a + b)

add(2, 3) # 5

呼び出しと定義

関数の呼び出しは関数定義の後でなければならない。

add(2, 3)

def add(a, b):
    print(a + b)

# NameError: name 'add' is not defined

add(2, 3)

def add(a, b):

print(a + b)

# NameError: name 'add' is not defined

ただし、関数定義においては、後で定義される関数をそれより前の関数定義で記述することはできる。

def parent_func():
    child_func()

def child_func():
    print('hello')

parent_func()

def parent_func():

child_func()

def child_func():

print('hello')

parent_func()

戻り値

戻り値がある場合はreturn文で返す。

def add(a, b):
  return a + b

print( add(2, 3) ) # 5

def add(a, b):

return a + b

print( add(2, 3) ) # 5

複数の戻り値

複数の戻り値を返すことができる。

def multi(a, b):
  return a + b, a * 3

print(multi(2, 3)) # (5, 6)

sum, mul = multi( 2, 3 )
print(sum, mul) # 5 6

def multi(a, b):

return a + b, a * 3

print(multi(2, 3)) # (5, 6)

sum, mul = multi( 2, 3 )

print(sum, mul) # 5 6

引数

通常の引数

通常の引数に対しては、呼び出し時にその個数分の値を指定する。個数が多すぎても少なすぎてもTypeErrorとなる。

デフォルト値付きの引数

引数を省略した場合のデフォルト値を指定できる(キーワード付き引数)。

def func(x, y=2, z=3):
    print(x + y +z)


func(1)       # 6 (1 + 2 + 3)
func(1, 4)    # 8 (1 + 4 + 3)
func(1, 4, 5) # 10 (1 + 4 + 5)

def func(x, y=2, z=3):

print(x + y +z)

func(1) # 6 (1 + 2 + 3)

func(1, 4) # 8 (1 + 4 + 3)

func(1, 4, 5) # 10 (1 + 4 + 5)

可変長の引数(1)

*[引数名]は数を超えた引数をタプルで受け取る。

def func(a, *args):
    print(a)
    print(*args)
    print(args)


func(1, 2, 'A')

# 実行結果
# 1
# 2 A
# (2, 'A')

def func(a, *args):

print(a)

print(*args)

print(args)

func(1, 2, 'A')

# 実行結果

# 1

# 2 A

# (2, 'A')

可変長の引数(2)

**[引数名]はキーワード付き引数を辞書型で受け取る。

def func(a, **dict):
    print(a)
#    print(**dict) # TypeError
    print(*dict)
    print(dict)


func(1, key1='Val1', key2='Val2')

# 実行結果
# 1
# key2 key1
# {'key2': 'Val2', 'key1': 'Val1'}

def func(a, **dict):

print(a)

# print(**dict) # TypeError

print(*dict)

print(dict)

func(1, key1='Val1', key2='Val2')

# 実行結果

# 1

# key2 key1

# {'key2': 'Val2', 'key1': 'Val1'}

可変長引数の引き渡し

可変長の引数を変数で引き渡す場合、引き渡し側の引数に*、**をつける。

def func(a, *args, **dict):
    print(a)
    print(args)
    print(dict)

a = 1
args = ('A', 'B')
dict = {'key1': 'Val1', 'key2': 'Val2'}
func(a, *args, **dict)

# 実行結果
# 1
# ('A', 'B')
# {'key1': 'Val1', 'key2': 'Val2'}

def func(a, *args, **dict):

print(a)

print(args)

print(dict)

a = 1

args = ('A', 'B')

dict = {'key1': 'Val1', 'key2': 'Val2'}

func(a, *args, **dict)

# 実行結果

# 1

# ('A', 'B')

# {'key1': 'Val1', 'key2': 'Val2'}

Python3 – 同値性と同一性

2016-06-26 / tau / コメントする

同値性

同値性に関しては、数値、文字列、オブジェクトに関わらず、そのコンテンツのパターンが同じならTrueとなる。

同一性

数値の同一性

一般的な予想

数値に関しては、同値性と同一性が同じ結果になると予想される。

1 is 1     # True
1 is 2     # False
2 is (1+1) # True

1 is 1 # True

1 is 2 # False

2 is (1+1) # True

予想外

整数で一定の範囲外の場合は、同一ではない(is not)と評価される。

a = 256; b = 256; a is b # True
a = 257; b = 257; a is b # False

a = -5; b = -5; a is b # True
a = -6; b = -6; a is b # False

a = 256; b = 256; a is b # True

a = 257; b = 257; a is b # False

a = -5; b = -5; a is b # True

a = -6; b = -6; a is b # False

多重代入の場合は同一と評価されるが、変数に対して演算を施すと同一ではなくなる。

a = b = 257; a is b     # True
a *= 1; b *= 1; a is b #False
a = b = -6; a is b     # True
a *= 1; b *= 1; a is b #False

a = b = 257; a is b # True

a *= 1; b *= 1; a is b #False

a = b = -6; a is b # True

a *= 1; b *= 1; a is b #False

同一性の変化は、演算に対して可逆的。

a = b = 256; a is b # True
a += 1; b += 1; a is b # False
a -= 1; b -= 1; a is b # True

a = b = 256; a is b # True

a += 1; b += 1; a is b # False

a -= 1; b -= 1; a is b # True

文字列の同一性

'ABC' is 'ABC' # True
'ABC' is 'DEF' # False
'ABCD' is 'ABC' + 'D' # True

'ABC' is 'ABC' # True

'ABC' is 'DEF' # False

'ABCD' is 'ABC' + 'D' # True

a = 'ABCD'; b = 'ABC' + 'D'; a is b     # True
a = 'ABCD'; b = 'ABC'; b += 'D'; a is b # False

1 2	a = 'ABCD'; b = 'ABC' + 'D'; a is b # True a = 'ABCD'; b = 'ABC'; b += 'D'; a is b # False

Python3 – 変数・式・演算

2016-06-26 / tau / コメントする

変数

変数の定義

変数は定義した時点で作成される。型指定や宣言のためのキーワードはなく、変数確保のためには何らかの値で初期化する。

# print var # NameError
var = 10
print var # 10

# print var # NameError

var = 10

print var # 10

内容の書き換え

変数の内容は、異なる型のもので任意に置き換え可能。

var = 1
print( var )     # 1
var = "override"
print( var )     # override

var = 1

print( var ) # 1

var = "override"

print( var ) # override

演算子

代数演算子

加減算(+/-)、乗算は一般的だが。除算系は以下に注意。

除算系

整数同士の除算は浮動小数点数となる。Python2から扱いが変更。

6 / 3 # 2.0

1	6 / 3 # 2.0

//演算子は商が整数となる除算、%演算子は剰余を返す。

//	切り捨て除算
%	剰余

5 // 3 # 1
5 % 3  # 2

1 2	5 // 3 # 1 5 % 3 # 2

詳しくは整数除算を参照。

べき乗

2 ** 3 # 8

1	2 ** 3 # 8

ビット演算子

~a	ビット反転
a & b	AND：論理積
a \| b	OR：論理和
a ^ b	XOR：排他的論理和
a << n	nビット左シフト
a >> n	nビット右シフト

代入演算子

+=、-=、*=など。

インクリメント(++)／デクリメント(–)演算子はない。

比較演算子

同値性

==、!=、<、>、<=、>=は標準的。

同一性・包含

a is b	aとbが同一である
a is not b	aとbが同一でない
a in b	aがbに含まれる
a not in b	aがbに含まれない

比較演算子については「同値性と同一性」についても参照。

ブール演算子

a and b	aもbもTrueのときTrue、それ以外はFalse
a or b	aかbがTrueのときTrue、aもbもFalseのときFalse
not a	aの否定

条件演算(3項演算子)

以下の式は、conditionが真であればtを、偽であればfを返す。

t if condition else f

1	t if condition else f

文字列演算子

a + b	文字列aと文字列bを連結
a * n	文字列aをn回繰り返す
a[n]	n番目の文字を取り出す(0文字目からカウント)
a[n:m]	n～m-1番目までの文字列を取り出す
a[n:]	n番目以降の文字列を取り出す
a[:m]	先頭からm-1番目までの文字列を取り出す
a[n:m:s]	n～m-1番目の文字列をs個飛ばしで取り出す

Python3 – 辞書

2016-06-26 / tau / コメントする

リテラル

辞書(dictionary)の要素はキーと値のセットで保持される。辞書の要素はリストのような順序を持たない（さらに言えば、このコードを実行するごとに表示される順番が変わる）。

dct = {'John':32, 'Bill':28, 'Luice':35}
print(dct) # {'John': 32, 'Luice': 35, 'Bill': 28}

1 2	dct = {'John':32, 'Bill':28, 'Luice':35} print(dct) # {'John': 32, 'Luice': 35, 'Bill': 28}

キーや値の型は混在しても構わない。

dct = {'one':1, 2:'two', 'three': [3, 3]}
print(dct) # {'three': [3, 3], 2: 'two', 'one': 1}

1 2	dct = {'one':1, 2:'two', 'three': [3, 3]} print(dct) # {'three': [3, 3], 2: 'two', 'one': 1}

キーについて

キーに使える型は、数値、文字列、タプルなど内容を変更できない型。

alpha = {1: 'A', 2: 'B', 3: 'C'}
area = {(10, 20): 'Asia', (40, 30): 'Europe'}
print(alpha[2]) # B
print(area[(10, 20)]) # Asia

alpha = {1: 'A', 2: 'B', 3: 'C'}

area = {(10, 20): 'Asia', (40, 30): 'Europe'}

print(alpha[2]) # B

print(area[(10, 20)]) # Asia

数値や文字を格納した変数をキーに指定すると、変数の内容がキーになる。

var1 = 1
var2 = 'a'
dct = {var1:11, var2:'aa'}
print(dct) # {1: 1, 'a': 'aa'}

var1 = 1

var2 = 'a'

dct = {var1:11, var2:'aa'}

print(dct) # {1: 1, 'a': 'aa'}

既存のキーに新たな要素を定義しようとすると、[最後に指定したキー]:[値]のペアになる（1つのキーには1つの値しか格納されない）。

dct = {'A':1, 'B':2, 'B':'two'}
print(dct) # {'B': 'two', 'A': 1}
# {'A': 1, 'B': 'two'}となることもある

dct = {'A':1, 'B':2, 'B':'two'}

print(dct) # {'B': 'two', 'A': 1}

# {'A': 1, 'B': 'two'}となることもある

リストやリストを含む変数、タプルをキーに使うとTypeErrorとなる。

# 以下は全てエラー
# TypeError: unhashable type: 'list'
dct = {[1, 2]:'list'}
dct = {(0, [1, 2]): 'list'}
lst = [1, 2]
dct = {lst:'list'}

# 以下は全てエラー

# TypeError: unhashable type: 'list'

dct = {[1, 2]:'list'}

dct = {(0, [1, 2]): 'list'}

lst = [1, 2]

dct = {lst:'list'}

内容の取得

要素数

辞書が持っている要素の数はlen()関数で得られる。

dct = {'A': 'a', 'B': 'b', 'C': 'c'}
print(len(dct)) # 3

1 2	dct = {'A': 'a', 'B': 'b', 'C': 'c'} print(len(dct)) # 3

全てのキー・値・要素

辞書内の全てのキー、値、要素は、それぞれkeys()、values()、items()で取得。結果はdict_keys、dict_values、dict_itemsオブジェクトで得られ、list()関数でリスト化が可能。

dct = {'A': 'a', 'B': 'b', 'C': 'c'}

print(dct.keys())
print(dct.values())
print(dct.items())
print()
print(list(dct.keys()))
print(list(dct.values()))
print(list(dct.items()))

# dict_keys(['A', 'B', 'C'])
# dict_values(['a', 'b', 'c'])
# dict_items([('A', 'a'), ('B', 'b'), ('C', 'c')])
#
# ['A', 'B', 'C']
# ['a', 'b', 'c']
# [('A', 'a'), ('B', 'b'), ('C', 'c')]

dct = {'A': 'a', 'B': 'b', 'C': 'c'}

print(dct.keys())

print(dct.values())

print(dct.items())

print()

print(list(dct.keys()))

print(list(dct.values()))

print(list(dct.items()))

# dict_keys(['A', 'B', 'C'])

# dict_values(['a', 'b', 'c'])

# dict_items([('A', 'a'), ('B', 'b'), ('C', 'c')])

# ['A', 'B', 'C']

# ['a', 'b', 'c']

# [('A', 'a'), ('B', 'b'), ('C', 'c')]

要素の操作

要素の参照、追加

値の参照はキーを指定して行う。存在しないキーを指定して参照するとKeyError。

t = {'one': 1, 'two': 2, 'three': 3}
print(dct['two'])  # 2
print(dct['four']) # KeyError

t = {'one': 1, 'two': 2, 'three': 3}

print(dct['two']) # 2

print(dct['four']) # KeyError

要素の追加は、新たなキーを指定して値を代入。

ct = {'one':1, 'two':2}
dct['three'] = 3
print(dct) # {'two': 2, 'one': 1, 'three': 3}

ct = {'one':1, 'two':2}

dct['three'] = 3

print(dct) # {'two': 2, 'one': 1, 'three': 3}

既存のキーを指定して、その内容を更新。

dct = {'one':1, 'two':2, 'three': 3}
dct['two'] = 'second'
print(dct) # {'one': 1, 'two': 'second', 'three': 3}

dct = {'one':1, 'two':2, 'three': 3}

dct['two'] = 'second'

print(dct) # {'one': 1, 'two': 'second', 'three': 3}

要素の削除

del文/del()関数

del文/del()関数はキーを指定して要素を削除する。

dct = {'one': 1, 'two': 2, 'three': 3}
del dct['two']
del(dct['three'])
print(dct) # {'one': 1}

dct = {'one': 1, 'two': 2, 'three': 3}

del dct['two']

del(dct['three'])

print(dct) # {'one': 1}

pop()メソッド

pop()メソッドは、引数で指定した要素を削除し、そのオブジェクトを返す。第2引数を指定した場合、キーが存在しないときに第2引数を返す。

dct = {'one': 1, 'two': 2, 'three': 3}
print(dct.pop('three'))
print(dct) 
# print(dct.pop('three')) 要素が存在しないときはKeyError
print(dct.pop('three', False))

# 実行結果
# 3
# {'one': 1, 'two': 2}
# False

dct = {'one': 1, 'two': 2, 'three': 3}

print(dct.pop('three'))

print(dct)

# print(dct.pop('three')) 要素が存在しないときはKeyError

print(dct.pop('three', False))

# 実行結果

# 3

# {'one': 1, 'two': 2}

# False

`clear()メソッド`

clear()メソッドは辞書をすべてクリアする。

dct = {'one': 1, 'two': 2}
dct.clear()
print(dct) # {}

dct = {'one': 1, 'two': 2}

dct.clear()

print(dct) # {}

存在確認

キーの存在確認

辞書が指定したキーを持つかどうかをチェックするにはin演算子を使う。直接辞書に適用してもkeys()に適用しても結果は同じ。Python3ではhas_key()メソッドはなくなった。

dct = {'one': 1, 'two': 2, 'three': 3}

print('two' in dct)
print('four' in dct)
print()
print('two' in dct.keys())
print('four' in dct)

# print('two' in dct)
# print('four' in dct)
# print()
# print('two' in dct.keys())
# print('four' in dct)

dct = {'one': 1, 'two': 2, 'three': 3}

print('two' in dct)

print('four' in dct)

print()

print('two' in dct.keys())

print('four' in dct)

# print('two' in dct)

# print('four' in dct)

# print()

# print('two' in dct.keys())

# print('four' in dct)

値の存在確認

辞書が指定した値を持つかどうかは、in演算子にvalues()を適用

print('two' in dct.keys())
print('four' in dct)

# True
# False

print('two' in dct.keys())

print('four' in dct)

# True

# False

辞書オブジェクトの操作

辞書同士の連結

update()メソッドで他の辞書を連結できる。この操作は、元の辞書の内容を更新する。

this_dict = {'one': 1, 'two': 2}
other_dict = {'three': 3, 'four': 4}
this_dict.update(other_dict)
print(this_dict) # {'two': 2, 'four': 4, 'one': 1, 'three': 3}

this_dict = {'one': 1, 'two': 2}

other_dict = {'three': 3, 'four': 4}

this_dict.update(other_dict)

print(this_dict) # {'two': 2, 'four': 4, 'one': 1, 'three': 3}

ただし元の辞書と追加する辞書で重複するキーがあった場合は、追加する方の辞書の要素で上書きされる。

複数の値を持つ辞書

通常は重複したキーに値を登録すると、最後に登録した値で上書きされて1つしか残らないが、値をリストにすることで、同じキーに複数の値をもたせることができる。

dct = {}
dct['one'] = []
dct['one'].append(1)
dct['two'] = []
dct['two'].append('2')
dct['two'].append('second')

print(dct)
for itm in dct.items():
    print(itm[0], end=": ")
    for val in itm[1]:
        print(val, end=" ")
    print()

# {'one': [1], 'two': ['2', 'second']}
# one: 1
# two: 2 second

dct = {}

dct['one'] = []

dct['one'].append(1)

dct['two'] = []

dct['two'].append('2')

dct['two'].append('second')

print(dct)

for itm in dct.items():

print(itm[0], end=": ")

for val in itm[1]:

print(val, end=" ")

print()

# {'one': [1], 'two': ['2', 'second']}

# one: 1

# two: 2 second

Python3 – 内包表記

2016-06-26 / tau / コメントする

基本形

リスト／タプルからの要素の取り出し

リスト／タプルの要素を順に取り出したリストを返す。

lst = [1, 2, 3, 4]
tpl = (1, 2, 3, 4)

[n for n in lst]
[n for n in tpl]

# いずれも[1, 2, 3, 4]

lst = [1, 2, 3, 4]

tpl = (1, 2, 3, 4)

[n for n in lst]

[n for n in tpl]

# いずれも[1, 2, 3, 4]

range()を使ったリストの生成

[x for x in range(5)]
# [0, 1, 2, 3, 4]

[x for x in range(4, -5, -2)]
# [4, 2, 0, -2, -4]

[x for x in range(5)]

# [0, 1, 2, 3, 4]

[x for x in range(4, -5, -2)]

# [4, 2, 0, -2, -4]

要素の演算

要素に対して順次同じ演算を施す。

[x * x for x in range(5)]
# [0, 1, 4, 9, 16]

1 2	[x * x for x in range(5)] # [0, 1, 4, 9, 16]

floatの要素

小数部分を持った数値を要素とする方法。

# 0から始めて0.3ずつ増やして5個
[x / 10 for x in range(0, 0+3*5, 3)]
# [0.0, 0.3, 0.6, 0.9, 1.2]

# 1から3まで0.25刻み
[x / 100 for x in range(100, 301, 25)]
# [1.0, 1.25, 1.5, 1.75, 2.0, 2.25, 2.5, 2.75, 3.0]

# 0から始めて0.3ずつ増やして5個

[x / 10 for x in range(0, 0+3*5, 3)]

# [0.0, 0.3, 0.6, 0.9, 1.2]

# 1から3まで0.25刻み

[x / 100 for x in range(100, 301, 25)]

# [1.0, 1.25, 1.5, 1.75, 2.0, 2.25, 2.5, 2.75, 3.0]

ifの使用

抽出する要素の条件の指定

後置if文で要素が条件に合致した場合のみ値に送ることができる。ただしelseは使えない。

[x for x in range(10) if 3 < x < 7]
# [4, 5, 6]

1 2	[x for x in range(10) if 3 < x < 7] # [4, 5, 6]

抽出した要素の条件による値の選択

値を三項演算子にすることで、取り出された要素の条件によって値を変えることができる。

print([0 if x % 2 == 0 else 1 for x in range(10)])
# [0, 1, 0, 1, 0, 1, 0, 1, 0, 1]

1 2	print([0 if x % 2 == 0 else 1 for x in range(10)]) # [0, 1, 0, 1, 0, 1, 0, 1, 0, 1]

複数のループ

複数リストの同時ループ

複数のリストを同時に回すときは、2つの変数に対応するリストにzip()を使う。

[x + y for x, y in zip([1, 2, 3], [10, 20, 30])]
# [11, 22, 33]

1 2	[x + y for x, y in zip([1, 2, 3], [10, 20, 30])] # [11, 22, 33]

多重ループ

多重ループの以下の2つの違いを押さえておく。

まず2つのforを連続させた場合。

print([r + c for r in [10, 20, 30] for c in [1, 2, 3]])
# [11, 12, 13, 21, 22, 23, 31, 32, 33]
# 右側のループから内側で実行される

# こう考えるとわかりやすい
# 実際こう書いても結果は同じ
print([r + c
    for r in [10, 20, 30]
        for c in [1, 2, 3]])
# [11, 12, 13, 21, 22, 23, 31, 32, 33]

print([r + c for r in [10, 20, 30] for c in [1, 2, 3]])

# [11, 12, 13, 21, 22, 23, 31, 32, 33]

# 右側のループから内側で実行される

# こう考えるとわかりやすい

# 実際こう書いても結果は同じ

print([r + c

for r in [10, 20, 30]

for c in [1, 2, 3]])

# [11, 12, 13, 21, 22, 23, 31, 32, 33]

次にforを[]で囲んだ場合。

print([[r + c for r in [10, 20, 30]] for c in [1, 2, 3]])
# [[11, 21, 31], [12, 22, 32], [13, 23, 33]]

# こうすれば見やすいか？
print([
    [r + c for r in [10, 20, 30]]
    for c in [1, 2, 3]])
# [[11, 21, 31], [12, 22, 32], [13, 23, 33]]

print([[r + c for r in [10, 20, 30]] for c in [1, 2, 3]])

# [[11, 21, 31], [12, 22, 32], [13, 23, 33]]

# こうすれば見やすいか？

print([

[r + c for r in [10, 20, 30]]

for c in [1, 2, 3]])

# [[11, 21, 31], [12, 22, 32], [13, 23, 33]]

入れ子のコレクションへのアクセス

入れ子になったリストなどの要素へのアクセスは、一時変数を使って多重ループ。

[n for sublist in [[1, 2], [3, 4, 5], [6, 7]] for n in sublist]
# [1, 2, 3, 4, 5, 6, 7]

1 2	[n for sublist in [[1, 2], [3, 4, 5], [6, 7]] for n in sublist] # [1, 2, 3, 4, 5, 6, 7]

多重配列の作成

多重配列の作成は、内側の要素から考えていくとわかりやすい。

[[0 for col in range(3)] for row in range(4)]
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]

1 2	[[0 for col in range(3)] for row in range(4)] # [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]

内包表記ではないが、以下の記法でも同じ結果を得る。

[[0] * 3] * 4
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]

1 2	[[0] * 3] * 4 # [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]

応用

要素数が増減する多重配列

要素数が順次増減する配列の例。内側のリストの終値=長さを変数として、その変数を外側のループで回している。

[[n for n in range(m + 1)] for m in range(5)]
# [[0], [0, 1], [0, 1, 2], [0, 1, 2, 3], [0, 1, 2, 3, 4]]

[[n for n in range(m, -1, -1)] for m in range(4, -1, -1)]
# [[4, 3, 2, 1, 0], [3, 2, 1, 0], [2, 1, 0], [1, 0], [0]]

[[n for n in range(m + 1)] for m in range(5)]

# [[0], [0, 1], [0, 1, 2], [0, 1, 2, 3], [0, 1, 2, 3, 4]]

[[n for n in range(m, -1, -1)] for m in range(4, -1, -1)]

# [[4, 3, 2, 1, 0], [3, 2, 1, 0], [2, 1, 0], [1, 0], [0]]

2つのリストの交互結合

2つのリストの要素を交互に結合する。たとえば[1, 3, 5]と[2, 4, 6]から[1, 2, 3, 4, 5, 6]を生成。

[z for sublist in [[x, y] for x, y in zip([1, 3, 5], [2, 4, 6])] for z in sublist]
[1, 2, 3, 4, 5, 6]

1 2	[z for sublist in [[x, y] for x, y in zip([1, 3, 5], [2, 4, 6])] for z in sublist] [1, 2, 3, 4, 5, 6]

各リストから1つずつ要素を取り出し、それらを要素とするリストを作成
- [[x, y] for x, y in zip([1, 3, 5], [2, 4, 6])] ->　[[1, 2], [3, 4], [5, 6]]
その結果から各要素リストをsublistとして取り出す
各サブリストから順次要素を取り出して、全体リストの要素とする

Python3 – リストとタプル

2016-06-25 / tau / コメントする

リストとタプルの表現

[…]でリスト(list)を、(…)でタプル(tuple)を記述する。リストは要素の変更が可能だが、タプルは変更できない。

lst = [1, 2, 3]
tpl = (4, 5, 6)
print(lst) # [1, 2, 3]
print(tpl) # (4, 5, 6)

lst = [1, 2, 3]

tpl = (4, 5, 6)

print(lst) # [1, 2, 3]

print(tpl) # (4, 5, 6)

要素を改行して記述可能で、最後の要素のカンマ(,)は付けても付けなくてもよい。

a = [
    'one', 'two',
    'three', 'four',
]

print( a ) # ['one', 'two', 'three', 'four']

a = [

'one', 'two',

'three', 'four',

]

print( a ) # ['one', 'two', 'three', 'four']

型の異なる要素を混在させてよい。

lst = [1, 'two', 3]
tpl = ('one', 2, 'three')

1 2	lst = [1, 'two', 3] tpl = ('one', 2, 'three')

要素が一つだけのタプルは、要素の後にカンマ(‘)を付ける必要がある。

print((1))  # 1 => 数値
print((1,)) # (1,) => タプル

1 2	print((1)) # 1 => 数値 print((1,)) # (1,) => タプル

入れ子

リスト、タプルは入れ子にできる。リストの要素にタプルがあってもよく、その逆も可能。

lt = [1, (2, 3), 4]
tl = (1, [2, 3], 4)

1 2	lt = [1, (2, 3), 4] tl = (1, [2, 3], 4)

リストとタプルの違い

リストの要素は変更できるが、タプルの要素は変更できない。

lst = [1, 2, 3, 4]
tpl = (1, 2, 3, 4)

lst[0] = 5 # 変更可能
tpl[0] = 5 # TypeError

lst = [1, 2, 3, 4]

tpl = (1, 2, 3, 4)

lst[0] = 5 # 変更可能

tpl[0] = 5 # TypeError

ただしタプルの要素がオブジェクトの場合、オブジェクトへの参照が変わらなければ、オブジェクトの内容は変更可能。

a = (1, 2, [3, 4], 5)

a[2][1] = 0
print(a) # (1, 2, [3, 0], 5)

a[2].append(-1)
print(a) # (1, 2, [3, 0, -1], 5)

a[2] = [0, 1] # TypeError

a = (1, 2, [3, 4], 5)

a[2][1] = 0

print(a) # (1, 2, [3, 0], 5)

a[2].append(-1)

print(a) # (1, 2, [3, 0, -1], 5)

a[2] = [0, 1] # TypeError

相互変換

list()関数でタプルをリストに、tuple()関数でリストをタプルに変換可能。

print(list((1, 2, 3)))  # [1, 2, 3]
print(tuple([1, 2, 3])) # (1, 2, 3)

1 2	print(list((1, 2, 3))) # [1, 2, 3] print(tuple([1, 2, 3])) # (1, 2, 3)

共通操作

要素の個数

要素数はlen()関数で得られる。

print(len([1, 2, 3, 4])) # 4

1	print(len([1, 2, 3, 4])) # 4

要素へのアクセス

インデックスを指定してアクセスできる。最初の要素のインデックスは0となる。

a = [1, 2, 3]
print(a[0])
print(a[1])
print(a[2])

# 実行結果
# 1
# 2
# 3

a = [1, 2, 3]

print(a[0])

print(a[1])

print(a[2])

# 実行結果

# 1

# 2

# 3

インデックスに負の数を指定すると、-1を最後尾としてそこから前方へカウントする。

t = (1, 2, 3)
print(t[-1])
print(t[-2])
print(t[-3])

# 実行結果
# 3
# 2
# 1

t = (1, 2, 3)

print(t[-1])

print(t[-2])

print(t[-3])

# 実行結果

# 3

# 2

# 1

forによる順次アクセス

forで個々の要素にアクセスできる。

a = [1, 2, 3]
for n in a:
  print(n)

# 実行結果
# 1
# 2
# 3

a = [1, 2, 3]

for n in a:

print(n)

# 実行結果

# 1

# 2

# 3

結合

リスト同士、タプル同士を結合して、新たなリスト／タプルを生成できる。

print([1, 2, 3] + [4, 5, 6]) # [1, 2, 3, 4, 5, 6]
print((1, 2, 3) + (4, 5, 6)) # (1, 2, 3, 4, 5, 6)

1 2	print([1, 2, 3] + [4, 5, 6]) # [1, 2, 3, 4, 5, 6] print((1, 2, 3) + (4, 5, 6)) # (1, 2, 3, 4, 5, 6)

部分列

[n:m]でn番目からm-1番目の要素を取り出した部分列を返す
[:m]は先頭からm-1番目まで、[n:]はn番目から最後までの部分列を返す
[n:m:s]でn番目～m-1番目の要素をs個おきで返す

a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(a[2:5])   # [3, 4, 5]
print(a[:3])    # [1, 2, 3]
print(a[5:])    # [6, 7, 8, 9]
print(a[1:8:2]) # [2, 4, 6, 8]

a = [1, 2, 3, 4, 5, 6, 7, 8, 9]

print(a[2:5]) # [3, 4, 5]

print(a[:3]) # [1, 2, 3]

print(a[5:]) # [6, 7, 8, 9]

print(a[1:8:2]) # [2, 4, 6, 8]

n、mにマイナスの値を指定すると、後ろから数える。-1が最後の要素を差し、そこから前へ遡っていく。ただしmに-1を指定すると、その一つ手前の-2番目の要素までが対象となる。

a = [1, 2, 3, 4, 5]
print(a[-1])    # 5
print(a[-3:-1]) # [3, 4]

a = [1, 2, 3, 4, 5]

print(a[-1]) # 5

print(a[-3:-1]) # [3, 4]

要素の検索

in演算子: 要素がリストに含まれているかどうかを判定。
index()メソッド: 指定した要素のインデックスを返す。2番目の引数で検索を開始するインデックスを指定可能。要素が存在しない場合はValueError。

lst = ['A', 'B', 'C', 'B', 'A']
print('C' in lst) # True
print('D' in lst) # False
print(lst.index('B'))    # 1
print(lst.index('A', 1)) # 4
# print(lst.index('D'))  # ValueError
print(lst.count('A'))    # 2

lst = ['A', 'B', 'C', 'B', 'A']

print('C' in lst) # True

print('D' in lst) # False

print(lst.index('B')) # 1

print(lst.index('A', 1)) # 4

# print(lst.index('D')) # ValueError

print(lst.count('A')) # 2

リストのみの操作

以下の操作は要素の変更を伴うので、リストのみ可能。

要素の変更

単独要素の置き換えのほか、部分リストを指定した一括置換が可能。置き換えられるリストと置き換えるリストの長さが違う場合、自動的にリストの長さが変更される。

lst = ['A', 'B', 'C', 'D']
lst[2] = 'c'
print(lst)
# 添字2の要素を置き換え
# ['A', 'B', 'c', 'D']

lst[:2] = ['a', 'b']
print(lst)
# 部分リストの要素で置き換え
# ['a', 'b', 'C', 'D']

lst = ['A', 'B', 'C']
lst[1:] = ['b', 'c', 'd']
print(lst)
# リストの自動的な拡張
# ['A', 'b', 'c', 'd']

lst = ['A', 'B', 'C', 'D']
lst[:2] = 'b'
print(lst)
# リストの自動的な縮小
# ['b', 'C', 'D']

lst = ['A', 'B', 'C', 'D']

lst[2] = 'c'

print(lst)

# 添字2の要素を置き換え

# ['A', 'B', 'c', 'D']

lst[:2] = ['a', 'b']

print(lst)

# 部分リストの要素で置き換え

# ['a', 'b', 'C', 'D']

lst = ['A', 'B', 'C']

lst[1:] = ['b', 'c', 'd']

print(lst)

# リストの自動的な拡張

# ['A', 'b', 'c', 'd']

lst = ['A', 'B', 'C', 'D']

lst[:2] = 'b'

print(lst)

# リストの自動的な縮小

# ['b', 'C', 'D']

要素の追加・削除

要素の追加

append()メソッド: 引数をリストの要素として追加する。
insert()メソッド: インデックスで指定した要素の前に新たな要素を追加する。

lst = [1, 2, 3]
lst.append(4)
print(lst) # [1, 2, 3, 4]

lst = [1, 2, 3]
lst.append([4, 5, 6])
print(lst) # [1, 2, 3, [4, 5, 6]]

lst = [1, 2, 3]
lst.insert(1, 1.5)
print(lst) # [1, 1.5, 2, 3]

lst = [1, 2, 3]
lst.insert(1, [1.5, 1.6])
print(lst) # [1, [1.5, 1.6], 2, 3]

lst = [1, 2, 3]

lst.append(4)

print(lst) # [1, 2, 3, 4]

lst = [1, 2, 3]

lst.append([4, 5, 6])

print(lst) # [1, 2, 3, [4, 5, 6]]

lst = [1, 2, 3]

lst.insert(1, 1.5)

print(lst) # [1, 1.5, 2, 3]

lst = [1, 2, 3]

lst.insert(1, [1.5, 1.6])

print(lst) # [1, [1.5, 1.6], 2, 3]

要素の削除

詳細はこちら

del文: 添字を指定してリストの要素を削除する。部分リストを指定して削除することも可能。
remove()メソッド: 要素そのものを指定して削除する。同じ値の要素が複数存在する場合、最初の要素を削除する。
pop()メソッド: 指定した位置の要素を取り出して削除する。先頭要素はゼロ番目、位置指定を省略した場合は最後尾。

lst = [1, 2, 3, 4, 5]
del lst[2] # [1, 2, 4, 5]
print(lst)
del lst[1:3]
print(lst) # [1, 5]

lst = ['A', 'B', 'C', 'B', 'A']
lst.remove('B')
print(lst) # ['A', 'C', 'B', 'A']

lst = [1, 2, 3, 4]
elm = lst.pop()
print(elm, lst) # [1, 2, 3]

lst = [1, 2, 3, 4]
elm = lst.pop(2)
print(elm, lst) # [1, 2, 4]

lst = [1, 2, 3, 4, 5]

del lst[2] # [1, 2, 4, 5]

print(lst)

del lst[1:3]

print(lst) # [1, 5]

lst = ['A', 'B', 'C', 'B', 'A']

lst.remove('B')

print(lst) # ['A', 'C', 'B', 'A']

lst = [1, 2, 3, 4]

elm = lst.pop()

print(elm, lst) # [1, 2, 3]

lst = [1, 2, 3, 4]

elm = lst.pop(2)

print(elm, lst) # [1, 2, 4]

リストの拡張

extend()メソッドにより、リストに他のリストの要素を展開して追加できる。

lst = [1, 2, 3]
lst.extend([4, 5, 6])
print(lst) # [1, 2, 3, 4, 5, 6]

lst = [1, 2, 3]
lst.extend([[4, 5], [6, 7]])
print(lst) # [1, 2, 3, [4, 5], [6, 7]]

lst = [1, 2, 3]

lst.extend([4, 5, 6])

print(lst) # [1, 2, 3, 4, 5, 6]

lst = [1, 2, 3]

lst.extend([[4, 5], [6, 7]])

print(lst) # [1, 2, 3, [4, 5], [6, 7]]

内包表記

内包表記を参照。

Python3 – リテラル

2016-06-25 / tau / コメントする

数値

整数

基数

10進のほか、8進、16進、2進表記が可能。

console.log( 1234 )  # 1234
console.log( 0o77 )  # 63
console.log( 0xff )  # 255
console.log( 0b111 ) # 7

console.log( 1234 ) # 1234

console.log( 0o77 ) # 63

console.log( 0xff ) # 255

console.log( 0b111 ) # 7

console.log()→print()としても結果は同じ。

長整数

Python2では長整数L/lがあったが、Python3ではintとlongは統合され、L/lの表記は廃止された。

Python3のprint関数では表現は変わらないが、一定値を超えるとObject扱いとなり、Brysonのconsole.logではオブジェクト形式で表示される。

# console.log( 1234567890123456789L + 1 ) # SyntaxError

console.log( 9007199254740990 ) # 整数形式でそのまま表示
console.log( 9007199254740991 ) # Object形式になる
# Object {__class__: Object, value: "9007199254740991", pos: true}

# console.log( 1234567890123456789L + 1 ) # SyntaxError

console.log( 9007199254740990 ) # 整数形式でそのまま表示

console.log( 9007199254740991 ) # Object形式になる

# Object {__class__: Object, value: "9007199254740991", pos: true}

print()ではint、longとも表示は変わらないが、console.log()で長整数の場合はObject表現となる。

浮動小数点数

console.log( 1.23 )
console.log( 1.23e-2 )

1 2	console.log( 1.23 ) console.log( 1.23e-2 )

虚数・複素数

Pythonでは複素数が扱え、虚数単位は数値に続く”j”で表す。

console.log( 2j )                      # Object {__class__: Object, real: 0, imag: 2}
console.log( 2j * 2j )                 # Object {__class__: Object, real: -4, imag: 0}
console.log( ( 1 + 2j ) * ( 1 + 2j ) ) # Object {__class__: Object, real: -3, imag: 4}
# print関数で表示した場合は、2j、(-4+0j)、(-3+4j)

console.log( 2j ) # Object {__class__: Object, real: 0, imag: 2}

console.log( 2j * 2j ) # Object {__class__: Object, real: -4, imag: 0}

console.log( ( 1 + 2j ) * ( 1 + 2j ) ) # Object {__class__: Object, real: -3, imag: 4}

# print関数で表示した場合は、2j、(-4+0j)、(-3+4j)

論理値

論理値はTrue/Falseの二値。頭文字を大文字にすること(小文字の場合は未定義変数扱いになる)

console.log( True )           # true
console.log( not True )       # false
console.log( True and False ) # false
console.log( True or False )  # true

console.log( True ) # true

console.log( not True ) # false

console.log( True and False ) # false

console.log( True or False ) # true

文字列

文字列リテラルは、ダブルクォート(“)かシングルクォート(‘)で囲む。

console.log( "String can include '" )
console.log( '" can be included in String' )

1 2	console.log( "String can include '" ) console.log( '" can be included in String' )

エスケープ

バックスラッシュ(\)によって制御文字を表したり、特殊文字を通常の文字として扱える。

\n	改行
\t	タブ
\”	ダブルクォート(“)
\’	シングルクォート(‘)
\\	バックスラッシュ(\)

Python3 – 型

2016-06-25 / tau / コメントする

組み込み型

bool型(True/False)
数値型
- 整数
- 浮動小数点数
- 複素数
シーケンス型
- byte列
  - bytesとString
- 文字列(unicode)
- リスト
- タプル
マップ型
- 辞書(dictionary)
ファイルオブジェクト

JavaScript Tips – 文字列の一括置換

2016-06-22 / tau / コメントする

String.prototype.replace()

以下の例は、文字列str中の”cd”を”CD”に一括置換し、結果は”abCDefabCDefabCDef”となる。

var str = "abcdefabcdefabcdef";
var newStr = str.replace( /cd/g, "CD" );

1 2	var str = "abcdefabcdefabcdef"; var newStr = str.replace( /cd/g, "CD" );

ただしこの方法では、//の間が直接文字列と評価されてしまうので、変数の内容を引き渡すことができない。

split/join

String.prototypeで定義されたsplit()メソッドとjoin()メソッドと用いて、文字列変数で引数を与えて一括置換ができる。

split

文字列操作のsplit()メソッドは、指定した文字列を検索して、それらで区切られた文字列を配列で返す。

var str = "abcdefabcdefabcdef";
var array = str.split( "cd" );

1 2	var str = "abcdefabcdefabcdef"; var array = str.split( "cd" );

上記の結果、配列arrayは以下の要素が格納される。

[ "ab", "efab", "efab", "ef" }

1	[ "ab", "efab", "efab", "ef" }

join

文字列操作のjoin()メソッドは、配列の要素を引数の文字列で繋いだ文字列を返す。

var newStr = array.join( "CD" );

1	var newStr = array.join( "CD" );

一つ上でsplit()の結果得られた配列に上記を適用すると、結果の文字列は以下のようになる。

abCDwfabCDef

1	abCDwfabCDef

一括置換

上記のsplit()、join()の機能・戻値を考慮して、以下の用法で文字列の一括置換が可能。

var newStr = str.split( "置換対象" ).join( "置換内容" );

1	var newStr = str.split( "置換対象" ).join( "置換内容" );