Python3 – 正規表現 – モジュール関数

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

概要

reモジュールの関数は、パターンと文字列を直接指定してマッチングなどの操作を行う。

引数の中のflagsについては、reモジュールで定義された定数を指定する。複数のflagsを指定する場合は、ビットごとのOR('|'演算子)を使って組み合わせる。

パターンは実行に先立ってコンパイルされるので、同じパターンを複数回用いる場合には、re.compile()関数でパターンをコンパイルし、コンパイルされたRegexObjectオブジェクトのメソッドを用いる方がよい。

正規表現のコンパイル

compile()

re.compile(pattern, flags=0)

正規表現パターンを正規表現オブジェクトにコンパイルする。正規表現オブジェクトのメソッド群で、以下のモジュール関数と同等の操作を行うことができる。

以下のモジュール関数を使う場合はflagsを関数ごとに指定するが、正規表現オブジェクトを使う場合は、compile()関数の引数でflagsを指定する。

パターンの検索

search()

re.search(pattern, string, flags=0)

stringの任意の位置で、最初にpatternにマッチした時にMatchObjectのオブジェクトを返す。マッチしなければNoneを返す。

import re
s = r"abcdabcd"
print(re.search(r'ab', s))
# <_sre.SRE_Match object; span=(0, 2), match='ab'>
print(re.search(r'cd', s))
# <_sre.SRE_Match object; span=(2, 4), match='cd'>
print(re.search(r'ef', s))
# None

import re

s = r"abcdabcd"

print(re.search(r'ab', s))

# <_sre.SRE_Match object; span=(0, 2), match='ab'>

print(re.search(r'cd', s))

# <_sre.SRE_Match object; span=(2, 4), match='cd'>

print(re.search(r'ef', s))

# None

match()

re.match(pattern, string, flags=0)

stringの先頭でpatternにマッチすればMatchObjectのオブジェクトを返す。マッチしなければNoneを返す。stringの途中ではマッチしない。

import re
s = r"abcdabcd"
print(re.match(r'ab', s))
# <_sre.SRE_Match object; span=(0, 2), match='ab'>
print(re.match(r'cd', s))
# None

import re

s = r"abcdabcd"

print(re.match(r'ab', s))

# <_sre.SRE_Match object; span=(0, 2), match='ab'>

print(re.match(r'cd', s))

# None

fullmatch()

re.fullmatch(pattern, string, flags=0)

patternがstring全体にマッチしたときだけMatcObjectのオブジェクトを返し、それ以外はNoneを返す。

import re
s = r"abcdabcd"
print(re.fullmatch(r'abcdabcd', s))
# <_sre.SRE_Match object; span=(0, 8), match='abcdabcd'>
print(re.fullmatch(r'abcd', s))
# None
print(re.fullmatch(r'.*', s))
# <_sre.SRE_Match object; span=(0, 8), match='abcdabcd'>
print(re.fullmatch(r'.{5}', s))
# None

import re

s = r"abcdabcd"

print(re.fullmatch(r'abcdabcd', s))

# <_sre.SRE_Match object; span=(0, 8), match='abcdabcd'>

print(re.fullmatch(r'abcd', s))

# None

print(re.fullmatch(r'.*', s))

# <_sre.SRE_Match object; span=(0, 8), match='abcdabcd'>

print(re.fullmatch(r'.{5}', s))

# None

findall()

re.findall(pattern, string, flags=0)

string中でpatternにマッチする全ての部分文字列を要素とするリストを返す。マッチする部分がなければ空のリスト([])を返す。先頭からマッチした部分を取り除きながらサーチしていく。

import re
s = r"abcdabcd"
print(re.findall(r'ab', s))
# ['ab', 'ab']
print(re.findall(r'ef', s))
# []
print(re.findall(r'.{3}', s))
# ['abc', 'dab']

import re

s = r"abcdabcd"

print(re.findall(r'ab', s))

# ['ab', 'ab']

print(re.findall(r'ef', s))

# []

print(re.findall(r'.{3}', s))

# ['abc', 'dab']

finditer()

re.finditer(pattern, string, flags=0)

string中でpatternにマッチした結果のMatchObjectオブジェクトのイテレータを返す。マッチする部分がなければ空のイテレータを返す。先頭からマッチした部分を取り除きながらサーチしていく。

import re
s = r"abcdabcd"
[print(x) for x in re.finditer(r'ab', s)]
# <_sre.SRE_Match object; span=(0, 2), match='ab'>
# <_sre.SRE_Match object; span=(4, 6), match='ab'>
[print(x) for x in re.finditer(r'ef', s)]
# 空のイテレータ
[print(x) for x in re.finditer(r'.{3}', s)]
# <_sre.SRE_Match object; span=(0, 3), match='abc'>
# <_sre.SRE_Match object; span=(3, 6), match='dab'>

import re

s = r"abcdabcd"

[print(x) for x in re.finditer(r'ab', s)]

# <_sre.SRE_Match object; span=(0, 2), match='ab'>

# <_sre.SRE_Match object; span=(4, 6), match='ab'>

[print(x) for x in re.finditer(r'ef', s)]

# 空のイテレータ

[print(x) for x in re.finditer(r'.{3}', s)]

# <_sre.SRE_Match object; span=(0, 3), match='abc'>

# <_sre.SRE_Match object; span=(3, 6), match='dab'>

分割

split()

re.split(pattern, string, maxsplit=0, flags=0)

stringをすべてのpatternにマッチする部分で分割し、それらを要素とするリストを返す。patternにマッチする部分は除かれる。マッチする部分がなければ、stringを1つの要素とするリストが返される。

maxsplitに1以上の数nを指定すると、先頭から最大n個の分割が発生し、残りはリストの最後の要素となる。

import re
s =r"she sells sea shells by the seashore"
print(re.split(r' ', s))
# ['she', 'sells', 'sea', 'shells', 'by', 'the', 'seashore']
print(re.split(r'se', s))
# ['she ', 'lls ', 'a shells by the ', 'ashore']
print(re.split(r'xyz', s))
# ['she sells sea shells by the seashore']
print(re.split(r' ', s, maxsplit=3))
# ['she', 'sells', 'sea', 'shells by the seashore']
print(re.split(r' ', s, maxsplit=10))
# ['she', 'sells', 'sea', 'shells', 'by', 'the', 'seashore']

import re

s =r"she sells sea shells by the seashore"

print(re.split(r' ', s))

# ['she', 'sells', 'sea', 'shells', 'by', 'the', 'seashore']

print(re.split(r'se', s))

# ['she ', 'lls ', 'a shells by the ', 'ashore']

print(re.split(r'xyz', s))

# ['she sells sea shells by the seashore']

print(re.split(r' ', s, maxsplit=3))

# ['she', 'sells', 'sea', 'shells by the seashore']

print(re.split(r' ', s, maxsplit=10))

# ['she', 'sells', 'sea', 'shells', 'by', 'the', 'seashore']

patternが先頭の部分に一致する場合は、リストの最初は空文字列から始まり、最後の部分に一致する場合はリストの最終要素が空文字列になる。

import re
s = "abracadabra"
print(re.split(r'ab', s))
# ['', 'racad', 'ra']
print(re.split(r'ra', s))
# ['ab', 'cadab', '']

import re

s = "abracadabra"

print(re.split(r'ab', s))

# ['', 'racad', 'ra']

print(re.split(r'ra', s))

# ['ab', 'cadab', '']

空文字列('')では分割されない。patternとして空文字1文字を指定するとエラー。

置換

sub()

re.sub(pattern, repl, string, count=0, flags=0)

string中でpatternにマッチする部分文字列をreplの文字列で置換する。countで正の整数値を指定すると、先頭から最大その回数だけ置換を行う。

import re
s = "she sells sea shells by the seashore"
print(re.sub(r'sh', "++", s))
# ++e sells sea ++ells by the sea++ore
print(re.sub(r'sh', "++", s, count=2))
# ++e sells sea ++ells by the seashore

import re

s = "she sells sea shells by the seashore"

print(re.sub(r'sh', "++", s))

# ++e sells sea ++ells by the sea++ore

print(re.sub(r'sh', "++", s, count=2))

# ++e sells sea ++ells by the seashore

空文字列とのマッチは、前のマッチの直後以外に置換される。

import re
print(re.sub(r'x*', '-', "abcde"))
# -a-b-c-d-e-

import re

print(re.sub(r'x*', '-', "abcde"))

# -a-b-c-d-e-

replには文字列を返す関数を指定できる。

import re

def repl_func(matchobj):
    if matchobj.group(0).isalpha():
        return 'A'
    else:
        return '0'

print(re.sub(r'[A-Z0-9]', repl_func, "TK-80-BS"))
# AA-00-AA

import re

def repl_func(matchobj):

if matchobj.group(0).isalpha():

return 'A'

else:

return '0'

print(re.sub(r'[A-Z0-9]', repl_func, "TK-80-BS"))

# AA-00-AA

subn()

re.subn(pattern, repl, string, count=0, fkags=0)

sub()と同じ操作を行うが、タプルで(置換後の文字列, 置換数)を返す。

import re
s = "she sells sea shells by the seashore"
print(re.subn(r'sh', "++", s))
# ('++e sells sea ++ells by the sea++ore', 3)
print(re.subn(r'sh', "++", s, count=2))
# ('++e sells sea ++ells by the seashore', 2)

import re

s = "she sells sea shells by the seashore"

print(re.subn(r'sh', "++", s))

# ('++e sells sea ++ells by the sea++ore', 3)

print(re.subn(r'sh', "++", s, count=2))

# ('++e sells sea ++ells by the seashore', 2)

Python3 – エスケープシーケンス

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

Pythonのエスケープシーケンス一覧

\\	バックスラッシュ(`'\'`)
`\'`	シングルクォーテーション(`"'"`)
`\"`	ダブルクォーテーション(`'"'`)
`\a`	ベル
`\b`	バックスペース
`\f`	改ページ
`\r`	キャリッジリターン
`\n`	改行
`\t`	水平タブ
`\v`	垂直タブ
`￥N{name}`	Unicodeデータベース中で名前`name`を持つ文字
`\uxxxx`	16ビットの16進数`xxxx`を持つUnicode文字
`\Uxxxxxxxx`	32ビットの16進数`xxxxxxxx`を持つUnicode文字
`\ooo`	8進数oooを持つASCII文字
`\xhh`	16進数hhを持つASCII文字
`\0`	NULL
`\+改行`	改行の直前(文末)が\の場合は次の行が継続

Python3 – 正規表現

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

Pythonでの正規表現の扱い

Pythonでは、パターン・マッチングを以下のいずれかの方法で行い、その結果をMatchObjectオブジェクトとして返す。

パターンと文字列を指定して、reモジュールで定義された関数を実行する
パターン文字列を正規表現オブジェクトとしてコンパイルしておき、そのメソッドで文字列を指定して実行する

reモジュール関数を使う方法

モジュール関数で実行する例は次の通り。実行結果はMatchObjectのオブジェクトとして返されるが、その文字列表現のspanのところに4文字目～8-1文字目でヒットしたことが記録されている。

import re

s = "The rain in Spain stays mainly in the plain."

print(re.search(r"rain", s))

# <_sre.SRE_Match object; span=(4, 8), match='rain'>
# マッチオブジェクトが返される

import re

s = "The rain in Spain stays mainly in the plain."

print(re.search(r"rain", s))

# <_sre.SRE_Match object; span=(4, 8), match='rain'>

# マッチオブジェクトが返される

パターン文字列を正規表現オブジェクトにコンパイルする方法

正規表現オブジェクトにコンパイルして検索する方法は次の通り。検索結果は先と同じMatchObjectオブジェクト。

import re

s = "The rain in Spain stays mainly in the plain."

ptnobj = re.compile(r"rain")
print(ptnobj)
print(ptnobj.search(s))

# re.compile('rain')
# <_sre.SRE_Match object; span=(4, 8), match='rain'>

import re

s = "The rain in Spain stays mainly in the plain."

ptnobj = re.compile(r"rain")

print(ptnobj)

print(ptnobj.search(s))

# re.compile('rain')

# <_sre.SRE_Match object; span=(4, 8), match='rain'>

Python3 – 文字列とコレクション

2016-10-02 / tau / コメントする

リストと文字列

list()関数で文字列をリストに分解し、join()メソッドで区切り文字を''(空文字)で指定してリストを文字列に結合。

s = "Python"

l = list(s)
print(l)
# ['P', 'y', 't', 'h', 'o', 'n']

s = "".join(l)
print(s)
# Python

s = "Python"

l = list(s)

print(l)

# ['P', 'y', 't', 'h', 'o', 'n']

s = "".join(l)

print(s)

# Python

数値要素のリストを文字列要素のリストにするには、map()関数でstr()関数を適用する。

number_list = [0, 1, 2, 3]
print(list(map(str, number_list)))
# ['0', '1', '2', '3']

number_list = [0, 1, 2, 3]

print(list(map(str, number_list)))

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

ただしmap()関数はいろいろと注意が必要。

setと文字列

set()で文字列の重複した文字を集約したセットが得られる。文字列の順番は固定されず、実行ごとにも異なる。

s = "abcabcabc"
print(set(s))
# {'b', 'a', 'c'}

s = "abcabcabc"

print(set(s))

# {'b', 'a', 'c'}

Python3 – 文字列

2016-09-30 / tau / コメントする

内容の取得

文字列長

文字列長はlen()関数で得られる。

one = "first"
two = "second"
print(len(one), len(two))
# 5 6

one = "first"

two = "second"

print(len(one), len(two))

# 5 6

一文字取得

配列のように文字列中の位置を指定して、一文字取得する。開始位置は0。-1で最後の文字を指定でき、そこから順に-2、-3と先頭に向けて遡る。

s = "ABCD"
print(s[0], s[1], s[2])
# A B C
print(s[-1], s[-2], s[-3])
# D C B

s = "ABCD"

print(s[0], s[1], s[2])

# A B C

print(s[-1], s[-2], s[-3])

# D C B

イテレータ、リストによる連続取得

文字列はイテレータ。

st = "Python"
for chr in st:
    print(chr, end=' ')
# P y t h o n

st = "Python"

for chr in st:

print(chr, end=' ')

# P y t h o n

list()関数で一文字ずつのリストが得られる。

st = "Python"
print(list(st))
# ['P', 'y', 't', 'h', 'o', 'n']

st = "Python"

print(list(st))

# ['P', 'y', 't', 'h', 'o', 'n']

文字の出現回数

count(sub[, start[, end]])は元の文字列の中の部分文字列subの出現回数を返す。start、endはオプションで指定可能。

s = "aababcabcd"

print(s.count('a'))
# 4

print(s.count("ab"))
# 3

print(s.count('b', 1))
# 3

print(s.count('b', 1, 6))
# 2

s = "aababcabcd"

print(s.count('a'))

# 4

print(s.count("ab"))

# 3

print(s.count('b', 1))

# 3

print(s.count('b', 1, 6))

# 2

部分文字列の取得(スライス)

以下の記法で部分文字列を取り出せる。ただし取り出される最後の文字列は終了位置-1番目の文字。

[開始位置:終了位置:ステップ値]

1	[開始位置:終了位置:ステップ値]

具体例は以下の通り。

st = "0123456789"

print(st[:])
# 0123456789
# 全部省略した場合は文字列全体

print(st[6:])
# 6789
# 開始位置から最後まで

print(st[:4])
# 0123
# 先頭から指定位置まで(最後の文字は[指定位置-1]文字目

print(st[3:7])
# 3456
# 3文字目から6文字目まで

print(st[-5:-1])
# 5678
# インデックスに負数も使えるが、開始位置:終了位置に注意

print(st[1:8:2])
# 1357
# 1文字目から8文字目まで2文字ステップで

print(st[3:3])
print(st[5:2])
# どちらも""(空行)
# 開始位置 < 終了位置でないといけない

st = "0123456789"

print(st[:])

# 0123456789

# 全部省略した場合は文字列全体

print(st[6:])

# 6789

# 開始位置から最後まで

print(st[:4])

# 0123

# 先頭から指定位置まで(最後の文字は[指定位置-1]文字目

print(st[3:7])

# 3456

# 3文字目から6文字目まで

print(st[-5:-1])

# 5678

# インデックスに負数も使えるが、開始位置:終了位置に注意

print(st[1:8:2])

# 1357

# 1文字目から8文字目まで2文字ステップで

print(st[3:3])

print(st[5:2])

# どちらも""(空行)

# 開始位置 < 終了位置でないといけない

正のステップ値の場合は検索方向が左→右なので以下の関係でなければならない。

[開始位置:終了位置] -> 開始位置 < 終了位置

1	[開始位置:終了位置] -> 開始位置 < 終了位置

負のステップ値を使うと、最後尾から先頭へ向かって文字を取り出す。特にステップ値を-1とすると、1文字ずつ前へ向かって取り出すので、文字列の反転に便利。ただし開始位置と終了位置に注意が必要。

st = "0123456789"

print(st[::-2])
# 97531
# 全ての文字列に対して最後尾から1文字おきに取り出す

print(st[::-1])
# 9876543210
# ステップ値を-1とすると逆向きに1文字ずつ取り出す

print(st[7:3:-1])
print(st[-3:-7:-1])
# どちらも7654
# 部分文字列の指定は、後方の開始値:前方の終了値の順で
# 位置指定には負の値も使える

print(st[3:7:-1])
# ''(空行)
# 逆順検索の場合は開始位置 > 終了位置でなければならない

print(st[9:0:-1])
print(st[9:-1:-1])
# 987654321
# ''（空行） -> -1が最後尾の文字となって検索方向に合わないため
# 先頭の文字が取り出せない

print(st[-1:-11:-1])
# 9876543210
# これでok

st = "0123456789"

print(st[::-2])

# 97531

# 全ての文字列に対して最後尾から1文字おきに取り出す

print(st[::-1])

# 9876543210

# ステップ値を-1とすると逆向きに1文字ずつ取り出す

print(st[7:3:-1])

print(st[-3:-7:-1])

# どちらも7654

# 部分文字列の指定は、後方の開始値:前方の終了値の順で

# 位置指定には負の値も使える

print(st[3:7:-1])

# ''(空行)

# 逆順検索の場合は開始位置 > 終了位置でなければならない

print(st[9:0:-1])

print(st[9:-1:-1])

# 987654321

# ''（空行） -> -1が最後尾の文字となって検索方向に合わないため

# 先頭の文字が取り出せない

print(st[-1:-11:-1])

# 9876543210

# これでok

負のステップ値の場合には検索方向が右→左になるので、以下の関係でなければならない。

[開始位置:終了位置] -> 開始位置 > 終了位置

1	[開始位置:終了位置] -> 開始位置 > 終了位置

n文字目からm文字取得したい時。

s = "123456789"
n = 1
m = 3
print(s[n-1:n-1+m])
# 123

s = "123456789"

n = 1

m = 3

print(s[n-1:n-1+m])

# 123

スライスとfinde/rfindでは開始位置・終了位置の指定の考え方が違ってくる。

特定文字での分割

split()メソッドは、指定した文字列で元の文字列を分解し、リストで返す。

s = "Bibbidi--Bobbidi--Boo"

print(s.split("--"))
# ['Bibbidi', 'Bobbidi', 'Boo']

s = "Bibbidi--Bobbidi--Boo"

print(s.split("--"))

# ['Bibbidi', 'Bobbidi', 'Boo']

partition()メソッドは指定文字の最初の出現位置で文字列を分割し、タプルで結果を返す。

s = "Bibbidi--Bobbidi--Boo"

print(s.partition("--"))
# ('Bibbidi', '--', 'Bobbidi--Boo')
# 戻り値はタプル

print(s.partition("$$"))
# ('Bibbidi--Bobbidi--Boo', '', '')
# 区切り文字が見つからない場合の戻り値

s = "Bibbidi--Bobbidi--Boo"

print(s.partition("--"))

# ('Bibbidi', '--', 'Bobbidi--Boo')

# 戻り値はタプル

print(s.partition("$$"))

# ('Bibbidi--Bobbidi--Boo', '', '')

# 区切り文字が見つからない場合の戻り値

内容の判定

stringオブジェクトの以下のメソッドは、それぞれの条件に合致した場合にTrueを返す。空文字列に対しては全てFalseを返す。

isalpha()

全ての文字がアルファベットの場合にTrue。

>>> print("aA".isalpha())
True
>>> print("a0".isalpha())
False

>>> print("aA".isalpha())

True

>>> print("a0".isalpha())

False

isdigit()

全ての文字が数字の場合にTrue。

>>> print("00".isdigit())
True
>>> print("0a".isdigit())
False

>>> print("00".isdigit())

True

>>> print("0a".isdigit())

False

isalnum()

全ての文字がアルファベットか数字の場合にTrue。

>>> print("0aA".isalnum())
True
>>> print("0a+".isalnum())
False

>>> print("0aA".isalnum())

True

>>> print("0a+".isalnum())

False

islower()

文字列中のアルファベットが全て小文字の場合にTrue。アルファベット以外の数字や記号が含まれていても判定対象外で無視されるが、アルファベットがまったく含まれていないとFalse。

>>> print("ab".islower())
True
>>> print("aA".islower())
False
>>> print("a0+".islower())
True
>>> print("00".islower())
False

>>> print("ab".islower())

True

>>> print("aA".islower())

False

>>> print("a0+".islower())

True

>>> print("00".islower())

False

isupper()

文字列中のアルファベットが全て大文字の場合にTrue。アルファベット以外の数字や記号が含まれていても判定対象外。アルファベット以外の数字や記号が含まれていても判定対象外で無視されるが、アルファベットがまったく含まれていないとFalse。

>>> print("AB".isupper())
True
>>> print("Ab".isupper())
False
>>> print("A0+".isupper())
True
>>> print("00".isupper())
False

>>> print("AB".isupper())

True

>>> print("Ab".isupper())

False

>>> print("A0+".isupper())

True

>>> print("00".isupper())

False

isspace()

全ての文字がスペースの場合にTrue。

>>> print("  ".isspace())
True
>>> print(" a".isspace())
False

>>> print(" ".isspace())

True

>>> print(" a".isspace())

False

istitle()

文字列中の区切られた部分文字列がタイトルケースの場合にTrue。

>>> print("Chapter 1 - Firstcontact".istitle())
True
>>> print("Chapter 1 - firstcontact".istitle())
False
>>> print("Chapter 1 - FirstContact".istitle())
False

>>> print("Chapter 1 - Firstcontact".istitle())

True

>>> print("Chapter 1 - firstcontact".istitle())

False

>>> print("Chapter 1 - FirstContact".istitle())

False

検索

find/rfind

find()は指定した文字列を検索し、そのインデックスを返す。存在しない場合は-1が返される。検索範囲の指定はスライスと同じで[開始位置, 終了位置)。

index()も同じ使い方ができるが、存在しない場合にValueError: substring not foundが返される。

st = "abcdeabcde"

print(st.find("cd"))
# 2
# findは先頭に近いインデックスが返される

print(st.find("xy"))
# -1
# 見つからなかった場合は-1

print(st.find("cd", 3))
# 7
# 開始位置以降で最も早く合致したもの

print(st.find('c', 2, 8))
# 2
# 開始位置と終了位置の指定はスライスと同じ

st = "abcdeabcde"

print(st.find("cd"))

# 2

# findは先頭に近いインデックスが返される

print(st.find("xy"))

# -1

# 見つからなかった場合は-1

print(st.find("cd", 3))

# 7

# 開始位置以降で最も早く合致したもの

print(st.find('c', 2, 8))

# 2

# 開始位置と終了位置の指定はスライスと同じ

rfind()は文字列の後方から検索する。開始位置と終了位置の意味はスライスと同じだが、開始位置だけ指定すると、そこから文字列の後方が検索範囲となってしまう点に注意。

print(st.rfind("cd"))
# 7
# rfindは後端に近いインデックスが返される

print(st.rfind("xy"))
# -1
# 見つからなかった場合は-1

[print(st.rfind('c', i), end=' ') for i in range(len(st))]
# 7 7 7 7 7 7 7 7 -1 -1
# 開始位置は
print()

print(st.rfind('c', 1, 5))
# 2

print(st.rfind("cd"))

# 7

# rfindは後端に近いインデックスが返される

print(st.rfind("xy"))

# -1

# 見つからなかった場合は-1

[print(st.rfind('c', i), end=' ') for i in range(len(st))]

# 7 7 7 7 7 7 7 7 -1 -1

# 開始位置は

print()

print(st.rfind('c', 1, 5))

# 2

find/rfindとスライスでの範囲指定が違ってくる点に注意。

内容の変更

連結

+演算子で文字列を連結できる。

a = "My"
b = " Fair"
c = " Lady"
print(a + b + c)

# My Fair Lady

a = "My"

b = " Fair"

c = " Lady"

print(a + b + c)

# My Fair Lady

join()メソッドで、元の文字列オブジェクトを区切り文字にして、引数リストの各文字列要素を連結できる。

lyric = ["The", "Rain", "in", "Spain"]
print("--".join(lyric))

# The--Rain--in--Spain

lyric = ["The", "Rain", "in", "Spain"]

print("--".join(lyric))

# The--Rain--in--Spain

数値と文字列を連結する場合、Pythonでは自動変換されない。str()関数で明示的に文字列に変換する必要がある。

print("Python" + 3)
# TypeError: Can't convert 'int' object to str implicitly

print("Python" + str(3))
# Python3

print("Python" + 3)

# TypeError: Can't convert 'int' object to str implicitly

print("Python" + str(3))

# Python3

join()の方が推奨されているらしい。

split = '-'
lst = ["Bibbidi", "Bobbidi", "Boo"]
print(split.join(lst))

# Bibbidi-Bobbidi-Boo

split = '-'

lst = ["Bibbidi", "Bobbidi", "Boo"]

print(split.join(lst))

# Bibbidi-Bobbidi-Boo

繰り返し

*演算子で同じ文字列を複数回繰り返した文字列を得られる。

shout = "Wow"
print(shout * 4)

# WowWowWowWow

shout = "Wow"

print(shout * 4)

# WowWowWowWow

置き換え

replace(old, new[, count)メソッドは、部分文字列oldをnewで置き換える。countが指定されると、先頭からその個数分だけ置き換える。

置き換え前後の部分文字列の長さが違ってもよい。置き換え後に空文字列を指定すると、文字列の削除に使える。

replace()のほか、sub()関数(reパッケージ)、str.translate()関数も使える。

s = "abcdabcdabcdabcd"

print(s.replace("bc", "BC"))
# aBCdaBCdaBCdaBCd

print(s.replace("bc", "BC", 2))
# aBCdaBCdabcdabcd
# 先頭から2個のみ置き換え

print(s.replace("cd", "CDE"))
# abCDEabCDEabCDEabCDE
# 置き換え前後の部分文字列の長さが違ってもよい

print(s.replace('d', ''))
# abcabcabcabc
# 文字(列)削除に使う

s = "abcdabcdabcdabcd"

print(s.replace("bc", "BC"))

# aBCdaBCdaBCdaBCd

print(s.replace("bc", "BC", 2))

# aBCdaBCdabcdabcd

# 先頭から2個のみ置き換え

print(s.replace("cd", "CDE"))

# abCDEabCDEabCDEabCDE

# 置き換え前後の部分文字列の長さが違ってもよい

print(s.replace('d', ''))

# abcabcabcabc

# 文字(列)削除に使う

なお、部分文字列をスライスで取得した書式を使って文字列を代入することはできず、エラーとなる。

s = "0123456789"

s[3] = 'T'
# Traceback (most recent call last):
#  File "test.py", line 3, in <module>
#     s[3] = 'T'
# TypeError: 'str' object does not support item assignment

s = "0123456789"

s[3] = 'T'

# Traceback (most recent call last):

# File "test.py", line 3, in <module>

# s[3] = 'T'

# TypeError: 'str' object does not support item assignment

書式・整形

センタリング・左寄せ・右寄せ

center()、ljust()、rjust()の各メソッドで、元の文字列を指定した幅の中でセンタリング・左寄せ・右寄せできる。デフォルトでは空いた場所がスペース(‘ ‘)で埋められるが、その文字を指定することが可能。

s = "***"
print('|' + s.center(10) + '|')
print('|' + s.center(10, '-') + '|')
print('|' + s.ljust(10, '-') + '|')
print('|' + s.rjust(10, '-') + '|')

# |   ***    |
 |---***----|
# |***-------|
# |-------***|

print('|' + s.rjust(10, '--') + '|')
# Traceback (most recent call last):
#   File "test.py", line 6, in <module>
#    print('|' + s.rjust(10, '--') + '|')
# TypeError: The fill character must be exactly one character long

s = "***"

print('|' + s.center(10) + '|')

print('|' + s.center(10, '-') + '|')

print('|' + s.ljust(10, '-') + '|')

print('|' + s.rjust(10, '-') + '|')

# | *** |

|---***----|

# |***-------|

# |-------***|

print('|' + s.rjust(10, '--') + '|')

# Traceback (most recent call last):

# File "test.py", line 6, in <module>

# print('|' + s.rjust(10, '--') + '|')

# TypeError: The fill character must be exactly one character long

余白などの切り落とし

strip()、lstrip()、rstrip()各メソッドは、文字列の両端の指定文字を削除する。デフォルトでは空白が削除されるが、複数の文字を切り落とす対象として指定できる。

ただし、切り落とされるのは最も外側の文字列群だけであることに注意。

s = "   Python   "
print('|' + s.strip() + '|')
print('|' + s.lstrip() + '|')
print('|' + s.rstrip() + '|')
# |Python|
# |Python   |
# |   Python|

s = "  $  Python  $  "
print('|' + s.strip() + '|')
# |$  Python  $|
# 最も外側の該当文字だけが削除される

s = "--$$ Python--$$  "
print('|' + s.strip('- ') + '|')
# |$$ Python--$$|
# 複数文字を指定することも可能だが、これも最外側のみ

s = " Python "

print('|' + s.strip() + '|')

print('|' + s.lstrip() + '|')

print('|' + s.rstrip() + '|')

# |Python|

# |Python |

# | Python|

s = " $ Python $ "

print('|' + s.strip() + '|')

# |$ Python $|

# 最も外側の該当文字だけが削除される

s = "--$$ Python--$$ "

print('|' + s.strip('- ') + '|')

# |$$ Python--$$|

# 複数文字を指定することも可能だが、これも最外側のみ

Python3 – map関数

2016-09-30 / tau / コメントする

基本

コレクションやイテレーターの戻り値に何らかの処理を施したい場合、たとえば内包表記を使うことが課が得られる。

lst = [0, 1, 2, 3, 4]
comprehension = [x * 2 for x in lst]
print(comprehension)

# 0, 2, 4, 6, 8]

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

comprehension = [x * 2 for x in lst]

print(comprehension)

# 0, 2, 4, 6, 8]

同様の効果があるmap()関数は、コレクションやイテレーターの戻り値に関数を作用させた結果を返す。第1引数には適用したい関数、第2引数には適用対象となるコレクション等を指定する。

map([関数], [コレクション／リスト])

1	map([関数], [コレクション／リスト])

以下の例は、冒頭に示した内包表記と同じくリストの要素を2倍する。使い方としては、与えられた引数を2倍する関数を準備し、関数を第1引数に、対象となるリストを第2引数に与える。

def double(x):
    return x * 2

for x in map(double, lst):
    print(x, end=" ")
print()
# 0 2 4 6 8

def double(x):

return x * 2

for x in map(double, lst):

print(x, end=" ")

print()

# 0 2 4 6 8

なおmapオブジェクトはイテレーターとして振舞うので、結果をリスト表示するためにはlist()関数を通す必要がある。

print(map(double, lst))
# <map object at 0x03098290>

print(list(map(double, lst)))
# [0, 2, 4, 6, 8]

print(map(double, lst))

# <map object at 0x03098290>

print(list(map(double, lst)))

# [0, 2, 4, 6, 8]

再利用不可

map()関数で得られたオブジェクトを変数にセットして使うこともできる。ただしmapオブジェクトはイテレーターなので1度利用したものをそのまま再度利用することはできない。

mapped = map(double, lst)
for x in mapped:
    print(x, end=" ")
print()
# 0 2 4 6 8

for x in mapped:
    print(x, end=" ")
print()
# nothing displayed

mapped = map(double, lst)

for x in mapped:

print(x, end=" ")

print()

# 0 2 4 6 8

for x in mapped:

print(x, end=" ")

print()

# nothing displayed

イテレーター等の指定

また第2引数にはコレクションではなく、rangeオブジェクトやイテレーターを渡すこともできる。

for x in map(double, range(5)):
    print(x, end=" ")
print()
# 0 2 4 6 8

from itertools import repeat
for x in map(double, repeat(1, 5)):
    print(x, end=" ")
print()
# 2 2 2 2 2

for x in map(double, range(5)):

print(x, end=" ")

print()

# 0 2 4 6 8

from itertools import repeat

for x in map(double, repeat(1, 5)):

print(x, end=" ")

print()

# 2 2 2 2 2

ラムダ式が可能

map()関数の第1引数には、関数のほかにラムダ式を指定することも可能。

for x in map(lambda x: x * 2, range(5)):
    print(x, end=" ")
print()

# 0 2 4 6 8

for x in map(lambda x: x * 2, range(5)):

print(x, end=" ")

print()

# 0 2 4 6 8

辞書によるマッピング

コードが格納されているコレクションから、辞書とmap()関数でコードに対応する値を得ることができる。

dict = {0:"zero", 1:"one", 2:"two"}
for x in map(lambda key: dict[key], [0, 1, 2, 1, 0]):
    print(x, end=" ")
print()

# zero one two one zero

dict = {0:"zero", 1:"one", 2:"two"}

for x in map(lambda key: dict[key], [0, 1, 2, 1, 0]):

print(x, end=" ")

print()

# zero one two one zero

逆に値が格納されているコレクションから、辞書を使ってコードのコレクションを得ることもできる。この場合、辞書のキーとコードを入れ替えて適用する。

lst = ["two", "one", "zero", "one", "two"]
dict_inv = {v:k for k, v in dict.items()}
for x in map(lambda key: dict_inv[key], lst):
    print(x, end=" ")
print()

# 2 1 0 1 2

lst = ["two", "one", "zero", "one", "two"]

dict_inv = {v:k for k, v in dict.items()}

for x in map(lambda key: dict_inv[key], lst):

print(x, end=" ")

print()

# 2 1 0 1 2

Python3 – スライスとfindでの位置指定の違い

2016-09-29 / tau / コメントする

文字列のスライスとfind/rfindで検索範囲の指定が違っていて混乱したので整理する。

文字列のスライスでは、次のように指定する。

string[start:end:step]

1	string[start:end:step]

このとき、stepが正なら前方から後方へ、負なら後方から前方へ向かって文字列が取り出されるが、そのときのstartとendの指定は、stepが正か負かで次のように違ってくる。

s = "0123456789"

print(s[3:7:1])
print(s[-7:-3:1])
# どちらも"3456"
# start:stopでstart<stop

print(s[7:3:1])
print(s[-3:-7:1])
# どちらも""
# start:stopでstart>stop

print(s[3:7:-1])
print(s[-7:-3:-1])
# どちらも""
# start:stopでstart<stop

print(s[7:3:-1])
print(s[-3:-7:-1])
# どちらも"7654"
# start:stopでstart>stop

s = "0123456789"

print(s[3:7:1])

print(s[-7:-3:1])

# どちらも"3456"

# start:stopでstart<stop

print(s[7:3:1])

print(s[-3:-7:1])

# どちらも""

# start:stopでstart>stop

print(s[3:7:-1])

print(s[-7:-3:-1])

# どちらも""

# start:stopでstart<stop

print(s[7:3:-1])

print(s[-3:-7:-1])

# どちらも"7654"

# start:stopでstart>stop

つまりstepが正の時は、前方から後方へ文字列が取り出されるのでstart<stop、stepが負の時は逆にstart>stopでなければならない。

一方、find/rfindについてはスライスと違ってくる。

s = "abcdeabcde"

print(s.find('b',4, 8))
print(s.find('b',-6, -2))
# どちらも6
# start,stopでstart<stop

print(s.find('b',8, 4))
print(s.find('b',-2, -6))
# どちらも-1
# start,stopでstart>stop

print(s.find('b',4, 8))
print(s.find('b', -6, -2))
# どちらも6
# start,stopでstart<stop

print(s.rfind('b',8, 4))
print(s.rfind('b',-2, -6))
# どちらも-1
# start,stopでstart>stop

s = "abcdeabcde"

print(s.find('b',4, 8))

print(s.find('b',-6, -2))

# どちらも6

# start,stopでstart<stop

print(s.find('b',8, 4))

print(s.find('b',-2, -6))

# どちらも-1

# start,stopでstart>stop

print(s.find('b',4, 8))

print(s.find('b', -6, -2))

# どちらも6

# start,stopでstart<stop

print(s.rfind('b',8, 4))

print(s.rfind('b',-2, -6))

# どちらも-1

# start,stopでstart>stop

(string, start, stop)の指定で、検索範囲の指定は常にstart < stopでなければならない。

Python3 – モジュールとパッケージ

2016-09-28 / tau / コメントする

概要

モジュールは共通して利用したい実行ファイルをインポートできるように配置したもの。パッケージはパッケージやモジュールをひとまとめにするもの。

ローカルの実行環境では、ディレクトリがパッケージになる
- パッケージ内の__init__.pyファイルは特別なモジュールで、パッケージをインポートするだけでモジュール内の関数やクラスが使える
- パッケージ下にモジュールファイルを置くと、[パッケージ名].[モジュール名]でモジュール内の関数やクラスが使える
パッケージのセットアップとインストール→今後

カレントディレクトリ下での使用

モジュールは普通のPython実行ファイルで作成。

たとえばカレントディレクトリに以下のようなファイルをtestmodule.pyとして置く。このモジュールには関数が1つとクラスが1つ定義されている。

# testmodule.py

def exec():
    print("Test module")

class ModuleClass:
    def display(self):
        print("Module class")

# testmodule.py

def exec():

print("Test module")

class ModuleClass:

def display(self):

print("Module class")

そして同じカレントディレクトリにあるtest.pyを以下のように書く。

# test.py

import testmodule

testmodule.exec()

instance = testmodule.ModuleClass()
instance.display()

# test.py

import testmodule

testmodule.exec()

instance = testmodule.ModuleClass()

instance.display()

この時点でファイル構成は以下のようになっている。

<python>
    test.py
    testmodule.py

test.py

testmodule.py

ここでtest.pyを実行すると次のように表示される。無事インポートできて、モジュールで定義した関数、クラスとも使える。

Test module
Module class

1 2	Test module Module class

実行後には新しいディレクトリが追加されて、以下のようになった。

<python>
    test.py
    testmodule.py
    <__pycache__>
        testmodule.cpython-35.pyc

test.py

testmodule.py

<__pycache__>

testmodule.cpython-35.pyc

カレントディレクトリ下でのモジュール管理のまとめ

関数・クラスなどを含むモジュールをPythonファイルとして作成し、カレントファイルに置く
利用側で、モジュール名(モジュールのファイル名から拡張子”.py”を除いた名前)を指定してインポート
[モジュール名].[関数名/クラス名]として利用

サブディレクトリ管理でのエラー

モジュールをカレントディレクトリではなくサブディレクトリに置いて管理したいので、以下のように置いてみる。

<python>
    test.py
    <subdir>
        testmodule.py

test.py

testmodule.py

そして以下のように呼び出そうとしたが残念ながらエラー。

import subdir.testmodule

#     import subdir/testmodule
# SyntaxError: invalid syntax

import subdir.testmodule

# import subdir/testmodule

# SyntaxError: invalid syntax

ただしこの実行後、サブディレクトリの下に新しいディレクトリがつくられていた。

<python>
    test.py
    <subdir>
        testmodule.py
        <__pyckache__>
            testmodule.cpython-35.pyc

test.py

testmodule.py

<__pyckache__>

testmodule.cpython-35.pyc

これはimport文を読んだPythonがsubdirというパッケージを探しに行ったが見つからなかったためで、モジュールを置いたディレクトリをパッケージとしてPythonに認識させる必要がある。

パッケージ

パッケージ直下のモジュール

ディレクトリをパッケージとしてPythonに認識させるためには__init__.pyというファイルが必要になる。

たとえば以下のようなディレクトリ・ファイル構造として

<python>
    test.py
    <testpackage>
        __init__.py

test.py

__init__.py

__init__.pyファイル内容を前のtestmodule.pyと同じとする。

# __init__.py

def exec():
    print("Test module")

class ModuleClass:
    def display(self):
        print("Module class")

# __init__.py

def exec():

print("Test module")

class ModuleClass:

def display(self):

print("Module class")

カレントディレクトリ下のtest.pyでは前は[モジュール名].[関数/クラス]としていたが、今回は以下のようにパッケージから呼び出すように変更。__init__.pyファイルに書いたモジュールは、パッケージ直下から呼び出される。

# test.py

import testpackage

testpackage.exec()

instance = testpackage.ModuleClass()
instance.display()

# test.py

import testpackage

testpackage.exec()

instance = testpackage.ModuleClass()

instance.display()

出力は以下の通りとなって成功。

Test module
Module class

1 2	Test module Module class

またここでもmypackageディレクトリの下に新しいディレクトリが作成された。

<python>
    test.py
    <testpackage>
        __init__.py
        <pychache>
            __init__.cpython-35.pyc

test.py

__init__.py

__init__.cpython-35.pyc

パッケージ内のモジュール

testpackageディレクトリ下にothermodule.pyファイルを置く。

<python>
    test.py
    <testpackage>
        __init__.py
        othermodule.py

test.py

__init__.py

othermodule.py

# othermodule.py

def exec():
    print("Other module")

# othermodule.py

def exec():

print("Other module")

test.pyを以下のようにして実行。

# test.py

import testpackage
import testpackage.othermodule

testpackage.exec()

instance = testpackage.ModuleClass()
instance.display()

testpackage.othermodule.exec()

# test.py

import testpackage

import testpackage.othermodule

testpackage.exec()

instance = testpackage.ModuleClass()

instance.display()

testpackage.othermodule.exec()

以下のように実行される。

Test module
Module class
Other module

Test module

Module class

Other module

一度実行されると、pycacheディレクトリに新たなファイルが追加される。

<python>
    test.py
    <testpackage>
        __init__.py
        othermodule.py
        <pychache>
            __init__.cpython-35.pyc
            othermodule.cpython-35.pyc

test.py

__init__.py

othermodule.py

__init__.cpython-35.pyc

othermodule.cpython-35.pyc

待ち行列(M/M/1)の再現 – 時刻制御

2016-09-27 / tau / コメントする

考え方

時刻制御(time driven)による待ち行列の計算の考え方は次の通り。

時刻t₀から始めて、以下時間間隔Δtずつ増やしながら計算を進めていく
ある時刻で一様乱数の値がλΔtより小さければ到着が発生
- 新たにトランザクションを生成し、到着時刻を記録し、システムに投入する
ある時刻で到着が発生せず、システムにトランザクションがある場合、一様乱数の値がμΔｔより小さければサービスが終了
- サービス中のトランザクションのサービスを終了させ、終了時刻を記録する
- このとき待ち行列にトランザクションがあれば、先頭のトランザクションのサービスを開始し、サービス開始時刻を記録する
予め設定していた時刻(またはトランザクション数)に達したら終了

queue-mm1-time-driven-fig1

たとえば上の図でトランザクション②に注目すると、

時刻t₄でトランザクションが発生
t₇でトランザクション①のサービスが終了し、②のサービスが開始
t₈でサービス終了

イベント制御のケースではRを用いたが、今回はPythonを使う。なおM/M/1待ち行列の解析的アプローチはこちら。

待ち行列システムのクラスをつくり、システムの外からはトランザクションの到着、サービス終了の操作を行うだけで、内部的に処理が進むようにする。

クラス構成

待ち行列システムを表すQueueSystemクラス、システムのサービス窓口を表すServiceクラス、システム中の1つのトランザクションを表すTransactionクラスから構成される。システム中の待ち行列はインスタンス変数のリストとして持つ。

M/M/1型の行列システムとして、QueueSystemクラスは1つのServiceオブジェクトと1つの待ち行列リストをメンバーに持つ。

トランザクションの到着の指示が出るとTransactionオブジェクトが生成され、システムに登録される。

その一方で実行中のサービス終了の指示が出るとサービスを受けているトランザクションが解放される。

各Transactionオブジェクトに対して、システムの到着、サービスの開始、サービスの終了の時刻が自動的に登録される。

Transactionクラス

識別子としての整数値のindexのほか、到着・サービス開始・サービス終了の時刻、到着時のシステム内トランザクション数と待ち行列長をメンバーとして持つ
- これらのメンバーに対しては直接アクセスして参照・代入する
このクラスのオブジェクトの文字列表現を__str__メソッドで実装している

class Transaction:
    def __init__(self, index, arrive_time):
        self.index = index
        self.arrive_time = arrive_time
        self.start_time = 0
        self.end_time = 0
        self.transaction_number_when_arrived = 0
        self.queue_length_when_arrived = 0

    def __str__(self):
        return "<{}:{},{},{}>".format(
            self.index, self.arrive_time, self.start_time, self.end_time)

class Transaction:

def __init__(self, index, arrive_time):

self.index = index

self.arrive_time = arrive_time

self.start_time = 0

self.end_time = 0

self.transaction_number_when_arrived = 0

self.queue_length_when_arrived = 0

def __str__(self):

return "<{}:{},{},{}>".format(

self.index, self.arrive_time, self.start_time, self.end_time)

Serviceクラス

privateなメンバ_transactionを持ち、これはサービス中のトランザクションを保持する
- サービス中のトランザクションがない場合はNone
サービス窓口が空いているか(vacant)、サービス中か(occupied)を判定するメソッドを持つ
サービス中のトランサクションへの参照を返すtransaction_in_service()メソッドを持つ
サービス開始時の処理を行うstart()メソッドを持つ
- サービスを開始するTransactionオブジェクトとサービス開始時刻を指定する
サービス終了時の処理を行うend()メソッドを持つ
- サービス終了時刻を指定し、サービス中のTransactionオブジェクトにその時刻を設定し、オブジェクトへの参照を返す

class Service:
    def __init__(self):
        self._transaction = None

    def is_vacant(self):
        return self._transaction is None

    def is_occupied(self):
        return self._transaction is not None

    def transaction_in_service(self):
        return self._transaction

    def start(self, transaction, time):
        transaction.start_time = time
        self._transaction = transaction

    def end(self, time):
        transaction = self._transaction
        transaction.end_time = time
        self._transaction = None
        return transaction

class Service:

def __init__(self):

self._transaction = None

def is_vacant(self):

return self._transaction is None

def is_occupied(self):

return self._transaction is not None

def transaction_in_service(self):

return self._transaction

def start(self, transaction, time):

transaction.start_time = time

self._transaction = transaction

def end(self, time):

transaction = self._transaction

transaction.end_time = time

self._transaction = None

return transaction

QueueSystemクラス

メンバとなるインスタンス変数は4つ

待ち行列リスト_queue
サービス窓口オブジェクト_service
到着済みのトランザクションを登録する_arrived_transaction_list
サービス完了済みのトランザクションを登録する_departed_transaction_list

getter系のメソッドは

システム中にあるトランザクション数を返すtransaction_number_in_system()
待ち行列長を返すqueue_length()
システム中にあるトランザクションへの参照を返すtransaction_in_service()
待ち行列中にあるトランザクションへの参照を返すtransaction_in_queue()
到着済みのトランザクション数を返すarrived_transaction_number()
完了済みのトランザクション数を返すdeparted_transaction_number()
到着済みのトランザクションのn番目を返すarrived_transaction()
完了済みのトランザクションのn番目を返すdeparted_transaction()

システムを操作するメソッドは

システムに到着したトランザクションを登録するarrive()
サービスが終了したトランザクションをシステムから取り出すdepart()

システムの状態を表示するメソッドとして以下の2つを実装している。

システムの現在の状態を表示するdisplay_current_status()
サービスを完了したトランザクション群の各パラメータを表示するdisplay_transaction_summary()

class QueueSystem:
    def __init__(self):
        self._queue = []
        self._service = Service()
        self._arrived_transaction_list = []
        self._departed_transaction_list = []

    def transaction_number_in_system(self):
        return (len(self._queue)
                + (1 if self._service.is_occupied() else 0))

    def queue_length(self):
        return len(self._queue)

    def transaction_in_service(self):
        return self._service.transaction_in_service()

    def transaction_in_queue(self, n):
        return self._queue[n]

    def arrived_transaction_number(self):
        return len(self._arrived_transaction_list)

    def departed_transaction_number(self):
        return len(self._departed_transaction_list)

    def arrived_transaction(self, n):
        return self._arrived_transaction_list[n]

    def departed_transaction(self, n):
        return self._departed_transaction_list[n]

    def arrive(self, transaction):
        self._arrived_transaction_list.append(transaction)
        transaction.transaction_number_when_arrived = \
            self.transaction_number_in_system()
        transaction.queue_length_when_arrived = self.queue_length()
        if self._service.is_vacant():
            self._service.start(transaction, transaction.arrive_time)
        else:
            self._queue.append(transaction)

    def depart(self, time):
        departing_transaction = self._service.end(time)
        self._departed_transaction_list.append(departing_transaction)
        if len(self._queue) > 0:
            waiting_transaction = self._queue.pop(0)
            self._service.start(waiting_transaction, time)

    def display_current_status(self):
        print()
        print("--- Queue System Status ---")
        print("arrived :{0:5d}".format(self.arrived_transaction_number()))
        print("departed:{0:5d}".format(self.departed_transaction_number()))
        print("[Service]")
        if self.transaction_number_in_system() > 0:
            print(' ' + str(self.transaction_in_service()))
        print("[Queue]")
        if self.queue_length() > 0:
            for n in range(0, self.queue_length()):
                print(self.transaction_in_queue(n))

    def display_transaction_summary(self):
        print()
        print("---------------------------- " \
            "All Transaction Summary " \
            "---------------------------")
        print(
            "     index    arrive     start       end" \
            "   trs num   que len wait time  trs time")
        for tr in self._departed_transaction_list:
            print("{0:10d}{1:10.2f}{2:10.2f}{3:10.2f}" \
                "{4:10d}{5:10d}{5:10.2f}{6:10.2f}".format(
                tr.index, tr.arrive_time, tr.start_time, tr.end_time,
                tr.transaction_number_when_arrived,
                tr.queue_length_when_arrived,
                tr.start_time - tr.arrive_time, tr.end_time - tr.arrive_time))

class QueueSystem:

def __init__(self):

self._queue = []

self._service = Service()

self._arrived_transaction_list = []

self._departed_transaction_list = []

def transaction_number_in_system(self):

return (len(self._queue)

+ (1 if self._service.is_occupied() else 0))

def queue_length(self):

return len(self._queue)

def transaction_in_service(self):

return self._service.transaction_in_service()

def transaction_in_queue(self, n):

return self._queue[n]

def arrived_transaction_number(self):

return len(self._arrived_transaction_list)

def departed_transaction_number(self):

return len(self._departed_transaction_list)

def arrived_transaction(self, n):

return self._arrived_transaction_list[n]

def departed_transaction(self, n):

return self._departed_transaction_list[n]

def arrive(self, transaction):

self._arrived_transaction_list.append(transaction)

transaction.transaction_number_when_arrived = \

self.transaction_number_in_system()

transaction.queue_length_when_arrived = self.queue_length()

if self._service.is_vacant():

self._service.start(transaction, transaction.arrive_time)

else:

self._queue.append(transaction)

def depart(self, time):

departing_transaction = self._service.end(time)

self._departed_transaction_list.append(departing_transaction)

if len(self._queue) > 0:

waiting_transaction = self._queue.pop(0)

self._service.start(waiting_transaction, time)

def display_current_status(self):

print()

print("--- Queue System Status ---")

print("arrived :{0:5d}".format(self.arrived_transaction_number()))

print("departed:{0:5d}".format(self.departed_transaction_number()))

print("[Service]")

if self.transaction_number_in_system() > 0:

print(' ' + str(self.transaction_in_service()))

print("[Queue]")

if self.queue_length() > 0:

for n in range(0, self.queue_length()):

print(self.transaction_in_queue(n))

def display_transaction_summary(self):

print()

print("---------------------------- " \

"All Transaction Summary " \

"---------------------------")

print(

" index arrive start end" \

" trs num que len wait time trs time")

for tr in self._departed_transaction_list:

print("{0:10d}{1:10.2f}{2:10.2f}{3:10.2f}" \

"{4:10d}{5:10d}{5:10.2f}{6:10.2f}".format(

tr.index, tr.arrive_time, tr.start_time, tr.end_time,

tr.transaction_number_when_arrived,

tr.queue_length_when_arrived,

tr.start_time - tr.arrive_time, tr.end_time - tr.arrive_time))

動作テスト

上記のクラス群を使って以下を実行。規則正しく刻まれた時刻に4つのトランザクションが到着し、その後規則正しくサービスが終了していく様子と、その結果を表示させている。

trs = []
for n in range(1, 10):
    trs.append(Transaction(n, n*10))

system = QueueSystem()
system.display_current_status()

system.arrive(trs[0])
system.display_current_status()

system.arrive(trs[1])
system.display_current_status()

system.arrive(trs[2])
system.display_current_status()

system.arrive(trs[3])
system.display_current_status()

system.depart(45)
system.display_current_status()

system.depart(55)
system.display_current_status()

system.depart(65)
system.display_current_status()

system.depart(75)
system.display_current_status()

print()
system.display_transaction_summary()

print()
print("-- arrived --")
na = system.arrived_transaction_number()
for i in range(0, na):
    print(system.arrived_transaction(i))

print()
print("-- departed --")
na = system.departed_transaction_number()
for i in range(0, na):
    print(system.departed_transaction(i))

trs = []

for n in range(1, 10):

trs.append(Transaction(n, n*10))

system = QueueSystem()