BrythonでJavaScriptの組み込みクラスを使う

2016-10-15 / tau / 2件のコメント

次の手順でBrythonからJavaScriptのクラスを直接使うことができる。JavaScript側の自作クラスをPythonで使う例はいくつか見かけたが、組込関数はどうかと思って試してみた。

browserモジュールからwindowオブジェクトをインポートする
JSConstructor()関数の引数にJavaScriptの組み込みクラスのコンストラクタを与えてPythonとしてのコンストラクタを得る
- ()や引数はつけない
- 引数に与えるJavaScriptのコンストラクタはwindowオブジェクトに属している
上のコンストラクタを使ってインスタンスを生成

たとえばJavaScriptの組込クラスArrayを使ってみる。

from browser import window
from javascript import JSConstructor

Array = JSConstructor(window.Array)
array = Array("one", "two", "three")
print(array)
# ['one', 'two', 'three']

from browser import window

from javascript import JSConstructor

Array = JSConstructor(window.Array)

array = Array("one", "two", "three")

print(array)

# ['one', 'two', 'three']

Arrayオブジェクトをつくると、Pythonのリストとして生成されているらしい。メソッドも使えそう。

array.reverse()
print(array)
# ['three', 'two', 'one']
array.sort()
print(array)
# ['one', 'three', 'two']

array.reverse()

print(array)

# ['three', 'two', 'one']

array.sort()

print(array)

# ['one', 'three', 'two']

ところがtoString()メソッドを使おうとするとエラーに。

print(array.toString())
# AttributeError: 'list' object has no attribute '$$toString'

1 2	print(array.toString()) # AttributeError: 'list' object has no attribute '$$toString'

これを見ると、JavaScriptのコンストラクタを使っているが、Pythonではリストとして解釈されるので、メソッドが存在しない、とエラーになる。上のreverse()やsort()は、JavaScriptのArrayクラスのメソッドではなく、Pythonのリストオブジェクトのメソッドとして解釈・実行されたということになる。

Pythonのクラスに定義されていないプロパティにアクセスした場合もエラーになる。

print(len(array))
# 3
print(array.length)
# AttributeError: 'list' object has no attribute 'length'

print(len(array))

# 3

print(array.length)

# AttributeError: 'list' object has no attribute 'length'

もともとBrythonに該当するものがないJavaScriptのクラスの場合。たとえばPath2Dをつくってみると、JSObjectでラップされたオブジェクトになっているらしい。

from browser import window
from javascript import JSConstructor

Path2D = JSConstructor(window.Path2D)
path = Path2D()
print(path)
# <JSObject wraps [object Path2D]>

from browser import window

from javascript import JSConstructor

Path2D = JSConstructor(window.Path2D)

path = Path2D()

print(path)

# <JSObject wraps [object Path2D]>

このPath2DオブジェクトのmoveTo()やlineTo()といったメソッドは問題なく機能して、canvasに描画することができる。

Python3 – 関数の引数は値渡しか

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

参照渡しだが値は保護

以下のコードを実行すると、関数実行の前後で引数に渡した変数の値が影響を受けていない。挙動だけ見ると値渡し(call by value)だが、Pythonの関数引数は参照渡し(call by reference)だという。

def func(arg):
    arg += 1

a = 0
func(a)
print(a)
func(a)
print(a)

# 0
# 0

def func(arg):

arg += 1

a = 0

func(a)

print(a)

func(a)

print(a)

# 0

実際には、引数を受け取った段階では、元の引数オブジェクトへの参照が渡されているが、その内容が変更されたときに新しいオブジェクトが生成され、元の変数の内容は保たれるらしい。

だが、時には関数に渡した引数の内容を、関数で変更したいような時がある(たとえばシステムの状態に関するフラグの変更など)。そのような変数をglobal定義してもよいが、やはり全体系への汚染のことを考えると気持ちはよくない。

リストを使った場合

以下の例では、要素を1つ持つリストをつくり、そのリストを関数に渡して、関数内でリストの要素の値を変更している。

def func(lst):
    lst[0] += 1

a = [0]
func(a)
print(a)
func(a)
print(a)

# [1]
# [2]

def func(lst):

lst[0] += 1

a = [0]

func(a)

print(a)

func(a)

print(a)

# [1]

# [2]

リストなどのミュータブルなオブジェクトの場合、その内容が関数内での変更の影響を受けている。

クラスを使った場合

以下の例では、カウンタをプロパティに持つクラスをつくり、そのインスタンスを関数に渡して、関数内でインスタンスのカウンタの値を変更している。

class ArgClass:
    def __init__(self):
        self.counter = 0

def func(cl):
    cl.counter += 1

a = ArgClass()
func(a)
print(a.counter)
func(a)
print(a.counter)

# 1
# 2

class ArgClass:

def __init__(self):

self.counter = 0

def func(cl):

cl.counter += 1

a = ArgClass()

func(a)

print(a.counter)

func(a)

print(a.counter)

# 1

# 2

変数の内容を特定の関数で変更させたい場合、リストよりもクラスを使った方が意味づけができてよいのではないか。

Brython – 日時とタイマ

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

このページでは、Brythonの外部スクリプトファイルを読み込んで実行している。ページのロード後にその時の日時が表示され、下のボタンを押すたびに現在時刻が1秒間隔で表示され、またそれが停止する。

このページのHTML部分は以下の通りで、ボタンと表示部、スクリプト読み込みが主要部分。

・・・・・

<input id="start-stop" type="button" value="Start/Stop" />
<div id="show-area" style="font-size: 2em;"></div>

・・・・・

<p style="font-size: 2em;"><script type="text/python" src="../brython/datetime.py"></script></p>

・・・・・

・・・・・

外部スクリプトの内容は以下の通り。global変数は使わず、timerを保持・表示するクラスを関数の引数に渡している。

また、timer.set_interval()の引数に関数を渡す際、インスタンスメソッドを渡すこともできる。

from browser import document
from datetime import datetime
from browser import timer

class DateTimeObject:
    def __init__(self):
        self.timer = None

    def show():
        date_string = datetime.now().strftime('%Y/%m/%d %H:%M:%S')
        document["show-area"].html = date_string

def switch(datetime_obj):
    if datetime_obj.timer is None:
        datetime_obj.timer = timer.set_interval(datetime_obj.show, 1000)
    else:
        timer.clear_interval(datetime_obj.timer)
        datetime_obj.timer = None

datetime_obj = DateTimeObject()
datetime_obj.show()

document["start-stop"].bind("click", lambda: switch(datetime_obj))

from browser import document

from datetime import datetime

from browser import timer

class DateTimeObject:

def __init__(self):

self.timer = None

def show():

date_string = datetime.now().strftime('%Y/%m/%d %H:%M:%S')

document["show-area"].html = date_string

def switch(datetime_obj):

if datetime_obj.timer is None:

datetime_obj.timer = timer.set_interval(datetime_obj.show, 1000)

else:

timer.clear_interval(datetime_obj.timer)

datetime_obj.timer = None

datetime_obj = DateTimeObject()

datetime_obj.show()

document["start-stop"].bind("click", lambda: switch(datetime_obj))

Brythonでのタイマの使い方についてはこちらを参照。

Brythonの開発環境

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

概要

Brythonの開発環境については、Brython Documentationの”Development Environment“で説明されている。

開発環境のダウンロードと解凍

まず、開発環境のzipファイルをダウンロードする。ファイルは”BrythonX.Y.Z_site_mirror”で、X.Y.Zはバージョン番号。

ダウンロードしたファイルをディレクトリ下に解凍する。以下、このディレクトリを”brython_directory”とする。

サーバの起動・終了

Brythonをローカル環境で開発するため、ローカルサーバを起動する。サーバはPythonでつくられていて、その場所はbrython_directory直下、ファイル名はserver.py。

brython_directoryで、コンソールからpython server.pyと打つとポート8000でローカルサーバが動き出す。

>python server.py

1	>python server.py

起動時の--portオプション指定で8000以外のポートを割り当てることも可能。

>python server.py --port 8001

1	>python server.py --port 8001

サーバの終了は、サーバが稼働中のコンソールで[CTRL-C]

ファイルの配置と呼び出し

開発するBrythonを呼び出すHTMLファイルを置く場所は、brython_directory/wwwの下に任意のディレクトリを作成して配置。

たとえばbrython_directory/www/brython_test/index.htmlなど。

ブラウザからこのファイルを読みに行く場合は”http://localhost:8000/brython_test/index.html”とする。

Python3 – 正規表現 – シンタックス

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

文字にマッチするもの

一覧

文字	それぞれの文字にマッチする。Python3ではUnicode文字も対象。
`.`	`'\n'`以外の任意の一文字にマッチする。`re.S`/`re.DOTALL`フラグが設定されると’\n’にもマッチする。
`[...]`	文字クラス。`[]`内に含まれる文字のいずれか一文字マッチする。`'-'`で範囲指定も可能。たとえば`[abc]`は`a`、`b`、`c`にマッチ。`[a-z]`は全ての小文字のアルファベット文字にマッチ。`[abcx-z]`は`a`、`b`、`c`、`x`、`y`、`z`にマッチ。Unicode文字にも対応していて`[０-９]`は全角の数字にマッチ。先頭に`'^'`記号があると、その文字クラス以外の文字列がマッチする。たとえば`[^abc]`は`a`、`b`、`c`以外にマッチする。
`\d`	数字[0-9]にマッチ。Unicode文字の数字も対象となり、全角の数字`[０-９]`なども対象となる。`re.A`/`re.ASCII`フラグが設定されると[0-9]にのみマッチする。バイト列に対しては`[0-9]`と等価。
`\D`	数字以外の文字にマッチ。Unicode文字の数字も除外対象となる。
`\w`	任意のUnicode単語文字にマッチ。あらゆる単語の一部になりうる文字で、文字・数字・アンダースコアが含まれる。re.ASCIIフラグが設定された場合`[a-zA-Z0-9_]`にマッチ。バイト列に対しては[a-zA-Z0-9_]と等価。
`\W`	Unicode単語文字以外の文字にマッチ。
`\s`	任意の空白文字とマッチ。`[ \t\n\r\f\v]`など。
`\S`	空白以外の文字にマッチ。

Pythonの標準エスケープも正規表現で認識される。

\a、\b、\f、\n、\r、\t、\u、\U、\v、\x、\\

ただし\bは単語境界を表し、文字クラス内でのみバックスペース文字を表す。

文字クラス

文字クラスはUnicode文字にも対応。

import re
print(re.findall(r'[あ-ん]', "我考える故に我あり"))
print(re.findall(r'[^あ-ん]', "我考える故に我あり"))
# ['え', 'る', 'に', 'あ', 'り']
# ['我', '考', '故', '我']

import re

print(re.findall(r'[あ-ん]', "我考える故に我あり"))

print(re.findall(r'[^あ-ん]', "我考える故に我あり"))

# ['え', 'る', 'に', 'あ', 'り']

# ['我', '考', '故', '我']

文字クラス内では特殊文字は意味を失い、1つの文字として扱われる。たとえば[(*+)]は'('、'*'、'+'、')'のいずれかとマッチする。

import re
print(re.findall(r'[(*+?)]', "(1+2)*3=9?"))
# ['(', '+', ')', '*', '?']

import re

print(re.findall(r'[(*+?)]', "(1+2)*3=9?"))

# ['(', '+', ')', '*', '?']

'^'と、']'は例外で、'^'は先頭の場合のみ否定の意味でそれ以外の位置では文字'^'を表し、']'は末尾では無視されそれ以外の位置では文字']'を表す。

import re

s = "array[n]=var^2"

print(re.findall(r'[^a]',s))
# ['r', 'r', 'y', '[', 'n', ']', '=', 'v', 'r', '^', '2']
print(re.findall(r'[a^]',s))
# ['a', 'a', 'a', '^']

print(re.findall(r'[[]',s))
# ['[']
print(re.findall(r'[[a]',s))
# ['a', 'a', '[', 'a']

print(re.findall(r'[]]',s))
# [']']
print(re.findall(r'[a]]',s))
# []
print(re.findall(r'[]a]',s))
# ['a', 'a', ']', 'a']

import re

s = "array[n]=var^2"

print(re.findall(r'[^a]',s))

# ['r', 'r', 'y', '[', 'n', ']', '=', 'v', 'r', '^', '2']

print(re.findall(r'[a^]',s))

# ['a', 'a', 'a', '^']

print(re.findall(r'[[]',s))

# ['[']

print(re.findall(r'[[a]',s))

# ['a', 'a', '[', 'a']

print(re.findall(r'[]]',s))

# [']']

print(re.findall(r'[a]]',s))

# []

print(re.findall(r'[]a]',s))

# ['a', 'a', ']', 'a']

位置にマッチするもの

一覧

`^`	文字列の先頭にマッチする。たとえば`'^A'`は先頭の文字が`'A'`であることを示す。デフォルトでは文字列全体の先頭だけにマッチするが、`re.MULTILINE`が指定されていれば、各改行の前にもマッチする。
`$`	文字列の末尾にマッチする。たとえば`’Z$'`は末尾の文字が`'Z'`であることを示す。デフォルトでは文字列全体の末尾だけにマッチするが、`re.MULTILINE`が指定されていれば、各改行の後にもマッチする。
\b	単語境界にマッチする。単語境界は`[^a-zA-Z0-9]`。

MULTILINE

re.MULTILINEフラグ指定の有無による動作の違いを確認する。

import re

s1 = "Some people feel the rain.\nOthers just get wet."

s2 = """Love the life you live.
Live the life you love."""

print(re.findall(r'^.+', s1))
print(re.findall(r'.+$', s1))
# ['Some people feel the rain.']
# ['Others just get wet.']

print(re.findall(r'^.+', s2))
print(re.findall(r'.+$', s2))
# ['Love the life you live.']
# ['Live the life you love.']

print(re.findall(r'^.+', s1, flags=re.MULTILINE))
print(re.findall(r'.+$', s1, flags=re.MULTILINE))
# ['Some people feel the rain.', 'Others just get wet.']
# ['Some people feel the rain.', 'Others just get wet.']

print(re.findall(r'^.+', s2, flags=re.MULTILINE))
print(re.findall(r'.+$', s2, flags=re.MULTILINE))
# ['Love the life you live.', 'Live the life you love.']
# ['Love the life you live.', 'Live the life you love.']

import re

s1 = "Some people feel the rain.\nOthers just get wet."

s2 = """Love the life you live.

Live the life you love."""

print(re.findall(r'^.+', s1))

print(re.findall(r'.+$', s1))

# ['Some people feel the rain.']

# ['Others just get wet.']

print(re.findall(r'^.+', s2))

print(re.findall(r'.+$', s2))

# ['Love the life you live.']

# ['Live the life you love.']

print(re.findall(r'^.+', s1, flags=re.MULTILINE))

print(re.findall(r'.+$', s1, flags=re.MULTILINE))

# ['Some people feel the rain.', 'Others just get wet.']

print(re.findall(r'^.+', s2, flags=re.MULTILINE))

print(re.findall(r'.+$', s2, flags=re.MULTILINE))

# ['Love the life you live.', 'Live the life you love.']

\b – 文字列境界

文字列境界が[^a-zA-Z0-9]であることが、以下の例で分かる。

import re
[print(match) for match in re.finditer(r'\bab\b', "ab_ab0ab ab-ab,ab;ab(ab)")]
# <_sre.SRE_Match object; span=(9, 11), match='ab'>
# <_sre.SRE_Match object; span=(12, 14), match='ab'>
# <_sre.SRE_Match object; span=(15, 17), match='ab'>
# <_sre.SRE_Match object; span=(18, 20), match='ab'>
#<_sre.SRE_Match object; span=(21, 23), match='ab'>

import re

[print(match) for match in re.finditer(r'\bab\b', "ab_ab0ab ab-ab,ab;ab(ab)")]

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

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

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

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

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

繰り返し

`*`	直前の文字の0回以上でできるだけ多くの繰り返し。`'ab*'`は`abbc`に対して`a`や`ab`ではなく`abb`としてマッチする。
`+`	直前の文字の1回以上でできるだけ多くの繰り返し。`'ab+'`は`abbbc`に対して`ab`や`abb`ではなく`abbb`としてマッチする。`'ab?'`は`abb...`に対して`ab`としてマッチする。
`?`	直前の文字が0個か1個でできるだけ多くの場合にマッチ。
`{m}`	直前の文字の`m`回の繰り返し。
`{m,n}`	直前の文字の`m`回以上`n`回以下でできるだけ多くの繰り返し。
`{m,}`	直前の文字の`m`回以上でできるだけ多くの繰り返し。
`{,n}`	直前の文字のn回以下でできるだけ多くの繰り返し。

実行例

import re

print(re.findall(r'a*', "a aa aaa"))
# ['a', '', 'aa', '', 'aaa', '']

print(re.findall(r'a+', "a aa aaa"))
# ['a', 'aa', 'aaa']

print(re.findall(r'aa?', "a aa aaa"))
# ['a', 'aa', 'aa', 'a']

print(re.findall(r'a{2}', "a aa aaa aaaa"))
# ['aa', 'aa', 'aa', 'aa']

print(re.findall(r'a{2,3}', "a aa aaa aaaa"))
# ['aa', 'aaa', 'aaa']

print(re.findall(r'a{2,}', "a aa aaa aaaa"))
# ['aa', 'aaa', 'aaaa']

print(re.findall(r'a{,3}', "a aa aaa aaaa"))
# ['a', '', 'aa', '', 'aaa', '', 'aaa', 'a', '']

import re

print(re.findall(r'a*', "a aa aaa"))

# ['a', '', 'aa', '', 'aaa', '']

print(re.findall(r'a+', "a aa aaa"))

# ['a', 'aa', 'aaa']

print(re.findall(r'aa?', "a aa aaa"))

# ['a', 'aa', 'aa', 'a']

print(re.findall(r'a{2}', "a aa aaa aaaa"))

# ['aa', 'aa', 'aa', 'aa']

print(re.findall(r'a{2,3}', "a aa aaa aaaa"))

# ['aa', 'aaa', 'aaa']

print(re.findall(r'a{2,}', "a aa aaa aaaa"))

# ['aa', 'aaa', 'aaaa']

print(re.findall(r'a{,3}', "a aa aaa aaaa"))

# ['a', '', 'aa', '', 'aaa', '', 'aaa', 'a', '']

'a*'は長さ0の文字列にもマッチする。マッチした文字列の直後の空文字列にマッチすることが、以下の例でもわかる。

print(re.findall(r'c*', "abbcccdddd"))
# ['', '', '', 'ccc', '', '', '', '', '']

1 2	print(re.findall(r'c*', "abbcccdddd")) # ['', '', '', 'ccc', '', '', '', '', '']

'aa?'はaとaaにマッチするが、最後のaaaに対しては、先頭のaaにマッチした後、残ったaにマッチしている。

'a{2}'は先頭からaaにマッチしていき、最後のaaaaには2回マッチしている。

'a{,3}'は各マッチの後の長さ0の文字列にもマッチしていて、最後のaaaaに対しては先頭のaaaにマッチした後、残ったaにマッチしている。

選択演算子(|)

'|'で区切られた要素のどれかとマッチすればよいことを表す。

import re

print(re.findall(r"bi|di", r"bibbidi bobbidi boo"))
# ['bi', 'bi', 'di', 'bi', 'di']

import re

print(re.findall(r"bi|di", r"bibbidi bobbidi boo"))

# ['bi', 'bi', 'di', 'bi', 'di']

注意点としては、'|'で区切られた要素の左から右へマッチング評価され、ある要素がマッチしたと評価されると、その部分列に対してそれ以降の要素の評価は行われない。

import re

print(re.findall(r"aa|aaaa", r"a,aa,aaa,aaaa"))
# ['aa', 'aa', 'aa', 'aa']
# 先に'aa'で評価されると'aaaa'で評価されない

print(re.findall(r"aaaa|aa", r"a,aa,aaa,aaaa"))
# ['aa', 'aa', 'aaaa']

import re

print(re.findall(r"aa|aaaa", r"a,aa,aaa,aaaa"))

# ['aa', 'aa', 'aa', 'aa']

# 先に'aa'で評価されると'aaaa'で評価されない

print(re.findall(r"aaaa|aa", r"a,aa,aaa,aaaa"))

# ['aa', 'aa', 'aaaa']

グループ(…)

()で囲んだ要素はグループ化されて、1つの文字と同じ様に扱われる。たとえば次の例では、'Aa'というパターンを1つのグループとして、それが繰り返される回数でマッチングさせている。

import re

def match_list(ptn, s, flags=0):
    return [a.group() for a in re.finditer(ptn, s, flags)]

print(match_list(r"(Aa)+", r"Aa-AaAa-AaAaAa"))
print(match_list(r"(Aa){2}", r"Aa-AaAa-AaAaAa"))

# ['Aa', 'AaAa', 'AaAaAa']
# ['AaAa', 'AaAa']

import re

def match_list(ptn, s, flags=0):

return [a.group() for a in re.finditer(ptn, s, flags)]

print(match_list(r"(Aa)+", r"Aa-AaAa-AaAaAa"))

print(match_list(r"(Aa){2}", r"Aa-AaAa-AaAaAa"))

# ['Aa', 'AaAa', 'AaAaAa']

# ['AaAa', 'AaAa']

後方参照

()囲った部分には、先頭から順番に番号nがふられて、そのあとで'\n'のようにマッチした内容を再利用できる。

import re
print(re.search(r'\d{3}-(\d{4})-\1', "090-1234-5678"))
# None
print(re.search(r'\d{3}-(\d{4})-\1', "090-1234-1234"))
# <_sre.SRE_Match object; span=(0, 13), match='090-1234-1234'>

import re

print(re.search(r'\d{3}-(\d{4})-\1', "090-1234-5678"))

# None

print(re.search(r'\d{3}-(\d{4})-\1', "090-1234-1234"))

# <_sre.SRE_Match object; span=(0, 13), match='090-1234-1234'>

Python3 – 正規表現 – 選択演算子’|’とfindall/finditerの注意点

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

findall()、finditer()のパターン文字列で選択演算子'|'を用いるとき、選択文字列の順序によって結果が変わってくる点に注意が必要。

たとえばreモジュール関数の場合、以下の例のようになる。

import re

s = "a,aa,aaa,aaaa,aaaaa"

print(re.findall(r'aa|aaa', s))
# ['aa', 'aa', 'aa', 'aa', 'aa', 'aa']

print(re.findall(r'aaa|aa', s))
# ['aa', 'aaa', 'aaa', 'aaa', 'aa']

[print(x.group(0), end=' ') for x in re.finditer('aa|aaa', s)]; print()
# aa aa aa aa aa aa

[print(x.group(0), end=' ') for x in re.finditer('aaa|aa', s)]; print()
# aa aaa aaa aaa aa

import re

s = "a,aa,aaa,aaaa,aaaaa"

print(re.findall(r'aa|aaa', s))

# ['aa', 'aa', 'aa', 'aa', 'aa', 'aa']

print(re.findall(r'aaa|aa', s))

# ['aa', 'aaa', 'aaa', 'aaa', 'aa']

[print(x.group(0), end=' ') for x in re.finditer('aa|aaa', s)]; print()

# aa aa aa aa aa aa

[print(x.group(0), end=' ') for x in re.finditer('aaa|aa', s)]; print()

# aa aaa aaa aaa aa

'aa|aaa'とした場合以下の順番でマッチしていく。

"a,|aa|,|aa|a,aaaa,aaaaa"
"a,|aa|,|aa|a,|aa|aa,aaaaa"
"a,|aa|,|aa|a,|aa|aa|,aaaaa"
"a,|aa|,|aa|a,|aa|aa|,|aa|aaa"
"a,|aa|,|aa|a,|aa|aa|,|aa|aa|a"

'aaa|aa'とした場合は以下の順番でマッチしていく

"a,|aa|,aaa,aaaa,aaaaa"
"a,|aa|,|aaa|,aaaa,aaaaa"
"a,|aa|,|aaa|,|aaa|a,aaaaa"
"a,|aa|,|aaa|,|aaa|a,aaaaa"
"a,|aa|,|aaa|,|aaa|a,|aaa|aa"
"a,|aa|,|aaa|,|aaa|a,|aaa|aa|"

つまり、各マッチングの段階で選択演算子'|'の左側からマッチする部分をまず探し、該当しなければ演算子の右へと判定パターンを変えていく。

このため、演算子の左のパターンが右のパターンより短いと、先にそちらがマッチングされるので右の長いパターンがマッチしなくなることがある。

この動作は、正規表現オブジェクトのメソッドについても同じ。

import re

s = "a,aa,aaa,aaaa,aaaaa"

matchobj1 = re.compile(r'aa|aaa')
matchobj2 = re.compile(r'aaa|aa')

print(matchobj1.findall(s))
# ['aa', 'aa', 'aa', 'aa', 'aa', 'aa']

print(matchobj2.findall(s))
# ['aa', 'aaa', 'aaa', 'aaa', 'aa']

[print(x.group(0), end=' ') for x in matchobj1.finditer(s)]; print()
# aa aa aa aa aa aa

[print(x.group(0), end=' ') for x in matchobj2.finditer(s)]; print()
# aa aaa aaa aaa aa

import re

s = "a,aa,aaa,aaaa,aaaaa"

matchobj1 = re.compile(r'aa|aaa')

matchobj2 = re.compile(r'aaa|aa')

print(matchobj1.findall(s))

# ['aa', 'aa', 'aa', 'aa', 'aa', 'aa']

print(matchobj2.findall(s))

# ['aa', 'aaa', 'aaa', 'aaa', 'aa']

[print(x.group(0), end=' ') for x in matchobj1.finditer(s)]; print()

# aa aa aa aa aa aa

[print(x.group(0), end=' ') for x in matchobj2.finditer(s)]; print()

# aa aaa aaa aaa aa

Python3 – 正規表現 – エスケープとraw文字列

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

エスケープの問題

正規表現ではいくつかの文字がパターンとしての特別の意味を持つが、その文字そのものをマッチングの対象としたいときにはバックスラッシュ(\）でエスケープする。

import re

s = "Does it work?"
print(re.search("\?", s))

# <_sre.SRE_Match object; span=(12, 13), match='?'>

import re

s = "Does it work?"

print(re.search("\?", s))

# <_sre.SRE_Match object; span=(12, 13), match='?'>

さらに検索対象の文字列にバックスラッシュが含まれている場合には、バックスラッシュ自身をエスケープしなければならない(\\)。このようなケースは、ファイルパスの区切りにバックスラッシュが使われている場合やLATexの\begin～\endなど多くある。

下の例は”\bigin”という文字列を検索する場合。

import re

s = "\\begin"
print(s)
print(re.search("\begin", s))
print(re.search("\\begin", s))
print(re.search("\\\\begin", s))

# \begin
# None
# None
# <_sre.SRE_Match object; span=(0, 6), match='\\begin'>

import re

s = "\\begin"

print(s)

print(re.search("\begin", s))

print(re.search("\\begin", s))

print(re.search("\\\\begin", s))

# \begin

# None

# <_sre.SRE_Match object; span=(0, 6), match='\\begin'>

検索される側の文字列のバックスラッシュをエスケープしなければならない(3行目)
- その文字列をprintしてみると意図した内容になっている(4行目と9行目)
次にパターン文字の方で、”\begin”とそのまま試してみるとヒットしない(5行目と10行目)
- これは最初の”\b”がPythonのエスケープシーケンス(バックスペース)として解釈されたため
そこでバックスラッシュをエスケープしてもヒットしない(6行目と11行目)
- Pythonでは文字としてのバックスラッシュとして解釈されるが、今度は正規表現として解釈したとき単独の特殊文字としての’\’となるため
2つのバックスラッシュそれぞれをエスケープするようにしてやっとヒットさせることができる(7行目と11行目)

raw文字列

Pythonでは、バックスラッシュを単なる文字として解釈するためのraw文字列が組み込まれていて、文字列リテラルの前に’r’か’R’を付けるだけでよい。”””で囲まれた複数行文字列でも同じ。

print("Hello\nPython")
# Hello
# Python

print(r"Hello\nPython")
# Hello\nPython

print("""abcd\nefgh
ijkl\nmnop""")
# abcd
# efgh
# ijkl
# mnop

print(r"""abcd\nefgh
ijkl\nmnop""")
# abcd\nefgh
# ijkl\nmnop

print("Hello\nPython")

# Hello

# Python

print(r"Hello\nPython")

# Hello\nPython

print("""abcd\nefgh

ijkl\nmnop""")

# abcd

# efgh

# ijkl

# mnop

print(r"""abcd\nefgh

ijkl\nmnop""")

# abcd\nefgh

# ijkl\nmnop

また、Python3で文字列変数の文字列をraw文字列に変換するには、repr()関数を使う。ただしその結果はシングルクォートで囲まれているため、それを取り除かなくてはいけない。

s = "Hello\nPython"
print(s)
# Hello
# Python

print(repr(s))
# 'Hello\nPython'

print(repr(s)[1:-2])
# Hello\nPytho

s = "Hello\nPython"

print(s)

# Hello

# Python

print(repr(s))

# 'Hello\nPython'

print(repr(s)[1:-2])

# Hello\nPytho

また複数行文字列の場合は、リテラルでのr指定と変数へのrepr()適用で結果が異なってくる。

s = """abc\ndef
ghi\njkl"""

print(s)
# abc
# def
# ghi
# jkl

print(repr(s))
# 'abc\ndef\nghi\njkl'

s = r"""ABC\nDEF

GHI\nJKL"""
print(s)
# ABC\nDEF
# GHI\nJKL

print(repr(s))
# 'ABC\\nDEF\nGHI\\nJKL'

s = """abc\ndef

ghi\njkl"""

print(s)

# abc

# def

# ghi

# jkl

print(repr(s))

# 'abc\ndef\nghi\njkl'

s = r"""ABC\nDEF

GHI\nJKL"""

print(s)

# ABC\nDEF

# GHI\nJKL

print(repr(s))

# 'ABC\\nDEF\nGHI\\nJKL'

Python3 – 正規表現 – MatchObject

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

概要

search()などのreモジュール関数や正規表現オブジェクトメソッドが実行の結果マッチした場合に、MatchObjectオブジェクトが返される。以下、MatchObjectのオブジェクトをmatchオブジェクトと表現する。matchオブジェクトは常にブール値Trueを持ち、matchオブジェクトそのものを判定式に使ってマッチしたかどうかの判定ができる。

match = re.search(pattern, string)
if match:
    # マッチした場合の処理
else:
    # マッチしなかった場合の処理

match = re.search(pattern, string)

if match:

# マッチした場合の処理

else:

# マッチしなかった場合の処理

matchオブジェクトの文字列表現には、(最初に)ヒットした場所の範囲と、マッチした内容が含まれている。

import re

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

print(re.search(r"in", s))
# <_sre.SRE_Match object; span=(6, 8), match='in'>

import re

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

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

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

正規表現・文字列情報

re

match.re

matchを生成した正規表現オブジェクト。

string

match.string

matchを生成したsearch()、match()へ渡された文字列。

import re

match = re.search(r'\b\w{4}\b', "The rain in Spain")
print(match.string)
# The rain in Spain
print(match.re)
# re.compile('\\b\\w{4}\\b')

import re

match = re.search(r'\b\w{4}\b', "The rain in Spain")

print(match.string)

# The rain in Spain

print(match.re)

# re.compile('\\b\\w{4}\\b')

グループ指定しない場合のマッチング結果

group()、start()、end()、span()

match.group()、match.start()、match.end()、match.span()

group（）はマッチした部分文字列、start()とend()はマッチした部分文字列の開始位置と終了位置、span()は(開始位置, 終了位置)のタプル。

import re
match = re.search(r'in', "The rain in Spain")
print(match.group()) # in
print(match.start()) # 6
print(match.end())   # 8
print(match.span())  # (6, 8)

import re

match = re.search(r'in', "The rain in Spain")

print(match.group()) # in

print(match.start()) # 6

print(match.end()) # 8

print(match.span()) # (6, 8)

グループ指定した場合のマッチング結果

group()

match.group()、match.group([group1, ...])

引数がない場合は、マッチしたもの全てが返される。引数がある場合はグループを指定(数字のほかグループ名でも可)。

groups()

match.groups()

マッチしたグループを要素とするタプルとする。

lastindex

match.lastindex

複数グループの最終インデックス。

import re

match = re.search(r'(\w+) (\w+)', "The rain in Spain")
print(match.group())   # The rain
print(match.groups())  # ('The', 'rain')
print(match.lastindex) # 2
print(match.group(0))  # The rain
print(match.group(1))  # The
print(match.group(2))  # rain

import re

match = re.search(r'(\w+) (\w+)', "The rain in Spain")

print(match.group()) # The rain

print(match.groups()) # ('The', 'rain')

print(match.lastindex) # 2

print(match.group(0)) # The rain

print(match.group(1)) # The

print(match.group(2)) # rain

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

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

ここでは正規表現の操作に使われるモジュール定数を整理する。

re.A/re. ASCII

\b、\B、\d、\D、\s、\S、\w、\Wにおいて、ASCII文字のみでマッチングを行う。Unicodeパターンでのみ意味があり、バイト列パターンでは無視される。

import re

ptn = r'\b\w+\b'
regex_obj = re.compile(ptn)
regex_obj_ascii = re.compile(ptn, flags=re.ASCII)

s = "プログラミング言語Python"
print(regex_obj.findall(s))
# ['プログラミング言語Python']
print(regex_obj_ascii.findall(s))
# ['Python']

s = "プログラミング言語　Python"
print(regex_obj.findall(s))
# ['プログラミング言語', 'Python']
print(regex_obj_ascii.findall(s))
# ['Python']

import re

ptn = r'\b\w+\b'

regex_obj = re.compile(ptn)

regex_obj_ascii = re.compile(ptn, flags=re.ASCII)

s = "プログラミング言語Python"

print(regex_obj.findall(s))

# ['プログラミング言語Python']

print(regex_obj_ascii.findall(s))

# ['Python']

s = "プログラミング言語　Python"

print(regex_obj.findall(s))

# ['プログラミング言語', 'Python']

print(regex_obj_ascii.findall(s))

# ['Python']

re.I/re.IGNORECASE

英大文字・小文字を区別せずにマッチングを行う。{A-Z]のような表現で小文字ともマッチする。現在のロケールに影響を受けず、Unicode文字に対しても動作する。

import re

s = "abc DEF"
print(re.findall(r'\b[A-Z]+\b', s))
# ['DEF']
print(re.findall(r'\b[A-Z]+\b', s, flags=re.IGNORECASE))
# ['abc', 'DEF']

s = "abc DEF ｇｅｈ ＩＪＫ"
print(re.findall(r'\b[A-ZＡ-Ｚ]+\b', s))
# ['DEF', 'ＩＪＫ']
print(re.findall(r'\b[A-ZＡ-Ｚ]+\b', s, flags=re.IGNORECASE))
# ['abc', 'DEF', 'ｇｅｈ', 'ＩＪＫ']

import re

s = "abc DEF"

print(re.findall(r'\b[A-Z]+\b', s))

# ['DEF']

print(re.findall(r'\b[A-Z]+\b', s, flags=re.IGNORECASE))

# ['abc', 'DEF']

s = "abc DEF ｇｅｈＩＪＫ"

print(re.findall(r'\b[A-ZＡ-Ｚ]+\b', s))

# ['DEF', 'ＩＪＫ']

print(re.findall(r'\b[A-ZＡ-Ｚ]+\b', s, flags=re.IGNORECASE))

# ['abc', 'DEF', 'ｇｅｈ', 'ＩＪＫ']

re.L/re.LOCALE

\b、\B、\s、\S、\w、\Wにおいて、現在のロケールに従ったマッチングを行う。バイト列でのみ意味を持つ。非推奨。

re.M/re.MULTILINE

デフォルトでは'^'は文字列全体の先頭に、'$'は文字列全体の末尾にのみマッチするが、このフラグにより、'^'は文字列の先頭と各行の先頭(各改行の直後)、'$'は文字列の末尾と各行の末尾(各改行のの直前)とマッチする。

import re

s = """Love the life you live.
Live the life you love."""

print(re.findall(r'^L\w*', s))
# ['Love']
print(re.findall(r'\w*e.$', s))
# ['love.']

print(re.findall(r'^L\w*', s, flags=re.MULTILINE))
# ['Love', 'Live']
print(re.findall(r'\w*e.$', s, flags=re.MULTILINE))
# ['live.', 'love.']

import re

s = """Love the life you live.

Live the life you love."""

print(re.findall(r'^L\w*', s))

# ['Love']

print(re.findall(r'\w*e.$', s))

# ['love.']

print(re.findall(r'^L\w*', s, flags=re.MULTILINE))

# ['Love', 'Live']

print(re.findall(r'\w*e.$', s, flags=re.MULTILINE))

# ['live.', 'love.']

re.S/re.DOTALL

デフォルトでは'.'は改行にマッチしないが、このフラグにより'.'を改行を含む任意の文字とマッチさせる。

import re

s = """Love the life you live.
Live the life you love."""

print(re.findall(r'.+', s))
['Love the life you live.', 'Live the life you love.']

print(re.findall(r'.+', s, flags=re.DOTALL))
['Love the life you live.\nLive the life you love.']

import re

s = """Love the life you live.

Live the life you love."""

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

['Love the life you live.', 'Live the life you love.']

print(re.findall(r'.+', s, flags=re.DOTALL))

['Love the life you live.\nLive the life you love.']

re.X/re.VERBOSE

このフラグにより、パターン文字列内に改行・インデントを入れたりコメントを入れるなど、より読みやすい正規表現を書くことができる。コメントには'#'を使う。

Python3 – 正規表現 – 正規表現オブジェクトメソッド

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

概要

reモジュールではre.RegexObjectクラスが定義されている。パターン文字列をコンパイルするとRegexObjectのオブジェクトが生成され、そのパターンはそのプロパティとして保持される。このクラスの各メソッドで、パターンを任意のテキストに適用する。

reモジュール関数を使う場合は実行のたびにパターン文字列とフラグを指定し、その都度コンパイルされる。一方、正規表現オブジェクトのメソッドを使う場合は、一度パターンをコンパイルしておけば、その後の操作でコンパイルのオーバーヘッドが生じない。フラグはコンパイル時に指定する。

import re

regex = re.compile(r'life')

print(regex.search("Love the life you live."))
# <_sre.SRE_Match object; span=(9, 13), match='life'>

print(regex.search("Live the life you love."))
# <_sre.SRE_Match object; span=(9, 13), match='life'>

import re

regex = re.compile(r'life')

print(regex.search("Love the life you live."))

# <_sre.SRE_Match object; span=(9, 13), match='life'>

print(regex.search("Live the life you love."))

# <_sre.SRE_Match object; span=(9, 13), match='life'>

パターンの検索

search()

regex.search(string,[ pos[, endpos]])

re.search()関数と同じ機能で、stringの任意の位置で、最初にregexにマッチした時にMatchObjectのオブジェクトを返す。マッチしなければNoneを返す。

posは検索開始位置で先頭が0。デフォルト値は0で先頭から検索する。

endposは検索範囲の終了位置で、endpos-1文字目までが検索範囲となる。デフォルトでは文字列の最後まで検索する。

import re

regex1 = re.compile(r'ab')
regex2 = re.compile(r'cd')
regex3 = re.compile(r'ef')
s = r"abcdabcd"

print(re.search(regex1, s))
# <_sre.SRE_Match object; span=(0, 2), match='ab'>
print(re.search(regex2, s))
# <_sre.SRE_Match object; span=(2, 4), match='cd'>
print(re.search(regex3, s))
# None

print(regex1.search(s, 2))
# <_sre.SRE_Match object; span=(4, 6), match='ab'>
print(regex1.search(s, 2, 5))
# None

import re

regex1 = re.compile(r'ab')

regex2 = re.compile(r'cd')

regex3 = re.compile(r'ef')

s = r"abcdabcd"

print(re.search(regex1, s))

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

print(re.search(regex2, s))

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

print(re.search(regex3, s))

# None

print(regex1.search(s, 2))

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

print(regex1.search(s, 2, 5))

# None

match()

regex.match(string[, pos[, endpos]])

re.match()関数と同じ機能で、regexがstringの先頭でマッチするときだけMatchObjectオブジェクトを返す。pos、endposはregex.search()と同じ意味。

import re

regex1 = re.compile(r'ab')
regex2 = re.compile(r'cd')
s = r"abcdabcd"

print(re.match(regex1, s))
# <_sre.SRE_Match object; span=(0, 2), match='ab'>
print(re.match(regex2, s))
# None

import re

regex1 = re.compile(r'ab')

regex2 = re.compile(r'cd')

s = r"abcdabcd"

print(re.match(regex1, s))

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

print(re.match(regex2, s))

# None

fullmatch()

regex.fullmatch(string[, pos[, endpos]])

re.fullmatch()関数と同じ機能で、regexがstring全体にマッチするときだけMatchObjectオブジェクトを返す。pos、endposはregex.search()と同じ意味。

import re

s = r"abcdabcd"

regex = re.compile(r'abcdabcd')
print(re.fullmatch(regex, s))
# <_sre.SRE_Match object; span=(0, 8), match='abcdabcd'>

regex = re.compile(r'abcd')
print(re.fullmatch(regex, s))
# None

regex = re.compile(r'.*')
print(re.fullmatch(regex, s))
# <_sre.SRE_Match object; span=(0, 8), match='abcdabcd'>

regex = re.compile(r'.{5}')
print(re.fullmatch(regex, s))
# None

import re

s = r"abcdabcd"

regex = re.compile(r'abcdabcd')

print(re.fullmatch(regex, s))

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

regex = re.compile(r'abcd')

print(re.fullmatch(regex, s))

# None

regex = re.compile(r'.*')

print(re.fullmatch(regex, s))

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

regex = re.compile(r'.{5}')

print(re.fullmatch(regex, s))

# None

findall()

regex.findall(string[, pos[, endpos]])

re.findall()関数と同じ機能でregexにマッチする部分列のリストを返す。pos、endposはregex.search()と同じ意味。

import re

s = r"abcdabcd"

regex = re.compile(r'ab')
print(regex.findall(s))
# ['ab', 'ab']

regex = re.compile(r'ef')
print(regex.findall(s))
# []

regex = re.compile(r'.{3}')
print(regex.findall(s))
# ['abc', 'dab']

import re

s = r"abcdabcd"

regex = re.compile(r'ab')

print(regex.findall(s))

# ['ab', 'ab']

regex = re.compile(r'ef')

print(regex.findall(s))

# []

regex = re.compile(r'.{3}')

print(regex.findall(s))

# ['abc', 'dab']

finditer()

regex.finditer(string[, pos[, endpos]])

re.finditer()関数と同じ機能で、regexにマッチする部分列のイテレータを返す。pos、endposはsearch()と同じ意味。

import re

s = r"abcdabcd"

regex = re.compile(r'ab')
[print(x) for x in regex.finditer(s)]
# <_sre.SRE_Match object; span=(0, 2), match='ab'>
# <_sre.SRE_Match object; span=(4, 6), match='ab'>

regex = re.compile(r'ef')
[print(x) for x in regex.finditer(s)]
# 空のイテレータ

regex = re.compile(r'.{3}')
[print(x) for x in regex.finditer(s)]
# <_sre.SRE_Match object; span=(0, 3), match='abc'>
# <_sre.SRE_Match object; span=(3, 6), match='dab'>

regex = re.compile(r'ab')
[print(x) for x in regex.finditer(s, 2, 6)]
# <_sre.SRE_Match object; span=(4, 6), match='ab'>

import re

s = r"abcdabcd"

regex = re.compile(r'ab')

[print(x) for x in regex.finditer(s)]

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

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

regex = re.compile(r'ef')

[print(x) for x in regex.finditer(s)]

# 空のイテレータ

regex = re.compile(r'.{3}')

[print(x) for x in regex.finditer(s)]

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

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

regex = re.compile(r'ab')

[print(x) for x in regex.finditer(s, 2, 6)]

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

分割

split()

regex.split(string, maxsplit=0)

re.split()関数と同じ機能で、regexにマッチする部分列でstringを切り分ける。pos、endposはsearch()と同じ意味。

置換

sub()

regex.sub(repl, string, count=0)

re.sub()関数と同じ機能でstring中のregexにマッチする部分をreplで置き換える。replには文字列を返す関数も指定可能。pos、endposはsearch()と同じ意味。

subn()

regex.subn(repl, string, count=0)

re.subn()関数と同じ機能で、置換後にタプルで(置換後の文字列, 置換数)を返す。pos、endposはsearch()と同じ意味。