>>> 10*(1/0)Traceback (most recent call last):
File "<stdin>", line 1, in ?ZeroDivisionError: integer division or modulo by zero>>> 4+spam*3Traceback (most recent call last):
File "<stdin>", line 1, in ?NameError: name 'spam' is not defined>>> '2'+2Traceback (most recent call last):
File "<stdin>", line 1, in ?TypeError: cannot concatenate 'str' and 'int' objects
>>> whileTrue:... try:... x=int(raw_input("Please enter a number: "))... break... exceptValueError:... print"Oops! That was no valid number. Try again..."...
importsystry:f=open('myfile.txt')s=f.readline()i=int(s.strip())exceptIOErroras(errno,strerror):print"I/O error({0}): {1}".format(errno,strerror)exceptValueError:print"Could not convert data to an integer."except:print"Unexpected error:",sys.exc_info()[0]raise
classError(Exception):"""Base class for exceptions in this module."""passclassInputError(Error):"""Exception raised for errors in the input. Attributes: expression -- input expression in which the error occurred message -- explanation of the error """def__init__(self,expression,message):self.expression=expressionself.message=messageclassTransitionError(Error):"""Raised when an operation attempts a state transition that's not allowed. Attributes: previous -- state at beginning of transition next -- attempted new state message -- explanation of why the specific transition is not allowed """def__init__(self,previous,next,message):self.previous=previousself.next=nextself.message=message
>>> importtextwrap>>> doc="""The wrap() method is just like fill() except that it returns... a list of strings instead of one big string with newlines to separate... the wrapped lines."""...>>> printtextwrap.fill(doc,width=40)The wrap() method is just like fill()except that it returns a list of stringsinstead of one big string with newlinesto separate the wrapped lines.
>>> importlocale>>> locale.setlocale(locale.LC_ALL,'English_United States.1252')'English_United States.1252'>>> conv=locale.localeconv()# get a mapping of conventions>>> x=1234567.8>>> locale.format("%d",x,grouping=True)'1,234,567'>>> locale.format("%s%.*f",(conv['currency_symbol'],... conv['frac_digits'],x),grouping=True)'$1,234,567.80'
+The struct module provides pack() and unpack() functions for
+working with variable length binary record formats. The following example shows
+how to loop through header information in a ZIP file without using the
+:mod:zipfile module. Pack codes "H" and "I" represent two and four
+byte unsigned numbers respectively. The "<" indicates that they are
+standard size and in little-endian byte order
importstructdata=open('myfile.zip','rb').read()start=0foriinrange(3):# show the first 3 file headersstart+=14fields=struct.unpack('<IIIHH',data[start:start+16])crc32,comp_size,uncomp_size,filenamesize,extra_size=fieldsstart+=16filename=data[start:start+filenamesize]start+=filenamesizeextra=data[start:start+extra_size]printfilename,hex(crc32),comp_size,uncomp_sizestart+=extra_size+comp_size# skip to the next header
importthreading,zipfileclassAsyncZip(threading.Thread):def__init__(self,infile,outfile):threading.Thread.__init__(self)self.infile=infileself.outfile=outfiledefrun(self):f=zipfile.ZipFile(self.outfile,'w',zipfile.ZIP_DEFLATED)f.write(self.infile)f.close()print'Finished background zip of: ',self.infilebackground=AsyncZip('mydata.txt','myarchive.zip')background.start()print'The main program continues to run in foreground.'background.join()# Wait for the background task to finishprint'Main program waited until background was done.'
>>> importweakref,gc>>> classA:... def__init__(self,value):... self.value=value... def__repr__(self):... returnstr(self.value)...>>> a=A(10)# create a reference>>> d=weakref.WeakValueDictionary()>>> d['primary']=a# does not create a reference>>> d['primary']# fetch the object if it is still alive10>>> dela# remove the one reference>>> gc.collect()# run garbage collection right away0>>> d['primary']# entry was automatically removedTraceback (most recent call last):
File "<stdin>", line 1, in <module>d['primary']# entry was automatically removed
File "C:/python26/lib/weakref.py", line 46, in __getitem__o=self.data[key]()KeyError: 'primary'
>>> fromcollectionsimportdeque>>> d=deque(["task1","task2","task3"])>>> d.append("task4")>>> print"Handling",d.popleft()Handling task1unsearched = deque([starting_node])def breadth_first_search(unsearched): node = unsearched.popleft() for m in gen_moves(node): if is_goal(m): return m unsearched.append(m)
>>> fromheapqimportheapify,heappop,heappush>>> data=[1,3,5,7,9,2,4,6,8,0]>>> heapify(data)# rearrange the list into heap order>>> heappush(data,-5)# add a new entry>>> [heappop(data)foriinrange(3)]# fetch the three smallest entries[-5, 0, 1]
>>> 'spam eggs''spam eggs'>>> 'doesn\'t'"doesn't">>> "doesn't""doesn't">>> '"Yes," he said.''"Yes," he said.'>>> "\"Yes,\" he said."'"Yes," he said.'>>> '"Isn\'t," she said.''"Isn\'t," she said.'
hello="This is a rather long string containing\n\several lines of text just as you would do in C.\n\ Note that whitespace at the beginning of the line is\ significant."printhello
This is a rather long string containing
several lines of text just as you would do in C.
Note that whitespace at the beginning of the line is significant.
>>> u"abc"u'abc'>>> u"あいう"u'\x82\xa0\x82\xa2\x82\xa4'>>> str(u"あいう")Traceback (most recent call last):
File "<stdin>", line 1, in ?UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-5:ordinal not in range(128)
re モジュールでは、より高度な文字列処理のための正規表現
(regular expression) を提供しています。
正規表現は複雑な一致検索や操作に対して簡潔で最適化された解決策を与えます:
>>> importre>>> re.findall(r'\bf[a-z]*','which foot or hand fell fastest')['foot', 'fell', 'fastest']>>> re.sub(r'(\b[a-z]+) \1',r'\1','cat in the the hat')'cat in the hat'
最小限の機能だけが必要なら、読みやすくデバッグしやすい文字列メソッドの方がお勧めです:
>>> 'tea for too'.replace('too','two')'tea for two'
# dates are easily constructed and formatted
>>> from datetime import date
>>> now = date.today()
>>> now
datetime.date(2003, 12, 2)
>>> now.strftime("%m-%d-%y. %d %b %Y is a %A on the %d day of %B")
'12-02-03. 02 Dec 2003 is a Tuesday on the 02 day of December'
# dates support calendar arithmetic
>>> birthday = date(1964, 7, 31)
>>> age = now - birthday
>>> age.days
14368
>>> importzlib>>> s='witch which has which witches wrist watch'>>> len(s)41>>> t=zlib.compress(s)>>> len(t)37>>> zlib.decompress(t)'witch which has which witches wrist watch'>>> zlib.crc32(s)226805979
defaverage(values):"""Computes the arithmetic mean of a list of numbers. >>> print average([20, 30, 70]) 40.0 """returnsum(values,0.0)/len(values)importdoctestdoctest.testmod()# automatically validate the embedded tests
importunittestclassTestStatisticalFunctions(unittest.TestCase):deftest_average(self):self.assertEqual(average([20,30,70]),40.0)self.assertEqual(round(average([1,5,7]),1),4.3)self.assertRaises(ZeroDivisionError,average,[])self.assertRaises(TypeError,average,20,30,70)unittest.main()# Calling from the command line invokes all tests
2 進の浮動小数点数に対する算術演算は、このような意外性をたくさん持っています。”0.1” に関する問題は、以下の “表現エラー” の章で詳細に説明します。
2 進法の浮動小数点演算にともなうその他のよく知られた意外な事象に関しては The Perils of Floating Point を参照してください。
class Reverse:
"Iterator for looping over a sequence backwards"
def __init__(self, data):
self.data = data
self.index = len(data)
def __iter__(self):
return self
def next(self):
if self.index == 0:
raise StopIteration
self.index = self.index - 1
return self.data[self.index]
>>> for char in Reverse('spam'):
... print char
...
m
a
p
s
http://www.python.org: メインの Python Web サイト。このサイトには、コード、ドキュメント、そして Web
のあちこちの Python に関連したページへのポインタがあります。この Web サイトは世界のあちこちのさまざまな場所、例えばヨーロッパ、
日本、オーストラリアなどでミラーされています。地理的な位置によっては、メインのサイトよりミラーのほうが速いかもしれません。
>>> s='Hello, world.'>>> str(s)'Hello, world.'>>> repr(s)"'Hello, world.'">>> str(0.1)'0.1'>>> repr(0.1)'0.10000000000000001'>>> x=10*3.25>>> y=200*200>>> s='The value of x is '+repr(x)+', and y is '+repr(y)+'...'>>> printsThe value of x is 32.5, and y is 40000...>>> # 文字列への repr() はクォートとバックスラッシュが付加される:... hello='hello, world\n'>>> hellos=repr(hello)>>> printhellos'hello, world\n'>>> # repr() の引数は Python オブジェクトの場合もある:... repr((x,y,('spam','eggs')))"(32.5, 40000, ('spam', 'eggs'))"
>>> print'This {food} is {adjective}.'.format(... food='spam',adjective='absolutely horrible')This spam is absolutely horrible.
順序引数とキーワード引数を組み合わせて使うこともできます。
>>> print'The story of {0}, {1}, and {other}.'.format('Bill','Manfred',... other='Georg')The story of Bill, Manfred, and Georg.
An optional ':' and format specifier can follow the field name. This also
greater control over how the value is formatted. The following example
truncates the Pi to three places after the decimal.
# vi スタイルの編集を選択する:
set editing-mode vi
# 一行だけを使って編集する:
set horizontal-scroll-mode On
# いくつかのキーを再束縛する:
Meta-h: backward-kill-word
"\C-u": universal-argument
"\C-x\C-r": re-read-init-file
より良くできたスタートアップファイルは以下例のようになります。
この例では、作成した名前が不要になると削除されるのに注目してください。
これは、スタートアップファイルが対話コマンドと同じ名前空間で実行されているので、
不要な名前を除去して対話環境に副作用を生まないようにするためです。
import されたモジュールのうち、 os のようなインタプリタのほとんどのセッションで
必要なものについては、残しておくと便利に思うかもしれません。
# Add auto-completion and a stored history file of commands to your Python# interactive interpreter. Requires Python 2.0+, readline. Autocomplete is# bound to the Esc key by default (you can change it - see readline docs).## Store the file in ~/.pystartup, and set an environment variable to point# to it, e.g. "export PYTHONSTARTUP=/home/user/.pystartup" in bash.## Note that PYTHONSTARTUP does *not* expand "~", so you have to put in the# full path to your home directory.importatexitimportosimportreadlineimportrlcompleterhistoryPath=os.path.expanduser("~/.pyhistory")defsave_history(historyPath=historyPath):importreadlinereadline.write_history_file(historyPath)ifos.path.exists(historyPath):readline.read_history_file(historyPath)atexit.register(save_history)delos,atexit,readline,rlcompleter,save_history,historyPath
標準のオブジェクトやモジュールの記述については、
「Python ライブラリリファレンス (Python Library Reference)」を参照してください。
C 言語や C++ 言語で拡張モジュールを書くなら、「Python インタプリタの拡張と埋め込み
(Extending and Embedding the Python Interpreter)」や
「Python/C API リファレンス (Python/C API Reference)」を参照してください。
他にも、 Python について広く深くカバーしている書籍はいくつかあります。
リストから要素を削除する際、値を指定する代わりにインデックスを指定する方法があります: それが del
文です。これは pop() メソッドとちがい、値を返しません。
del 文はリストからスライスを除去したり、リスト全体を削除することもできます (以前はスライスに空のリストを代入して行っていました)。例えば以下のようにします:
辞書は順序付けのされていない キー(key): 値(value) のペアからなり、キーが (辞書の中で)
一意でければならない、と考えると最もよいでしょう。波括弧 (brace) のペア: {} は空の辞書を生成します。カンマで区切られた key:
value のペアを波括弧ペアの間に入れると、辞書の初期値となる key: value が追加されます; この表現方法は出力時に辞書が書き出されるのと同じ方法です。
辞書での主な操作は、ある値を何らかのキーを付けて記憶することと、キーを指定して値を取り出すことです。 del で key: value のペアを
削除することもできます。すでに使われているキーを使って値を記憶すると、以前そのキーに関連づけられていた値は忘れ去られてしまいます。存在しないキーを使って
値を取り出そうとするとエラーになります。
辞書オブジェクトの keys() メソッドは、辞書で使われている全てのキーからなるリストを適当な順番で返します (リストをソート
したいなら、このキーのリストに sort() を使ってください)。ある単一のキーが辞書にあるかどうか調べるには、 in キーワードを使います。
>>> questions=['name','quest','favorite color']>>> answers=['lancelot','the holy grail','blue']>>> forq,ainzip(questions,answers):... print'What is your {0}? It is {1}.'.format(q,a)...What is your name? It is lancelot.What is your quest? It is the holy grail.What is your favorite color? It is blue.
while や if 文で使った条件 (condiction) には、値の比較だけでなく、他の演算子も使うことができます、
比較演算子 in および notin は、ある値があるシーケンス中に存在するか (または存在しないか) どうかを調べます。演算子
is および isnot は、二つのオブジェクトが実際に同じオブジェクトであるかどうかを調べます; この比較は、リストのような変更可能なオブジェクトにだけ意味があります。全ての比較演算子は同じ優先順位を持っており、ともに数値演算子よりも低い優先順位となります。
比較は連鎖 (chain) させることができます。例えば、 a<b==c は、 a が b より小さく、かつ b と
c が等しいかどうか、をテストします。
比較演算はブール演算子 and や or で組み合わせられます。また、比較演算 (あるいは何らかのブール式) の結果の否 (negate)
は not でとれます。これらの演算子は全て、比較演算子よりも低い優先順位になっています。 AandnotBorC と (Aand(notB))orC``が等価になるように、ブール演算子の中で、 not `` の優先順位が最も高く、`` or`` が最も
低くなっています。もちろん、丸括弧を使えば望みの組み合わせを表現できます。
ブール演算子 and と or は、いわゆる 短絡 (short-circuit) 演算子です: これらの演算子の引数は
左から右へと順に評価され、結果が確定した時点で評価を止めます。例えば、 A と C は真で B が偽のとき、 AandBandC``は式``C を評価しません。一般に、短絡演算子の戻り値をブール値ではなくて一般的な値として用いると、値は最後に評価された引数になります。
>>> x=int(raw_input("Please enter an integer: "))Please enter an integer: 42>>> ifx<0:... x=0... print'Negative changed to zero'... elifx==0:... print'Zero'... elifx==1:... print'Single'... else:... print'More'...More
>>> forninrange(2,10):... forxinrange(2,n):... ifn%x==0:... printn,'equals',x,'*',n/x... break... else:... # 因数が見つからずにループが終了... printn,'is a prime number'...2 is a prime number3 is a prime number4 equals 2 * 25 is a prime number6 equals 2 * 37 is a prime number8 equals 2 * 49 equals 3 * 3
>>> deffib2(n):# n までのフィボナッチ級数を返す... """Return a list containing the Fibonacci series up to n."""... result=[]... a,b=0,1... whileb<n:... result.append(b)# 下記参照... a,b=b,a+b... returnresult...>>> f100=fib2(100)# 関数を呼び出す>>> f100# 結果を出力する[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
defask_ok(prompt,retries=4,complaint='Yes or no, please!'):whileTrue:ok=raw_input(prompt)ifokin('y','ye','yes'):returnTrueifokin('n','no','nop','nope'):returnFalseretries=retries-1ifretries<0:raiseIOError,'refusenik user'printcomplaint
defparrot(voltage,state='a stiff',action='voom',type='Norwegian Blue'):print"-- This parrot wouldn't",action,print"if you put",voltage,"volts through it."print"-- Lovely plumage, the",typeprint"-- It's",state,"!"
は、以下のいずれの方法でも呼び出せます:
parrot(1000)parrot(action='VOOOOOM',voltage=1000000)parrot('a thousand',state='pushing up the daisies')parrot('a million','bereft of life','jump')
defcheeseshop(kind,*arguments,**keywords):print"-- Do you have any",kind,"?"print"-- I'm sorry, we're all out of",kindforarginarguments:printargprint"-"*40keys=keywords.keys()keys.sort()forkwinkeys:printkw,":",keywords[kw]
のようにすると、呼び出しは以下:
cheeseshop("Limburger","It's very runny, sir.","It's really very, VERY runny, sir.",shopkeeper="Michael Palin",client="John Cleese",sketch="Cheese Shop Sketch")
のようになり、もちろん以下のように出力されます:
-- Do you have any Limburger ?
-- I'm sorry, we're all out of Limburger
It's very runny, sir.
It's really very, VERY runny, sir.
----------------------------------------
client : John Cleese
shopkeeper : Michael Palin
sketch : Cheese Shop Sketch
>>> defparrot(voltage,state='a stiff',action='voom'):... print"-- This parrot wouldn't",action,... print"if you put",voltage,"volts through it.",... print"E's",state,"!"...>>> d={"voltage":"four million","state":"bleedin' demised","action":"VOOM"}>>> parrot(**d)-- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !
>>> defmy_function():... """Do nothing, but document it....... No, really, it doesn't do anything.... """... pass...>>> printmy_function.__doc__Do nothing, but document it. No, really, it doesn't do anything.
Terms and conditions for accessing or otherwise using Python¶
PSF LICENSE AGREEMENT FOR PYTHON 2.6.2
This LICENSE AGREEMENT is between the Python Software Foundation (“PSF”), and
the Individual or Organization (“Licensee”) accessing and otherwise using Python
2.6.2 software in source or binary form and its associated documentation.
In the event Licensee prepares a derivative work that is based on or
incorporates Python 2.6.2 or any part thereof, and wants to make the
derivative work available to others as provided herein, then Licensee hereby
agrees to include in any such work a brief summary of the changes made to Python
2.6.2.
PSF is making Python 2.6.2 available to Licensee on an “AS IS” basis.
PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF
EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR
WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE
USE OF PYTHON 2.6.2 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON 2.6.2
FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF
MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 2.6.2, OR ANY DERIVATIVE
THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
This License Agreement will automatically terminate upon a material breach of
its terms and conditions.
Nothing in this License Agreement shall be deemed to create any relationship
of agency, partnership, or joint venture between PSF and Licensee. This License
Agreement does not grant permission to use PSF trademarks or trade name in a
trademark sense to endorse or promote products or services of Licensee, or any
third party.
By copying, installing or otherwise using Python 2.6.2, Licensee agrees
to be bound by the terms and conditions of this License Agreement.
BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0
BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1
This LICENSE AGREEMENT is between BeOpen.com (“BeOpen”), having an office at
160 Saratoga Avenue, Santa Clara, CA 95051, and the Individual or Organization
(“Licensee”) accessing and otherwise using this software in source or binary
form and its associated documentation (“the Software”).
Subject to the terms and conditions of this BeOpen Python License Agreement,
BeOpen hereby grants Licensee a non-exclusive, royalty-free, world-wide license
to reproduce, analyze, test, perform and/or display publicly, prepare derivative
works, distribute, and otherwise use the Software alone or in any derivative
version, provided, however, that the BeOpen Python License is retained in the
Software, alone or in any derivative version prepared by Licensee.
BeOpen is making the Software available to Licensee on an “AS IS” basis.
BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF
EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND DISCLAIMS ANY REPRESENTATION OR
WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE
USE OF THE SOFTWARE WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE SOFTWARE FOR
ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF USING,
MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY DERIVATIVE THEREOF, EVEN IF
ADVISED OF THE POSSIBILITY THEREOF.
This License Agreement will automatically terminate upon a material breach of
its terms and conditions.
This License Agreement shall be governed by and interpreted in all respects
by the law of the State of California, excluding conflict of law provisions.
Nothing in this License Agreement shall be deemed to create any relationship of
agency, partnership, or joint venture between BeOpen and Licensee. This License
Agreement does not grant permission to use BeOpen trademarks or trade names in a
trademark sense to endorse or promote products or services of Licensee, or any
third party. As an exception, the “BeOpen Python” logos available at
http://www.pythonlabs.com/logos.html may be used according to the permissions
granted on that web page.
By copying, installing or otherwise using the software, Licensee agrees to be
bound by the terms and conditions of this License Agreement.
CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1
This LICENSE AGREEMENT is between the Corporation for National Research
Initiatives, having an office at 1895 Preston White Drive, Reston, VA 20191
(“CNRI”), and the Individual or Organization (“Licensee”) accessing and
otherwise using Python 1.6.1 software in source or binary form and its
associated documentation.
In the event Licensee prepares a derivative work that is based on or
incorporates Python 1.6.1 or any part thereof, and wants to make the derivative
work available to others as provided herein, then Licensee hereby agrees to
include in any such work a brief summary of the changes made to Python 1.6.1.
CNRI is making Python 1.6.1 available to Licensee on an “AS IS” basis. CNRI
MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE,
BUT NOT LIMITATION, CNRI MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY
OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF
PYTHON 1.6.1 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON 1.6.1 FOR
ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF
MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1, OR ANY DERIVATIVE
THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
This License Agreement will automatically terminate upon a material breach of
its terms and conditions.
This License Agreement shall be governed by the federal intellectual property
law of the United States, including without limitation the federal copyright
law, and, to the extent such U.S. federal law does not apply, by the law of the
Commonwealth of Virginia, excluding Virginia’s conflict of law provisions.
Notwithstanding the foregoing, with regard to derivative works based on Python
1.6.1 that incorporate non-separable material that was previously distributed
under the GNU General Public License (GPL), the law of the Commonwealth of
Virginia shall govern this License Agreement only as to issues arising under or
with respect to Paragraphs 4, 5, and 7 of this License Agreement. Nothing in
this License Agreement shall be deemed to create any relationship of agency,
partnership, or joint venture between CNRI and Licensee. This License Agreement
does not grant permission to use CNRI trademarks or trade name in a trademark
sense to endorse or promote products or services of Licensee, or any third
party.
By clicking on the “ACCEPT” button where indicated, or by copying, installing
or otherwise using Python 1.6.1, Licensee agrees to be bound by the terms and
conditions of this License Agreement.
ACCEPT
CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted, provided that
the above copyright notice appear in all copies and that both that copyright
notice and this permission notice appear in supporting documentation, and that
the name of Stichting Mathematisch Centrum or CWI not be used in advertising or
publicity pertaining to distribution of the software without specific, written
prior permission.
STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE FOR ANY SPECIAL, INDIRECT
OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.
Licenses and Acknowledgements for Incorporated Software¶
This section is an incomplete, but growing list of licenses and acknowledgements
for third-party software incorporated in the Python distribution.
The _random module includes code based on a download from
http://www.math.keio.ac.jp/ matumoto/MT2002/emt19937ar.html . The following
are the verbatim comments from the original code:
A C-program for MT19937, with initialization improved 2002/1/26.
Coded by Takuji Nishimura and Makoto Matsumoto.
Before using, initialize the state by using init_genrand(seed)
or init_by_array(init_key, key_length).
Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. The names of its contributors may not be used to endorse or promote
products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Any feedback is very welcome.
http://www.math.keio.ac.jp/matumoto/emt.html
email: matumoto@math.keio.ac.jp
The socket module uses the functions, getaddrinfo(), and
getnameinfo(), which are coded in separate source files from the WIDE
Project, http://www.wide.ad.jp/.
Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the project nor the names of its contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
GAI_ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
FOR GAI_ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON GAI_ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN GAI_ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
The source for the fpectl module includes the following notice:
---------------------------------------------------------------------
/ Copyright (c) 1996. \
| The Regents of the University of California. |
| All rights reserved. |
| |
| Permission to use, copy, modify, and distribute this software for |
| any purpose without fee is hereby granted, provided that this en- |
| tire notice is included in all copies of any software which is or |
| includes a copy or modification of this software and in all |
| copies of the supporting documentation for such software. |
| |
| This work was produced at the University of California, Lawrence |
| Livermore National Laboratory under contract no. W-7405-ENG-48 |
| between the U.S. Department of Energy and The Regents of the |
| University of California for the operation of UC LLNL. |
| |
| DISCLAIMER |
| |
| This software was prepared as an account of work sponsored by an |
| agency of the United States Government. Neither the United States |
| Government nor the University of California nor any of their em- |
| ployees, makes any warranty, express or implied, or assumes any |
| liability or responsibility for the accuracy, completeness, or |
| usefulness of any information, apparatus, product, or process |
| disclosed, or represents that its use would not infringe |
| privately-owned rights. Reference herein to any specific commer- |
| cial products, process, or service by trade name, trademark, |
| manufacturer, or otherwise, does not necessarily constitute or |
| imply its endorsement, recommendation, or favoring by the United |
| States Government or the University of California. The views and |
| opinions of authors expressed herein do not necessarily state or |
| reflect those of the United States Government or the University |
| of California, and shall not be used for advertising or product |
\ endorsement purposes. /
---------------------------------------------------------------------
The source code for the md5 module contains the following notice:
Copyright (C) 1999, 2002 Aladdin Enterprises. All rights reserved.
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
L. Peter Deutsch
ghost@aladdin.com
Independent implementation of MD5 (RFC 1321).
This code implements the MD5 Algorithm defined in RFC 1321, whose
text is available at
http://www.ietf.org/rfc/rfc1321.txt
The code is derived from the text of the RFC, including the test suite
(section A.5) but excluding the rest of Appendix A. It does not include
any code or documentation that is identified in the RFC as being
copyrighted.
The original and principal author of md5.h is L. Peter Deutsch
<ghost@aladdin.com>. Other authors are noted in the change history
that follows (in reverse chronological order):
2002-04-13 lpd Removed support for non-ANSI compilers; removed
references to Ghostscript; clarified derivation from RFC 1321;
now handles byte order either statically or dynamically.
1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5);
added conditionalization for C++ compilation from Martin
Purschke <purschke@bnl.gov>.
1999-05-03 lpd Original version.
Copyright 1996 by Sam Rushing
All Rights Reserved
Permission to use, copy, modify, and distribute this software and
its documentation for any purpose and without fee is hereby
granted, provided that the above copyright notice appear in all
copies and that both that copyright notice and this permission
notice appear in supporting documentation, and that the name of Sam
Rushing not be used in advertising or publicity pertaining to
distribution of the software without specific, written prior
permission.
SAM RUSHING DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
NO EVENT SHALL SAM RUSHING BE LIABLE FOR ANY SPECIAL, INDIRECT OR
CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
Copyright 2000 by Timothy O'Malley <timo@alum.mit.edu>
All Rights Reserved
Permission to use, copy, modify, and distribute this software
and its documentation for any purpose and without fee is hereby
granted, provided that the above copyright notice appear in all
copies and that both that copyright notice and this permission
notice appear in supporting documentation, and that the name of
Timothy O'Malley not be used in advertising or publicity
pertaining to distribution of the software without specific, written
prior permission.
Timothy O'Malley DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS, IN NO EVENT SHALL Timothy O'Malley BE LIABLE FOR
ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
The profile and pstats modules contain the following notice:
Copyright 1994, by InfoSeek Corporation, all rights reserved.
Written by James Roskind
Permission to use, copy, modify, and distribute this Python software
and its associated documentation for any purpose (subject to the
restriction in the following sentence) without fee is hereby granted,
provided that the above copyright notice appears in all copies, and
that both that copyright notice and this permission notice appear in
supporting documentation, and that the name of InfoSeek not be used in
advertising or publicity pertaining to distribution of the software
without specific, written prior permission. This permission is
explicitly restricted to the copying and modification of the software
to remain in Python, compiled Python, or other languages (such as C)
wherein the modified or derived code is exclusively imported into a
Python module.
INFOSEEK CORPORATION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS. IN NO EVENT SHALL INFOSEEK CORPORATION BE LIABLE FOR ANY
SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
portions copyright 2001, Autonomous Zones Industries, Inc., all rights...
err... reserved and offered to the public under the terms of the
Python 2.2 license.
Author: Zooko O'Whielacronx
http://zooko.com/
mailto:zooko@zooko.com
Copyright 2000, Mojam Media, Inc., all rights reserved.
Author: Skip Montanaro
Copyright 1999, Bioreason, Inc., all rights reserved.
Author: Andrew Dalke
Copyright 1995-1997, Automatrix, Inc., all rights reserved.
Author: Skip Montanaro
Copyright 1991-1995, Stichting Mathematisch Centrum, all rights reserved.
Permission to use, copy, modify, and distribute this Python software and
its associated documentation for any purpose without fee is hereby
granted, provided that the above copyright notice appears in all copies,
and that both that copyright notice and this permission notice appear in
supporting documentation, and that the name of neither Automatrix,
Bioreason or Mojam Media be used in advertising or publicity pertaining to
distribution of the software without specific, written prior permission.
Copyright 1994 by Lance Ellinghouse
Cathedral City, California Republic, United States of America.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of Lance Ellinghouse
not be used in advertising or publicity pertaining to distribution
of the software without specific, written prior permission.
LANCE ELLINGHOUSE DISCLAIMS ALL WARRANTIES WITH REGARD TO
THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS, IN NO EVENT SHALL LANCE ELLINGHOUSE CENTRUM BE LIABLE
FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
Modified by Jack Jansen, CWI, July 1995:
- Use binascii module to do the actual line-by-line conversion
between ascii and binary. This results in a 1000-fold speedup. The C
version is still 5 times faster, though.
- Arguments more compliant with python standard
The xmlrpclib module contains the following notice:
The XML-RPC client interface is
Copyright (c) 1999-2002 by Secret Labs AB
Copyright (c) 1999-2002 by Fredrik Lundh
By obtaining, using, and/or copying this software and/or its
associated documentation, you agree that you have read, understood,
and will comply with the following terms and conditions:
Permission to use, copy, modify, and distribute this software and
its associated documentation for any purpose and without fee is
hereby granted, provided that the above copyright notice appears in
all copies, and that both that copyright notice and this permission
notice appear in supporting documentation, and that the name of
Secret Labs AB or the author not be used in advertising or publicity
pertaining to distribution of the software without specific, written
prior permission.
SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-
ABILITY AND FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR
BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
OF THIS SOFTWARE.
Copyright (c) 2001-2006 Twisted Matrix Laboratories.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
The select and contains the following notice for the kqueue interface:
Copyright (c) 2000 Doug White, 2006 James Knight, 2007 Christian Heimes
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
( expression for expr in sequence1
if condition1
for expr2 in sequence2
if condition2
for expr3 in sequence3 ...
if condition3
for exprN in sequenceN
if conditionN )
リスト内包表記も、外側の括弧が違うだけ (丸ではなく角括弧) で、あとは同じです。
生成される出力は expression 部分の値を要素として並べたものになります。
if 節はすべて、なくても大丈夫です; あれば condition が真のときだけ
expression が評価されて出力に追加されます。
partial のコンストラクタは
(関数,引数1,引数2,...キーワード引数1=既定値1,キーワード引数2=既定値2)
という引数を取ります。できあがったオブジェクトはコーラブルですので、それを
呼べば、引数の埋まった function を実行したのと同じことになります。
以下にあるのは、小さいけれども現実的な一つの例です:
importfunctoolsdeflog(message,subsystem):"Write the contents of 'message' to the specified subsystem."print'%s: %s'%(subsystem,message)...server_log=functools.partial(log,subsystem='server')server_log('Unable to open socket')
The author would like to thank the following people for offering suggestions,
corrections and assistance with various drafts of this article: Ian Bicking,
Nick Coghlan, Nick Efford, Raymond Hettinger, Jim Jewett, Mike Krell, Leandro
Lameiro, Jussi Salmela, Collin Winter, Blake Winton.
Version 0.1: posted June 30 2006.
Version 0.11: posted July 1 2006. Typo fixes.
Version 0.2: posted July 10 2006. Merged genexp and listcomp sections into one.
Typo fixes.
Version 0.21: Added more references suggested on the tutor mailing list.
Version 0.30: Adds a section on the functional module written by Collin
Winter; adds short section on the operator module; a few other edits.
Structure and Interpretation of Computer Programs, by Harold Abelson and
Gerald Jay Sussman with Julie Sussman. Full text at
http://mitpress.mit.edu/sicp/. In this classic textbook of computer science,
chapters 2 and 3 discuss the use of sequences and streams to organize the data
flow inside a program. The book uses Scheme for its examples, but many of the
design approaches described in these chapters are applicable to functional-style
Python code.
http://gnosis.cx/TPiP/: The first chapter of David Mertz’s book
Text Processing in Python discusses functional programming
for text processing, in the section titled “Utilizing Higher-Order Functions in
Text Processing”.
David Mertz は IBM の DeveloperWorks サイトにも、
三部構成で関数型プログラミングの記事を書いています:
第1回 /
第2回 /
第3回
This document shows how Python fits into the web. It presents some ways on
how to integrate Python with the web server and general practices useful for
developing web sites.
Programming for the Web has become a hot topic since the raise of the “Web 2.0”,
which focuses on user-generated content on web sites. It has always been
possible to use Python for creating web sites, but it was a rather tedious task.
Therefore, many so-called “frameworks” and helper tools were created to help
developers creating sites faster and these sites being more robust. This HOWTO
describes some of the methods used to combine Python with a web server to create
dynamic content. It is not meant as a general introduction as this topic is far
too broad to be covered in one single document. However, a short overview of
the most popular libraries is provided.
参考
While this HOWTO tries to give an overview over Python in the Web, it cannot
always be as up to date as desired. Web development in Python is moving
forward rapidly, so the wiki page on Web Programming might be more in sync with
recent development.
When a user enters a web site, his browser makes a connection to the site’s
webserver (this is called the request). The server looks up the file in the
file system and sends it back to the user’s browser, which displays it (this is
the response). This is roughly how the unterlying protocol, HTTP works.
Now, dynamic web sites are not files in the file system, but rather programs
which are run by the web server when a request comes in. They can do all sorts
of useful things, like display the postings of a bulletin board, show your
mails, configurate software or just display the current time. These programs
can be written in about any programming language the server supports, so it is
easy to use Python for creating dynamic web sites.
As most of HTTP servers are written in C or C++, they cannot execute Python code
in a simple way – a bridge is needed between the server and the program. These
bridges or rather interfaces define how programs interact with the server. In
the past there have been numerous attempts to create the best possible
interface, but there are only a few worth mentioning.
Not every web server supports every interface. Many web servers do support only
old, now-obsolete interfaces. But they can often be extended using some
third-party modules to support new interfaces.
This interface is the oldest one, supported by nearly every web server out of
the box. Programs using CGI to communicate with their web server need to be
started by the server for every request. So, every request starts a new Python
interpreter – which takes some time to start up – thus making the whole
interface only usable for low load situations.
The upside of CGI is that it is simple – writing a program which uses CGI is a
matter of about three lines of code. But this simplicity comes at a price: it
does very few things to help the developer.
Writing CGI programs, while still possible, is not recommended anymore. With
WSGI (more on that later) it is possible to write programs that emulate CGI, so
they can be run as CGI if no better option is available.
参考
The Python standard library includes some modules that are helpful for
creating plain CGI programs:
You need to write this code into a file with a .py or .cgi extension,
this depends on your web server configuration. Depending on your web server
configuration, this file may also need to be in a cgi-bin folder, for
security reasons.
You might wonder what the cgitb line is about. This line makes it possible
to display a nice traceback instead of just crashing and displaying an “Internal
Server Error” in the user’s browser. This is useful for debugging, but it might
risk exposing some confident data to the user. Don’t use it when the script is
ready for production use. Still, you should always catch exceptions, and
display proper error pages – end-users don’t like to see nondescript “Internal
Server Errors” in their browsers.
If you don’t have your own web server, this does not apply to you. You can
check whether if works as-is and if not you need to talk to the administrator of
your web server anyway. If it is a big hoster, you can try filing a ticket
asking for Python support.
If you’re your own administrator or want to install it for testing purposes on
your own computers, you have to configure it by yourself. There is no one and
single way on how to configure CGI, as there are many web servers with different
configuration options. The currently most widely used free web server is
Apache HTTPd, Apache for short – this is the one
that most people use, it can be easily installed on nearly every system using
the systems’ package management. But lighttpd has
been gaining attention since some time and is said to have a better performance.
On many systems this server can also be installed using the package management,
so manually compiling the web server is never needed.
On Apache you can take a look into the Dynamic Content with CGI tutorial, where everything
is described. Most of the time it is enough just to set +ExecCGI. The
tutorial also describes the most common gotchas that might arise.
On lighttpd you need to use the CGI module which can be configured
in a straightforward way. It boils down to setting cgi.assign properly.
Trying to use CGI sometimes leads to small annoyances that one might experience
while trying to get these scripts to run. Sometimes it happens that a seemingly
correct script does not work as expected, which is caused by some small hidden
reason that’s difficult to spot.
Some of these reasons are:
The Python script is not marked executable. When CGI scripts are not
executable most of the web servers will let the user download it, instead of
running it and sending the output to the user. For CGI scripts to run
properly the +x bit needs to be set. Using chmoda+xyour_script.py
might already solve the problem.
The line endings must be of Unix-type. This is important because the web
server checks the first line of the script (called shebang) and tries to run
the program specified there. It gets easily confused by Windows line endings
(Carriage Return & Line Feed, also called CRLF), so you have to convert the
file to Unix line endings (only Line Feed, LF). This can be done
automatically by uploading the file via FTP in text mode instead of binary
mode, but the preferred way is just telling your editor to save the files with
Unix line endings. Most proper editors support this.
Your web server must be able to read the file, you need to make sure the
permissions are fine. Often the server runs as user and group www-data,
so it might be worth a try to change the file ownership or making the file
world readable by using chmoda+ryour_script.py.
The webserver must be able to know that the file you’re trying to access is a
CGI script. Check the configuration of your web server, maybe there is some
mistake.
The path to the interpreter in the shebang (#!/usr/bin/envpython) must be
currect. This line calls /usr/bin/env to find Python, but it’ll fail if
there is no /usr/bin/env. If you know where your Python is installed, you
can also use that path. The commands whereispython and type-ppython might also help to find where it is installed. Once this is known,
the shebang line can be changed accordingly: #!/usr/bin/python.
The file must not contain a BOM (Byte Order Mark). The BOM is meant for
determining the byte order of UTF-16 encodings, but some editors write this
also into UTF-8 files. The BOM interferes with the shebang line, so be sure
to tell your editor not to write the BOM.
mod_python might be making problems. mod_python is able to handle CGI
scripts by itself, but it can also be a source for problems. Be sure you
disable it.
People coming from PHP often find it hard to grasp how to use Python in the web.
Their first thought is mostly mod_python because
they think that this is the equivalent to mod_php. Actually it is not
really. It does embed the interpreter into the Apache process, thus speeding up
requests by not having to start a Python interpreter every request. On the
other hand, it is by far not “Python intermixed with HTML” as PHP often does.
The Python equivalent of that is a template engine. mod_python itself is much
more powerful and gives more access to Apache internals. It can emulate CGI, it
can work an a “Python Server Pages” mode similar to JSP which is “HTML
intermangled with Python” and it has a “Publisher” which destignates one file to
accept all requests and decide on what to do then.
But mod_python has some problems. Unlike the PHP interpreter the Python
interpreter uses caching when executing files, so when changing a file the whole
web server needs to be re-started to update. Another problem ist the basic
concept – Apache starts some child processes to handle the requests and
unfortunately every child process needs to load the whole Python interpreter
even if it does not use it. This makes the whole web server slower. Another
problem is that as mod_python is linked against a specific version of
libpython, it is not possible to switch from an older version to a newer
(e.g. 2.4 to 2.5) without recompiling mod_python. mod_python is also bound to
the Apache web server, so programs written for mod_python cannot easily run on
other web servers.
These are the reasons why mod_python should be avoided when writing new
programs. In some circumstances it might be still a good idea to use mod_python
for deployment, but WSGI makes it possible to run WSGI programs under mod_python
as well.
FastCGI and SCGI try to solve the performance problem of CGI in another way.
Instead of embedding the interpreter into the web server, they create
long-running processes which run in the background. There still is some module
in the web server which makes it possible for the web server to “speak” with the
background process. As the background process is independent from the server,
it can be written in any language of course also in Python. The language just
needs to have a library which handles the communication with the web server.
The difference between FastCGI and SCGI is very small, as SCGI is essentially
just a “simpler FastCGI”. But as the web server support for SCGI is limited
most people use FastCGI instead, which works the same way. Almost everything
that applies to SCGI also applies to FastCGI as well, so we’ll only write about
the latter.
These days, FastCGI is never used directly. Just like mod_python it is only
used for the deployment of WSGI applications.
Depending on the web server you need to have a special module.
Apache has both mod_fastcgi and mod_fcgid. mod_fastcgi is the original one, but it
has some licensing issues that’s why it is sometimes considered non-free.
mod_fcgid is a smaller, compatible alternative. One of these modules needs
to be loaded by Apache.
This is a simple WSGI application, but you need to install flup first, as flup handles the low level
FastCGI access.
参考
There is some documentation on setting up Django with FastCGI, most of which can be
reused for other WSGI-compliant frameworks and libraries. Only the
manage.py part has to be changed, the example used here can be used
instead. Django does more or less the exact same thing.
mod_wsgi is an attempt to get rid of the low level
gateways. As FastCGI, SCGI, mod_python are mostly used to deploy WSGI
applications anyway, mod_wsgi was started to directly embed WSGI aplications
into the Apache web server. The benefit from this approach is that WSGI
applications can be deployed much easier as is is specially designed to host
WSGI applications – unlike the other low level methods which have glue code to
host WSGI applications (like flup which was mentioned before). The downside is
that mod_wsgi is limited to the Apache web server, other servers would need
their own implementations of mod_wsgi.
It supports two modes: the embedded mode in which it integrates with the Apache
process and the daemon mode which is more FastCGI-like. Contrary to FastCGI,
mod_wsgi handles the worker-processes by itself which makes administration
easier.
WSGI was already mentioned several times so it has to be something important.
In fact it really is, so now it’s time to explain.
The Web Server Gateway Interface, PEP 333 or WSGI for short is currently
the best possible way to Python web programming. While it is great for
programmers writing frameworks, the normal person does not need to get in direct
contact with it. But when choosing a framework for web development it is a good
idea to take one which supports WSGI.
The big profit from WSGI is the unification. When your program is compatible
with WSGI – that means that your framework has support for WSGI, your program
can be deployed on every web server interface for which there are WSGI wrappers.
So you do not need to care about whether the user uses mod_python or FastCGI –
with WSGI it just works on any gateway interface. The Python standard library
contains its own WSGI server wsgiref, which is a small web server that
can be used for testing.
A really great WSGI feature are the middlewares. Middlewares are layers around
your program which can add various functionality to it. There is a number of
middlewares already available.
For example, instead of writing your own session management (to identify a user
in subsequent requests, as HTTP does not maintain state, so it does now know
that the requests belong to the same user) you can just take one middleware,
plug it in and you can rely an already existing functionality. The same thing
is compression – say you want to compress your HTML using gzip, to save your
server’s bandwidth. So you only need to plug-in a middleware and you’re done.
Authentication is also a problem easily solved using a middleware.
So, generally – although WSGI may seem complex, the initial phase of learning
can be very rewarding as WSGI does already have solutions to many problems that
might arise while writing web sites.
The code that is used to connect to various low level gateways like CGI or
mod_python is called WSGI server. One of these servers is flup which was
already mentioned and supports FastCGI, SCGI as well as AJP. Some of these servers
are written in Python as flup is, but there also exist others which are
written in C and can be used as drop-in replacements.
There are quite a lot of servers already available, so a Python web application
can be deployed nearly everywhere. This is one big advantage that Python has
compared with other web techniques.
参考
A good overview of all WSGI-related code can be found in the WSGI wiki, which contains an extensive list of WSGI servers, which can be used by every application
supporting WSGI.
You might be interested in some WSGI-supporting modules already contained in
the standard library, namely:
wsgiref – some tiny utilities and servers for WSGI
What does WSGI give the web application developer? Let’s take a look on one
long existing web application written in Python without using WSGI.
One of the most widely used wiki software is MoinMoin.
It was created in 2000, so it predates WSGI by about three years. While it now
includes support for WSGI, older versions needed separate code to run on CGI,
mod_python, FastCGI and standalone. Now, this all is possible by using WSGI and
the already-written gateways. For running with on FastCGI flup can be used,
for running a standalone server wsgiref is the way to go.
The term MVC is often heard in statements like “framework foo supports MVC”.
While MVC is not really something technical but rather organisational, many web
frameworks use this model to help the developer to bring structure into his
program. Bigger web applications can have lots of code so it is a good idea to
have structure in the program right from the beginnings. That way, even users
of other frameworks (or even languages, as MVC is nothing Python-specific) can
understand the existing code easier, as they are already familiar with the
structure.
MVC stands for three components:
The model. This is the data that is meant to modify. In Python frameworks
this component is often represented by the classes used by the
object-relational mapper. So, all declarations go here.
The view. This component’s job is to display the data of the model to the
user. Typically this component is represented by the templates.
The controller. This is the layer between the user and the model. The
controller reacts on user actions (like opening some specific URL) and tells
the model to modify the data if neccessary.
While one might think that MVC is a complex design pattern, in fact it is not.
It is used in Python because it has turned out to be useful for creating clean,
maintainable web sites.
ノート
While not all Python frameworks explicitly support MVC, it is often trivial
to create a web site which uses the MVC pattern by seperating the data logic
(the model) from the user interaction logic (the controller) and the
templates (the view). That’s why it is important not to write unneccessary
Python code in the templates – it is against MVC and creates more chaos.
参考
The english Wikipedia has an article about the Model-View-Controller pattern, which includes a long
list of web frameworks for different programming languages.
Web sites are complex constructs, so tools were created to help the web site
developer to make his work maintainable. None of these tools are in any way
Python specific, they also exist for other programming languages as well. Of
course, developers are not forced to use these tools and often there is no
“best” tool, but it is worth informing yourself before choosing something
because of the big number of helpers that the developer can use.
参考
People have written far more components that can be combined than these
presented here. The Python wiki has a page about these components, called
Web Components.
Mixing of HTML and Python code is possible with some libraries. While
convenient at first, it leads to horribly unmaintainable code. That’s why
templates exist. Templates are, in the simplest case, just HTML files with
placeholders. The HTML is sent to the user’s browser after filling out the
placeholders.
Python already includes such simple templates:
# a simple templatetemplate="<html><body><h1>Hello %s!</h1></body></html>"printtemplate%"Reader"
The Python standard library also includes some more advanced templates usable
through string.Template, but in HTML templates it is needed to use
conditional and looping contructs like Python’s for and if. So, some
template engine is needed.
Now, Python has a lot of template engines which can be used with or without a
framework. Some of these are using a plain-text programming language which
is very easy to learn as it is quite limited while others use XML so the
template output is always guaranteed to be valid XML. Some frameworks ship
their own template engine or recommend one particular. If one is not yet sure,
using these is a good idea.
ノート
While Python has quite a lot of different template engines it usually does
not make sense to use a homebrewed template system. The time needed to
evaluate all templating systems is not really worth it, better invest the
time in looking through the most popular ones. Some frameworks have their
own template engine or have a recommentation for one. It’s wise to use
these.
Popular template engines include:
Mako
Genshi
Jinja
参考
Lots of different template engines divide the attention between themselves
because it’s easy to create them in Python. The page Templating in the wiki lists a big,
ever-growing number of these.
Data persistence, while sounding very complicated is just about storing data.
This data might be the text of blog entries, the postings of a bulletin board or
the text of a wiki page. As always, there are different ways to store
informations on a web server.
Often relational database engines like MySQL or
PostgreSQL are used due to their good
performance handling very large databases consisting of up to millions of
entries. These are queried using a language called SQL. Python programmers in general do not like
SQL too much, they prefer to work with objects. It is possible to save Python
objects into a database using a technology called ORM. ORM translates all
object-oriented access into SQL code under the hood, the user does not need to
think about it. Most frameworks use ORMs and it works quite well.
A second possibility is using files that are saved on the hard disk (sometimes
called flatfiles). This is very easy, but is not too fast. There is even a
small database engine called SQLite which is bundled
with Python in the sqlite module and uses only one file. This database
can be used to store objects via an ORM and has no other dependencies. For
smaller sites SQLite is just enough. But it is not the only way in which data
can be saved into the file systems. Sometimes normal, plain text files are
enough.
The third and least used possibility are so-called object oriented databases.
These databases store the actual objects instead of the relations that
OR-mapping creates between rows in a database. This has the advantage that
nearly all objects can be saven in a straightforward way, unlike in relational
databases where some objects are very hard to represent with ORMs.
Frameworks often give the users hints on which method to choose, it is
usually a good idea to stick to these unless there are some special requirements
which require to use the one method and not the other.
参考
Persistence Tools lists
possibilities on how to save data in the file system, some of these modules
are part of the standard library
As web sites can easily become quite large, there are so-called frameworks which
were created to help the developer with making these sites. Although the most
well-known framework is Ruby on Rails, Python does also have its own frameworks
which are partly inspired by Rails or which were existing a long time before
Rails.
Two possible approaches to web frameworks exist: the minimalistic approach and
the all-inclusive approach (somtimes called full-stack). Frameworks which are
all-inclusive give you everything you need to start working, like a template
engine, some way to save and access data in databases and many features more.
Most users are best off using these as they are widely used by lots of other
users and well documented in form of books and tutorials. Other web frameworks
go the minimalistic approach trying to be as flexible as possible leaving the
user the freedom to choose what’s best for him.
The majority of users is best off with all-inclusive framewors. They bring
everything along so a user can just jump in and start to code. While they do
have some limitations they can fullfill 80% of what one will ever want to
perfectly. They consist of various components which are designed to work
together as good as possible.
The multitude of web frameworks written in Python demonstrates that it is really
easy to write one. One of the most well-known web applications written in
Python is Zope which can be regarded as some kind of
big framework. But Zope was not the only framework, there were some others
which are by now nearly forgotten. These do not need to be mentioned anymore,
because most people that used them moved on to newer ones.
There is an incredible number of frameworks, so there is no way to describe them
all. It is not even neccessary, as most of these frameworks are nothing special
and everything that can be done with these can also be done with one of the
popular ones.
Django is a framework consisting of several
tightly coupled elements which were written from scratch and work together very
well. It includes an ORM which is quite powerful while being simple to use and
has a great online administration interface which makes it possible to edit the
data in the database with a browser. The template engine is text-based and is
designed to be usable for page designers who cannot write Python. It supports
so-called template inheritance and filters (which work like Unix pipes). Django
has many handy features bundled, like creation of RSS feeds or generic views
which make it possible to write web sites nearly without any Python code.
It has a big, international community which has created many sites using Django.
There are also quite a lot of add-on projects which extend Django’s normal
functionality. This is partly due to Django’s well written online
documentation and the Django book.
ノート
Although Django is an MVC-style framework, it calls the components
differently, which is described in the Django FAQ.
The other popular web framework in Python is TurboGears. It takes the approach of using already existing
components and combining them with glue code to create a seamless experience.
TurboGears gives the user more flexibility on which components to choose, the
ORM can be switched between some easy to use but limited and complex but very
powerful. Same goes for the template engine. One strong point about TurboGears
is that the components that it consists of can be used easily in other projects
without depending on TurboGears, for example the underlying web server CherryPy.
The documentation can be found in the TurboGears wiki, where links to screencasts can be found.
TurboGears has also an active user community which can respond to most related
questions. There is also a TurboGears book
published, which is a good starting point.
The plan for the next major version of TurboGears, version 2.0 is to switch to a
more flexible base provided by another very flexible web framework called
Pylons.
These two are of course not the only frameworks that are available, there are
also some less-popular frameworks worth mentioning.
One of these is the already mentioned Zope, which has been around for quite a
long time. With Zope 2.x having been known as rather un-pythonic, the newer
Zope 3.x tries to change that and therefore gets more acceptance from Python
programmers. These efforts already showed results, there is a project which
connects Zope with WSGI called Repoze and another
project called Grok which makes it possible for
“normal” Python programmers use the very mature Zope components.
Another framework that’s already been mentioned is Pylons. Pylons is much
like TurboGears with ab even stronger emphasis on flexibility, which is bought
at the cost of being more difficult to use. Nearly every component can be
exchanged, which makes it neccessary to use the documentation of every single
component, because there are so many Pylons combinations possible that can
satisfy every requirement. Pylons builds upon Paste, an extensive set of tools which are handy for WSGI.
And that’s still not everything. The most up-to-date information can always be
found in the Python wiki.
参考
The Python wiki contains an extensive list of web frameworks.
Most frameworks also have their own mailing lists and IRC channels, look out
for these on the projects’ websites. There is also a general “Python in the
Web” IRC channel on freenode called #python.web.
classmysocket:'''demonstration class only - coded for clarity, not efficiency '''def__init__(self,sock=None):ifsockisNone:self.sock=socket.socket(socket.AF_INET,socket.SOCK_STREAM)else:self.sock=sockdefconnect(self,host,port):self.sock.connect((host,port))defmysend(self,msg):totalsent=0whiletotalsent<MSGLEN:sent=self.sock.send(msg[totalsent:])ifsent==0:raiseRuntimeError, \
"socket connection broken"totalsent=totalsent+sentdefmyreceive(self):msg=''whilelen(msg)<MSGLEN:chunk=self.sock.recv(MSGLEN-len(msg))ifchunk=='':raiseRuntimeError, \
"socket connection broken"msg=msg+chunkreturnmsg
最速のソケットコードはノンブロッキングソケットを使って
select で多重化するものだということに疑問の余地はない。
CPU に負荷をかけることなく LAN 接続を使いきるアプリは作れる。
問題は、そうやって書かれたものはあまり他のことができなくなるということだ -
いつでもデータをあちらこちらへ廻せるようにしている必要があるのだ。
In 1968, the American Standard Code for Information Interchange, better known by
its acronym ASCII, was standardized. ASCII defined numeric codes for various
characters, with the numeric values running from 0 to
127. For example, the lowercase letter ‘a’ is assigned 97 as its code
value.
ASCII was an American-developed standard, so it only defined unaccented
characters. There was an ‘e’, but no ‘é’ or ‘Í’. This meant that languages
which required accented characters couldn’t be faithfully represented in ASCII.
(Actually the missing accents matter for English, too, which contains words such
as ‘naïve’ and ‘café’, and some publications have house styles which require
spellings such as ‘coöperate’.)
For a while people just wrote programs that didn’t display accents. I remember
looking at Apple ][ BASIC programs, published in French-language publications in
the mid-1980s, that had lines like these:
PRINT "FICHER EST COMPLETE."
PRINT "CARACTERE NON ACCEPTE."
Those messages should contain accents, and they just look wrong to someone who
can read French.
In the 1980s, almost all personal computers were 8-bit, meaning that bytes could
hold values ranging from 0 to 255. ASCII codes only went up to 127, so some
machines assigned values between 128 and 255 to accented characters. Different
machines had different codes, however, which led to problems exchanging files.
Eventually various commonly used sets of values for the 128-255 range emerged.
Some were true standards, defined by the International Standards Organization,
and some were de facto conventions that were invented by one company or
another and managed to catch on.
255 characters aren’t very many. For example, you can’t fit both the accented
characters used in Western Europe and the Cyrillic alphabet used for Russian
into the 128-255 range because there are more than 127 such characters.
You could write files using different codes (all your Russian files in a coding
system called KOI8, all your French files in a different coding system called
Latin1), but what if you wanted to write a French document that quotes some
Russian text? In the 1980s people began to want to solve this problem, and the
Unicode standardization effort began.
Unicode started out using 16-bit characters instead of 8-bit characters. 16
bits means you have 2^16 = 65,536 distinct values available, making it possible
to represent many different characters from many different alphabets; an initial
goal was to have Unicode contain the alphabets for every single human language.
It turns out that even 16 bits isn’t enough to meet that goal, and the modern
Unicode specification uses a wider range of codes, 0-1,114,111 (0x10ffff in
base-16).
There’s a related ISO standard, ISO 10646. Unicode and ISO 10646 were
originally separate efforts, but the specifications were merged with the 1.1
revision of Unicode.
(This discussion of Unicode’s history is highly simplified. I don’t think the
average Python programmer needs to worry about the historical details; consult
the Unicode consortium site listed in the References for more information.)
A character is the smallest possible component of a text. ‘A’, ‘B’, ‘C’,
etc., are all different characters. So are ‘È’ and ‘Í’. Characters are
abstractions, and vary depending on the language or context you’re talking
about. For example, the symbol for ohms (Ω) is usually drawn much like the
capital letter omega (Ω) in the Greek alphabet (they may even be the same in
some fonts), but these are two different characters that have different
meanings.
The Unicode standard describes how characters are represented by code
points. A code point is an integer value, usually denoted in base 16. In the
standard, a code point is written using the notation U+12ca to mean the
character with value 0x12ca (4810 decimal). The Unicode standard contains a lot
of tables listing characters and their corresponding code points:
0061 'a'; LATIN SMALL LETTER A
0062 'b'; LATIN SMALL LETTER B
0063 'c'; LATIN SMALL LETTER C
...
007B '{'; LEFT CURLY BRACKET
Strictly, these definitions imply that it’s meaningless to say ‘this is
character U+12ca’. U+12ca is a code point, which represents some particular
character; in this case, it represents the character ‘ETHIOPIC SYLLABLE WI’. In
informal contexts, this distinction between code points and characters will
sometimes be forgotten.
A character is represented on a screen or on paper by a set of graphical
elements that’s called a glyph. The glyph for an uppercase A, for example,
is two diagonal strokes and a horizontal stroke, though the exact details will
depend on the font being used. Most Python code doesn’t need to worry about
glyphs; figuring out the correct glyph to display is generally the job of a GUI
toolkit or a terminal’s font renderer.
To summarize the previous section: a Unicode string is a sequence of code
points, which are numbers from 0 to 0x10ffff. This sequence needs to be
represented as a set of bytes (meaning, values from 0-255) in memory. The rules
for translating a Unicode string into a sequence of bytes are called an
encoding.
The first encoding you might think of is an array of 32-bit integers. In this
representation, the string “Python” would look like this:
P y t h o n
0x50 00 00 00 79 00 00 00 74 00 00 00 68 00 00 00 6f 00 00 00 6e 00 00 00
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
This representation is straightforward but using it presents a number of
problems.
It’s not portable; different processors order the bytes differently.
It’s very wasteful of space. In most texts, the majority of the code points
are less than 127, or less than 255, so a lot of space is occupied by zero
bytes. The above string takes 24 bytes compared to the 6 bytes needed for an
ASCII representation. Increased RAM usage doesn’t matter too much (desktop
computers have megabytes of RAM, and strings aren’t usually that large), but
expanding our usage of disk and network bandwidth by a factor of 4 is
intolerable.
It’s not compatible with existing C functions such as strlen(), so a new
family of wide string functions would need to be used.
Many Internet standards are defined in terms of textual data, and can’t
handle content with embedded zero bytes.
Generally people don’t use this encoding, instead choosing other encodings that
are more efficient and convenient.
Encodings don’t have to handle every possible Unicode character, and most
encodings don’t. For example, Python’s default encoding is the ‘ascii’
encoding. The rules for converting a Unicode string into the ASCII encoding are
simple; for each code point:
If the code point is < 128, each byte is the same as the value of the code
point.
If the code point is 128 or greater, the Unicode string can’t be represented
in this encoding. (Python raises a UnicodeEncodeError exception in this
case.)
Latin-1, also known as ISO-8859-1, is a similar encoding. Unicode code points
0-255 are identical to the Latin-1 values, so converting to this encoding simply
requires converting code points to byte values; if a code point larger than 255
is encountered, the string can’t be encoded into Latin-1.
Encodings don’t have to be simple one-to-one mappings like Latin-1. Consider
IBM’s EBCDIC, which was used on IBM mainframes. Letter values weren’t in one
block: ‘a’ through ‘i’ had values from 129 to 137, but ‘j’ through ‘r’ were 145
through 153. If you wanted to use EBCDIC as an encoding, you’d probably use
some sort of lookup table to perform the conversion, but this is largely an
internal detail.
UTF-8 is one of the most commonly used encodings. UTF stands for “Unicode
Transformation Format”, and the ‘8’ means that 8-bit numbers are used in the
encoding. (There’s also a UTF-16 encoding, but it’s less frequently used than
UTF-8.) UTF-8 uses the following rules:
If the code point is <128, it’s represented by the corresponding byte value.
If the code point is between 128 and 0x7ff, it’s turned into two byte values
between 128 and 255.
Code points >0x7ff are turned into three- or four-byte sequences, where each
byte of the sequence is between 128 and 255.
UTF-8 has several convenient properties:
It can handle any Unicode code point.
A Unicode string is turned into a string of bytes containing no embedded zero
bytes. This avoids byte-ordering issues, and means UTF-8 strings can be
processed by C functions such as strcpy() and sent through protocols that
can’t handle zero bytes.
A string of ASCII text is also valid UTF-8 text.
UTF-8 is fairly compact; the majority of code points are turned into two
bytes, and values less than 128 occupy only a single byte.
If bytes are corrupted or lost, it’s possible to determine the start of the
next UTF-8-encoded code point and resynchronize. It’s also unlikely that
random 8-bit data will look like valid UTF-8.
The Unicode Consortium site at <http://www.unicode.org> has character charts, a
glossary, and PDF versions of the Unicode specification. Be prepared for some
difficult reading. <http://www.unicode.org/history/> is a chronology of the
origin and development of Unicode.
Unicode strings are expressed as instances of the unicode type, one of
Python’s repertoire of built-in types. It derives from an abstract type called
basestring, which is also an ancestor of the str type; you can
therefore check if a value is a string type with isinstance(value,basestring). Under the hood, Python represents Unicode strings as either 16-
or 32-bit integers, depending on how the Python interpreter was compiled.
The unicode() constructor has the signature unicode(string[,encoding,errors]). All of its arguments should be 8-bit strings. The first argument
is converted to Unicode using the specified encoding; if you leave off the
encoding argument, the ASCII encoding is used for the conversion, so
characters greater than 127 will be treated as errors:
>>> unicode('abcdef')u'abcdef'>>> s=unicode('abcdef')>>> type(s)<type 'unicode'>>>> unicode('abcdef'+chr(255))Traceback (most recent call last):
File "<stdin>", line 1, in ?UnicodeDecodeError: 'ascii' codec can't decode byte 0xff in position 6: ordinal not in range(128)
The errors argument specifies the response when the input string can’t be
converted according to the encoding’s rules. Legal values for this argument are
‘strict’ (raise a UnicodeDecodeError exception), ‘replace’ (add U+FFFD,
‘REPLACEMENT CHARACTER’), or ‘ignore’ (just leave the character out of the
Unicode result). The following examples show the differences:
>>> unicode('\x80abc',errors='strict')Traceback (most recent call last):
File "<stdin>", line 1, in ?UnicodeDecodeError: 'ascii' codec can't decode byte 0x80 in position 0: ordinal not in range(128)>>> unicode('\x80abc',errors='replace')u'\ufffdabc'>>> unicode('\x80abc',errors='ignore')u'abc'
Encodings are specified as strings containing the encoding’s name. Python 2.4
comes with roughly 100 different encodings; see the Python Library Reference at
標準エンコーディング for a list. Some encodings
have multiple names; for example, ‘latin-1’, ‘iso_8859_1’ and ‘8859’ are all
synonyms for the same encoding.
One-character Unicode strings can also be created with the unichr()
built-in function, which takes integers and returns a Unicode string of length 1
that contains the corresponding code point. The reverse operation is the
built-in ord() function that takes a one-character Unicode string and
returns the code point value:
>>> unichr(40960)u'\ua000'>>> ord(u'\ua000')40960
Instances of the unicode type have many of the same methods as the
8-bit string type for operations such as searching and formatting:
>>> s=u'Was ever feather so lightly blown to and fro as this multitude?'>>> s.count('e')5>>> s.find('feather')9>>> s.find('bird')-1>>> s.replace('feather','sand')u'Was ever sand so lightly blown to and fro as this multitude?'>>> s.upper()u'WAS EVER FEATHER SO LIGHTLY BLOWN TO AND FRO AS THIS MULTITUDE?'
Note that the arguments to these methods can be Unicode strings or 8-bit
strings. 8-bit strings will be converted to Unicode before carrying out the
operation; Python’s default ASCII encoding will be used, so characters greater
than 127 will cause an exception:
>>> s.find('Was\x9f')Traceback (most recent call last):
File "<stdin>", line 1, in ?UnicodeDecodeError: 'ascii' codec can't decode byte 0x9f in position 3: ordinal not in range(128)>>> s.find(u'Was\x9f')-1
Much Python code that operates on strings will therefore work with Unicode
strings without requiring any changes to the code. (Input and output code needs
more updating for Unicode; more on this later.)
Another important method is .encode([encoding],[errors='strict']), which
returns an 8-bit string version of the Unicode string, encoded in the requested
encoding. The errors parameter is the same as the parameter of the
unicode() constructor, with one additional possibility; as well as ‘strict’,
‘ignore’, and ‘replace’, you can also pass ‘xmlcharrefreplace’ which uses XML’s
character references. The following example shows the different results:
>>> u=unichr(40960)+u'abcd'+unichr(1972)>>> u.encode('utf-8')'\xea\x80\x80abcd\xde\xb4'>>> u.encode('ascii')Traceback (most recent call last):
File "<stdin>", line 1, in ?UnicodeEncodeError: 'ascii' codec can't encode character '\ua000' in position 0: ordinal not in range(128)>>> u.encode('ascii','ignore')'abcd'>>> u.encode('ascii','replace')'?abcd?'>>> u.encode('ascii','xmlcharrefreplace')'ꀀabcd޴'
Python’s 8-bit strings have a .decode([encoding],[errors]) method that
interprets the string using the given encoding:
>>> u=unichr(40960)+u'abcd'+unichr(1972)# Assemble a string>>> utf8_version=u.encode('utf-8')# Encode as UTF-8>>> type(utf8_version),utf8_version(<type 'str'>, '\xea\x80\x80abcd\xde\xb4')>>> u2=utf8_version.decode('utf-8')# Decode using UTF-8>>> u==u2# The two strings matchTrue
The low-level routines for registering and accessing the available encodings are
found in the codecs module. However, the encoding and decoding functions
returned by this module are usually more low-level than is comfortable, so I’m
not going to describe the codecs module here. If you need to implement a
completely new encoding, you’ll need to learn about the codecs module
interfaces, but implementing encodings is a specialized task that also won’t be
covered here. Consult the Python documentation to learn more about this module.
The most commonly used part of the codecs module is the
codecs.open() function which will be discussed in the section on input and
output.
In Python source code, Unicode literals are written as strings prefixed with the
‘u’ or ‘U’ character: u'abcdefghijk'. Specific code points can be written
using the \u escape sequence, which is followed by four hex digits giving
the code point. The \U escape sequence is similar, but expects 8 hex
digits, not 4.
Unicode literals can also use the same escape sequences as 8-bit strings,
including \x, but \x only takes two hex digits so it can’t express an
arbitrary code point. Octal escapes can go up to U+01ff, which is octal 777.
Using escape sequences for code points greater than 127 is fine in small doses,
but becomes an annoyance if you’re using many accented characters, as you would
in a program with messages in French or some other accent-using language. You
can also assemble strings using the unichr() built-in function, but this is
even more tedious.
Ideally, you’d want to be able to write literals in your language’s natural
encoding. You could then edit Python source code with your favorite editor
which would display the accented characters naturally, and have the right
characters used at runtime.
Python supports writing Unicode literals in any encoding, but you have to
declare the encoding being used. This is done by including a special comment as
either the first or second line of the source file:
The syntax is inspired by Emacs’s notation for specifying variables local to a
file. Emacs supports many different variables, but Python only supports
‘coding’. The -*- symbols indicate that the comment is special; within
them, you must supply the name coding and the name of your chosen encoding,
separated by ':'.
If you don’t include such a comment, the default encoding used will be ASCII.
Versions of Python before 2.4 were Euro-centric and assumed Latin-1 as a default
encoding for string literals; in Python 2.4, characters greater than 127 still
work but result in a warning. For example, the following program has no
encoding declaration:
#!/usr/bin/env pythonu=u'abcdé'printord(u[-1])
When you run it with Python 2.4, it will output the following warning:
amk:~$ python p263.py
sys:1: DeprecationWarning: Non-ASCII character '\xe9'
in file p263.py on line 2, but no encoding declared;
see http://www.python.org/peps/pep-0263.html for details
The Unicode specification includes a database of information about code points.
For each code point that’s defined, the information includes the character’s
name, its category, the numeric value if applicable (Unicode has characters
representing the Roman numerals and fractions such as one-third and
four-fifths). There are also properties related to the code point’s use in
bidirectional text and other display-related properties.
The following program displays some information about several characters, and
prints the numeric value of one particular character:
importunicodedatau=unichr(233)+unichr(0x0bf2)+unichr(3972)+unichr(6000)+unichr(13231)fori,cinenumerate(u):printi,'%04x'%ord(c),unicodedata.category(c),printunicodedata.name(c)# Get numeric value of second characterprintunicodedata.numeric(u[1])
When run, this prints:
0 00e9 Ll LATIN SMALL LETTER E WITH ACUTE
1 0bf2 No TAMIL NUMBER ONE THOUSAND
2 0f84 Mn TIBETAN MARK HALANTA
3 1770 Lo TAGBANWA LETTER SA
4 33af So SQUARE RAD OVER S SQUARED
1000.0
The category codes are abbreviations describing the nature of the character.
These are grouped into categories such as “Letter”, “Number”, “Punctuation”, or
“Symbol”, which in turn are broken up into subcategories. To take the codes
from the above output, 'Ll' means ‘Letter, lowercase’, 'No' means
“Number, other”, 'Mn' is “Mark, nonspacing”, and 'So' is “Symbol,
other”. See
<http://www.unicode.org/Public/UNIDATA/UCD.html#General_Category_Values> for a
list of category codes.
Marc-André Lemburg gave a presentation at EuroPython 2002 titled “Python and
Unicode”. A PDF version of his slides is available at
<http://downloads.egenix.com/python/Unicode-EPC2002-Talk.pdf>, and is an
excellent overview of the design of Python’s Unicode features.
Once you’ve written some code that works with Unicode data, the next problem is
input/output. How do you get Unicode strings into your program, and how do you
convert Unicode into a form suitable for storage or transmission?
It’s possible that you may not need to do anything depending on your input
sources and output destinations; you should check whether the libraries used in
your application support Unicode natively. XML parsers often return Unicode
data, for example. Many relational databases also support Unicode-valued
columns and can return Unicode values from an SQL query.
Unicode data is usually converted to a particular encoding before it gets
written to disk or sent over a socket. It’s possible to do all the work
yourself: open a file, read an 8-bit string from it, and convert the string with
unicode(str,encoding). However, the manual approach is not recommended.
One problem is the multi-byte nature of encodings; one Unicode character can be
represented by several bytes. If you want to read the file in arbitrary-sized
chunks (say, 1K or 4K), you need to write error-handling code to catch the case
where only part of the bytes encoding a single Unicode character are read at the
end of a chunk. One solution would be to read the entire file into memory and
then perform the decoding, but that prevents you from working with files that
are extremely large; if you need to read a 2Gb file, you need 2Gb of RAM.
(More, really, since for at least a moment you’d need to have both the encoded
string and its Unicode version in memory.)
The solution would be to use the low-level decoding interface to catch the case
of partial coding sequences. The work of implementing this has already been
done for you: the codecs module includes a version of the open()
function that returns a file-like object that assumes the file’s contents are in
a specified encoding and accepts Unicode parameters for methods such as
.read() and .write().
The function’s parameters are open(filename,mode='rb',encoding=None,errors='strict',buffering=1). mode can be 'r', 'w', or 'a',
just like the corresponding parameter to the regular built-in open()
function; add a '+' to update the file. buffering is similarly parallel
to the standard function’s parameter. encoding is a string giving the
encoding to use; if it’s left as None, a regular Python file object that
accepts 8-bit strings is returned. Otherwise, a wrapper object is returned, and
data written to or read from the wrapper object will be converted as needed.
errors specifies the action for encoding errors and can be one of the usual
values of ‘strict’, ‘ignore’, and ‘replace’.
Unicode character U+FEFF is used as a byte-order mark (BOM), and is often
written as the first character of a file in order to assist with autodetection
of the file’s byte ordering. Some encodings, such as UTF-16, expect a BOM to be
present at the start of a file; when such an encoding is used, the BOM will be
automatically written as the first character and will be silently dropped when
the file is read. There are variants of these encodings, such as ‘utf-16-le’
and ‘utf-16-be’ for little-endian and big-endian encodings, that specify one
particular byte ordering and don’t skip the BOM.
Most of the operating systems in common use today support filenames that contain
arbitrary Unicode characters. Usually this is implemented by converting the
Unicode string into some encoding that varies depending on the system. For
example, Mac OS X uses UTF-8 while Windows uses a configurable encoding; on
Windows, Python uses the name “mbcs” to refer to whatever the currently
configured encoding is. On Unix systems, there will only be a filesystem
encoding if you’ve set the LANG or LC_CTYPE environment variables; if
you haven’t, the default encoding is ASCII.
The sys.getfilesystemencoding() function returns the encoding to use on
your current system, in case you want to do the encoding manually, but there’s
not much reason to bother. When opening a file for reading or writing, you can
usually just provide the Unicode string as the filename, and it will be
automatically converted to the right encoding for you:
Functions in the os module such as os.stat() will also accept Unicode
filenames.
os.listdir(), which returns filenames, raises an issue: should it return
the Unicode version of filenames, or should it return 8-bit strings containing
the encoded versions? os.listdir() will do both, depending on whether you
provided the directory path as an 8-bit string or a Unicode string. If you pass
a Unicode string as the path, filenames will be decoded using the filesystem’s
encoding and a list of Unicode strings will be returned, while passing an 8-bit
path will return the 8-bit versions of the filenames. For example, assuming the
default filesystem encoding is UTF-8, running the following program:
This section provides some suggestions on writing software that deals with
Unicode.
The most important tip is:
Software should only work with Unicode strings internally, converting to a
particular encoding on output.
If you attempt to write processing functions that accept both Unicode and 8-bit
strings, you will find your program vulnerable to bugs wherever you combine the
two different kinds of strings. Python’s default encoding is ASCII, so whenever
a character with an ASCII value > 127 is in the input data, you’ll get a
UnicodeDecodeError because that character can’t be handled by the ASCII
encoding.
It’s easy to miss such problems if you only test your software with data that
doesn’t contain any accents; everything will seem to work, but there’s actually
a bug in your program waiting for the first user who attempts to use characters
> 127. A second tip, therefore, is:
Include characters > 127 and, even better, characters > 255 in your test
data.
When using data coming from a web browser or some other untrusted source, a
common technique is to check for illegal characters in a string before using the
string in a generated command line or storing it in a database. If you’re doing
this, be careful to check the string once it’s in the form that will be used or
stored; it’s possible for encodings to be used to disguise characters. This is
especially true if the input data also specifies the encoding; many encodings
leave the commonly checked-for characters alone, but Python includes some
encodings such as 'base64' that modify every single character.
For example, let’s say you have a content management system that takes a Unicode
filename, and you want to disallow paths with a ‘/’ character. You might write
this code:
defread_file(filename,encoding):if'/'infilename:raiseValueError("'/' not allowed in filenames")unicode_name=filename.decode(encoding)f=open(unicode_name,'r')# ... return contents of file ...
However, if an attacker could specify the 'base64' encoding, they could pass
'L2V0Yy9wYXNzd2Q=', which is the base-64 encoded form of the string
'/etc/passwd', to read a system file. The above code looks for '/'
characters in the encoded form and misses the dangerous character in the
resulting decoded form.
Thanks to the following people who have noted errors or offered suggestions on
this article: Nicholas Bastin, Marius Gedminas, Kent Johnson, Ken Krugler,
Marc-André Lemburg, Martin von Löwis, Chad Whitacre.
Version 1.0: posted August 5 2005.
Version 1.01: posted August 7 2005. Corrects factual and markup errors; adds
several links.
Version 1.02: posted August 16 2005. Corrects factual errors.
#include "stdlib.h"#include "Python.h"#include "bytesobject.h"/* text example */staticPyObject*say_hello(PyObject*self,PyObject*args){PyObject*name,*result;if(!PyArg_ParseTuple(args,"U:say_hello",&name))returnNULL;result=PyUnicode_FromFormat("Hello, %S!",name);returnresult;}/* just a forward */staticchar*do_encode(PyObject*);/* bytes example */staticPyObject*encode_object(PyObject*self,PyObject*args){char*encoded;PyObject*result,*myobj;if(!PyArg_ParseTuple(args,"O:encode_object",&myobj))returnNULL;encoded=do_encode(myobj);if(encoded==NULL)returnNULL;result=PyBytes_FromString(encoded);free(encoded);returnresult;}
This document is an introductory tutorial to using regular expressions in Python
with the re module. It provides a gentler introduction than the
corresponding section in the Library Reference.
The re module was added in Python 1.5, and provides Perl-style regular
expression patterns. Earlier versions of Python came with the regex
module, which provided Emacs-style patterns. The regex module was
removed completely in Python 2.5.
Regular expressions (called REs, or regexes, or regex patterns) are essentially
a tiny, highly specialized programming language embedded inside Python and made
available through the re module. Using this little language, you specify
the rules for the set of possible strings that you want to match; this set might
contain English sentences, or e-mail addresses, or TeX commands, or anything you
like. You can then ask questions such as “Does this string match the pattern?”,
or “Is there a match for the pattern anywhere in this string?”. You can also
use REs to modify a string or to split it apart in various ways.
Regular expression patterns are compiled into a series of bytecodes which are
then executed by a matching engine written in C. For advanced use, it may be
necessary to pay careful attention to how the engine will execute a given RE,
and write the RE in a certain way in order to produce bytecode that runs faster.
Optimization isn’t covered in this document, because it requires that you have a
good understanding of the matching engine’s internals.
The regular expression language is relatively small and restricted, so not all
possible string processing tasks can be done using regular expressions. There
are also tasks that can be done with regular expressions, but the expressions
turn out to be very complicated. In these cases, you may be better off writing
Python code to do the processing; while Python code will be slower than an
elaborate regular expression, it will also probably be more understandable.
We’ll start by learning about the simplest possible regular expressions. Since
regular expressions are used to operate on strings, we’ll begin with the most
common task: matching characters.
For a detailed explanation of the computer science underlying regular
expressions (deterministic and non-deterministic finite automata), you can refer
to almost any textbook on writing compilers.
Most letters and characters will simply match themselves. For example, the
regular expression test will match the string test exactly. (You can
enable a case-insensitive mode that would let this RE match Test or TEST
as well; more about this later.)
There are exceptions to this rule; some characters are special
metacharacters, and don’t match themselves. Instead, they signal that
some out-of-the-ordinary thing should be matched, or they affect other portions
of the RE by repeating them or changing their meaning. Much of this document is
devoted to discussing various metacharacters and what they do.
Here’s a complete list of the metacharacters; their meanings will be discussed
in the rest of this HOWTO.
. ^ $ * + ? { [ ] \ | ( )
The first metacharacters we’ll look at are [ and ]. They’re used for
specifying a character class, which is a set of characters that you wish to
match. Characters can be listed individually, or a range of characters can be
indicated by giving two characters and separating them by a '-'. For
example, [abc] will match any of the characters a, b, or c; this
is the same as [a-c], which uses a range to express the same set of
characters. If you wanted to match only lowercase letters, your RE would be
[a-z].
Metacharacters are not active inside classes. For example, [akm$] will
match any of the characters 'a', 'k', 'm', or '$'; '$' is
usually a metacharacter, but inside a character class it’s stripped of its
special nature.
You can match the characters not listed within the class by complementing
the set. This is indicated by including a '^' as the first character of the
class; '^' outside a character class will simply match the '^'
character. For example, [^5] will match any character except '5'.
Perhaps the most important metacharacter is the backslash, \. As in Python
string literals, the backslash can be followed by various characters to signal
various special sequences. It’s also used to escape all the metacharacters so
you can still match them in patterns; for example, if you need to match a [
or \, you can precede them with a backslash to remove their special
meaning: \[ or \\.
Some of the special sequences beginning with '\' represent predefined sets
of characters that are often useful, such as the set of digits, the set of
letters, or the set of anything that isn’t whitespace. The following predefined
special sequences are available:
\d
Matches any decimal digit; this is equivalent to the class [0-9].
\D
Matches any non-digit character; this is equivalent to the class [^0-9].
\s
Matches any whitespace character; this is equivalent to the class [\t\n\r\f\v].
\S
Matches any non-whitespace character; this is equivalent to the class [^\t\n\r\f\v].
\w
Matches any alphanumeric character; this is equivalent to the class
[a-zA-Z0-9_].
\W
Matches any non-alphanumeric character; this is equivalent to the class
[^a-zA-Z0-9_].
These sequences can be included inside a character class. For example,
[\s,.] is a character class that will match any whitespace character, or
',' or '.'.
The final metacharacter in this section is .. It matches anything except a
newline character, and there’s an alternate mode (re.DOTALL) where it will
match even a newline. '.' is often used where you want to match “any
character”.
Being able to match varying sets of characters is the first thing regular
expressions can do that isn’t already possible with the methods available on
strings. However, if that was the only additional capability of regexes, they
wouldn’t be much of an advance. Another capability is that you can specify that
portions of the RE must be repeated a certain number of times.
The first metacharacter for repeating things that we’ll look at is *. *
doesn’t match the literal character *; instead, it specifies that the
previous character can be matched zero or more times, instead of exactly once.
For example, ca*t will match ct (0 a characters), cat (1 a),
caaat (3 a characters), and so forth. The RE engine has various
internal limitations stemming from the size of C’s int type that will
prevent it from matching over 2 billion a characters; you probably don’t
have enough memory to construct a string that large, so you shouldn’t run into
that limit.
Repetitions such as * are greedy; when repeating a RE, the matching
engine will try to repeat it as many times as possible. If later portions of the
pattern don’t match, the matching engine will then back up and try again with
few repetitions.
A step-by-step example will make this more obvious. Let’s consider the
expression a[bcd]*b. This matches the letter 'a', zero or more letters
from the class [bcd], and finally ends with a 'b'. Now imagine matching
this RE against the string abcbd.
Step
Matched
Explanation
1
a
The a in the RE matches.
2
abcbd
The engine matches [bcd]*,
going as far as it can, which
is to the end of the string.
3
Failure
The engine tries to match
b, but the current position
is at the end of the string, so
it fails.
4
abcb
Back up, so that [bcd]*
matches one less character.
5
Failure
Try b again, but the
current position is at the last
character, which is a 'd'.
6
abc
Back up again, so that
[bcd]* is only matching
bc.
6
abcb
Try b again. This time
the character at the
current position is 'b', so
it succeeds.
The end of the RE has now been reached, and it has matched abcb. This
demonstrates how the matching engine goes as far as it can at first, and if no
match is found it will then progressively back up and retry the rest of the RE
again and again. It will back up until it has tried zero matches for
[bcd]*, and if that subsequently fails, the engine will conclude that the
string doesn’t match the RE at all.
Another repeating metacharacter is +, which matches one or more times. Pay
careful attention to the difference between * and +; * matches
zero or more times, so whatever’s being repeated may not be present at all,
while + requires at least one occurrence. To use a similar example,
ca+t will match cat (1 a), caaat (3 a‘s), but won’t match
ct.
There are two more repeating qualifiers. The question mark character, ?,
matches either once or zero times; you can think of it as marking something as
being optional. For example, home-?brew matches either homebrew or
home-brew.
The most complicated repeated qualifier is {m,n}, where m and n are
decimal integers. This qualifier means there must be at least m repetitions,
and at most n. For example, a/{1,3}b will match a/b, a//b, and
a///b. It won’t match ab, which has no slashes, or a////b, which
has four.
You can omit either m or n; in that case, a reasonable value is assumed for
the missing value. Omitting m is interpreted as a lower limit of 0, while
omitting n results in an upper bound of infinity — actually, the upper bound
is the 2-billion limit mentioned earlier, but that might as well be infinity.
Readers of a reductionist bent may notice that the three other qualifiers can
all be expressed using this notation. {0,} is the same as *, {1,}
is equivalent to +, and {0,1} is the same as ?. It’s better to use
*, +, or ? when you can, simply because they’re shorter and easier
to read.
Now that we’ve looked at some simple regular expressions, how do we actually use
them in Python? The re module provides an interface to the regular
expression engine, allowing you to compile REs into objects and then perform
matches with them.
Regular expressions are compiled into RegexObject instances, which have
methods for various operations such as searching for pattern matches or
performing string substitutions.
>>> importre>>> p=re.compile('ab*')>>> printp<re.RegexObject instance at 80b4150>
re.compile() also accepts an optional flags argument, used to enable
various special features and syntax variations. We’ll go over the available
settings later, but for now a single example will do:
>>> p=re.compile('ab*',re.IGNORECASE)
The RE is passed to re.compile() as a string. REs are handled as strings
because regular expressions aren’t part of the core Python language, and no
special syntax was created for expressing them. (There are applications that
don’t need REs at all, so there’s no need to bloat the language specification by
including them.) Instead, the re module is simply a C extension module
included with Python, just like the socket or zlib modules.
Putting REs in strings keeps the Python language simpler, but has one
disadvantage which is the topic of the next section.
As stated earlier, regular expressions use the backslash character ('\') to
indicate special forms or to allow special characters to be used without
invoking their special meaning. This conflicts with Python’s usage of the same
character for the same purpose in string literals.
Let’s say you want to write a RE that matches the string \section, which
might be found in a LaTeX file. To figure out what to write in the program
code, start with the desired string to be matched. Next, you must escape any
backslashes and other metacharacters by preceding them with a backslash,
resulting in the string \\section. The resulting string that must be passed
to re.compile() must be \\section. However, to express this as a
Python string literal, both backslashes must be escaped again.
In short, to match a literal backslash, one has to write '\\\\' as the RE
string, because the regular expression must be \\, and each backslash must
be expressed as \\ inside a regular Python string literal. In REs that
feature backslashes repeatedly, this leads to lots of repeated backslashes and
makes the resulting strings difficult to understand.
The solution is to use Python’s raw string notation for regular expressions;
backslashes are not handled in any special way in a string literal prefixed with
'r', so r"\n" is a two-character string containing '\' and 'n',
while "\n" is a one-character string containing a newline. Regular
expressions will often be written in Python code using this raw string notation.
Once you have an object representing a compiled regular expression, what do you
do with it? RegexObject instances have several methods and attributes.
Only the most significant ones will be covered here; consult the re docs
for a complete listing.
Method/Attribute
Purpose
match()
Determine if the RE matches at the beginning
of the string.
search()
Scan through a string, looking for any
location where this RE matches.
findall()
Find all substrings where the RE matches, and
returns them as a list.
finditer()
Find all substrings where the RE matches, and
returns them as an iterator.
match() and search() return None if no match can be found. If
they’re successful, a MatchObject instance is returned, containing
information about the match: where it starts and ends, the substring it matched,
and more.
You can learn about this by interactively experimenting with the re
module. If you have Tkinter available, you may also want to look at
Tools/scripts/redemo.py, a demonstration program included with the
Python distribution. It allows you to enter REs and strings, and displays
whether the RE matches or fails. redemo.py can be quite useful when
trying to debug a complicated RE. Phil Schwartz’s Kodos is also an interactive tool for developing and
testing RE patterns.
This HOWTO uses the standard Python interpreter for its examples. First, run the
Python interpreter, import the re module, and compile a RE:
Python 2.2.2 (#1, Feb 10 2003, 12:57:01)
>>> import re
>>> p = re.compile('[a-z]+')
>>> p
<_sre.SRE_Pattern object at 80c3c28>
Now, you can try matching various strings against the RE [a-z]+. An empty
string shouldn’t match at all, since + means ‘one or more repetitions’.
match() should return None in this case, which will cause the
interpreter to print no output. You can explicitly print the result of
match() to make this clear.
>>> p.match("")>>> printp.match("")None
Now, let’s try it on a string that it should match, such as tempo. In this
case, match() will return a MatchObject, so you should store the
result in a variable for later use.
>>> m=p.match('tempo')>>> printm<_sre.SRE_Match object at 80c4f68>
Now you can query the MatchObject for information about the matching
string. MatchObject instances also have several methods and
attributes; the most important ones are:
Method/Attribute
Purpose
group()
Return the string matched by the RE
start()
Return the starting position of the match
end()
Return the ending position of the match
span()
Return a tuple containing the (start, end)
positions of the match
Trying these methods will soon clarify their meaning:
group() returns the substring that was matched by the RE. start()
and end() return the starting and ending index of the match. span()
returns both start and end indexes in a single tuple. Since the match()
method only checks if the RE matches at the start of a string, start()
will always be zero. However, the search() method of RegexObject
instances scans through the string, so the match may not start at zero in that
case.
findall() has to create the entire list before it can be returned as the
result. The finditer() method returns a sequence of MatchObject
instances as an iterator. [1]
You don’t have to create a RegexObject and call its methods; the
re module also provides top-level functions called match(),
search(), findall(), sub(), and so forth. These functions
take the same arguments as the corresponding RegexObject method, with
the RE string added as the first argument, and still return either None or a
MatchObject instance.
>>> printre.match(r'From\s+','Fromage amk')None>>> re.match(r'From\s+','From amk Thu May 14 19:12:10 1998')<re.MatchObject instance at 80c5978>
Under the hood, these functions simply produce a RegexObject for you
and call the appropriate method on it. They also store the compiled object in a
cache, so future calls using the same RE are faster.
Should you use these module-level functions, or should you get the
RegexObject and call its methods yourself? That choice depends on how
frequently the RE will be used, and on your personal coding style. If the RE is
being used at only one point in the code, then the module functions are probably
more convenient. If a program contains a lot of regular expressions, or re-uses
the same ones in several locations, then it might be worthwhile to collect all
the definitions in one place, in a section of code that compiles all the REs
ahead of time. To take an example from the standard library, here’s an extract
from xmllib.py:
Compilation flags let you modify some aspects of how regular expressions work.
Flags are available in the re module under two names, a long name such as
IGNORECASE and a short, one-letter form such as I. (If you’re
familiar with Perl’s pattern modifiers, the one-letter forms use the same
letters; the short form of re.VERBOSE is re.X, for example.)
Multiple flags can be specified by bitwise OR-ing them; re.I|re.M sets
both the I and M flags, for example.
Here’s a table of the available flags, followed by a more detailed explanation
of each one.
Flag
Meaning
DOTALL, S
Make . match any character, including
newlines
IGNORECASE, I
Do case-insensitive matches
LOCALE, L
Do a locale-aware match
MULTILINE, M
Multi-line matching, affecting ^ and
$
VERBOSE, X
Enable verbose REs, which can be organized
more cleanly and understandably.
I
IGNORECASE
Perform case-insensitive matching; character class and literal strings will
match letters by ignoring case. For example, [A-Z] will match lowercase
letters, too, and Spam will match Spam, spam, or spAM. This
lowercasing doesn’t take the current locale into account; it will if you also
set the LOCALE flag.
L
LOCALE
Make \w, \W, \b, and \B, dependent on the current locale.
Locales are a feature of the C library intended to help in writing programs that
take account of language differences. For example, if you’re processing French
text, you’d want to be able to write \w+ to match words, but \w only
matches the character class [A-Za-z]; it won’t match 'é' or 'ç'. If
your system is configured properly and a French locale is selected, certain C
functions will tell the program that 'é' should also be considered a letter.
Setting the LOCALE flag when compiling a regular expression will cause
the resulting compiled object to use these C functions for \w; this is
slower, but also enables \w+ to match French words as you’d expect.
M
MULTILINE
(^ and $ haven’t been explained yet; they’ll be introduced in section
More Metacharacters.)
Usually ^ matches only at the beginning of the string, and $ matches
only at the end of the string and immediately before the newline (if any) at the
end of the string. When this flag is specified, ^ matches at the beginning
of the string and at the beginning of each line within the string, immediately
following each newline. Similarly, the $ metacharacter matches either at
the end of the string and at the end of each line (immediately preceding each
newline).
S
DOTALL
Makes the '.' special character match any character at all, including a
newline; without this flag, '.' will match anything except a newline.
X
VERBOSE
This flag allows you to write regular expressions that are more readable by
granting you more flexibility in how you can format them. When this flag has
been specified, whitespace within the RE string is ignored, except when the
whitespace is in a character class or preceded by an unescaped backslash; this
lets you organize and indent the RE more clearly. This flag also lets you put
comments within a RE that will be ignored by the engine; comments are marked by
a '#' that’s neither in a character class or preceded by an unescaped
backslash.
For example, here’s a RE that uses re.VERBOSE; see how much easier it
is to read?
charref=re.compile(r""" &[#] # Start of a numeric entity reference ( 0[0-7]+ # Octal form | [0-9]+ # Decimal form | x[0-9a-fA-F]+ # Hexadecimal form ) ; # Trailing semicolon""",re.VERBOSE)
Without the verbose setting, the RE would look like this:
In the above example, Python’s automatic concatenation of string literals has
been used to break up the RE into smaller pieces, but it’s still more difficult
to understand than the version using re.VERBOSE.
So far we’ve only covered a part of the features of regular expressions. In
this section, we’ll cover some new metacharacters, and how to use groups to
retrieve portions of the text that was matched.
There are some metacharacters that we haven’t covered yet. Most of them will be
covered in this section.
Some of the remaining metacharacters to be discussed are zero-width
assertions. They don’t cause the engine to advance through the string;
instead, they consume no characters at all, and simply succeed or fail. For
example, \b is an assertion that the current position is located at a word
boundary; the position isn’t changed by the \b at all. This means that
zero-width assertions should never be repeated, because if they match once at a
given location, they can obviously be matched an infinite number of times.
|
Alternation, or the “or” operator. If A and B are regular expressions,
A|B will match any string that matches either A or B. | has very
low precedence in order to make it work reasonably when you’re alternating
multi-character strings. Crow|Servo will match either Crow or Servo,
not Cro, a 'w' or an 'S', and ervo.
To match a literal '|', use \|, or enclose it inside a character class,
as in [|].
^
Matches at the beginning of lines. Unless the MULTILINE flag has been
set, this will only match at the beginning of the string. In MULTILINE
mode, this also matches immediately after each newline within the string.
For example, if you wish to match the word From only at the beginning of a
line, the RE to use is ^From.
>>> printre.search('^From','From Here to Eternity')<re.MatchObject instance at 80c1520>>>> printre.search('^From','Reciting From Memory')None
$
Matches at the end of a line, which is defined as either the end of the string,
or any location followed by a newline character.
>>> printre.search('}$','{block}')<re.MatchObject instance at 80adfa8>>>> printre.search('}$','{block} ')None>>> printre.search('}$','{block}\n')<re.MatchObject instance at 80adfa8>
To match a literal '$', use \$ or enclose it inside a character class,
as in [$].
\A
Matches only at the start of the string. When not in MULTILINE mode,
\A and ^ are effectively the same. In MULTILINE mode, they’re
different: \A still matches only at the beginning of the string, but ^
may match at any location inside the string that follows a newline character.
\Z
Matches only at the end of the string.
\b
Word boundary. This is a zero-width assertion that matches only at the
beginning or end of a word. A word is defined as a sequence of alphanumeric
characters, so the end of a word is indicated by whitespace or a
non-alphanumeric character.
The following example matches class only when it’s a complete word; it won’t
match when it’s contained inside another word.
>>> p=re.compile(r'\bclass\b')>>> printp.search('no class at all')<re.MatchObject instance at 80c8f28>>>> printp.search('the declassified algorithm')None>>> printp.search('one subclass is')None
There are two subtleties you should remember when using this special sequence.
First, this is the worst collision between Python’s string literals and regular
expression sequences. In Python’s string literals, \b is the backspace
character, ASCII value 8. If you’re not using raw strings, then Python will
convert the \b to a backspace, and your RE won’t match as you expect it to.
The following example looks the same as our previous RE, but omits the 'r'
in front of the RE string.
>>> p=re.compile('\bclass\b')>>> printp.search('no class at all')None>>> printp.search('\b'+'class'+'\b')<re.MatchObject instance at 80c3ee0>
Second, inside a character class, where there’s no use for this assertion,
\b represents the backspace character, for compatibility with Python’s
string literals.
\B
Another zero-width assertion, this is the opposite of \b, only matching when
the current position is not at a word boundary.
Frequently you need to obtain more information than just whether the RE matched
or not. Regular expressions are often used to dissect strings by writing a RE
divided into several subgroups which match different components of interest.
For example, an RFC-822 header line is divided into a header name and a value,
separated by a ':', like this:
From: author@example.com
User-Agent: Thunderbird 1.5.0.9 (X11/20061227)
MIME-Version: 1.0
To: editor@example.com
This can be handled by writing a regular expression which matches an entire
header line, and has one group which matches the header name, and another group
which matches the header’s value.
Groups are marked by the '(', ')' metacharacters. '(' and ')'
have much the same meaning as they do in mathematical expressions; they group
together the expressions contained inside them, and you can repeat the contents
of a group with a repeating qualifier, such as *, +, ?, or
{m,n}. For example, (ab)* will match zero or more repetitions of
ab.
Groups indicated with '(', ')' also capture the starting and ending
index of the text that they match; this can be retrieved by passing an argument
to group(), start(), end(), and span(). Groups are
numbered starting with 0. Group 0 is always present; it’s the whole RE, so
MatchObject methods all have group 0 as their default argument. Later
we’ll see how to express groups that don’t capture the span of text that they
match.
Subgroups are numbered from left to right, from 1 upward. Groups can be nested;
to determine the number, just count the opening parenthesis characters, going
from left to right.
group() can be passed multiple group numbers at a time, in which case it
will return a tuple containing the corresponding values for those groups.
>>> m.group(2,1,2)('b', 'abc', 'b')
The groups() method returns a tuple containing the strings for all the
subgroups, from 1 up to however many there are.
>>> m.groups()('abc', 'b')
Backreferences in a pattern allow you to specify that the contents of an earlier
capturing group must also be found at the current location in the string. For
example, \1 will succeed if the exact contents of group 1 can be found at
the current position, and fails otherwise. Remember that Python’s string
literals also use a backslash followed by numbers to allow including arbitrary
characters in a string, so be sure to use a raw string when incorporating
backreferences in a RE.
For example, the following RE detects doubled words in a string.
>>> p=re.compile(r'(\b\w+)\s+\1')>>> p.search('Paris in the the spring').group()'the the'
Backreferences like this aren’t often useful for just searching through a string
— there are few text formats which repeat data in this way — but you’ll soon
find out that they’re very useful when performing string substitutions.
Elaborate REs may use many groups, both to capture substrings of interest, and
to group and structure the RE itself. In complex REs, it becomes difficult to
keep track of the group numbers. There are two features which help with this
problem. Both of them use a common syntax for regular expression extensions, so
we’ll look at that first.
Perl 5 added several additional features to standard regular expressions, and
the Python re module supports most of them. It would have been
difficult to choose new single-keystroke metacharacters or new special sequences
beginning with \ to represent the new features without making Perl’s regular
expressions confusingly different from standard REs. If you chose & as a
new metacharacter, for example, old expressions would be assuming that & was
a regular character and wouldn’t have escaped it by writing \& or [&].
The solution chosen by the Perl developers was to use (?...) as the
extension syntax. ? immediately after a parenthesis was a syntax error
because the ? would have nothing to repeat, so this didn’t introduce any
compatibility problems. The characters immediately after the ? indicate
what extension is being used, so (?=foo) is one thing (a positive lookahead
assertion) and (?:foo) is something else (a non-capturing group containing
the subexpression foo).
Python adds an extension syntax to Perl’s extension syntax. If the first
character after the question mark is a P, you know that it’s an extension
that’s specific to Python. Currently there are two such extensions:
(?P<name>...) defines a named group, and (?P=name) is a backreference to
a named group. If future versions of Perl 5 add similar features using a
different syntax, the re module will be changed to support the new
syntax, while preserving the Python-specific syntax for compatibility’s sake.
Now that we’ve looked at the general extension syntax, we can return to the
features that simplify working with groups in complex REs. Since groups are
numbered from left to right and a complex expression may use many groups, it can
become difficult to keep track of the correct numbering. Modifying such a
complex RE is annoying, too: insert a new group near the beginning and you
change the numbers of everything that follows it.
Sometimes you’ll want to use a group to collect a part of a regular expression,
but aren’t interested in retrieving the group’s contents. You can make this fact
explicit by using a non-capturing group: (?:...), where you can replace the
... with any other regular expression.
Except for the fact that you can’t retrieve the contents of what the group
matched, a non-capturing group behaves exactly the same as a capturing group;
you can put anything inside it, repeat it with a repetition metacharacter such
as *, and nest it within other groups (capturing or non-capturing).
(?:...) is particularly useful when modifying an existing pattern, since you
can add new groups without changing how all the other groups are numbered. It
should be mentioned that there’s no performance difference in searching between
capturing and non-capturing groups; neither form is any faster than the other.
A more significant feature is named groups: instead of referring to them by
numbers, groups can be referenced by a name.
The syntax for a named group is one of the Python-specific extensions:
(?P<name>...). name is, obviously, the name of the group. Named groups
also behave exactly like capturing groups, and additionally associate a name
with a group. The MatchObject methods that deal with capturing groups
all accept either integers that refer to the group by number or strings that
contain the desired group’s name. Named groups are still given numbers, so you
can retrieve information about a group in two ways:
>>> p=re.compile(r'(?P<word>\b\w+\b)')>>> m=p.search('(((( Lots of punctuation )))')>>> m.group('word')'Lots'>>> m.group(1)'Lots'
Named groups are handy because they let you use easily-remembered names, instead
of having to remember numbers. Here’s an example RE from the imaplib
module:
It’s obviously much easier to retrieve m.group('zonem'), instead of having
to remember to retrieve group 9.
The syntax for backreferences in an expression such as (...)\1 refers to the
number of the group. There’s naturally a variant that uses the group name
instead of the number. This is another Python extension: (?P=name) indicates
that the contents of the group called name should again be matched at the
current point. The regular expression for finding doubled words,
(\b\w+)\s+\1 can also be written as (?P<word>\b\w+)\s+(?P=word):
>>> p=re.compile(r'(?P<word>\b\w+)\s+(?P=word)')>>> p.search('Paris in the the spring').group()'the the'
Another zero-width assertion is the lookahead assertion. Lookahead assertions
are available in both positive and negative form, and look like this:
(?=...)
Positive lookahead assertion. This succeeds if the contained regular
expression, represented here by ..., successfully matches at the current
location, and fails otherwise. But, once the contained expression has been
tried, the matching engine doesn’t advance at all; the rest of the pattern is
tried right where the assertion started.
(?!...)
Negative lookahead assertion. This is the opposite of the positive assertion;
it succeeds if the contained expression doesn’t match at the current position
in the string.
To make this concrete, let’s look at a case where a lookahead is useful.
Consider a simple pattern to match a filename and split it apart into a base
name and an extension, separated by a .. For example, in news.rc,
news is the base name, and rc is the filename’s extension.
The pattern to match this is quite simple:
.*[.].*$
Notice that the . needs to be treated specially because it’s a
metacharacter; I’ve put it inside a character class. Also notice the trailing
$; this is added to ensure that all the rest of the string must be included
in the extension. This regular expression matches foo.bar and
autoexec.bat and sendmail.cf and printers.conf.
Now, consider complicating the problem a bit; what if you want to match
filenames where the extension is not bat? Some incorrect attempts:
.*[.][^b].*$ The first attempt above tries to exclude bat by requiring
that the first character of the extension is not a b. This is wrong,
because the pattern also doesn’t match foo.bar.
.*[.]([^b]..|.[^a].|..[^t])$
The expression gets messier when you try to patch up the first solution by
requiring one of the following cases to match: the first character of the
extension isn’t b; the second character isn’t a; or the third character
isn’t t. This accepts foo.bar and rejects autoexec.bat, but it
requires a three-letter extension and won’t accept a filename with a two-letter
extension such as sendmail.cf. We’ll complicate the pattern again in an
effort to fix it.
.*[.]([^b].?.?|.[^a]?.?|..?[^t]?)$
In the third attempt, the second and third letters are all made optional in
order to allow matching extensions shorter than three characters, such as
sendmail.cf.
The pattern’s getting really complicated now, which makes it hard to read and
understand. Worse, if the problem changes and you want to exclude both bat
and exe as extensions, the pattern would get even more complicated and
confusing.
A negative lookahead cuts through all this confusion:
.*[.](?!bat$).*$ The negative lookahead means: if the expression bat
doesn’t match at this point, try the rest of the pattern; if bat$ does
match, the whole pattern will fail. The trailing $ is required to ensure
that something like sample.batch, where the extension only starts with
bat, will be allowed.
Excluding another filename extension is now easy; simply add it as an
alternative inside the assertion. The following pattern excludes filenames that
end in either bat or exe:
Up to this point, we’ve simply performed searches against a static string.
Regular expressions are also commonly used to modify strings in various ways,
using the following RegexObject methods:
Method/Attribute
Purpose
split()
Split the string into a list, splitting it
wherever the RE matches
sub()
Find all substrings where the RE matches, and
replace them with a different string
subn()
Does the same thing as sub(), but
returns the new string and the number of
replacements
The split() method of a RegexObject splits a string apart
wherever the RE matches, returning a list of the pieces. It’s similar to the
split() method of strings but provides much more generality in the
delimiters that you can split by; split() only supports splitting by
whitespace or by a fixed string. As you’d expect, there’s a module-level
re.split() function, too.
.split(string[, maxsplit=0])
Split string by the matches of the regular expression. If capturing
parentheses are used in the RE, then their contents will also be returned as
part of the resulting list. If maxsplit is nonzero, at most maxsplit splits
are performed.
You can limit the number of splits made, by passing a value for maxsplit.
When maxsplit is nonzero, at most maxsplit splits will be made, and the
remainder of the string is returned as the final element of the list. In the
following example, the delimiter is any sequence of non-alphanumeric characters.
>>> p=re.compile(r'\W+')>>> p.split('This is a test, short and sweet, of split().')['This', 'is', 'a', 'test', 'short', 'and', 'sweet', 'of', 'split', '']>>> p.split('This is a test, short and sweet, of split().',3)['This', 'is', 'a', 'test, short and sweet, of split().']
Sometimes you’re not only interested in what the text between delimiters is, but
also need to know what the delimiter was. If capturing parentheses are used in
the RE, then their values are also returned as part of the list. Compare the
following calls:
>>> p=re.compile(r'\W+')>>> p2=re.compile(r'(\W+)')>>> p.split('This... is a test.')['This', 'is', 'a', 'test', '']>>> p2.split('This... is a test.')['This', '... ', 'is', ' ', 'a', ' ', 'test', '.', '']
The module-level function re.split() adds the RE to be used as the first
argument, but is otherwise the same.
Another common task is to find all the matches for a pattern, and replace them
with a different string. The sub() method takes a replacement value,
which can be either a string or a function, and the string to be processed.
.sub(replacement, string[, count=0])
Returns the string obtained by replacing the leftmost non-overlapping
occurrences of the RE in string by the replacement replacement. If the
pattern isn’t found, string is returned unchanged.
The optional argument count is the maximum number of pattern occurrences to be
replaced; count must be a non-negative integer. The default value of 0 means
to replace all occurrences.
Here’s a simple example of using the sub() method. It replaces colour
names with the word colour:
>>> p=re.compile('(blue|white|red)')>>> p.sub('colour','blue socks and red shoes')'colour socks and colour shoes'>>> p.sub('colour','blue socks and red shoes',count=1)'colour socks and red shoes'
The subn() method does the same work, but returns a 2-tuple containing the
new string value and the number of replacements that were performed:
>>> p=re.compile('(blue|white|red)')>>> p.subn('colour','blue socks and red shoes')('colour socks and colour shoes', 2)>>> p.subn('colour','no colours at all')('no colours at all', 0)
Empty matches are replaced only when they’re not adjacent to a previous match.
If replacement is a string, any backslash escapes in it are processed. That
is, \n is converted to a single newline character, \r is converted to a
carriage return, and so forth. Unknown escapes such as \j are left alone.
Backreferences, such as \6, are replaced with the substring matched by the
corresponding group in the RE. This lets you incorporate portions of the
original text in the resulting replacement string.
This example matches the word section followed by a string enclosed in
{, }, and changes section to subsection:
There’s also a syntax for referring to named groups as defined by the
(?P<name>...) syntax. \g<name> will use the substring matched by the
group named name, and \g<number> uses the corresponding group number.
\g<2> is therefore equivalent to \2, but isn’t ambiguous in a
replacement string such as \g<2>0. (\20 would be interpreted as a
reference to group 20, not a reference to group 2 followed by the literal
character '0'.) The following substitutions are all equivalent, but use all
three variations of the replacement string.
replacement can also be a function, which gives you even more control. If
replacement is a function, the function is called for every non-overlapping
occurrence of pattern. On each call, the function is passed a
MatchObject argument for the match and can use this information to
compute the desired replacement string and return it.
In the following example, the replacement function translates decimals into
hexadecimal:
>>> defhexrepl(match):... "Return the hex string for a decimal number"... value=int(match.group())... returnhex(value)...>>> p=re.compile(r'\d+')>>> p.sub(hexrepl,'Call 65490 for printing, 49152 for user code.')'Call 0xffd2 for printing, 0xc000 for user code.'
When using the module-level re.sub() function, the pattern is passed as
the first argument. The pattern may be a string or a RegexObject; if
you need to specify regular expression flags, you must either use a
RegexObject as the first parameter, or use embedded modifiers in the
pattern, e.g. sub("(?i)b+","x","bbbbBBBB") returns 'xx'.
Regular expressions are a powerful tool for some applications, but in some ways
their behaviour isn’t intuitive and at times they don’t behave the way you may
expect them to. This section will point out some of the most common pitfalls.
Sometimes using the re module is a mistake. If you’re matching a fixed
string, or a single character class, and you’re not using any re features
such as the IGNORECASE flag, then the full power of regular expressions
may not be required. Strings have several methods for performing operations with
fixed strings and they’re usually much faster, because the implementation is a
single small C loop that’s been optimized for the purpose, instead of the large,
more generalized regular expression engine.
One example might be replacing a single fixed string with another one; for
example, you might replace word with deed. re.sub() seems like the
function to use for this, but consider the replace() method. Note that
replace() will also replace word inside words, turning swordfish
into sdeedfish, but the naive RE word would have done that, too. (To
avoid performing the substitution on parts of words, the pattern would have to
be \bword\b, in order to require that word have a word boundary on
either side. This takes the job beyond replace()‘s abilities.)
Another common task is deleting every occurrence of a single character from a
string or replacing it with another single character. You might do this with
something like re.sub('\n','',S), but translate() is capable of
doing both tasks and will be faster than any regular expression operation can
be.
In short, before turning to the re module, consider whether your problem
can be solved with a faster and simpler string method.
The match() function only checks if the RE matches at the beginning of the
string while search() will scan forward through the string for a match.
It’s important to keep this distinction in mind. Remember, match() will
only report a successful match which will start at 0; if the match wouldn’t
start at zero, match() will not report it.
Sometimes you’ll be tempted to keep using re.match(), and just add .*
to the front of your RE. Resist this temptation and use re.search()
instead. The regular expression compiler does some analysis of REs in order to
speed up the process of looking for a match. One such analysis figures out what
the first character of a match must be; for example, a pattern starting with
Crow must match starting with a 'C'. The analysis lets the engine
quickly scan through the string looking for the starting character, only trying
the full match if a 'C' is found.
Adding .* defeats this optimization, requiring scanning to the end of the
string and then backtracking to find a match for the rest of the RE. Use
re.search() instead.
When repeating a regular expression, as in a*, the resulting action is to
consume as much of the pattern as possible. This fact often bites you when
you’re trying to match a pair of balanced delimiters, such as the angle brackets
surrounding an HTML tag. The naive pattern for matching a single HTML tag
doesn’t work because of the greedy nature of .*.
The RE matches the '<' in <html>, and the .* consumes the rest of
the string. There’s still more left in the RE, though, and the > can’t
match at the end of the string, so the regular expression engine has to
backtrack character by character until it finds a match for the >. The
final match extends from the '<' in <html> to the '>' in
</title>, which isn’t what you want.
In this case, the solution is to use the non-greedy qualifiers *?, +?,
??, or {m,n}?, which match as little text as possible. In the above
example, the '>' is tried immediately after the first '<' matches, and
when it fails, the engine advances a character at a time, retrying the '>'
at every step. This produces just the right result:
>>> printre.match('<.*?>',s).group()<html>
(Note that parsing HTML or XML with regular expressions is painful.
Quick-and-dirty patterns will handle common cases, but HTML and XML have special
cases that will break the obvious regular expression; by the time you’ve written
a regular expression that handles all of the possible cases, the patterns will
be very complicated. Use an HTML or XML parser module for such tasks.)
By now you’ve probably noticed that regular expressions are a very compact
notation, but they’re not terribly readable. REs of moderate complexity can
become lengthy collections of backslashes, parentheses, and metacharacters,
making them difficult to read and understand.
For such REs, specifying the re.VERBOSE flag when compiling the regular
expression can be helpful, because it allows you to format the regular
expression more clearly.
The re.VERBOSE flag has several effects. Whitespace in the regular
expression that isn’t inside a character class is ignored. This means that an
expression such as dog|cat is equivalent to the less readable dog|cat,
but [ab] will still match the characters 'a', 'b', or a space. In
addition, you can also put comments inside a RE; comments extend from a #
character to the next newline. When used with triple-quoted strings, this
enables REs to be formatted more neatly:
pat=re.compile(r""" \s* # Skip leading whitespace (?P<header>[^:]+) # Header name \s* : # Whitespace, and a colon (?P<value>.*?) # The header's value -- *? used to # lose the following trailing whitespace \s*$ # Trailing whitespace to end-of-line""",re.VERBOSE)
Regular expressions are a complicated topic. Did this document help you
understand them? Were there parts that were unclear, or Problems you
encountered that weren’t covered here? If so, please send suggestions for
improvements to the author.
The most complete book on regular expressions is almost certainly Jeffrey
Friedl’s Mastering Regular Expressions, published by O’Reilly. Unfortunately,
it exclusively concentrates on Perl and Java’s flavours of regular expressions,
and doesn’t contain any Python material at all, so it won’t be useful as a
reference for programming in Python. (The first edition covered Python’s
now-removed regex module, which won’t help you much.) Consider checking
it out from your library.
It’s usually difficult to get your management to accept open source software,
and Python is no exception to this rule. This document discusses reasons to use
Python, strategies for winning acceptance, facts and arguments you can use, and
cases where you shouldn’t try to use Python.
There are several reasons to incorporate a scripting language into your
development process, and this section will discuss them, and why Python has some
properties that make it a particularly good choice.
Programs are often organized in a modular fashion. Lower-level operations are
grouped together, and called by higher-level functions, which may in turn be
used as basic operations by still further upper levels.
For example, the lowest level might define a very low-level set of functions for
accessing a hash table. The next level might use hash tables to store the
headers of a mail message, mapping a header name like Date to a value such
as Tue,13May199720:00:54-0400. A yet higher level may operate on
message objects, without knowing or caring that message headers are stored in a
hash table, and so forth.
Often, the lowest levels do very simple things; they implement a data structure
such as a binary tree or hash table, or they perform some simple computation,
such as converting a date string to a number. The higher levels then contain
logic connecting these primitive operations. Using the approach, the primitives
can be seen as basic building blocks which are then glued together to produce
the complete product.
Why is this design approach relevant to Python? Because Python is well suited
to functioning as such a glue language. A common approach is to write a Python
module that implements the lower level operations; for the sake of speed, the
implementation might be in C, Java, or even Fortran. Once the primitives are
available to Python programs, the logic underlying higher level operations is
written in the form of Python code. The high-level logic is then more
understandable, and easier to modify.
John Ousterhout wrote a paper that explains this idea at greater length,
entitled “Scripting: Higher Level Programming for the 21st Century”. I
recommend that you read this paper; see the references for the URL. Ousterhout
is the inventor of the Tcl language, and therefore argues that Tcl should be
used for this purpose; he only briefly refers to other languages such as Python,
Perl, and Lisp/Scheme, but in reality, Ousterhout’s argument applies to
scripting languages in general, since you could equally write extensions for any
of the languages mentioned above.
In The Mythical Man-Month, Fredrick Brooks suggests the following rule when
planning software projects: “Plan to throw one away; you will anyway.” Brooks
is saying that the first attempt at a software design often turns out to be
wrong; unless the problem is very simple or you’re an extremely good designer,
you’ll find that new requirements and features become apparent once development
has actually started. If these new requirements can’t be cleanly incorporated
into the program’s structure, you’re presented with two unpleasant choices:
hammer the new features into the program somehow, or scrap everything and write
a new version of the program, taking the new features into account from the
beginning.
Python provides you with a good environment for quickly developing an initial
prototype. That lets you get the overall program structure and logic right, and
you can fine-tune small details in the fast development cycle that Python
provides. Once you’re satisfied with the GUI interface or program output, you
can translate the Python code into C++, Fortran, Java, or some other compiled
language.
Prototyping means you have to be careful not to use too many Python features
that are hard to implement in your other language. Using eval(), or regular
expressions, or the pickle module, means that you’re going to need C or
Java libraries for formula evaluation, regular expressions, and serialization,
for example. But it’s not hard to avoid such tricky code, and in the end the
translation usually isn’t very difficult. The resulting code can be rapidly
debugged, because any serious logical errors will have been removed from the
prototype, leaving only more minor slip-ups in the translation to track down.
This strategy builds on the earlier discussion of programmability. Using Python
as glue to connect lower-level components has obvious relevance for constructing
prototype systems. In this way Python can help you with development, even if
end users never come in contact with Python code at all. If the performance of
the Python version is adequate and corporate politics allow it, you may not need
to do a translation into C or Java, but it can still be faster to develop a
prototype and then translate it, instead of attempting to produce the final
version immediately.
One example of this development strategy is Microsoft Merchant Server. Version
1.0 was written in pure Python, by a company that subsequently was purchased by
Microsoft. Version 2.0 began to translate the code into C++, shipping with some
C++code and some Python code. Version 3.0 didn’t contain any Python at all; all
the code had been translated into C++. Even though the product doesn’t contain
a Python interpreter, the Python language has still served a useful purpose by
speeding up development.
This is a very common use for Python. Past conference papers have also
described this approach for developing high-level numerical algorithms; see
David M. Beazley and Peter S. Lomdahl’s paper “Feeding a Large-scale Physics
Application to Python” in the references for a good example. If an algorithm’s
basic operations are things like “Take the inverse of this 4000x4000 matrix”,
and are implemented in some lower-level language, then Python has almost no
additional performance cost; the extra time required for Python to evaluate an
expression like m.invert() is dwarfed by the cost of the actual computation.
It’s particularly good for applications where seemingly endless tweaking is
required to get things right. GUI interfaces and Web sites are prime examples.
The Python code is also shorter and faster to write (once you’re familiar with
Python), so it’s easier to throw it away if you decide your approach was wrong;
if you’d spent two weeks working on it instead of just two hours, you might
waste time trying to patch up what you’ve got out of a natural reluctance to
admit that those two weeks were wasted. Truthfully, those two weeks haven’t
been wasted, since you’ve learnt something about the problem and the technology
you’re using to solve it, but it’s human nature to view this as a failure of
some sort.
Python is definitely not a toy language that’s only usable for small tasks.
The language features are general and powerful enough to enable it to be used
for many different purposes. It’s useful at the small end, for 10- or 20-line
scripts, but it also scales up to larger systems that contain thousands of lines
of code.
However, this expressiveness doesn’t come at the cost of an obscure or tricky
syntax. While Python has some dark corners that can lead to obscure code, there
are relatively few such corners, and proper design can isolate their use to only
a few classes or modules. It’s certainly possible to write confusing code by
using too many features with too little concern for clarity, but most Python
code can look a lot like a slightly-formalized version of human-understandable
pseudocode.
In The New Hacker’s Dictionary, Eric S. Raymond gives the following definition
for “compact”:
Compact adj. Of a design, describes the valuable property that it can all be
apprehended at once in one’s head. This generally means the thing created from
the design can be used with greater facility and fewer errors than an equivalent
tool that is not compact. Compactness does not imply triviality or lack of
power; for example, C is compact and FORTRAN is not, but C is more powerful than
FORTRAN. Designs become non-compact through accreting features and cruft that
don’t merge cleanly into the overall design scheme (thus, some fans of Classic C
maintain that ANSI C is no longer compact).
In this sense of the word, Python is quite compact, because the language has
just a few ideas, which are used in lots of places. Take namespaces, for
example. Import a module with importmath, and you create a new namespace
called math. Classes are also namespaces that share many of the properties
of modules, and have a few of their own; for example, you can create instances
of a class. Instances? They’re yet another namespace. Namespaces are currently
implemented as Python dictionaries, so they have the same methods as the
standard dictionary data type: .keys() returns all the keys, and so forth.
This simplicity arises from Python’s development history. The language syntax
derives from different sources; ABC, a relatively obscure teaching language, is
one primary influence, and Modula-3 is another. (For more information about ABC
and Modula-3, consult their respective Web sites at http://www.cwi.nl/~steven/abc/
and http://www.m3.org.) Other features have come from C, Icon,
Algol-68, and even Perl. Python hasn’t really innovated very much, but instead
has tried to keep the language small and easy to learn, building on ideas that
have been tried in other languages and found useful.
Simplicity is a virtue that should not be underestimated. It lets you learn the
language more quickly, and then rapidly write code – code that often works the
first time you run it.
If you’re working with Java, Jython (http://www.jython.org/) is definitely worth
your attention. Jython is a re-implementation of Python in Java that compiles
Python code into Java bytecodes. The resulting environment has very tight,
almost seamless, integration with Java. It’s trivial to access Java classes
from Python, and you can write Python classes that subclass Java classes.
Jython can be used for prototyping Java applications in much the same way
CPython is used, and it can also be used for test suites for Java code, or
embedded in a Java application to add scripting capabilities.
Let’s say that you’ve decided upon Python as the best choice for your
application. How can you convince your management, or your fellow developers,
to use Python? This section lists some common arguments against using Python,
and provides some possible rebuttals.
Python is freely available software that doesn’t cost anything. How good can
it be?
Very good, indeed. These days Linux and Apache, two other pieces of open source
software, are becoming more respected as alternatives to commercial software,
but Python hasn’t had all the publicity.
Python has been around for several years, with many users and developers.
Accordingly, the interpreter has been used by many people, and has gotten most
of the bugs shaken out of it. While bugs are still discovered at intervals,
they’re usually either quite obscure (they’d have to be, for no one to have run
into them before) or they involve interfaces to external libraries. The
internals of the language itself are quite stable.
Having the source code should be viewed as making the software available for
peer review; people can examine the code, suggest (and implement) improvements,
and track down bugs. To find out more about the idea of open source code, along
with arguments and case studies supporting it, go to http://www.opensource.org.
Who’s going to support it?
Python has a sizable community of developers, and the number is still growing.
The Internet community surrounding the language is an active one, and is worth
being considered another one of Python’s advantages. Most questions posted to
the comp.lang.python newsgroup are quickly answered by someone.
Should you need to dig into the source code, you’ll find it’s clear and
well-organized, so it’s not very difficult to write extensions and track down
bugs yourself. If you’d prefer to pay for support, there are companies and
individuals who offer commercial support for Python.
Who uses Python for serious work?
Lots of people; one interesting thing about Python is the surprising diversity
of applications that it’s been used for. People are using Python to:
Run Web sites
Write GUI interfaces
Control number-crunching code on supercomputers
Make a commercial application scriptable by embedding the Python interpreter
inside it
Process large XML data sets
Build test suites for C or Java code
Whatever your application domain is, there’s probably someone who’s used Python
for something similar. Yet, despite being useable for such high-end
applications, Python’s still simple enough to use for little jobs.
They’re practically nonexistent. Consult the Misc/COPYRIGHT file in the
source distribution, or the section History and License for the full
language, but it boils down to three conditions:
You have to leave the copyright notice on the software; if you don’t include
the source code in a product, you have to put the copyright notice in the
supporting documentation.
Don’t claim that the institutions that have developed Python endorse your
product in any way.
If something goes wrong, you can’t sue for damages. Practically all software
licenses contain this condition.
Notice that you don’t have to provide source code for anything that contains
Python or is built with it. Also, the Python interpreter and accompanying
documentation can be modified and redistributed in any way you like, and you
don’t have to pay anyone any licensing fees at all.
Why should we use an obscure language like Python instead of well-known
language X?
I hope this HOWTO, and the documents listed in the final section, will help
convince you that Python isn’t obscure, and has a healthily growing user base.
One word of advice: always present Python’s positive advantages, instead of
concentrating on language X’s failings. People want to know why a solution is
good, rather than why all the other solutions are bad. So instead of attacking
a competing solution on various grounds, simply show how Python’s virtues can
help.
John Ousterhout’s white paper on scripting is a good argument for the utility of
scripting languages, though naturally enough, he emphasizes Tcl, the language he
developed. Most of the arguments would apply to any scripting language.
The authors, David M. Beazley and Peter S. Lomdahl, describe their use of
Python at Los Alamos National Laboratory. It’s another good example of how
Python can help get real work done. This quotation from the paper has been
echoed by many people:
Originally developed as a large monolithic application for massively parallel
processing systems, we have used Python to transform our application into a
flexible, highly modular, and extremely powerful system for performing
simulation, data analysis, and visualization. In addition, we describe how
Python has solved a number of important problems related to the development,
debugging, deployment, and maintenance of scientific software.
This interview with Andy Feit, discussing Infoseek’s use of Python, can be used
to show that choosing Python didn’t introduce any difficulties into a company’s
development process, and provided some substantial benefits.
Management may be doubtful of the reliability and usefulness of software that
wasn’t written commercially. This site presents arguments that show how open
source software can have considerable advantages over closed-source software.
The Linux Advocacy mini-HOWTO was the inspiration for this document, and is also
well worth reading for general suggestions on winning acceptance for a new
technology, such as Linux or Python. In general, you won’t make much progress
by simply attacking existing systems and complaining about their inadequacies;
this often ends up looking like unfocused whining. It’s much better to point
out some of the many areas where Python is an improvement over other systems.
The curses library supplies a terminal-independent screen-painting and
keyboard-handling facility for text-based terminals; such terminals include
VT100s, the Linux console, and the simulated terminal provided by X11 programs
such as xterm and rxvt. Display terminals support various control codes to
perform common operations such as moving the cursor, scrolling the screen, and
erasing areas. Different terminals use widely differing codes, and often have
their own minor quirks.
In a world of X displays, one might ask “why bother”? It’s true that
character-cell display terminals are an obsolete technology, but there are
niches in which being able to do fancy things with them are still valuable. One
is on small-footprint or embedded Unixes that don’t carry an X server. Another
is for tools like OS installers and kernel configurators that may have to run
before X is available.
The curses library hides all the details of different terminals, and provides
the programmer with an abstraction of a display, containing multiple
non-overlapping windows. The contents of a window can be changed in various
ways– adding text, erasing it, changing its appearance–and the curses library
will automagically figure out what control codes need to be sent to the terminal
to produce the right output.
The curses library was originally written for BSD Unix; the later System V
versions of Unix from AT&T added many enhancements and new functions. BSD curses
is no longer maintained, having been replaced by ncurses, which is an
open-source implementation of the AT&T interface. If you’re using an
open-source Unix such as Linux or FreeBSD, your system almost certainly uses
ncurses. Since most current commercial Unix versions are based on System V
code, all the functions described here will probably be available. The older
versions of curses carried by some proprietary Unixes may not support
everything, though.
No one has made a Windows port of the curses module. On a Windows platform, try
the Console module written by Fredrik Lundh. The Console module provides
cursor-addressable text output, plus full support for mouse and keyboard input,
and is available from http://effbot.org/zone/console-index.htm.
Thy Python module is a fairly simple wrapper over the C functions provided by
curses; if you’re already familiar with curses programming in C, it’s really
easy to transfer that knowledge to Python. The biggest difference is that the
Python interface makes things simpler, by merging different C functions such as
addstr(), mvaddstr(), mvwaddstr(), into a single
addstr() method. You’ll see this covered in more detail later.
This HOWTO is simply an introduction to writing text-mode programs with curses
and Python. It doesn’t attempt to be a complete guide to the curses API; for
that, see the Python library guide’s section on ncurses, and the C manual pages
for ncurses. It will, however, give you the basic ideas.
Before doing anything, curses must be initialized. This is done by calling the
initscr() function, which will determine the terminal type, send any
required setup codes to the terminal, and create various internal data
structures. If successful, initscr() returns a window object representing
the entire screen; this is usually called stdscr, after the name of the
corresponding C variable.
importcursesstdscr=curses.initscr()
Usually curses applications turn off automatic echoing of keys to the screen, in
order to be able to read keys and only display them under certain circumstances.
This requires calling the noecho() function.
curses.noecho()
Applications will also commonly need to react to keys instantly, without
requiring the Enter key to be pressed; this is called cbreak mode, as opposed to
the usual buffered input mode.
curses.cbreak()
Terminals usually return special keys, such as the cursor keys or navigation
keys such as Page Up and Home, as a multibyte escape sequence. While you could
write your application to expect such sequences and process them accordingly,
curses can do it for you, returning a special value such as
curses.KEY_LEFT. To get curses to do the job, you’ll have to enable
keypad mode.
stdscr.keypad(1)
Terminating a curses application is much easier than starting one. You’ll need
to call
curses.nocbreak();stdscr.keypad(0);curses.echo()
to reverse the curses-friendly terminal settings. Then call the endwin()
function to restore the terminal to its original operating mode.
curses.endwin()
A common problem when debugging a curses application is to get your terminal
messed up when the application dies without restoring the terminal to its
previous state. In Python this commonly happens when your code is buggy and
raises an uncaught exception. Keys are no longer be echoed to the screen when
you type them, for example, which makes using the shell difficult.
In Python you can avoid these complications and make debugging much easier by
importing the module curses.wrapper. It supplies a wrapper()
function that takes a callable. It does the initializations described above,
and also initializes colors if color support is present. It then runs your
provided callable and finally deinitializes appropriately. The callable is
called inside a try-catch clause which catches exceptions, performs curses
deinitialization, and then passes the exception upwards. Thus, your terminal
won’t be left in a funny state on exception.
Windows are the basic abstraction in curses. A window object represents a
rectangular area of the screen, and supports various methods to display text,
erase it, allow the user to input strings, and so forth.
The stdscr object returned by the initscr() function is a window
object that covers the entire screen. Many programs may need only this single
window, but you might wish to divide the screen into smaller windows, in order
to redraw or clear them separately. The newwin() function creates a new
window of a given size, returning the new window object.
A word about the coordinate system used in curses: coordinates are always passed
in the order y,x, and the top-left corner of a window is coordinate (0,0).
This breaks a common convention for handling coordinates, where the x
coordinate usually comes first. This is an unfortunate difference from most
other computer applications, but it’s been part of curses since it was first
written, and it’s too late to change things now.
When you call a method to display or erase text, the effect doesn’t immediately
show up on the display. This is because curses was originally written with slow
300-baud terminal connections in mind; with these terminals, minimizing the time
required to redraw the screen is very important. This lets curses accumulate
changes to the screen, and display them in the most efficient manner. For
example, if your program displays some characters in a window, and then clears
the window, there’s no need to send the original characters because they’d never
be visible.
Accordingly, curses requires that you explicitly tell it to redraw windows,
using the refresh() method of window objects. In practice, this doesn’t
really complicate programming with curses much. Most programs go into a flurry
of activity, and then pause waiting for a keypress or some other action on the
part of the user. All you have to do is to be sure that the screen has been
redrawn before pausing to wait for user input, by simply calling
stdscr.refresh() or the refresh() method of some other relevant
window.
A pad is a special case of a window; it can be larger than the actual display
screen, and only a portion of it displayed at a time. Creating a pad simply
requires the pad’s height and width, while refreshing a pad requires giving the
coordinates of the on-screen area where a subsection of the pad will be
displayed.
pad=curses.newpad(100,100)# These loops fill the pad with letters; this is# explained in the next sectionforyinrange(0,100):forxinrange(0,100):try:pad.addch(y,x,ord('a')+(x*x+y*y)%26)exceptcurses.error:pass# Displays a section of the pad in the middle of the screenpad.refresh(0,0,5,5,20,75)
The refresh() call displays a section of the pad in the rectangle
extending from coordinate (5,5) to coordinate (20,75) on the screen; the upper
left corner of the displayed section is coordinate (0,0) on the pad. Beyond
that difference, pads are exactly like ordinary windows and support the same
methods.
If you have multiple windows and pads on screen there is a more efficient way to
go, which will prevent annoying screen flicker at refresh time. Use the
noutrefresh() method of each window to update the data structure
representing the desired state of the screen; then change the physical screen to
match the desired state in one go with the function doupdate(). The
normal refresh() method calls doupdate() as its last act.
From a C programmer’s point of view, curses may sometimes look like a twisty
maze of functions, all subtly different. For example, addstr() displays a
string at the current cursor location in the stdscr window, while
mvaddstr() moves to a given y,x coordinate first before displaying the
string. waddstr() is just like addstr(), but allows specifying a
window to use, instead of using stdscr by default. mvwaddstr() follows
similarly.
Fortunately the Python interface hides all these details; stdscr is a window
object like any other, and methods like addstr() accept multiple argument
forms. Usually there are four different forms.
Form
Description
str or ch
Display the string str or character ch at
the current position
str or ch, attr
Display the string str or character ch,
using attribute attr at the current
position
y, x, str or ch
Move to position y,x within the window, and
display str or ch
y, x, str or ch, attr
Move to position y,x within the window, and
display str or ch, using attribute attr
Attributes allow displaying text in highlighted forms, such as in boldface,
underline, reverse code, or in color. They’ll be explained in more detail in
the next subsection.
The addstr() function takes a Python string as the value to be displayed,
while the addch() functions take a character, which can be either a Python
string of length 1 or an integer. If it’s a string, you’re limited to
displaying characters between 0 and 255. SVr4 curses provides constants for
extension characters; these constants are integers greater than 255. For
example, ACS_PLMINUS is a +/- symbol, and ACS_ULCORNER is the
upper left corner of a box (handy for drawing borders).
Windows remember where the cursor was left after the last operation, so if you
leave out the y,x coordinates, the string or character will be displayed
wherever the last operation left off. You can also move the cursor with the
move(y,x) method. Because some terminals always display a flashing cursor,
you may want to ensure that the cursor is positioned in some location where it
won’t be distracting; it can be confusing to have the cursor blinking at some
apparently random location.
If your application doesn’t need a blinking cursor at all, you can call
curs_set(0) to make it invisible. Equivalently, and for compatibility with
older curses versions, there’s a leaveok(bool) function. When bool is
true, the curses library will attempt to suppress the flashing cursor, and you
won’t need to worry about leaving it in odd locations.
Characters can be displayed in different ways. Status lines in a text-based
application are commonly shown in reverse video; a text viewer may need to
highlight certain words. curses supports this by allowing you to specify an
attribute for each cell on the screen.
An attribute is a integer, each bit representing a different attribute. You can
try to display text with multiple attribute bits set, but curses doesn’t
guarantee that all the possible combinations are available, or that they’re all
visually distinct. That depends on the ability of the terminal being used, so
it’s safest to stick to the most commonly available attributes, listed here.
Attribute
Description
A_BLINK
Blinking text
A_BOLD
Extra bright or bold text
A_DIM
Half bright text
A_REVERSE
Reverse-video text
A_STANDOUT
The best highlighting mode available
A_UNDERLINE
Underlined text
So, to display a reverse-video status line on the top line of the screen, you
could code:
The curses library also supports color on those terminals that provide it, The
most common such terminal is probably the Linux console, followed by color
xterms.
To use color, you must call the start_color() function soon after calling
initscr(), to initialize the default color set (the
curses.wrapper.wrapper() function does this automatically). Once that’s
done, the has_colors() function returns TRUE if the terminal in use can
actually display color. (Note: curses uses the American spelling ‘color’,
instead of the Canadian/British spelling ‘colour’. If you’re used to the
British spelling, you’ll have to resign yourself to misspelling it for the sake
of these functions.)
The curses library maintains a finite number of color pairs, containing a
foreground (or text) color and a background color. You can get the attribute
value corresponding to a color pair with the color_pair() function; this
can be bitwise-OR’ed with other attributes such as A_REVERSE, but
again, such combinations are not guaranteed to work on all terminals.
An example, which displays a line of text using color pair 1:
As I said before, a color pair consists of a foreground and background color.
start_color() initializes 8 basic colors when it activates color mode.
They are: 0:black, 1:red, 2:green, 3:yellow, 4:blue, 5:magenta, 6:cyan, and
7:white. The curses module defines named constants for each of these colors:
curses.COLOR_BLACK, curses.COLOR_RED, and so forth.
The init_pair(n,f,b) function changes the definition of color pair n, to
foreground color f and background color b. Color pair 0 is hard-wired to white
on black, and cannot be changed.
Let’s put all this together. To change color 1 to red text on a white
background, you would call:
When you change a color pair, any text already displayed using that color pair
will change to the new colors. You can also display new text in this color
with:
Very fancy terminals can change the definitions of the actual colors to a given
RGB value. This lets you change color 1, which is usually red, to purple or
blue or any other color you like. Unfortunately, the Linux console doesn’t
support this, so I’m unable to try it out, and can’t provide any examples. You
can check if your terminal can do this by calling can_change_color(),
which returns TRUE if the capability is there. If you’re lucky enough to have
such a talented terminal, consult your system’s man pages for more information.
The curses library itself offers only very simple input mechanisms. Python’s
support adds a text-input widget that makes up some of the lack.
The most common way to get input to a window is to use its getch() method.
getch() pauses and waits for the user to hit a key, displaying it if
echo() has been called earlier. You can optionally specify a coordinate
to which the cursor should be moved before pausing.
It’s possible to change this behavior with the method nodelay(). After
nodelay(1), getch() for the window becomes non-blocking and returns
curses.ERR (a value of -1) when no input is ready. There’s also a
halfdelay() function, which can be used to (in effect) set a timer on each
getch(); if no input becomes available within a specified
delay (measured in tenths of a second), curses raises an exception.
The getch() method returns an integer; if it’s between 0 and 255, it
represents the ASCII code of the key pressed. Values greater than 255 are
special keys such as Page Up, Home, or the cursor keys. You can compare the
value returned to constants such as curses.KEY_PPAGE,
curses.KEY_HOME, or curses.KEY_LEFT. Usually the main loop of
your program will look something like this:
while1:c=stdscr.getch()ifc==ord('p'):PrintDocument()elifc==ord('q'):break# Exit the while()elifc==curses.KEY_HOME:x=y=0
The curses.ascii module supplies ASCII class membership functions that
take either integer or 1-character-string arguments; these may be useful in
writing more readable tests for your command interpreters. It also supplies
conversion functions that take either integer or 1-character-string arguments
and return the same type. For example, curses.ascii.ctrl() returns the
control character corresponding to its argument.
There’s also a method to retrieve an entire string, getstr(). It isn’t
used very often, because its functionality is quite limited; the only editing
keys available are the backspace key and the Enter key, which terminates the
string. It can optionally be limited to a fixed number of characters.
curses.echo()# Enable echoing of characters# Get a 15-character string, with the cursor on the top lines=stdscr.getstr(0,0,15)
The Python curses.textpad module supplies something better. With it, you
can turn a window into a text box that supports an Emacs-like set of
keybindings. Various methods of Textbox class support editing with
input validation and gathering the edit results either with or without trailing
spaces. See the library documentation on curses.textpad for the
details.
This HOWTO didn’t cover some advanced topics, such as screen-scraping or
capturing mouse events from an xterm instance. But the Python library page for
the curses modules is now pretty complete. You should browse it next.
If you’re in doubt about the detailed behavior of any of the ncurses entry
points, consult the manual pages for your curses implementation, whether it’s
ncurses or a proprietary Unix vendor’s. The manual pages will document any
quirks, and provide complete lists of all the functions, attributes, and
ACS_* characters available to you.
Because the curses API is so large, some functions aren’t supported in the
Python interface, not because they’re difficult to implement, but because no one
has needed them yet. Feel free to add them and then submit a patch. Also, we
don’t yet have support for the menus or panels libraries associated with
ncurses; feel free to add that.
If you write an interesting little program, feel free to contribute it as
another demo. We can always use more of them!
A tutorial on Basic Authentication, with examples in Python.
urllib2 is a Python module for fetching URLs
(Uniform Resource Locators). It offers a very simple interface, in the form of
the urlopen function. This is capable of fetching URLs using a variety of
different protocols. It also offers a slightly more complex interface for
handling common situations - like basic authentication, cookies, proxies and so
on. These are provided by objects called handlers and openers.
urllib2 supports fetching URLs for many “URL schemes” (identified by the string
before the ”:” in URL - for example “ftp” is the URL scheme of
“ftp://python.org/”) using their associated network protocols (e.g. FTP, HTTP).
This tutorial focuses on the most common case, HTTP.
For straightforward situations urlopen is very easy to use. But as soon as you
encounter errors or non-trivial cases when opening HTTP URLs, you will need some
understanding of the HyperText Transfer Protocol. The most comprehensive and
authoritative reference to HTTP is RFC 2616. This is a technical document and
not intended to be easy to read. This HOWTO aims to illustrate using urllib2,
with enough detail about HTTP to help you through. It is not intended to replace
the urllib2 docs, but is supplementary to them.
Many uses of urllib2 will be that simple (note that instead of an ‘http:’ URL we
could have used an URL starting with ‘ftp:’, ‘file:’, etc.). However, it’s the
purpose of this tutorial to explain the more complicated cases, concentrating on
HTTP.
HTTP is based on requests and responses - the client makes requests and servers
send responses. urllib2 mirrors this with a Request object which represents
the HTTP request you are making. In its simplest form you create a Request
object that specifies the URL you want to fetch. Calling urlopen with this
Request object returns a response object for the URL requested. This response is
a file-like object, which means you can for example call .read() on the
response:
Note that urllib2 makes use of the same Request interface to handle all URL
schemes. For example, you can make an FTP request like so:
req=urllib2.Request('ftp://example.com/')
In the case of HTTP, there are two extra things that Request objects allow you
to do: First, you can pass data to be sent to the server. Second, you can pass
extra information (“metadata”) about the data or the about request itself, to
the server - this information is sent as HTTP “headers”. Let’s look at each of
these in turn.
Sometimes you want to send data to a URL (often the URL will refer to a CGI
(Common Gateway Interface) script [1] or other web application). With HTTP,
this is often done using what’s known as a POST request. This is often what
your browser does when you submit a HTML form that you filled in on the web. Not
all POSTs have to come from forms: you can use a POST to transmit arbitrary data
to your own application. In the common case of HTML forms, the data needs to be
encoded in a standard way, and then passed to the Request object as the data
argument. The encoding is done using a function from the urllib library
not from urllib2.
Note that other encodings are sometimes required (e.g. for file upload from HTML
forms - see HTML Specification, Form Submission for more
details).
If you do not pass the data argument, urllib2 uses a GET request. One
way in which GET and POST requests differ is that POST requests often have
“side-effects”: they change the state of the system in some way (for example by
placing an order with the website for a hundredweight of tinned spam to be
delivered to your door). Though the HTTP standard makes it clear that POSTs are
intended to always cause side-effects, and GET requests never to cause
side-effects, nothing prevents a GET request from having side-effects, nor a
POST requests from having no side-effects. Data can also be passed in an HTTP
GET request by encoding it in the URL itself.
We’ll discuss here one particular HTTP header, to illustrate how to add headers
to your HTTP request.
Some websites [2] dislike being browsed by programs, or send different versions
to different browsers [3] . By default urllib2 identifies itself as
Python-urllib/x.y (where x and y are the major and minor version
numbers of the Python release,
e.g. Python-urllib/2.5), which may confuse the site, or just plain
not work. The way a browser identifies itself is through the
User-Agent header [4]. When you create a Request object you can
pass a dictionary of headers in. The following example makes the same
request as above, but identifies itself as a version of Internet
Explorer [5].
importurllibimporturllib2url='http://www.someserver.com/cgi-bin/register.cgi'user_agent='Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'values={'name':'Michael Foord','location':'Northampton','language':'Python'}headers={'User-Agent':user_agent}data=urllib.urlencode(values)req=urllib2.Request(url,data,headers)response=urllib2.urlopen(req)the_page=response.read()
The response also has two useful methods. See the section on info and geturl
which comes after we have a look at what happens when things go wrong.
urlopen raises URLError when it cannot handle a response (though as usual
with Python APIs, builtin exceptions such as
ValueError, TypeError etc. may also
be raised).
HTTPError is the subclass of URLError raised in the specific case of
HTTP URLs.
Often, URLError is raised because there is no network connection (no route to
the specified server), or the specified server doesn’t exist. In this case, the
exception raised will have a ‘reason’ attribute, which is a tuple containing an
error code and a text error message.
Every HTTP response from the server contains a numeric “status code”. Sometimes
the status code indicates that the server is unable to fulfil the request. The
default handlers will handle some of these responses for you (for example, if
the response is a “redirection” that requests the client fetch the document from
a different URL, urllib2 will handle that for you). For those it can’t handle,
urlopen will raise an HTTPError. Typical errors include ‘404’ (page not
found), ‘403’ (request forbidden), and ‘401’ (authentication required).
See section 10 of RFC 2616 for a reference on all the HTTP error codes.
The HTTPError instance raised will have an integer ‘code’ attribute, which
corresponds to the error sent by the server.
Because the default handlers handle redirects (codes in the 300 range), and
codes in the 100-299 range indicate success, you will usually only see error
codes in the 400-599 range.
BaseHTTPServer.BaseHTTPRequestHandler.responses is a useful dictionary of
response codes in that shows all the response codes used by RFC 2616. The
dictionary is reproduced here for convenience
# Table mapping response codes to messages; entries have the# form {code: (shortmessage, longmessage)}.responses={100:('Continue','Request received, please continue'),101:('Switching Protocols','Switching to new protocol; obey Upgrade header'),200:('OK','Request fulfilled, document follows'),201:('Created','Document created, URL follows'),202:('Accepted','Request accepted, processing continues off-line'),203:('Non-Authoritative Information','Request fulfilled from cache'),204:('No Content','Request fulfilled, nothing follows'),205:('Reset Content','Clear input form for further input.'),206:('Partial Content','Partial content follows.'),300:('Multiple Choices','Object has several resources -- see URI list'),301:('Moved Permanently','Object moved permanently -- see URI list'),302:('Found','Object moved temporarily -- see URI list'),303:('See Other','Object moved -- see Method and URL list'),304:('Not Modified','Document has not changed since given time'),305:('Use Proxy','You must use proxy specified in Location to access this ''resource.'),307:('Temporary Redirect','Object moved temporarily -- see URI list'),400:('Bad Request','Bad request syntax or unsupported method'),401:('Unauthorized','No permission -- see authorization schemes'),402:('Payment Required','No payment -- see charging schemes'),403:('Forbidden','Request forbidden -- authorization will not help'),404:('Not Found','Nothing matches the given URI'),405:('Method Not Allowed','Specified method is invalid for this server.'),406:('Not Acceptable','URI not available in preferred format.'),407:('Proxy Authentication Required','You must authenticate with ''this proxy before proceeding.'),408:('Request Timeout','Request timed out; try again later.'),409:('Conflict','Request conflict.'),410:('Gone','URI no longer exists and has been permanently removed.'),411:('Length Required','Client must specify Content-Length.'),412:('Precondition Failed','Precondition in headers is false.'),413:('Request Entity Too Large','Entity is too large.'),414:('Request-URI Too Long','URI is too long.'),415:('Unsupported Media Type','Entity body in unsupported format.'),416:('Requested Range Not Satisfiable','Cannot satisfy request range.'),417:('Expectation Failed','Expect condition could not be satisfied.'),500:('Internal Server Error','Server got itself in trouble'),501:('Not Implemented','Server does not support this operation'),502:('Bad Gateway','Invalid responses from another server/proxy.'),503:('Service Unavailable','The server cannot process the request due to a high load'),504:('Gateway Timeout','The gateway server did not receive a timely response'),505:('HTTP Version Not Supported','Cannot fulfill request.'),}
When an error is raised the server responds by returning an HTTP error code
and an error page. You can use the HTTPError instance as a response on the
page returned. This means that as well as the code attribute, it also has read,
geturl, and info, methods.
>>> req=urllib2.Request('http://www.python.org/fish.html')>>> try:>>> urllib2.urlopen(req)>>> exceptURLError,e:>>> printe.code>>> printe.read()>>>404<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"><?xml-stylesheet href="./css/ht2html.css" type="text/css"?><html><head><title>Error 404: File Not Found</title>...... etc...
The response returned by urlopen (or the HTTPError instance) has two useful
methods info() and geturl().
geturl - this returns the real URL of the page fetched. This is useful
because urlopen (or the opener object used) may have followed a
redirect. The URL of the page fetched may not be the same as the URL requested.
info - this returns a dictionary-like object that describes the page
fetched, particularly the headers sent by the server. It is currently an
httplib.HTTPMessage instance.
Typical headers include ‘Content-length’, ‘Content-type’, and so on. See the
Quick Reference to HTTP Headers
for a useful listing of HTTP headers with brief explanations of their meaning
and use.
When you fetch a URL you use an opener (an instance of the perhaps
confusingly-named urllib2.OpenerDirector). Normally we have been using
the default opener - via urlopen - but you can create custom
openers. Openers use handlers. All the “heavy lifting” is done by the
handlers. Each handler knows how to open URLs for a particular URL scheme (http,
ftp, etc.), or how to handle an aspect of URL opening, for example HTTP
redirections or HTTP cookies.
You will want to create openers if you want to fetch URLs with specific handlers
installed, for example to get an opener that handles cookies, or to get an
opener that does not handle redirections.
To create an opener, instantiate an OpenerDirector, and then call
.add_handler(some_handler_instance) repeatedly.
Alternatively, you can use build_opener, which is a convenience function for
creating opener objects with a single function call. build_opener adds
several handlers by default, but provides a quick way to add more and/or
override the default handlers.
Other sorts of handlers you might want to can handle proxies, authentication,
and other common but slightly specialised situations.
install_opener can be used to make an opener object the (global) default
opener. This means that calls to urlopen will use the opener you have
installed.
Opener objects have an open method, which can be called directly to fetch
urls in the same way as the urlopen function: there’s no need to call
install_opener, except as a convenience.
To illustrate creating and installing a handler we will use the
HTTPBasicAuthHandler. For a more detailed discussion of this subject –
including an explanation of how Basic Authentication works - see the Basic
Authentication Tutorial.
When authentication is required, the server sends a header (as well as the 401
error code) requesting authentication. This specifies the authentication scheme
and a ‘realm’. The header looks like : Www-authenticate:SCHEMErealm="REALM".
e.g.
Www-authenticate: Basic realm="cPanel Users"
The client should then retry the request with the appropriate name and password
for the realm included as a header in the request. This is ‘basic
authentication’. In order to simplify this process we can create an instance of
HTTPBasicAuthHandler and an opener to use this handler.
The HTTPBasicAuthHandler uses an object called a password manager to handle
the mapping of URLs and realms to passwords and usernames. If you know what the
realm is (from the authentication header sent by the server), then you can use a
HTTPPasswordMgr. Frequently one doesn’t care what the realm is. In that
case, it is convenient to use HTTPPasswordMgrWithDefaultRealm. This allows
you to specify a default username and password for a URL. This will be supplied
in the absence of you providing an alternative combination for a specific
realm. We indicate this by providing None as the realm argument to the
add_password method.
The top-level URL is the first URL that requires authentication. URLs “deeper”
than the URL you pass to .add_password() will also match.
# create a password managerpassword_mgr=urllib2.HTTPPasswordMgrWithDefaultRealm()# Add the username and password.# If we knew the realm, we could use it instead of ``None``.top_level_url="http://example.com/foo/"password_mgr.add_password(None,top_level_url,username,password)handler=urllib2.HTTPBasicAuthHandler(password_mgr)# create "opener" (OpenerDirector instance)opener=urllib2.build_opener(handler)# use the opener to fetch a URLopener.open(a_url)# Install the opener.# Now all calls to urllib2.urlopen use our opener.urllib2.install_opener(opener)
ノート
In the above example we only supplied our HHTPBasicAuthHandler to
build_opener. By default openers have the handlers for normal situations
– ProxyHandler, UnknownHandler, HTTPHandler,
HTTPDefaultErrorHandler, HTTPRedirectHandler, FTPHandler,
FileHandler, HTTPErrorProcessor.
top_level_url is in fact either a full URL (including the ‘http:’ scheme
component and the hostname and optionally the port number)
e.g. “http://example.com/” or an “authority” (i.e. the hostname,
optionally including the port number) e.g. “example.com” or “example.com:8080”
(the latter example includes a port number). The authority, if present, must
NOT contain the “userinfo” component - for example “joe@password:example.com” is
not correct.
urllib2 will auto-detect your proxy settings and use those. This is through
the ProxyHandler which is part of the normal handler chain. Normally that’s
a good thing, but there are occasions when it may not be helpful [6]. One way
to do this is to setup our own ProxyHandler, with no proxies defined. This
is done using similar steps to setting up a Basic Authentication handler :
Currently urllib2does not support fetching of https locations
through a proxy. However, this can be enabled by extending urllib2 as
shown in the recipe [7].
The Python support for fetching resources from the web is layered. urllib2 uses
the httplib library, which in turn uses the socket library.
As of Python 2.3 you can specify how long a socket should wait for a response
before timing out. This can be useful in applications which have to fetch web
pages. By default the socket module has no timeout and can hang. Currently,
the socket timeout is not exposed at the httplib or urllib2 levels. However,
you can set the default timeout globally for all sockets using
importsocketimporturllib2# timeout in secondstimeout=10socket.setdefaulttimeout(timeout)# this call to urllib2.urlopen now uses the default timeout# we have set in the socket modulereq=urllib2.Request('http://www.voidspace.org.uk')response=urllib2.urlopen(req)
Like Google for example. The proper way to use google from a program
is to use PyGoogle of course. See
Voidspace Google
for some examples of using the Google API.
Browser sniffing is a very bad practise for website design - building
sites using web standards is much more sensible. Unfortunately a lot of
sites still send different versions to different browsers.
In my case I have to use a proxy to access the internet at work. If you
attempt to fetch localhost URLs through this proxy it blocks them. IE
is set to use the proxy, which urllib2 picks up on. In order to test
scripts with a localhost server, I have to prevent urllib2 from using
the proxy.
型はオブジェクトの動作のほとんど全てに影響します。オブジェクトのアイデンティティが重要かどうかでさえ、ある意味では型に左右されます:
変更不能な型では、新たな値を計算するような操作を行うと、実際には同じ型と値を持った既存のオブジェクトへの参照を返すことがありますが、
変更可能なオブジェクトではそのような動作は起こりえません。例えば、 a=1;b=1 とすると、 a と b は値 1 を持つ
同じオブジェクトを参照するときもあるし、そうでないときもあります。これは実装に依存します。しかし、 c=[];d=[] とすると、
c と d はそれぞれ二つの異なった、互いに一意な、新たに作成された空のリストを参照することが保証されています。 (c=d=[] とすると、 c と d の両方に同じオブジェクトを代入します)
この型は、計算機レベルで倍精度とされている浮動小数点を 2 つ一組にして複素数を表現します。浮動小数点について述べたのと同じ性質が当てはまります。複素数
z の実数部および虚数部は、それぞれ読み出し専用属性 z.real および z.imag で取り出すことができます。
シーケンス型 (sequence)
この型は、有限の順序集合 (ordered set) を表現します。要素は非負の整数でインデクス化されています。組み込み関数 len()
を使うと、シーケンスの要素数を返します。シーケンスの長さが n の場合、インデクスは 0, 1, ..., n -1 からなる集合です。シーケンス
a の要素 i は a[i] で選択します。
任意のインデクス集合でインデクス化された、有限のオブジェクトからなる集合を表現します。添字表記 a[k] は、 k でインデクス指定
された要素を a から選択します; 選択された要素は式の中で使うことができ、代入や del 文の対象にすることができます。
組み込み関数 len() は、マップ内の要素数を返します。
関数オブジェクトはまた、任意の属性を設定したり取得したりできます。この機能は、例えば関数にメタデータを付与したい場合などに使えます。関数の get や
set には、通常のドット表記を使います。 現在の実装では、ユーザ定義の関数でのみ属性をサポートしているので
注意して下さい。組み込み関数の属性は将来サポートする予定です。
If the __reversed__() method is not provided, the
reversed() builtin will fall back to using the sequence protocol
(__len__() and __getitem__()). Objects should normally
only provide __reversed__() if they do not support the sequence
protocol and an efficient implementation of reverse iteration is possible.
classMyClass:...def__getitem__(self,index):...def__setitem__(self,index,value):...def__delitem__(self,index):...ifsys.version_info<(2,0):# They won't be defined if version is at least 2.0 finaldef__getslice__(self,i,j):returnself[max(0,i):max(0,j):]def__setslice__(self,i,j,seq):self[max(0,i):max(0,j):]=seqdef__delslice__(self,i,j):delself[max(0,i):max(0,j):]...
コンテキストマネージャ(context manager) とは、 with 文の実行時にランタイムコンテキストを定義するオブジェクトです。
コンテキストマネージャは、コードブロックを実行するために必要な入り口および出口の処理を扱います。コンテキストマネージャは通常、
with 文（ with 文 の章を参照）により起動されますが、これらのメソッドを直接呼び出すことで起動することもできます。
This behaviour means that special methods may exhibit different behaviour
for different instances of a single old-style class if the appropriate
special attributes are set differently:
新スタイルクラスでは、特殊メソッドの暗黙的な呼び出しは、オブジェクトインスタンスの辞書ではなく、
type の辞書で定義されているときにのみ正しく動作することが保証されます。
この動作は、以下のコードが(旧スタイルクラスの同等な例と異なり)例外を発生させる理由です。
>>> classC(object):... pass...>>> c=C()>>> c.__len__=lambda:5>>> len(c)Traceback (most recent call last):
File "<stdin>", line 1, in <module>TypeError: object of type 'C' has no len()
この動作の背景となる理由は、 __hash__() と __repr__() といった
type オブジェクトを含むすべてのオブジェクトで定義されている特殊メソッドにあります。
これらのメソッドの暗黙の検索が通常の検索プロセスを使った場合、
type オブジェクト自体に対して実行されたときに失敗してしまいます。
>>> 1.__hash__()==hash(1)True>>> int.__hash__()==hash(int)Traceback (most recent call last):
File "<stdin>", line 1, in <module>TypeError: descriptor '__hash__' of 'int' object needs an argument
キャッシュにモジュールが見つからなかった場合、次は sys.meta_path が検索されます。
(sys.meta_path の仕様は PEP 302 に見つけることができます。)
これは finder オブジェクトのリストで、そのモジュールを読み込む方法を
知っているかどうかをその find_module() メソッドをモジュール名を引数として
呼び出すことで、順番に問い合せていきます。
モジュールがパッケージに含まれていた(モジュール名の中にドットが含まれていた)場合、
find_module() の第2引数に親パッケージの __path__ 属性が渡されます。
(モジュール名の最後のドットより前のすべてがインポートされます)
finder はモジュールを見つけたとき、(後で解説する) loader か None
を返します。
sys.meta_path に含まれるすべての finder が module を見つけられない場合、
幾つかの暗黙的に定義されている finder に問い合わせられます。
どんな暗黙の meta path finder が定義されているかは Python の実装によって様々です。
すべての実装が定義しなければならない1つの finder は、 sys.path_hooks
を扱います。
global 文は、現在のコードブロック全体で維持される宣言文です。 global
文は、列挙した識別子をグローバル変数として解釈するよう指定することを意味します。 global
を使わずにグローバル変数に代入を行うことは不可能ですが、自由変数を使えばその変数をグローバルであると宣言せずにグローバル変数を参照することができます。
global 文で列挙する名前は、同じコードブロック中で、プログラムテキスト上 global 文より前に使っては
なりません。
global 文で列挙する名前は、 for ループのループ制御ターゲットや、 class
定義、関数定義、 import 文内で仮引数として使ってはなりません。
Javaで実装されたPythonです。この実装はJavaアプリケーションのためのスクリプト言語として，もしくはJavaクラスライブラリを使った
アプリケーションを作成するために使用することができます。また、Javaライブラリのテストを作成するためにもしばしば使用されています。さらなる情報については
the Jython website を参照してください。
Python for .NET
この実装は内部ではCPythonを使用していますが、 .NETアプリケーションによって管理されているので、
.NETライブラリを参照することが可能です。
この実装はBrian Lloydによって作成されました。
さならる情報については、`Python for .NET home page <http://pythonnet.sourceforge.net>`_
を参照してください。
IronPython
.NETでPythonを使用するためのもう一つの実装です。 Python.NETとは異なり、完全にILを生成することができるPythonの実装あり、
直接Pythonコードを.NETアセンブリにコンパイルします。これはJythonの初代の開発者であるJim Huguninによって作られました。
さらなる情報については the IronPython website
を参照してください。
PyPy
Python自体で書かれたPythonの実装です。つまり、バイトコードのインタプリタがPythonで書かれています。
背後で動作するインタプリタとしてCPythonを使用することで、この実装を実行します。このプロジェクトの一つの目的は、
（それ自体がPythonで書かれたいますので、）その言語自体によってインタプリタを簡単に修正するための実験を後押しすることです。
さらなる情報は the PyPy project’s home page にあります。
month_names=['Januari','Februari','Maart',# These are the'April','Mei','Juni',# Dutch names'Juli','Augustus','September',# for the months'Oktober','November','December']# of the year
defperm(l):# Compute the list of all permutations of liflen(l)<=1:return[l]r=[]foriinrange(len(l)):s=l[:i]+l[i+1:]p=perm(s)forxinp:r.append(l[i:i+1]+x)returnr
以下の例は、様々なインデントエラーになります:
def perm(l): # error: first line indented
for i in range(len(l)): # error: not indented
s = l[:i] + l[i+1:]
p = perm(l[:i] + l[i+1:]) # error: unexpected indent
for x in p:
r.append(l[i:i+1] + x)
return r # error: inconsistent dedent
論理行の先頭や文字列の内部にある場合を除き、空白文字であるスペース、タブ、およびフォームフィードは、トークンを分割するために自由に
利用することができます。二つのトークンを並べて書くと別のトークンとしてみなされてしまうような場合には、トークンの間に空白が必要となります (例えば、ab
は一つのトークンですが、 a b は二つのトークンとなります)。
and del from not while
as elif global or with
assert else if pass yield
break except import print
class exec in raise
continue finally is return
def for lambda try
バージョン 2.5 で変更: with_statement 機能をfuture文によって有効にしたときにのみ、
キーワード as と with は認識されます。
この機能はPython 2.6で正式に有効になる予定です。詳しくは、
with 文 節を参照してください。 as と with を識別子として使用した場合は、
たとえfuture文で with_statement が有効になっていなかったとしても常にワーニングが表示されます。
Class definitions, like function definitions, may be wrapped by one or more
decorator expressions. The evaluation rules for the decorator
expressions are the same as for functions. The result must be a class object,
which is then bound to the class name.
クラス定義は、関数定義と同じように、1つ以上のデコレータ(decorator)式でラップすることができます。
デコレータ式の評価は関数と同じです。結果はクラスオブジェクトでなければならず、
それがクラス名に束縛されます。
リスト表現は、新に作成されたリストオブジェクトを表します。新たなリストの内容は、式のリストを与えるか、リストの内包表記 (list
comprehension) で指定します。 カンマで区切られた式のリストを与えた場合、リストの各要素は左から
右へと順に評価され、評価された順番にリスト内に配置されます。リストの内包表記を与える場合、内包表記はまず単一の式、続いて少なくとも一つの
for 節、続いてゼロ個以上の for 節か if 節になります。
この場合、新たに作成されるリストの各要素は、各々の for や if
節を左から右の順にネストしたブロックとみなして実行し、ネストの最内ブロックに到達する度に式を評価した値となります。 [1]
ジェネレータ式は新たなジェネレータオブジェクトを生み出します。 ジェネレータ式は単一の式の後ろに少なくとも一つの for
節と、場合によりさらに複数の for または if 節を続けたものです。
新たなジェネレータが繰り返す値は、各 for および if 節をブロックとして、左から右へとネストし、
その最内ブロックの中で式を評価した結果を出力しているものとみなせます。
ジェネレータ式の使う変数の評価は、独立したスコープでジェネレータオブジェクトに対して
next() メソッドを呼び出すまで遅延されます。とはいえ、最も左に位置する
for 節の in はカレントスコープで直ちに評価されるため、
ジェネレータ式の最左 for 節のエラーは、ジェネレータ式を使っている
コードの他のエラーに先立って起きることがあります。その後に続く for や
if 節は、その前の for ループに依存しているため、直ちには評価されません。
例: (x*yforxinrange(10)foryinbar(x))
>>> defecho(value=None):... print"Execution starts when 'next()' is called for the first time."... try:... whileTrue:... try:... value=(yieldvalue)... exceptException,e:... value=e... finally:... print"Don't forget to clean up when 'close()' is called."...>>> generator=echo(1)>>> printgenerator.next()Execution starts when 'next()' is called for the first time.1>>> printgenerator.next()None>>> printgenerator.send(2)2>>> generator.throw(TypeError,"spam")TypeError('spam',)>>> generator.close()Don't forget to clean up when 'close()' is called.
ユニコード文字列間の比較はバイトレベルでは当然とはいえ、ユーザにとっては直感的ではないかもしれません。
例えば、文字列 u"\u00C7" と u"\u0043\u0327" の比較は、
両方の文字列が同じユニコード文字(LATIN CAPTITAL LETTER C WITH CEDILLA)で表されたとしても違います。
人間が分かり易い方法で文字列を比較するために unicodedata.normalize() を使用して比較してください。
サブクラスの決定はかなり正攻法で行いますが、クラスシステムの拡張を実装する人たちに知っておいて欲しいちょっとした問題点があります。 A と
B がクラスオブジェクトの場合、 B が A のサブクラスとなるのは、 B が
A を直接的あるいは間接的に継承 (inherit) している場合です。両方がクラスオブジェクトでない場合、二つのオブジェクト間の
クラス関係を決めるには、より汎用の機構を使います。 B が A のサブクラスであるか調べたとき、 A が B
と等しければ、 PyObject_IsSubclass() は真を返します。 A および B が異なるオブジェクトなら、 B の
__bases__ 属性から深さ優先探索 (depth-first search)で A を探索します —
オブジェクトに __bases__ があるだけで、この決定法を適用する条件を満たしているとみなされます。
マップ型オブジェクト b の全ての要素にわたって、反復的にキー/値のペアを辞書 a に追加します。 b
は辞書か、 PyMapping_Keys() または PyObject_GetItem() をサポートする何らかのオブジェクト
にできます。 override が真ならば、 a のキーと一致するキーが b にある際に、既存のペアを置き換えます。それ以外の場合は、 b
のキーに一致するキーが a にないときのみ追加を行います。成功した場合には 0 を返し、例外が送出された場合には -1 を返します。
C 関数 printf() 形式の format 文字列と可変個の引数をとり、書式化済みの文字列長を計算した上で、書式化を行った結果を
値とする Python 文字列にして返します。可変個の引数部は C のデータ型でなくてはならず、かつ format 文字列内の書式指定文字 (format
character) に一致する型でなくてはなりません。利用できる書式化文字は以下の通りです:
書式指定文字
型
コメント
%%
n/a
文字 % のリテラル。
%c
int
C の整数型で表現される単一の文字。
%d
int
C の printf("%d") と全く同じ。
%u
unsigned int
C の printf("%u") と全く同じ。
%ld
long
C の printf("%ld") と全く同じ。
%lu
unsigned long
C の printf("%lu") と全く同じ。
%zd
Py_ssize_t
C の printf("%zd") と全く同じ。
%zu
size_t
C の printf("%zu") と全く同じ。
%i
int
C の printf("%i") と全く同じ。
%x
int
C の printf("%x") と全く同じ。
%s
char*
null で終端された C の文字列。
%p
void*
C ポインタの 16
進表記。 printf("%p")
とほとんど同じだが、プラットフォームにおける
printf の定義に関わりなく先頭にリテラル
0x が付きます。
新たにメモリ確保されたオブジェクト op に対し、型と初期状態での参照 (initial reference) を初期化します。
初期化されたオブジェクトを返します。 type からそのオブジェクトが循環参照ガベージ検出の機能を有する場合、検出機構が監視対象とする
オブジェクトのセットに追加されます。オブジェクトの他のフィールドには影響を及ぼしません。
typedefstruct_typeobject{PyObject_VAR_HEADchar*tp_name;/* For printing, in format "<module>.<name>" */inttp_basicsize,tp_itemsize;/* For allocation *//* Methods to implement standard operations */destructortp_dealloc;printfunctp_print;getattrfunctp_getattr;setattrfunctp_setattr;cmpfunctp_compare;reprfunctp_repr;/* Method suites for standard classes */PyNumberMethods*tp_as_number;PySequenceMethods*tp_as_sequence;PyMappingMethods*tp_as_mapping;/* More standard operations (here for binary compatibility) */hashfunctp_hash;ternaryfunctp_call;reprfunctp_str;getattrofunctp_getattro;setattrofunctp_setattro;/* Functions to access object as input/output buffer */PyBufferProcs*tp_as_buffer;/* Flags to define presence of optional/expanded features */longtp_flags;char*tp_doc;/* Documentation string *//* Assigned meaning in release 2.0 *//* call function for all accessible objects */traverseproctp_traverse;/* delete references to contained objects */inquirytp_clear;/* Assigned meaning in release 2.1 *//* rich comparisons */richcmpfunctp_richcompare;/* weak reference enabler */longtp_weaklistoffset;/* Added in release 2.2 *//* Iterators */getiterfunctp_iter;iternextfunctp_iternext;/* Attribute descriptor and subclassing stuff */structPyMethodDef*tp_methods;structPyMemberDef*tp_members;structPyGetSetDef*tp_getset;struct_typeobject*tp_base;PyObject*tp_dict;descrgetfunctp_descr_get;descrsetfunctp_descr_set;longtp_dictoffset;initproctp_init;allocfunctp_alloc;newfunctp_new;freefunctp_free;/* Low-level free-memory routine */inquirytp_is_gc;/* For PyObject_IS_GC */PyObject*tp_bases;PyObject*tp_mro;/* method resolution order */PyObject*tp_cache;PyObject*tp_subclasses;PyObject*tp_weaklist;}PyTypeObject;
typedefstruct{binaryfuncnb_add;binaryfuncnb_subtract;binaryfuncnb_multiply;binaryfuncnb_divide;binaryfuncnb_remainder;binaryfuncnb_divmod;ternaryfuncnb_power;unaryfuncnb_negative;unaryfuncnb_positive;unaryfuncnb_absolute;inquirynb_nonzero;/* Used by PyObject_IsTrue */unaryfuncnb_invert;binaryfuncnb_lshift;binaryfuncnb_rshift;binaryfuncnb_and;binaryfuncnb_xor;binaryfuncnb_or;coercionnb_coerce;/* Used by the coerce() function */unaryfuncnb_int;unaryfuncnb_long;unaryfuncnb_float;unaryfuncnb_oct;unaryfuncnb_hex;/* Added in release 2.0 */binaryfuncnb_inplace_add;binaryfuncnb_inplace_subtract;binaryfuncnb_inplace_multiply;binaryfuncnb_inplace_divide;binaryfuncnb_inplace_remainder;ternaryfuncnb_inplace_power;binaryfuncnb_inplace_lshift;binaryfuncnb_inplace_rshift;binaryfuncnb_inplace_and;binaryfuncnb_inplace_xor;binaryfuncnb_inplace_or;/* Added in release 2.2 */binaryfuncnb_floor_divide;binaryfuncnb_true_divide;binaryfuncnb_inplace_floor_divide;binaryfuncnb_inplace_true_divide;/* Added in release 2.5 */unaryfuncnb_index;}PyNumberMethods;
p が指しているメモリブロックを n バイトにサイズ変更します。メモリの内容のうち、新旧のサイズのうち小さい方までの領域は変更されません。 p が
NULL ならば、この関数は PyMem_Malloc(n)() と等価になります; それ以外の場合で、 n がゼロに等しければ、
メモリブロックはサイズ変更されますが、解放されず、非 NULL のポインタを返します。 p の値を NULL にしないのなら、以前呼び出した
PyMem_Malloc() や PyMem_Realloc() の返した値でなければなりません。
p が指すメモリブロックを解放します。 p は以前呼び出した PyMem_Malloc() や
PyMem_Realloc() の返した値でなければなりません。それ以外の場合や、すでに PyMem_Free(p)() を
呼び出した後だった場合、未定義の動作になります。 p が NULL なら、何も行いません。
以下に挙げる型対象のマクロは利便性のために提供されているものです。 TYPE は任意の C の型を表します。
PyMem_Realloc() と同じですが、 (n*sizeof(TYPE))
バイトにサイズ変更されたメモリを確保します。
TYPE* に型キャストされたポインタを返します。
関数が終わったとき、 p は新しいメモリ領域のポインタか、失敗した場合は
NULL になります。これは C プリプロセッサのマクロで、 p
は常に上書きされます。エラーを処理するときにメモリを失う事を避けるには、
p の元の値を保存しておいてください。
PyObject*res;char*buf=(char*)PyMem_Malloc(BUFSIZ);/* for I/O */if(buf==NULL)returnPyErr_NoMemory();/* ...Do some I/O operation involving buf... */res=PyString_FromString(buf);PyMem_Free(buf);/* allocated with PyMem_Malloc */returnres;
同じコードを型対象の関数セットで書いたものを以下に示します:
PyObject*res;char*buf=PyMem_New(char,BUFSIZ);/* for I/O */if(buf==NULL)returnPyErr_NoMemory();/* ...Do some I/O operation involving buf... */res=PyString_FromString(buf);PyMem_Del(buf);/* allocated with PyMem_New */returnres;
上の二つの例では、バッファを常に同じ関数セットに属する関数で操作していることに注意してください。
実際、あるメモリブロックに対する操作は、異なるメモリ操作機構を混用する危険を減らすために、同じメモリ API ファミリを使って行うことが
必要です。以下のコードには二つのエラーがあり、そのうちの一つには異なるヒープを操作する別のメモリ操作関数を混用しているので 致命的 (Fatal)
とラベルづけをしています。
char*buf1=PyMem_New(char,BUFSIZ);char*buf2=(char*)malloc(BUFSIZ);char*buf3=(char*)PyMem_Malloc(BUFSIZ);...PyMem_Del(buf3);/* Wrong -- should be PyMem_Free() */free(buf2);/* Right -- allocated via malloc() */free(buf1);/* Fatal -- should be PyMem_Del() */
int PyErr_WarnPy3k(char *message, int stacklevel)¶
Issue a DeprecationWarning with the given message and stacklevel
if the Py_Py3kWarningFlag flag is enabled.
Py_Py3kWarningFlag フラグが有効な場合、
与えられた message と stacklevel に応じて DeprecationWarning を発生させます。
インタプリタがスタック空間を使い尽くしたときに真を返します。このチェック関数には信頼性がありますが、 USE_STACKCHECK
が定義されている場合 (現状では Microsoft Visual C++ コンパイラでビルドした Windows 版) にしか利用できません .
USE_CHECKSTACK は自動的に定義されます; 自前のコードでこの定義を変更してはなりません。
しかし実際には、タプルやリストを生成して値を入れる際には、上記のような方法はほとんど使いません。
より汎用性のある関数、 Py_BuildValue() があり、ほとんどの主要なオブジェクトをフォーマット文字列 format
string の指定に基づいて C の値から生成できます。例えば、上の二種類のコードブロックは、以下のように置き換えられます
(エラーチェックにも配慮しています):
Structure which describes an attribute of a type which corresponds to a C
struct member. Its fields are:
type の構造体に C 言語のメンバとして格納されている、 type の属性を表す構造体です。
この構造体のフィールドは以下のとおりです。
Like PyImport_ExecCodeModule(), but the __file__ attribute of
the module object is set to pathname if it is non-NULL.
PyImport_ExecCodeModule() に似ていますが、 pathname が NULL で無い場合、
モジュールオブジェクトの __file__ 属性に設定します。
This function is similar to PyNumber_Coerce(), except that it returns
1 when the conversion is not possible and when no error is raised.
Reference counts are still not increased in this case.
この関数は PyNumber_Coerce() と似ていますが、
変換が失敗た場合にはエラーを発生させず、 -1 を返します。
この場合、参照カウントはインクリメントされません。
If base64SetO is nonzero, “Set O” (punctuation that has no otherwise
special meaning) will be encoded in base-64. If base64WhiteSpace is
nonzero, whitespace will be encoded in base-64. Both are set to zero for the
Python “utf-7” codec.
base64SetO が非ゼロのとき、 “Set O” 文字
(他の場合には何も特別な意味を持たない句読点) を base-64 エンコードします。
base64WhiteSpace が非ゼロのとき、空白文字を base-64 エンコードします。
Python の “utf-7” コーデックでは、両方ともゼロに設定されています。
Python オブジェクトを (一切変換を行わずに) C の Python オブジェクト型ポインタに保存します。これにより、C
プログラムは実際のオブジェクトを受け渡しされます。オブジェクトの参照カウントは増加しません。保存されるポインタが NULL になることはありません。
O! (オブジェクト) [typeobject, PyObject *]
Python オブジェクトを C の Python オブジェクト型ポインタに保存します。 O に似ていますが、二つの C の引数をとります:
一つ目の引数は Python の型オブジェクトへのアドレスで、二つ目の引数はオブジェクトへのポインタが保存されている (PyObject*
の) C の変数へのアドレスです。Python オブジェクトが指定した型ではない場合、 TypeError を送出します。
O& (オブジェクト) [converter, anything]
Python オブジェクトを converter 関数を介して C の変数に変換します。二つの引数をとります: 一つ目は関数で、二つ目は (任意の型の)
C 変数へのアドレスを void* 型に変換したものです。 converter は以下のようにして呼び出されます:
If updatepath is zero, this is all the function does. If updatepath
is non-zero, the function also modifies sys.path according to the
following algorithm:
updatepath が 0 のとき、これがこの関数がすることの全てです。
updatepath が 0 でないとき、この関数は sys.path を以下の
アルゴリズムに基づいて修正します。
C でスレッドを生成した場合、そのスレッドにはグローバルインタプリタロックが
なく、スレッド状態データ構造体もないことに注意する必要があります。
このようなスレッドが Python/C API を利用するには、まずスレッド状態データ構造体を
生成し、次にロックを獲得し、そしてスレッド状態ポインタを保存するといったように、自分自身をブートストラップして生成しなければ
なりません。スレッドが作業を終えたら、スレッド状態ポインタをリセットして、ロックを解放し、最後にスレッド状態データ構造体をメモリ解放しなければなりません。
バージョン 2.3 からは、上記の事を全て自動で行われて、スレッドは PyGILState_*() の恩恵に預かることができます。 C
のスレッドから Python を呼び出す典型的な方法は以下のとおりです。
PyGILState_STATEgstate;gstate=PyGILState_Ensure();/* Perform Python actions here. */result=CallSomeFunction();/* evaluate result *//* Release the thread. No Python API allowed beyond this point. */PyGILState_Release(gstate);
int PyThreadState_SetAsyncExc(long id, PyObject *exc)¶
スレッド内で非同期的に例外を送出します。 id 引数はターゲットとなるスレッドのスレッド id です; exc は送出する例外オブジェクトです。
この関数は exc に対する参照を一切盗み取りません。素朴な間違いを防ぐため、この関数を呼び出すには独自に C 拡張モジュールを書かねばなりません。
グローバルインタプリタロックを保持した状態で呼び出さなければなりません。
int PyBuffer_FillInfo(Py_buffer *view, PyObject *obj, void *buf, Py_ssize_t len, int readonly, int infoflags)¶
Fill in a buffer-info structure, view, correctly for an exporter that can
only share a contiguous chunk of memory of “unsigned bytes” of the given
length. Return 0 on success and -1 (with raising an error) on error.
バッファ提供側が与えられた長さの “unsigned bytes” の連続した1つのメモリブロックしか
提供できないものとして、 view バッファ情報構造体を正しく埋める。
成功したら 0 を、エラー時には(例外を発生させつつ) -1 を返す。
int PyRun_SimpleFileExFlags(FILE *fp, const char *filename, int closeit, PyCompilerFlags *flags)¶
Similar to PyRun_SimpleStringFlags(), but the Python source
PyRun_SimpleString() と似ていますが、Pythonソースコードをメモリ内の文字列ではなく fp から読み込みます。
filename はそのファイルの名前でなければなりません。 closeit が真ならば、PyRun_SimpleFileExFlags は処理を戻す前に
ファイルを閉じます。
int PyRun_InteractiveOne(FILE *fp, const char *filename)¶
シーケンス o がすでにタプルやリストであれば o を返し、そうでなければ o をタプルで返します。返されるタプルのメンバにアクセスするには
PySequence_Fast_GET_ITEM() を使ってください。失敗すると NULL を返します。
オブジェクトがシーケンスでなければ、 m がメッセージテキストになっている TypeError を送出します。
#!/usr/bin/env pythonfromdistutils.coreimportsetupsetup(name='Distutils',version='1.0',description='Python Distribution Utilities',author='Greg Ward',author_email='gward@python.net',url='http://www.python.org/sigs/distutils-sig/',packages=['distutils','distutils.command'],)
setup(...,classifiers=['Development Status :: 4 - Beta','Environment :: Console','Environment :: Web Environment','Intended Audience :: End Users/Desktop','Intended Audience :: Developers','Intended Audience :: System Administrators','License :: OSI Approved :: Python Software Foundation License','Operating System :: MacOS :: MacOS X','Operating System :: Microsoft :: Windows','Operating System :: POSIX','Programming Language :: Python','Topic :: Communications :: Email','Topic :: Office/Business','Topic :: Software Development :: Bug Tracking',],)
# patch distutils if it can't cope with the "classifiers" or# "download_url" keywordsfromsysimportversionifversion<'2.2.3':fromdistutils.distimportDistributionMetadataDistributionMetadata.classifiers=NoneDistributionMetadata.download_url=None
running register
We need to know who you are, so please choose either:
1. use your existing login,
2. register as a new user,
3. have the server generate a new password for you (and email it to you), or
4. quit
Your selection [default 1]:
配布物の名前は name オプションで個々に指定し、配布されるモジュールの一つと配布物を同じ名前にする必要はないことに注意してください
(とはいえ、この命名方法はよいならわしでしょう)。ただし、配布物名はファイル名を作成するときに使われるので、
文字、数字、アンダースコア、ハイフンだけで構成しなければなりません。
py_modules はリストなので、もちろん複数のモジュールを指定できます。例えば、モジュール foo と
bar を配布しようとしているのなら、 setup スクリプトは以下のようになります:
> python setup.py --help build_ext
[...]
Options for 'build_ext' command:
--build-lib (-b) directory for compiled extension modules
--build-temp (-t) directory for temporary files (build by-products)
--inplace (-i) ignore build-lib and put compiled extensions into the
source directory alongside your pure Python modules
--include-dirs (-I) list of directories to search for header files
--define (-D) C preprocessor macros to define
--undef (-U) C preprocessor macros to undefine
--swig-opts list of SWIG command line options
[...]
(pure Python モジュールとパッケージだけの入った) pure モジュール配布物の場合、作成されるインストーラは実行バージョンに依存しない
形式になり、 foo-1.0.win32.exe のような名前になります。 pure モジュールの Windows インストーラは Unix や
Mac OS X でも作成できます。
非 pure 配布物の場合、拡張モジュールは Windows プラットフォーム上だけで作成でき、Python のバージョンに依存したインストーラになります。
インストーラのファイル名もバージョン依存性を反映して、 foo-1.0.win32-py2.0.exe のような形式になります。
従って、サポートしたい全てのバージョンの Python に対して、別々のインストーラを作成しなければなりません。
from distutils.command.build_py import build_py as _build_py
from distutils.core import setup
class build_py(_build_py):
"""Specialized Python source builder."""
# implement whatever needs to be different...
setup(cmdclass={'build_py': build_py},
...)
Python-2.6.2-DocJa-1/_sources/ 0000755 0001750 0001750 00000000000 11477163433 015351 5 ustar inada-n inada-n Python-2.6.2-DocJa-1/_sources/glossary.txt 0000644 0001750 0001750 00000146751 11474251542 017767 0 ustar inada-n inada-n .. _glossary:
********
用語集
********
.. if you add new entries, keep the alphabetical sorting!
.. glossary::
``>>>``
.. The default Python prompt of the interactive shell. Often seen for code
examples which can be executed interactively in the interpreter.
インタラクティブシェルにおける、デフォルトのPythonプロンプト。
インタラクティブに実行されるコードサンプルとしてよく出てきます。
``...``
.. The default Python prompt of the interactive shell when entering code for
an indented code block or within a pair of matching left and right
delimiters (parentheses, square brackets or curly braces).
インタラクティブシェルにおける、インデントされたコードブロックや対応する括弧(丸括弧()、
角括弧[]、curly brace{})の内側で表示されるデフォルトのプロンプト。
2to3
.. A tool that tries to convert Python 2.x code to Python 3.x code by
handling most of the incompatibilites which can be detected by parsing the
source and traversing the parse tree.
Python 2.x のコードを Python 3.x のコードに変換するツール。
ソースコードを解析して、その解析木を巡回(traverse)して、非互換なコードの大部分を処理する。
.. 2to3 is available in the standard library as :mod:`lib2to3`; a standalone
entry point is provided as :file:`Tools/scripts/2to3`. See
:ref:`2to3-reference`.
2to3 は、 :mod:`lib2to3` モジュールとして標準ライブラリに含まれています。
スタンドアローンのツールとして使うときのコマンドは :file:`Tools/scripts/2to3`
として提供されています。 :ref:`2to3-reference` を参照してください。
abstract base class
.. Abstract Base Classes (abbreviated ABCs) complement :term:`duck-typing` by
providing a way to define interfaces when other techniques like :func:`hasattr`
would be clumsy. Python comes with many builtin ABCs for data structures
(in the :mod:`collections` module), numbers (in the :mod:`numbers`
module), and streams (in the :mod:`io` module). You can create your own
ABC with the :mod:`abc` module.
(抽象基底クラス) Abstract Base Classes (ABCs と略されます)は :term:`duck-typing`
を補完するもので、 :func:`hasattr` などの別のテクニックでは不恰好になる場合に
インタフェースを定義する方法を提供します。
Pythonは沢山のビルトインABCsを、(:mod:`collections` モジュールで)データ構造、
(:mod:`numbers` モジュールで)数値型、(:mod:`io` モジュールで)ストリーム型で
提供いています。
:mod:`abc` モジュールを利用して独自のABCを作成することもできます。
argument
(引数)
関数やメソッドに渡された値。関数の中では、名前の付いたローカル変数に代入されます。
関数やメソッドは、その定義中に位置指定引数(positional arguments, 訳注: ``f(1, 2)``
のように呼び出し側で名前を指定せず、引数の位置に引数の値を対応付けるもの)
とキーワード引数(keyword arguments, 訳注: ``f(a=1, b=2)`` のように、引数名に
引数の値を対応付けるもの)の両方を持つことができます。
位置指定引数とキーワード引数は可変長です。
関数定義や呼び出しは、 ``*`` を使って、不定数個の位置指定引数をシーケンス型に入れて
受け取ったり渡したりすることができます。
同じく、キーワード引数は ``**`` を使って、辞書に入れて受け取ったり渡したりできます。
引数リスト内では任意の式を使うことができ、その式を評価した値が渡されます。
.. todo::
キーワード引数？名前付き引数？
順序付き引数？順序引数？位置指定引数？
attribute
(属性)
オブジェクトに関連付けられ、ドット演算子を利用して名前で参照される値。
例えば、オブジェクト *o* が属性 *a* を持っているとき、その属性は
*o.a* で参照されます。
BDFL
慈悲ぶかき独裁者 (Benevolent Dictator For Life) の略です。
Python の作者、 `Guido van Rossum `_
のことです。
.. Benevolent Dictator For Life, a.k.a. `Guido van Rossum
`_, Python's creator.
bytecode
(バイトコード)
Pythonのソースコードはバイトコードへとコンパイルされます。
バイトコードはPythonプログラムのインタプリタ内部での形です。
バイトコードはまた、 ``.pyc`` や ``.pyo`` ファイルにキャッシュされ、
同じファイルを二度目に実行した際により高速に実行できるようにします
(ソースコードからバイトコードへの再度のコンパイルは回避されます)。
このバイトコードは、各々のバイトコードに対応するサブルーチンを呼び出すような
"仮想計算機(:term:`virtual machine`)" で動作する "中間言語 (intermediate language)" といえます。
.. Python source code is compiled into bytecode, the internal representation
of a Python program in the interpreter. The bytecode is also cached in
``.pyc`` and ``.pyo`` files so that executing the same file is faster the
second time (recompilation from source to bytecode can be avoided). This
"intermediate language" is said to run on a :term:`virtual machine`
that executes the machine code corresponding to each bytecode.
class
(クラス)
ユーザー定義オブジェクトを作成するためのテンプレート。
クラス定義は普通、そのクラスのインスタンス上の操作をするメソッドの定義を含みます。
classic class
(旧スタイルクラス)
:class:`object` を継承していないクラス全てを指します。
新スタイルクラス(:term:`new-style class`) も参照してください。
旧スタイルクラスはPython 3.0で削除されます。
.. Any class which does not inherit from :class:`object`. See
:term:`new-style class`. Classic classes will be removed in Python 3.0.
coercion
(型強制)
同じ型の2つの引数を要する演算の最中に、ある型のインスタンスを別の型に暗黙のうちに変換することです。
例えば、 ``int(3.15)`` は浮動小数点数を整数の ``3`` にします。
しかし、 ``3+4.5`` の場合、各引数は型が異なっていて(一つは整数、一つは浮動小数点数)、
加算をする前に同じ型に変換しなければいけません。そうでないと、 ``TypeError`` 例外が投げられます。
2つの被演算子間の型強制は組み込み関数の ``coerce`` を使って行えます。
従って、 ``3+4.5`` は ``operator.add(*coerce(3, 4.5))`` を呼び出すことに等しく、
``operator.add(3.0, 4.5)`` という結果になります。
型強制を行わない場合、たとえ互換性のある型であっても、すべての引数はプログラマーが、
単に ``3+4.5`` とするのではなく、
``float(3)+4.5`` というように、同じ型に正規化しなければいけません。
.. The implicit conversion of an instance of one type to another during an
operation which involves two arguments of the same type. For example,
``int(3.15)`` converts the floating point number to the integer ``3``, but
in ``3+4.5``, each argument is of a different type (one int, one float),
and both must be converted to the same type before they can be added or it
will raise a ``TypeError``. Coercion between two operands can be
performed with the ``coerce`` builtin function; thus, ``3+4.5`` is
equivalent to calling ``operator.add(*coerce(3, 4.5))`` and results in
``operator.add(3.0, 4.5)``. Without coercion, all arguments of even
compatible types would have to be normalized to the same value by the
programmer, e.g., ``float(3)+4.5`` rather than just ``3+4.5``.
complex number
(複素数)
よく知られている実数系を拡張したもので、すべての数は実部と虚部の和として表されます。
虚数は虚数単位元(``-1`` の平方根)に実数を掛けたもので、一般に数学では ``i``
と書かれ、工業では ``j`` と書かれます。
Pythonは複素数に組込みで対応し、後者の表記を取っています。
虚部は末尾に ``j`` をつけて書きます。例えば、 ``3+1j`` となります。
:mod:`math` モジュールの複素数版を利用するには、 :mod:`cmath` を使います。
複素数の使用はかなり高度な数学の機能です。
必要性を感じなければ、ほぼ間違いなく無視してしまってよいでしょう。
.. An extension of the familiar real number system in which all numbers are
expressed as a sum of a real part and an imaginary part. Imaginary
numbers are real multiples of the imaginary unit (the square root of
``-1``), often written ``i`` in mathematics or ``j`` in
engineering. Python has builtin support for complex numbers, which are
written with this latter notation; the imaginary part is written with a
``j`` suffix, e.g., ``3+1j``. To get access to complex equivalents of the
:mod:`math` module, use :mod:`cmath`. Use of complex numbers is a fairly
advanced mathematical feature. If you're not aware of a need for them,
it's almost certain you can safely ignore them.
context manager
(コンテキストマネージャー)
:keyword:`with` 文で扱われる、環境を制御するオブジェクト。
:meth:`__enter__` と :meth:`__exit__` メソッドを定義することで作られる。
:pep:`343` を参照。
CPython
Pythonプログラミング言語の基準となる実装。
CPython という単語は、この実装を Jython や IronPython といった他の実装と
区別する必要が有る文脈で利用されます。
decorator
(デコレータ)
関数を返す関数。
通常、 ``@wrapper`` という文法によって関数を変換するのに利用されます。
デコレータの一般的な利用レとして、 :func:`classmethod` と
:func:`staticmethod` があります。
デコレータの文法はシンタックスシュガーです。
次の2つの関数定義は意味的に同じものです。 ::
def f(...):
...
f = staticmethod(f)
@staticmethod
def f(...):
...
デコレータについてのより詳しい情報は、
:ref:`the documentation for function definition `
を参照してください。
descriptor
(デスクリプタ)
メソッド :meth:`__get__`, :meth:`__set__`, あるいは :meth:`__delete__`
が定義されている *新スタイル (new-style)* のオブジェクトです。
あるクラス属性がデスクリプタである場合、その属性を参照するときに、
そのデスクリプタに束縛されている特別な動作を呼び出します。
通常、get,set,deleteのために *a.b* と書くと、 *a* のクラス辞書内でオブジェクト
*b* を検索しますが、 *b* がデスクリプタの場合にはデスクリプタで定義された
メソッドを呼び出します。
デスクリプタの理解は、 Python を深く理解する上で鍵となります。
というのは、デスクリプタこそが、関数、メソッド、プロパティ、
クラスメソッド、静的メソッド、そしてスーパクラスの参照といった多くの機能の基盤だからです。
.. todo::
デスクリプタとディスクリプタのどちらかに統一する。
.. Any *new-style* object which defines the methods :meth:`__get__`,
:meth:`__set__`, or :meth:`__delete__`. When a class attribute is a
descriptor, its special binding behavior is triggered upon attribute
lookup. Normally, using *a.b* to get, set or delete an attribute looks up
the object named *b* in the class dictionary for *a*, but if *b* is a
descriptor, the respective descriptor method gets called. Understanding
descriptors is a key to a deep understanding of Python because they are
the basis for many features including functions, methods, properties,
class methods, static methods, and reference to super classes.
For more information about descriptors' methods, see :ref:`descriptors`.
dictionary
(辞書)
任意のキーを値に対応付ける連想配列です。
:class:`dict` の使い方は :class:`list` に似ていますが、ゼロから始まる整数に限らず、
:meth:`__hash__` 関数を実装している全てのオブジェクトをキーにできます。
Perl ではハッシュ (hash) と呼ばれています。
.. An associative array, where arbitrary keys are mapped to values. The use
of :class:`dict` closely resembles that for :class:`list`, but the keys can
be any object with a :meth:`__hash__` function, not just integers.
Called a hash in Perl.
docstring
クラス、関数、モジュールの最初の式となっている文字列リテラルです。
実行時には無視されますが、コンパイラによって識別され、そのクラス、
関数、モジュールの :attr:`__doc__` 属性として保存されます。
イントロスペクションできる（訳注: 属性として参照できる）ので、
オブジェクトのドキュメントを書く正しい場所です。
.. todo::
ドキュメンテーション文字列？？ 統一した訳語を定義する。
duck-typing
Python 的なプログラムスタイルではオブジェクトの型を（型オブジェクトとの関係ではなく）
メソッドや属性といったシグネチャを見ることで判断します。
（「もしそれがガチョウのようにみえて、ガチョウのように鳴けば、それはガチョウである」）
インタフェースを型より重視することで、上手くデザインされたコードは
(polymorphicな置換を許可することによって)柔軟性を増すことができます。
duck-typing は :func:`type` や :func:`isinstance` を避けます。
(ただし、duck-typing を抽象ベースクラス(abstract base classes)で補完することもできます。)
その代わりに :func:`hasattr` テストや *EAFP* プログラミングを利用します。
.. A pythonic programming style which determines an object's type by inspection
of its method or attribute signature rather than by explicit relationship
to some type object ("If it looks like a duck and quacks like a duck, it
must be a duck.") By emphasizing interfaces rather than specific types,
well-designed code improves its flexibility by allowing polymorphic
substitution. Duck-typing avoids tests using :func:`type` or
:func:`isinstance`. (Note, however, that duck-typing can be complemented
with abstract base classes.) Instead, it typically employs :func:`hasattr`
tests or :term:`EAFP` programming.
EAFP
「認可をとるより許しを請う方が容易 (easier to ask for forgiveness than permission、マーフィーの法則)」
の略です。 Python で広く使われているコーディングスタイルでは、通常は有効なキーや
属性が存在するものと仮定し、その仮定が誤っていた場合に例外を捕捉します。
この簡潔で手早く書けるコーディングスタイルには、 :keyword:`try` 文および
:keyword:`except` 文がたくさんあるのが特徴です。
このテクニックは、C のような言語でよく使われている :term:`LBYL` スタイルと対照的なものです。
.. Easier to ask for forgiveness than permission. This common Python coding
style assumes the existence of valid keys or attributes and catches
exceptions if the assumption proves false. This clean and fast style is
characterized by the presence of many :keyword:`try` and :keyword:`except`
statements. The technique contrasts with the :term:`LBYL` style
common to many other languages such as C.
expression
(式)
何かの値に評価される、一つづきの構文(a piece of syntax).
言い換えると、リテラル、名前、属性アクセス、演算子や関数呼び出しといった、
値を返す式の要素の組み合わせ。
他の多くの言語と違い、Pythonは言語の全ての構成要素が式というわけではありません。
:keyword:`print` や :keyword:`if` のように、式にはならない、文(:term:`statement`)
もあります。代入も式ではなく文です。
extension module
(拡張モジュール)
CやC++で書かれたモジュール。ユーザーコードやPythonのコアとやりとりするために、
PythonのC APIを利用します。
finder
モジュールの :term:`loader` を探すオブジェクト。
:meth:`find_module` という名前のメソッドを実装していなければなりません。
詳細については :pep:`302` を参照してください。
function
(関数)
呼び出し側に値を返す、一連の文。
ゼロ個以上の引数を受け取り、それを関数の本体を実行するときに諒できます。
:term:`argument` や :term:`method` も参照してください。
__future__
互換性のない新たな機能を現在のインタプリタで有効にするためにプログラマが
利用できる擬似モジュールです。例えば、式 ``11/4`` は現状では ``2``
になります。この式を実行しているモジュールで ::
from __future__ import division
を行って *真の除算操作 (true division)* を有効にすると、式 ``11/4`` は
``2.75`` になります。実際に :mod:`__future__` モジュールを import
してその変数を評価すれば、新たな機能が初めて追加されたのがいつで、
いつデフォルトの機能になる予定かわかります。 ::
>>> import __future__
>>> __future__.division
_Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)
garbage collection
(ガベージコレクション)
もう使われなくなったメモリを開放する処理。
Pythonは、Pythonは参照カウントと循環参照を見つけて破壊する循環参照コレクタ
を使ってガベージコレクションを行います。
.. index:: single: generator
generator
(ジェネレータ)
イテレータを返す関数です。 :keyword:`return` 文の代わりに :keyword:`yield`
文を使って呼び出し側に要素を返す他は、通常の関数と同じに見えます。
よくあるジェネレータ関数は一つまたはそれ以上の :keyword:`for` ループや :keyword:`while` ループ
を含んでおり、ループの呼び出し側に要素を返す(:keyword:`yield`)ようになっています。
ジェネレータが返すイテレータを使って関数を実行すると、関数は
:keyword:`yield` キーワードで (値を返して) 一旦停止し、 :meth:`next`
を呼んで次の要素を要求するたびに実行を再開します。
.. A function which returns an iterator. It looks like a normal function
except that values are returned to the caller using a :keyword:`yield`
statement instead of a :keyword:`return` statement. Generator functions
often contain one or more :keyword:`for` or :keyword:`while` loops which
:keyword:`yield` elements back to the caller. The function execution is
stopped at the :keyword:`yield` keyword (returning the result) and is
resumed there when the next element is requested by calling the
:meth:`next` method of the returned iterator.
.. index:: single: generator expression
generator expression
(ジェネレータ式)
ジェネレータを返す式です。
普通の式に、ループ変を定義している :keyword:`for` 式、範囲、そしてオプショナルな
:keyword:`if` 式がつづいているように見えます。
こうして構成された式は、外側の関数に対して値を生成します。::
>>> sum(i*i for i in range(10)) # sum of squares 0, 1, 4, ... 81
285
.. An expression that returns a generator. It looks like a normal expression
followed by a :keyword:`for` expression defining a loop variable, range,
and an optional :keyword:`if` expression. The combined expression
generates values for an enclosing function::
GIL
グローバルインタプリタロック(:term:`global interpreter lock`)を参照してください。
global interpreter lock
(グローバルインタプリタロック)
:term:`CPython` のVM(:term:`virtual machine`)の中で一度に1つのスレッドだけが
動作することを保証するために使われているロックです。
このロックによって、同時に同じメモリにアクセスする2つのプロセスは存在しないと保証されているので、
CPython を単純な構造にできるのです。
インタプリタ全体にロックをかけると、多重プロセサ計算機における並列性の恩恵と引き換えにインタプリタの
多重スレッド化を簡単に行えます。かつて "スレッド自由な (free-threaded)"
インタプリタを作ろうと努力したことがありましたが、広く使われている単一プロセッサの場合には
パフォーマンスが低下するという事態に悩まされました。
.. The lock used by Python threads to assure that only one thread
executes in the :term:`CPython` :term:`virtual machine` at a time.
This simplifies the CPython implementation by assuring that no two
processes can access the same memory at the same time. Locking the
entire interpreter makes it easier for the interpreter to be
multi-threaded, at the expense of much of the parallelism afforded by
multi-processor machines. Efforts have been made in the past to
create a "free-threaded" interpreter (one which locks shared data at a
much finer granularity), but so far none have been successful because
performance suffered in the common single-processor case.
hashable
(ハッシュ可能)
*ハッシュ可能* なオブジェクトとは、生存期間中変わらないハッシュ値を持ち
(:meth:`__hash__` メソッドが必要)、他のオブジェクトと比較ができる
(:meth:`__eq__` か :meth:`__cmp__` メソッドが必要) オブジェクトです。
同値なハッシュ可能オブジェクトは必ず同じハッシュ値を持つ必要があります。
辞書のキーや集合型のメンバーは、内部でハッシュ値を使っているので、
ハッシュ可能オブジェクトである必要があります。
Python の全ての不変(:term:`immutable`)なビルドインオブジェクトはハッシュ可能です。
リストや辞書といった変更可能なコンテナ型はハッシュ可能ではありません。
ユーザー定義クラスのインスタンスはデフォルトでハッシュ可能です。
それらは、比較すると常に不等で、ハッシュ値は :func:`id` になります。
IDLE
Python の組み込み開発環境 (Integrated DeveLopment Environment) です。
IDLE は Pythonの標準的な配布物についてくる基本的な機能のエディタとインタプリタ環境です。
初心者に向いている点として、 IDLEはよく洗練され、複数プラットフォームで動作する GUI
アプリケーションを実装したい人むけの明解なコード例にもなっています。
.. An Integrated Development Environment for Python. IDLE is a basic editor
and interpreter environment which ships with the standard distribution of
Python. Good for beginners, it also serves as clear example code for
those wanting to implement a moderately sophisticated, multi-platform GUI
application.
immutable
(不変オブジェクト)
固定の値を持ったオブジェクトです。
変更不能なオブジェクトには、数値、文字列、およびタプルなどがあります。
これらのオブジェクトは値を変えられません。
別の値を記憶させる際には、新たなオブジェクトを作成しなければなりません。
不変オブジェクトは、固定のハッシュ値が必要となる状況で重要な役割を果たします。
辞書におけるキーがその例です。
.. An object with a fixed value. Immutable objects include numbers, strings and
tuples. Such an object cannot be altered. A new object has to
be created if a different value has to be stored. They play an important
role in places where a constant hash value is needed, for example as a key
in a dictionary.
integer division
(整数除算)
剰余を考慮しない数学的除算です。例えば、式 ``11/4`` は現状では ``2.75`` ではなく
``2`` になります。これは *切り捨て除算 (floor division)* とも呼ばれます。
二つの整数間で除算を行うと、結果は (端数切捨て関数が適用されて) 常に整数になります。
しかし、被演算子の一方が (:class:`float` のような) 別の数値型の場合、
演算の結果は共通の型に型強制されます (型強制(:term:`coercion`)参照)。
例えば、浮動小数点数で整数を除算すると結果は浮動小数点になり、
場合によっては端数部分を伴います。 ``//`` 演算子を
``/`` の代わりに使うと、整数除算を強制できます。
:term:`__future__` も参照してください。
.. Mathematical division discarding any remainder. For example, the
expression ``11/4`` currently evaluates to ``2`` in contrast to the
``2.75`` returned by float division. Also called *floor division*.
When dividing two integers the outcome will always be another integer
(having the floor function applied to it). However, if one of the operands
is another numeric type (such as a :class:`float`), the result will be
coerced (see :term:`coercion`) to a common type. For example, an integer
divided by a float will result in a float value, possibly with a decimal
fraction. Integer division can be forced by using the ``//`` operator
instead of the ``/`` operator. See also :term:`__future__`.
importer
モジュールを探してロードするオブジェクト。 :term:`finder` と :term:`loader`
のどちらでもあるオブジェクト。
interactive
(対話的)
Python には対話的インタプリタがあり、文や式をインタプリタのプロンプトに
入力すると即座に実行されて結果を見ることができます。
``python`` と何も引数を与えずに実行してください。(コンピュータのメインメニューから
Pythonの対話的インタプリタを起動できるかもしれません。)
対話的インタプリタは、新しいあアイデアを試してみたり、モジュールや
パッケージの中を覗いてみる(``help(x)`` を覚えておいてください)
のに非常に便利なツールです。
interpreted
Python はインタプリタ形式の言語であり、コンパイラ言語の対極に位置します。
(バイトコードコンパイラがあるために、この区別は曖昧ですが。)
ここでのインタプリタ言語とは、ソースコードのファイルを、
まず実行可能形式にしてから実行させるといった操作なしに、直接実行できることを意味します。
インタプリタ形式の言語は通常、
コンパイラ形式の言語よりも開発／デバッグのサイクルは短いものの、プログラムの実行は一般に遅いです。
対話的(:term:`interactive`)も参照してください。
.. Python is an interpreted language, as opposed to a compiled one,
though the distinction can be blurry because of the presence of the
bytecode compiler. This means that source files can be run directly
without explicitly creating an executable which is then run.
Interpreted languages typically have a shorter development/debug cycle
than compiled ones, though their programs generally also run more
slowly. See also :term:`interactive`.
iterable
(反復可能オブジェクト)
要素を一つずつ返せるオブジェクトです。
反復可能オブジェクトの例には、(:class:`list`, :class:`str`, :class:`tuple` といった)
全てのシーケンス型や、 :class:`dict` や :class:`file` といった幾つかの非シーケンス型、
あるいは :meth:`__iter__` か :meth:`__getitem__` メソッドを実装したクラスのインスタンスが含まれます。
反復可能オブジェクトは :keyword:`for` ループ内やその他多くのシーケンス
(訳注: ここでのシーケンスとは、シーケンス型ではなくただの列という意味)が必要となる状況
(:func:`zip`, :func:`map`, ...) で利用できます。
反復可能オブジェクトを組み込み関数 :func:`iter` の引数として渡すと、
オブジェクトに対するイテレータを返します。
このイテレータは一連の値を引き渡す際に便利です。
反復可能オブジェクトを使う際には、通常 :func:`iter` を呼んだり、
イテレータオブジェクトを自分で扱う必要はありません。
``for`` 文ではこの操作を自動的に行い、無名の変数を作成してループの間イテレータを記憶します。
イテレータ(:term:`iterator`) シーケンス(:term:`sequence`),
およびジェネレータ(:term:`generator`)も参照してください。
iterator
一連のデータ列 (stream) を表現するオブジェクトです。
イテレータの :meth:`next` メソッドを繰り返し呼び出すと、
データ列中の要素を一つずつ返します。
後続のデータがなくなると、データの代わりに :exc:`StopIteration` 例外を送出します。
その時点で、イテレータオブジェクトは全てのオブジェクトを出し尽くしており、
それ以降は :meth:`next` を何度呼んでも :exc:`StopIteration` を送出します。
イテレータは、そのイテレータオブジェクト自体を返す :meth:`__iter__`
メソッドを実装しなければならなくなっており、そのため全てのイテレータは他の
反復可能オブジェクトを受理できるほとんどの場所で利用できます。
著しい例外は複数の反復を行うようなコードです。
(:class:`list` のような) コンテナオブジェクトでは、 :func:`iter`
関数にオブジェクトを渡したり、 :keyword:`for` ループ内で使うたびに、
新たな未使用のイテレータを生成します。
このイテレータをさらに別の場所でイテレータとして使おうとすると、
前回のイテレーションパスで使用された同じイテレータオブジェクトを返すため、
空のコンテナのように見えます。
より詳細な情報は :ref:`typeiter` にあります。
.. An object representing a stream of data. Repeated calls to the iterator's
:meth:`next` method return successive items in the stream. When no more
data are available a :exc:`StopIteration` exception is raised instead. At
this point, the iterator object is exhausted and any further calls to its
:meth:`next` method just raise :exc:`StopIteration` again. Iterators are
required to have an :meth:`__iter__` method that returns the iterator
object itself so every iterator is also iterable and may be used in most
places where other iterables are accepted. One notable exception is code
which attempts multiple iteration passes. A container object (such as a
:class:`list`) produces a fresh new iterator each time you pass it to the
:func:`iter` function or use it in a :keyword:`for` loop. Attempting this
with an iterator will just return the same exhausted iterator object used
in the previous iteration pass, making it appear like an empty container.
More information can be found in :ref:`typeiter`.
keyword argument
(キーワード引数)
呼び出し時に、 ``variable_name=`` が手前にある引数。
変数名は、その値が関数内のどのローカル変数に渡されるかを指定します。
キーワード引数として辞書を受け取ったり渡したりするために ``**``
を使うことができます。 :term:`argument` も参照してください。
lambda
(ラムダ)
無名のインライン関数で、関数が呼び出されたときに評価される1つの式
(:term:`expression`) を持ちます。
ラムダ関数を作る構文は、 ``lambda [arguments]: expression`` です。
LBYL
「ころばぬ先の杖」 (look before you leap) の略です。
このコーディングスタイルでは、呼び出しや検索を行う前に、明示的に前提条件
(pre-condition) 判定を行います。
*EAFP* アプローチと対照的で、:keyword:`if` 文がたくさん使われるのが特徴的です。
.. Look before you leap. This coding style explicitly tests for
pre-conditions before making calls or lookups. This style contrasts with
the :term:`EAFP` approach and is characterized by the presence of many
:keyword:`if` statements.
list
(リスト)
Python のビルトインのシーケンス型(:term:`sequence`)です。
リストという名前ですが、リンクリストではなく、他の言語で言う配列(array)と
同種のもので、要素へのアクセスは O(1) です。
list comprehension
(リスト内包表記)
シーケンス内の全てあるいは一部の要素を処理して、その結果からなるリストを返す、
コンパクトな書き方です。
``result = ["0x%02x" % x for x in range(256) if x % 2 == 0]``
とすると、 0 から 255 までの偶数を 16進数表記 (0x..) した文字列からなるリストを生成します。
:keyword:`if` 節はオプションです。 :keyword:`if` 節がない場合、
``range(256)`` の全ての要素が処理されます。
.. A compact way to process all or part of the elements in a sequence and
return a list with the results. ``result = ["0x%02x" % x for x in
range(256) if x % 2 == 0]`` generates a list of strings containing
even hex numbers (0x..) in the range from 0 to 255. The :keyword:`if`
clause is optional. If omitted, all elements in ``range(256)`` are
processed.
loader
モジュールをロードするオブジェクト。
:meth:`load_module` という名前のメソッドを定義していなければなりません。
詳細は :pep:`302` を参照してください。
mapping
(マップ)
特殊メソッド :meth:`__getitem__` を使って、任意のキーに対する検索をサポートする
(:class:`dict` のような)コンテナオブジェクトです。
.. A container object (such as :class:`dict`) which supports arbitrary key
lookups using the special method :meth:`__getitem__`.
metaclass
(メタクラス)
クラスのクラスです。
クラス定義は、クラス名、クラスの辞書と、基底クラスのリストを作ります。
メタクラスは、それら3つを引数として受け取り、クラスを作る責任を負います。
ほとんどのオブジェクト指向言語は(訳注:メタクラスの)デフォルトの実装を提供しています。
Pythonはカスタムのメタクラスを作成できる点が特別です。
ほとんどのユーザーに取って、メタクラスは全く必要のないものです。
しかし、一部の場面では、メタクラスは強力でエレガントな方法を提供します。
たとえば属性アクセスのログを取ったり、スレッドセーフ性を追加したり、オブジェクトの
生成を追跡したり、シングルトンを実装するなど、多くの場面で利用されます。
.. The class of a class. Class definitions create a class name, a class
dictionary, and a list of base classes. The metaclass is responsible for
taking those three arguments and creating the class. Most object oriented
programming languages provide a default implementation. What makes Python
special is that it is possible to create custom metaclasses. Most users
never need this tool, but when the need arises, metaclasses can provide
powerful, elegant solutions. They have been used for logging attribute
access, adding thread-safety, tracking object creation, implementing
singletons, and many other tasks.
More information can be found in :ref:`metaclasses`.
method
クラス内で定義された関数。
クラス属性として呼び出された場合、メソッドはインスタンスオブジェクトを
第一引数(:term:`argument`) として受け取ります(この第一引数は普段
``self`` と呼ばれます)。
:term:`function` と :term:`nested scope` も参照してください。
mutable
(変更可能オブジェクト)
変更可能なオブジェクトは、 :func:`id` を変えることなく値を変更できます。
変更不能 (:term:`immutable`) も参照してください。
.. Mutable objects can change their value but keep their :func:`id`. See
also :term:`immutable`.
named tuple
(名前付きタプル)
タプルに似ていて、インデックスによりアクセスする要素に名前付き属性としても
アクセス出来るクラス。
(例えば、 :func:`time.localtime` はタプルに似たオブジェクトを返し、
その *year* には ``t[0]`` のようなインデックスによるアクセスと、
``t.tm_year`` のような名前付き要素としてのアクセスが可能です。)
名前付きタプルには、 :class:`time.struct_time` のようなビルトイン型もありますし、
通常のクラス定義によって作成することもできます。
名前付きタプルを :func:`collections.namedtuple` ファクトリ関数で作成することもできます。
最後の方法で作った名前付きタプルには自動的に、
``Employee(name='jones', title='programmer')`` のような自己ドキュメント表現(self-documenting
representation) 機能が付いてきます。
namespace
(名前空間)
変数を記憶している場所です。
名前空間は辞書を用いて実装されています。
名前空間には、ローカル、グローバル、組み込み名前空間、そして (メソッド内の)
オブジェクトのネストされた名前空間があります。
例えば、関数 :func:`__builtin__.open` と :func:`os.open`
は名前空間で区別されます。
名前空間はまた、ある関数をどのモジュールが実装しているかをはっきりさせることで、
可読性やメンテナンス性に寄与します。
例えば、 :func:`random.seed`, :func:`itertools.izip` と書くことで、これらの関数がそれぞれ
:mod:`random` モジュールや :mod:`itertools`
モジュールで実装されていることがはっきりします。
.. The place where a variable is stored. Namespaces are implemented as
dictionaries. There are the local, global and builtin namespaces as well
as nested namespaces in objects (in methods). Namespaces support
modularity by preventing naming conflicts. For instance, the functions
:func:`__builtin__.open` and :func:`os.open` are distinguished by their
namespaces. Namespaces also aid readability and maintainability by making
it clear which module implements a function. For instance, writing
:func:`random.seed` or :func:`itertools.izip` makes it clear that those
functions are implemented by the :mod:`random` and :mod:`itertools`
modules, respectively.
nested scope
(ネストされたスコープ)
外側で定義されている変数を参照する機能。
具体的に言えば、ある関数が別の関数の中で定義されている場合、内側の関数は外側の関数中の変数を参照できます。
ネストされたスコープは変数の参照だけができ、変数の代入はできないので注意してください。
変数の代入は、常に最も内側のスコープにある変数に対する書き込みになります。
同様に、グローバル変数を使うとグローバル名前空間の値を読み書きします。
.. The ability to refer to a variable in an enclosing definition. For
instance, a function defined inside another function can refer to
variables in the outer function. Note that nested scopes work only for
reference and not for assignment which will always write to the innermost
scope. In contrast, local variables both read and write in the innermost
scope. Likewise, global variables read and write to the global namespace.
new-style class
(新スタイルクラス)
:class:`object` から継承したクラス全てを指します。これには :class:`list` や :class:`dict`
のような全ての組み込み型が含まれます。 :meth:`__slots__`, デスクリプタ、プロパティ、
:meth:`__getattribute__` といった、
Python の新しい機能を使えるのは新スタイルクラスだけです。
より詳しい情報は :ref:`newstyle` を参照してください。
.. Any class which inherits from :class:`object`. This includes all built-in
types like :class:`list` and :class:`dict`. Only new-style classes can
use Python's newer, versatile features like :attr:`__slots__`,
descriptors, properties, and :meth:`__getattribute__`.
More information can be found in :ref:`newstyle`.
object
状態(属性や値)と定義された振る舞い(メソッド)をもつ全てのデータ。
もしくは、全ての新スタイルクラス(:term:`new-style class`)
の基底クラスのこと。
positional argument
(位置指定引数)
引数のうち、呼び出すときの順序で、関数やメソッドの中のどの名前に
代入されるかが決定されるもの。
複数の位置指定引数を、関数定義側が受け取ったり、渡したりするために、
``*`` を使うことができます。
:term:`argument` も参照してください。
Python 3000
Pythonの次のメジャーバージョンである Python 3.0 のニックネームです。
(Python 3 が遠い将来の話だった頃に作られた言葉です。)
"Py3k" と略されることもあります。
.. Nickname for the next major Python version, 3.0 (coined long ago
when the release of version 3 was something in the distant future.) This
is also abbreviated "Py3k".
Pythonic
他の言語で一般的な考え方で書かれたコードではなく、Python の特に一般的な
イディオムに繋がる、考え方やコード。
例えば、Python の一般的なイディオムに iterable の要素を :keyword:`for`
文を使って巡回することです。この仕組を持たない言語も多くあるので、Python
に慣れ親しんでいない人は数値のカウンターを使うかもしれません。 ::
for i in range(len(food)):
print food[i]
これと対照的な、よりきれいな Pythonic な方法はこうなります。 ::
for piece in food:
print piece
reference count
(参照カウント)
あるオブジェクトに対する参照の数。
参照カウントが0になったとき、そのオブジェクトは破棄されます。
参照カウントは通常は Python のコード上には現れませんが、
:term:`CPython` 実装の重要な要素です。
:mod:`sys` モジュールは、プログラマーが任意のオブジェクトの参照カウントを
知るための :func:`getrefcount` 関数を提供しています。
__slots__
新スタイルクラス(:term:`new-style class`)内で、インスタンス属性の記憶に
必要な領域をあらかじめ定義しておき、それとひきかえにインスタンス辞書を排除して
メモリの節約を行うための宣言です。
これはよく使われるテクニックですが、正しく動作させるのには少々手際を要するので、
例えばメモリが死活問題となるようなアプリケーション内にインスタンスが大量に
存在するといった稀なケースを除き、使わないのがベストです。
.. A declaration inside a :term:`new-style class` that saves memory by
pre-declaring space for instance attributes and eliminating instance
dictionaries. Though popular, the technique is somewhat tricky to get
right and is best reserved for rare cases where there are large numbers of
instances in a memory-critical application.
sequence
(シーケンス)
特殊メソッド :meth:`__getitem__` で整数インデックスによる効率的な要素へのアクセスを
サポートし、 :meth:`len` で長さを返すような反復可能オブジェクト(:term:`iterable`)です。
組み込みシーケンス型には、 :class:`list`, :class:`str`, :class:`tuple`, :class:`unicode`
などがあります。
:class:`dict` は :meth:`__getitem__` と :meth:`__len__` もサポートしますが、
検索の際に任意の変更不能(:term:`immutable`)なキーを使うため、シーケンスではなく
マップ (mapping) とみなされているので注意してください。
.. An :term:`iterable` which supports efficient element access using integer
indices via the :meth:`__getitem__` special method and defines a
:meth:`len` method that returns the length of the sequence.
Some built-in sequence types are :class:`list`, :class:`str`,
:class:`tuple`, and :class:`unicode`. Note that :class:`dict` also
supports :meth:`__getitem__` and :meth:`__len__`, but is considered a
mapping rather than a sequence because the lookups use arbitrary
:term:`immutable` keys rather than integers.
slice
(スライス)
多くの場合、シーケンス(:term:`sequence`)の一部を含むオブジェクト。
スライスは、添字記号 ``[]`` で数字の間にコロンを書いたときに作られます。
例えば、 ``variable_name[1:3:5]`` です。
添字記号は :class:`slice` オブジェクトを内部で利用しています。
(もしくは、古いバージョンの、 :meth:`__getslice__` と :meth:`__setslice__`
を利用します。)
special method
(特殊メソッド)
ある型に対する特定の動作をするために、 Python から暗黙的に呼ばれるメソッド。
この種類のメソッドは、メソッド名の最初と最後にアンダースコア2つを持ちます。
特殊メソッドについては :ref:`specialnames` で解説されています。
statement
(文)
文は一種のコードブロックです。
文は :term:`expression` か、それ以外のキーワードにより構成されます。
例えば :keyword:`if`, :keyword:`while`, :keyword:`print` は文です。
triple-quoted string
(三重クォート文字列)
3つの連続したクォート記号(")かアポストロフィー(')で囲まれた文字列。
通常の(一重)クォート文字列に比べて表現できる文字列に違いはありませんが、
幾つかの理由で有用です。
1つか2つの連続したクォート記号をエスケープ無しに書くことができますし、
行継続文字(\\)を使わなくても複数行にまたがることができるので、
ドキュメンテーション文字列を書く時に特に便利です。
type
(型)
Python のオブジェクトの型は、そのオブジェクトの種類を決定します。
全てのオブジェクトは型を持っています。
オブジェクトの型は、 :attr:`__class__` 属性からアクセスしたり、
``type(obj)`` で取得することができます。
virtual machine
(仮想マシン)
ソフトウェアにより定義されたコンピュータ。
Python の仮想マシンは、バイトコードコンパイラが出力したバイトコード
(:term:`bytecode`)を実行します。
Zen of Python
(Pythonの悟り)
Python を理解し利用する上での導きとなる、Python の設計原則と哲学をリストにしたものです。
対話プロンプトで "``import this``" とするとこのリストを読めます。
.. Listing of Python design principles and philosophies that are helpful in
understanding and using the language. The listing can be found by typing
"``import this``" at the interactive prompt.
Python-2.6.2-DocJa-1/_sources/tutorial/ 0000755 0001750 0001750 00000000000 11477163430 017211 5 ustar inada-n inada-n Python-2.6.2-DocJa-1/_sources/tutorial/inputoutput.txt 0000644 0001750 0001750 00000074305 11476441527 022410 0 ustar inada-n inada-n .. _tut-io:
**********
入力と出力
**********
プログラムの出力をもたらす方法はいくつかあります; データは人間が可読な形で出力することも、将来使うためにファイルに書くこともできます。
この章では、こうした出力のいくつかの可能性について議論します。
.. % Input and Output
.. % % There are several ways to present the output of a program; data can be
.. % % printed in a human-readable form, or written to a file for future use.
.. % % This chapter will discuss some of the possibilities.
.. _tut-formatting:
ファンシーな出力の書式化
========================
これまでのところ、値を出力する二つの方法: *式でできた文 (expression statement)* と :keyword:`print`
文が出てきました。(第三はファイルオブジェクトの :meth:`write` を使う方法です; 標準出力を表すファイルは ``sys.stdout``
で参照できます。詳細はライブラリリファレンスを参照してください。)
.. % Fancier Output Formatting
.. % % So far we've encountered two ways of writing values: \emph{expression
.. % % statements} and the \keyword{print} statement. (A third way is using
.. % % the \method{write()} method of file objects; the standard output file
.. % % can be referenced as \code{sys.stdout}. See the Library Reference for
.. % % more information on this.)
.. index:: module: string
出力を書式化する際に、単に値をスペースで区切って出力するよりももっときめ細かな制御をしたいと思うことがしばしばあるでしょう。
出力を書式化するには二つの方法があります; 第一の方法は、全ての文字列を自分で処理するというものです; 文字列のスライスや結合といった操作を
使えば、思い通りのレイアウトを作成することができます。標準モジュール :mod:`string` には、
文字列を指定されたカラム幅にそろえるための便利な操作がいくつかあります; これらの操作については後で簡単に説明します。
もうひとつの方法は :meth:`str.format` メソッドを利用することです。
.. % % Often you'll want more control over the formatting of your output than
.. % % simply printing space-separated values. There are two ways to format
.. % % your output; the first way is to do all the string handling yourself;
.. % % using string slicing and concatenation operations you can create any
.. % % lay-out you can imagine. The standard module
.. % % \module{string}\refstmodindex{string} contains some useful operations
.. % % for padding strings to a given column width; these will be discussed
.. % % shortly. The second way is to use the \code{\%} operator with a
.. % % string as the left argument. The \code{\%} operator interprets the
.. % % left argument much like a \cfunction{sprintf()}-style format
.. % % string to be applied to the right argument, and returns the string
.. % % resulting from this formatting operation.
.. % % One question remains, of course: how do you convert values to strings?
.. % % Luckily, Python has ways to convert any value to a string: pass it to
.. % % the \function{repr()} or \function{str()} functions. Reverse quotes
.. % % (\code{``}) are equivalent to \function{repr()}, but they are no
.. % % longer used in modern Python code and will likely not be in future
.. % % versions of the language.
もちろん、一つ問題があります。値をどうやって文字列に変換したらいいのでしょうか？幸運なことに、Python には値を文字列に変換する方法があります: 値を
:func:`repr` か :func:`str` 関数に渡してください。
:func:`str` 関数は、値を表現するときにかなり人間にとって可読なものにするためのものです。一方、 :func:`repr` は
インタプリタで読めるような表現にする (あるいは、等価な値を表現するための構文がない場合には :exc:`SyntaxError` を送出させる)
ためのものです。人間が利用するための特別な表現をもたないオブジェクトでは、 :func:`str` は :func:`repr` と同じ値を返します。
数値や、リストや辞書といった構造体のような多くの値は、どちらの関数でも同じ表現になります。文字列と浮動小数点は特別で、二つの別個の表現となります。
.. % % The \function{str()} function is meant to return representations of
.. % % values which are fairly human-readable, while \function{repr()} is
.. % % meant to generate representations which can be read by the interpreter
.. % % (or will force a \exception{SyntaxError} if there is not equivalent
.. % % syntax). For objects which don't have a particular representation for
.. % % human consumption, \function{str()} will return the same value as
.. % % \function{repr()}. Many values, such as numbers or structures like
.. % % lists and dictionaries, have the same representation using either
.. % % function. Strings and floating point numbers, in particular, have two
.. % % distinct representations.
下にいくつか例を挙げます:
.. % % Some examples:
::
>>> s = 'Hello, world.'
>>> str(s)
'Hello, world.'
>>> repr(s)
"'Hello, world.'"
>>> str(0.1)
'0.1'
>>> repr(0.1)
'0.10000000000000001'
>>> x = 10 * 3.25
>>> y = 200 * 200
>>> s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'
>>> print s
The value of x is 32.5, and y is 40000...
>>> # 文字列への repr() はクォートとバックスラッシュが付加される:
... hello = 'hello, world\n'
>>> hellos = repr(hello)
>>> print hellos
'hello, world\n'
>>> # repr() の引数は Python オブジェクトの場合もある:
... repr((x, y, ('spam', 'eggs')))
"(32.5, 40000, ('spam', 'eggs'))"
以下に 2 乗と 3 乗の値からなる表を書く二つの方法を示します:
.. % % Here are two ways to write a table of squares and cubes:
::
>>> for x in range(1, 11):
... print repr(x).rjust(2), repr(x*x).rjust(3),
... # 上の行の末尾のコンマに注意
... print repr(x*x*x).rjust(4)
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
>>> for x in range(1,11):
... print '{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x)
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
(最初の例で、各カラムの間のスペース一個は :keyword:`print` の働きで追加されていることに注意してください:
:keyword:`print` は引数間に常に空白を追加します)
.. % % (Note that one space between each column was added by the way
.. % % \keyword{print} works: it always adds spaces between its arguments.)
この例では、メソッド :meth:`rjust` を実際に利用しています。 :meth:`rjust` は文字列を指定された幅のフィールド内に
右詰めで入るように、左に空白を追加します。同様のメソッドとして、 :meth:`ljust` と :meth:`center` が
あります。これらのメソッドは何か出力を行うわけではなく、ただ新しい文字列を返します。入力文字列が長すぎる場合、文字列を切り詰めることはせず、
ただ値をそのまま返します; この仕様のために、カラムのレイアウトが滅茶苦茶になるかもしれませんが、嘘の値が代わりに書き出される
よりはましです。(本当に切り詰めを行いたいのなら、全てのカラムに ``x.ljust(n)[:n]``) のようにスライス表記を加えることもできます。)
.. % % This example demonstrates the function \method{rjust()},
.. % % which right-justifies a string in a field of a given width by padding
.. % % it with spaces on the left. There are similar methods
.. % % \method{ljust()} and \method{center()}. These
.. % % functions do not write anything, they just return a new string. If
.. % % the input string is too long, they don't truncate it, but return it
.. % % unchanged; this will mess up your column lay-out but that's usually
.. % % better than the alternative, which would be lying about a value. (If
.. % % you really want truncation you can always add a slice operation, as in
.. % % \samp{ljust(x,~n)[0:n]}.)
もう一つのメソッド、 :func:`zfill` は、数値文字列の左側をゼロ詰めします。このメソッドは正と負の符号を正しく扱います:
.. % % There is another method, \method{zfill()}, which pads a
.. % % numeric string on the left with zeros. It understands about plus and
.. % % minus signs:
::
>>> '12'.zfill(5)
'00012'
>>> '-3.14'.zfill(7)
'-003.14'
>>> '3.14159265359'.zfill(5)
'3.14159265359'
Basic usage of the :meth:`str.format` method looks like this::
:meth:`str.format` メソッドの基本的な使い方は次のようなものです。 ::
>>> print 'We are the {0} who say "{1}!"'.format('knights', 'Ni')
We are the knights who say "Ni!"
括弧とその中の文字(これをフォーマットフィールドと呼びます)は、 format メソッドに
渡されたオブジェクトに置換されます。
括弧の中の数字は format メソッドに渡されたオブジェクトの位置を表します。 ::
>>> print '{0} and {1}'.format('spam', 'eggs')
spam and eggs
>>> print '{1} and {0}'.format('spam', 'eggs')
eggs and spam
フォーマットメソッドにキーワード引数が渡された場合、その値はキーワード引数の名前に
よって参照されます。 ::
>>> print 'This {food} is {adjective}.'.format(
... food='spam', adjective='absolutely horrible')
This spam is absolutely horrible.
順序引数とキーワード引数を組み合わせて使うこともできます。 ::
>>> print 'The story of {0}, {1}, and {other}.'.format('Bill', 'Manfred',
... other='Georg')
The story of Bill, Manfred, and Georg.
An optional ``':'`` and format specifier can follow the field name. This also
greater control over how the value is formatted. The following example
truncates the Pi to three places after the decimal.
オプションの ``':'`` とフォーマット指定子を、フィールド名の後ろに付けることができます。
フォーマット指定子によって値がどうフォーマットされるかを制御することができます。
次の例では、円周率πを、小数点以下3桁でフォーマットしています。
::
>>> import math
>>> print 'The value of PI is approximately {0:.3f}.'.format(math.pi)
The value of PI is approximately 3.142.
``':'`` の後ろに整数をつけると、そのフィールドの最低の文字幅を指定できます。
この機能は綺麗なテーブルを作るのに便利です。
::
>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
>>> for name, phone in table.items():
... print '{0:10} ==> {1:10d}'.format(name, phone)
...
Jack ==> 4098
Dcab ==> 7678
Sjoerd ==> 4127
もしも長い書式化文字列があり、それを分割したくない場合には、変数を引数の位置ではなく
変数の名前で参照できるとよいでしょう。
これは、辞書を引数に渡して、角括弧 ``'[]'`` を使って辞書のキーを参照することで可能です。
::
>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print 'Jack: %(Jack)d; Sjoerd: %(Sjoerd)d; Dcab: %(Dcab)d' % table
>>> print ('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '
... 'Dcab: {0[Dcab]:d}'.format(table))
Jack: 4098; Sjoerd: 4127; Dcab: 8637678
table を '**' 記法を使ってキーワード引数として渡す方法もあります。
::
>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print 'Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}'.format(**table)
Jack: 4098; Sjoerd: 4127; Dcab: 8637678
全てのローカルな変数が入った辞書を返す、新たに紹介する組み込み関数 :func:`vars` と組み合わせると特に便利です。
.. % % This is particularly useful in combination with the new built-in
.. % % \function{vars()} function, which returns a dictionary containing all
.. % % local variables.
:meth:`str.format` による文字列フォーマットの完全な解説は、 :ref:`formatstrings`
を参照してください。
古い文字列フォーマット方法
---------------------------
``%`` 演算しを使って文字列フォーマットをする方法もあります。
これは、演算子の左側の :cfunc:`sprintf` スタイルのフォーマット文字列に、
演算子の右側の値を適用し、その結果の文字列を返します。例えば::
::
>>> import math
>>> print 'The value of PI is approximately %5.3f.' % math.pi
The value of PI is approximately 3.142.
:meth:`str.format` は最近導入された機能なので、多くのPythonのコードがまだ ``%``
演算子を利用しています。
ですが、古い方法はいつか削除されるかもしれないので、普通は :meth:`str.format`
を使うのが良いでしょう。
より詳しい情報は :ref:`string-formatting` にあります。
.. _tut-files:
ファイルを読み書きする
======================
.. index::
builtin: open
object: file
:func:`open` はファイルオブジェクトを返します。 :func:`open` は、 ``open(filename, mode)``
のように二つの引数を伴って呼び出されることがほとんどです。
::
>>> f = open('/tmp/workfile', 'w')
>>> print f
最初の引数はファイル名の入った文字列です。二つめの引数もまた文字列で、ファイルをどのように使うかを示す数個の文字が入っています。 *mode*
は、ファイルが読み出し専用なら ``'r'`` 、書き込み専用 (同名の既存のファイルがあれば消去されます) なら ``'w'`` とします。 ``'a'``
はファイルを追記用に開きます; ファイルに書き込まれた内容は自動的にファイルの終端に追加されます。 ``'r+'`` はファイルを読み
書き両用に開きます。 *mode* 引数はオプションです; 省略された場合には ``'r'`` であると仮定します。
.. % % The first argument is a string containing the filename. The second
.. % % argument is another string containing a few characters describing the
.. % % way in which the file will be used. \var{mode} can be \code{'r'} when
.. % % the file will only be read, \code{'w'} for only writing (an existing
.. % % file with the same name will be erased), and \code{'a'} opens the file
.. % % for appending; any data written to the file is automatically added to
.. % % the end. \code{'r+'} opens the file for both reading and writing.
.. % % The \var{mode} argument is optional; \code{'r'} will be assumed if
.. % % it's omitted.
Windows では、 *mode* に ``'b'`` を追加するとファイルをバイナリモードで開きます。したがって、
``'rb'``, ``'wb'``, ``'r+b'`` といったモードがあります。 Windows はテキストファイルとバイナリファイルを区別しています;
テキストファイルでは、読み書きの際に行末文字が自動的に少し変更されます。この舞台裏でのファイルデータ変更は、ASCII でできたテキストファイル
では差し支えないものですが、 :file:`JPEG` や :file:`EXE` ファイルのようなバイナリデータは破損してしまうことになるでしょう。
こうしたファイルを読み書きする際にはバイナリモードを使うよう十分注意してください。
Unix では、 ``'b'`` を追加しても何も影響がないので、バイナリフォーマットを扱うための
プラットフォーム非依存な方法として利用できます。
.. % % On Windows and the Macintosh, \code{'b'} appended to the
.. % % mode opens the file in binary mode, so there are also modes like
.. % % \code{'rb'}, \code{'wb'}, and \code{'r+b'}. Windows makes a
.. % % distinction between text and binary files; the end-of-line characters
.. % % in text files are automatically altered slightly when data is read or
.. % % written. This behind-the-scenes modification to file data is fine for
.. % % \ASCII{} text files, but it'll corrupt binary data like that in \file{JPEG} or
.. % % \file{EXE} files. Be very careful to use binary mode when reading and
.. % % writing such files.
.. _tut-filemethods:
ファイルオブジェクトのメソッド
------------------------------
この節の以降の例は、 ``f`` というファイルオブジェクトが既に生成されているものと仮定します。
.. % Methods of File Objects
.. % % The rest of the examples in this section will assume that a file
.. % % object called \code{f} has already been created.
ファイルの内容を読み出すには、 ``f.read(size)`` を呼び出します。このメソッドはある量のデータを読み出して、文字列として返します。 *size*
はオプションの数値引数です。 *size* が省略されたり負の数であった場合、ファイルの内容全てを読み出して返します; ただし、
ファイルがマシンのメモリの二倍の大きさもある場合にはどうなるかわかりません。 *size* が負でない数ならば、最大で *size* バイトを読み出して
返します。ファイルの終端にすでに達していた場合、 ``f.read()`` は空の文字列 (``""``) を返します。
.. % % To read a file's contents, call \code{f.read(\var{size})}, which reads
.. % % some quantity of data and returns it as a string. \var{size} is an
.. % % optional numeric argument. When \var{size} is omitted or negative,
.. % % the entire contents of the file will be read and returned; it's your
.. % % problem if the file is twice as large as your machine's memory.
.. % % Otherwise, at most \var{size} bytes are read and returned. If the end
.. % % of the file has been reached, \code{f.read()} will return an empty
.. % % string (\code {""}).
::
>>> f.read()
'This is the entire file.\n'
>>> f.read()
''
``f.readline()`` はファイルから 1 行だけを読み取ります; 改行文字 (``\n``) は読み出された文字列の終端に残ります。
改行が省略されるのは、ファイルが改行で終わっていない場合の最終行のみです。これは、戻り値があいまいでないようにするためです; ``f.readline()``
が空の文字列を返したら、ファイルの終端に達したことが分かります。一方、空行は ``'\n'`` 、すなわち改行 1 文字だけからなる文字列で表現されます。
.. % % \code{f.readline()} reads a single line from the file; a newline
.. % % character (\code{\e n}) is left at the end of the string, and is only
.. % % omitted on the last line of the file if the file doesn't end in a
.. % % newline. This makes the return value unambiguous; if
.. % % \code{f.readline()} returns an empty string, the end of the file has
.. % % been reached, while a blank line is represented by \code{'\e n'}, a
.. % % string containing only a single newline.
::
>>> f.readline()
'This is the first line of the file.\n'
>>> f.readline()
'Second line of the file\n'
>>> f.readline()
''
``f.readlines()`` は、ファイルに入っているデータの全ての行からなるリストを返します。オプションのパラメタ *sizehint* が指定されて
いれば、ファイルから指定されたバイト数を読み出し、さらに一行を完成させるのに必要なだけを読み出して、読み出された行からなる
リストを返します。このメソッドは巨大なファイルを行単位で効率的に読み出すためによく使われます。未完成の行が返されることはありません。
.. % % \code{f.readlines()} returns a list containing all the lines of data
.. % % in the file. If given an optional parameter \var{sizehint}, it reads
.. % % that many bytes from the file and enough more to complete a line, and
.. % % returns the lines from that. This is often used to allow efficient
.. % % reading of a large file by lines, but without having to load the
.. % % entire file in memory. Only complete lines will be returned.
::
>>> f.readlines()
['This is the first line of the file.\n', 'Second line of the file\n']
行を読む別のアプローチは、ファイルオブジェクトについてループをおこなうことです。これは省メモリで、速く、コードがよりシンプルになります:
::
>>> for line in f:
print line,
This is the first line of the file.
Second line of the file
この方法はシンプルですが細かなコントロールをすることができません。行バッファを管理する方法が異なるので、これらを混在させて使うことはできません。
.. % % The alternative approach is simpler but does not provide as fine-grained
.. % % control. Since the two approaches manage line buffering differently,
.. % % they should not be mixed.
``f.write(string)`` は、 *string* の内容をファイルに書き込み、 ``None`` を返します。
.. % % \code{f.write(\var{string})} writes the contents of \var{string} to
.. % % the file, returning \code{None}.
::
>>> f.write('This is a test\n')
文字列以外のものを出力したい場合、まず文字列に変換してやる必要があります:
.. % % To write something other than a string, it needs to be converted to a
.. % % string first:
::
>>> value = ('the answer', 42)
>>> s = str(value)
>>> f.write(s)
``f.tell()`` は、ファイルオブジェクトが指しているあるファイル中の位置を示す整数を、ファイルの先頭からのバイト数で図った値で返します。
ファイルオブジェクトの位置を変更するには、 ``f.seek(offset, from_what)`` を使います。ファイル位置は基準点 (reference
point) にオフセット値 *offset* を足して計算されます; 参照点は *from_what* 引数で選びます。 *from_what* の値が 0
ならばファイルの先頭から測り、 1 ならば現在のファイル位置を使い、2 ならばファイルの終端を参照点として使います。 *from_what*
は省略することができ、デフォルトの値は 0 、すなわち参照点としてファイルの先頭を使います。
.. % % \code{f.tell()} returns an integer giving the file object's current
.. % % position in the file, measured in bytes from the beginning of the
.. % % file. To change the file object's position, use
.. % % \samp{f.seek(\var{offset}, \var{from_what})}. The position is
.. % % computed from adding \var{offset} to a reference point; the reference
.. % % point is selected by the \var{from_what} argument. A
.. % % \var{from_what} value of 0 measures from the beginning of the file, 1
.. % % uses the current file position, and 2 uses the end of the file as the
.. % % reference point. \var{from_what} can be omitted and defaults to 0,
.. % % using the beginning of the file as the reference point.
::
>>> f = open('/tmp/workfile', 'r+')
>>> f.write('0123456789abcdef')
>>> f.seek(5) # ファイルの第6バイトへ行く
>>> f.read(1)
'5'
>>> f.seek(-3, 2) # 終端から前へ第3バイトへ行く
>>> f.read(1)
'd'
ファイルが用済みになったら、 ``f.close()`` を呼び出してファイルを閉じ、ファイルを開くために取られていたシステム資源を解放します。
``f.close()`` を呼び出した後、そのファイルオブジェクトを使おうとすると自動的に失敗します。
.. % % When you're done with a file, call \code{f.close()} to close it and
.. % % free up any system resources taken up by the open file. After calling
.. % % \code{f.close()}, attempts to use the file object will automatically fail.
::
>>> f.close()
>>> f.read()
Traceback (most recent call last):
File "", line 1, in ?
ValueError: I/O operation on closed file
ファイルオブジェクトを扱うときに :keyword:`with` キーワードを使うのは良い習慣です。
:keyword:`with` を使うと、処理中に例外が発生しても必ず最後にファイルを閉じることができます。
同じことを :keyword:`try`-:keyword:`finally` を使って書くよりずっと簡潔に書けます。 ::
>>> with open('/tmp/workfile', 'r') as f:
... read_data = f.read()
>>> f.closed
True
ファイルオブジェクトには、他にも :meth:`isatty` や :meth:`truncate` といった、あまり使われないメソッドがあります。
ファイルオブジェクトについての完全なガイドは、ライブラリリファレンスを参照してください。
.. % % File objects have some additional methods, such as
.. % % \method{isatty()} and \method{truncate()} which are less frequently
.. % % used; consult the Library Reference for a complete guide to file
.. % % objects.
.. _tut-pickle:
:mod:`pickle` モジュール
------------------------
.. index:: module: pickle
.. % The \module{pickle} Module
文字列をファイルに読み書きするのは簡単にできます。数値でもほんのわずかに苦労するくらいです。というのは、 :meth:`read` は文字列だけを
返すので、 ``'123'`` のような文字列を受け取って、その数値 123 を返す :func:`int` のような関数に対して文字列を渡してやらなければ
ならないからです。ところが、リストや辞書、クラスのインスタンスのように、もっと複雑なデータ型を保存したいなら、事態はもっと複雑になります。
.. % % Strings can easily be written to and read from a file. Numbers take a
.. % % bit more effort, since the \method{read()} method only returns
.. % % strings, which will have to be passed to a function like
.. % % \function{int()}, which takes a string like \code{'123'} and
.. % % returns its numeric value 123. However, when you want to save more
.. % % complex data types like lists, dictionaries, or class instances,
.. % % things get a lot more complicated.
複雑なデータ型を保存するためのコードを利用者に毎回毎回書かせてデバッグさせる代わりに、Python では :mod:`pickle` という標準
モジュールを用意しています。 :mod:`pickle` は驚くべきモジュールで、ほとんどどんな Python オブジェクトも (ある形式の Python
コードでさえも!) 受け取って文字列表現へ変換できます。この変換過程は :dfn:`pickling` (ピクルス (漬物) 化、以降 pickle 化)
と呼ばれます。文字列表現からオブジェクトを再構成する操作は :dfn:`unpickling` (逆 pickle 化)と呼びます。 pickle 化や
unpickle 化の間、オブジェクトを表現する文字列はファイルやデータに保存したり、ネットワーク接続を介して離れたマシンに送信したりできます。
.. % % Rather than have users be constantly writing and debugging code to
.. % % save complicated data types, Python provides a standard module called
.. % % \module{pickle}. This is an amazing module that can take almost
.. % % any Python object (even some forms of Python code!), and convert it to
.. % % a string representation; this process is called \dfn{pickling}.
.. % % Reconstructing the object from the string representation is called
.. % % \dfn{unpickling}. Between pickling and unpickling, the string
.. % % representing the object may have been stored in a file or data, or
.. % % sent over a network connection to some distant machine.
オブジェクト ``x`` と、書込み用に開かれているファイルオブジェクト ``f`` があると仮定すると、オブジェクトを pickle 化する最も簡単な
方法は、たった一行のコードしか必要ありません:
.. % % If you have an object \code{x}, and a file object \code{f} that's been
.. % % opened for writing, the simplest way to pickle the object takes only
.. % % one line of code:
::
pickle.dump(x, f)
逆 pickle 化して再びオブジェクトに戻すには、 ``f`` を読取り用に開かれているファイル・オブジェクトと仮定して:
.. % % To unpickle the object again, if \code{f} is a file object which has
.. % % been opened for reading:
::
x = pickle.load(f)
とします。
(逆 pickle 化にはいくつか変型があり、たくさんのオブジェクトを pickle 化したり、 pickle
化されたデータをファイルに書きたくないときに使われます。完全なドキュメントについては、ライブラリリファレンスの
:mod:`pickle` を調べてください。)
.. % % (There are other variants of this, used when pickling many objects or
.. % % when you don't want to write the pickled data to a file; consult the
.. % % complete documentation for
.. % % \ulink{\module{pickle}}{../lib/module-pickle.html} in the
.. % % \citetitle[../lib/]{Python Library Reference}.)
:mod:`pickle` は、Pythonのオブジェクトを保存できるようにし、他のプログラムや、
同じプログラムが将来起動されたときに再利用できるようにする標準の方法です; 技術的な用語でいうと
:dfn:`persistent` (永続性) オブジェクトです。 :mod:`pickle` はとても広範に使われているので、
Python 拡張モジュールの多くの作者は、行列のような新たなデータ型が正しく pickle
化/unpickle 化できるよう気をつけています。
.. % % \ulink{\module{pickle}}{../lib/module-pickle.html} is the standard way to make Python objects which can
.. % % be stored and reused by other programs or by a future invocation of
.. % % the same program; the technical term for this is a
.. % % \dfn{persistent} object. Because \ulink{\module{pickle}}{../lib/module-pickle.html} is so widely used,
.. % % many authors who write Python extensions take care to ensure that new
.. % % data types such as matrices can be properly pickled and unpickled.
Python-2.6.2-DocJa-1/_sources/tutorial/datastructures.txt 0000644 0001750 0001750 00000067404 11474251540 023037 0 ustar inada-n inada-n .. _tut-structures:
**********
データ構造
**********
この章では、すでに学んだことについてより詳しく説明するとともに、いくつか新しいことを追加します。
.. _tut-morelists:
リスト型についてもう少し
========================
リストデータ型には、他にもいくつかメソッドがあります。リストオブジェクトのすべてのメソッドを以下に示します:
.. method:: list.append(x)
:noindex:
リストの末尾に要素を一つ追加します。 ``a[len(a):] = [x]`` と等価です。
.. method:: list.extend(L)
:noindex:
指定したリスト中のすべての要素を対象のリストに追加し、リストを拡張します。 ``a[len(a):] = L`` と等価です。
.. method:: list.insert(i, x)
:noindex:
指定した位置に要素を挿入します。第 1 引数は、リストのインデクスで、そのインデクスを持つ要素の直前に挿入が行われます。従って、
``a.insert(0, x)`` はリストの先頭に挿入を行います。
また ``a.insert(len(a), x)`` は ``a.append(x)`` と等価です。
.. method:: list.remove(x)
:noindex:
リスト中で、値 *x* を持つ最初の要素を削除します。該当する項目がなければエラーとなります。
.. method:: list.pop([i])
:noindex:
リスト中の指定された位置にある要素をリストから削除して、その要素を返します。インデクスが指定されなければ、
``a.pop()`` はリストの末尾の要素を削除して、返します。
この場合も要素は削除されます。 (メソッドの用法 (signature) で *i* の両側にある角括弧は、
この引数がオプションであることを表しているだけなので、角括弧を入力する必要はありません。この表記法は Python Library Reference の中で頻繁に見ることになるでしょう。)
.. method:: list.index(x)
:noindex:
リスト中で、値 *x* を持つ最初の要素のインデクスを返します。
該当する項目がなければエラーとなります。
.. method:: list.count(x)
:noindex:
リストでの *x* の出現回数を返します。
.. method:: list.sort()
:noindex:
リストの項目を、インプレース演算 (in place、元のデータを演算結果で置き換えるやりかた) でソートします。
.. method:: list.reverse()
:noindex:
リストの要素を、インプレース演算で逆順にします。
以下にリストのメソッドをほぼ全て使った例を示します:
::
>>> a = [66.25, 333, 333, 1, 1234.5]
>>> print a.count(333), a.count(66.25), a.count('x')
2 1 0
>>> a.insert(2, -1)
>>> a.append(333)
>>> a
[66.25, 333, -1, 333, 1, 1234.5, 333]
>>> a.index(333)
1
>>> a.remove(333)
>>> a
[66.25, -1, 333, 1, 1234.5, 333]
>>> a.reverse()
>>> a
[333, 1234.5, 1, 333, -1, 66.25]
>>> a.sort()
>>> a
[-1, 1, 66.25, 333, 333, 1234.5]
.. _tut-lists-as-stacks:
リストをスタックとして使う
--------------------------
.. sectionauthor:: Ka-Ping Yee
リスト型のメソッドのおかげで、簡単にリストをスタックとして使えます。スタックでは、最後に追加された要素が最初に取り出されます ("last-in,
first-out") 。スタックの一番上に要素を追加するには :meth:`append` を使います。スタックの一番上から要素を取り出すには
:meth:`pop` をインデクスを指定せずに使います。例えば以下のようにします。
::
>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]
.. _tut-lists-as-queues:
リストをキューとして使う
------------------------
.. sectionauthor:: Ka-Ping Yee
リストをキュー (queue) として手軽に使うこともできます。キューでは、最初に追加された要素が最初に取り出されます ("first-in, first-
out")。キューの末尾に項目を追加するには :meth:`append` を使います。キューの先頭から項目を取り出すには インデクスに ``0``
を指定して :meth:`pop` を使います。例えば以下のようにします。
::
>>> queue = ["Eric", "John", "Michael"]
>>> queue.append("Terry") # Terry が到着 (arrive) する
>>> queue.append("Graham") # Graham が到着する
>>> queue.pop(0)
'Eric'
>>> queue.pop(0)
'John'
>>> queue
['Michael', 'Terry', 'Graham']
.. _tut-functional:
実用的なプログラミングツール
----------------------------
組み込み関数には、リストで使うと非常に便利なものが三つあります: :func:`filter`, :func:`map`, :func:`reduce` です。
``filter(function, sequence)`` は、シーケンス *sequence* 中の要素 *item* から、
``function(item)`` が真となるような要素からなるシーケンスを返します。もし *sequence* が :class:`string` か
:class:`tuple` なら、返り値も同じ型になります。そうでなければ :class:`list` になります。
例えば、いくつかの素数を計算するには以下のようにします。
::
>>> def f(x): return x % 2 != 0 and x % 3 != 0
...
>>> filter(f, range(2, 25))
[5, 7, 11, 13, 17, 19, 23]
``map(function, sequence)`` は、シーケンス *sequence* の各要素 *item* に対して
``function(item)`` を呼び出し、その戻り値からなるリストを返します。例えば、三乗された値の列を計算するには以下のようにします:
::
>>> def cube(x): return x*x*x
...
>>> map(cube, range(1, 11))
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
::
>>> seq = range(8)
>>> def add(x, y): return x+y
...
>>> map(add, seq, seq)
[0, 2, 4, 6, 8, 10, 12, 14]
``reduce(function, sequence)`` は単一の値を返します。この値は 2 つの引数をとる関数 *function* をシーケンス
*sequence* の最初の二つの要素を引数として呼び出し、次にその結果とシーケンスの次の要素を引数にとり、以降これを繰り返すことで構成します。例えば、
1 から 10 までの数の総和を計算するには以下のようにします:
::
>>> def add(x,y): return x+y
...
>>> reduce(add, range(1, 11))
55
シーケンス中にただ一つしか要素がなければ、その値自体が返されます; シーケンスが空なら、例外が送出されます。
3 つめの引数をわたして、初期値を指定することもできます。この場合、空のシーケンスを渡すと初期値が返されます。それ以外の場合には、
まず初期値とシーケンス中の最初の要素に対して関数が適用され、次いでその結果とシーケンスの次の要素に対して適用され、以降これが繰り返されます。例えば以下のようになります。
::
>>> def sum(seq):
... def add(x,y): return x+y
... return reduce(add, seq, 0)
...
>>> sum(range(1, 11))
55
>>> sum([])
0
(2.3 以降では) 実際には、上の例のように :func:`sum` を定義しないでください: 数値の合計は広く必要とされている操作なので、すでに組み込み関数
``sum(sequence)`` が提供されており、上の例と全く同様に動作します。
.. versionadded:: 2.3
リストの内包表記
----------------
リストの内包表記 (list comprehension) は、 :func:`map` や :func:`filter` や
:keyword:`lambda` を使わずにリストを生成するための簡潔な方法を提供しています。
内包表記によるリストの定義は、たいてい :func:`map`, :func:`filter`, :keyword:`lambda`
を使ってリストを生成するコードよりも明快になります。
リストの内包表記は、式、続いて :keyword:`for` 節、そしてその後ろに続くゼロ個以上の
:keyword:`for` 節または :keyword:`if` 節からなります。
結果として得られるリストの要素は、式を、それに続く :keyword:`for` と :keyword:`if`
節のコンテキストで評価した値になります。
式をタプルとして評価したいなら、丸括弧で囲わなければなりません。
::
>>> freshfruit = [' banana', ' loganberry ', 'passion fruit ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
>>> vec = [2, 4, 6]
>>> [3*x for x in vec]
[6, 12, 18]
>>> [3*x for x in vec if x > 3]
[12, 18]
>>> [3*x for x in vec if x < 2]
[]
>>> [[x,x**2] for x in vec]
[[2, 4], [4, 16], [6, 36]]
>>> [x, x**2 for x in vec] # エラー - タプルには丸かっこが必要
File "", line 1, in ?
[x, x**2 for x in vec]
^
SyntaxError: invalid syntax
>>> [(x, x**2) for x in vec]
[(2, 4), (4, 16), (6, 36)]
>>> vec1 = [2, 4, 6]
>>> vec2 = [4, 3, -9]
>>> [x*y for x in vec1 for y in vec2]
[8, 6, -18, 16, 12, -36, 24, 18, -54]
>>> # 訳注: 上記の内包表記をループで書きなおすと、こうなります。
>>> L = []
>>> for x in vec1:
... for y in vec2:
... L.append(x*y)
...
>>> L
[8, 6, -18, 16, 12, -36, 24, 18, -54]
>>> [x+y for x in vec1 for y in vec2]
[6, 5, -7, 8, 7, -5, 10, 9, -3]
>>> [vec1[i]*vec2[i] for i in range(len(vec1))]
[8, 12, -54]
.. note::
訳注: 内包表記の中に :keyword:`for` や :keyword:`if` が複数回現れる場合、
左側の :keyword:`for`, :keyword:`if` が、内包表記ではなくループで書いた場合の
外側のブロックになります。
上の例はまだ判りやすいですが、複雑な内包表記はすぐに読みにくくなってしまうので、
その場合はループで書き下した方が良いでしょう。
リストの内包表記は :func:`map` よりもはるかに柔軟性があり、複雑な式や入れ子になった関数でも利用できます。
::
>>> [str(round(355/113.0, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']
ネストしたリストの内包表記
--------------------------
もし望むなら、リストの内包表記はネストさせることができます。
ネストしたリストの内包表記はとても強力な道具なのですが -- 全ての強力な道具がそうであるように -- とにかく気を付けて使う必要があります。
1行を1つのリストに対応させた3つのリストからなるリストで、3行3列の行列を表現した例を考えます::
>>> mat = [
... [1, 2, 3],
... [4, 5, 6],
... [7, 8, 9],
... ]
ここで、行と列を入れ換えたいとしたときにリストの内包表記が使えます::
>>> print [[row[i] for row in mat] for i in [0, 1, 2]]
[[1, 4, 7], [2, 5, 8], [3, 6, 9]]
*ネストした* リストの内包表記は特に気を付けて使わなければなりません:
リストの内包表記を怖がらずにネストするためには、右から左へ読んでください。
このコードの断片のより冗長なバージョンを見ると処理の流れがはっきりします::
for i in [0, 1, 2]:
for row in mat:
print row[i],
print
実際には複雑な流れの式よりも組み込み関数を使う方が良いです。
この場合 :func:`zip` 関数が大きな仕事をしてくれるでしょう::
>>> zip(*mat)
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
この行にあるアスタリスクの詳細については :ref:`tut-unpacking-arguments` を参照してください。
.. _tut-del:
:keyword:`del` 文
=================
リストから要素を削除する際、値を指定する代わりにインデックスを指定する方法があります: それが :keyword:`del`
文です。これは :meth:`pop` メソッドとちがい、値を返しません。
:keyword:`del` 文はリストからスライスを除去したり、リスト全体を削除することもできます (以前はスライスに空のリストを代入して行っていました)。例えば以下のようにします:
::
>>> a
[-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]
:keyword:`del` は変数全体の削除にも使えます:
::
>>> del a
この文の後で名前 ``a`` を参照すると、(別の値を ``a`` に代入するまで) エラーになります。 :keyword:`del` の別の用途について
はまた後で取り上げます。
.. _tut-tuples:
タプルとシーケンス
==================
リストや文字列には、インデクスやスライスを使った演算のように、数多くの共通の性質があることを見てきました。これらは *シーケンス (sequence)*
データ型 (:ref:`typesseq` を参照) の二つの例です。Python はまだ
進歩の過程にある言語なので、他のシーケンスデータ型が追加されるかもしれません。標準のシーケンス型はもう一つあります: *タプル (tuple)* 型です。
タプルはコンマで区切られたいくつかの値からなります。例えば以下のように書きます:
::
>>> t = 12345, 54321, 'hello!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
>>> # タプルを入れ子にしてもよい
... u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
ご覧のように、出力ではタプルは常に丸括弧で囲われています。これは、入れ子になったタプルが正しく解釈されるようにするためです; 入力の際には
丸括弧なしでもかまいませんが、結局 (タプルがより大きな式の一部分の場合) たいてい必要となります。
タプルの用途はたくさんあります。例えば、(x, y) 座標対、データベースから取り出した従業員レコードなどです。タプルは文字列と同じく、変更不能です:
タプルの個々の要素に代入を行うことはできません (スライスと連結を使って同じ効果を実現することはできますが)。リストのような変更可能な
オブジェクトの入ったタプルを作成することもできます。
問題は 0 個または 1 個の項目からなるタプルの構築です: これらの操作を行うため、構文には特別な細工がされています。空のタプルは
空の丸括弧ペアで構築できます; 一つの要素を持つタプルは、値の後ろにコンマを続ける (単一の値を丸括弧で囲むだけでは不十分です)
ことで構築できます。美しくはないけれども、効果的です。例えば以下のようにします:
::
>>> empty = ()
>>> singleton = 'hello', # <-- 末尾のコンマに注目
>>> len(empty)
0
>>> len(singleton)
1
>>> singleton
('hello',)
文 ``t = 12345, 54321, 'hello!'`` は *タプルのパック (tuple packing)* の例です: 値 ``12345`` 、
``54321`` 、および ``'hello!'`` が一つのタプルにパックされます。逆の演算も可能です:
::
>>> x, y, z = t
この操作は、 *シーケンスのアンパック (sequence unpacking)* とでも呼ぶべきもので、右辺にあるシーケンスに働きます。シーケンスのアンパックでは、左辺に列挙されている
変数が、右辺のシーケンスの長さと同じであることが要求されます。複数同時の代入が実はタプルのパックとシーケンスのアンパックを
組み合わせたものに過ぎないことに注意してください。
.. XXX Add a bit on the difference between tuples and lists.
.. _tut-sets:
集合型
======
Python には、 *集合 (set)* を扱うためのデータ型もあります。集合とは、重複する要素をもたない、順序づけられていない要素の集まりです。 Set
オブジェクトは、結合 (union)、交差 (intersection)、差分 (difference)、対象差 (symmetric difference)
といった数学的な演算もサポートしています。
簡単なデモンストレーションを示します::
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> fruit = set(basket) # 重複のない集合を作成
>>> fruit
set(['orange', 'pear', 'apple', 'banana'])
>>> 'orange' in fruit # 高速なメンバシップテスト
True
>>> 'crabgrass' in fruit
False
>>> # 二つの単語の文字を例にした集合間の演算
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a # a 内の一意な文字
set(['a', 'r', 'b', 'c', 'd'])
>>> a - b # a にあって b にない文字
set(['r', 'd', 'b'])
>>> a | b # a か b にある文字
set(['a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'])
>>> a & b # a と b の双方にある文字
set(['a', 'c'])
>>> a ^ b # a または b の片方だけにある文字
set(['r', 'd', 'b', 'm', 'z', 'l'])
.. _tut-dictionaries:
辞書
====
もう一つ、有用な型が Python に組み込まれています。それは *辞書 (dictionary)*
(:ref:`typesmapping` を参照)です。辞書は他の言語にも "連想記憶 (associated memory)" や "連想配列
(associative array)" として存在することがあります。ある範囲の数でインデクス化されているシーケンスと異なり、辞書は *キー (key)*
でインデクス化されています。このキーは何らかの変更不能な型になります; 文字列、数値、およびタプルは常にキーにすることができます; ただし、タプルに
何らかの変更可能なオブジェクトが含まれている場合にはキーに使うことはできません。リストをキーとして使うことはできません。これは、リストに
スライスやインデクス指定の代入を行ったり、 :meth:`append` や :meth:`extend` のようなメソッドを使うと、
インプレースで変更することができるためです。
辞書は順序付けのされていない *キー(key): 値(value)* のペアからなり、キーが (辞書の中で)
一意でければならない、と考えると最もよいでしょう。波括弧 (brace) のペア: ``{}`` は空の辞書を生成します。カンマで区切られた key:
value のペアを波括弧ペアの間に入れると、辞書の初期値となる key: value が追加されます; この表現方法は出力時に辞書が書き出されるのと同じ方法です。
辞書での主な操作は、ある値を何らかのキーを付けて記憶することと、キーを指定して値を取り出すことです。 ``del`` で key: value のペアを
削除することもできます。すでに使われているキーを使って値を記憶すると、以前そのキーに関連づけられていた値は忘れ去られてしまいます。存在しないキーを使って
値を取り出そうとするとエラーになります。
辞書オブジェクトの :meth:`keys` メソッドは、辞書で使われている全てのキーからなるリストを適当な順番で返します (リストをソート
したいなら、このキーのリストに :meth:`sort` を使ってください)。ある単一のキーが辞書にあるかどうか調べるには、 :keyword:`in` キーワードを使います。
以下に、辞書を使った小さな例を示します:
::
>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'sape': 4139, 'guido': 4127, 'jack': 4098}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'guido': 4127, 'irv': 4127, 'jack': 4098}
>>> tel.keys()
['guido', 'irv', 'jack']
>>> 'guido' in tel
True
:func:`dict` コンストラクタは、キーと値のペアをタプルにしたものからなるリストを使って直接辞書を生成します。キーと値のペアが
あるパターンをなしているなら、リストの内包表現を使えばキーと値のリストをコンパクトに指定できます。
::
>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'jack': 4098, 'guido': 4127}
>>> dict([(x, x**2) for x in (2, 4, 6)]) # リスト内包表現を利用
{2: 4, 4: 16, 6: 36}
チュートリアルの後部では、キー=値ペアを :func:`dict` コンストラクタに渡すために適したジェネレータ式について学習します。
キーが単純な文字列の場合、キーワード引数を使って定義する方が単純な場合もあります。
::
>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'jack': 4098, 'guido': 4127}
.. _tut-loopidioms:
ループのテクニック
==================
辞書の内容にわたってループを行う際、 :meth:`iteritems` メソッドを使うと、キーとそれに対応する値を同時に取り出せます。
::
>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.iteritems():
... print k, v
...
gallahad the pure
robin the brave
シーケンスにわたるループを行う際、 :func:`enumerate` 関数を使うと、要素のインデクスと要素を同時に取り出すことができます。
::
>>> for i, v in enumerate(['tic', 'tac', 'toe']):
... print i, v
...
0 tic
1 tac
2 toe
二つまたはそれ以上のシーケンス型を同時にループするために、関数 :func:`zip` を使って各要素をひと組みにすることができます。
::
>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
... print 'What is your {0}? It is {1}.'.format(q, a)
...
What is your name? It is lancelot.
What is your quest? It is the holy grail.
What is your favorite color? It is blue.
シーケンスを逆方向に渡ってループするには、まずシーケンスの範囲を順方向に指定し、次いで関数 :func:`reversed` を呼び出します。
::
>>> for i in reversed(xrange(1,10,2)):
... print i
...
9
7
5
3
1
シーケンスを並び順にループするには、 :func:`sorted` 関数を使います。この関数は元の配列を変更せず、並べ変え済みの新たな配列を返します。
::
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
... print f
...
apple
banana
orange
pear
.. _tut-conditions:
条件についてもう少し
====================
``while`` や ``if`` 文で使った条件 (condiction) には、値の比較だけでなく、他の演算子も使うことができます、
比較演算子 ``in`` および ``not in`` は、ある値があるシーケンス中に存在するか (または存在しないか) どうかを調べます。演算子
``is`` および ``is not`` は、二つのオブジェクトが実際に同じオブジェクトであるかどうかを調べます; この比較は、リストのような変更可能なオブジェクトにだけ意味があります。全ての比較演算子は同じ優先順位を持っており、ともに数値演算子よりも低い優先順位となります。
比較は連鎖 (chain) させることができます。例えば、 ``a < b == c`` は、 ``a`` が ``b`` より小さく、かつ ``b`` と
``c`` が等しいかどうか、をテストします。
比較演算はブール演算子 ``and`` や ``or`` で組み合わせられます。また、比較演算 (あるいは何らかのブール式) の結果の否 (negate)
は ``not`` でとれます。これらの演算子は全て、比較演算子よりも低い優先順位になっています。 ``A and not B or C`` と ``(A
and (not B)) or C `` が等価になるように、ブール演算子の中で、`` not `` の優先順位が最も高く、`` or`` が最も
低くなっています。もちろん、丸括弧を使えば望みの組み合わせを表現できます。
ブール演算子 ``and`` と ``or`` は、いわゆる *短絡 (short-circuit)* 演算子です: これらの演算子の引数は
左から右へと順に評価され、結果が確定した時点で評価を止めます。例えば、 ``A`` と ``C`` は真で ``B`` が偽のとき、 ``A and B and
C `` は式 `` C`` を評価しません。一般に、短絡演算子の戻り値をブール値ではなくて一般的な値として用いると、値は最後に評価された引数になります。
比較や他のブール式の結果を変数に代入することもできます。例えば、
::
>>> string1, string2, string3 = '', 'Trondheim', 'Hammer Dance'
>>> non_null = string1 or string2 or string3
>>> non_null
'Trondheim'
Python では、C 言語と違って、式の内部で代入を行えないので注意してください。 C 言語のプログラマは不満を呈するかもしれませんが、この仕様は、 C 言語
プログラムで遭遇する、式の中で ``==`` のつもりで ``=`` とタイプしてしまうといったありふれた問題を回避します。
.. _tut-comparing:
シーケンスとその他の型の比較
============================
シーケンスオブジェクトは同じシーケンス型の他のオブジェクトと比較できます。比較には *辞書的な (lexicographical)* 順序が用いられます:
まず、最初の二つの要素を比較し、その値が等しくなければその時点で比較結果が決まります。等しければ次の二つの要素を比較し、以降
シーケンスの要素が尽きるまで続けます。比較しようとする二つの要素がいずれも同じシーケンス型であれば、そのシーケンス間での辞書比較を再帰的に行います。
二つのシーケンスの全ての要素の比較結果が等しくなれば、シーケンスは等しいとみなされます。片方のシーケンスがもう一方の先頭部分にあたる部分シーケンス
ならば、短い方のシーケンスが小さい (劣位の) シーケンスとみなされます。文字列に対する辞書的な順序づけには、個々の文字ごとに ASCII 順序を用います。
以下に、同じ型のオブジェクトを持つシーケンス間での比較を行った例を示します:
::
(1, 2, 3) < (1, 2, 4)
[1, 2, 3] < [1, 2, 4]
'ABC' < 'C' < 'Pascal' < 'Python'
(1, 2, 3, 4) < (1, 2, 4)
(1, 2) < (1, 2, -1)
(1, 2, 3) == (1.0, 2.0, 3.0)
(1, 2, ('aa', 'ab')) < (1, 2, ('abc', 'a'), 4)
違う型のオブジェクト間の比較は認められていることに注意してください。比較結果は決定性がありますが、その決め方は、型は型の名前で順番づけられる、
という恣意的なものです。従って、リスト (list) 型は常に文字列 (string) 型よりも小さく、文字列型は常にタプル (tuple)
よりも小さい、といった具合になります。 [#]_
型混合の数値の比較は、数値そのものに従って比較されるので、例えば 0 は 0.0 と等しい、という結果になります。
.. rubric:: Footnotes
.. [#] 異なる型のオブジェクトを比較するための規則を今後にわたって当てにしてはなりません; Python 言語の将来のバージョンでは変更されるかもしれません。
Python-2.6.2-DocJa-1/_sources/tutorial/index.txt 0000644 0001750 0001750 00000013321 11474251541 021057 0 ustar inada-n inada-n .. _tutorial-index:
#############################
Python チュートリアル
#############################
:Release: |version|
:Date: |today|
.. Python is an easy to learn, powerful programming language. It has efficient
high-level data structures and a simple but effective approach to
object-oriented programming. Python's elegant syntax and dynamic typing,
together with its interpreted nature, make it an ideal language for scripting
and rapid application development in many areas on most platforms.
Python は簡単に習得でき、それでいて強力な言語の一つです。
Python は高レベルなデータ構造を効率的に実装していて、
オブジェクト指向プログラミングに対しても、単純ながら効果的なアプローチをとっています。
洗練された文法とデータ型を動的に決定する機能、そしてインタプリタであるという特徴から、
Python はほとんどのプラットフォームの幅広い対象領域において、
スクリプティングや迅速なアプリケーション開発のための理想的な言語になっています。
.. The Python interpreter and the extensive standard library are freely available
in source or binary form for all major platforms from the Python Web site,
http://www.python.org/, and may be freely distributed. The same site also
contains distributions of and pointers to many free third party Python modules,
programs and tools, and additional documentation.
Pythonインタプリタ自体と膨大な標準ライブラリは、ソースコード形式や、
主要なプラットフォーム向けのバイナリ形式で、Python Web サイト
http://www.python.org/ から無料で入手でき、かつ無料で再配布できます。
また、Python Webサイトでは、無料で手に入るたくさんのサードパーティ製
Python モジュールから、プログラム、ツール類、その他のドキュメントに至るまで、
配布物やポインタの情報を公開しています。
.. The Python interpreter is easily extended with new functions and data types
implemented in C or C++ (or other languages callable from C). Python is also
suitable as an extension language for customizable applications.
Python インタプリタは、 C 言語や C++ 言語 (あるいはその他の C 言語から呼び出せる言語) で実装された新たな関数やデータ構造を組み込んで簡単に拡張できます。
Python はまた、カスタマイズ可能なアプリケーションを作るための拡張機能記述言語としても適しています。
.. This tutorial introduces the reader informally to the basic concepts and
features of the Python language and system. It helps to have a Python
interpreter handy for hands-on experience, but all examples are self-contained,
so the tutorial can be read off-line as well.
このチュートリアルでは、Python の言語仕様と仕組みについて、基本的な概念と機能をざっと紹介します。
Python インタプリタが手元にあれば、自分で試しながら学ぶ助けになりますが、
例題は全て明解なので、チュートリアルはオフラインでも十分読めます。
.. For a description of standard objects and modules, see the Python Library
Reference document. The Python Reference Manual gives a more formal definition
of the language. To write extensions in C or C++, read Extending and Embedding
the Python Interpreter and Python/C API Reference. There are also several books
covering Python in depth.
標準のオブジェクトやモジュールの記述については、
「Python ライブラリリファレンス (Python Library Reference)」を参照してください。
C 言語や C++ 言語で拡張モジュールを書くなら、「Python インタプリタの拡張と埋め込み
(Extending and Embedding the Python Interpreter)」や
「Python/C API リファレンス (Python/C API Reference)」を参照してください。
他にも、 Python について広く深くカバーしている書籍はいくつかあります。
.. This tutorial does not attempt to be comprehensive and cover every single
feature, or even every commonly used feature. Instead, it introduces many of
Python's most noteworthy features, and will give you a good idea of the
language's flavor and style. After reading it, you will be able to read and
write Python modules and programs, and you will be ready to learn more about the
various Python library modules described in the Python Library Reference.
このチュートリアルは網羅的な内容を目指しているわけではありませんし、
Pythonの個別の機能や、よく使われる機能でさえ完全にカバーしてはいません。
その代わり、このチュートリアルではPythonの特筆すべき機能をたくさん紹介して、
この言語の持ち味やスタイルについて好印象を持ってもらうつもりです。
このチュートリアルを読んだ後には、読者のみなさんは Python のモジュールやプログラムを
読み書きできるようになり、「Python ライブラリリファレンス (Python Library Reference)」
に記述されているさまざまな Python ライブラリモジュールについて学べるようになるでしょう。
:ref:`glossary` もまた役に立つはずです。
.. toctree::
:numbered:
appetite.rst
interpreter.rst
introduction.rst
controlflow.rst
datastructures.rst
modules.rst
inputoutput.rst
errors.rst
classes.rst
stdlib.rst
stdlib2.rst
whatnow.rst
interactive.rst
floatingpoint.rst
jptranslation.rst
Python-2.6.2-DocJa-1/_sources/tutorial/floatingpoint.txt 0000644 0001750 0001750 00000044233 11474251537 022640 0 ustar inada-n inada-n .. _tut-fp-issues:
******************************
浮動小数点演算、その問題と制限
******************************
.. sectionauthor:: Tim Peters
浮動小数点数は、計算機ハードウェアの中では、基数を 2 とする (2進法の) 分数として表現されています。例えば、小数
.. % % Floating Point Arithmetic: Issues and Limitations
.. % % Floating-point numbers are represented in computer hardware as
.. % % base 2 (binary) fractions. For example, the decimal fraction
::
0.125
は、 1/10 + 2/100 + 5/1000 という値を持ちますが、これと同様に、 2 進法の分数
.. % % has value 1/10 + 2/100 + 5/1000, and in the same way the binary fraction
::
0.001
は 0/2 + 0/4 + 1/8 という値になります。これら二つの分数は同じ値を持っていますが、ただ一つ、最初の分数は基数 10 で記述されており、
二番目の分数は基数 2 で記述されていることが違います。
.. % % has value 0/2 + 0/4 + 1/8. These two fractions have identical values,
.. % % the only real difference being that the first is written in base 10
.. % % fractional notation, and the second in base 2.
残念なことに、ほとんどの小数は 2 進法の分数として正確に表わすことができません。その結果、一般に、入力した 10 進の浮動小数点数は、 2
進法の浮動小数点数で近似された後、実際にマシンに記憶されます。
.. % % Unfortunately, most decimal fractions cannot be represented exactly as
.. % % binary fractions. A consequence is that, in general, the decimal
.. % % floating-point numbers you enter are only approximated by the binary
.. % % floating-point numbers actually stored in the machine.
最初は基数 10 を使うと問題を簡単に理解できます。分数 1/3 を考えてみましょう。分数 1/3 は、基数 10 の分数として、以下のように近似する
ことができます:
.. % % The problem is easier to understand at first in base 10. Consider the
.. % % fraction 1/3. You can approximate that as a base 10 fraction:
::
0.3
さらに正確な近似は、
.. % % or, better,
::
0.33
です。さらに正確に近似すると、
.. % % or, better,
::
0.333
となり、以後同様です。何個桁数を増やして書こうが、結果は決して厳密な 1/3 にはなりません。しかし、少しづつ正確な近似にはなっていくでしょう。
.. % % and so on. No matter how many digits you're willing to write down, the
.. % % result will never be exactly 1/3, but will be an increasingly better
.. % % approximation to 1/3.
同様に、基数を 2 とした表現で何桁使おうとも、10 進数の 0.1 は基数を 2 とした分数で正確に表現することはできません。基数 2 では、1/10
は循環小数 (repeating fraction)
.. % % In the same way, no matter how many base 2 digits you're willing to
.. % % use, the decimal value 0.1 cannot be represented exactly as a base 2
.. % % fraction. In base 2, 1/10 is the infinitely repeating fraction
::
0.0001100110011001100110011001100110011001100110011...
となります。どこか有限の桁で止めると、近似値を得ることになります。これこそが、以下のような事態:
.. % % Stop at any finite number of bits, and you get an approximation. This
.. % % is why you see things like:
::
>>> 0.1
0.10000000000000001
に出くわす理由です。
今日では、ほとんどのマシンでは、0.1 を Python のプロンプトから入力すると上のような結果を目にします。そうならないかもしれませんが、これは
ハードウェアが浮動小数点数を記憶するのに用いているビット数がマシンによって異なり、Python は単にマシンに 2 進で記憶されている、真の 10 進の
値を近似した値を、されに 10 進で近似して出力するだけだからです。ほとんどのマシンでは、Python が 0.1 を記憶するために 2 進近似した真の値を
10 進で表すと、以下のような出力
.. % % On most machines today, that is what you'll see if you enter 0.1 at
.. % % a Python prompt. You may not, though, because the number of bits
.. % % used by the hardware to store floating-point values can vary across
.. % % machines, and Python only prints a decimal approximation to the true
.. % % decimal value of the binary approximation stored by the machine. On
.. % % most machines, if Python were to print the true decimal value of
.. % % the binary approximation stored for 0.1, it would have to display
::
>>> 0.1
0.1000000000000000055511151231257827021181583404541015625
になるでしょう！ Python プロンプトは、文字列表現を得るために何に対しても :func:`repr` を使います。浮動小数点数の場合、
``repr(float)`` は真の 10 進値を有効数字 17 桁で丸め、以下のような表示
.. % % instead! The Python prompt uses the builtin
.. % % \function{repr()} function to obtain a string version of everything it
.. % % displays. For floats, \code{repr(\var{float})} rounds the true
.. % % decimal value to 17 significant digits, giving
::
0.10000000000000001
を行います。
``repr(float)`` が有効数字 17桁の値を生成するのは、この値が (ほとんどのマシン上で) 、全ての有限の浮動小数点数 *x* について
``eval(repr(x)) == x`` が成り立つのに十分で、かつ有効数字 16 桁に丸めると成り立たないからです。
.. % % \code{repr(\var{float})} produces 17 significant digits because it
.. % % turns out that's enough (on most machines) so that
.. % % \code{eval(repr(\var{x})) == \var{x}} exactly for all finite floats
.. % % \var{x}, but rounding to 16 digits is not enough to make that true.
これは 2 進法の浮動小数点の性質です: Python のバグでも、ソースコードのバグでもなく、浮動小数点演算を扱えるハードウェア上の、すべての言語で同じ
類の現象が発生します (ただし、言語によっては、デフォルトのモードや全ての出力モードでその差を *表示しない* かもしれません)。
.. % % Note that this is in the very nature of binary floating-point: this is
.. % % not a bug in Python, and it is not a bug in your code either. You'll
.. % % see the same kind of thing in all languages that support your
.. % % hardware's floating-point arithmetic (although some languages may
.. % % not \emph{display} the difference by default, or in all output modes).
Python の組み込みの :func:`str` 関数は有効数字 12 桁しか生成しません。このため、この関数を代わりに使用したいと思うかもしれません。
この関数は ``eval(str(x))`` としたときに *x* を再現しないことが多いですが、出力を目で見るには好ましいかもしれません:
.. % % Python's builtin \function{str()} function produces only 12
.. % % significant digits, and you may wish to use that instead. It's
.. % % unusual for \code{eval(str(\var{x}))} to reproduce \var{x}, but the
.. % % output may be more pleasant to look at:
::
>>> print str(0.1)
0.1
現実という考えからは、上の表示は錯覚であると気づくのは重要なことです: マシン内の値は厳密に 1/10 ではなく、単に真のマシン内の *表示される値*
を丸めているだけなのです。
.. % % It's important to realize that this is, in a real sense, an illusion:
.. % % the value in the machine is not exactly 1/10, you're simply rounding
.. % % the \emph{display} of the true machine value.
まだ驚くべきことがあります。例えば、以下
.. % % Other surprises follow from this one. For example, after seeing
::
>>> 0.1
0.10000000000000001
を見て、 :func:`round` 関数を使って桁を切り捨て、期待する 1 桁にしたい誘惑にかられたとします。しかし、結果は依然同じ値です:
.. % % you may be tempted to use the \function{round()} function to chop it
.. % % back to the single digit you expect. But that makes no difference:
::
>>> round(0.1, 1)
0.10000000000000001
問題は、"0.1" を表すために記憶されている 2 進表現の浮動小数点数の値は、すでに 1/10 に対する最良の近似になっており、値を再度丸めようとしても
これ以上ましにはならないということです: すでに値は、 :func:`round` で得られる値になっているというわけです。
.. % % The problem is that the binary floating-point value stored for "0.1"
.. % % was already the best possible binary approximation to 1/10, so trying
.. % % to round it again can't make it better: it was already as good as it
.. % % gets.
もう一つの重要なことは、0.1 が正確に 1/10 ではないため、0.1 を 10 個加算すると厳密に 1.0 にはならないこともある、ということです:
.. % % Another consequence is that since 0.1 is not exactly 1/10,
.. % % summing ten values of 0.1 may not yield exactly 1.0, either:
::
>>> sum = 0.0
>>> for i in range(10):
... sum += 0.1
...
>>> sum
0.99999999999999989
2 進の浮動小数点数に対する算術演算は、このような意外性をたくさん持っています。"0.1" に関する問題は、以下の "表現エラー" の章で詳細に説明します。
2 進法の浮動小数点演算にともなうその他のよく知られた意外な事象に関しては `The Perils of Floating Point
`_ を参照してください。
.. % % Binary floating-point arithmetic holds many surprises like this. The
.. % % problem with "0.1" is explained in precise detail below, in the
.. % % "Representation Error" section. See
.. % % \citetitle[http://www.lahey.com/float.htm]{The Perils of Floating
.. % % Point} for a more complete account of other common surprises.
究極的にいうと、"容易な答えはありません"。ですが、浮動小数点数のことを過度に警戒しないでください！ Python の float 型操作における
エラーは浮動小数点処理ハードウェアから受けついたものであり、ほとんどのマシン上では一つの演算あたり高々 2\*\*53 分の 1 です。
この誤差はほとんどの作業で相当以上のものですが、浮動小数点演算は 10 進の演算えはなく、浮動小数点の演算を新たに行うと、新たな
丸め誤差の影響を受けることを心にとどめておいてください。
.. % % As that says near the end, ``there are no easy answers.'' Still,
.. % % don't be unduly wary of floating-point! The errors in Python float
.. % % operations are inherited from the floating-point hardware, and on most
.. % % machines are on the order of no more than 1 part in 2**53 per
.. % % operation. That's more than adequate for most tasks, but you do need
.. % % to keep in mind that it's not decimal arithmetic, and that every float
.. % % operation can suffer a new rounding error.
異常なケースが存在する一方で、普段の浮動小数点演算の利用では、単に最終的な結果の値を必要な
10 進の桁数に丸めて表示するのなら、最終的には期待通りの結果を得ることになるでしょう。
こうした操作は普通 :func:`str` で事足りますし、よりきめ細かな制御をしたければ、
:ref:`formatstrings` にある :meth:`str.format` メソッドのフォーマット仕様を参照してください。
.. % % While pathological cases do exist, for most casual use of
.. % % floating-point arithmetic you'll see the result you expect in the end
.. % % if you simply round the display of your final results to the number of
.. % % decimal digits you expect. \function{str()} usually suffices, and for
.. % % finer control see the discussion of Pythons's \code{\%} format
.. % % operator: the \code{\%g}, \code{\%f} and \code{\%e} format codes
.. % % supply flexible and easy ways to round float results for display.
.. _tut-fp-error:
表現エラー
==========
この章では、"0.1" の例について詳細に説明し、このようなケースに対してどのようにすれば正確な分析を自分で行えるかを示します。ここでは、 2
進法表現の浮動小数点数についての基礎的な知識があるものとして話を進めます。
.. % Representation Error
.. % % This section explains the ``0.1'' example in detail, and shows how
.. % % you can perform an exact analysis of cases like this yourself. Basic
.. % % familiarity with binary floating-point representation is assumed.
:dfn:`表現エラー` は、いくつかの (実際にはほとんどの) 10 進の小数が 2 進法 (基数 2 )
の分数として表現できないという事実に関係しています。これは Python (あるいは Perl、 C、 C++、Japa、Fortran 、および
その他多く) が期待通りの正確な 10 進数を表示できない主要な理由です:
.. % % \dfn{Representation error} refers to the fact that some (most, actually)
.. % % decimal fractions cannot be represented exactly as binary (base 2)
.. % % fractions. This is the chief reason why Python (or Perl, C, \Cpp,
.. % % Java, Fortran, and many others) often won't display the exact decimal
.. % % number you expect:
::
>>> 0.1
0.10000000000000001
なぜこうなるのでしょうか？ 1/10 は 2 進法の分数で厳密に表現することができません。今日 (2000年11月) のマシンは、ほとんどすべて
IEEE-754 浮動小数点演算を使用しており、ほとんどすべてのプラットフォームでは Python の浮動小数点を IEEE-754 における "倍精度
(double precision)" に対応付けます。754 の double には 53 ビットの精度を持つ数が入るので、
計算機に入力を行おうとすると、可能な限り 0.1 を最も近い値の分数に変換し、
*J*/2\*\**N* の形式にしようと努力します。 *J* はちょうど 53 ビットの精度の整数です。
.. % % Why is that? 1/10 is not exactly representable as a binary fraction.
.. % % Almost all machines today (November 2000) use IEEE-754 floating point
.. % % arithmetic, and almost all platforms map Python floats to IEEE-754
.. % % "double precision". 754 doubles contain 53 bits of precision, so on
.. % % input the computer strives to convert 0.1 to the closest fraction it can
.. % % of the form \var{J}/2**\var{N} where \var{J} is an integer containing
.. % % exactly 53 bits. Rewriting
::
1 / 10 ~= J / (2**N)
を書き直すと、
.. % % as
::
J ~= 2**N / 10
となります。 *J* は厳密に 53 ビットの精度を持っている (``>= 2**52`` だが ``< 2**53`` ) ことを思い出すと、 *N*
として最適な値は 56 になります:
.. % % and recalling that \var{J} has exactly 53 bits (is \code{>= 2**52} but
.. % % \code{< 2**53}), the best value for \var{N} is 56:
::
>>> 2**52
4503599627370496L
>>> 2**53
9007199254740992L
>>> 2**56/10
7205759403792793L
すなわち、56 は *J* をちょうど 53 ビットの精度のままに保つ *N* の唯一の値です。 *J* の取りえる値はその商を丸めたものです:
.. % % That is, 56 is the only value for \var{N} that leaves \var{J} with
.. % % exactly 53 bits. The best possible value for \var{J} is then that
.. % % quotient rounded:
::
>>> q, r = divmod(2**56, 10)
>>> r
6L
残りは 10 の半分以上なので、最良の近似は丸め値を一つ増やした (round up) ものになります:
.. % % Since the remainder is more than half of 10, the best approximation is
.. % % obtained by rounding up:
::
>>> q+1
7205759403792794L
従って、754 倍精度における 1/10 の取りえる最良の近似は 2\*\*56 以上の値、もしくは
.. % % Therefore the best possible approximation to 1/10 in 754 double
.. % % precision is that over 2**56, or
::
7205759403792794 / 72057594037927936
となります。丸め値を 1 増やしたので、この値は実際には 1/10 より少し小さいことに注意してください; 丸め値を 1 増やさない場合、商は 1/10
よりもわずかに小さくなります。しかし、どちらにしろ *厳密に* 1/10 ではありません！
.. % % Note that since we rounded up, this is actually a little bit larger than
.. % % 1/10; if we had not rounded up, the quotient would have been a little
.. % % bit smaller than 1/10. But in no case can it be \emph{exactly} 1/10!
つまり、計算機は 1/10 を "理解する" ことは決してありません: 計算機が理解できるのは、上記のような厳密な分数であり、 754
の倍精度浮動小数点数で得られるもっともよい近似は:
.. % % So the computer never ``sees'' 1/10: what it sees is the exact
.. % % fraction given above, the best 754 double approximation it can get:
::
>>> .1 * 2**56
7205759403792794.0
となります。
この分数に 10\*\*30 を掛ければ、有効数字 30 桁の十進数の (切り詰められた) 値を見ることができます:
.. % % If we multiply that fraction by 10**30, we can see the (truncated)
.. % % value of its 30 most significant decimal digits:
::
>>> 7205759403792794 * 10**30 / 2**56
100000000000000005551115123125L
これは、計算機が記憶している正確な数値が、10 進数値 0.100000000000000005551115123125 にほぼ等しいということです。この値を
有効数字 17 桁で丸めると、Python が表示する値は 0.10000000000000001 になります (もちろんこのような値になるのは、 IEEE
754 に適合していて、C ライブラリで可能な限り正確に値の入出力を行った場合だけです --- 読者の計算機ではそうではないかもしれません！)
.. % % meaning that the exact number stored in the computer is approximately
.. % % equal to the decimal value 0.100000000000000005551115123125. Rounding
.. % % that to 17 significant digits gives the 0.10000000000000001 that Python
.. % % displays (well, will display on any 754-conforming platform that does
.. % % best-possible input and output conversions in its C library --- yours may
.. % % not!).
Python-2.6.2-DocJa-1/_sources/tutorial/errors.txt 0000644 0001750 0001750 00000044176 11474251540 021277 0 ustar inada-n inada-n .. _tut-errors:
************
エラーと例外
************
これまでエラーメッセージについては簡単に触れるだけでしたが、チュートリアル中の例を自分で試していたら、実際にいくつかのエラーメッセージを見ている
ことでしょう。エラーには (少なくとも) 二つのはっきり異なる種類があります: それは *構文エラー (syntax error)* と*例外
(exception)* です。
.. _tut-syntaxerrors:
構文エラー
==========
構文エラーは構文解析エラー (parsing error) としても知られており、まだ Python
を学習中なら、おそらくもっともよく受け取る種の文句でしょう:
::
>>> while True print 'Hello world'
File "", line 1, in ?
while True print 'Hello world'
^
SyntaxError: invalid syntax
パーサは違反の起きている行を繰り返し、小さな '矢印' を表示して、
違反の起きている行中でエラーが検出された最初の位置を示します。エラーは矢印の *直前の*
トークンでひき起こされています (または、少なくともそこで検出されています)。上述の例の中では、エラーは :keyword:`print`
で検出されています。コロン (``':'``) がその前に無いからです。入力がスクリプトから来ている場合は、どこを見ればよいか分かるように
ファイル名と行番号が出力されます。
.. _tut-exceptions:
例外
====
たとえ文や式が構文的に正しくても、実行しようとしたときにエラーが発生するかもしれません。実行中に検出されたエラーは *例外 (exception)*
と呼ばれ、常に致命的とは限りません: Python プログラムで例外をどのように扱うかは、
すぐに習得することでしょう。ほとんどの例外はプログラムで処理されず、以下に示されるようなメッセージになります:
::
>>> 10 * (1/0)
Traceback (most recent call last):
File "", line 1, in ?
ZeroDivisionError: integer division or modulo by zero
>>> 4 + spam*3
Traceback (most recent call last):
File "", line 1, in ?
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback (most recent call last):
File "", line 1, in ?
TypeError: cannot concatenate 'str' and 'int' objects
エラーメッセージの最終行は何が起こったかを示しています。例外は様々な例外型 (type) で起こり、その型がエラーメッセージの一部として出力されます:
上の例での型は :exc:`ZeroDivisionError`, :exc:`NameError`, :exc:`TypeError` です。
例外型として出力される文字列は、発生した例外の組み込み名です。これは全ての組み込み例外について成り立ちますが、ユーザ定義の例外では
(成り立つようにするのは有意義な慣習ですが) 必ずしも成り立ちません。標準例外の名前は組み込みの識別子です (予約語ではありません)。
残りの行は例外の詳細で、その例外の型と何が起きたかに依存します。
エラーメッセージの先頭部分では、例外が発生した実行コンテキスト (context) を、スタックのトレースバック (stack traceback) の
形式で示しています。一般には、この部分にはソースコード行をリストしたトレースバックが表示されます; しかし、標準入力から
読み取られた行については表示しません。
:ref:`bltin-exceptions`
には、組み込み例外とその意味がリストされています。
.. _tut-handling:
例外を処理する
==============
例外を選別して処理するようなプログラムを書くことができます。以下の例を見てください。この例では、有効な文字列が入力されるまで
ユーザに入力を促しますが、ユーザがプログラムに (:kbd:`Control-C` か、またはオペレーティングシステムがサポートしている何らかのキーを使って)
割り込みをかけてプログラムを中断させることができるようにしています; ユーザが生成した割り込みは、 :exc:`KeyboardInterrupt`
例外が送出されることで通知されるということに注意してください。
::
>>> while True:
... try:
... x = int(raw_input("Please enter a number: "))
... break
... except ValueError:
... print "Oops! That was no valid number. Try again..."
...
:keyword:`try` 文は下記のように動作します。
* まず、 *try 節 (try clause)* (キーワード :keyword:`try` と :keyword:`except` の間の文)
が実行されます。
* 何も例外が発生しなければ、 *except 節* をスキップして :keyword:`try` 文の実行を終えます。
* try 節内の実行中に例外が発生すると、その節の残りは飛ばされます。
次に、例外型が :keyword:`except` キーワードの後に指定されている
例外に一致する場合、except 節が実行された後、 :keyword:`try` 節の後の文に実行が継続されます。
* もしも except 節で指定された例外と一致しない例外が発生すると、その例外は
:keyword:`try` 文の外側に渡されます。例外に対する
ハンドラ (handler、処理部) がどこにもなければ、 *処理されない例外 (unhandled exception)* となり、
上記に示したようなメッセージを出して実行を停止します。
一つの :keyword:`try` 文に複数の except 節を設けて、さまざまな例外に対するハンドラを指定することができます。同時に一つ以上のハンドラが
実行されることはありません。ハンドラは対応する try 節内で発生した例外だけを処理し、同じ try 節内の別の例外ハンドラで起きた例外は
処理しません。except 節には複数の例外を丸括弧で囲ったタプルにして渡すことができます。例えば以下のようにします:
::
... except (RuntimeError, TypeError, NameError):
... pass
最後の except 節では例外名を省いて、ワイルドカード (wildcard、総称記号) にすることができます。ワイルドカードの except
節は非常に注意して使ってください。というのは、ワイルドカードは通常のプログラムエラーをたやすく隠してしまうからです！ワイルドカードの except
節はエラーメッセージを出力した後に例外を再送出する (関数やメソッドの呼び出し側が同様にして例外を処理できるようにする) 用途にも使えます:
::
import sys
try:
f = open('myfile.txt')
s = f.readline()
i = int(s.strip())
except IOError as (errno, strerror):
print "I/O error({0}): {1}".format(errno, strerror)
except ValueError:
print "Could not convert data to an integer."
except:
print "Unexpected error:", sys.exc_info()[0]
raise
:keyword:`try` ... :keyword:`except` 文には、オプションで *else 節 (else clause)*
を設けることができます。
:keyword:`else` 節を設ける場合、全ての :keyword:`except` 節よりも後ろに置かねばなりません。
:keyword:`else` 節は try 節で全く例外が送出されなかったときに実行されるコードを書くのに役立ちます。
例えば以下のようにします。
::
for arg in sys.argv[1:]:
try:
f = open(arg, 'r')
except IOError:
print 'cannot open', arg
else:
print arg, 'has', len(f.readlines()), 'lines'
f.close()
追加のコードを追加するのは :keyword:`try` 節の後ろよりも :keyword:`else` 節の方がよいでしょう。なぜなら、そうすることで
:keyword:`try` ... :keyword:`except` 文で保護したいコードから
送出されたもの以外の例外を偶然に捕捉してしまうという事態を避けられるからです。
例外が発生するとき、例外に関連付けられた値を持つことができます。この値は例外の例外の *引数 (argument)* としても知られています。
引数の有無と引数の型がどうなっているかは例外の型に依存します。
except 節では、例外名 (または例外名タプル) の後に変数を指定することができます。この変数は例外インスタンスに結び付けられており、
``instance.args`` に例外インスタンス生成時の引数が入っています。例外インスタンスには :meth:`__getitem__` および
:meth:`__str__` が定義されており、 ``.args`` を参照しなくても引数に直接アクセスしたり印字したりできるように利便性が図られています。
しかし ``.args`` の利用は推奨されません。そのかわりに、例外へ引数を1つだけ渡してください（複数の値が必要な場合にはタプルを使用でき
ます）。そしてそれを ``message`` 属性に結びつけます。例外をraiseする前にインスタンス化をするときだけでなく、必要に応じて属性を追加できます。
::
>>> try:
... raise Exception('spam', 'eggs')
... except Exception as inst:
... print type(inst) # 例外インスタンス
... print inst.args # .args に記憶されている引数
... print inst # __str__ で引数を直接出力できる
... x, y = inst # __getitem__ で引数を直接アンパックできる
... print 'x =', x
... print 'y =', y
...
('spam', 'eggs')
('spam', 'eggs')
x = spam
y = eggs
処理されない例外の場合、例外が引数を持っていれば、メッセージの最後の ('詳細説明の') 部分に出力されます。
例外ハンドラは、try 節でじかに発生した例外を処理するだけではなく、その try 節から呼び出された関数の内部で発生した例外も処理します
(間接的に呼ばれていてもです) 。例えば:
::
>>> def this_fails():
... x = 1/0
...
>>> try:
... this_fails()
... except ZeroDivisionError, detail:
... print 'Handling run-time error:', detail
...
Handling run-time error: integer division or modulo by zero
.. _tut-raising:
例外を送出する
==============
:keyword:`raise` 文を使うと、プログラマは指定した例外を強制的に送出させられます。例えば:
::
>>> raise NameError, 'HiThere'
Traceback (most recent call last):
File "", line 1, in ?
NameError: HiThere
:keyword:`raise` の第一引数には、ひき起こすべき例外を指定します。オプションの第二引数では例外の引数を指定します。同じことを ``raise
NameError('HiThere')`` としても記述できます。どちらの形式でもうまく動きますが後者のほうがスタイルがよくみえます。
例外が発生したかどうかは判定したいが、その処理を行おうとは思っていない場合、単純な形式の :keyword:`raise` 文を使って例外を再送出させることが
できます:
::
>>> try:
... raise NameError, 'HiThere'
... except NameError:
... print 'An exception flew by!'
... raise
...
An exception flew by!
Traceback (most recent call last):
File "", line 2, in ?
NameError: HiThere
.. _tut-userexceptions:
ユーザ定義の例外
================
プログラム上で新しい例外クラスを作成することで、独自の例外を指定することができます。例外は、典型的に :exc:`Exception` クラスから、
直接または間接的に導出したものです。例えば:
::
>>> class MyError(Exception):
... def __init__(self, value):
... self.value = value
... def __str__(self):
... return repr(self.value)
...
>>> try:
... raise MyError(2*2)
... except MyError as e:
... print 'My exception occurred, value:', e.value
...
My exception occurred, value: 4
>>> raise MyError, 'oops!'
Traceback (most recent call last):
File "", line 1, in ?
__main__.MyError: 'oops!'
この例では :class:`Exception` のデフォルト :meth:`__init__` がオーバーライドされています。新しいふるまいでは、単に
*value* 属性を作ります。これはデフォルトの *args* 属性を作成するふるまいを置き換えています。
例外クラスでは、他のクラスができることなら何でも定義することができますが、通常は単純なものにしておきます。たいていは、いくつかの
属性だけを提供し、例外が発生したときにハンドラがエラーに関する情報を取り出せるようにする程度にとどめます。
複数の別個の例外を送出するようなモジュールを作成する際には、そのモジュールで定義されている例外の基底クラスを作成するのが一般的なならわしです:
::
class Error(Exception):
"""Base class for exceptions in this module."""
pass
class InputError(Error):
"""Exception raised for errors in the input.
Attributes:
expression -- input expression in which the error occurred
message -- explanation of the error
"""
def __init__(self, expression, message):
self.expression = expression
self.message = message
class TransitionError(Error):
"""Raised when an operation attempts a state transition that's not
allowed.
Attributes:
previous -- state at beginning of transition
next -- attempted new state
message -- explanation of why the specific transition is not allowed
"""
def __init__(self, previous, next, message):
self.previous = previous
self.next = next
self.message = message
ほとんどの例外は、標準の例外の名前付けと同様に、 "Error," で終わる名前で定義されています。
多くの標準モジュールでは、モジュールで定義されている関数内で発生する可能性のあるエラーを報告させるために、独自の例外を定義しています。
クラスについての詳細な情報は :ref:`tut-classes` 章で提供されています。
.. _tut-cleanup:
後片付け動作を定義する
======================
:keyword:`try` 文にはもう一つオプションの節があります。この節はクリーンアップ動作を定義するためのもので、どんな状況でも必ず
実行されます。例えば:
::
>>> try:
... raise KeyboardInterrupt
... finally:
... print 'Goodbye, world!'
...
Goodbye, world!
Traceback (most recent call last):
File "", line 2, in ?
KeyboardInterrupt
*finally 節 (finally clause)* は、 :keyword:`try`
節で例外が発生したかどうかに関係なく常に :keyword:`try` 節のあとに実行されます。
:keyword:`try` 節の中で例外が発生して、 :keyword:`except` 節でハンドルされ
ていない場合、または :keyword:`except` 節か :keyword:`else` 節で例外が発生した場合は、 :keyword:`finally`
節を実行した後、その例外を再送出します。 :keyword:`finally` 節はまた、 :keyword:`try` 節から :keyword:`break`
文や :keyword:`continue` 文、 :keyword:`return` 文経由で抜ける際にも、 "抜ける途中で" 実行されます。
より複雑な例です (:keyword:`except` 節や :keyword:`finally` 節が同じ :keyword:`try` 文の中にあっても Python 2.5 と同じように動作します):
::
>>> def divide(x, y):
... try:
... result = x / y
... except ZeroDivisionError:
... print "division by zero!"
... else:
... print "result is", result
... finally:
... print "executing finally clause"
...
>>> divide(2, 1)
result is 2
executing finally clause
>>> divide(2, 0)
division by zero!
executing finally clause
>>> divide("2", "1")
executing finally clause
Traceback (most recent call last):
File "", line 1, in ?
File "", line 3, in divide
TypeError: unsupported operand type(s) for /: 'str' and 'str'
見てわかるとおり、 :keyword:`finally` 節はどの場合にも実行されています。文字列を割り算することで発生した :exc:`TypeError` は
:keyword:`except` 節でハンドルされていませんので、 :keyword:`finally` 節実行後に再度raiseされています。
実世界のアプリケーションでは、 :keyword:`finally` 節は(ファイルやネットワー
ク接続などの)外部リソースを利用の成否にかかわらず開放するために便利です。
.. _tut-cleanup-with:
定義済み完了処理
================
オブジェクトのなかには、その利用の成否にかかわらず、不要になった際に実行される標準的な完了処理が定義されているものがあります。
以下の、ファイルをオープンして内容を画面に表示する例をみてください:
::
for line in open("myfile.txt"):
print line
このコードの問題点は、このコードが実行されてから、ファイルをいつまで openしたままでいるかわからないことです。
これは単純なスクリプトでは問題になりませんが、大きなアプリケーションでは問題になりえます。 :keyword:`with` 文はファイルのようなオブジェクトが
常に、即座に正しく完了されることを保証します。
::
with open("myfile.txt") as f:
for line in f:
print line
文が実行されたあと、行の処理中に問題があったかどうかに関係なく、ファイル *f* は常にcloseされます。他の定義済み完了処理をもつオブジェクト
については、それぞれのドキュメントで示されます。
Python-2.6.2-DocJa-1/_sources/tutorial/stdlib.txt 0000644 0001750 0001750 00000043661 11474251540 021242 0 ustar inada-n inada-n .. _tut-brieftour:
************************
標準ライブラリミニツアー
************************
.. _tut-os-interface:
オペレーティングシステムへのインタフェース
==========================================
:mod:`os` モジュールは、オペレーティングシステムと対話するための
何ダースもの関数を提供しています:
::
>>> import os
>>> os.system('time 0:02')
0
>>> os.getcwd() # 現在の作業ディレクトリを返す
'C:\\Python26'
>>> os.chdir('/server/accesslogs')
``from os import *`` ではなく、 ``import os`` 形式を使うようにしてください。そうすることで、
動作が大きく異なる組み込み関数 :func:`open` が :func:`os.open` で隠蔽されるのを避けられます。
.. % % Be sure to use the \samp{import os} style instead of
.. % % \samp{from os import *}. This will keep \function{os.open()} from
.. % % shadowing the builtin \function{open()} function which operates much
.. % % differently.
.. index:: builtin: help
組み込み関数 :func:`dir` および :func:`help` は、 :mod:`os` のような大規模なモジュールで作業をするときに、対話的な
操作上の助けになります:
.. % % The builtin \function{dir()} and \function{help()} functions are useful
.. % % as interactive aids for working with large modules like \module{os}:
::
>>> import os
>>> dir(os)
>>> help(os)
ファイルやディレクトリの日常的な管理作業のために、より簡単に使える高レベルインタフェースが
:mod:`shutil` モジュールで提供されています。
::
>>> import shutil
>>> shutil.copyfile('data.db', 'archive.db')
>>> shutil.move('/build/executables', 'installdir')
.. _tut-file-wildcards:
ファイルのワイルドカード表記
============================
:mod:`glob` モジュールでは、
ディレクトリのワイルドカード検索からファイルのリストを生成するための関数を提供しています:
.. % % The \ulink{\module{glob}}{../lib/module-glob.html}
.. % % module provides a function for making file lists from directory
.. % % wildcard searches:
::
>>> import glob
>>> glob.glob('*.py')
['primes.py', 'random.py', 'quote.py']
.. _tut-command-line-arguments:
コマンドライン引数
==================
広く使われているユーティリティスクリプトでは、しばしばコマンドライン引数の処理を呼び出します。
これらの引数は :mod:`sys` モジュールの *argv* 属性にリストとして記憶されます。
例えば、以下の出力は、 ``python demo.py one two three`` をコマンドライン上で起動した際に得られるものです:
.. % % Common utility scripts often need to process command line arguments.
.. % % These arguments are stored in the
.. % % \ulink{\module{sys}}{../lib/module-sys.html}\ module's \var{argv}
.. % % attribute as a list. For instance the following output results from
.. % % running \samp{python demo.py one two three} at the command line:
::
>>> import sys
>>> print sys.argv
['demo.py', 'one', 'two', 'three']
:mod:`getopt` モジュールは、 *sys.argv* を
Unix の :func:`getopt` 関数の慣習に従って処理します。より強力で柔軟性のあるコマンドライン処理機能は、 :mod:`optparse`
モジュールで提供されています。
.. % % The \ulink{\module{getopt}}{../lib/module-getopt.html}
.. % % module processes \var{sys.argv} using the conventions of the \UNIX{}
.. % % \function{getopt()} function. More powerful and flexible command line
.. % % processing is provided by the
.. % % \ulink{\module{optparse}}{../lib/module-optparse.html} module.
.. _tut-stderr:
エラー出力のリダイレクトとプログラムの終了
==========================================
:mod:`sys` モジュールには、 *stdin*, *stdout*, *stderr* を表す属性値も存在します。
後者の *stderr* は、警告やエラーメッセージを出力して、 *stdout*
がリダイレクトされた場合でもそれらが読めるようにする上で便利です:
.. % % The \ulink{\module{sys}}{../lib/module-sys.html}
.. % % module also has attributes for \var{stdin}, \var{stdout}, and
.. % % \var{stderr}. The latter is useful for emitting warnings and error
.. % % messages to make them visible even when \var{stdout} has been redirected:
::
>>> sys.stderr.write('Warning, log file not found starting a new one\n')
Warning, log file not found starting a new one
``sys.exit()`` は、スクリプトを終了させるもっとも直接的な方法です。
.. % % The most direct way to terminate a script is to use \samp{sys.exit()}.
.. _tut-string-pattern-matching:
文字列のパターンマッチング
==========================
:mod:`re` モジュールでは、より高度な文字列処理のための正規表現
(regular expression) を提供しています。
正規表現は複雑な一致検索や操作に対して簡潔で最適化された解決策を与えます:
.. % % The \ulink{\module{re}}{../lib/module-re.html}
.. % % module provides regular expression tools for advanced string processing.
.. % % For complex matching and manipulation, regular expressions offer succinct,
.. % % optimized solutions:
::
>>> import re
>>> re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest')
['foot', 'fell', 'fastest']
>>> re.sub(r'(\b[a-z]+) \1', r'\1', 'cat in the the hat')
'cat in the hat'
最小限の機能だけが必要なら、読みやすくデバッグしやすい文字列メソッドの方がお勧めです:
.. % % When only simple capabilities are needed, string methods are preferred
.. % % because they are easier to read and debug:
::
>>> 'tea for too'.replace('too', 'two')
'tea for two'
.. _tut-mathematics:
数学
====
:mod:`math` モジュールでは、根底にある浮動小数点演算のための C
言語ライブラリ関数にアクセスする手段を提供しています:
::
>>> import math
>>> math.cos(math.pi / 4.0)
0.70710678118654757
>>> math.log(1024, 2)
10.0
:mod:`random` モジュールでは、乱数に基づいた要素選択のためのツールを提供しています:
.. % % The \ulink{\module{random}}{../lib/module-random.html}
.. % % module provides tools for making random selections:
::
>>> import random
>>> random.choice(['apple', 'pear', 'banana'])
'apple'
>>> random.sample(xrange(100), 10) # 要素を戻さないサンプリング
[30, 83, 16, 4, 8, 81, 41, 50, 18, 33]
>>> random.random() # ランダムな浮動小数点数
0.17970987693706186
>>> random.randrange(6) # range(6) からランダムに選ばれた整数
4
.. _tut-internet-access:
インターネットへのアクセス
==========================
インターネットにアクセスしたり、インターネットプロトコルを処理したりするための数多くのモジュールがあります。
その中でも特にシンプルなモジュールとして、URL
を指定してデータを取得するための :mod:`urllib2`
と、メールを送信するための :mod:`smtplib` があります。
::
>>> import urllib2
>>> for line in urllib2.urlopen('http://tycho.usno.navy.mil/cgi-bin/timer.pl'):
... if 'EST' in line or 'EDT' in line: # look for Eastern Time
... print line
Nov. 25, 09:43:32 PM EST
>>> import smtplib
>>> server = smtplib.SMTP('localhost')
>>> server.sendmail('soothsayer@example.org', 'jcaesar@example.org',
... """To: jcaesar@example.org
... From: soothsayer@example.org
...
... Beware the Ides of March.
... """)
>>> server.quit()
(2つ目の例は localhost でメールサーバーが動いている必要があることに注意してください。)
.. _tut-dates-and-times:
日付と時刻
==========
:mod:`datetime` モジュールは、
日付や時刻を操作するためのクラスを、単純な方法と複雑な方法の両方で供給しています。日付や時刻に対する算術がサポートされている一方、
実装では出力の書式化や操作のための効率的なデータメンバ抽出に重点を置いています。このモジュールでは、タイムゾーンに対応したオブジェクトもサポート
しています。
.. % % The \ulink{\module{datetime}}{../lib/module-datetime.html} module
.. % % supplies classes for manipulating dates and times in both simple
.. % % and complex ways. While date and time arithmetic is supported, the
.. % % focus of the implementation is on efficient member extraction for
.. % % output formatting and manipulation. The module also supports objects
.. % % that are time zone aware.
::
# dates are easily constructed and formatted
>>> from datetime import date
>>> now = date.today()
>>> now
datetime.date(2003, 12, 2)
>>> now.strftime("%m-%d-%y. %d %b %Y is a %A on the %d day of %B")
'12-02-03. 02 Dec 2003 is a Tuesday on the 02 day of December'
# dates support calendar arithmetic
>>> birthday = date(1964, 7, 31)
>>> age = now - birthday
>>> age.days
14368
.. _tut-data-compression:
データ圧縮
==========
データの書庫化や圧縮で広く使われている形式については、 :mod:`zlib`,
:mod:`gzip`, :mod:`bz2`, :mod:`zipfile`, :mod:`tarfile` といったモジュールで直接サポートしています。
.. % % Common data archiving and compression formats are directly supported
.. % % by modules including:
.. % % \ulink{\module{zlib}}{../lib/module-zlib.html},
.. % % \ulink{\module{gzip}}{../lib/module-gzip.html},
.. % % \ulink{\module{bz2}}{../lib/module-bz2.html},
.. % % \ulink{\module{zipfile}}{../lib/module-zipfile.html}, and
.. % % \ulink{\module{tarfile}}{../lib/module-tarfile.html}.
::
>>> import zlib
>>> s = 'witch which has which witches wrist watch'
>>> len(s)
41
>>> t = zlib.compress(s)
>>> len(t)
37
>>> zlib.decompress(t)
'witch which has which witches wrist watch'
>>> zlib.crc32(s)
226805979
.. _tut-performance-measurement:
パフォーマンスの計測
====================
Python ユーザの中には、同じ問題を異なったアプローチで解いた際の相対的なパフォーマンスについて知りたいという深い興味を
持っている人がいます。Python では、そういった疑問に即座に答える計測ツールを提供しています。
.. % % Some Python users develop a deep interest in knowing the relative
.. % % performance between different approaches to the same problem.
.. % % Python provides a measurement tool that answers those questions
.. % % immediately.
例えば、引数の入れ替え操作に対して、伝統的なアプローチの代わりにタプルのパックやアンパックを使ってみたい気持ちになるかもしれません。
:mod:`timeit` モジュールを使えば、パフォーマンス上の利点はほぼ互角だとわかります:
.. % % For example, it may be tempting to use the tuple packing and unpacking
.. % % feature instead of the traditional approach to swapping arguments.
.. % % The \ulink{\module{timeit}}{../lib/module-timeit.html} module
.. % % quickly demonstrates a modest performance advantage:
::
>>> from timeit import Timer
>>> Timer('t=a; a=b; b=t', 'a=1; b=2').timeit()
0.57535828626024577
>>> Timer('a,b = b,a', 'a=1; b=2').timeit()
0.54962537085770791
:mod:`timeit` では高い粒度レベルを提供しているのに対し、 :mod:`profile` や
:mod:`pstats` モジュールではより大きなコードブロックにおいて律速となる部分を
判定するためのツールを提供しています。
.. % % In contrast to \module{timeit}'s fine level of granularity, the
.. % % \ulink{\module{profile}}{../lib/module-profile.html} and \module{pstats}
.. % % modules provide tools for identifying time critical sections in larger
.. % % blocks of code.
.. _tut-quality-control:
品質管理
========
高い品質のソフトウェアを開発するための一つのアプローチは、全ての関数に対して開発と同時にテストを書き、開発の過程で頻繁にテストを走らせるというものです。
.. % % One approach for developing high quality software is to write tests for
.. % % each function as it is developed and to run those tests frequently during
.. % % the development process.
:mod:`doctest` モジュールでは、
モジュールを検索して、プログラムの docstring に埋め込まれたテストの評価を行うためのツールを提供しています。テストの作り方は単純で、
典型的な呼び出し例とその結果を docstring にカット& ペーストするというものです。この作業は、ユーザに使用例を与えるという意味で
ドキュメントの情報を増やすと同時に、ドキュメントに書かれている内容が正しいかどうか doctest モジュールが確認できるようにしています:
.. % % The \ulink{\module{doctest}}{../lib/module-doctest.html} module provides
.. % % a tool for scanning a module and validating tests embedded in a program's
.. % % docstrings. Test construction is as simple as cutting-and-pasting a
.. % % typical call along with its results into the docstring. This improves
.. % % the documentation by providing the user with an example and it allows the
.. % % doctest module to make sure the code remains true to the documentation:
::
def average(values):
"""Computes the arithmetic mean of a list of numbers.
>>> print average([20, 30, 70])
40.0
"""
return sum(values, 0.0) / len(values)
import doctest
doctest.testmod() # automatically validate the embedded tests
:mod:`unittest` モジュールは
:mod:`doctest` モジュールほど気楽に使えるものではありませんが、より網羅的なテストセットを別のファイルで管理することができます:
.. % % The \ulink{\module{unittest}}{../lib/module-unittest.html} module is not
.. % % as effortless as the \module{doctest} module, but it allows a more
.. % % comprehensive set of tests to be maintained in a separate file:
::
import unittest
class TestStatisticalFunctions(unittest.TestCase):
def test_average(self):
self.assertEqual(average([20, 30, 70]), 40.0)
self.assertEqual(round(average([1, 5, 7]), 1), 4.3)
self.assertRaises(ZeroDivisionError, average, [])
self.assertRaises(TypeError, average, 20, 30, 70)
unittest.main() # Calling from the command line invokes all tests
.. _tut-batteries-included:
バッテリー同梱
==============
Python には "バッテリー同梱 (batteries included)" 哲学があります。この哲学は、洗練され、安定した機能を持つ Python
の膨大なパッケージ群に如実に表れています。例えば:
.. % % Python has a ``batteries included'' philosophy. This is best seen
.. % % through the sophisticated and robust capabilities of its larger
.. % % packages. For example:
* The :mod:`xmlrpclib` および
:mod:`SimpleXMLRPCServer`
モジュールは、遠隔手続き呼び出し (remote procedure call) を全くたいしたことのない作業に変えてしまいます。モジュール名とは違い、XML
を扱うための直接的な知識は必要ありません。
.. % % \item The \ulink{\module{email}}{../lib/module-email.html}
.. % % package is a library for managing email messages,
.. % % including MIME and other RFC 2822-based message documents. Unlike
.. % % \module{smtplib} and \module{poplib} which actually send and receive
.. % % messages, the email package has a complete toolset for building or
.. % % decoding complex message structures (including attachments)
.. % % and for implementing internet encoding and header protocols.
* The :mod:`email` パッケージは、MIME やその他の
RFC 2822 に基づくメッセージ文書を含む電子メイルメッセージを管理するためのライブラリです。実際にメッセージを送信したり受信したりする
:mod:`smtplib` や :mod:`poplib` と違って、email パッケージには (添付文書を含む)
複雑なメッセージ構造の構築やデコードを行ったり、インターネット標準のエンコードやヘッダプロトコルの実装を行ったりするための完全なツールセットを備えています。
.. % % \item The \ulink{\module{xml.dom}}{../lib/module-xml.dom.html} and
.. % % \ulink{\module{xml.sax}}{../lib/module-xml.sax.html} packages provide
.. % % robust support for parsing this popular data interchange format. Likewise,
.. % % the \module{csv} module supports direct reads and writes in a common
.. % % database format. Together, these modules and packages greatly simplify
.. % % data interchange between python applications and other tools.
* :mod:`xml.dom` および :mod:`xml.sax`
パッケージでは、一般的なデータ交換形式である XML
を解析するための頑健なサポートを提供しています。同様に、 :mod:`csv` モジュールでは、広く用いられている
データベース形式のデータを直接読み書きする機能をサポートしています。これらのモジュールやパッケージは併用することで、Python アプリケーション
と他のツール群との間でのデータ交換を劇的に簡単化します。
.. % % \item Internationalization is supported by a number of modules including
.. % % \ulink{\module{gettext}}{../lib/module-gettext.html},
.. % % \ulink{\module{locale}}{../lib/module-locale.html}, and the
.. % % \ulink{\module{codecs}}{../lib/module-codecs.html} package.
* 国際化に関する機能は、 :mod:`gettext`,
:mod:`locale` および :mod:`codecs` パッケージといったモジュール群でサポートされています。
Python-2.6.2-DocJa-1/_sources/tutorial/modules.txt 0000644 0001750 0001750 00000077701 11474251541 021434 0 ustar inada-n inada-n .. _tut-modules:
**********
モジュール
**********
Python インタプリタを終了させ、再び起動すると、これまでに行ってきた定義 (関数や変数) は失われています。ですから、より長いプログラムを
書きたいなら、テキストエディタを使ってインタプリタへの入力を用意しておき、手作業の代わりにファイルを入力に使って動作させるとよいでしょう。この作業を
*スクリプト (script)* の作成と言います; プログラムが長くなるにつれ、メンテナンスを楽にするために、スクリプトをいくつかの
ファイルに分割したくなるかもしれません。また、いくつかのプログラムで書いてきた便利な関数について、その定義をコピーすることなく個々の
プログラムで使いたいと思うかもしれません。
こういった要求をサポートするために、Python では定義をファイルに書いておき、スクリプトの中やインタプリタの対話インスタンス上で使う方法があります。
このファイルを *モジュール (module)* と呼びます; モジュールにある定義は、他のモジュールや *main* モジュール (実行の
トップレベルや電卓モードでアクセスできる変数の集まりを指します) に *import* (取り込み) することができます。
モジュールは Python の定義や文が入ったファイルです。ファイル名はモジュール名に接尾語 :file:`.py` がついたものになります。
モジュールの中では、(文字列の) モジュール名をグローバル変数 ``__name__`` で取得できます。例えば、お気に入りのテキストエディタ
を使って、現在のディレクトリに以下の内容のファイル :file:`fibo.py` を作成してみましょう:
::
# フィボナッチ数列モジュール
def fib(n): # nまで加算されるフィボナッチ級数を印字
a, b = 0, 1
while b < n:
print b,
a, b = b, a+b
def fib2(n): # nまで加算されるフィボナッチ級数を返す
result = []
a, b = 0, 1
while b < n:
result.append(b)
a, b = b, a+b
return result
次に Python インタプリタに入り、モジュールを以下のコマンドで import しましょう。
::
>>> import fibo
この操作では、 ``fibo`` で定義された関数の名前を直接現在のシンボルテーブルに入力することはありません; 単にモジュール名 ``fibo``
だけをシンボルテーブルに入れます。関数にはモジュール名を使ってアクセスします:
::
>>> fibo.fib(1000)
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
関数を度々使うのなら、ローカルな名前に代入できます:
::
>>> fib = fibo.fib
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
.. _tut-moremodules:
モジュールについてもうすこし
============================
モジュールには、関数定義に加えて実行文を入れることができます。これらの実行文はモジュールを初期化するためのものです。
これらの実行文は、モジュールがどこかで *最初に* import された時にだけ実行されます。 [#]_
各々のモジュールは、自前のプライベートなシンボルテーブルを持っていて、モジュールで定義されている関数はこのテーブルをグローバルな
シンボルテーブルとして使います。したがって、モジュールの作者は、ユーザのグローバル変数と偶然的な衝突が
起こる心配をせずに、グローバルな変数をモジュールで使うことができます。一方、自分が行っている操作をきちんと理解していれば、モジュール内の
関数を参照するのと同じ表記法 ``modname.itemname`` で、モジュールのグローバル変数をいじることもできます。
モジュールが他のモジュールを import することもできます。 :keyword:`import` 文は全てモジュールの先頭に (さらに言えばスクリプトでも)
置きますが、これは慣習であって必須ではありません。import されたモジュール名は import
を行っているモジュールのグローバルなシンボルテーブルに置かれます。
:keyword:`import` 文には、あるモジュール内の名前を、import を実行しているモジュールのシンボルテーブル内に直接取り込むという変型が
あります。例えば:
::
>>> from fibo import fib, fib2
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
この操作は、import の対象となるモジュール名をローカルなシンボルテーブル内に取り入れることはありません (従って上の例では、 ``fibo``
は定義されません)。
モジュールで定義されている名前を全て import するという変型もあります:
::
>>> from fibo import *
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
上の操作は、アンダースコア (``_``) で開始する名前以外の全ての名前を import します。
.. note::
実行効率上の理由で、各モジュールはインタープリタの 1 セッションごとに 1 回だけ import されます。従って、モジュールを修正した場合には、インタープリタを再起動させなければなりません -- もしくは、その場で手直ししてテストしたいモジュールが 1 つだった場合には、例えば ``reload(modulename)`` のように :func:`reload` を使ってください。
.. _tut-modulesasscripts:
モジュールをスクリプトとして実行する
====================================
Python モジュールを
::
python fibo.py
と実行すると、 ``__name__`` に ``__main__`` が設定されている点を除いて import したときと同じようにモジュール内のコードが実行されます。つまりモジュールの末尾にこのコード
::
if __name__ == "__main__":
import sys
fib(int(sys.argv[1]))
を追加することで、このファイルが import できるモジュールであると同時にスクリプトとしても使えるようになります、なぜならモジュールが "main" ファイルとして起動されたときだけ、コマンドラインを解釈するコードが実行されるからです:
::
$ python fibo.py 50
1 1 2 3 5 8 13 21 34
モジュールが import された場合は、そのコードは実行されません:
::
>>> import fibo
>>>
この方法はモジュールに便利なユーザインターフェースを提供したり、テストのために (スクリプトをモジュールとして起動しテストスイートを実行して) 使われます。
.. _tut-searchpath:
モジュール検索パス
------------------
.. index:: triple: module; search; path
:mod:`spam` という名前のモジュールが import されると、インタプリタは :file:`spam.py`
という名前のファイルを現在のディレクトリ内で探し、次に環境変数 :envvar:`PYTHONPATH` に指定されているディレクトリのリスト
から探します。 :envvar:`PYTHONPATH` はシェル変数 :envvar:`PATH` と
同じ構文、すなわちディレクトリ名を並べたものです。 :envvar:`PYTHONPATH` が設定されていないか、探しているファイルが見つからなかった場合は、
検索対象をインストール方法に依存するデフォルトのパスにして続けます; Unixでは、このパスは通常
:file:`.:/usr/locall/lib/python` です。
実際には、モジュールは変数 ``sys.path`` で指定されたディレクトリのリストから検索されます。 ``sys.path`` は、入力とするスクリプトの
入ったディレクトリ (現在のディレクトリ)、 :envvar:`PYTHONPATH` 、およびインストール方法依存のデフォルト値を使って初期化されます。
Python プログラマは、自分の行っている操作を理解しているなら、この変数を使ってモジュール検索パスを修正したり置き換えたりすることができます。
起動しようとするスクリプトの入ったディレクトリが検索パス上にあるため、スクリプトが標準モジュールと同じ名前をもたないようにすることが
重要です。さもなければ、Python が標準モジュールを import するときにスクリプトをモジュールとして import しようと試みてしまうので注意
してください。このような誤りを犯すと、通常はエラーになります。詳しくは :ref:`tut-standardmodules` 節
を参照してください。
"コンパイル" された Python ファイル
-----------------------------------
たくさんの標準モジュールを使うような短いプログラムで重要となる起動時間の高速化を行うために、 :file:`spam.py` が見つかったディレクトリに
:file:`spam.pyc` という名前のファイルがあった場合には、このファイルをモジュール :mod:`spam` の "バイトコンパイルされた"
バージョンであると仮定します。 :file:`spam.pyc` を生成するのに使われたバージョンの :file:`spam.py` のファイル修正時刻が
:file:`spam.pyc` に記録されており、この値が一致しなければ :file:`spam.pyc` ファイルは無視されます。
通常、 :file:`spam.pyc` ファイルを生成するために何かをする必要はありません。 :file:`spam.py` が無事コンパイルされると、常に
コンパイルされたバージョンを :file:`spam.pyc` へ書き出すよう試みます。この試みが失敗してもエラーにはなりません;
何らかの理由でファイルが完全に書き出されなかった場合、作成された :file:`smap.pyc` は無効であるとみなされ、それ以後無視されます。
:file:`spam.pyc` ファイルの内容はプラットフォームに依存しないので、 Python のモジュールのディレクトリは異なるアーキテクチャのマシン間で
共有することができます。
エキスパートへの助言:
* Python インタプリタを :option:`-O` フラグ付きで起動すると、最適化 (optimize) されたコードが生成されて
:file:`.pyo` ファイルに保存されます。最適化機構は今のところあまり役に立っていません; 最適化機構は :keyword:`assert` 文と
``SET_LINENO`` 命令を除去しているだけです。 :option:`-O` を使うと、 *すべての* バイトコード (:term:`bytecode`) が最適化されます; ``.pyc``
ファイルは無視され、 ``.py`` ファイルは最適化されたバイトコードにコンパイルされます。
* 二つの :option:`-O` フラグ (:option:`-OO`) を Python インタプリタへ渡すと、バイトコードコンパイラは、
まれにプログラムが正しく動作しなくなるかもしれないような最適化を実行します。現状では、ただ ``__doc__`` 文字列をバイトコードから除去して、
よりコンパクトな :file:`.pyo` ファイルにするだけです。この文字列が利用できることをあてにしているプログラムがあるかもしれない
ので、自分の行っている操作が何かわかっているときにだけこのオプションを使うべきです。
* :file:`.pyc` ファイルや :file:`.pyo` ファイルから読み出されたとしても、プログラムは何ら高速に動作するわけでは
ありません。 :file:`.pyc` ファイルや :file:`.pyo` ファイルで高速化されるのは、読み込まれるときの速度だけです。
* スクリプトの名前をコマンドラインで指定して実行した場合、そのスクリプトのバイトコードが :file:`.pyc` や :file:`.pyo` に
書き出されることはありません。従って、スクリプトのほとんどのコードをモジュールに移し、そのモジュールを import する小さなブートストラップ
スクリプトを作れば、スクリプトの起動時間を短縮できるときがあります。 :file:`.pyc` または :file:`.pyo`
ファイルの名前を直接コマンドラインに指定することもできます。
* 一つのモジュールについて、ファイル :file:`spam.py` のない :file:`spam.pyc` (:option:`-O` を使ったときは
:file:`spam.pyo`) があってもかまいません。この仕様は、Python コードでできたライブラリを
リバースエンジニアリングがやや困難な形式で配布するために使えます。
.. index:: module: compileall
* :mod:`compileall`
は、 :file:`.pyc` ファイル (または :option:`-O` を使ったときは :file:`.pyo` ファイル) を
ディレクトリ内の全てのモジュールに対して生成することができます。
.. %
.. _tut-standardmodules:
標準モジュール
==============
.. index:: module: sys
Python には標準モジュールのライブラリが付属しています。ライブラリは独立したドキュメント Python ライブラリリファレンス (Python
Library Reference) (以降 "ライブラリリファレンス")
で記述されています。モジュールによってはインタプリタに組み込まれたものがあります; インタプリタに組み込まれているモジュールが提供しているのは、
言語の中核の部分ではありませんが、効率化のためや、システムコールのようなオペレーティングシステムの根本機能へのアクセス手段を提供するための
操作です。これらのモジュールのセットは設定時に選択可能で、また根底にあるプラットフォームにも依存します。例えば、 :mod:`winreg` モジュールは、
Windows でのみ提供されます。とりわけ、注目に値するモジュールが一つあります:
:mod:`sys` はどの Python インタプリタにも
組み込まれています。変数 ``sys.ps1`` と ``sys.ps2`` は、それぞれ一次プロンプトと二次プロンプトとして使われる文字列を定義しています:
::
>>> import sys
>>> sys.ps1
'>>> '
>>> sys.ps2
'... '
>>> sys.ps1 = 'C> '
C> print 'Yuck!'
Yuck!
C>
これらの二つの変数は、インタプリタが対話モードにあるときだけ定義されています。
変数 ``sys.path`` は文字列からなるリストで、インタプリタがモジュールを検索するときのパスを決定します。 ``sys.path`` は環境変数
:envvar:`PYTHONPATH` から得たデフォルトパスに、 :envvar:`PYTHONPATH`
が設定されていなければ組み込みのデフォルト値に設定されます。標準的なリスト操作で変更することができます:
::
>>> import sys
>>> sys.path.append('/ufs/guido/lib/python')
.. _tut-dir:
:func:`dir` 関数
================
組込み関数 :func:`dir` は、あるモジュールがどんな名前を定義しているか調べるために使われます。 :func:`dir`
はソートされた文字列のリストを返します:
::
>>> import fibo, sys
>>> dir(fibo)
['__name__', 'fib', 'fib2']
>>> dir(sys)
['__displayhook__', '__doc__', '__excepthook__', '__name__', '__stderr__',
'__stdin__', '__stdout__', '_getframe', 'api_version', 'argv',
'builtin_module_names', 'byteorder', 'callstats', 'copyright',
'displayhook', 'exc_clear', 'exc_info', 'exc_type', 'excepthook',
'exec_prefix', 'executable', 'exit', 'getdefaultencoding', 'getdlopenflags',
'getrecursionlimit', 'getrefcount', 'hexversion', 'maxint', 'maxunicode',
'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache',
'platform', 'prefix', 'ps1', 'ps2', 'setcheckinterval', 'setdlopenflags',
'setprofile', 'setrecursionlimit', 'settrace', 'stderr', 'stdin', 'stdout',
'version', 'version_info', 'warnoptions']
引数がなければ、 :func:`dir` は現在定義している名前を列挙します。
::
>>> a = [1, 2, 3, 4, 5]
>>> import fibo
>>> fib = fibo.fib
>>> dir()
['__builtins__', '__doc__', '__file__', '__name__', 'a', 'fib', 'fibo', 'sys']
変数、モジュール、関数、その他の、すべての種類の名前をリストすることに注意してください。
.. index:: module: __builtin__
:func:`dir` は、組込みの関数や変数の名前はリストしません。これらの名前からなるリストが必要なら、標準モジュール
:mod:`__builtin__` で定義されています:
::
>>> import __builtin__
>>> dir(__builtin__)
['ArithmeticError', 'AssertionError', 'AttributeError', 'DeprecationWarning',
'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False',
'FloatingPointError', 'FutureWarning', 'IOError', 'ImportError',
'IndentationError', 'IndexError', 'KeyError', 'KeyboardInterrupt',
'LookupError', 'MemoryError', 'NameError', 'None', 'NotImplemented',
'NotImplementedError', 'OSError', 'OverflowError',
'PendingDeprecationWarning', 'ReferenceError', 'RuntimeError',
'RuntimeWarning', 'StandardError', 'StopIteration', 'SyntaxError',
'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'True',
'TypeError', 'UnboundLocalError', 'UnicodeDecodeError',
'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError',
'UserWarning', 'ValueError', 'Warning', 'WindowsError',
'ZeroDivisionError', '_', '__debug__', '__doc__', '__import__',
'__name__', 'abs', 'apply', 'basestring', 'bool', 'buffer',
'callable', 'chr', 'classmethod', 'cmp', 'coerce', 'compile',
'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod',
'enumerate', 'eval', 'execfile', 'exit', 'file', 'filter', 'float',
'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex',
'id', 'input', 'int', 'intern', 'isinstance', 'issubclass', 'iter',
'len', 'license', 'list', 'locals', 'long', 'map', 'max', 'min',
'object', 'oct', 'open', 'ord', 'pow', 'property', 'quit', 'range',
'raw_input', 'reduce', 'reload', 'repr', 'reversed', 'round', 'set',
'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super',
'tuple', 'type', 'unichr', 'unicode', 'vars', 'xrange', 'zip']
.. _tut-packages:
パッケージ
==========
パッケージ (package) は、Python のモジュール名前空間を "ドット付きモジュール名 (dotted module names)" を使って
構造化する手段です。例えば、モジュール名 :mod:`A.B` は、 ``A`` というパッケージのサブモジュール ``B`` を表します。
ちょうど、モジュールを利用すると、別々のモジュールの著者が互いのグローバル変数名について心配しなくても済むようになるのと同じように、
ドット付きモジュール名を利用すると、 NumPy や Python Imaging Library のように複数モジュールからなる
パッケージの著者が、互いのモジュール名について心配しなくても済むようになります。
音声ファイルや音声データを一様に扱うためのモジュールのコレクション ("パッケージ") を設計したいと仮定しましょう。音声ファイルには多くの異なった形式がある
(通常は拡張子、例えば :file:`.wav`, :file:`.aiff`, :file:`.au` などで認識されます) ので、
様々なファイル形式間で変換を行うためのモジュールからなる、次第に増えていくモジュールのコレクションを作成したりメンテナンス
したりする必要がありかもしれません。また、音声データに対して実行したい様々な独自の操作 (ミキシング、エコーの追加、
イコライザ関数の適用、人工的なステレオ効果の作成など) があるかもしれません。そうなると、こうした操作を実行するモジュールを果てしなく
書くことになるでしょう。以下に (階層的なファイルシステムで表現した) パッケージの構造案を示します:
::
sound/ トップレベルのパッケージ
__init__.py サウンドパッケージを初期化する
formats/ ファイルフォーマット変換用の下位パッケージ
__init__.py
wavread.py
wavwrite.py
aiffread.py
aiffwrite.py
auread.py
auwrite.py
...
effects/ サウンド効果用の下位パッケージ
__init__.py
echo.py
surround.py
reverse.py
...
filters/ フィルタ用の下位パッケージ
__init__.py
equalizer.py
vocoder.py
karaoke.py
...
パッケージを import する際、 Python は ``sys.path`` 上のディレクトリ
を検索して、トップレベルのパッケージの入ったサブディレクトリを探します。
あるディレクトリを、パッケージが入ったディレクトリとしてPython に扱わせるには、ファイル :file:`__init__.py` が必要です:
このファイルを置かなければならないのは、 ``string`` のようなよくある名前のディレクトリにより、モジュール検索パスの後の方で見つかる
正しいモジュールが意図せず隠蔽されてしまうのを防ぐためです。最も簡単なケースでは :file:`__init__.py` はただの空ファイルで
構いませんが、 :file:`__init__.py` ではパッケージのための初期化コードを実行したり、後述の ``__all__``
変数を設定してもかまいません。
パッケージのユーザは、個々のモジュールをパッケージから import することができます。例えば:
::
import sound.effects.echo
この操作はサブモジュール :mod:`sound.effects.echo` をロードします。
このモジュールは、以下のように完全な名前で参照しなければなりません:
::
sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)
サブモジュールを import するもう一つの方法を示します:
::
from sound.effects import echo
これもサブモジュール :mod:`echo` をロードし、 :mod:`echo` をパッケージ名を表す接頭辞なしで利用できるようにします。従って以下のように
用いることができます:
::
echo.echofilter(input, output, delay=0.7, atten=4)
さらにもう一つのバリエーションとして、必要な関数や変数を直接 import する方法があります:
::
from sound.effects.echo import echofilter
この操作も同様にサブモジュール :mod:`echo` をロードしますが、 :func:`echofilter` を直接利用できるようにします。
::
echofilter(input, output, delay=0.7, atten=4)
``from package import item`` を使う場合、 *item* はパッケージ *package* のサブモジュール
(またはサブパッケージ) でもかまいませんし、関数やクラス、変数のような、 *package* で定義されている別の名前でもかまわないことに注意してください。
``import`` 文はまず、 *item* がパッケージ内で定義されているかどうか調べます; 定義されていなければ、 *item* はモジュール
名であると仮定して、モジュールをロードしようと試みます。もしモジュールが見つからなければ、 :exc:`ImportError` が送出されます。
反対に、 ``import item.subitem.subsubitem`` のような構文を使った場合、最後の ``subsubitem``
を除く各要素はパッケージでなければなりません; 最後の要素はモジュールかパッケージにできますが、
一つ前の要素で定義されているクラスや関数や変数にはできません。
.. _tut-pkg-import-star:
パッケージから \* を import する
--------------------------------
.. index:: single: __all__
それでは、ユーザが ``from sound.effects import *`` と書いたら、どうなるのでしょうか？
理想的には、何らかの方法でファイルシステムが調べられ、そのパッケージにどんなサブモジュールがあるかを調べ上げ、全てを import
する、という処理を望むことでしょう。残念ながら、この操作は Windows のプラットフォームではうまく動作しません。
これらのプラットフォームでは、ファイルシステムはファイル名の大小文字の区別について正しい情報をもっているとは限らないからです！
こうしたプラットフォームでは、ファイル :file:`ECHO.PY` をモジュール :mod:`echo` として import
すべきか、 :mod:`Echo` とすべきかが分かる確かな方法がないからです (例えば、 Windows 95 は
すべてのファイル名の最初の文字を大文字にして表示するという困った慣習があります)。また、DOS の 8+3 のファイル名制限のせいで、
長いモジュール名に関して別の奇妙な問題が追加されています。
唯一の解決策は、パッケージの作者にパッケージの索引を明示的に提供させるというものです。 import 文は次の規約を使います: パッケージの
:file:`__init__.py` コードに ``__all__`` という名前のリストが定義されていれば、 ``from package import
*`` が現れたときに import するリストとして使います。新たなパッケージがリリースされるときに
リストを最新の状態に更新するのはパッケージの作者の責任となります。自分のパッケージから \* を import するという使い方に同意できなければ、
パッケージの作者は :file:`__init__.py` をサポートしないことにしてもかまいません。例えば、ファイル
``sounds/effects/__init__.py`` には、次のようなコードを入れてもよいかもしれません:
::
__all__ = ["echo", "surround", "reverse"]
このコードは、 ``from sound.effects import *`` とすると、 :mod:`sound` パッケージから指定された 3
つのサブモジュールが import されることになっている、ということを意味します。
もしも ``__all__`` が定義されていなければ、実行文 ``from sound.effects import *`` は、パッケージ
:mod:`sound.effects` の全てのサブモジュールを現在の名前空間の中へ import *しません* ; この文は単に
(場合によっては初期化コード :file:`__init__.py` を実行して) パッケージ :mod:`sound.effects` が import
されたということを確認し、そのパッケージで定義されている名前を全て import するだけです。 import
される名前には、 :file:`__init__.py` で定義された名前 (と、明示的にロードされたサブモジュール) が含まれます。
パッケージのサブモジュールで、以前の import 文で明示的にロードされたものも含みます。以下のコードを考えてください:
::
import sound.effects.echo
import sound.effects.surround
from sound.effects import *
上の例では、echo と surround モジュールが現在の名前空間に import されます。これらのモジュールは ``from...import`` 文が
実行された際に :mod:`sound.effects` 内で定義されているからです (この機構は ``__all__`` が定義されているときにも働きます)。
一般的には、モジュールやパッケージから ``*`` を import するというやり方には賛同できません。というのは、この操作を行うとしばしば可読性に
乏しいコードになるからです。しかし、対話セッションでキータイプの量を減らすために使うのは構わないでしょう。それに、特定のモジュールでは、
特定のパターンに従った名前のみを公開 (export) するように設計されています。
``from package import specific_submodule`` を使っても何も問題は
ないことに留意してください！実際この表記法は、import を行うモジュールが他のパッケージかと同じ名前を持つサブモジュールを使わなければ
ならない場合を除いて推奨される方式です。
パッケージ内での参照
--------------------
サブモジュール同士で互いに参照を行う必要がしばしば起こります。例えば、 :mod:`surround` モジュールは :mod:`echo` モジュールを
使うかもしれません。実際には、このような参照はよくあることなので、 :keyword:`import` 文を実行すると、まず最初に import 文の入っている
パッケージを検索し、その後になって標準のモジュール検索パスを見に行きます。こうして、 :mod:`surround` モジュールは単に ``import
echo `` や `` from echo import echofilter`` を使うことができます。 import されたモジュールが現在のパッケージ
(現在のモジュールをサブモジュールにしているパッケージ) 内に見つからなかった場合、 :keyword:`import`
文は指定した名前のトップレベルのモジュールを検索します。
パッケージが (前述の例の :mod:`sound` パッケージのように) サブパッケージの集まりに構造化されている場合、絶対 import を使って兄弟関係にある
パッケージを参照できます。例えば、モジュール
:mod:`sound.filters.vocoder` で :mod:`sound.effects` パッケージの :mod:`echo`
モジュールを使いたいとすると、 ``from sound.effects import echo`` を使うことはできます。
Python 2.5 からは、上で説明した暗黙の相対importに加えて、明示的な相対importを ``from module import name``
の形式のimport文で利用できます。この明示的な相対importでは、先頭のドットで現在および親パッケージを指定して相対importを行います。
:mod:`surround` モジュールの例では、以下のように記述できます:
::
from . import echo
from .. import formats
from ..filters import equalizer
明示的および暗黙的な相対importのどちらもカレントモジュールの名前をベースにすることに注意してください。メインモジュールの名前は常に
``"__main__"`` なので、Pythonアプリケーションのメインモジュールとし
て利用されることを意図しているモジュールでは絶対importを利用するべきです。
複数ディレクトリ中のパッケージ
------------------------------
パッケージのサポートする特殊な属性には、もう一つ :attr:`__path__` があります。この属性は、パッケージの
:file:`__init__.py` 中のコードが実行されるよりも前に、 :file:`__init__.py` の収められているディレクトリ名
の入ったリストになるよう初期化されます。この変数は変更することができます; 変更を加えると、以降そのパッケージに
入っているモジュールやサブパッケージの検索に影響します。
この機能はほとんど必要にはならないのですが、パッケージ内に見つかるモジュールのセットを拡張するために使うことができます。
.. rubric:: Footnotes
.. [#] 実際には、関数定義も '実行' される '文' です; モジュールを実行すると、関数名はモジュールのグローバルなシンボルテーブルに入力されます。
Python-2.6.2-DocJa-1/_sources/tutorial/interactive.txt 0000644 0001750 0001750 00000032601 11474251540 022266 0 ustar inada-n inada-n .. _tut-interacting:
**************************
対話入力編集とヒストリ置換
**************************
あるバージョンの Python インタプリタでは、Korn シェルや GNU Bash シェルに見られる機能に似た、現在の入力行に対する編集機能や
ヒストリ置換機能をサポートしています。この機能は *GNU Readline* ライブラリを使って実装されています。このライブラリは Emacs スタイルと
vi スタイルの編集をサポートしています。ライブラリには独自のドキュメントがあり、ここでそれを繰り返すつもりはありません;
とはいえ、基本について簡単に解説することにします。ここで述べる対話的な編集とヒストリについては、 Unix 版と Cygwin
版のインタプリタでオプションとして利用することができます。
.. % Interactive Input Editing and History Substitution
.. % % Some versions of the Python interpreter support editing of the current
.. % % input line and history substitution, similar to facilities found in
.. % % the Korn shell and the GNU Bash shell. This is implemented using the
.. % % \emph{GNU Readline} library, which supports Emacs-style and vi-style
.. % % editing. This library has its own documentation which I won't
.. % % duplicate here; however, the basics are easily explained. The
.. % % interactive editing and history described here are optionally
.. % % available in the \UNIX{} and Cygwin versions of the interpreter.
この章では、Mark Hammond の PythonWin パッケージや、 Python とともに配布される Tk ベースの環境である IDLE にある
編集機能については解説 *しません* 。 NT 上の DOS ボックスやその他の DOS および Windows 類で働く
コマンド行ヒストリ呼出しもまた別のものです。
.. % % This chapter does \emph{not} document the editing facilities of Mark
.. % % Hammond's PythonWin package or the Tk-based environment, IDLE,
.. % % distributed with Python. The command line history recall which
.. % % operates within DOS boxes on NT and some other DOS and Windows flavors
.. % % is yet another beast.
.. _tut-lineediting:
行編集
======
入力行の編集がサポートされている場合、インタプリタが一次または二次プロンプトを出力している際にはいつでも有効になっています。現在の行は、慣例的な Emacs
制御文字を使って編集することができます。そのうち最も重要なものとして、以下のようなキーがあります: :kbd:`C-A` (Control-A)
はカーソルを行の先頭へ移動させます。 :kbd:`C-E` は末尾へ移動させます。 :kbd:`C-B` は逆方向へ一つ移動させます。 :kbd:`C-F`
は順方向へ移動させます。 Backspace は逆方向に向かって文字を消します。 :kbd:`C-D` は順方向に向かって消します。 :kbd:`C-K`
は順方向に向かって行の残りを kill し (消し) ます、 :kbd:`C-Y` は最後に kill された文字列を再び yank し (取り出し) ます。
:kbd:`C-underscore` 最後の変更を元に戻します; これは、繰り返してどんどんさかのぼることができます。
.. % Line Editing
.. % % If supported, input line editing is active whenever the interpreter
.. % % prints a primary or secondary prompt. The current line can be edited
.. % % using the conventional Emacs control characters. The most important
.. % % of these are: \kbd{C-A} (Control-A) moves the cursor to the beginning
.. % % of the line, \kbd{C-E} to the end, \kbd{C-B} moves it one position to
.. % % the left, \kbd{C-F} to the right. Backspace erases the character to
.. % % the left of the cursor, \kbd{C-D} the character to its right.
.. % % \kbd{C-K} kills (erases) the rest of the line to the right of the
.. % % cursor, \kbd{C-Y} yanks back the last killed string.
.. % % \kbd{C-underscore} undoes the last change you made; it can be repeated
.. % % for cumulative effect.
.. _tut-history:
ヒストリ置換
============
ヒストリ置換は次のように働きます。入力された行のうち、空行でない実行された行はすべてヒストリバッファに保存されます。そして、プロンプト
が呈示されるときには、ヒストリバッファの最も下の新たな行に移動します。 :kbd:`C-P` はヒストリバッファの中を一行だけ上に移動し (戻し)
ます。 :kbd:`C-N` は 1 行だけ下に移動します。ヒストリバッファのどの行も編集することができます。行が編集されると、それを示すために
プロンプトの前にアスタリスクが表示されます [#]_。 :kbd:`Return` キーを押すと現在行がインタプリタへ渡されます。 :kbd:`C-R`
はインクリメンタルな逆方向サーチ (reverse search) を開始し、 :kbd:`C-S` は順方向サーチ (forward search)
を開始します。
.. % History Substitution
.. % % History substitution works as follows. All non-empty input lines
.. % % issued are saved in a history buffer, and when a new prompt is given
.. % % you are positioned on a new line at the bottom of this buffer.
.. % % \kbd{C-P} moves one line up (back) in the history buffer,
.. % % \kbd{C-N} moves one down. Any line in the history buffer can be
.. % % edited; an asterisk appears in front of the prompt to mark a line as
.. % % modified. Pressing the \kbd{Return} key passes the current line to
.. % % the interpreter. \kbd{C-R} starts an incremental reverse search;
.. % % \kbd{C-S} starts a forward search.
.. _tut-keybindings:
キー割り当て
============
Readline ライブラリのキー割り当て (key binding) やその他のパラメタは、 :file:`~/.inputrc` という初期化ファイル
[#]_にコマンドを置くことでカスタマイズできます。キー割り当ての形式は
.. % Key Bindings
.. % % The key bindings and some other parameters of the Readline library can
.. % % be customized by placing commands in an initialization file called
.. % % \file{\~{}/.inputrc}. Key bindings have the form
::
key-name: function-name
または
.. % % or
::
"string": function-name
で、オプションの設定方法は
.. % % and options can be set with
::
set option-name value
です。例えば、以下のように設定します:
.. % % For example:
::
# vi スタイルの編集を選択する:
set editing-mode vi
# 一行だけを使って編集する:
set horizontal-scroll-mode On
# いくつかのキーを再束縛する:
Meta-h: backward-kill-word
"\C-u": universal-argument
"\C-x\C-r": re-read-init-file
Python では、 :kbd:`Tab` に対するデフォルトの割り当ては TAB の挿入です。 Readline
のデフォルトであるファイル名補完関数ではないので注意してください。もし、どうしても Readline のデフォルトを割り当てたいのなら、
:file:`~/.inputrc` に
.. % % Note that the default binding for \kbd{Tab} in Python is to insert a
.. % % \kbd{Tab} character instead of Readline's default filename completion
.. % % function. If you insist, you can override this by putting
::
Tab: complete
を入れれば設定を上書きすることができます。 (もちろん、 :kbd:`Tab` を使って補完を行うのに慣れている場合、この設定を行うと
インデントされた継続行を入力しにくくなります。)
.. % % in your \file{\~{}/.inputrc}. (Of course, this makes it harder to
.. % % type indented continuation lines if you're accustomed to using
.. % % \kbd{Tab} for that purpose.)
.. index::
module: rlcompleter
module: readline
変数名とモジュール名の自動的な補完がオプションとして利用できます。補完をインタプリタの対話モードで有効にするには、
以下の設定をスタートアップファイルに追加します: [#]_
.. % % Automatic completion of variable and module names is optionally
.. % % available. To enable it in the interpreter's interactive mode, add
.. % % the following to your startup file:\footnote{
.. % % Python will execute the contents of a file identified by the
.. % % \envvar{PYTHONSTARTUP} environment variable when you start an
.. % % interactive interpreter.}
.. % % \refstmodindex{rlcompleter}\refbimodindex{readline}
::
import rlcompleter, readline
readline.parse_and_bind('tab: complete')
この設定は、 :kbd:`Tab` キーを補完関数に束縛します。従って、 :kbd:`Tab` キーを二回たたくと補完候補が示されます; 補完機能は Python
の文の名前、現在のローカル変数、および利用可能なモジュール名を検索します。 ``string.a`` のようなドットで区切られた式については、最後の
``'.'`` までの式を評価し、結果として得られたオブジェクトの属性から補完候補を示します。 :meth:`__getattr__`
メソッドを持ったオブジェクトが式に含まれている場合、 :meth:`__getattr__` がアプリケーション定義のコードを実行する
かもしれないので注意してください。
.. % % This binds the \kbd{Tab} key to the completion function, so hitting
.. % % the \kbd{Tab} key twice suggests completions; it looks at Python
.. % % statement names, the current local variables, and the available module
.. % % names. For dotted expressions such as \code{string.a}, it will
.. % % evaluate the expression up to the final \character{.} and then
.. % % suggest completions from the attributes of the resulting object. Note
.. % % that this may execute application-defined code if an object with a
.. % % \method{__getattr__()} method is part of the expression.
より良くできたスタートアップファイルは以下例のようになります。
この例では、作成した名前が不要になると削除されるのに注目してください。
これは、スタートアップファイルが対話コマンドと同じ名前空間で実行されているので、
不要な名前を除去して対話環境に副作用を生まないようにするためです。
import されたモジュールのうち、 :mod:`os` のようなインタプリタのほとんどのセッションで
必要なものについては、残しておくと便利に思うかもしれません。
.. % % A more capable startup file might look like this example. Note that
.. % % this deletes the names it creates once they are no longer needed; this
.. % % is done since the startup file is executed in the same namespace as
.. % % the interactive commands, and removing the names avoids creating side
.. % % effects in the interactive environments. You may find it convenient
.. % % to keep some of the imported modules, such as \module{os}, which turn
.. % % out to be needed in most sessions with the interpreter.
::
# Add auto-completion and a stored history file of commands to your Python
# interactive interpreter. Requires Python 2.0+, readline. Autocomplete is
# bound to the Esc key by default (you can change it - see readline docs).
#
# Store the file in ~/.pystartup, and set an environment variable to point
# to it, e.g. "export PYTHONSTARTUP=/home/user/.pystartup" in bash.
#
# Note that PYTHONSTARTUP does *not* expand "~", so you have to put in the
# full path to your home directory.
import atexit
import os
import readline
import rlcompleter
historyPath = os.path.expanduser("~/.pyhistory")
def save_history(historyPath=historyPath):
import readline
readline.write_history_file(historyPath)
if os.path.exists(historyPath):
readline.read_history_file(historyPath)
atexit.register(save_history)
del os, atexit, readline, rlcompleter, save_history, historyPath
.. _tut-commentary:
解説
====
この機能は、初期の版のインタプリタに比べれば大きな進歩です; とはいえ、まだいくつかの要望が残されています: 例えば、
行を継続するときに正しいインデントが呈示されたら快適でしょう (パーサは次の行でインデントトークンが必要かどうかを知っています)。
補完機構がインタプリタのシンボルテーブルを使ってもよいかもしれません。かっこやクォートなどの対応をチェックする (あるいは指示する) コマンドも
有用でしょう。
.. % Commentary
.. % % This facility is an enormous step forward compared to earlier versions
.. % % of the interpreter; however, some wishes are left: It would be nice if
.. % % the proper indentation were suggested on continuation lines (the
.. % % parser knows if an indent token is required next). The completion
.. % % mechanism might use the interpreter's symbol table. A command to
.. % % check (or even suggest) matching parentheses, quotes, etc., would also
.. % % be useful.
.. rubric:: Footnotes
.. [#] 訳注: これはデフォルト設定の Readline では現れません。 ``set mark-modified-lines on`` という行を
:file:`~/.inputrc` または環境変数 :envvar:`INPUTRC` が指定するファイルに置くことによって現れるようになります。
.. [#] 訳注: このファイル名は環境変数 :envvar:`INPUTRC` がもしあればその指定が優先されます。
.. [#] Python は、対話インタプリタを開始する時に :envvar:`PYTHONSTARTUP` 環境変数が指定するファイルの内容を実行します。
Python-2.6.2-DocJa-1/_sources/tutorial/interpreter.txt 0000644 0001750 0001750 00000044112 11477225570 022323 0 ustar inada-n inada-n .. _tut-using:
*************************
Python インタプリタを使う
*************************
.. _tut-invoking:
インタプリタを起動する
======================
Python が使える計算機なら、インタプリタは大抵 :file:`/usr/local/bin/python`
にインストールされています。Unix シェルの検索パスに :file:`/usr/local/bin`
を入れれば、シェルで
::
python
とコマンドを入力すれば使えるようになります。
インストールする際にどのディレクトリに Python インタプリタを入れるかを
オプションで指定できるので、インタプリタは他のディレクトリにあるかも
しれません; 身近な Python の導師 (guru) か、システム管理者に聞いてみてください。
(例えば、その他の場所としては :file:`/usr/local/python` が一般的です。)
Windows マシンの場合には、Pythonは大抵の場合 :file:`C:\\Python26`
にインストールされますが、インストーラ実行時に変更することができます。
このディレクトリをあなたのパスに追加するには、以下のコマンドをコマンドプロンプトで実行してください::
set path=%path%;C:\python26
ファイル終端文字 (Unixでは :kbd:`Control-D` 、DOS や Windows では :kbd:`Control-Z`) を一次プロンプト
(primary prompt) に入力すると、インタプリタが終了状態ゼロで終了します。もしこの操作がうまく働かないなら、コマンド: ``import
sys; sys.exit()`` と入力すればインタプリタを終了できます。
通常、インタプリタの行編集機能は、あまり洗練されたものではありません。
Unixシステムでは、インタプリタをインストールした誰かが GNU readline
ライブラリのサポートを有効にしていれば、洗練された対話的行編集やヒストリ機能が追加されます。
コマンドライン編集機能がサポートされているかを最も手っ取り早く調べる方法は、
おそらく最初に表示された Python プロンプトに Control-P を入力してみることでしょう。
ビープ音が鳴るなら、コマンドライン編集機能があります。編集キーについての解説は付録 :ref:`tut-interacting`
を参照してください。何も起こらないように見えるか、 ``^P`` がエコーバックされるなら、
コマンドライン編集機能は利用できません。
この場合、現在編集中の行から文字を削除するにはバックスペースを使うしかありません。
インタプリタはさながら Unix シェルのように働きます。
標準入力が端末に接続された状態で呼び出されると、コマンドを対話的に読み込んで実行します。
ファイル名を引数にしたり、標準入力からファイルを入力すると、インタプリタはファイルから
*スクリプト* を読み込んで実行します。
インタプリタを起動する第二の方法は ``python -c command [arg] ...`` です。
この形式では、シェルの :option:`-c` オプションと同じように、 *command*
に指定した文を実行します。
Python 文には、スペースなどのシェルにとって特殊な意味をもつ文字がしばしば
含まれるので、 *command* 全体を二重引用符を囲っておいたほうが良いでしょう。
Python のモジュールには、スクリプトとしても便利に使えるものがあります。
``python -m module [arg] ...`` のようにすると、 *module* のソースファイルを、
フルパスを指定して起動したかのように実行できます。
``python file`` と ``python >>``) です。一つの入力が次の行まで続く
(行継続: continuation line を行う) 場合、インタプリタは
*二次プロンプト (secondary prompt)* を表示します。二次プロンプトは、
デフォルトでは三つのドット (``...``) です。
インタプリタは、最初のプロンプトを出す前にバージョン番号と著作権表示から始まる起動メッセージを出力します。
::
python
Python 2.6 (#1, Feb 28 2007, 00:02:06)
Type "help", "copyright", "credits" or "license" for more information.
>>>
行継続は、例えば以下の :keyword:`if` 文のように、複数の行からなる構文を入力するときに必要です。
::
>>> the_world_is_flat = 1
>>> if the_world_is_flat:
... print "Be careful not to fall off!"
...
Be careful not to fall off!
.. _tut-interp:
インタプリタとその環境
======================
.. _tut-error:
エラー処理
----------
エラーが発生すると、インタプリタはエラーメッセージとスタックトレース
(stack trace) を出力します。対話モードにいるときは、インタプリタは
一次プロンプトに戻ります;
入力がファイルからきているときには、インタプリタはスタックトレースを出力した後、
非ゼロの終了状態で終了します。 (:keyword:`try` 文の :keyword:`except`
節で処理された例外は、ここでいうエラーにはあたりません。)
いくつかのエラーは無条件に致命的であり、非ゼロの終了状態となるプログラムの終了を引き起こします;
これにはインタプリタ内部の矛盾やある種のメモリ枯渇が当てはまります。
エラーメッセージは全て標準エラー出力ストリームに書き込まれます;
これに対して、実行した命令からの通常出力される内容は標準出力に書き込まれます。
割り込み文字 (interrupt character、普通は Control-C か DEL) を
一次または二次プロンプトに対して打鍵すると、入力が取り消されて一次プロンプトに戻ります。 [#]_
コマンドの実行中に割り込み文字を打鍵すると
:exc:`KeyboardInterrupt` 例外が送出されます。この例外は :keyword:`try` 文で処理できます。
.. _tut-scripts:
実行可能な Python スクリプト
----------------------------
BSD 風の Unix システムでは、Python スクリプトはシェルスクリプトのように
直接実行可能にできます。これを行うには、以下の行
::
#! /usr/bin/env python
(ここではインタプリタがユーザの :envvar:`PATH` 上にあると仮定しています)
をスクリプトの先頭に置き、スクリプトファイルに実行可能モードを与えます。
``#!`` はファイルの最初の２文字でなければなりません。
プラットフォームによっては、この最初の行を終端する改行文字が
Windows 形式 (``'\r\n'``) ではなく、 Unix形式(``'\n'``)でなければならないことがあります。
ハッシュまたはポンド文字、すなわち ``'#'`` は、Python ではコメントを書き始めるために
使われていることに注意してください。
:program:`chmod` コマンドを使えば、スクリプトに実行モード (または実行権限) を与えることができます。
::
$ chmod +x myscript.py
Windows では、"実行モード" のような概念はありません。
Python のインストーラーは自動的に ``.py`` ファイルを ``python.exe``
に関連付けるので、 Python ファイルをダブルクリックするとそれをスクリプトとして実行します。
``.pyw`` 拡張子も(訳注: ``pythonw.exe`` に)関連付けられ、通常コンソールウィンドウを
抑制して実行します。
ソースコードの文字コード方式 (encoding)
---------------------------------------
ASCII 形式でない文字コード化方式 (エンコーディング: encoding) を Python
ソースコードファイル中で使うことができます。
最良の方法は、 ``#!`` 行の直後に一行かそれ以上の特殊なコメントを挿入して、
ソースファイルのエンコードを指定するというものです。
::
# -*- coding: エンコーディング -*-
このように宣言しておくと、ソースファイル中の全ての文字は *エンコーディング*
という文字コードでエンコードされているものとして扱われ、Unicode 文字列
リテラルを指定したエンコードで直接記述できます。
実際に利用できるエンコードのリストは Python ライブラリリファレンスの
:mod:`codecs` の節にあります。
.. note::
訳注: *エンコーディング* の部分には、
実際には ``utf-8`` や ``cp932`` など、そのソースのエンコーディングを記述します。
プログラムから日本語を扱う場合には、必ずある程度の文字コードの知識が必要になります。
もし文字コードについてよく判らないのであれば、まずは英語だけ扱いながらチュートリアルを読み進めて、
並行して文字コードについても勉強してみましょう。
現在は、 Unicode の扱い易さの観点から、推奨される文字コードは ``utf-8`` です。
ただし、 ``utf-8`` でソースを書いた場合、 ``utf-8`` を表示できない Windows の
コマンドプロンプトは ``print "こんにちは"`` を実行すると文字化けを起こすでしょう。
その場合は、互換性のために古い ``cp932`` エンコーディングを使うか、
``print u"こんにちは"`` のように Unicode 文字列を使います。
例えばユーロ通貨記号を含む Unicode リテラルを書くには、 ISO-8859-15
エンコーディングを使えます。
ISO-8859-15 では、ユーロ通過記号の序数 (ordinal) は 164 です。
以下のスクリプトは 8364 という値 (Unicode でユーロ記号に対応するコードポイントの値)
を出力して終了します。
.. % For example, to write Unicode literals including the Euro currency
.. % symbol, the ISO-8859-15 encoding can be used, with the Euro symbol
.. % having the ordinal value 164. This script will print the value 8364
.. % (the Unicode codepoint corresponding to the Euro symbol) and then
.. % exit:
::
# -*- coding: iso-8859-15 -*-
currency = u"€"
print ord(currency)
利用しているエディタがファイルを UTF-8 バイト整列記号 (通称 BOM: Byte Order Mark) 付きの ``UTF-8``
で保存できる場合、エンコード宣言の代わりに使うことができます。 IDLE は ``Options/General/Default Source
Encoding/UTF-8`` が設定されている場合、 UTF-8 でエンコードされたファイルの識別機能をサポートします。ただし、 (2.2 以前の) 古い
Python リリースは UTF-8 シグネチャを理解しませんし、オペレーティングシステムは (Unix システムでしか使われていませんが) ``#!``
の行を含むスクリプトファイルを判別できなくなるので注意してください。
.. % % If your editor supports saving files as \code{UTF-8} with a UTF-8
.. % % \emph{byte order mark} (aka BOM), you can use that instead of an
.. % % encoding declaration. IDLE supports this capability if
.. % % \code{Options/General/Default Source Encoding/UTF-8} is set. Notice
.. % % that this signature is not understood in older Python releases (2.2
.. % % and earlier), and also not understood by the operating system for
.. % +script files with \code{\#!} lines (only used on \UNIX{} systems).
UTF-8 を (シグネチャやエンコード宣言を行って) 使うと、世界中のほとんどの
言語で使われている文字を文字列リテラルやコメントの中に同時に使うことができます。
識別子に対する非 ASCII 文字の使用はサポートされていません。
全ての文字を正しく表示できるようにするには、使っているエディタがファイルを
UTF-8 であると認識することができなければならず、かつファイル内で使われている
全ての文字をサポートするようなフォントを使わなければなりません。
.. % % By using UTF-8 (either through the signature or an encoding
.. % % declaration), characters of most languages in the world can be used
.. % % simultaneously in string literals and comments. Using non-\ASCII
.. % % characters in identifiers is not supported. To display all these
.. % % characters properly, your editor must recognize that the file is
.. % % UTF-8, and it must use a font that supports all the characters in the
.. % % file.
.. _tut-startup:
対話モード用の起動時実行ファイル
--------------------------------
Python を対話的に使うときには、インタプリタが起動する度に実行される何らかの標準的なコマンドがあると便利なことがよくあります。
これを行うには、 :envvar:`PYTHONSTARTUP` と呼ばれる環境変数を、インタプリタ起動時に実行されるコマンドが入ったファイル名に設定します。
この機能は Unix シェルの :file:`.profile` に似ています。
このファイルは対話セッションのときだけ読み出されます。Python がコマンドをスクリプトから読み出しているときや、 :file:`/dev/tty`
がコマンドの入力元として明示的に指定されている (この場合対話的セッションのように動作します) *わけではない* 場合にはこのファイルは読み出されません。
ファイル内のコマンドは、対話的コマンドが実行される名前空間と同じ名前空間内で実行されます。このため、ファイル内で定義されていたり import された
オブジェクトは、限定子をつけなくても対話セッション内で使うことができます。また、このファイル内で ``sys.ps1`` や ``sys.ps2``
を変更して、プロンプトを変更することもできます。
.. % % This file is only read in interactive sessions, not when Python reads
.. % % commands from a script, and not when \file{/dev/tty} is given as the
.. % % explicit source of commands (which otherwise behaves like an
.. % % interactive session). It is executed in the same namespace where
.. % % interactive commands are executed, so that objects that it defines or
.. % % imports can be used without qualification in the interactive session.
.. % % You can also change the prompts \code{sys.ps1} and \code{sys.ps2} in
.. % % this file.
もし現在のディレクトリから追加的なスタートアップファイルを読み出したいのなら、グローバルのスタートアップファイルの中で ``if
os.path.isfile('.pythonrc.py'): execfile('.pythonrc.py')``
のようなコードのプログラムを書くことができます。スクリプト中でスタートアップファイルを使いたいのなら、以下のようにして
スクリプト中で明示的に実行しなければなりません:
.. % % If you want to read an additional start-up file from the current
.. % % directory, you can program this in the global start-up file using code
.. % % like \samp{if os.path.isfile('.pythonrc.py'):
.. % % execfile('.pythonrc.py')}. If you want to use the startup file in a
.. % % script, you must do this explicitly in the script:
::
import os
filename = os.environ.get('PYTHONSTARTUP')
if filename and os.path.isfile(filename):
execfile(filename)
.. rubric:: 脚注
.. [#] GNU Readline パッケージに関する問題のせいで妨げられることがあります。
Python-2.6.2-DocJa-1/_sources/tutorial/stdlib2.txt 0000644 0001750 0001750 00000063214 11474251537 021326 0 ustar inada-n inada-n .. _tut-brieftourtwo:
**********************************
標準ライブラリミニツアー -- その 2
**********************************
もう一つのツアーでは、プロフェッショナルプログラミングを支えるもっと高度なモジュールをカバーします。ここで挙げるモジュールは、
小さなスクリプトの開発ではほとんど使いません。
.. % Brief Tour of the Standard Library -- Part II
.. _tut-output-formatting:
出力のフォーマット
==================
:mod:`repr` モジュールでは、
大きなコンテナや、深くネストしたコンテナを省略して表示するバージョンの :func:`repr` を提供しています:
.. % Output Formatting
.. % The \ulink{\module{repr}}{../lib/module-repr.html} module provides a
.. % version of \function{repr()} customized for abbreviated displays of large
.. % or deeply nested containers:
::
>>> import repr
>>> repr.repr(set('supercalifragilisticexpialidocious'))
"set(['a', 'c', 'd', 'e', 'f', 'g', ...])"
:mod:`pprint` モジュールを使うと、
組み込み型やユーザ定義型がより洗練された形式で出力されるよう制御できます。出力が複数行にわたる場合には、"pretty printer" が改行を追加して、
入れ子構造を理解しやすいようにインデントを挿入します:
.. % The \ulink{\module{pprint}}{../lib/module-pprint.html} module offers
.. % more sophisticated control over printing both built-in and user defined
.. % objects in a way that is readable by the interpreter. When the result
.. % is longer than one line, the ``pretty printer'' adds line breaks and
.. % indentation to more clearly reveal data structure:
::
>>> import pprint
>>> t = [[[['black', 'cyan'], 'white', ['green', 'red']], [['magenta',
... 'yellow'], 'blue']]]
...
>>> pprint.pprint(t, width=30)
[[[['black', 'cyan'],
'white',
['green', 'red']],
[['magenta', 'yellow'],
'blue']]]
:mod:`textwrap` モジュールは、
一段落の文を指定したスクリーン幅にぴったり収まるように調整します:
.. % The \ulink{\module{textwrap}}{../lib/module-textwrap.html} module
.. % formats paragraphs of text to fit a given screen width:
::
>>> import textwrap
>>> doc = """The wrap() method is just like fill() except that it returns
... a list of strings instead of one big string with newlines to separate
... the wrapped lines."""
...
>>> print textwrap.fill(doc, width=40)
The wrap() method is just like fill()
except that it returns a list of strings
instead of one big string with newlines
to separate the wrapped lines.
:mod:`locale` モジュールは、文化ごと
に特化したデータ表現形式のデータベースにアクセスします。 :mod:`locale` の :func:`format` 関数の grouping
属性を使えば、数値の各桁を適切な区切り文字でグループ化してフォーマットできます:
.. % The \ulink{\module{locale}}{../lib/module-locale.html} module accesses
.. % a database of culture specific data formats. The grouping attribute
.. % of locale's format function provides a direct way of formatting numbers
.. % with group separators:
::
>>> import locale
>>> locale.setlocale(locale.LC_ALL, 'English_United States.1252')
'English_United States.1252'
>>> conv = locale.localeconv() # get a mapping of conventions
>>> x = 1234567.8
>>> locale.format("%d", x, grouping=True)
'1,234,567'
>>> locale.format("%s%.*f", (conv['currency_symbol'],
... conv['frac_digits'], x), grouping=True)
'$1,234,567.80'
.. _tut-templating:
文字列テンプレート
==================
:mod:`string` モジュールには、
柔軟で、エンドユーザが簡単に編集できる簡単な構文を備えた :class:`Template`
クラスが入っています。このクラスを使うと、ユーザがアプリケーションの出力をカスタマイズしたいときに全てを置き換えなくてもすみます。
.. % Templating
.. % The \ulink{\module{string}}{../lib/module-string.html} module includes a
.. % versatile \class{Template} class with a simplified syntax suitable for
.. % editing by end-users. This allows users to customize their applications
.. % without having to alter the application.
テンプレートでは、 ``$`` と有効な Python 識別子名 (英数字とアンダースコア) からなるプレースホルダ名を使います。プレースホルダの
周りを丸括弧で囲えば、間にスペースをはさまなくても後ろに英数文字を続けられます。 ``$$`` のようにすると、 ``$`` 自体をエスケープできます:
.. % The format uses placeholder names formed by \samp{\$} with valid Python
.. % identifiers (alphanumeric characters and underscores). Surrounding the
.. % placeholder with braces allows it to be followed by more alphanumeric letters
.. % with no intervening spaces. Writing \samp{\$\$} creates a single escaped
.. % \samp{\$}:
::
>>> from string import Template
>>> t = Template('${village}folk send $$10 to $cause.')
>>> t.substitute(village='Nottingham', cause='the ditch fund')
'Nottinghamfolk send $10 to the ditch fund.'
:meth:`substitute` メソッドは、プレースホルダに相当する値が辞書やキーワード引数にない場合に :exc:`KeyError` を送出します。
メールマージ型アプリケーションの場合、ユーザが入力するデータは不完全なことがあるので、欠落したデータがあるとプレースホルダをそのままにして出力する
:meth:`safe_substitute` メソッドを使う方が適切でしょう:
.. % The \method{substitute} method raises a \exception{KeyError} when a
.. % placeholder is not supplied in a dictionary or a keyword argument. For
.. % mail-merge style applications, user supplied data may be incomplete and the
.. % \method{safe_substitute} method may be more appropriate --- it will leave
.. % placeholders unchanged if data is missing:
::
>>> t = Template('Return the $item to $owner.')
>>> d = dict(item='unladen swallow')
>>> t.substitute(d)
Traceback (most recent call last):
. . .
KeyError: 'owner'
>>> t.safe_substitute(d)
'Return the unladen swallow to $owner.'
:class:`Template` をサブクラス化すると、区切り文字を自作できます。例えば、
画像ブラウザ用にバッチで名前を変更するユーティリティを作っていたとして、現在の日付や画像のシーケンス番号、ファイル形式といったプレースホルダに
パーセント記号を選んだとします:
.. % Template subclasses can specify a custom delimiter. For example, a batch
.. % renaming utility for a photo browser may elect to use percent signs for
.. % placeholders such as the current date, image sequence number, or file format:
::
>>> import time, os.path
>>> photofiles = ['img_1074.jpg', 'img_1076.jpg', 'img_1077.jpg']
>>> class BatchRename(Template):
... delimiter = '%'
>>> fmt = raw_input('Enter rename style (%d-date %n-seqnum %f-format): ')
Enter rename style (%d-date %n-seqnum %f-format): Ashley_%n%f
>>> t = BatchRename(fmt)
>>> date = time.strftime('%d%b%y')
>>> for i, filename in enumerate(photofiles):
... base, ext = os.path.splitext(filename)
... newname = t.substitute(d=date, n=i, f=ext)
... print '{0} --> {1}'.format(filename, newname)
img_1074.jpg --> Ashley_0.jpg
img_1076.jpg --> Ashley_1.jpg
img_1077.jpg --> Ashley_2.jpg
テンプレートのもう一つの用途は、複数ある出力様式からのプログラムロジックの分離です。テンプレートを使えば、カスタムのテンプレートを XML ファイル
用や平文テキストのレポート、 HTML で書かれた web レポート用などに置き換えられます。
.. % Another application for templating is separating program logic from the
.. % details of multiple output formats. This makes it possible to substitute
.. % custom templates for XML files, plain text reports, and HMTL web reports.
.. _tut-binary-formats:
バイナリデータレコードの操作
============================
+The :mod:`struct` module provides :func:`pack` and :func:`unpack` functions for
+working with variable length binary record formats. The following example shows
+how to loop through header information in a ZIP file without using the
+:mod:`zipfile` module. Pack codes ``"H"`` and ``"I"`` represent two and four
+byte unsigned numbers respectively. The ``"<"`` indicates that they are
+standard size and in little-endian byte order
:mod:`struct` モジュールでは、
可変長のバイナリレコード形式を操作する :func:`pack` や :func:`unpack` といった関数を提供しています。
以下の例では、 :mod:`zipfile` モジュールを使わずに、ZIPファイルのヘッダ情報を巡回する方法を示しています
``"H"`` と ``"I"`` というパック符号は、それぞれ2バイトと4バイトの符号無し整数を表しています。
``"<"`` は、そのパック符号が通常のサイズであり、バイトオーダーがリトルエンディアンであることを示しています。
::
import struct
data = open('myfile.zip', 'rb').read()
start = 0
for i in range(3): # show the first 3 file headers
start += 14
fields = struct.unpack('>> import weakref, gc
>>> class A:
... def __init__(self, value):
... self.value = value
... def __repr__(self):
... return str(self.value)
...
>>> a = A(10) # create a reference
>>> d = weakref.WeakValueDictionary()
>>> d['primary'] = a # does not create a reference
>>> d['primary'] # fetch the object if it is still alive
10
>>> del a # remove the one reference
>>> gc.collect() # run garbage collection right away
0
>>> d['primary'] # entry was automatically removed
Traceback (most recent call last):
File "", line 1, in
d['primary'] # entry was automatically removed
File "C:/python26/lib/weakref.py", line 46, in __getitem__
o = self.data[key]()
KeyError: 'primary'
.. _tut-list-tools:
リスト操作のためのツール
========================
多くのデータ構造は、組み込みリスト型を使った実装で事足ります。とはいえ、時には組み込みリストとは違うパフォーマンス上のトレードオフを
持つような実装が必要になこともあります。
.. % Tools for Working with Lists
.. % Many data structure needs can be met with the built-in list type.
.. % However, sometimes there is a need for alternative implementations
.. % with different performance trade-offs.
:mod:`array` モジュールでは、
同じ形式のデータだけをコンパクトに保存できる、リスト型に似た :class:`array()` オブジェクトを提供しています。
以下の例では、通常要素あたり
16 バイトを必要とする Python 整数型のリストの代りに、 2 バイトの符号無しの 2 進数 (タイプコード ``"H"``)
を使っている数値配列を示します:
.. % The \ulink{\module{array}}{../lib/module-array.html} module provides an
.. % \class{array()} object that is like a list that stores only homogenous
.. % data and stores it more compactly. The following example shows an array
.. % of numbers stored as two byte unsigned binary numbers (typecode
.. % \code{"H"}) rather than the usual 16 bytes per entry for regular lists
.. % of python int objects:
::
>>> from array import array
>>> a = array('H', [4000, 10, 700, 22222])
>>> sum(a)
26932
>>> a[1:3]
array('H', [10, 700])
:mod:`collections` モジュールでは、
リスト型に似た :class:`deque()` オブジェクトを提供しています。 :class:`deque()`
オブジェクトでは、データの追加と左端からの取り出しが高速な半面、中間にある値の検索が低速になります。
こうしたオブジェクトはキューの実装や幅優先(breadth first)のツリー探索に向いています:
.. % The \ulink{\module{collections}}{../lib/module-collections.html} module
.. % provides a \class{deque()} object that is like a list with faster
.. % appends and pops from the left side but slower lookups in the middle.
.. % These objects are well suited for implementing queues and breadth first
.. % tree searches:
::
>>> from collections import deque
>>> d = deque(["task1", "task2", "task3"])
>>> d.append("task4")
>>> print "Handling", d.popleft()
Handling task1
unsearched = deque([starting_node])
def breadth_first_search(unsearched):
node = unsearched.popleft()
for m in gen_moves(node):
if is_goal(m):
return m
unsearched.append(m)
リストの代わりの実装以外にも、標準ライブラリにはソート済みのリストを操作するための関数を備えた :mod:`bisect`
のようなツールも提供しています:
.. % In addition to alternative list implementations, the library also offers
.. % other tools such as the \ulink{\module{bisect}}{../lib/module-bisect.html}
.. % module with functions for manipulating sorted lists:
::
>>> import bisect
>>> scores = [(100, 'perl'), (200, 'tcl'), (400, 'lua'), (500, 'python')]
>>> bisect.insort(scores, (300, 'ruby'))
>>> scores
[(100, 'perl'), (200, 'tcl'), (300, 'ruby'), (400, 'lua'), (500, 'python')]
:mod:`heapq` モジュールでは、
通常のリストでヒープを実装するための関数を提供しています。ヒープでは、最も低い値をもつエントリがつねにゼロの位置に配置
されます。ヒープは、毎回リストをソートすることなく、最小の値をもつ要素に繰り返しアクセスするようなアプリケーションで便利です:
.. % The \ulink{\module{heapq}}{../lib/module-heapq.html} module provides
.. % functions for implementing heaps based on regular lists. The lowest
.. % valued entry is always kept at position zero. This is useful for
.. % applications which repeatedly access the smallest element but do not
.. % want to run a full list sort:
::
>>> from heapq import heapify, heappop, heappush
>>> data = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
>>> heapify(data) # rearrange the list into heap order
>>> heappush(data, -5) # add a new entry
>>> [heappop(data) for i in range(3)] # fetch the three smallest entries
[-5, 0, 1]
.. _tut-decimal-fp:
10 進浮動小数演算
=================
:mod:`decimal` では、 10 進浮動小数の
算術演算をサポートする :class:`Decimal` データ型を提供しています。組み込みの 2 進浮動小数の実装である :class:`float`
に比べて、この新たなクラスがとりわけ便利なのは、厳密な 10 進表記や計算精度の制御、法的または
規制上の理由に基づく値丸めの制御、有効桁数の追跡が必要になる金融計算などのアプリケーションや、ユーザが手計算の結果と同じ演算結果を期待するような
アプリケーションの場合です。
.. % Decimal Floating Point Arithmetic
.. % The \ulink{\module{decimal}}{../lib/module-decimal.html} module offers a
.. % \class{Decimal} datatype for decimal floating point arithmetic. Compared to
.. % the built-in \class{float} implementation of binary floating point, the new
.. % class is especially helpful for financial applications and other uses which
.. % require exact decimal representation, control over precision, control over
.. % rounding to meet legal or regulatory requirements, tracking of significant
.. % decimal places, or for applications where the user expects the results to
.. % match calculations done by hand.
例えば、 70 セントの電話代にかかる 5% の税金を計算しようとすると、 10 進の浮動小数点値と 2 進の浮動小数点値では違う結果になってしまいます。
例えば以下のような例では、計算結果を四捨五入してセント単位にしようとすると違いがはっきり現れます:
.. % For example, calculating a 5\%{} tax on a 70 cent phone charge gives
.. % different results in decimal floating point and binary floating point.
.. % The difference becomes significant if the results are rounded to the
.. % nearest cent:
::
>>> from decimal import *
>>> Decimal('0.70') * Decimal('1.05')
Decimal("0.7350")
>>> .70 * 1.05
0.73499999999999999
:class:`Decimal` を使った計算では、末尾桁のゼロが保存されており、有効数字2桁の被乗数から自動的に有効数字を 4
桁と判断しています。 :class:`Decimal` は手計算と同じ方法で計算を行い、 2 進浮動小数点が 10 進小数成分を正確に
表現できないことによって起きる問題を回避しています。
.. % The \class{Decimal} result keeps a trailing zero, automatically inferring four
.. % place significance from multiplicands with two place significance. Decimal reproduces
.. % mathematics as done by hand and avoids issues that can arise when binary
.. % floating point cannot exactly represent decimal quantities.
:class:`Decimal` クラスは厳密な値を表現できるため、2 進浮動小数点数では期待通りに計算できないようなモジュロの計算や等値テストも実現
できます:
.. % Exact representation enables the \class{Decimal} class to perform
.. % modulo calculations and equality tests that are unsuitable for binary
.. % floating point:
::
>>> Decimal('1.00') % Decimal('.10')
Decimal("0.00")
>>> 1.00 % 0.10
0.09999999999999995
>>> sum([Decimal('0.1')]*10) == Decimal('1.0')
True
>>> sum([0.1]*10) == 1.0
False
:mod:`decimal` モジュールを使うと、必要なだけの精度で算術演算を行えます:
.. % The \module{decimal} module provides arithmetic with as much precision as
.. % needed:
::
>>> getcontext().prec = 36
>>> Decimal(1) / Decimal(7)
Decimal("0.142857142857142857142857142857142857")
Python-2.6.2-DocJa-1/_sources/tutorial/appetite.txt 0000644 0001750 0001750 00000026357 11477221463 021603 0 ustar inada-n inada-n .. _tut-intro:
****************
やる気を高めよう
****************
コンピュータを使って様々な作業をしていたら、自動化したい作業が出てくるでしょう。
たとえば、たくさんのテキストファイルで検索-置換操作を行いたい、大量の写真ファイルを
込み入ったやりかたでリネームまたは整理したいといったものです。
ひょっとすると、小さなカスタムデータベースや、何かに特化したGUIアプリケーション、シンプルなゲームを作りたいかもしれません。
.. % % Whetting Your Appetite
.. % % If you do much work on computers, eventually you find that there's
.. % % some task you'd like to automate. For example, you may wish to
.. % % perform a search-and-replace over a large number of text files, or
.. % % rename and rearrange a bunch of photo files in a complicated way.
.. % % Perhaps you'd like to write a small custom database, or a specialized
.. % % GUI application, or a simple game.
.. % % If you're a professional software developer, you may have to work with
.. % % several C/\Cpp/Java libraries but find the usual
.. % % write/compile/test/re-compile cycle is too slow. Perhaps you're
.. % % writing a test suite for such a library and find writing the testing
.. % % code a tedious task. Or maybe you've written a program that could use
.. % % an extension language, and you don't want to design and implement a
.. % % whole new language for your application.
もしあなたがプロのソフト開発者なら、C/C++/Java ライブラリを扱う必要があって、
通常の write/compile/test/re-compile サイクルが遅すぎると感じるかもしれません。
ひょっとするとそのようなライブラリのテストスイートを書いていて、
テスト用のコードを書くのにうんざりしているかもしれません。
拡張言語を使えるプログラムを書いていて、アプリケーションのために新しい
言語一式の設計と実装をしたくないと思っているかもしれません。
Pythonはそんなあなたのための言語です。
.. % % Python is just the language for you.
それらの作業の幾つかは、 Unix シェルスクリプトや Windows バッチファイルで
書くこともできますが、シェルスクリプトはファイル操作やテキストデータの操作には
向いているもののGUIアプリケーションやゲームにはむいていません。
C/C++/Java プログラムを書くこともできますが、最初の試し書きにすらかなりの
時間がかかってしまいます。Pythonは簡単に利用でき、Windows、 Mac OS X、
そして Unix オペレーティングシステムで動作し、あなたの作業を素早く行う助けになるでしょう。
.. % % You could write a {\UNIX} shell script or Windows batch files for some
.. % % +of these tasks, but shell scripts are best at moving around files and
.. % % +changing text data, not well-suited for GUI applications or games.
.. % % +You could write a C/{\Cpp}/Java program, but it can take a lot of
.. % % +development time to get even a first-draft program. Python is simpler
.. % % +to use, available on Windows, MacOS X, and {\UNIX} operating systems,
.. % % +and will help you get the job done more quickly.
.. % % Python is simple to use, but it is a real programming language,
.. % % offering much more structure and support for large programs than shell
.. % % scripts or batch files can offer. On the other hand, Python also
.. % % offers much more error checking than C, and, being a
.. % % \emph{very-high-level language}, it has high-level data types built
.. % % in, such as flexible arrays and dictionaries. Because of its more
.. % % general data types Python is applicable to a much larger problem
.. % % domain than Awk or even Perl, yet many things are at
.. % % least as easy in Python as in those languages.
Pyhonは簡単に利用できますが、本物のプログラミング言語であり、シェルスクリプトや
バッチファイルで提供されるよりもたくさんの、大規模プログラムむけの構造や支援を
提供しています。
一方、PythonはCよりたくさんのエラーチェックを提供しており、
*超高級言語(very-high-level language)* であり、可変長配列や辞書などのハイレベルな
型を組込みで持っています。
そのような型は一般的なため、PythonはAwkやPerlが扱うものより (多くの場合、
少なくともそれらの言語と同じくらい簡単に)大規模な問題に利用できます。
Python ではプログラムをモジュールに分割して他の Python プログラムで再利用できます。
Python には膨大な標準モジュールが付属していて、プログラムを作る上での基盤として、
あるいは Python プログラミングを学ぶために利用できます。
組み込みモジュールではまた、ファイル I/O 、システムコール、ソケットといった機能や、
Tk のようなグラフィカルユーザインタフェースツールキットを使うためのインタフェース
なども提供しています。
.. % % Python allows you to split your program in modules that can be
.. % % reused in other Python programs. It comes with a large collection of
.. % % standard modules that you can use as the basis of your programs --- or
.. % % as examples to start learning to program in Python. Some of these
.. % % modules provide things like file I/O, system calls,
.. % % sockets, and even interfaces to graphical user interface toolkits like Tk.
Python はインタプリタ言語です。このため、コンパイルやリンクが必要ないので、プログラムを開発する際にかなりの時間を節約できます。インタプリタ
は対話的な使い方もできます。インタプリタは対話的にも使えるので、言語の様々な機能について実験してみたり、やっつけ仕事のプログラムを書いたり、
ボトムアップでプログラムを開発する際に関数をテストしたりといったことが簡単にできます。便利な電卓にもなります。
.. % % Python is an interpreted language, which can save you considerable time
.. % % during program development because no compilation and linking is
.. % % necessary. The interpreter can be used interactively, which makes it
.. % % easy to experiment with features of the language, to write throw-away
.. % % programs, or to test functions during bottom-up program development.
.. % % It is also a handy desk calculator.
Python では、とてもコンパクトで読みやすいプログラムを書けます。Python で書かれたプログラムは大抵、同じ機能を提供する C 言語, C++ 言語や
Javaのプログラムよりもはるかに短くなります。これには以下のようないくつかの理由があります:
.. % % Python allows writing very compact and readable programs. Programs
.. % % written in Python are typically much shorter than equivalent C or
.. % % \Cpp{} programs, for several reasons:
.. % % \begin{itemize}
.. % % \item
.. % % the high-level data types allow you to express complex operations in a
.. % % single statement;
.. % % \item
.. % % statement grouping is done by indentation instead of beginning and ending
.. % % brackets;
.. % % \item
.. % % no variable or argument declarations are necessary.
.. % % \end{itemize}
* 高レベルのデータ型によって、複雑な操作を一つの実行文で表現できます。
* 実行文のグループ化を、グループの開始や終了の括弧ではなくインデントで行えます。
* 変数や引数の宣言が不要です。
Python は *拡張* できます: C 言語でプログラムを書く方法を知っているなら、新たな組み込み関数やモジュールを簡単にインタプリタに追加できま
す。これによって、処理速度を決定的に左右する操作を最大速度で動作するように実現したり、(ベンダ特有のグラフィクスライブラリのように) バイナリ
形式でしか手に入らないライブラリを Python にリンクしたりできます。その気になれば、Python インタプリタを C で書かれたアプリケーションにリンク
して、アプリケーションに対する拡張言語や命令言語としても使えます。
.. % % Python is \emph{extensible}: if you know how to program in C it is easy
.. % % to add a new built-in function or module to the interpreter, either to
.. % % perform critical operations at maximum speed, or to link Python
.. % % programs to libraries that may only be available in binary form (such
.. % % as a vendor-specific graphics library). Once you are really hooked,
.. % % you can link the Python interpreter into an application written in C
.. % % and use it as an extension or command language for that application.
ところで、この言語は BBC のショー番組、"モンティパイソンの空飛ぶサーカス (Monty Python's Flying Circus)"
から取ったもので、爬虫類とは関係ありません。このドキュメントにあるモンティパイソンの寸劇は、
参照してもかまわないというより、むしろ積極的に見るようおすすめします！
.. % % By the way, the language is named after the BBC show ``Monty Python's
.. % % Flying Circus'' and has nothing to do with nasty reptiles. Making
.. % % references to Monty Python skits in documentation is not only allowed,
.. % % it is encouraged!
.. % Where From Here
.. % % Now that you are all excited about Python, you'll want to examine it
.. % % in some more detail. Since the best way to learn a language is
.. % % to use it, the tutorial invites you to play with the Python interpreter
.. % % as you read.
さて、皆さんはもう Python にワクワクして、もうちょっと詳しく調べてみたくなったはずです。プログラミング言語を習得する最良の方法は使ってみるこ
とですから、このチュートリアルではみなさんが読んだ内容を Python インタプリタで試してみることをおすすめします。
次の章では、まずインタプリタを使うための機微を説明します。これはさして面白みのない情報なのですが、後に説明する例題を試してみる上で不可欠なことです。
.. % % In the next chapter, the mechanics of using the interpreter are
.. % % explained. This is rather mundane information, but essential for
.. % % trying out the examples shown later.
チュートリアルの残りの部分では、Python プログラム言語と実行システムの様々な機能を例題を交えて紹介します。単純な式、実行文、データ型から始め
て、関数とモジュールを経て、最後には例外処理やユーザ定義クラスといったやや高度な概念にも触れます。
.. % % The rest of the tutorial introduces various features of the Python
.. % % language and system through examples, beginning with simple
.. % % expressions, statements and data types, through functions and modules,
.. % % and finally touching upon advanced concepts like exceptions
.. % % and user-defined classes.
Python-2.6.2-DocJa-1/_sources/tutorial/jptranslation.txt 0000644 0001750 0001750 00000002656 11474251537 022656 0 ustar inada-n inada-n 日本語訳について
========================
この文書は、Pythonドキュメント翻訳プロジェクトによる Python Tutorial の日本語訳版です。日本語訳に対する質問や提案などが
ありましたら、Pythonドキュメント翻訳プロジェクトのメーリングリスト
``_
または、プロジェクトのバグ管理ページ
``_
までご報告ください。
翻訳者一覧 (敬称略)
-------------------
* 1.3 和訳: SUZUKI Hisao (August 27, 1995)
* 1.4 和訳: SUZUKI Hisao (April 20, 1997)
* 1.5.1 和訳: SUZUKI Hisao (August 23, 1998)
* 2.1 和訳: SUZUKI Hisao (June 10, 2001)
* 2.2.3 差分和訳: sakito (August 10, 2003)
* 2.2.3 敬体訳: ymasuda (September 5, 2003)
* 2.3 差分和訳: sakito (August 30, 2003)
* 2.3 敬体訳: ymasuda (November 30, 2003)
* 2.3.3 差分訳: ymasuda (Devember 25, 2003)
* 2.4 差分訳: ymasuda , G. Yoshida (etale) (March 20, 2006)
* 2.4 差分訳: moriwaka (September 11, 2007)
* 2.5 差分訳: moriwaka (September 12, 2007)
* 2.6 差分訳: cocoatomo, INADA Naoki
Python-2.6.2-DocJa-1/_sources/tutorial/introduction.txt 0000644 0001750 0001750 00000105473 11477315373 022512 0 ustar inada-n inada-n .. _tut-informal:
**************************
形式ばらない Python の紹介
**************************
以下の例では、入力と出力は (``>>>`` や ``...``) といったプロンプトがあるかないかで区別します: 例どおりに実行するなら、
プロンプトが表示されているときに、例中のプロンプトよりも後ろの内容全てをタイプ入力しなければなりません; プロンプトが先頭にない行はインタプリタ
からの出力です。
例中には二次プロンプトだけが表示されている行がありますが、これは空行を入力しなければならないことを意味するので注意してください;
空行の入力は複数の行からなる命令の終わりをインタプリタに教えるために使われます。
このマニュアルにある例の多くは、対話プロンプトで入力されるものでもコメントを含んでいます。
Python におけるコメント文はハッシュ文字 ``#`` で始まり、物理行の終わりまで続きます。
コメントは行の先頭にも、空白やコードの後にも書くことができますが、文字列リテラル
の内部に置くことはできません。文字列リテラル中のハッシュ文字はただのハッシュ文字です。
コメントはコードを明快にするためのものであり、Pythonはコメントを解釈しません。
なので、コードサンプルを実際に入力して試して見るときは、コメントをを省いても大丈夫です。
例::
# これは１番目のコメント
SPAM = 1 # そしてこれは２番目のコメント
# ... そしてこれは３番目!
STRING = "# これはコメントではありません。"
.. _tut-calculator:
Python を電卓として使う
=======================
それでは、簡単な Python コマンドをいくつか試しましょう。
インタプリタを起動して、一次プロンプト、 ``>>>`` が現れるのを待ちます。
(そう長くはかからないはずです)
.. _tut-numbers:
数
--
インタプリタは単純な電卓のように動作します: 式を入力することができ、
その結果が表示されます。
式の文法は素直なものです: 演算子 ``+``, ``-``, ``*``, ``/`` は
(Pascal や C といった) 他のほとんどの言語と同じように動作します。
括弧をグループ化に使うこともできます。例えば、
.. % Numbers
.. % % The interpreter acts as a simple calculator: you can type an
.. % % expression at it and it will write the value. Expression syntax is
.. % % straightforward: the operators \code{+}, \code{-}, \code{*} and
.. % % \code{/} work just like in most other languages (for example, Pascal
.. % % or C); parentheses can be used for grouping. For example:
::
>>> 2+2
4
>>> # これはコメント
... 2+2
4
>>> 2+2 # そしてこれはコードと同じ行にあるコメント
4
>>> (50-5*6)/4
5
>>> # 整数の除算は floor (実数の解を越えない最大の整数) を返す:
... 7/3
2
>>> 7/-3
-3
等号 (``'='``) は変数に値を代入するときに使います。
代入を行っても、その結果が次のプロンプトの前に出力されたりはしません。
::
>>> width = 20
>>> height = 5*9
>>> width * height
900
複数の変数に同時に値を代入することができます。
::
>>> x = y = z = 0 # x と y と z をゼロにする
>>> x
0
>>> y
0
>>> z
0
変数は、利用する前に(値を代入することによって) "定義" しなければなりません。
定義していない変数を利用しようとするとエラーが発生します。
::
>>> # try to access an undefined variable
... n
Traceback (most recent call last):
File "", line 1, in
NameError: name 'n' is not defined
浮動小数点を完全にサポートしています;
被演算子の型が混合されているときには、演算子は整数の被演算子を浮動小数点型に変換します。
::
>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.5
複素数もサポートされています。虚数は接尾辞 ``j`` または ``J`` を付けて書き表します。
ゼロでない実数部をもつ複素数は ``(実数部+虚数部j)`` のように書き表すか、
``complex(実数部, 虚数部)`` 関数で生成できます。
::
>>> 1j * 1J
(-1+0j)
>>> 1j * complex(0,1)
(-1+0j)
>>> 3+1j*3
(3+3j)
>>> (3+1j)*3
(9+3j)
>>> (1+2j)/(1+1j)
(1.5+0.5j)
複素数は、常に実数部と虚数部に相当する二つの浮動小数点数で表されます。
複素数 *z* からそれぞれの部分を取り出すには、 ``z.real`` と ``z.imag`` を使います。
::
>>> a=1.5+0.5j
>>> a.real
1.5
>>> a.imag
0.5
数値を浮動小数点数や整数へに変換する関数 (:func:`float`, :func:`int`, :func:`long`) は複素数に対しては動作しません
--- 複素数を実数に変換する方法には、ただ一つの正解というものがないからです。
絶対値 (magnitude) を (浮動小数点数として) 得るには
``abs(z)`` を使い、実部を得るには ``z.real`` を使ってください。
::
>>> a=3.0+4.0j
>>> float(a)
Traceback (most recent call last):
File "", line 1, in ?
TypeError: can't convert complex to float; use abs(z)
>>> a.real
3.0
>>> a.imag
4.0
>>> abs(a) # sqrt(a.real **2 + a.imag** 2)
5.0
>>>
対話モードでは、最後に表示された結果は変数 ``_`` に代入されます。
このことを利用すると、 Python を電卓として使うときに、計算を連続して行う作業が多少楽になります。
以下に例を示します。
::
>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06
>>>
ユーザはこの変数を読取り専用の値として扱うべきです。
この変数に明示的な代入を行ってはいけません --- そんなことをすれば、
同じ名前で、元の組み込み変数の特別な動作を覆い隠してしまうような、
別個のローカルな変数が生成されてしまいます。
.. _tut-strings:
文字列
------
数のほかに、Python は文字列も操作できます。文字列はいくつもの方法で表現できます。
文字列はシングルまたはダブルのクォートで囲みます。
::
>>> 'spam eggs'
'spam eggs'
>>> 'doesn\'t'
"doesn't"
>>> "doesn't"
"doesn't"
>>> '"Yes," he said.'
'"Yes," he said.'
>>> "\"Yes,\" he said."
'"Yes," he said.'
>>> '"Isn\'t," she said.'
'"Isn\'t," she said.'
文字列リテラルはいくつかの方法で複数行にまたがって記述できます。
継続行を使うことができ、これには行の末尾の文字をバックスラッシュにします。
こうすることで、次の行が現在の行と論理的に継続していることを示します。
.. % % String literals can span multiple lines in several ways. Continuation
.. % % lines can be used, with a backslash as the last character on the line
.. % % indicating that the next line is a logical continuation of the line:
::
hello = "This is a rather long string containing\n\
several lines of text just as you would do in C.\n\
Note that whitespace at the beginning of the line is\
significant."
print hello
``\n`` を使って文字列に改行位置を埋め込まなくてはならないことに注意してください;
末尾のバックスラッシュの後ろにある改行文字は無視されます。
従って、上の例は以下のような出力を行います。
::
This is a rather long string containing
several lines of text just as you would do in C.
Note that whitespace at the beginning of the line is significant.
また、対になった三重クォート ``"""`` または ``'''`` で文字列を囲むこともできます。
三重クォートを使っているときには、行末をエスケープする必要はありません。
しかし、行末の改行文字も文字列に含まれることになります。
::
print """
Usage: thingy [OPTIONS]
-h Display this usage message
-H hostname Hostname to connect to
"""
は以下のような出力を行います。
::
Usage: thingy [OPTIONS]
-h Display this usage message
-H hostname Hostname to connect to
文字列リテラルを "raw" 文字列にすると、 ``\n`` のようなエスケープシーケンスは
改行に変換されません。
逆に、行末のバックスラッシュやソースコード中の改行文字が文字列データに含められます。
つまり、以下の例:
::
hello = r"This is a rather long string containing\n\
several lines of text much as you would do in C."
print hello
は、以下のような出力を行います。
::
This is a rather long string containing\n\
several lines of text much as you would do in C.
インタプリタは、文字列演算の結果を、タイプして入力する時と同じ方法で出力します:
文字列はクオート文字で囲い、クオート文字自体やその他の特別な文字は、
正しい文字が表示されるようにするためにバックスラッシュでエスケープします。
文字列がシングルクオートを含み、かつダブルクオートを含まない場合には、全体をダブルクオートで囲います。
そうでない場合にはシングルクオートで囲みます。
(後で述べる :keyword:`print` を使って、クオートやエスケープのない文字列を表示することができます。)
文字列は ``+`` 演算子で連結させる (くっつけて一つにする) ことができ、
``*`` 演算子で反復させることができます。
::
>>> word = 'Help' + 'A'
>>> word
'HelpA'
>>> '<' + word*5 + '>'
''
互いに隣あった二つの文字列リテラルは自動的に連結されます:
例えば、上記の最初の行は ``word = 'Help' 'A'`` と書くこともできました;
この機能は二つともリテラルの場合にのみ働くもので、任意の文字列表現で使うことができるわけではありません。
.. % % Two string literals next to each other are automatically concatenated;
.. % % the first line above could also have been written \samp{word = 'Help'
.. % % 'A'}; this only works with two literals, not with arbitrary string
.. % % expressions:
::
>>> 'str' 'ing' # <- これは ok
'string'
>>> 'str'.strip() + 'ing' # <- これは ok
'string'
>>> 'str'.strip() 'ing' # <- これはダメ
File "", line 1, in ?
'str'.strip() 'ing'
^
SyntaxError: invalid syntax
文字列は添字表記 (インデクス表記) することができます;
C 言語と同じく、文字列の最初の文字の添字 (インデクス) は 0 となります。
独立した文字型というものはありません; 単一の文字は、単にサイズが 1 の文字列です。
Icon 言語と同じく、部分文字列を *スライス表記*:
コロンで区切られた二つのインデクスで指定することができます。
.. % % Strings can be subscripted (indexed); like in C, the first character
.. % % of a string has subscript (index) 0. There is no separate character
.. % % type; a character is simply a string of size one. Like in Icon,
.. % % substrings can be specified with the \emph{slice notation}: two indices
.. % % separated by a colon.
::
>>> word[4]
'A'
>>> word[0:2]
'He'
>>> word[2:4]
'lp'
スライスのインデクスには便利なデフォルト値があります; 最初のインデクスを省略すると、0 と見なされます。
第 2 のインデクスを省略すると、スライスしようとする文字列のサイズとみなされます。
.. % % Slice indices have useful defaults; an omitted first index defaults to
.. % % zero, an omitted second index defaults to the size of the string being
.. % % sliced.
::
>>> word[:2] # 最初の 2 文字
'He'
>>> word[2:] # 最初の 2 文字を除くすべて
'lpA'
C 言語の文字列と違い、Python の文字列は変更できません。
インデックス指定された文字列中のある位置に代入を行おうとするとエラーになります:
.. % % Unlike a C string, Python strings cannot be changed. Assigning to an
.. % % indexed position in the string results in an error:
::
>>> word[0] = 'x'
Traceback (most recent call last):
File "", line 1, in ?
TypeError: object doesn't support item assignment
>>> word[:1] = 'Splat'
Traceback (most recent call last):
File "", line 1, in ?
TypeError: object doesn't support slice assignment
一方、文字列同士の内容を組み合わせた新しい文字列の生成は、簡単で効率的です。
.. % % However, creating a new string with the combined content is easy and
.. % % efficient:
::
>>> 'x' + word[1:]
'xelpA'
>>> 'Splat' + word[4]
'SplatA'
スライス演算には便利な不変式があります: ``s[:i] + s[i:]`` は ``s`` に等しくなります。
.. % % Here's a useful invariant of slice operations:
.. % % \code{s[:i] + s[i:]} equals \code{s}.
::
>>> word[:2] + word[2:]
'HelpA'
>>> word[:3] + word[3:]
'HelpA'
スライス表記に行儀の悪いインデクス指定をしても、値はたしなみよく処理されます:
インデクスが大きすぎる場合は文字列のサイズと置き換えられます。
スライスの下境界 (文字列の左端) よりも小さいインデクス値を上境界 (文字列の右端) に指定すると、空文字列が返されます。
.. % % Degenerate slice indices are handled gracefully: an index that is too
.. % % large is replaced by the string size, an upper bound smaller than the
.. % % lower bound returns an empty string.
::
>>> word[1:100]
'elpA'
>>> word[10:]
''
>>> word[2:1]
''
インデクスを負の数にして、右から数えることもできます。例えば:
.. % % Indices may be negative numbers, to start counting from the right.
.. % % For example:
::
>>> word[-1] # 末尾の文字
'A'
>>> word[-2] # 末尾から 2 つめの文字
'p'
>>> word[-2:] # 末尾の 2 文字
'pA'
>>> word[:-2] # 末尾の 2 文字を除くすべて
'Hel'
-0 は 0 と全く同じなので、右から数えることができません。注意してください!
.. % % But note that -0 is really the same as 0, so it does not count from
.. % % the right!
::
>>> word[-0] # (-0 は 0 に等しい)
'H'
負で、かつ範囲外のインデクスをスライス表記で行うと、インデクスは切り詰められます。
しかし、単一の要素を指定する (スライスでない) インデクス指定でこれを行ってはいけません:
.. % % Out-of-range negative slice indices are truncated, but don't try this
.. % % for single-element (non-slice) indices:
::
>>> word[-100:]
'HelpA'
>>> word[-10] # エラー
Traceback (most recent call last):
File "", line 1, in ?
IndexError: string index out of range
スライスの働きかたをおぼえる良い方法は、インデクスが文字と文字の *あいだ (between)* を指しており、最初の文字の左端が 0
になっていると考えることです。そうすると、 *n* 文字からなる文字列中の最後の文字の右端はインデクス *n* となります。例えば:
.. % % The best way to remember how slices work is to think of the indices as
.. % % pointing \emph{between} characters, with the left edge of the first
.. % % character numbered 0. Then the right edge of the last character of a
.. % % string of \var{n} characters has index \var{n}, for example:
::
+---+---+---+---+---+
| H | e | l | p | A |
+---+---+---+---+---+
0 1 2 3 4 5
-5 -4 -3 -2 -1
といった具合です。
数が記された行のうち、最初の方の行は、文字列中のインデクス 0...5 の位置を表します; 次の行は、対応する負のインデクスを表しています。 *i* から
*j* までのスライスは、それぞれ *i*, *j* とラベル付けされたけられた端点間のすべての文字からなります。
.. % % The first row of numbers gives the position of the indices 0...5 in
.. % % the string; the second row gives the corresponding negative indices.
.. % % The slice from \var{i} to \var{j} consists of all characters between
.. % % the edges labeled \var{i} and \var{j}, respectively.
非負のインデクス対の場合、スライスされたシーケンスの長さは、スライスの両端のインデクスが境界内にあるかぎり、インデクス間の差になります。例えば、
``word[1:3]`` の長さは 2 になります。
.. % % For non-negative indices, the length of a slice is the difference of
.. % % the indices, if both are within bounds. For example, the length of
.. % % \code{word[1:3]} is 2.
組込み関数 :func:`len` は文字列の長さ (length) を返します。
.. % % The built-in function \function{len()} returns the length of a string:
::
>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34
.. seealso::
:ref:`typesseq`
次節で記述されている文字列および Unicode 文字列は *シーケンス型* の例であり、
シーケンス型でサポートされている共通の操作をサポートしています。
:ref:`string-methods`
(バイト)文字列や Unicode 文字列では、基本的な変換や検索を行うための
数多くのメソッドをサポートしています。
:ref:`new-string-formatting`
:meth:`str.format` を使った文字列のフォーマットについて、ここで解説されています。
:ref:`string-formatting`
(バイト)文字列や Unicode 文字列が ``%`` 演算子の左オペランドである場合に
呼び出される(古い)フォーマット操作については、ここで詳しく記述されています。
.. _tut-unicodestrings:
Unicode 文字列
--------------
.. sectionauthor:: Marc-Andre Lemburg
.. % Unicode Strings
Python 2.0 から、プログラマはテキスト・データを格納するための新しいデータ型、
Unicode オブジェクトを利用できるようになりました。
Unicode オブジェクトを使うと、Unicode データ (http://www.unicode.org/ 参照)
を記憶したり、操作したりできます。
また、 Unicode オブジェクトは既存の文字列オブジェクトとよく統合していて、
必要に応じた自動変換機能を提供しています。
.. % % Starting with Python 2.0 a new data type for storing text data is
.. % % available to the programmer: the Unicode object. It can be used to
.. % % store and manipulate Unicode data (see \url{http://www.unicode.org/})
.. % % and integrates well with the existing string objects providing
.. % % auto-conversions where necessary.
Unicode には、古今のテキストで使われているあらゆる書き文字のあらゆる文字について、対応付けを行うための一つの序数を規定しているという利点があります。
これまでは、書き文字のために利用可能な序数は 256 個しかなく、テキストは書き文字の対応付けを行っているコードページに束縛されているのが通常でした。
このことは、とりわけソフトウェアの国際化 (通常 ``i18n`` --- ``'i'`` + 18 文字 + ``'n'`` の意) に対して大きな
混乱をもたらしました。Unicode では、すべての書き文字に対して単一のコードページを定義することで、これらの問題を解決しています。
.. % % Unicode has the advantage of providing one ordinal for every character
.. % % in every script used in modern and ancient texts. Previously, there
.. % % were only 256 possible ordinals for script characters and texts were
.. % % typically bound to a code page which mapped the ordinals to script
.. % % characters. This lead to very much confusion especially with respect
.. % % to internationalization (usually written as \samp{i18n} ---
.. % % \character{i} + 18 characters + \character{n}) of software. Unicode
.. % % solves these problems by defining one code page for all scripts.
Python では、Unicode 文字列の作成は通常の文字列を作成するのと同じように単純なものです:
.. % % Creating Unicode strings in Python is just as simple as creating
.. % % normal strings:
::
>>> u'Hello World !'
u'Hello World !'
クオートの前にある小文字の ``'u'`` は、Unicode 文字列を生成することになっていることを示します。文字列に特殊な文字を
含めたければ、Python の *Unicode-Escape* エンコーディングを使って行えます。以下はその方法を示しています:
.. % % The small \character{u} in front of the quote indicates that an
.. % % Unicode string is supposed to be created. If you want to include
.. % % special characters in the string, you can do so by using the Python
.. % % \emph{Unicode-Escape} encoding. The following example shows how:
::
>>> u'Hello\u0020World !'
u'Hello World !'
エスケープシーケンス ``\u0020`` は、序数の値 0x0020 を持つ Unicode 文字 (スペース文字) を、指定場所に挿入することを示します。
.. % % The escape sequence \code{\e u0020} indicates to insert the Unicode
.. % % character with the ordinal value 0x0020 (the space character) at the
.. % % given position.
他の文字は、それぞれの序数値をそのまま Unicode の序数値に用いて解釈されます。多くの西洋諸国で使われている標準 Latin-1 エンコーディング
のリテラル文字列があれば、Unicode の下位 256 文字が Latin-1 の 256 文字と同じになっていて便利だと思うことでしょう。
.. % % Other characters are interpreted by using their respective ordinal
.. % % values directly as Unicode ordinals. If you have literal strings
.. % % in the standard Latin-1 encoding that is used in many Western countries,
.. % % you will find it convenient that the lower 256 characters
.. % % of Unicode are the same as the 256 characters of Latin-1.
上級者のために、通常の文字列の場合と同じく raw モードもあります。
これには、文字列を開始するクオート文字の前に 'ur' を付けて、 Python に
*Raw-Unicode-Escape* エンコーディングを使わせなければなりません。
このモードでは、上記の ``\uXXXX`` の変換は、小文字の
'u' の前に奇数個のバックスラッシュがあるときにだけ適用されます。
.. % % For experts, there is also a raw mode just like the one for normal
.. % % strings. You have to prefix the opening quote with 'ur' to have
.. % % Python use the \emph{Raw-Unicode-Escape} encoding. It will only apply
.. % % the above \code{\e uXXXX} conversion if there is an uneven number of
.. % % backslashes in front of the small 'u'.
::
>>> ur'Hello\u0020World !'
u'Hello World !'
>>> ur'Hello\\u0020World !'
u'Hello\\\\u0020World !'
raw モードは、正規表現を記述する時のように、沢山のバックスラッシュを入力しなければならないときとても役に立ちます。
.. % % The raw mode is most useful when you have to enter lots of
.. % % backslashes, as can be necessary in regular expressions.
これら標準のエンコーディングにとは別に、Python では、既知の文字エンコーディングに基づいて Unicode 文字列を生成する一連の
手段を提供しています。
.. % % Apart from these standard encodings, Python provides a whole set of
.. % % other ways of creating Unicode strings on the basis of a known
.. % % encoding.
.. index:: builtin: unicode
組込み関数 :func:`unicode` は、登録されているすべての Unicode codecs (COder: エンコーダと DECoder
デコーダ) へのアクセス機能を提供します。codecs が変換できるエンコーディングには、よく知られているものとして *Latin-1*, *ASCII*,
*UTF-8* および *UTF-16* があります。後者の二つは可変長のエンコードで、各 Unicode 文字を 1
バイトまたはそれ以上のバイト列に保存します。デフォルトのエンコーディングは通常 ASCIIに設定されています。ASCIIでは 0 から 127 の範囲の
文字だけを通過させ、それ以外の文字は受理せずエラーを出します。 Unicode 文字列を印字したり、ファイルに書き出したり、 :func:`str`
で変換すると、デフォルトのエンコーディングを使った変換が行われます。
.. % % The built-in function \function{unicode()}\bifuncindex{unicode} provides
.. % % access to all registered Unicode codecs (COders and DECoders). Some of
.. % % the more well known encodings which these codecs can convert are
.. % % \emph{Latin-1}, \emph{ASCII}, \emph{UTF-8}, and \emph{UTF-16}.
.. % % The latter two are variable-length encodings that store each Unicode
.. % % character in one or more bytes. The default encoding is
.. % % normally set to \ASCII, which passes through characters in the range
.. % % 0 to 127 and rejects any other characters with an error.
.. % % When a Unicode string is printed, written to a file, or converted
.. % % with \function{str()}, conversion takes place using this default encoding.
::
>>> u"abc"
u'abc'
>>> u"あいう"
u'\x82\xa0\x82\xa2\x82\xa4'
>>> str(u"あいう")
Traceback (most recent call last):
File "", line 1, in ?
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-5:
ordinal not in range(128)
特定のエンコーディングを使って Unicode 文字列を 8 ビットの文字列に変換するために、Unicode オブジェクトでは :func:`encode`
メソッドを提供しています。このメソッドは単一の引数としてエンコーディングの名前をとります。エンコーディング名には小文字の使用が推奨されています。
.. % % To convert a Unicode string into an 8-bit string using a specific
.. % % encoding, Unicode objects provide an \function{encode()} method
.. % % that takes one argument, the name of the encoding. Lowercase names
.. % % for encodings are preferred.
::
>>> u"あいう".encode('utf-8')
'\xc2\x82\xc2\xa0\xc2\x82\xc2\xa2\xc2\x82\xc2\xa4'
特定のエンコーディングで書かれているデータがあり、そこから Unicode 文字列を生成したいなら、 :func:`unicode` を使い、第 2
引数にエンコーディング名を指定します。
.. % % If you have data in a specific encoding and want to produce a
.. % % corresponding Unicode string from it, you can use the
.. % % \function{unicode()} function with the encoding name as the second
.. % % argument.
::
unicode('\xc2\x82\xc2\xa0\xc2\x82\xc2\xa2\xc2\x82\xc2\xa4', 'utf-8')
u'\x82\xa0\x82\xa2\x82\xa4'
.. _tut-lists:
リスト
------
Python は数多くの *複合 (compound)* データ型を備えており、別々の値を一まとめにするために使えます。
最も汎用的なデータ型は *リスト(list)* で、コンマで区切られた値からなるリストを各カッコで囲んだものとして書き表されます。
リストの要素をすべて同じ型にする必要はありません。
.. % Lists
.. % % Python knows a number of \emph{compound} data types, used to group
.. % % together other values. The most versatile is the \emph{list}, which
.. % % can be written as a list of comma-separated values (items) between
.. % % square brackets. List items need not all have the same type.
::
>>> a = ['spam', 'eggs', 100, 1234]
>>> a
['spam', 'eggs', 100, 1234]
文字列のインデクスと同じく、リストのインデクスは 0 から開始します。また、スライス、連結なども行えます:
.. % % Like string indices, list indices start at 0, and lists can be sliced,
.. % % concatenated and so on:
::
>>> a[0]
'spam'
>>> a[3]
1234
>>> a[-2]
100
>>> a[1:-1]
['eggs', 100]
>>> a[:2] + ['bacon', 2*2]
['spam', 'eggs', 'bacon', 4]
>>> 3*a[:3] + ['Boo!']
['spam', 'eggs', 100, 'spam', 'eggs', 100, 'spam', 'eggs', 100, 'Boo!']
*変化不可能 (:term:`immutable`)* な文字列型と違い、リストは個々の要素を変更することができます。
.. % % Unlike strings, which are \emph{immutable}, it is possible to change
.. % % individual elements of a list:
::
>>> a
['spam', 'eggs', 100, 1234]
>>> a[2] = a[2] + 23
>>> a
['spam', 'eggs', 123, 1234]
スライスに代入することもできます。スライスの代入を行って、リストのサイズを変更したり、完全に消すことさえできます:
.. % % Assignment to slices is also possible, and this can even change the size
.. % % of the list or clear it entirely:
::
>>> # いくつかの項目を置換する:
... a[0:2] = [1, 12]
>>> a
[1, 12, 123, 1234]
>>> # いくつかの項目を除去する:
... a[0:2] = []
>>> a
[123, 1234]
>>> # いくつかの項目を挿入する:
... a[1:1] = ['bletch', 'xyzzy']
>>> a
[123, 'bletch', 'xyzzy', 1234]
>>> # それ自身 (のコピー) を先頭に挿入する
>>> a[:0] = a
>>> a
[123, 'bletch', 'xyzzy', 1234, 123, 'bletch', 'xyzzy', 1234]
>>> # リストをクリアする: 全てのアイテムを空のリストに置換する
>>> a[:] = []
>>> a
[]
組込み関数 :func:`len` はリストにも適用できます。
.. % % The built-in function \function{len()} also applies to lists:
::
>>> a = ['a', 'b', 'c', 'd']
>>> len(a)
4
リストを入れ子にする (ほかのリストを含むリストを造る) ことも可能です。例えば、
.. % % It is possible to nest lists (create lists containing other lists),
.. % % for example:
::
>>> q = [2, 3]
>>> p = [1, q, 4]
>>> len(p)
3
>>> p[1]
[2, 3]
>>> p[1][0]
2
>>> p[1].append('xtra') # 5.1節を参照
>>> p
[1, [2, 3, 'xtra'], 4]
>>> q
[2, 3, 'xtra']
最後の例では、 ``p[1]`` と ``q`` が実際には同一のオブジェクトを参照していることに注意してください! *オブジェクトの意味付け
(semantics)* については、後ほど触れることにします。
.. % % Note that in the last example, \code{p[1]} and \code{q} really refer to
.. % % the same object! We'll come back to \emph{object semantics} later.
.. _tut-firststeps:
プログラミングへの第一歩
========================
もちろん、2 たす 2 よりももっと複雑な仕事にも Python を使うことができます。 *Fibonacci* 級数列の先頭の部分列は次のようにして
書くことができます:
.. % First Steps Towards Programming
.. % % Of course, we can use Python for more complicated tasks than adding
.. % % two and two together. For instance, we can write an initial
.. % % sub-sequence of the \emph{Fibonacci} series as follows:
::
>>> # Fibonacci 級数:
... # 二つの要素の和が次の要素を定義する
... a, b = 0, 1
>>> while b < 10:
... print b
... a, b = b, a+b
...
1
1
2
3
5
8
上の例では、いくつか新しい機能を取り入れています。
.. % % This example introduces several new features.
* 最初の行には * 複数同時の代入 (multiple assignment)* が入っています: 変数 ``a`` と ``b`` は、それぞれ同時に新しい値
0 と 1 になっています。この代入は最後の行でも再度使われており、代入が行われる前に右辺の式がまず評価されます。右辺の式は左から右へと
順番に評価されます。
* :keyword:`while` は、条件 (ここでは ``b < 10``) が真である限り実行を繰り返し (ループし) ます。Python では、C
言語と同様に、ゼロでない整数値は真となり、ゼロは偽です。条件式は文字列値やリスト値、実際には任意のシーケンス型でもかまいません。例中で使われている条件テスト
は単なる比較です。標準的な比較演算子は C 言語と同様です: すなわち、 ``<`` (より小さい)、 ``>`` (より大きい)、 ``==`` (等しい)、
``<=`` (より小さいか等しい)、 ``>=`` (より大きいか等しい)、および ``!=`` (等しくない) 、です。
* ループの* 本体 (body)* は* インデント (indent, 字下げ)* されています: インデントは Python
において実行文をグループにまとめる方法です。Python は (いまだに!) 賢い入力行編集機能を提供していないので、
インデントされた各行を入力するにはタブや (複数個の) スペースを使わなければなりません。実際には、Python へのより複雑な入力を準備する
にはテキストエディタを使うことになるでしょう; ほとんどのテキストエディタは自動インデント機能を持っています。
複合文を対話的に入力するときには、(パーザはいつ最後の行を入力したのか推し量ることができないので) 入力の完了を示すために最後に空行を
続けなければなりません。基本ブロックの各行は同じだけインデントされていなければならないので注意してください。
* :keyword:`print` は指定した (1 つまたは複数の) 式の値を書き出します。 :keyword:`print` は、(電卓の例でしたように)
単に値を出力したい式を書くのとは、複数の式や文字列を扱う方法が違います。文字列は引用符無しで出力され、複数の要素の間にはスペースが挿入されるので、
以下のように出力をうまく書式化できます。 ::
>>> i = 256*256
>>> print 'The value of i is', i
The value of i is 65536
末尾にコンマを入れると、出力を行った後に改行されません:
.. % % A trailing comma avoids the newline after the output:
::
>>> a, b = 0, 1
>>> while b < 1000:
... print b,
... a, b = b, a+b
...
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
インタプリタは、最後に入力した行がまだ完全な文になっていない場合、
改行をはさんで次のプロンプトを出力することに注意してください。
.. % % Note that the interpreter inserts a newline before it prints the next
.. % % prompt if the last line was not completed.
Python-2.6.2-DocJa-1/_sources/tutorial/classes.txt 0000644 0001750 0001750 00000234733 11474251537 021426 0 ustar inada-n inada-n .. _tut-classes:
******
クラス
******
Python では、最小限の構文と意味付けを使ってクラス (class) のメカニズムを言語に追加しています。Python のクラスは、C++ と
Modula-3 で見られるクラスメカニズムを混合したものです。モジュールがそうであるように、 Python
におけるクラスでは、クラス定義とユーザとの間に絶対的な障壁をおかず、ユーザが礼儀正しく、 "定義に首を突っ込む" ことはないと
あてにしています。とはいえ、クラスにおける最も重要な機能はそのままに、完全な力を持っています: クラスの継承 (inheritance) メカニズムでは、
複数の基底クラスを持つことができ、導出されたクラスでは基底クラスの任意のメソッドをオーバライド (override, 上書き) することができます。
メソッドでは、基底クラスのメソッドを同じ名前で呼び出すことができます。オブジェクトには任意のプライベートなデータを入れることができます。
.. % Classes
.. % % Python's class mechanism adds classes to the language with a minimum
.. % % of new syntax and semantics. It is a mixture of the class mechanisms
.. % % found in \Cpp{} and Modula-3. As is true for modules, classes in Python
.. % % do not put an absolute barrier between definition and user, but rather
.. % % rely on the politeness of the user not to ``break into the
.. % % definition.'' The most important features of classes are retained
.. % % with full power, however: the class inheritance mechanism allows
.. % % multiple base classes, a derived class can override any methods of its
.. % % base class or classes, and a method can call the method of a base class with the
.. % % same name. Objects can contain an arbitrary amount of private data.
C++ の用語では、全てのクラスメンバ (データメンバも含む) は *public* (公開されたデータ) であり、メンバ関数はすべて *仮想関数
(virtual)* です。特別なコンストラクタ (constructor: 生成関数) やデストラクタ (destructor: 破壊関数)
はありません。Module-3 にあるような、オブジェクトのメンバをメソッドから参照するために短縮した記法は使えません:
メソッド関数の宣言では、オブジェクト自体を表すパラメタ第一引数に明示せねばなりません。第一引数のオブジェクトはメソッド呼び
出しの際に暗黙の引数として渡されます。Smalltalk に似て、クラスはそれ自体がオブジェクトです。とはいえ、これは広義のオブジェクトという意味で、
Python では全てのデータ型はオブジェクトです。このことは、import や名前変更といった操作のセマンティクスにつながります。 C++ や
Modula-3 と違って、ユーザは組込みの型を基底クラスにして拡張を行えます。また、C++ とは同じで Modula-3 とは違う点として、特別な
構文を伴うほとんどの組み込み演算子 (算術演算子 (arithmetic operator) や添字表記) はクラスインスタンスで使うために再定義できます。
.. % % In \Cpp{} terminology, all class members (including the data members) are
.. % % \emph{public}, and all member functions are \emph{virtual}. There are
.. % % no special constructors or destructors. As in Modula-3, there are no
.. % % shorthands for referencing the object's members from its methods: the
.. % % method function is declared with an explicit first argument
.. % % representing the object, which is provided implicitly by the call. As
.. % % in Smalltalk, classes themselves are objects, albeit in the wider
.. % % sense of the word: in Python, all data types are objects. This
.. % % provides semantics for importing and renaming. Unlike
.. % % \Cpp{} or Modula-3, built-in types can be used as base classes for
.. % % extension by the user. Also, like in \Cpp{} but unlike in Modula-3, most
.. % % built-in operators with special syntax (arithmetic operators,
.. % % subscripting etc.) can be redefined for class instances.
.. _tut-terminology:
用語について一言
================
クラスに関して広範に受け入れられている用語定義がないので、 Smalltalk と C++ の用語を場合に応じて使っていくことにします。
(オブジェクト指向における意味付けの方法は C++よりも Modula-3 のほうが Python に近いので Modula-3 の用語を使いたいのですが、
ほとんどの読者はそれを耳にしたことがないと思います。)
.. % A Word About Terminology
.. % % Lacking universally accepted terminology to talk about classes, I will
.. % % make occasional use of Smalltalk and \Cpp{} terms. (I would use Modula-3
.. % % terms, since its object-oriented semantics are closer to those of
.. % % Python than \Cpp, but I expect that few readers have heard of it.)
オブジェクトには個体性があり、同一のオブジェクトに (複数のスコープの) 複数の名前を割り当てることができます。この機能は他の言語では別名 (ailias)
づけとして知られています。Python を一見しただけでは、別名づけの重要性は分からないことが多く、変更不能な基本型 (数値、文字列、タプル)
を扱うときには無視して差し支えありません。しかしながら、別名付けには、リストや辞書、またプログラムの外部にある実体 (ファイル、ウィンドウ、など)
を表現するためのほとんどの型が入った Python コードで意味付けを行う上で (意図的な！) 効果があります。
別名付けはいくつかの点でポインタのように振舞うので、通常はプログラムに利するように使われます。例えば、オブジェクトの受け渡しは、実装上は
ポインタが渡されるだけなのでコストの低い操作になります; また、関数があるオブジェクトを引数として渡されたとき、関数の呼び出し側から
オブジェクトに対する変更を見ることができます --- これにより、 Pascal にあるような二つの引数渡し機構をもつ必要をなくしています。
.. % % Objects have individuality, and multiple names (in multiple scopes)
.. % % can be bound to the same object. This is known as aliasing in other
.. % % languages. This is usually not appreciated on a first glance at
.. % % Python, and can be safely ignored when dealing with immutable basic
.. % % types (numbers, strings, tuples). However, aliasing has an
.. % % (intended!) effect on the semantics of Python code involving mutable
.. % % objects such as lists, dictionaries, and most types representing
.. % % entities outside the program (files, windows, etc.). This is usually
.. % % used to the benefit of the program, since aliases behave like pointers
.. % % in some respects. For example, passing an object is cheap since only
.. % % a pointer is passed by the implementation; and if a function modifies
.. % % an object passed as an argument, the caller will see the change --- this
.. % % obviates the need for two different argument passing mechanisms as in
.. % % Pascal.
.. _tut-scopes:
Python のスコープと名前空間
===========================
クラスを紹介する前に、Python のスコープ規則についてあることを話しておかなければなりません。クラス定義はある巧みなトリックを名前空間に
施すので、何が起こっているのかを完全に理解するには、スコープと名前空間がどのように動作するかを理解する必要があります。ちなみに、この問題に関する知識は全ての
Python プログラマにとって有用です。
.. % Python Scopes and Name Spaces
.. % % Before introducing classes, I first have to tell you something about
.. % % Python's scope rules. Class definitions play some neat tricks with
.. % % namespaces, and you need to know how scopes and namespaces work to
.. % % fully understand what's going on. Incidentally, knowledge about this
.. % % subject is useful for any advanced Python programmer.
まず定義から始めましょう。
.. % % Let's begin with some definitions.
*名前空間 (namespace)* とは、名前からオブジェクトへの対応付け (mapping) です。ほとんどの名前空間は、現状では Python
の辞書として実装されていますが、そのことは通常は (パフォーマンス以外では) 目立つことはないし、将来は変更されるかもしれません。
名前空間の例には、組込み名の集合 (:func:`abs` 等の関数や組込み例外名)、モジュールないのグローバルな名前; 関数を呼び出したときの
ローカルな名前、があります。その意味では、オブジェクトの属性からなる集合もまた、名前空間を形成します。名前空間について知っておくべき
重要なことは、異なった名前空間にある名前の間には全く関係がないということです; 例えば、二つの別々のモジュールの両方で関数 "maximize"
という関数を定義することができ、定義自体は混同されることはありません --- モジュールのユーザは名前の前にモジュール名をつけなければなりません。
.. % % A \emph{namespace} is a mapping from names to objects. Most
.. % % namespaces are currently implemented as Python dictionaries, but
.. % % that's normally not noticeable in any way (except for performance),
.. % % and it may change in the future. Examples of namespaces are: the set
.. % % of built-in names (functions such as \function{abs()}, and built-in
.. % % exception names); the global names in a module; and the local names in
.. % % a function invocation. In a sense the set of attributes of an object
.. % % also form a namespace. The important thing to know about namespaces
.. % % is that there is absolutely no relation between names in different
.. % % namespaces; for instance, two different modules may both define a
.. % % function ``maximize'' without confusion --- users of the modules must
.. % % prefix it with the module name.
ところで、 *属性* という言葉は、ドットに続く名前すべてに対して使っています --- 例えば式 ``z.real`` で、 ``real`` はオブジェクト
``z`` の属性です。厳密にいえば、モジュール内の名前に対する参照は属性の参照です: 式 ``modname.funcname`` では、
``modname`` はあるモジュールオブジェクトで、 ``funcname`` はその属性です。この場合には、たまたまモジュールの属性とモジュール内の
グローバルな名前の間にはこの場合はたまたま、モジュールの属性とモジュールで定義されているグローバル名の間には、直接的な対応付けがされます: これらの名前は
同じ名前空間を共有しているのです！ [#]_
.. % % By the way, I use the word \emph{attribute} for any name following a
.. % % dot --- for example, in the expression \code{z.real}, \code{real} is
.. % % an attribute of the object \code{z}. Strictly speaking, references to
.. % % names in modules are attribute references: in the expression
.. % % \code{modname.funcname}, \code{modname} is a module object and
.. % % \code{funcname} is an attribute of it. In this case there happens to
.. % % be a straightforward mapping between the module's attributes and the
.. % % global names defined in the module: they share the same namespace!
.. % % \footnote{
.. % % Except for one thing. Module objects have a secret read-only
.. % % attribute called \member{__dict__} which returns the dictionary
.. % % used to implement the module's namespace; the name
.. % % \member{__dict__} is an attribute but not a global name.
.. % % Obviously, using this violates the abstraction of namespace
.. % % implementation, and should be restricted to things like
.. % % post-mortem debuggers.
.. % % }
属性は読取り専用にも、書き込み専用にもできます。後者の場合、属性に代入することができます。モジュール属性は書込み可能です:
``modname.the_answer = 42`` と書くことができます。書込み可能な属性は、 :keyword:`del` 文で削除することも
できます。例えば、 ``del modname.the_answer`` は、 ``modname`` で指定されたオブジェクトから属性
:attr:`the_answer` を除去します。
.. % % Attributes may be read-only or writable. In the latter case,
.. % % assignment to attributes is possible. Module attributes are writable:
.. % % you can write \samp{modname.the_answer = 42}. Writable attributes may
.. % % also be deleted with the \keyword{del} statement. For example,
.. % % \samp{del modname.the_answer} will remove the attribute
.. % % \member{the_answer} from the object named by \code{modname}.
名前空間は様々な時点で作成され、その寿命も様々です。組み込みの名前が入った名前空間は Python インタプリタが起動するときに
作成され、決して削除されることはありません。モジュールのグローバルな名前空間は、モジュール定義が読み込まれたときに作成されます; 通常、
モジュールの名前空間は、インタプリタが終了するまで残ります。インタプリタのトップレベルで実行された文は、スクリプトファイルから
読み出されたものでも対話的に読み出されたものでも、 :mod:`__main__` という名前のモジュールの一部分であるとみなされるので、独自の
名前空間を持つことになります。(組み込みの名前は実際にはモジュール内に存在します; そのモジュールは :mod:`__builtin__`
と呼ばれています。)
.. % % Name spaces are created at different moments and have different
.. % % lifetimes. The namespace containing the built-in names is created
.. % % when the Python interpreter starts up, and is never deleted. The
.. % % global namespace for a module is created when the module definition
.. % % is read in; normally, module namespaces also last until the
.. % % interpreter quits. The statements executed by the top-level
.. % % invocation of the interpreter, either read from a script file or
.. % % interactively, are considered part of a module called
.. % % \module{__main__}, so they have their own global namespace. (The
.. % % built-in names actually also live in a module; this is called
.. % % \module{__builtin__}.)
関数のローカルな名前空間は、関数が呼び出されたときに作成され、関数から戻ったときや、関数内で例外が送出され、かつ関数内で処理されなかった場合に削除されます。
(実際には、忘れられる、と言ったほうが起きていることをよく表しています。) もちろん、再帰呼出しのときには、各々の呼び出しで各自の
ローカルな名前空間があります。
.. % % The local namespace for a function is created when the function is
.. % % called, and deleted when the function returns or raises an exception
.. % % that is not handled within the function. (Actually, forgetting would
.. % % be a better way to describe what actually happens.) Of course,
.. % % recursive invocations each have their own local namespace.
*スコープ (scope)* とは、ある名前空間が直接アクセスできる (directly accessible) ような、Python
プログラムのテキスト上の領域です。 "直接アクセス可能" とは、限定なし (unqualified) である名前を参照
した際に、その名前空間から名前を見つけようと試みることを意味します。
.. % % A \emph{scope} is a textual region of a Python program where a
.. % % namespace is directly accessible. ``Directly accessible'' here means
.. % % that an unqualified reference to a name attempts to find the name in
.. % % the namespace.
スコープは静的に決定されますが、動的に使用されます。実行中はいつでも、直接名前空間にアクセス可能な、少なくとも三つの入れ子になったスコープがあります:
最初に検索される最も内側のスコープには、ローカルな名前が入っています; あるいは、最も内側のスコープを囲んでいる関数群のスコープで、最も
近傍のスコープから検索を始めます; 中間のスコープが次に検索され、このスコープには現在のモジュールのグローバルな名前が入っています; (最後に検索される)
最も外側のスコープは、組み込みの名前が入った名前空間です。
.. % % Although scopes are determined statically, they are used dynamically.
.. % % At any time during execution, there are at least three nested scopes whose
.. % % namespaces are directly accessible: the innermost scope, which is searched
.. % % first, contains the local names; the namespaces of any enclosing
.. % % functions, which are searched starting with the nearest enclosing scope;
.. % % the middle scope, searched next, contains the current module's global names;
.. % % and the outermost scope (searched last) is the namespace containing built-in
.. % % names.
名前がグローバルであると宣言されている場合、その名前に対する参照や代入は全て、モジュールのグローバルな名前の入った中間のスコープに
対して直接行われます。そうでない場合、最も内側のスコープより外側にある変数は全て読み出し専用(そのような変数に対する書き込みは、単に
*新しい* ローカル変数もっとも内側のスコープで作成し、外部のスコープの値は変化しません)となります。
.. % % If a name is declared global, then all references and assignments go
.. % % directly to the middle scope containing the module's global names.
.. % % Otherwise, all variables found outside of the innermost scope are read-only
.. % % (an attempt to write to such a variable will simply create a \emph{new}
.. % % local variable in the innermost scope, leaving the identically named
.. % % outer variable unchanged).
通常、ローカルスコープは (プログラムテキスト上の) 現在の関数のローカルな名前を参照します。関数の外側では、ローカルスコープは
グローバルな名前空間と同じ名前空間: モジュールの名前空間を参照します。クラスを定義すると、ローカルスコープの中にもう一つ名前空間が置かれます。
.. % % Usually, the local scope references the local names of the (textually)
.. % % current function. Outside functions, the local scope references
.. % % the same namespace as the global scope: the module's namespace.
.. % % Class definitions place yet another namespace in the local scope.
スコープはテキスト上で決定されていると理解することが重要です: モジュール内で定義される関数のグローバルなスコープは、
関数がどこから呼び出されても、どんな別名をつけて呼び出されても、そのモジュールの名前空間になります。反対に、実際の名前の検索は実行時に動的に行われます
--- とはいえ、言語の定義は、"コンパイル" 時の静的な名前解決の方向に進化しているので、動的な名前解決に頼ってはいけません！
(事実、ローカルな変数は既に静的に決定されています。)
.. % % It is important to realize that scopes are determined textually: the
.. % % global scope of a function defined in a module is that module's
.. % % namespace, no matter from where or by what alias the function is
.. % % called. On the other hand, the actual search for names is done
.. % % dynamically, at run time --- however, the language definition is
.. % % evolving towards static name resolution, at ``compile'' time, so don't
.. % % rely on dynamic name resolution! (In fact, local variables are
.. % % already determined statically.)
Python 特有の癖として、代入を行うと -- どの :keyword:`global` 文も有効でない場合は -- 名前がいつも最も内側のスコープに入るというものがあります。代入はデータのコピーを行いません ---
単に名前をオブジェクトに結びつける (bind) だけです。オブジェクトの削除でも同じです: ``del x`` は、 ``x``
をローカルスコープが参照している名前空間から削除します。実際、新たな名前を導入する操作は全てローカルスコープを用います: とりわけ、 import
文や関数定義は、モジュールや関数の名前をローカルスコープに結び付けます。(:keyword:`global` 文を使えば、
特定の変数がグローバルスコープにあることを示せます。)
.. % % A special quirk of Python is that assignments always go into the
.. % % innermost scope. Assignments do not copy data --- they just
.. % % bind names to objects. The same is true for deletions: the statement
.. % % \samp{del x} removes the binding of \code{x} from the namespace
.. % % referenced by the local scope. In fact, all operations that introduce
.. % % new names use the local scope: in particular, import statements and
.. % % function definitions bind the module or function name in the local
.. % % scope. (The \keyword{global} statement can be used to indicate that
.. % % particular variables live in the global scope.)
.. _tut-firstclasses:
クラス初見
==========
クラスでは、新しい構文を少しと、三つの新たなオブジェクト型、そして新たな意味付けをいくつか取り入れています。
.. % A First Look at Classes
.. % % Classes introduce a little bit of new syntax, three new object types,
.. % % and some new semantics.
.. _tut-classdefinition:
クラス定義の構文
----------------
クラス定義の最も単純な形式は、以下のようになります:
.. % Class Definition Syntax
.. % % The simplest form of class definition looks like this:
::
class ClassName:
<文-1>
.
.
.
<文-N>
関数定義 (:keyword:`def` 文) と同様、クラス定義が効果をもつにはまず実行しなければなりません。 (クラス定義を :keyword:`if`
文の分岐先や関数内部に置くことも、考え方としてはありえます。)
.. % % Class definitions, like function definitions
.. % % (\keyword{def} statements) must be executed before they have any
.. % % effect. (You could conceivably place a class definition in a branch
.. % % of an \keyword{if} statement, or inside a function.)
実際には、クラス定義の内側にある文は、通常は関数定義になりますが、他の文を書くこともでき、それがそれが役に立つこともあります ---
これについては後で述べます。クラス内の関数定義は通常、メソッドの呼び出し規約で決められた独特の形式の引数リストを持ちます --- これについても後で述べます。
.. % % In practice, the statements inside a class definition will usually be
.. % % function definitions, but other statements are allowed, and sometimes
.. % % useful --- we'll come back to this later. The function definitions
.. % % inside a class normally have a peculiar form of argument list,
.. % % dictated by the calling conventions for methods --- again, this is
.. % % explained later.
クラス定義に入ると、新たな名前空間が作成され、ローカルな名前空間として使われます --- 従って、ローカルな変数に対する
全ての代入はこの新たな名前空間に名要ります。特に、関数定義を行うと、新たな関数の名前はこの名前空間に結び付けられます。
.. % % When a class definition is entered, a new namespace is created, and
.. % % used as the local scope --- thus, all assignments to local variables
.. % % go into this new namespace. In particular, function definitions bind
.. % % the name of the new function here.
クラス定義から普通に (定義の終端に到達して) 抜けると、 *クラスオブジェクト (class object)* が生成されます。
クラスオブジェクトは、基本的にはクラス定義で作成された名前空間の内容をくるむラッパ (wrapper) です; クラスオブジェクトについては
次の節で詳しく学ぶことにします。(クラス定義に入る前に有効だった) 元のローカルスコープが復帰し、生成されたクラスオブジェクトは
復帰したローカルスコープにクラス定義のヘッダで指定した名前 (上の例では :class:`ClassName`) で結び付けられます。
.. % % When a class definition is left normally (via the end), a \emph{class
.. % % object} is created. This is basically a wrapper around the contents
.. % % of the namespace created by the class definition; we'll learn more
.. % % about class objects in the next section. The original local scope
.. % % (the one in effect just before the class definitions was entered) is
.. % % reinstated, and the class object is bound here to the class name given
.. % % in the class definition header (\class{ClassName} in the example).
.. _tut-classobjects:
クラスオブジェクト
------------------
クラス・オブジェクトでは２種類の演算: 属性参照とインスタンス生成をサポートしています。
.. % Class Objects
.. % % Class objects support two kinds of operations: attribute references
.. % % and instantiation.
*属性参照 (attribute reference)* は、Python におけるすべての属性参照で使われている標準的な構文、 ``obj.name``
を使います。クラスオブジェクトが生成された際にクラスの名前空間にあった名前すべてが有効な属性名です。従って、以下のようなクラス定義:
.. % % \emph{Attribute references} use the standard syntax used for all
.. % % attribute references in Python: \code{obj.name}. Valid attribute
.. % % names are all the names that were in the class's namespace when the
.. % % class object was created. So, if the class definition looked like
.. % % this:
::
class MyClass:
"""A simple example class"""
i = 12345
def f(self):
return 'hello world'
では、 ``MyClass.i`` と ``MyClass.f`` は妥当な属性参照であり、それぞれ整数と関数オブジェクトを返します。
クラス属性に代入を行うこともできます。従って、 ``MyClass.i`` の値を代入して変更できます。 ``__doc__``
も有効な属性で、そのクラスに属している docstring、この場合は ``"A simple example class"`` を返します。
.. % % then \code{MyClass.i} and \code{MyClass.f} are valid attribute
.. % % references, returning an integer and a method object, respectively.
.. % % Class attributes can also be assigned to, so you can change the value
.. % % of \code{MyClass.i} by assignment. \member{__doc__} is also a valid
.. % % attribute, returning the docstring belonging to the class: \code{"A
.. % % simple example class"}).
クラスの *インスタンス生成 (instantiation)* には関数のような表記法を使います。クラスオブジェクトのことを、単にクラスの新しい
インスタンスを返すパラメタを持たない関数かのように扱います。例えば (上記のクラスでいえば):
.. % % Class \emph{instantiation} uses function notation. Just pretend that
.. % % the class object is a parameterless function that returns a new
.. % % instance of the class. For example (assuming the above class):
::
x = MyClass()
は、クラスの新しい *インスタンス (instance)* を生成し、そのオブジェクトをローカル変数 ``x`` へ代入します。
.. % % creates a new \emph{instance} of the class and assigns this object to
.. % % the local variable \code{x}.
インスタンス生成操作 (クラスオブジェクトの "呼出し") を行うと、空のオブジェクト (empty object) を生成します。多くのクラスは、
オブジェクトを作成する際に、カスタマイズされた特定の初期状態になってほしいと望んでいます。従って、クラスでは :meth:`__init__`
という名前の特別なメソッド定義することができます。例えば以下のようにします:
.. % % The instantiation operation (``calling'' a class object) creates an
.. % % empty object. Many classes like to create objects with instances
.. % % customized to a specific initial state.
.. % % Therefore a class may define a special method named
.. % % \method{__init__()}, like this:
::
def __init__(self):
self.data = []
クラスが :meth:`__init__` メソッドを定義している場合、クラスのインスタンスを生成すると、新しく生成されたクラスインスタンスに対して自動的に
:meth:`__init__` を呼び出します。従って、この例では、新たな初期済みのインスタンスを以下のようにして得ることができます:
.. % % When a class defines an \method{__init__()} method, class
.. % % instantiation automatically invokes \method{__init__()} for the
.. % % newly-created class instance. So in this example, a new, initialized
.. % % instance can be obtained by:
::
x = MyClass()
もちろん、より大きな柔軟性を持たせるために、 :meth:`__init__` メソッドに複数の引数をもたせることができます。
その場合、クラスのインスタンス生成操作に渡された引数は :meth:`__init__` に渡されます。例えば以下のように:
.. % % Of course, the \method{__init__()} method may have arguments for
.. % % greater flexibility. In that case, arguments given to the class
.. % % instantiation operator are passed on to \method{__init__()}. For
.. % % example,
::
>>> class Complex:
... def __init__(self, realpart, imagpart):
... self.r = realpart
... self.i = imagpart
...
>>> x = Complex(3.0, -4.5)
>>> x.r, x.i
(3.0, -4.5)
.. _tut-instanceobjects:
インスタンスオブジェクト
------------------------
ところで、インスタンスオブジェクトを使うと何ができるのでしょうか？インスタンスオブジェクトが理解できる唯一の操作は、属性の参照です。
有効な属性の名前には二種類(データ属性およびメソッド)あります。
.. % Instance Objects
.. % % Now what can we do with instance objects? The only operations
.. % % understood by instance objects are attribute references. There are
.. % % two kinds of valid attribute names, data attributes and methods.
*データ属性 (data attribute)* は、これは Smalltalk の "インスタンス変数" (instance variable) や C++の
"データメンバ" (data member) に相当します。データ属性を宣言する必要はありません; ローカルな変数と同様に、
これらの属性は最初に代入された時点で湧き出てきます。例えば、上で生成した :class:`MyClass` のインスタンス ``x`` に対して、
以下のコード断片を実行すると、値 ``16`` を印字し、 ``x`` の痕跡は残りません。
.. % % \emph{data attributes} correspond to
.. % % ``instance variables'' in Smalltalk, and to ``data members'' in
.. % % \Cpp. Data attributes need not be declared; like local variables,
.. % % they spring into existence when they are first assigned to. For
.. % % example, if \code{x} is the instance of \class{MyClass} created above,
.. % % the following piece of code will print the value \code{16}, without
.. % % leaving a trace:
::
x.counter = 1
while x.counter < 10:
x.counter = x.counter * 2
print x.counter
del x.counter
もうひとつのインスタンス属性は *メソッド (method)* です。メソッドとは、オブジェクトに "属している" 関数のことです。(Python
では、メソッドという用語はクラスインスタンスだけのものではありません: オブジェクト型にもメソッドを持つことができます。例えば、リストオブジェクトには、
append, insert, remove, sort などといったメソッドがあります。とはいえ、以下では特に明記しない限り、クラスの
インスタンスオブジェクトのメソッドだけを意味するものとして使うことにします。)
.. % % The other kind of instance attribute reference is a \emph{method}.
.. % % A method is a function that ``belongs to'' an
.. % % object. (In Python, the term method is not unique to class instances:
.. % % other object types can have methods as well. For example, list objects have
.. % % methods called append, insert, remove, sort, and so on. However,
.. % % in the following discussion, we'll use the term method exclusively to mean
.. % % methods of class instance objects, unless explicitly stated otherwise.)
.. index:: object: method
インスタンスオブジェクトで有効なメソッド名は、そのクラスによります。定義により、クラスの全てのo関数オブジェクトである属性が
インスタンスオブジェクトの妥当なメソッド名に決まります。従って、例では、 ``MyClass.f`` は関数なので、 ``x.f``
はメソッドの参照として有効です。しかし、 ``MyClass.i`` は関数ではないので、 ``x.i`` はメソッドの参照
として有効ではありません。 ``x.f`` は ``MyClass.f`` と同じものではありません --- 関数オブジェクトではなく、 *メソッドオブジェクト
(method object)* です。
.. % % Valid method names of an instance object depend on its class. By
.. % % definition, all attributes of a class that are function
.. % % objects define corresponding methods of its instances. So in our
.. % % example, \code{x.f} is a valid method reference, since
.. % % \code{MyClass.f} is a function, but \code{x.i} is not, since
.. % % \code{MyClass.i} is not. But \code{x.f} is not the same thing as
.. % % \code{MyClass.f} --- it is a \obindex{method}\emph{method object}, not
.. % % a function object.
.. _tut-methodobjects:
メソッドオブジェクト
--------------------
普通、メソッドはバインドされた直後に呼び出されます:
.. % Method Objects
.. % % Usually, a method is called right after it is bound:
::
x.f()
:class:`MyClass` の例では、上のコードは文字列 ``'hello world'`` を返すでしょう。
しかしながら、必ずしもメソッドをその場で呼び出さなければならないわけではありません: ``x.f`` はメソッドオブジェクトであり、
どこかに記憶しておいて後で呼び出すことができます。例えば以下のコード:
.. % % In the \class{MyClass} example, this will return the string \code{'hello world'}.
.. % % However, it is not necessary to call a method right away:
.. % % \code{x.f} is a method object, and can be stored away and called at a
.. % % later time. For example:
::
xf = x.f
while True:
print xf()
は、 ``hello world`` を時が終わるまで印字し続けるでしょう。
.. % % will continue to print \samp{hello world} until the end of time.
メソッドが呼び出されるときには実際には何が起きているのでしょうか？ :meth:`f` の関数定義では引数を一つ指定していたにもかかわらず、上記では
``x.f`` が引数なしで呼び出されたことに気付いているかもしれませんね。引数はどうなったのでしょうか？たしか、引数が必要な関数を
引数無しで呼び出すと、Python が例外を送出するはずです --- たとえその引数が実際には使われなくても…。
.. % % What exactly happens when a method is called? You may have noticed
.. % % that \code{x.f()} was called without an argument above, even though
.. % % the function definition for \method{f} specified an argument. What
.. % % happened to the argument? Surely Python raises an exception when a
.. % % function that requires an argument is called without any --- even if
.. % % the argument isn't actually used...
実際、もう答は想像できているかもしれませんね: メソッドについて特別なこととして、オブジェクトが関数の第 1 引数として渡される、
ということがあります。我々の例では、 ``x.f()`` という呼び出しは、 ``MyClass.f(x)`` と厳密に等価なものです。一般に、 *n*
個の引数リストもったメソッドの呼出しは、そのメソッドのオブジェクトを最初の引数の前に挿入した引数リストでメソッドに対応する関数を呼び出すことと等価です。
.. % % Actually, you may have guessed the answer: the special thing about
.. % % methods is that the object is passed as the first argument of the
.. % % function. In our example, the call \code{x.f()} is exactly equivalent
.. % % to \code{MyClass.f(x)}. In general, calling a method with a list of
.. % % \var{n} arguments is equivalent to calling the corresponding function
.. % % with an argument list that is created by inserting the method's object
.. % % before the first argument.
もしもまだメソッドの働きかたを理解できなければ、一度実装を見てみると事情がよく分かるかもしれません。
データ属性ではないインスタンス属性が参照された時は、そのクラスが検索されます。
その名前が有効なクラス属性を表している関数オブジェクトなら、インスタンスオブジェクトと見つかった関数オブジェクト (へのポインタ)
を抽象オブジェクト: すなわちメソッドオブジェクトにパック (pack) して作成します。
メソッドオブジェクトは、引数リストを伴って呼び出される際に再度\
アンパック (unpack) され、新たな引数リストがインスタンスオブジェクト\
とオリジナルの引数リストから構成され、関数オブジェクトは新たな引数\
リストを使って呼び出されます。
.. % % If you still don't understand how methods work, a look at the
.. % % implementation can perhaps clarify matters. When an instance
.. % % attribute is referenced that isn't a data attribute, its class is
.. % % searched. If the name denotes a valid class attribute that is a
.. % % function object, a method object is created by packing (pointers to)
.. % % the instance object and the function object just found together in an
.. % % abstract object: this is the method object. When the method object is
.. % % called with an argument list, it is unpacked again, a new argument
.. % % list is constructed from the instance object and the original argument
.. % % list, and the function object is called with this new argument list.
.. _tut-remarks:
いろいろな注意点
================
.. % Random Remarks
.. % % [These should perhaps be placed more carefully...]
.. これらはおそらくもっと注意深く配置すべきだろう…
データ属性は同じ名前のメソッド属性を上書きしてしまいます; 大規模なプログラムでみつけにくいバグを引き起こすことがある
この偶然的な名前の衝突を避けるには、衝突の可能性を最小限にするような規約を使うのが賢明です。
可能な規約としては、メソッド名を大文字で始める、データ属性名の先頭に短い一意的な文字列 (あるいはただの下線) をつける、またメソッドには動詞、
データ属性には名詞を用いる、などがあります。
.. % % Data attributes override method attributes with the same name; to
.. % % avoid accidental name conflicts, which may cause hard-to-find bugs in
.. % % large programs, it is wise to use some kind of convention that
.. % % minimizes the chance of conflicts. Possible conventions include
.. % % capitalizing method names, prefixing data attribute names with a small
.. % % unique string (perhaps just an underscore), or using verbs for methods
.. % % and nouns for data attributes.
データ属性は、メソッドから参照できると同時に、通常のオブジェクトのユーザ ("クライアント") からも参照できます。言い換えると、
クラスは純粋な抽象データ型として使うことができません。実際、 Python では、データ隠蔽を補強するための機構はなにもありません ---
データの隠蔽はすべて規約に基づいています。(逆に、C 言語で書かれた Python の実装では実装の詳細を完全に隠蔽し、必要に応じてオブジェクト
へのアクセスを制御できます; この機構は C 言語で書かれた Python 拡張で使うことができます)
.. % % Data attributes may be referenced by methods as well as by ordinary
.. % % users (``clients'') of an object. In other words, classes are not
.. % % usable to implement pure abstract data types. In fact, nothing in
.. % % Python makes it possible to enforce data hiding --- it is all based
.. % % upon convention. (On the other hand, the Python implementation,
.. % % written in C, can completely hide implementation details and control
.. % % access to an object if necessary; this can be used by extensions to
.. % % Python written in C.)
クライアントはデータ属性を注意深く扱うべきです --- クライアントは、メソッドを使うことで維持しているデータ属性の不変式を踏みにじり、
台無しにするかもしれません。クライアントは、名前の衝突が回避されている限り、メソッドの有効性に
影響を及ぼすことなくインスタンスに独自の属性を追加することができる、ということに注意してください --- ここでも、名前付けの規約は
頭痛の種を無くしてくれます。
.. % % Clients should use data attributes with care --- clients may mess up
.. % % invariants maintained by the methods by stamping on their data
.. % % attributes. Note that clients may add data attributes of their own to
.. % % an instance object without affecting the validity of the methods, as
.. % % long as name conflicts are avoided --- again, a naming convention can
.. % % save a lot of headaches here.
データ属性を (またはその他のメソッドも！) メソッドの中で参照するための短縮された記法はありません。私は、この仕様が実際にメソッドの
可読性を高めていると考えています: あるメソッドを眺めているときにローカルな変数とインスタンス変数を混同する可能性はまったくありません。
.. % % There is no shorthand for referencing data attributes (or other
.. % % methods!) from within methods. I find that this actually increases
.. % % the readability of methods: there is no chance of confusing local
.. % % variables and instance variables when glancing through a method.
しばしば、メソッドの最初の引数を、しばしば ``self`` と呼びます。この名前付けは単なる慣行でしかありません: ``self`` という名前は、
Python では何ら特殊な意味を持ちません。 (とはいえ、この慣行に従わないと、コードは他の Python プログラマにとってやや読みにくいものとなります。
また、 *クラスブラウザ (class browser)* プログラムがこの慣行をあてにして書かれているかもしれません。)
.. % % Often, the first argument of a method is called
.. % % \code{self}. This is nothing more than a convention: the name
.. % % \code{self} has absolutely no special meaning to Python. (Note,
.. % % however, that by not following the convention your code may be less
.. % % readable to other Python programmers, and it is also conceivable that
.. % % a \emph{class browser} program might be written that relies upon such a
.. % % convention.)
クラス属性である関数オブジェクトはいずれも、そのクラスのインスタンスのためのメソッドを定義しています。関数定義は、テキスト上では
クラス定義の中に入っていなければならないわけではありません: 関数オブジェクトをクラスのローカルな変数の中に代入するのも OK です。
例えば以下のコードのようにします:
.. % % Any function object that is a class attribute defines a method for
.. % % instances of that class. It is not necessary that the function
.. % % definition is textually enclosed in the class definition: assigning a
.. % % function object to a local variable in the class is also ok. For
.. % % example:
::
# クラスの外側で定義された関数
def f1(self, x, y):
return min(x, x+y)
class C:
f = f1
def g(self):
return 'hello world'
h = g
これで、 ``f`` 、 ``g`` 、および ``h`` は、すべて :class:`C` の属性であり関数オブジェクトを参照しています。
従って、これら全ては、 :class:`C` のインスタンスのメソッドとなります --- ``h`` は ``g`` と全く等価です。これを実践しても、大抵は
単にプログラムの読者に混乱をもたらすだけなので注意してください。
.. % % Now \code{f}, \code{g} and \code{h} are all attributes of class
.. % % \class{C} that refer to function objects, and consequently they are all
.. % % methods of instances of \class{C} --- \code{h} being exactly equivalent
.. % % to \code{g}. Note that this practice usually only serves to confuse
.. % % the reader of a program.
メソッドは、 ``self`` 引数のメソッド属性を使って、他のメソッドを呼び出すことができます:
.. % % Methods may call other methods by using method attributes of the
.. % % \code{self} argument:
::
class Bag:
def __init__(self):
self.data = []
def add(self, x):
self.data.append(x)
def addtwice(self, x):
self.add(x)
self.add(x)
メソッドは、通常の関数と同じようにして、グローバルな名前を参照してもかまいません。あるメソッドに関連付けられたグローバルなスコープは、
クラス定義の入っているモジュールになります。 (クラス自体はグローバルなスコープとして用いられることはありません！) メソッドでグローバルな
データを使う良い理由はほとんどありませんが、グローバルなスコープを使う合法的な使い方は多々あります: 一つ挙げると、メソッド内では、グローバルなスコープに
import された関数やモジュールや、その中で定義された関数やクラスを使うことができます。通常、メソッドの入っているクラス自体はグローバルなスコープ内で
定義されています。次の章では、メソッドが自分のクラスを参照する理由として正当なものを見てみましょう！
.. % % Methods may reference global names in the same way as ordinary
.. % % functions. The global scope associated with a method is the module
.. % % containing the class definition. (The class itself is never used as a
.. % % global scope!) While one rarely encounters a good reason for using
.. % % global data in a method, there are many legitimate uses of the global
.. % % scope: for one thing, functions and modules imported into the global
.. % % scope can be used by methods, as well as functions and classes defined
.. % % in it. Usually, the class containing the method is itself defined in
.. % % this global scope, and in the next section we'll find some good
.. % % reasons why a method would want to reference its own class!
個々の値はオブジェクトなので、 *クラス* (*型* とも言います) を持っています。
それは ``object.__class__`` に保持されています。
.. _tut-inheritance:
継承
====
言うまでもなく、継承の概念をサポートしない言語機能は "クラス" と呼ぶに値しません。導出クラス (derived class) を定義する構文は以下のように
なります:
.. % Inheritance
.. % % Of course, a language feature would not be worthy of the name ``class''
.. % % without supporting inheritance. The syntax for a derived class
.. % % definition looks like this:
::
class DerivedClassName(BaseClassName):
<文-1>
.
.
.
<文-N>
基底クラス (base class) の名前 :class:`BaseClassName` は、
導出クラス定義の入っているスコープで定義されていなければなりません。基底クラス名のかわりに任意の式を入れることもできます。これは以下のように、
.. % % The name \class{BaseClassName} must be defined in a scope containing
.. % % the derived class definition. In place of a base class name, other
.. % % arbitrary expression is also allowed. This can be useful, for
.. % % example, when the base class is defined in another module:
::
class DerivedClassName(modname.BaseClassName):
基底クラスが別モジュールで定義されているときに便利なことがあります。
導出クラス定義の実行は、基底クラスの場合と同じように進められます。クラスオブジェクトが構築される時、基底クラスが記憶されます。
記憶された基底クラスは、属性参照を解決するために使われます: 要求された属性がクラスに見つからなかった場合、基底クラスに検索
が進みます。この規則は、基底クラスが他の何らかのクラスから導出されたものであった場合、再帰的に適用されます。
.. % % Execution of a derived class definition proceeds the same as for a
.. % % base class. When the class object is constructed, the base class is
.. % % remembered. This is used for resolving attribute references: if a
.. % % requested attribute is not found in the class, search proceeds to look in the
.. % % base class. This rule is applied recursively if the base class itself
.. % % is derived from some other class.
導出クラスのインスタンス化では、特別なことは何もありません: ``DerivedClassName()`` はクラスの新たなインスタンスを生成します。
メソッドの参照は以下のようにしてい解決されます: まず対応するクラス属性が検索されます。検索は、必要に応じ、基底クラス連鎖を下って行われ、
検索の結果として何らかの関数オブジェクトがもたらされた場合、メソッド参照は有効なものとなります。
.. % % There's nothing special about instantiation of derived classes:
.. % % \code{DerivedClassName()} creates a new instance of the class. Method
.. % % references are resolved as follows: the corresponding class attribute
.. % % is searched, descending down the chain of base classes if necessary,
.. % % and the method reference is valid if this yields a function object.
導出クラスは基底クラスのメソッドを上書き (override) してもかまいません。メソッドは同じオブジェクトの別のメソッドを呼び出す際に何ら特殊な権限を
持ちません。このため、ある基底クラスのメソッドが、同じ基底クラスで定義されているもう一つのメソッド呼び出しを行っている場合、
導出クラスで上書きされた何らかのメソッドが呼び出されることになるかもしれません。 (C++ プログラマへ: Python では、すべてのメソッドは事実上
``virtual`` です。)
.. % % Derived classes may override methods of their base classes. Because
.. % % methods have no special privileges when calling other methods of the
.. % % same object, a method of a base class that calls another method
.. % % defined in the same base class may end up calling a method of
.. % % a derived class that overrides it. (For \Cpp{} programmers: all methods
.. % % in Python are effectively \keyword{virtual}.)
導出クラスで上書きしているメソッドでは、実際は単に基底クラスの同名のメソッドを置き換えるだけではなく、拡張を行いたいかもしれません。
基底クラスのメソッドを直接呼び出す簡単な方法があります: 単に ``BaseClassName.methodname(self, arguments)``
を呼び出すだけです。この仕様は、場合によってはクライアントでも役に立ちます。 (この呼び出し方が動作するのは、基底クラスがグローバルなスコープ内で
定義されているか、直接 import されている場合だけなので注意してください。)
.. % % An overriding method in a derived class may in fact want to extend
.. % % rather than simply replace the base class method of the same name.
.. % % There is a simple way to call the base class method directly: just
.. % % call \samp{BaseClassName.methodname(self, arguments)}. This is
.. % % occasionally useful to clients as well. (Note that this only works if
.. % % the base class is defined or imported directly in the global scope.)
Python には継承に関係する 2 つの組み込み関数があります:
* :func:`isinstance` を使うとオブジェクトの型が調べられます: ``isinstance(obj, int)`` は ``obj.__class__`` が :class:`int` や :class:`int` の導出クラスの場合に限り ``True`` になります。
* :func:`issubclass` を使うとクラスの継承関係が調べられます: :class:`bool` は :class:`int` のサブクラスなので ``issubclass(bool, int)`` は ``True`` です。しかし、 :class:`unicode` は :class:`str` のサブクラスではない (単に共通の祖先 :class:`basestring` を共有している) ので ``issubclass(unicode, str)`` は ``False`` です。
.. _tut-multiple:
多重継承
--------
Python では、限られた形式の多重継承 (multiple inheritance) もサポートしています。複数の基底クラスをもつクラス定義は以下のように
なります:
.. % Multiple Inheritance
.. % % Python supports a limited form of multiple inheritance as well. A
.. % % class definition with multiple base classes looks like this:
::
class DerivedClassName(Base1, Base2, Base3):
<文-1>
.
.
.
<文-N>
旧形式のクラスでは、
解決規則は深さ優先 (depth-first)、左から右へ (left-to-right) だけです。従って、ある属性が
:class:`DerivedClassName` で見つからなければ :class:`Base1` で検索され、次に :class:`Base1` の
基底クラスで (再帰的に) 検索されます。それでも見つからなければはじめて :class:`Base2` で検索される、といった具合です。
.. % % The only rule necessary to explain the semantics is the resolution
.. % % rule used for class attribute references. This is depth-first,
.. % % left-to-right. Thus, if an attribute is not found in
.. % % \class{DerivedClassName}, it is searched in \class{Base1}, then
.. % % (recursively) in the base classes of \class{Base1}, and only if it is
.. % % not found there, it is searched in \class{Base2}, and so on.
(人によっては、幅優先 (breadth first) --- :class:`Base2` と :class:`Base3` を検索してから
:class:`Base1` の基底クラスで検索する --- のほうが自然のように見えます。しかしながら、幅優先の検索では、 :class:`Base1`
の特定の属性のうち、実際に定義されているのが :class:`Base1` なのか、その基底クラスなのかを知らなければ、 :class:`Base2`
の属性との名前衝突がどんな結果をもたらすのか分からないことになります。深さ優先規則では、 :class:`Base1` の直接の
属性と継承された属性とを区別しません。)
.. % % (To some people breadth first --- searching \class{Base2} and
.. % % \class{Base3} before the base classes of \class{Base1} --- looks more
.. % % natural. However, this would require you to know whether a particular
.. % % attribute of \class{Base1} is actually defined in \class{Base1} or in
.. % % one of its base classes before you can figure out the consequences of
.. % % a name conflict with an attribute of \class{Base2}. The depth-first
.. % % rule makes no differences between direct and inherited attributes of
.. % % \class{Base1}.)
.. % Python では偶然的な名前の衝突を慣習に頼って回避しているので、見境なく多重継承の使用すると、メンテナンスの悪夢に陥ることは明らかです。
.. % 多重継承に関するよく知られた問題は、二つのクラスから導出されたクラスがたまたま共通の基底クラスを持つ場合です。
.. % この場合になにが起こるかを結論することは簡単です (インスタンスは共通の基底クラスで使われている "インスタンス変数" の単一のコピーを持つことになります)
.. % が、この意味付けが何の役に立つのかは明らかではありません。
.. % % It is clear that indiscriminate use of multiple inheritance is a
.. % % maintenance nightmare, given the reliance in Python on conventions to
.. % % avoid accidental name conflicts. A well-known problem with multiple
.. % % inheritance is a class derived from two classes that happen to have a
.. % % common base class. While it is easy enough to figure out what happens
.. % % in this case (the instance will have a single copy of ``instance
.. % % variables'' or data attributes used by the common base class), it is
.. % % not clear that these semantics are in any way useful.
.. % % XXX Add rules for new-style MRO?
.. glossary
:term:`new-style class` では、 :func:`super` が適切に呼び出せるようにするためにメソッドの解決順序は動的に変わります。
このアプローチは他の多重継承のある言語で call-next-method として知られており、単一継承しかない言語の super 呼び出しよりも強力です。
新形式のクラスについて、多重継承の全ての場合に 1 つかそれ以上のダイヤモンド継承 (少なくとも 1 つの祖先クラスに対し最も下のクラスから到達する経路が複数ある状態) があるので動的順序付けが必要です。
例えば、全ての新形式のクラスは :class:`object` を継承しているので、どの多重継承でも :class:`object` へ到達するための道は複数存在します。
基底クラスが複数回アクセスされないようにするために、動的アルゴリズムで検索順序を直列化し、各クラスで指定されている祖先クラスどうしの左から右への順序は崩さず、各祖先クラスを一度だけ呼び出し、かつ一様になる (つまり祖先クラスの順序に影響を与えずにサブクラス化できる) ようにします。
まとめると、これらの特徴のおかげで信頼性と拡張性のある多重継承したクラスを設計することができるのです。
さらに詳細を知りたければ、 http://www.python.org/download/releases/2.3/mro/ を見てください。
.. _tut-private:
プライベート変数
================
クラスプライベート (class-private) の識別子に関して限定的なサポートがなされています。 ``__spam`` (先頭に二個以上の下線文字、末尾に
高々一個の下線文字) という形式の識別子、テキスト上では ``_classname__spam`` へと置換されるようになりました。ここで
``classname`` は、現在のクラス名から先頭の下線文字をはぎとった名前になります。このような難号化 (mangle) は、識別子の
文法的な位置にかかわらず行われるので、クラスプライベートなインスタンス変数やクラス変数、メソッド、グローバル変数、そしてインスタンスに含まれる変数を
定義するために利用できます。また、このクラスにとってプライベートなインスタンス変数を *他の* クラスのインスタンスに格納するために
使うことさえできます。難号化した名前が 255 文字より長くなるときは、切り詰めが起こるかもしれません。
クラスの外側や、クラス名が下線文字だけからできているときには、難号化加工は起こりません。
.. % Private Variables
.. % % There is limited support for class-private
.. % % identifiers. Any identifier of the form \code{__spam} (at least two
.. % % leading underscores, at most one trailing underscore) is now textually
.. % % replaced with \code{_classname__spam}, where \code{classname} is the
.. % % current class name with leading underscore(s) stripped. This mangling
.. % % is done without regard to the syntactic position of the identifier, so
.. % % it can be used to define class-private instance and class variables,
.. % % methods, variables stored in globals, and even variables stored in instances.
.. % % private to this class on instances of \emph{other} classes. Truncation
.. % % may occur when the mangled name would be longer than 255 characters.
.. % % Outside classes, or when the class name consists of only underscores,
.. % % no mangling occurs.
名前の難号化は、クラスにおいて、 "プライベートな" インスタンス変数やメソッドを定義する際に、導出クラスで定義されるインスタンス変数を気に
したり、クラスの外側のコードからインスタンス変数をいじりまわすことがないように簡単に定義できるようにするためのものです。
難号化の規則は主に不慮の事故を防ぐためのものだということに注意してください; 確信犯的な方法で、プライベートとされている変数にアクセス
したり変更することは依然として可能なのです。デバッガのような特殊な状況では、この仕様は便利ですらあります。そのため、この抜け穴は塞がれていません。
(些細なバグ: 基底クラスと同じ名前のクラスを導出すると、基底クラスのプライベート変数を使えるようになります。)
.. % % Name mangling is intended to give classes an easy way to define
.. % % ``private'' instance variables and methods, without having to worry
.. % % about instance variables defined by derived classes, or mucking with
.. % % instance variables by code outside the class. Note that the mangling
.. % % rules are designed mostly to avoid accidents; it still is possible for
.. % % a determined soul to access or modify a variable that is considered
.. % % private. This can even be useful in special circumstances, such as in
.. % % the debugger, and that's one reason why this loophole is not closed.
.. % % (Buglet: derivation of a class with the same name as the base class
.. % % makes use of private variables of the base class possible.)
``exec`` や ``eval()`` や ``execfile()`` へ渡されたコードでは、
呼出し元のクラス名を現在のクラスと見なさないことに注意してください; この仕様は ``global`` 文の効果と似ており、その効果もまた同様に、
バイトコンパイルされたコードに制限されています。同じ制約が ``getattr()`` と ``setattr()`` と ``delattr()``
にも適用されます。また、 ``__dict__`` を直接参照するときにも適用されます。
.. % % Notice that code passed to \code{exec}, \code{eval()} or
.. % % \code{execfile()} does not consider the classname of the invoking
.. % % class to be the current class; this is similar to the effect of the
.. % % \code{global} statement, the effect of which is likewise restricted to
.. % % code that is byte-compiled together. The same restriction applies to
.. % % \code{getattr()}, \code{setattr()} and \code{delattr()}, as well as
.. % % when referencing \code{__dict__} directly.
.. _tut-odds:
残りのはしばし
==============
Pascal の "レコード (record)" や、C 言語の "構造体 (struct)" のような、名前つきのデータ要素を一まとめにするデータ型があると
便利なことがたまにあります。空のクラス定義を使うとうまくできます:
.. % Odds and Ends
.. % % Sometimes it is useful to have a data type similar to the Pascal
.. % % ``record'' or C ``struct'', bundling together a few of named data
.. % % items. An empty class definition will do nicely:
::
class Employee:
pass
john = Employee() # 空の従業員レコードを造る
# Fill the fields of the record
john.name = 'John Doe'
john.dept = 'computer lab'
john.salary = 1000
ある特定の抽象データ型を要求する Python コードの断片には、そのデータ型のメソッドをエミュレーションするクラスを代わりに渡す
ことができます。例えば、ファイルオブジェクトから何らかのデータを書式化する関数がある場合、 :meth:`read` と :meth:`readline`
を持つクラスを定義して、ファイルではなく文字列バッファからデータを書式するようにしておき、引数として渡すことができます。
(残念なことに、このテクニックには限界があります: クラスにはシーケンスの添字アクセスや算術演算などの特殊構文でアクセスされる操作が定義できず、"疑似ファイル" を sys.stdin に代入してもそこからインタープリタに入力データを読み込ませることはできません。)
.. % % A piece of Python code that expects a particular abstract data type
.. % % can often be passed a class that emulates the methods of that data
.. % % type instead. For instance, if you have a function that formats some
.. % % data from a file object, you can define a class with methods
.. % % \method{read()} and \method{readline()} that gets the data from a string
.. % % buffer instead, and pass it as an argument.
.. % (Unfortunately, this
.. % technique has its limitations: a class can't define operations that
.. % are accessed by special syntax such as sequence subscripting or
.. % arithmetic operators, and assigning such a ``pseudo-file'' to
.. % \code{sys.stdin} will not cause the interpreter to read further input
.. % from it.)
インスタンスメソッドオブジェクトにもまた、属性があります: ``m.im_self`` はメソッド :meth:`m` の属しているインスタンスオブジェクトで、
``m.im_func`` はメソッドに対応する関数オブジェクトです。
.. % % Instance method objects have attributes, too: \code{m.im_self} is the
.. % % instance object with the method \method{m}, and \code{m.im_func} is the
.. % % function object corresponding to the method.
.. _tut-exceptionclasses:
例外はクラスであってもよい
--------------------------
ユーザ定義の例外をクラスとして識別することもできます。このメカニズムを使って、拡張可能な階層化された例外を作成することができます。
.. % Exceptions Can Be Classes
.. % % User-defined exceptions are identified by classes as well. Using this
.. % % mechanism it is possible to create extensible hierarchies of exceptions.
新しく二つの (意味付け的な) 形式の raise 文ができました:
.. % % There are two new valid (semantic) forms for the raise statement:
::
raise Class, instance
raise instance
第一の形式では、 ``instance`` は :class:`Class` またはその導出クラスのインスタンスでなければなりません。第二の形式は以下の表記:
.. % % In the first form, \code{instance} must be an instance of
.. % % \class{Class} or of a class derived from it. The second form is a
.. % % shorthand for:
::
raise instance.__class__, instance
の短縮された記法です。
except 節には、文字列オブジェクトだけでなくクラスを並べることができます。 except 節のクラスは、同じクラスか基底クラスの例外のときに互換
(compatible) となります (逆方向では成り立ちません --- 導出クラスの例外がリストされている except
節は基底クラスの例外と互換ではありません)。例えば、次のコードは、 B, C, D を順序通りに出力します:
.. % % An except clause may list classes as well as string objects. A class
.. % % in an except clause is compatible with an exception if it is the same
.. % % class or a base class thereof (but not the other way around --- an
.. % % except clause listing a derived class is not compatible with a base
.. % % class). For example, the following code will print B, C, D in that
.. % % order:
::
class B:
pass
class C(B):
pass
class D(C):
pass
for c in [B, C, D]:
try:
raise c()
except D:
print "D"
except C:
print "C"
except B:
print "B"
except 節が逆に並んでいた場合 (``except B`` が最初にくる場合)、 B, B, B と出力されるはずだったことに注意してください ---
最初に一致した except 節が駆動されるのです。
.. % % Note that if the except clauses were reversed (with
.. % % \samp{except B} first), it would have printed B, B, B --- the first
.. % % matching except clause is triggered.
処理されないクラスの例外に対してエラーメッセージが出力されるとき、まずクラス名が出力され、続いてコロン、スペース、最後に組み込み関数 :func:`str`
を使って文字列に変換したインスタンスが出力されます。
.. % % When an error message is printed for an unhandled exception, the
.. % % exception's class name is printed, then a colon and a space, and
.. % % finally the instance converted to a string using the built-in function
.. % % \function{str()}.
.. % % \section{Iterators\label{iterators}}
.. _tut-iterators:
イテレータ (iterator)
=====================
すでに気づいているでしょうが、 ``for`` 文を使うとほとんどのコンテナオブジェクトにわたってループを行うことができます:
.. % % By now you have probably noticed that most container objects can looped over
.. % % using a \code{for} statement:
::
for element in [1, 2, 3]:
print element
for element in (1, 2, 3):
print element
for key in {'one':1, 'two':2}:
print key
for char in "123":
print char
for line in open("myfile.txt"):
print line
こうしたアクセス方法は明確で、簡潔で、かつ便利なものです。イテレータの使用は Python
全体に普及していて、統一性をもたらしています。背後では、 ``for`` 文はコンテナオブジェクトの :func:`iter` を呼び出しています。この関数は
:meth:`next` メソッドの定義されたイテレータオブジェクトを返します。 :meth:`next`
メソッドは一度コンテナ内の要素に一度に一つづつアクセスします。コンテナ内にアクセスすべき要素がなくなると、 :meth:`next` は
:exc:`StopIteration` 例外を送出し、 ``for`` ループを終了させます。実際にどのように動作するかを以下の例に示します:
.. % % This style of access is clear, concise, and convenient. The use of iterators
.. % % pervades and unifies Python. Behind the scenes, the \code{for} statement calls
.. % % \function{iter()} on the container object. The function returns an iterator
.. % % object that defines the method \method{next()} which accesses elements in the
.. % % container one at a time. When there are no more elements, \method{next()}
.. % % raises a \exception{StopIteration} exception which tells the \code{for} loop
.. % % to terminate. This example shows how it all works:
::
>>> s = 'abc'
>>> it = iter(s)
>>> it
>>> it.next()
'a'
>>> it.next()
'b'
>>> it.next()
'c'
>>> it.next()
Traceback (most recent call last):
File "", line 1, in ?
it.next()
StopIteration
イテレータプロトコルの背後にあるメカニズムを一度目にすれば、自作のクラスにイテレータとしての振る舞いを追加するのは簡単です。 :meth:`__iter__`
メソッドを定義して、 :meth:`next` メソッドを持つオブジェクトを返すようにしてください。クラス自体で :meth:`next`
を定義している場合、 :meth:`__iter__` では単に ``self`` を返すようにできます:
.. % % Having seen the mechanics behind the iterator protocol, it is easy to add
.. % % iterator behavior to your classes. Define a \method{__iter__()} method
.. % % which returns an object with a \method{next()} method. If the class defines
.. % % \method{next()}, then \method{__iter__()} can just return \code{self}:
::
class Reverse:
"Iterator for looping over a sequence backwards"
def __init__(self, data):
self.data = data
self.index = len(data)
def __iter__(self):
return self
def next(self):
if self.index == 0:
raise StopIteration
self.index = self.index - 1
return self.data[self.index]
>>> for char in Reverse('spam'):
... print char
...
m
a
p
s
.. % % \section{Generators\label{generators}}
.. _tut-generators:
ジェネレータ (generator)
========================
:term:`Generator` は、イテレータを作成するための簡潔で強力なツールです。ジェネレータは通常の関数のように書かれますが、何らかのデータを返すときには
:keyword:`yield` 文を使います。 :meth:`next` が呼び出されるたびに、ジェネレータは以前に中断した処理を再開します
(ジェネレータは、全てのデータ値と最後にどの文が実行されたかを記憶しています)。以下の例を見れば、ジェネレータがとても簡単に作成できることがわかります:
.. % % Generators are a simple and powerful tool for creating iterators. They are
.. % % written like regular functions but use the \keyword{yield} statement whenever
.. % % they want to return data. Each time the \method{next()} is called, the
.. % % generator resumes where it left-off (it remembers all the data values and
.. % % which statement was last executed). An example shows that generators can
.. % % be trivially easy to create:
::
def reverse(data):
for index in range(len(data)-1, -1, -1):
yield data[index]
>>> for char in reverse('golf'):
... print char
...
f
l
o
g
ジェネレータを使ってできることは、前節で記述したクラスに基づいたイテレータを使えばできます。ジェネレータを使うとコンパクトに記述できるのは、
:meth:`__iter__` と :meth:`next` メソッドが自動的に作成されるからです。
.. % % Anything that can be done with generators can also be done with class based
.. % % iterators as described in the previous section. What makes generators so
.. % % compact is that the \method{__iter__()} and \method{next()} methods are
.. % % created automatically.
ジェネレータのもう一つの重要な機能は、呼び出しごとにローカル変数と実行状態が自動的に保存されるということです。これにより、 ``self.index`` や
``self.data`` といったインスタンス変数を使ったアプローチよりも簡単に関数を書くことができるようになります。
.. % % Another key feature is that the local variables and execution state
.. % % are automatically saved between calls. This made the function easier to write
.. % % and much more clear than an approach using instance variables like
.. % % \code{self.index} and \code{self.data}.
メソッドを自動生成したりプログラムの実行状態を自動保存するほかに、ジェネレータは終了時に自動的に :exc:`StopIteration` を送出します。
これらの機能を組み合わせると、通常の関数を書くのに比べ、全く苦労することなく簡単にイテレータを生成できます。
.. % % In addition to automatic method creation and saving program state, when
.. % % generators terminate, they automatically raise \exception{StopIteration}.
.. % % In combination, these features make it easy to create iterators with no
.. % % more effort than writing a regular function.
.. _tut-genexps:
ジェネレータ式
==============
単純なジェネレータなら、式を使って簡潔にコードする方法があります。リスト内包に似た構文の式ですが、各括弧ではなく丸括弧を使います。
ジェネレータ式は、関数の中でジェネレータをすぐに使いたいような状況のために用意されています。ジェネレータ式はコンパクトですが、
完全なジェネレータに比べてちょっと融通の効かないところがあります。同じ内容を返すリスト内包よりはメモリに優しいことが多いという利点もあります。
.. % Generator Expressions
.. % Some simple generators can be coded succinctly as expressions using a syntax
.. % similar to list comprehensions but with parentheses instead of brackets. These
.. % expressions are designed for situations where the generator is used right
.. % away by an enclosing function. Generator expressions are more compact but
.. % less versatile than full generator definitions and tend to be more memory
.. % friendly than equivalent list comprehensions.
例::
>>> sum(i*i for i in range(10)) # 平方和を求める
285
>>> xvec = [10, 20, 30]
>>> yvec = [7, 5, 3]
>>> sum(x*y for x,y in zip(xvec, yvec)) # 内積を求める
260
>>> from math import pi, sin
>>> sine_table = dict((x, sin(x*pi/180)) for x in range(0, 91))
>>> unique_words = set(word for line in page for word in line.split())
>>> valedictorian = max((student.gpa, student.name) for student in graduates)
>>> data = 'golf'
>>> list(data[i] for i in range(len(data)-1,-1,-1))
['f', 'l', 'o', 'g']
.. rubric:: Footnotes
.. [#] 例外が一つあります。モジュールオブジェクトには、秘密の読取り専用の属性 :attr:`__dict__`
があり、モジュールの名前空間を実装するために使われている辞書を返します; :attr:`__dict__` という名前は属性ですが、グローバルな名前では
ありません。この属性を利用すると名前空間の実装に対する抽象化を侵すことになるので、プログラムを検死するデバッガのような用途に限るべきです。
Python-2.6.2-DocJa-1/_sources/tutorial/whatnow.txt 0000644 0001750 0001750 00000010743 11474251541 021444 0 ustar inada-n inada-n .. _tut-whatnow:
**********
さあ何を？
**********
このチュートリアルを読んだことで、おそらく Python を使ってみようという関心はますます強くなったことでしょう --- 現実世界の問題を解決
するために、Python を適用してみたくなったはずです。さて、それではどこで勉強をしたらよいのでしょうか？
.. % What Now?
.. % % Reading this tutorial has probably reinforced your interest in using
.. % % Python --- you should be eager to apply Python to solving your
.. % % real-world problems. Where should you go to learn more?
このチュートリアルはPythonのドキュメンテーションセットの一部です。 セットの中の他のドキュメンテーションをいくつか紹介します:
.. % % Some other documents in the set are:
* :ref:`library-index`:
このマニュアルをざっと眺めておくと便利です。このマニュアルは型、関数、標準ライブラリのモジュールについての完全なリファレンスです。
標準的なPython配布物は *たくさんの* 追加コードを含んでいます。 Unix メールボックスの読み込み、HTTPによるドキュメント取得、
乱数の生成、コマンドラインオプションの構文解析、CGIプログラムの作成、データ圧縮やその他たくさんのタスクのためのモジュールがあります。
ライブラリリファレンスをざっと見ることで、何が利用できるかのイメージをつかむことができます。
* :ref:`install-index` は、他のPythonユーザによって書かれた外部モジュールを
どうやってインストールするかを説明しています。
* :ref:`reference-index`: Pythonの文法とセマンティクスを詳しく説明しています。
読むのは大変ですが、言語の完全なガイドとして有用です。
More Python resources:
* http://www.python.org: メインの Python Web サイト。このサイトには、コード、ドキュメント、そして Web
のあちこちの Python に関連したページへのポインタがあります。この Web サイトは世界のあちこちのさまざまな場所、例えばヨーロッパ、
日本、オーストラリアなどでミラーされています。地理的な位置によっては、メインのサイトよりミラーのほうが速いかもしれません。
* http://docs.python.org: Pythonドキュメントへの素早いアクセスを提供します。
* http://pypi.python.org: Python パッケージインデックス、愛称はCheese Shopです。
ユーザ作成のダウンロードできるPythonモジュール索引です。コードのリリースをしたら、ここに登録することで他の人が見つけられます。
* http://aspn.activestate.com/ASPN/Python/Cookbook/: Python
クックブックはコード例、モジュール、実用的なスクリプトの巨大なコレクションです。主要なものは同名の本Python Cookbook (O'Reilly &
Associates, ISBN 0-596-00797-3.)に収録されています。
Python に関する質問をしたり、問題を報告するために、ニュースグループ :newsgroup:`comp.lang.python` に投稿したり、
python-list@python.org のメーリングリストに送信することができます。ニュースグループとメーリングリストは相互接続されて
いるので、どちらかにポストされたメッセージは自動的にもう一方にも転送されます。一日に約 120 通程度、質問を
(そしてその解凍)、新機能の提案、新たなモジュールのアナウンスが投稿されています。投稿する前に、必ず `よく出される質問
`_ (Frequently Asked Questions, FAQ とも言います)
のリストを確認するか、Python ソースコード配布物の :file:`Misc/` ディレクトリを探すようにしてください。メーリングリストのアーカイブは
http://mail.python.org/pipermail/ で入手することができます。 FAQ
では、何度も繰り返し現れる質問の多くに答えています。読者の抱えている問題に対する解答がすでに入っているかもしれません。
.. Postings figure based on average of last six months activity as
reported by www.egroups.com; Jan. 2000 - June 2000: 21272 msgs / 182
days = 116.9 msgs / day and steadily increasing. (XXX up to date figures?)
Python-2.6.2-DocJa-1/_sources/tutorial/controlflow.txt 0000644 0001750 0001750 00000065351 11474251537 022337 0 ustar inada-n inada-n .. _tut-morecontrol:
************************
その他の制御フローツール
************************
今しがた紹介した :keyword:`while` 文の他に、Python
では他の言語でおなじみの普通の制御フロー文を備えていますが、これらには多少ひねりを加えてあります。
.. _tut-if:
:keyword:`if` 文
================
おそらく最もおなじみの文型は :keyword:`if` 文でしょう。例えば、
::
>>> x = int(raw_input("Please enter an integer: "))
Please enter an integer: 42
>>> if x < 0:
... x = 0
... print 'Negative changed to zero'
... elif x == 0:
... print 'Zero'
... elif x == 1:
... print 'Single'
... else:
... print 'More'
...
More
ゼロ個以上の :keyword:`elif` 部を使うことができ、 :keyword:`else` 部を付けることもできます。
キーワード ':keyword:`elif`' は 'else if' を短くしたもので、過剰なインデントを避けるのに役立ちます。
一連の :keyword:`if` ... :keyword:`elif` ... :keyword:`elif` ... は、他の言語における ``switch`` 文や ``case`` 文の代用となります。
.. _tut-for:
:keyword:`for` 文
=================
.. index::
statement: for
statement: for
Python の :keyword:`for` 文は、読者が C 言語や Pascal 言語で使いなれているかもしれない :keyword:`for`
文とは少し違います。 (Pascal のように) 常に算術型の数列にわたる反復を行ったり、 (C のように)
繰返しステップと停止条件を両方ともユーザが定義できるようにするのとは違い、Python の :keyword:`for` 文は、任意のシーケンス型
(リストまたは文字列) にわたって反復を行います。反復の順番はシーケンス中に要素が現れる順番です。
例えば、
::
>>> # いくつかの文字列の長さを測る:
... a = ['cat', 'window', 'defenestrate']
>>> for x in a:
... print x, len(x)
...
cat 3
window 6
defenestrate 12
反復操作の対象になっているシーケンスをループので書き換える操作 (リストのような、変更可能 (mutable) なシーケンス型でおきます) は、安全
ではありません。もし反復処理を行う対象とするリスト型を変更したいのなら、 (対象の要素を複製するなどして) コピーに対して反復を行わなければ
なりません。この操作にはスライス表記を使うと特に便利です:
::
>>> for x in a[:]: # リスト全体のスライス・コピーを作る
... if len(x) > 6: a.insert(0, x)
...
>>> a
['defenestrate', 'cat', 'window', 'defenestrate']
.. _tut-range:
:func:`range` 関数
==================
数列にわたって反復を行う必要がある場合、組み込み関数 :func:`range` が便利です。この関数は算術型の数列が入ったリストを生成します。
::
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
指定した終端値は生成されるリストには入りません。 ``range(10)`` は 10 個の値からなるリストを生成し、長さ 10
のシーケンスにおける各項目のインデクスとなります。 range を別の数から開始したり、他の増加量 (負の増加量でさえも; 増加量は時に
'ステップ(step)' と呼ばれることもあります) を指定することもできます:
::
>>> range(5, 10)
[5, 6, 7, 8, 9]
>>> range(0, 10, 3)
[0, 3, 6, 9]
>>> range(-10, -100, -30)
[-10, -40, -70]
あるシーケンスにわたってインデクスで反復を行うには、 :func:`range` と :func:`len` を次のように組み合わせられます:
::
>>> a = ['Mary', 'had', 'a', 'little', 'lamb']
>>> for i in range(len(a)):
... print i, a[i]
...
0 Mary
1 had
2 a
3 little
4 lamb
しかし、多くの場合は :func:`enumerate` 関数を使う方が便利です。
:ref:`tut-loopidioms` を参照してください。
.. _tut-break:
:keyword:`break` 文と :keyword:`continue` 文とループの :keyword:`else` 節
==========================================================================
:keyword:`break` 文は、C 言語と同じく、最も内側の :keyword:`for` または :keyword:`while`
ループを中断します。
:keyword:`continue` 文は、これもまた C 言語から借りてきたものですが、ループを次の反復処理に飛ばします。
ループ文は :keyword:`else` 節を持つことができます; :keyword:`else` 節は、 (:keyword:`for` で)
反復処理対象のリストを使い切ってループが終了したとき、または (:keyword:`while` で) 条件が偽になったときに実行されますが、
:keyword:`break` 文でループが終了したときは実行されません。この動作を、素数を探す下記のループを例にとって示します:
::
>>> for n in range(2, 10):
... for x in range(2, n):
... if n % x == 0:
... print n, 'equals', x, '*', n/x
... break
... else:
... # 因数が見つからずにループが終了
... print n, 'is a prime number'
...
2 is a prime number
3 is a prime number
4 equals 2 * 2
5 is a prime number
6 equals 2 * 3
7 is a prime number
8 equals 2 * 4
9 equals 3 * 3
.. _tut-pass:
:keyword:`pass` 文
==================
:keyword:`pass` 文は何もしません。 :keyword:`pass` は、文を書くことが
構文上要求されているが、プログラム上何の動作もする必要がない時に使われます。
::
>>> while True:
... pass # キーボード割り込み (keyboard interrupt, Ctrl+C) をbusy-wait で待つ
...
これは最小のクラスを作るときによく使われる方法です::
>>> class MyEmptyClass:
... pass
...
:keyword:`pass` が使われるもう1つの場所は、新しいコードを書いている時の関数や条件文の中身です。
こうすることで、具体的なコードを書かないで抽象的なレベルで考えることができます。
:keyword:`pass` は何もすることなく無視されます::
>>> def initlog(*args):
... pass # 忘れずにここを実装すること!
...
.. _tut-functions:
関数を定義する
==============
フィボナッチ数列 (Fibonacci series) を任意の上限値まで書き出すような関数を作成できます:
::
>>> def fib(n): # n までのフィボナッチ級数を出力する
... """Print a Fibonacci series up to n."""
... a, b = 0, 1
... while b < n:
... print b,
... a, b = b, a+b
...
>>> # 今しがた定義した関数を呼び出す:
... fib(2000)
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
.. index::
single: documentation strings
single: docstrings
single: strings, documentation
:keyword:`def` は関数の *定義 (definition)* を導くキーワードです。 :keyword:`def` の後には、関数名と仮引数
(formal parameter) を丸括弧で囲んだリストを続けなければなりません。関数の実体を
校正する実行文は次の行から始め、インデントされていなければなりません。
関数の本体の記述する文の最初の行は文字列リテラルにすることもできます。
その場合、この文字列は関数のドキュメンテーション文字列 (documentation string)、または :dfn:`docstring` と呼ばれます。 (docstring については :ref:`tut-docstrings` でさらに扱っています。)
ドキュメンテーション文字列を使ったツールには、オンライン文書や印刷文書を自動的に生成したり、ユーザが対話的にコードを閲覧できるようにするものがあります;
自分が書くコードにドキュメンテーション文字列を入れるのはよい習慣です。書く癖をつけてください。
関数を *実行 (execution)* するとき、関数のローカル変数のために使われる新たなシンボルテーブル (symbol table) が用意されます。
もっと正確にいうと、関数内で変数への代入を行うと、その値はすべてこのローカルなシンボルテーブルに記憶されます。
一方、変数の参照を行うと、まずローカルなシンボルテーブルが検索され、次にさらに外側の関数 [#]_ のローカルなシンボルテーブルを検索し、その後グローバルなシンボルテーブルを調べ、最後に組み込みの名前テーブルを調べます。
従って、関数の中では、グローバルな変数を参照することはできますが、直接値を代入することは (:keyword:`global` 文で名前を挙げておかない限り)
できません。
関数を呼び出す際の実際のパラメタ (引数) は、関数が呼び出されるときに関数のローカルなシンボルテーブル内に取り込まれます; そうすることで、引数は
*値渡し (call by value)* で関数に渡されることになります (ここでの *値 (value)* とは常にオブジェクトへの *参照
(reference)* をいい、オブジェクトの値そのものではありません) [#]_ 。ある関数がほかの関数を呼び出すときには、新たな呼び出しのために
ローカルなシンボルテーブルが新たに作成されます。
関数の定義を行うと、関数名は現在のシンボルテーブル内に取り入れられます。関数名の値は、インタプリタからはユーザ定義関数 (user-defined
function) として認識される型を持ちます。この値は別の名前に代入して、その名前を後に関数として使うこともできます。
これは一般的な名前変更のメカニズムとして働きます。
::
>>> fib
>>> f = fib
>>> f(100)
1 1 2 3 5 8 13 21 34 55 89
他の言語出身の人からは、 ``fib`` は値を返さないので関数ではなく手続き (procedure) だと異論があるかもしれませんね。
技術的に言えば、実際には手続きもややつまらない値ですが値を返しています。この値は ``None`` と呼ばれます
(これは組み込みの名前です)。 ``None`` だけを書き出そうとすると、インタプリタは通常出力を抑制します。
本当に出力したいのなら、以下のように :keyword:`print` を使うと見ることができます:
::
>>> fib(0)
>>> print fib(0)
None
フィボナッチ数列の数からなるリストを出力する代わりに、値を返すような関数を書くのは簡単です:
::
>>> def fib2(n): # n までのフィボナッチ級数を返す
... """Return a list containing the Fibonacci series up to n."""
... result = []
... a, b = 0, 1
... while b < n:
... result.append(b) # 下記参照
... a, b = b, a+b
... return result
...
>>> f100 = fib2(100) # 関数を呼び出す
>>> f100 # 結果を出力する
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
例によって、この例は Python の新しい機能を示しています:
* :keyword:`return` 文では、関数から一つ値を返します。 :keyword:`return` の引数となる式がない場合、 ``None``
が返ります。関数が終了したときにも ``None`` が返ります。
* 文 ``result.append(b)`` では、リストオブジェクト ``result`` の *メソッド (method)* を呼び出しています。
メソッドとは、オブジェクトに '属している' 関数のことで、 ``obj`` を何らかのオブジェクト (式であっても構いません)、 ``methodname``
をそのオブジェクトで定義されているメソッド名とすると、 ``obj.methodname`` と書き表されます。
異なる型は異なるメソッドを定義しています。異なる型のメソッドで同じ名前のメソッドを持つことができ、あいまいさを生じることはありません。
(自前のオブジェクト型とメソッドを定義することもできます。これには、後でこのチュートリアルで述べる *クラス (class)* を使います。)
例で示されているメソッド :meth:`append` は、リストオブジェクトで定義されています; このメソッドはリストの末尾に新たな要素を追加します。
この例での :meth:`append` は ``result = result + [b]`` と等価ですが、より効率的です。
.. _tut-defining:
関数定義についてもう少し
========================
可変個の引数を伴う関数を定義することもできます。引数の定義方法には 3 つの形式があり、それらを組み合わせることができます。
.. _tut-defaultargs:
デフォルトの引数値
------------------
もっとも便利なのは、一つ以上の引数に対してデフォルトの値を指定する形式です。この形式を使うと、定義されている引数より少ない個数の引数
で呼び出せる関数を作成します:
::
def ask_ok(prompt, retries=4, complaint='Yes or no, please!'):
while True:
ok = raw_input(prompt)
if ok in ('y', 'ye', 'yes'): return True
if ok in ('n', 'no', 'nop', 'nope'): return False
retries = retries - 1
if retries < 0: raise IOError, 'refusenik user'
print complaint
この関数は、 ``ask_ok('Do you really want to quit?')`` のようにも、 ``ask_ok('OK to
overwrite the file?', 2)`` のようにも呼び出すことができます。
デフォルト値は、関数が定義された時点で、関数を *定義している* 側のスコープ (scope) で評価されるので、
::
i = 5
def f(arg=i):
print arg
i = 6
f()
は ``5`` を出力します。
**重要な警告:** デフォルト値は 1 度だけしか評価されません。デフォルト値がリストや辞書のような変更可能なオブジェクトの時には
その影響がでます。例えば以下の関数は、後に続く関数呼び出しで関数に渡されている引数を累積します:
::
def f(a, L=[]):
L.append(a)
return L
print f(1)
print f(2)
print f(3)
このコードは、
::
[1]
[1, 2]
[1, 2, 3]
を出力します。
後続の関数呼び出しでデフォルト値を共有したくなければ、代わりに以下のように関数を書くことができます:
::
def f(a, L=None):
if L is None:
L = []
L.append(a)
return L
.. _tut-keywordargs:
キーワード引数
--------------
関数を ``keyword = value`` という形式のキーワード引数を使って呼び出すこともできます。例えば、以下の関数:
::
def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
print "-- This parrot wouldn't", action,
print "if you put", voltage, "volts through it."
print "-- Lovely plumage, the", type
print "-- It's", state, "!"
は、以下のいずれの方法でも呼び出せます:
::
parrot(1000)
parrot(action = 'VOOOOOM', voltage = 1000000)
parrot('a thousand', state = 'pushing up the daisies')
parrot('a million', 'bereft of life', 'jump')
しかし、以下の呼び出しはすべて不正なものです:
::
parrot() # 必要な引数がない
parrot(voltage=5.0, 'dead') # キーワード引数の後に非キーワード引数がある
parrot(110, voltage=220) # 引数に対して値が重複している
parrot(actor='John Cleese') # 未知のキーワードを使用している
一般に、引数リストでは、固定引数 (positional argument) の後ろにキーワード引数を置かねばならず、キーワードは仮引数名から選ばなければ
なりません。仮引数がデフォルト値を持っているかどうかは重要ではありません。引数はいずれも一つ以上の値を受け取りません ---
同じ関数呼び出しの中では、固定引数に対応づけられた仮引数名をキーワードとして使うことはできません。この制限のために実行が失敗する例を以下に示します。
::
>>> def function(a):
... pass
...
>>> function(0, a=0)
Traceback (most recent call last):
File "", line 1, in ?
TypeError: function() got multiple values for keyword argument 'a'
仮引数の最後に ``**name`` の形式のものがあると、それまでの仮引数に対応したものをのぞくすべてのキーワード引数が入った辞書 (
:ref:`typesmapping` を参照) を受け取ります。
``**name`` は ``*name`` の形式をとる、仮引数のリストを超えた固定引数の入ったタプルを受け取る引数 (次の節で述べます) と組み合わせることができます。 (``*name`` は
``**name`` より前になければなりません)。例えば、ある関数の定義を以下:
::
def cheeseshop(kind, *arguments, **keywords):
print "-- Do you have any", kind, "?"
print "-- I'm sorry, we're all out of", kind
for arg in arguments: print arg
print "-" * 40
keys = keywords.keys()
keys.sort()
for kw in keys: print kw, ":", keywords[kw]
のようにすると、呼び出しは以下:
::
cheeseshop("Limburger", "It's very runny, sir.",
"It's really very, VERY runny, sir.",
shopkeeper="Michael Palin",
client="John Cleese",
sketch="Cheese Shop Sketch")
のようになり、もちろん以下のように出力されます:
::
-- Do you have any Limburger ?
-- I'm sorry, we're all out of Limburger
It's very runny, sir.
It's really very, VERY runny, sir.
----------------------------------------
client : John Cleese
shopkeeper : Michael Palin
sketch : Cheese Shop Sketch
キーワード引数名のリストに対して :meth:`sort` を呼び出した後に ``keywords`` 辞書の内容を出力していることに注意してください;
:meth:`sort` が呼び出されていないと、引数が出力される順番は不確定となります。
.. _tut-arbitraryargs:
任意引数リスト
--------------
.. index::
statement: *
最後に、最も使うことの少ない選択肢として、関数が任意の個数の引数で呼び出せるよう指定する方法があります。これらの引数はタプル (:ref:`tut-tuples` を参照) に
格納されます。可変個の引数の前に、ゼロ個かそれ以上の引数があっても構いません。
::
def write_multiple_items(file, separator, *args):
file.write(separator.join(args))
.. _tut-unpacking-arguments:
引数リストのアンパック
----------------------
引数がすでにリストやタプルになっていて、個別な固定引数を要求する関数呼び出しに渡すためにアンパックする必要がある場合には、逆の状況が起こります。
例えば、組み込み関数 :func:`range` は引数 *start* と *stop* を別に与える必要があります。
個別に引数を与えることができない場合、関数呼び出しを ``*`` 演算子を使って書き、リストやタプルから引数をアンパックします。
::
>>> range(3, 6) # 個別の引数を使った通常の呼び出し
[3, 4, 5]
>>> args = [3, 6]
>>> range(*args) # リストからアンパックされた引数での呼び出し
[3, 4, 5]
.. index::
statement: **
同じやりかたで、 ``**`` オペレータを使って辞書でもキーワード引数を渡すことができます。
::
>>> def parrot(voltage, state='a stiff', action='voom'):
... print "-- This parrot wouldn't", action,
... print "if you put", voltage, "volts through it.",
... print "E's", state, "!"
...
>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
>>> parrot(**d)
-- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !
.. _tut-lambda:
ラムダ式
---------
多くの人の要望により、Lispのような関数型プログラミング言語によくあるいくつかの機能が Python に加えられました。キーワード
:keyword:`lambda` を使うと、名前のない小さな関数を生成できます。例えば ``lambda a, b: a+b``
は、二つの引数の和を返す関数です。ラムダ式(lambda form) は、関数オブジェクトが要求されている場所にならどこでも使うことができます。ラムダ式は、構文上単一の式に制限されています。
意味付け的には、ラムダ形式はただ通常の関数に構文的な糖衣をかぶせたものに過ぎません。入れ子構造になった関数定義と同様、ラムダ式もそれを取り囲むスコープから変数を参照することができます。
::
>>> def make_incrementor(n):
... return lambda x: x + n
...
>>> f = make_incrementor(42)
>>> f(0)
42
>>> f(1)
43
.. _tut-docstrings:
ドキュメンテーション文字列
--------------------------
.. index::
single: docstrings
single: documentation strings
single: strings, documentation
ドキュメンテーション文字列については、その内容と書式に関する慣習ができつつあります。
最初の行は、常に対象物の目的を短く簡潔にまとめたものでなくてはなりません。簡潔に書くために、対象物の名前や型を明示する必要はありません。
名前や型は他の方法でも得られるからです (名前がたまたま関数の演算内容を記述する動詞である場合は例外です)。
最初の行は大文字で始まり、ピリオドで終わっていなければなりません。
ドキュメンテーション文字列中にさらに記述すべき行がある場合、二行目は空行にし、まとめの行と残りの記述部分を視覚的に分離
します。つづく行は一つまたはそれ以上の段落で、対象物の呼び出し規約や副作用について記述します。
Python のパーザは複数行にわたる Python 文字列リテラルからインデントを剥ぎ取らないので、ドキュメントを処理するツールでは必要に応じて
インデントを剥ぎ取らなければなりません。この処理は以下の規約に従って行います。最初の行の *後にある* 空行でない最初の行が、ドキュメント
全体のインデントの量を決めます。 (最初の行は通常、文字列を開始するクオートに隣り合っているので、インデントが文字列リテラル中に現れないためです。)
このインデント量と "等価な" 空白が、文字列のすべての行頭から剥ぎ取られます。インデントの量が少ない行を書いてはならないの
ですが、もしそういう行があると、先頭の空白すべてが剥ぎ取られます。インデントの空白の大きさが等しいかどうかは、タブ文字を (通常は 8 文字の
スペースとして) 展開した後に調べられます。
以下に複数行のドキュメンテーション文字列の例を示します:
::
>>> def my_function():
... """Do nothing, but document it.
...
... No, really, it doesn't do anything.
... """
... pass
...
>>> print my_function.__doc__
Do nothing, but document it.
No, really, it doesn't do anything.
.. _tut-codingstyle:
間奏曲: コーディングスタイル
============================
.. sectionauthor:: Georg Brandl
.. index:: pair: coding; style
これからより長くより複雑な Python のコードを書いていくので、そろそろ *コーディングスタイル* について語っても良い頃です。
ほとんどの言語は様々なスタイルで書け (もっと簡潔に言えば *フォーマットでき*)、スタイルによって読み易さが異なります。
他人にとって読み易いコードにしようとするのはどんなときでも良い考えであり、良いコーディングスタイルを採用することが非常に強力な助けになります。
Python には、ほとんどのプロジェクトが守っているスタイルガイドとして :pep:`8` があります; それは非常に読み易く目に優しいコーディングスタイルを推奨しています。
全ての Python 開発者はある時点でそれを読むべきです; ここに最も重要な点を抜き出しておきます:
* インデントには空白 4 つを使い、タブは使わないこと。
空白 4 つは (深くネストできる) 小さいインデントと (読み易い) 大きいインデントのちょうど中間に当たります。タブは混乱させるので、使わずにおくのが良いです。
* ソースコードの幅が 79 文字を越えないように行を折り返すこと。
こうすることで小さいディスプレイを使っているユーザも読み易くなり、大きなディスプレイではソースコードファイルを並べることもできるようになります。
* 関数やクラスや関数内の大きめのコードブロックの区切りに空行を使いなさい。
* 可能なら、コメントはコードと同じ行に書きなさい。
* docstring を使いなさい。
* 演算子の前後とコンマの後には空白を入れ、括弧類のすぐ内側には空白を入れないこと: ``a = f(1, 2) + g(3, 4)``
* クラスや関数に一貫性のある名前を付けなさい; 慣習では ``CamelCase`` をクラス名に使い、 ``lower_case_with_underscores`` を関数名やメソッド名に使います。常に ``self`` をメソッドの第 1 引数の名前 (クラスやメソッドについては :ref:`tut-firstclasses` を見よ) として使いなさい。
* あなたのコードを世界中で使ってもらうつもりなら、風変りなエンコーディングは使わないこと。どんな場合でも ASCII が最も上手くいきます。
.. rubric:: 脚注
.. [#] 訳注: Pythonでは関数内で関数を定義することができ、内側の関数から外側の関数のローカル変数を参照することができます。
.. [#] 実際には、 *オブジェクトへの参照渡し (call by object reference)*
と書けばよいのかもしれません。というのは、変更可能なオブジェクトが渡されると、関数の呼び出し側は、呼び出された側の関数がオブジェクトに
(リストに値が挿入されるといった) 何らかの変更に出くわすことになるからです。
Python-2.6.2-DocJa-1/_sources/contents.txt 0000644 0001750 0001750 00000000650 11474251602 017741 0 ustar inada-n inada-n %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Python Documentation contents
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
.. toctree::
whatsnew/index.rst
tutorial/index.rst
using/index.rst
reference/index.rst
library/index.rst
extending/index.rst
c-api/index.rst
distutils/index.rst
install/index.rst
documenting/index.rst
howto/index.rst
glossary.rst
about.rst
bugs.rst
copyright.rst
license.rst
Python-2.6.2-DocJa-1/_sources/howto/ 0000755 0001750 0001750 00000000000 11477163231 016505 5 ustar inada-n inada-n Python-2.6.2-DocJa-1/_sources/howto/curses.txt 0000644 0001750 0001750 00000052741 11476415457 020574 0 ustar inada-n inada-n .. _curses-howto:
*****************************************
Curses Programming with Python (英語)
*****************************************
:Author: A.M. Kuchling, Eric S. Raymond
:Release: 2.03
.. topic:: Abstract
This document describes how to write text-mode programs with Python 2.x, using
the :mod:`curses` extension module to control the display.
What is curses?
===============
The curses library supplies a terminal-independent screen-painting and
keyboard-handling facility for text-based terminals; such terminals include
VT100s, the Linux console, and the simulated terminal provided by X11 programs
such as xterm and rxvt. Display terminals support various control codes to
perform common operations such as moving the cursor, scrolling the screen, and
erasing areas. Different terminals use widely differing codes, and often have
their own minor quirks.
In a world of X displays, one might ask "why bother"? It's true that
character-cell display terminals are an obsolete technology, but there are
niches in which being able to do fancy things with them are still valuable. One
is on small-footprint or embedded Unixes that don't carry an X server. Another
is for tools like OS installers and kernel configurators that may have to run
before X is available.
The curses library hides all the details of different terminals, and provides
the programmer with an abstraction of a display, containing multiple
non-overlapping windows. The contents of a window can be changed in various
ways-- adding text, erasing it, changing its appearance--and the curses library
will automagically figure out what control codes need to be sent to the terminal
to produce the right output.
The curses library was originally written for BSD Unix; the later System V
versions of Unix from AT&T added many enhancements and new functions. BSD curses
is no longer maintained, having been replaced by ncurses, which is an
open-source implementation of the AT&T interface. If you're using an
open-source Unix such as Linux or FreeBSD, your system almost certainly uses
ncurses. Since most current commercial Unix versions are based on System V
code, all the functions described here will probably be available. The older
versions of curses carried by some proprietary Unixes may not support
everything, though.
No one has made a Windows port of the curses module. On a Windows platform, try
the Console module written by Fredrik Lundh. The Console module provides
cursor-addressable text output, plus full support for mouse and keyboard input,
and is available from http://effbot.org/zone/console-index.htm.
The Python curses module
------------------------
Thy Python module is a fairly simple wrapper over the C functions provided by
curses; if you're already familiar with curses programming in C, it's really
easy to transfer that knowledge to Python. The biggest difference is that the
Python interface makes things simpler, by merging different C functions such as
:func:`addstr`, :func:`mvaddstr`, :func:`mvwaddstr`, into a single
:meth:`addstr` method. You'll see this covered in more detail later.
This HOWTO is simply an introduction to writing text-mode programs with curses
and Python. It doesn't attempt to be a complete guide to the curses API; for
that, see the Python library guide's section on ncurses, and the C manual pages
for ncurses. It will, however, give you the basic ideas.
Starting and ending a curses application
========================================
Before doing anything, curses must be initialized. This is done by calling the
:func:`initscr` function, which will determine the terminal type, send any
required setup codes to the terminal, and create various internal data
structures. If successful, :func:`initscr` returns a window object representing
the entire screen; this is usually called ``stdscr``, after the name of the
corresponding C variable. ::
import curses
stdscr = curses.initscr()
Usually curses applications turn off automatic echoing of keys to the screen, in
order to be able to read keys and only display them under certain circumstances.
This requires calling the :func:`noecho` function. ::
curses.noecho()
Applications will also commonly need to react to keys instantly, without
requiring the Enter key to be pressed; this is called cbreak mode, as opposed to
the usual buffered input mode. ::
curses.cbreak()
Terminals usually return special keys, such as the cursor keys or navigation
keys such as Page Up and Home, as a multibyte escape sequence. While you could
write your application to expect such sequences and process them accordingly,
curses can do it for you, returning a special value such as
:const:`curses.KEY_LEFT`. To get curses to do the job, you'll have to enable
keypad mode. ::
stdscr.keypad(1)
Terminating a curses application is much easier than starting one. You'll need
to call ::
curses.nocbreak(); stdscr.keypad(0); curses.echo()
to reverse the curses-friendly terminal settings. Then call the :func:`endwin`
function to restore the terminal to its original operating mode. ::
curses.endwin()
A common problem when debugging a curses application is to get your terminal
messed up when the application dies without restoring the terminal to its
previous state. In Python this commonly happens when your code is buggy and
raises an uncaught exception. Keys are no longer be echoed to the screen when
you type them, for example, which makes using the shell difficult.
In Python you can avoid these complications and make debugging much easier by
importing the module :mod:`curses.wrapper`. It supplies a :func:`wrapper`
function that takes a callable. It does the initializations described above,
and also initializes colors if color support is present. It then runs your
provided callable and finally deinitializes appropriately. The callable is
called inside a try-catch clause which catches exceptions, performs curses
deinitialization, and then passes the exception upwards. Thus, your terminal
won't be left in a funny state on exception.
Windows and Pads
================
Windows are the basic abstraction in curses. A window object represents a
rectangular area of the screen, and supports various methods to display text,
erase it, allow the user to input strings, and so forth.
The ``stdscr`` object returned by the :func:`initscr` function is a window
object that covers the entire screen. Many programs may need only this single
window, but you might wish to divide the screen into smaller windows, in order
to redraw or clear them separately. The :func:`newwin` function creates a new
window of a given size, returning the new window object. ::
begin_x = 20 ; begin_y = 7
height = 5 ; width = 40
win = curses.newwin(height, width, begin_y, begin_x)
A word about the coordinate system used in curses: coordinates are always passed
in the order *y,x*, and the top-left corner of a window is coordinate (0,0).
This breaks a common convention for handling coordinates, where the *x*
coordinate usually comes first. This is an unfortunate difference from most
other computer applications, but it's been part of curses since it was first
written, and it's too late to change things now.
When you call a method to display or erase text, the effect doesn't immediately
show up on the display. This is because curses was originally written with slow
300-baud terminal connections in mind; with these terminals, minimizing the time
required to redraw the screen is very important. This lets curses accumulate
changes to the screen, and display them in the most efficient manner. For
example, if your program displays some characters in a window, and then clears
the window, there's no need to send the original characters because they'd never
be visible.
Accordingly, curses requires that you explicitly tell it to redraw windows,
using the :func:`refresh` method of window objects. In practice, this doesn't
really complicate programming with curses much. Most programs go into a flurry
of activity, and then pause waiting for a keypress or some other action on the
part of the user. All you have to do is to be sure that the screen has been
redrawn before pausing to wait for user input, by simply calling
``stdscr.refresh()`` or the :func:`refresh` method of some other relevant
window.
A pad is a special case of a window; it can be larger than the actual display
screen, and only a portion of it displayed at a time. Creating a pad simply
requires the pad's height and width, while refreshing a pad requires giving the
coordinates of the on-screen area where a subsection of the pad will be
displayed. ::
pad = curses.newpad(100, 100)
# These loops fill the pad with letters; this is
# explained in the next section
for y in range(0, 100):
for x in range(0, 100):
try: pad.addch(y,x, ord('a') + (x*x+y*y) % 26 )
except curses.error: pass
# Displays a section of the pad in the middle of the screen
pad.refresh( 0,0, 5,5, 20,75)
The :func:`refresh` call displays a section of the pad in the rectangle
extending from coordinate (5,5) to coordinate (20,75) on the screen; the upper
left corner of the displayed section is coordinate (0,0) on the pad. Beyond
that difference, pads are exactly like ordinary windows and support the same
methods.
If you have multiple windows and pads on screen there is a more efficient way to
go, which will prevent annoying screen flicker at refresh time. Use the
:meth:`noutrefresh` method of each window to update the data structure
representing the desired state of the screen; then change the physical screen to
match the desired state in one go with the function :func:`doupdate`. The
normal :meth:`refresh` method calls :func:`doupdate` as its last act.
Displaying Text
===============
From a C programmer's point of view, curses may sometimes look like a twisty
maze of functions, all subtly different. For example, :func:`addstr` displays a
string at the current cursor location in the ``stdscr`` window, while
:func:`mvaddstr` moves to a given y,x coordinate first before displaying the
string. :func:`waddstr` is just like :func:`addstr`, but allows specifying a
window to use, instead of using ``stdscr`` by default. :func:`mvwaddstr` follows
similarly.
Fortunately the Python interface hides all these details; ``stdscr`` is a window
object like any other, and methods like :func:`addstr` accept multiple argument
forms. Usually there are four different forms.
+---------------------------------+-----------------------------------------------+
| Form | Description |
+=================================+===============================================+
| *str* or *ch* | Display the string *str* or character *ch* at |
| | the current position |
+---------------------------------+-----------------------------------------------+
| *str* or *ch*, *attr* | Display the string *str* or character *ch*, |
| | using attribute *attr* at the current |
| | position |
+---------------------------------+-----------------------------------------------+
| *y*, *x*, *str* or *ch* | Move to position *y,x* within the window, and |
| | display *str* or *ch* |
+---------------------------------+-----------------------------------------------+
| *y*, *x*, *str* or *ch*, *attr* | Move to position *y,x* within the window, and |
| | display *str* or *ch*, using attribute *attr* |
+---------------------------------+-----------------------------------------------+
Attributes allow displaying text in highlighted forms, such as in boldface,
underline, reverse code, or in color. They'll be explained in more detail in
the next subsection.
The :func:`addstr` function takes a Python string as the value to be displayed,
while the :func:`addch` functions take a character, which can be either a Python
string of length 1 or an integer. If it's a string, you're limited to
displaying characters between 0 and 255. SVr4 curses provides constants for
extension characters; these constants are integers greater than 255. For
example, :const:`ACS_PLMINUS` is a +/- symbol, and :const:`ACS_ULCORNER` is the
upper left corner of a box (handy for drawing borders).
Windows remember where the cursor was left after the last operation, so if you
leave out the *y,x* coordinates, the string or character will be displayed
wherever the last operation left off. You can also move the cursor with the
``move(y,x)`` method. Because some terminals always display a flashing cursor,
you may want to ensure that the cursor is positioned in some location where it
won't be distracting; it can be confusing to have the cursor blinking at some
apparently random location.
If your application doesn't need a blinking cursor at all, you can call
``curs_set(0)`` to make it invisible. Equivalently, and for compatibility with
older curses versions, there's a ``leaveok(bool)`` function. When *bool* is
true, the curses library will attempt to suppress the flashing cursor, and you
won't need to worry about leaving it in odd locations.
Attributes and Color
--------------------
Characters can be displayed in different ways. Status lines in a text-based
application are commonly shown in reverse video; a text viewer may need to
highlight certain words. curses supports this by allowing you to specify an
attribute for each cell on the screen.
An attribute is a integer, each bit representing a different attribute. You can
try to display text with multiple attribute bits set, but curses doesn't
guarantee that all the possible combinations are available, or that they're all
visually distinct. That depends on the ability of the terminal being used, so
it's safest to stick to the most commonly available attributes, listed here.
+----------------------+--------------------------------------+
| Attribute | Description |
+======================+======================================+
| :const:`A_BLINK` | Blinking text |
+----------------------+--------------------------------------+
| :const:`A_BOLD` | Extra bright or bold text |
+----------------------+--------------------------------------+
| :const:`A_DIM` | Half bright text |
+----------------------+--------------------------------------+
| :const:`A_REVERSE` | Reverse-video text |
+----------------------+--------------------------------------+
| :const:`A_STANDOUT` | The best highlighting mode available |
+----------------------+--------------------------------------+
| :const:`A_UNDERLINE` | Underlined text |
+----------------------+--------------------------------------+
So, to display a reverse-video status line on the top line of the screen, you
could code::
stdscr.addstr(0, 0, "Current mode: Typing mode",
curses.A_REVERSE)
stdscr.refresh()
The curses library also supports color on those terminals that provide it, The
most common such terminal is probably the Linux console, followed by color
xterms.
To use color, you must call the :func:`start_color` function soon after calling
:func:`initscr`, to initialize the default color set (the
:func:`curses.wrapper.wrapper` function does this automatically). Once that's
done, the :func:`has_colors` function returns TRUE if the terminal in use can
actually display color. (Note: curses uses the American spelling 'color',
instead of the Canadian/British spelling 'colour'. If you're used to the
British spelling, you'll have to resign yourself to misspelling it for the sake
of these functions.)
The curses library maintains a finite number of color pairs, containing a
foreground (or text) color and a background color. You can get the attribute
value corresponding to a color pair with the :func:`color_pair` function; this
can be bitwise-OR'ed with other attributes such as :const:`A_REVERSE`, but
again, such combinations are not guaranteed to work on all terminals.
An example, which displays a line of text using color pair 1::
stdscr.addstr( "Pretty text", curses.color_pair(1) )
stdscr.refresh()
As I said before, a color pair consists of a foreground and background color.
:func:`start_color` initializes 8 basic colors when it activates color mode.
They are: 0:black, 1:red, 2:green, 3:yellow, 4:blue, 5:magenta, 6:cyan, and
7:white. The curses module defines named constants for each of these colors:
:const:`curses.COLOR_BLACK`, :const:`curses.COLOR_RED`, and so forth.
The ``init_pair(n, f, b)`` function changes the definition of color pair *n*, to
foreground color f and background color b. Color pair 0 is hard-wired to white
on black, and cannot be changed.
Let's put all this together. To change color 1 to red text on a white
background, you would call::
curses.init_pair(1, curses.COLOR_RED, curses.COLOR_WHITE)
When you change a color pair, any text already displayed using that color pair
will change to the new colors. You can also display new text in this color
with::
stdscr.addstr(0,0, "RED ALERT!", curses.color_pair(1) )
Very fancy terminals can change the definitions of the actual colors to a given
RGB value. This lets you change color 1, which is usually red, to purple or
blue or any other color you like. Unfortunately, the Linux console doesn't
support this, so I'm unable to try it out, and can't provide any examples. You
can check if your terminal can do this by calling :func:`can_change_color`,
which returns TRUE if the capability is there. If you're lucky enough to have
such a talented terminal, consult your system's man pages for more information.
User Input
==========
The curses library itself offers only very simple input mechanisms. Python's
support adds a text-input widget that makes up some of the lack.
The most common way to get input to a window is to use its :meth:`getch` method.
:meth:`getch` pauses and waits for the user to hit a key, displaying it if
:func:`echo` has been called earlier. You can optionally specify a coordinate
to which the cursor should be moved before pausing.
It's possible to change this behavior with the method :meth:`nodelay`. After
``nodelay(1)``, :meth:`getch` for the window becomes non-blocking and returns
``curses.ERR`` (a value of -1) when no input is ready. There's also a
:func:`halfdelay` function, which can be used to (in effect) set a timer on each
:meth:`getch`; if no input becomes available within a specified
delay (measured in tenths of a second), curses raises an exception.
The :meth:`getch` method returns an integer; if it's between 0 and 255, it
represents the ASCII code of the key pressed. Values greater than 255 are
special keys such as Page Up, Home, or the cursor keys. You can compare the
value returned to constants such as :const:`curses.KEY_PPAGE`,
:const:`curses.KEY_HOME`, or :const:`curses.KEY_LEFT`. Usually the main loop of
your program will look something like this::
while 1:
c = stdscr.getch()
if c == ord('p'): PrintDocument()
elif c == ord('q'): break # Exit the while()
elif c == curses.KEY_HOME: x = y = 0
The :mod:`curses.ascii` module supplies ASCII class membership functions that
take either integer or 1-character-string arguments; these may be useful in
writing more readable tests for your command interpreters. It also supplies
conversion functions that take either integer or 1-character-string arguments
and return the same type. For example, :func:`curses.ascii.ctrl` returns the
control character corresponding to its argument.
There's also a method to retrieve an entire string, :const:`getstr()`. It isn't
used very often, because its functionality is quite limited; the only editing
keys available are the backspace key and the Enter key, which terminates the
string. It can optionally be limited to a fixed number of characters. ::
curses.echo() # Enable echoing of characters
# Get a 15-character string, with the cursor on the top line
s = stdscr.getstr(0,0, 15)
The Python :mod:`curses.textpad` module supplies something better. With it, you
can turn a window into a text box that supports an Emacs-like set of
keybindings. Various methods of :class:`Textbox` class support editing with
input validation and gathering the edit results either with or without trailing
spaces. See the library documentation on :mod:`curses.textpad` for the
details.
For More Information
====================
This HOWTO didn't cover some advanced topics, such as screen-scraping or
capturing mouse events from an xterm instance. But the Python library page for
the curses modules is now pretty complete. You should browse it next.
If you're in doubt about the detailed behavior of any of the ncurses entry
points, consult the manual pages for your curses implementation, whether it's
ncurses or a proprietary Unix vendor's. The manual pages will document any
quirks, and provide complete lists of all the functions, attributes, and
:const:`ACS_\*` characters available to you.
Because the curses API is so large, some functions aren't supported in the
Python interface, not because they're difficult to implement, but because no one
has needed them yet. Feel free to add them and then submit a patch. Also, we
don't yet have support for the menus or panels libraries associated with
ncurses; feel free to add that.
If you write an interesting little program, feel free to contribute it as
another demo. We can always use more of them!
The ncurses FAQ: http://invisible-island.net/ncurses/ncurses.faq.html
Python-2.6.2-DocJa-1/_sources/howto/cporting.txt 0000644 0001750 0001750 00000014715 11474251541 021102 0 ustar inada-n inada-n .. highlightlang:: c
**************************
3.0 への拡張モジュール移植
**************************
:author: Benjamin Peterson
.. topic:: 概要
C-API の変更は Python 3.0 の目標には入っていませんでしたが、Python レベルでの
変更がたくさんあったので、2.x の API を無傷で済ませることはできませんでした。
実際、 :func:`int` と :func:`long` の統合などは C レベルのほうが目立ちます。
この文書では、なくなった互換性と、その対処方法について記述しようと思います。
条件コンパイル
==============
一部のコードを 3.0 にだけコンパイルするための一番簡単な方法は、
:cmacro:`PY_MAJOR_VERSION` が 3 以上かどうかチェックすることです。 ::
#if PY_MAJOR_VERSION >= 3
#define IS_PY3K
#endif
存在しなくなった関数については、条件ブロックの中で同等品に
エイリアスすれば良いでしょう。
オブジェクト API の変更
=======================
Python 3.0 では、似た機能を持つタイプのいくつかを、
統合したり、きっちり分けたりしました。
str/unicode の統合
------------------
Python 3.0 の :func:`str` (C では ``PyString_*`` 関数) タイプは 2.x の
:func:`unicode` (``PyUnicode_*``) と同じものです。昔の 8 ビット文字列タイプは
:func:`bytes` です。Python 2.6 以降には互換性ヘッダ :file:`bytesobject.h`
が用意されており、 ``PyBytes`` 系の名前を ``PyString`` 系にマップしています。
3.0 との互換性を最大限確保するには、 :ctype:`PyUnicode` は文字データに、
:ctype:`PyBytes` はバイナリデータにだけ使うべきです。ほかにも、3.0 の
:ctype:`PyBytes` と :ctype:`PyUnicode` は 2.x の :ctype:`PyString` や
:ctype:`PyUnicode` とは違って交換不可能だということも重要です。以下の例では
:ctype:`PyUnicode`, :ctype:`PyString`, :ctype:`PyBytes` に関する
ベストプラクティスを見ることができます。 ::
#include "stdlib.h"
#include "Python.h"
#include "bytesobject.h"
/* text example */
static PyObject *
say_hello(PyObject *self, PyObject *args) {
PyObject *name, *result;
if (!PyArg_ParseTuple(args, "U:say_hello", &name))
return NULL;
result = PyUnicode_FromFormat("Hello, %S!", name);
return result;
}
/* just a forward */
static char * do_encode(PyObject *);
/* bytes example */
static PyObject *
encode_object(PyObject *self, PyObject *args) {
char *encoded;
PyObject *result, *myobj;
if (!PyArg_ParseTuple(args, "O:encode_object", &myobj))
return NULL;
encoded = do_encode(myobj);
if (encoded == NULL)
return NULL;
result = PyBytes_FromString(encoded);
free(encoded);
return result;
}
long/int の統合
---------------
Python 3.0 では整数タイプが一つしかありません。これは Python レベルでは
:func:`int` と呼ばれますが、実際には 2.x の :func:`long` タイプと
同じものです。C-API では ``PyInt_*`` 関数群の中身が、お隣さんの
``PyLong_*`` に交換されています。ここでとるべき最良の行動指針は、
:file:`intobject.h` で ``PyLong_*`` にエイリアスされている ``PyInt_*``
を使うというものです。ある場合には抽象 API 群 ``PyNumber_*`` も使える
かもしれません。 ::
#include "Python.h"
#include "intobject.h"
static PyObject *
add_ints(PyObject *self, PyObject *args) {
int one, two;
PyObject *result;
if (!PyArg_ParseTuple(args, "ii:add_ints", &one, &two))
return NULL;
return PyInt_FromLong(one + two);
}
モジュールの初期化と状態情報
============================
Python 3.0 には、改良された拡張モジュール初期化システムがあります (PEP
:pep:`3121` 参照)。モジュールの状態はグローバル変数に持つのではなく、
インタプリタ固有の構造体に持つべきだということになったのです。2.x と 3.0
のどちらでも動くモジュールを作るのにはコツが要ります。次の簡単な例で、
その方法を実演してみます。 ::
#include "Python.h"
struct module_state {
PyObject *error;
};
#if PY_MAJOR_VERSION >= 3
#define GETSTATE(m) ((struct module_state*)PyModule_GetState(m))
#else
#define GETSTATE(m) (&_state)
static struct module_state _state;
#endif
static PyObject *
error_out(PyObject *m) {
struct module_state *st = GETSTATE(m);
PyErr_SetString(st->error, "something bad happened");
return NULL;
}
static PyMethodDef myextension_methods[] = {
{"error_out", (PyCFunction)error_out, METH_NOARGS, NULL},
{NULL, NULL}
};
#if PY_MAJOR_VERSION >= 3
static int myextension_traverse(PyObject *m, visitproc visit, void *arg) {
Py_VISIT(GETSTATE(m)->error);
return 0;
}
static int myextension_clear(PyObject *m) {
Py_CLEAR(GETSTATE(m)->error);
return 0;
}
static struct PyModuleDef moduledef = {
PyModuleDef_HEAD_INIT,
"myextension",
NULL,
sizeof(struct module_state),
myextension_methods,
NULL,
myextension_traverse,
myextension_clear,
NULL
};
#define INITERROR return NULL
PyObject *
PyInit_myextension(void)
#else
#define INITERROR return
void
initmyextension(void)
#endif
{
#if PY_MAJOR_VERSION >= 3
PyObject *module = PyModule_Create(&moduledef);
#else
PyObject *module = Py_InitModule("myextension", myextension_methods);
#endif
if (module == NULL)
INITERROR;
struct module_state *st = GETSTATE(module);
st->error = PyErr_NewException("myextension.Error", NULL, NULL);
if (st->error == NULL) {
Py_DECREF(module);
INITERROR;
}
#if PY_MAJOR_VERSION >= 3
return module;
#endif
}
ほかの選択肢
============
新規に拡張モジュールを書こうと思っているのであれば、 `Cython
`_ を検討してみても良いでしょう。これは
Python 風の言語を C に翻訳してくれるもので、出力される
拡張モジュールは Python 3.x と 2.x に両方対応しています。
Python-2.6.2-DocJa-1/_sources/howto/index.txt 0000644 0001750 0001750 00000001136 11476415702 020360 0 ustar inada-n inada-n **************
Python HOWTO
**************
Python HOWTO は、それぞれが単独の話題を取り扱って自己完結した
文書群です。Linux Documentation Project の HOWTO 書庫をモデルに、
Python ライブラリリファレンスよりも詳細な文書を作っていこう
という努力の成果なのです。
今のところ揃っている HOWTO はこちらです:
.. toctree::
:maxdepth: 1
advocacy.rst
cporting.rst
curses.rst
doanddont.rst
functional.rst
regex.rst
sockets.rst
unicode.rst
urllib2.rst
webservers.rst
jptranslation.rst
Python-2.6.2-DocJa-1/_sources/howto/functional.txt 0000644 0001750 0001750 00000167511 11474251541 021422 0 ustar inada-n inada-n ******************************
関数型プログラミング HOWTO
******************************
:Author: A. M. Kuchling
:Release: 0.31
(これは下書きです。原文に関するコメント/間違い報告/提案は英語で amk@amk.ca まで。)
この文書では、関数型スタイルでプログラムを実装するのにピッタリな Python
の機能を見てまわることにしましょう。まず関数型プログラミングという概念を
紹介したあと、 :term:`iterator` や :term:`generator` のような言語機能、
および :mod:`itertools` や :mod:`functools` といった関連するライブラリ
モジュールを見ることにします。
はじめに
========
この章は関数型プログラミングの基本概念を説明します; Python
の言語機能についてだけ知りたい人は、次の章まで飛ばしてください。
プログラミング言語とは問題を分解するものですが、
各言語がサポートする分解方法にはいくつかの種類があります:
* ほとんどのプログラミング言語は **手続き型** です: プログラムは、
入力に対して行うべきことをコンピュータに教える指示リストとなります。
C, Pascal, さらには Unix シェルまでもが手続き型言語に入ります。
* **宣言型** 言語で書くのは、解くべき問題を説明する仕様書であって、それを
効率的に計算処理する方法を見付けるのは言語実装の役目です。SQL はおそらく
一番よく知られた宣言型言語です; SQL のクエリは取得したいデータセットを
説明しているだけで、テーブルを走査するかインデックスを使うか、
どのサブクローズから実行するか等々を決めるのは SQL エンジンなのです。
* **オブジェクト指向** プログラムはオブジェクトの集まりを操作します。
オブジェクトには内部状態があり、その状態を調べたり色々と変更したりするための
メソッドがあります。Smalltalk や Java はオブジェクト指向言語です。
C++ と Python はオブジェクト指向プログラミングをサポートしていますが、
関連する機能を使わなくても構わないようになっています。
* **関数型** プログラミングは問題をいくつかの関数にわけて考えます。
理想的に言うと、関数は入力を受けて出力を吐くだけで、同じ入力に対して
異なる出力をするような内部状態を一切持ちません。有名な関数型言語には
ML 一家 (Standard ML, OCaml 等々) と Haskell があります。
設計者が特定のアプローチを強調することにした言語もありますが、
そうすると大抵は、別のアプローチを使うプログラムを書きにくくなります。
複数のアプローチに対応した言語もあり、Lisp, C++, Python はそうした
マルチパラダイム言語です; この中のどれを使っても、基本的に手続き型な、または
基本的にオブジェクト指向な、とか、基本的に関数型なプログラムやライブラリを
書くことができます。大きなプログラムでは、各部で別々のアプローチを使って書く
ことがあるかもしれません; GUI はオブジェクト指向で、でも処理ロジックは
手続き型や関数型で、といったようにです。
関数型プログラムでは、入力は一連の関数を通って流れていきます。それぞれの関数は
入力に何らかの作業をして出力します。関数型スタイルにおいては、内部状態を
変えてしまったり、返り値に現れない変更をしたりといった副作用のある関数は
やめるように言われています。副作用のまったくない関数は **純粋関数型** である
とされます。副作用をなくすということは、プログラムの実行中に順次変化していく
データ構造を持たない、つまり各関数の出力はその入力にしか影響を受けてはいけない
ということです。
この純粋性を守る面で非常に厳しい言語もあり、そうした言語には ``a=3`` や
``c = a + b`` といった代入文さえありません。しかし副作用を完全になくすのは
難しいもので、たとえば画面表示やディスクファイルへの書き込みも副作用なのです。
Python で言うと、たとえば ``print`` 文や ``time.sleep(1)`` はどちらも
意味ある値を返しません; ただ画面にテキストを送ったり動作を 1 秒止めたり
といった副作用のためだけに呼ばれるのです。
関数型スタイルで書いた Python プログラムはふつう、I/O や代入を完全になくす
といった極端なところまでは行かずに、関数型っぽく見えるインタフェースを
提供しつつも内部では非関数型の機能を使います。たとえば、関数内で
ローカル変数の代入は使いますが、グローバル変数は変更せず、他の副作用も
ないように実装するのです。
関数型プログラミングはオブジェクト指向プログラミングの反対と考えることも
できます。オブジェクト指向において、オブジェクトは内部状態とそれを変更する
メソッドコールの入ったカプセルであり、プログラムはその状態を適正に変化
させていく手順です。一方で、関数型プログラミングは可能なかぎり状態の変更を
避け、関数どうしの間を流れるデータだけを扱おうとします。Python ではこの
二つのアプローチを結び合わせることができます。アプリケーション内の
オブジェクト (メール、トランザクション、等々) を表現したインスタンスを、
関数が受け渡しするようにするのです。
関数型デザインは、わけのわからない制約に見えるかもしれません。
どうしてオブジェクトも副作用もないほうが良いのでしょうか。
実は、関数型スタイルには理論と実践に基づく次の利点があるのです:
* 形式的証明可能性
* モジュラー性
* 結合性
* デバグやテストの簡単さ
形式的証明可能性
----------------
理論面の利点としては、プログラムが正しいことの数学的証明を
他より簡単に構築できるという点があります。
研究者たちは長いあいだ、プログラムが正しいことを数学的に証明する方法の
発見に血道をあげてきました。これは、色々な入力でテストして出力が正しかった
からまあ正しいだろう、と結論するのとも違いますし、ソースコードを読んで
「間違いはなさそうだ」と言うのとも別の話です; 目指すのは、出現しうる入力
すべてに対してプログラムが正しい結果を出すことの厳密な証明なのです。
プログラムを証明するために使われているのは **不変式** を書き出していく
というテクニックで、不変式とは入力データやプログラム変数のうち常に真である
性質のことです。コードの一行一行で、 **実行前** の不変式 X と Y が真なら
**実行後に** ちょっと違う不変式 X' と Y' が真になることを示していき、
これをプログラムの終わりまで続けるわけです。すると最終的な不変式は
プログラムの出力に合った条件になっているはずです。
関数型プログラミングが代入を嫌うのは、この不変式テクニックでは代入を
扱いにくいからです; 代入は、それまで真だった不変式を壊しておいて、
自分は次の行に伝えてゆける不変式を生み出さないことがあるのです。
残念ながら、プログラムの証明はだいたい実際的でもありませんし、Python
ソフトウェアにも関係ありません。本当に簡単なプログラムでも、証明には
数ページにわたる論文が必要なのです; ある程度の複雑なプログラムではもう
尋常でない長さになってしまうので、日常で使っているプログラム (Python
インタプリタ、XML パーサ、ウェブブラウザ) はほとんど、あるいはすべて、
正しさを証明するのは不可能でしょう。仮に証明を書き出したり生成したりしても、
その証明を検証するための疑いが残ります; 証明に間違いがあるかもしれず、
その場合は証明したと自分で勝手に思い込んでいただけになるのです。
モジュラー性
------------
より実用的には、関数型プログラミングをすると問題を細かく切り分けることになる
という利点があります。結果としてプログラムはモジュラー化されます。
複雑な変形を施す大きな関数を書くより、一つのことに絞ってそれだけをする
小さな関数のほうが書きやすいものです。それに、小さいほうが
読むのもエラーをチェックするのも簡単です。
デバグやテストの簡単さ
----------------------
テストやデバグも関数型プログラムなら簡単です。
関数が一般的に小さくて明確に意味付けされているので、デバグ方法は単純です。
プログラムが正しく動かないときには、関数ひとつひとつがデータの正しさを
チェックするポイントになるので、それぞれの時点における入力と出力を
見ていけば、バグの原因となる関数を素早く切り出すことができるのです。
ひとつひとつの関数がユニットテストの対象になり得るわけですから、
テストも簡単です。関数はシステムの状態に依存しませんので、テストの実行前に
そうした状態を再現する必要はありません; 単に適切な入力を合成して、
出力が期待どおりかどうかチェックするだけで良いのです。
結合性
------
関数型スタイルのプログラムを作っていると、色々な入力や出力のために
色々な関数を書くことになります。仕方なく特定のアプリケーションに特化した関数を
書くこともあるでしょうけれど、広範なプログラムに使える関数もあることでしょう。
たとえば、ディレクトリ名を受け取ってその中の XML ファイル一覧を返す関数や、
ファイル名を受け取って内容を返す関数などは、多様な場面に適用できそうです。
時たつうちに自分の特製ライブラリやユーティリティが充実してくると、
新しいプログラムも、既存の関数を調整して少し今回に特化した関数を書くだけで
組み立てられるようになります。
イテレータ
==========
まずは関数型スタイルのプログラムを書く際の基礎となる重要な
Python 機能から見ていきましょう: イテレータです。
イテレータは連続データを表現するオブジェクトです; このオブジェクトは
一度に一つの要素ずつデータを返します。Python のイテレータは ``next()``
という、引数を取らず次の要素を返すメソッドを必ずサポートしています。
データストリームに要素が残っていない場合、 ``next()`` は必ず
``StopIteration`` 例外を出します。ただ、イテレータの長さは有限である
必要はありません; 無限のストリームを出すイテレータを書くというのも
まったく理に適ったことです。
ビルトインの :func:`iter` 関数は任意のオブジェクトを受けて、
その中身や要素を返すイテレータを返そうとします。引数のオブジェクトが
イテレータを作れないときは :exc:`TypeError` を投げます。Python の
ビルトインなデータ型にもいくつかイテレータ化のできるものがあり、
中でもよく使われるのはリストと辞書です。イテレータを作れる
オブジェクトは **イテラブル** オブジェクトと呼ばれます。
手を動かしてイテレータ化の実験をしてみましょう:
>>> L = [1,2,3]
>>> it = iter(L)
>>> print it
<...iterator object at ...>
>>> it.next()
1
>>> it.next()
2
>>> it.next()
3
>>> it.next()
Traceback (most recent call last):
File "", line 1, in ?
StopIteration
>>>
Python は色々な文脈でイテラブルなオブジェクトを期待しますが、
最も重要なのは ``for`` 文です。 ``for X in Y`` という文の Y は、
イテレータか、あるいは ``iter()`` でイテレータを作れるオブジェクト
である必要があります。次の二つは同じ意味になります::
for i in iter(obj):
print i
for i in obj:
print i
イテレータは :func:`list` や :func:`tuple` といったコンストラクタ関数
を使ってリストやタプルに具現化することができます:
>>> L = [1,2,3]
>>> iterator = iter(L)
>>> t = tuple(iterator)
>>> t
(1, 2, 3)
シーケンスのアンパックもイテレータに対応しています: イテレータが N 個の要素を
返すということが事前にわかっていれば、N-タプルにアンパックすることができます:
>>> L = [1,2,3]
>>> iterator = iter(L)
>>> a,b,c = iterator
>>> a,b,c
(1, 2, 3)
ビルトイン関数の :func:`max` や :func:`min` なども、イテレータ一つだけを引数に
取って最大・最小の要素を返すことができます。 ``in`` や ``not in`` 演算子も
イテレータに対応しています: ``X in イテレータ`` は、そのイテレータから返る
ストリームに X があれば真です。ですからイテレータが無限長だと、当然ながら問題
に直面します; ``max()``, ``min()``, ``not in`` はいつまでも戻って来ませんし、
要素 X がストリームに出てこなければ ``in`` オペレータも戻りません。
イテレータは次に進むことしかできませんのでご注意ください;
前の要素を手に入れたり、イテレータをリセットしたり、コピーを作ったり
する方法はありません。イテレータがオブジェクトとしてそうした追加機能を
持つことはできますが、プロトコルでは ``next()`` メソッドのことしか
指定されていません。ですから関数はイテレータの出力を使い尽くして
しまうかもしれませんし、同じストリームに何か別のことをする
必要があるなら新しいイテレータを作らなくてはいけません。
イテレータ対応のデータ型
------------------------
リストやタプルがイテレータに対応している方法については既に見ましたが、
実のところ Python のシーケンス型はどれでも、たとえば文字列なども、
自動でイテレータ生成に対応しています。
辞書に対して :func:`iter` すると、
辞書のキーでループを回すイテレータが返されます:
.. not a doctest since dict ordering varies across Pythons
::
>>> m = {'Jan': 1, 'Feb': 2, 'Mar': 3, 'Apr': 4, 'May': 5, 'Jun': 6,
... 'Jul': 7, 'Aug': 8, 'Sep': 9, 'Oct': 10, 'Nov': 11, 'Dec': 12}
>>> for key in m:
... print key, m[key]
Mar 3
Feb 2
Aug 8
Sep 9
Apr 4
Jun 6
Jul 7
Jan 1
May 5
Nov 11
Dec 12
Oct 10
順番は基本的にランダムであることに注目してください。
これは辞書内オブジェクトのハッシュの順番になっているからです。
辞書は :func:`iter` を適用するとキーでループを回しますが、辞書には他の
イテレータを返すメソッドもあります。明示的にキー、値、あるいはキーと値のペアで
イテレートしたければ、 ``iterkeys()``, ``itervalues()``, ``iteritems()``
というメソッドでイテレータを作ることができます。
逆に :func:`dict` コンストラクタは、有限な ``(キー, 値)`` タプルのストリーム
を返すイテレータを受け入れることができます:
>>> L = [('Italy', 'Rome'), ('France', 'Paris'), ('US', 'Washington DC')]
>>> dict(iter(L))
{'Italy': 'Rome', 'US': 'Washington DC', 'France': 'Paris'}
ファイルも、最後の行まで ``readline()`` メソッドを呼んでいくことで
イテレータ化に対応しています。つまりこうやってファイルの各行を
読んでいくことができるわけです::
for line in file:
# 一行ごとに何かをする
...
セットはイテラブルを受け取れますし、
そのセットの要素でイテレートすることもできます::
S = set((2, 3, 5, 7, 11, 13))
for i in S:
print i
ジェネレータ式とリスト内包表記
==============================
イテレータの出力に対してよく使う操作トップ 2 は、(1) ひとつずつ全要素に
操作を実行する、および (2) 条件に合う要素でサブセットを作る、です。たとえば
文字列のリストなら、各行のうしろに付いた邪魔なホワイトスペースを削りたい
とか、特定の文字列を含む部分をピックアップしたいなどと思うかもしれません。
リスト内包表記とジェネレータ式 (略して「listcomp」と「genexp」) は、
そうした操作向けの簡潔な表記方法です。これは関数型プログラミング言語
Haskell (http://www.haskell.org) にインスパイアされました。
文字列のストリームからホワイトスペースをすべて削るのは次のコードでできます::
line_list = [' line 1\n', 'line 2 \n', ...]
# ジェネレータ式 -- イテレータを返す
stripped_iter = (line.strip() for line in line_list)
# リスト内包表記 -- リストを返す
stripped_list = [line.strip() for line in line_list]
特定の要素だけを選び出すのは ``if`` 条件式を付けることで可能です::
stripped_list = [line.strip() for line in line_list
if line != ""]
リスト内包表記を使うと Python リストが返って来ます; ``stripped_list`` は
実行結果の行が入ったリストであって、イテレータではありません。ジェネレータ
式はイテレータを返し、これだと必要に応じてだけ値を算出しますので、
すべての値を一度に出す必要がありません。つまりリスト内包表記のほうは、
無限長ストリームや膨大なデータを返すようなイテレータを扱う際には、
あまり役に立たないということです。そういった状況では
ジェネレータ式のほうが好ましいと言えます。
ジェネレータ式は丸括弧 "()" で囲まれ、リスト内包表記は
角括弧 "[]" で囲まれます。ジェネレータ式の形式は次のとおりです::
( expression for expr in sequence1
if condition1
for expr2 in sequence2
if condition2
for expr3 in sequence3 ...
if condition3
for exprN in sequenceN
if conditionN )
リスト内包表記も、外側の括弧が違うだけ (丸ではなく角括弧) で、あとは同じです。
生成される出力は ``expression`` 部分の値を要素として並べたものになります。
``if`` 節はすべて、なくても大丈夫です; あれば ``condition`` が真のときだけ
``expression`` が評価されて出力に追加されます。
ジェネレータ式は常に括弧の中に書かなければなりませんが、
関数コールの目印になっている括弧でも大丈夫です。
関数にすぐ渡すイテレータを作りたければこう書けるのです::
obj_total = sum(obj.count for obj in list_all_objects())
``for...in`` 節は複数つなげられますが、どれにも、イテレートするための
シーケンスが含まれています。それらのシーケンスは並行して **ではなく** 、
左から右へ順番にイテレートされるので、長さが同じである必要はありません。
``sequence1`` の各要素ごとに毎回最初から ``sequence2`` をループで回すのです。
その後 ``sequence1`` と ``sequence2`` から出た要素ペアごとに、
``sequence3`` でループします。
別の書き方をすると、リスト内包表記やジェネレータ式は次の
Python コードと同じ意味になります::
for expr1 in sequence1:
if not (condition1):
continue # この要素は飛ばす
for expr2 in sequence2:
if not (condition2):
continue # この要素は飛ばす
...
for exprN in sequenceN:
if not (conditionN):
continue # この要素は飛ばす
# expression の値を出力する。
つまり、複数の ``for...in`` 節があって ``if`` がないときの最
終出力は、長さが各シーケンス長の積に等しくなるということです。
長さ 3 のリスト二つなら、出力リストの長さは 9 要素です:
.. doctest::
:options: +NORMALIZE_WHITESPACE
>>> seq1 = 'abc'
>>> seq2 = (1,2,3)
>>> [(x,y) for x in seq1 for y in seq2]
[('a', 1), ('a', 2), ('a', 3),
('b', 1), ('b', 2), ('b', 3),
('c', 1), ('c', 2), ('c', 3)]
Python の文法に曖昧さを紛れ込ませないように、 ``expression``
でタプルを作るなら括弧で囲わなくてはなりません。下にあるリス
ト内包表記で、最初のは構文エラーですが、二番目は有効です::
# Syntax error
[ x,y for x in seq1 for y in seq2]
# Correct
[ (x,y) for x in seq1 for y in seq2]
ジェネレータ
============
ジェネレータは、イテレータを書く作業を簡単にする、特殊な関数です。
標準的な関数は値を計算して返しますが、ジェネレータが返すのは、
一連の値を返すイテレータです。
Python や C の標準的な関数コールについては、よくご存じに違いありません。
関数を呼ぶと、ローカル変数を作るプライベートな名前空間ができますね。
その関数が ``return`` 文まで来ると、ローカル変数が破壊されてから、返り値が
呼び出し元に返ります。次に同じ関数をもう一度呼ぶと、新しいプライベート
名前空間に新規のローカル変数が作られるのです。しかし、関数を出るときに
ローカル変数を捨てなければどうなるでしょうか。その出ていったところから
関数を続行できたとしたら、どうでしょう。これこそジェネレータが提供する
機能です; すなわち、ジェネレータは続行できる関数と考えることができます。
ごく単純なジェネレータ関数の例がこちらにあります:
.. testcode::
def generate_ints(N):
for i in range(N):
yield i
``yield`` キーワードを含む関数はすべてジェネレータ関数です;
Python の :term:`bytecode` コンパイラがこれを検出して、特別な方法で
コンパイルしてくれるのです。
ジェネレータ関数は、呼ばれたときに一回だけ値を返すのではなく、イテレータ
プロトコルに対応したオブジェクトを返します。上の例で ``yield`` を実行したとき、
ジェネレータは ``return`` 文のようにして ``i`` の値を出力します。
``yield`` と ``return`` 文の大きな違いは、 ``yield`` に到達した段階で
ジェネレータの実行状態が一時停止になって、ローカル変数が保存される点です。
次回そのジェネレータの ``.next()`` を呼ぶと、そこから関数が実行を再開します。
上記 ``generate_ints()`` ジェネレータの使用例はこちらです:
>>> gen = generate_ints(3)
>>> gen
>>> gen.next()
0
>>> gen.next()
1
>>> gen.next()
2
>>> gen.next()
Traceback (most recent call last):
File "stdin", line 1, in ?
File "stdin", line 2, in generate_ints
StopIteration
同じく ``for i in generate_ints(5)`` や ``a,b,c = generate_ints(3)``
といった書き方もできます。
ジェネレータ関数内で ``return`` 文は、引数を付けずに、処理の終わりを
知らせるためにだけ使うことができます; ``return`` を実行したあとは、
もうそのジェネレータが値を返すことはできません。
ジェネレータ関数の中では、 ``return 5`` などと値を付けた ``return``
は構文エラーです。ジェネレータの出力が終わったことを示すには、
ほかにも、手動で ``StopIteration`` を投げてもいいですし、
関数の最後まで実行するだけでも同じことになります。
自分でクラスを書いて、ジェネレータで言うところのローカル変数を
インスタンス変数として全部保管しておけば、同じ効果を得ることは可能です。
たとえば整数のリストを返すのは、 ``self.count`` を 0 にして、
``next()`` メソッドが ``self.count`` をインクリメントして返すように
すればできます。しかしながら、ある程度複雑なジェネレータになってくると、
同じことをするクラスを書くのは格段にややこしいことになります。
Python のライブラリに含まれているテストスイート ``test_generators.py`` には、
ほかにも興味深い例が数多く入っています。これは二分木の通りがけ順 (in-order) 探索
を再帰で実装したジェネレータです。 ::
# A recursive generator that generates Tree leaves in in-order.
def inorder(t):
if t:
for x in inorder(t.left):
yield x
yield t.label
for x in inorder(t.right):
yield x
ほかにも ``test_generators.py`` には、N-Queens 問題 (N×N コマのチェス盤に、
互いに攻撃できないような配置で N 個のクイーンを置く) やナイト・ツアー (N×N
盤の全コマをナイトが一度ずつ通るような経路を探す) の解を出す例が入っています。
ジェネレータに値を渡す
----------------------
Python 2.4 までのジェネレータは出力することしかできませんでした。
ジェネレータのコードを実行してイテレータを作ってしまったあとで、
その関数を再開するときに新しい情報を渡す手段はなかったのです。
ジェネレータがグローバル変数を見るようにしたり、ミュータブルな
オブジェクトを渡しておいて呼び出し元であとからそれを変更したり、
といったハックは可能でしたが、どれもゴチャゴチャしていますね。
Python 2.5 で、ジェネレータに値を渡す簡単な手段ができました。
:keyword:`yield` が、変数に代入したり演算したりできる値を返す
式になったのです::
val = (yield i)
上のように、返り値で何かをするときは ``yield`` 式の前後に **必ず**
括弧を付けるようお勧めします。括弧は常に必要なわけではありませんが、
どんなとき付けなくて良いのかを覚えておくより、
いつも付けておくほうが楽ですから。
(PEP 342 がその規則を正確に説明していますが、それによると
``yield``-式は、代入式で右辺のトップレベルにあるとき以外はいつも
括弧を付ける必要があります。つまり ``val = yield i`` とは書けますが、
``val = (yield i) + 12`` のように演算子があるときは
括弧を使わなくてはいけません。)
ジェネレータに値を送るには ``send(値)`` メソッドを呼びます。
するとジェネレータのコードが実行を再開し、 ``yield`` 式が
その値を返すのです。ふつうの ``next()`` メソッドを呼ぶと、
``yield`` は ``None`` を返します。
下にあるのは 1 ずつ増える単純なカウンタですが、内部カウンタ
の値を変更することができるようになっています。
.. testcode::
def counter (maximum):
i = 0
while i < maximum:
val = (yield i)
# 値が提供されていればカウンタを変更する
if val is not None:
i = val
else:
i += 1
そしてカウンタ変更の例がこちらです:
>>> it = counter(10)
>>> print it.next()
0
>>> print it.next()
1
>>> print it.send(8)
8
>>> print it.next()
9
>>> print it.next()
Traceback (most recent call last):
File ``t.py'', line 15, in ?
print it.next()
StopIteration
``yield`` が ``None`` を返すことはよくあるのですから、そうなっていないか
どうか必ずチェックしておくべきです。ジェネレータ関数を再開するために使う
メソッドが ``send()`` しかないのだと確定してるのでない限り、式の値を
そのまま使ってはいけません。
ジェネレータには、 ``send()`` のほかにも新しいメソッドが二つあります:
* ``throw(type, value=None, traceback=None)`` はジェネレータ内で例外を
投げるために使います; その例外はジェネレータの実行が停止したところの
``yield`` 式によって投げられます。
* ``close()`` はジェネレータ内で :exc:`GeneratorExit` 例外を投げて、
イテレートを終了させます。この例外を受け取ったジェネレータのコードは
:exc:`GeneratorExit` か :exc:`StopIteration` を投げなくてはいけません;
この例外を捕捉して何かほかのことをしようとするのは規則違反であり、
:exc:`RuntimeError` を引き起こします。 ``close()`` はジェネレータが GC
されるときにも呼ばれます。
:exc:`GeneratorExit` が起こったときにクリーンアップ作業をする必要が
あるなら、 :exc:`GeneratorExit` を捕捉するのではなく
``try: ... finaly:`` するようお勧めします。
これらの変更の合わせ技で、ジェネレータは情報の一方的な生産者から、
生産者かつ消費者という存在に変貌を遂げたのです。
ジェネレータは **コルーチン** という、より一般化された形式のサブルーチン
にもなります。サブルーチンは一カ所 (関数の冒頭) から入って別の一カ所
(``return`` 文) から出るだけですが、コルーチンはいろいろな場所
(``yield`` 文) から入ったり出たり再開したりできるのです。
ビルトイン関数
==============
よくイテレータと一緒に使うビルトイン関数について、もっと詳しく見ていきましょう。
Python のビルトイン関数 :func:`map` と :func:`filter` は少し
時代遅れになっています; 機能がリスト内包表記と重複していて、
イテレータではなくリストそのものを返します。
``map(f, iterA, iterB, ...)`` は
``f(iterA[0], iterB[0]), f(iterA[1], iterB[1]), f(iterA[2], iterB[2]), ...``
のリストを返します。
>>> def upper(s):
... return s.upper()
>>> map(upper, ['sentence', 'fragment'])
['SENTENCE', 'FRAGMENT']
>>> [upper(s) for s in ['sentence', 'fragment']]
['SENTENCE', 'FRAGMENT']
上にあるように、リスト内包表記でも同じ結果を得ることができます。
:func:`itertools.imap` 関数も同じことをしてくれますが、
無限長イテレータまで扱うことができます; これについてはあとから
:mod:`itertools` モジュールの章で論じましょう。
``filter(predicate, iter)`` は条件に合う要素すべてのリストを
返しますので、同様にリスト内包表記で再現できます。 **predicate**
の部分には、条件が合うと真値を返す関数を入れてください;
:func:`filter` で使うには、その関数が取る引数は一つだけ
でなくてはいけません。
>>> def is_even(x):
... return (x % 2) == 0
>>> filter(is_even, range(10))
[0, 2, 4, 6, 8]
これはリスト内包表記でも書けます:
>>> [x for x in range(10) if is_even(x)]
[0, 2, 4, 6, 8]
:func:`filter` も :mod:`itertools` モジュールに同等品があり、その
:func:`itertools.ifilter` はイテレータを返すので、
:func:`itertools.imap` と同様、無限長シーケンスまで扱えます。
``reduce(func, iter, [initial_value])`` はイテラブルの要素に対して次々に
演算を実行していった最終結果を出すもので、それゆえ無限長イテラブルには
適用できませんので、 :mod:`itertools` モジュールに同等品がありません。
``func`` には、要素を二つ取って値を一つ返す関数が入ります。
:func:`reduce` はイテレータが返す最初の二要素 A と B を取って
``func(A, B)`` を出します。それから三番目の要素 C を要求して
``func(func(A, B), C)`` を算出すると、その結果をさらに四番目の要素と
組み合わせて……ということをイテラブルが尽きるまで続けるのです。
もしイテラブルが一つも値を返さなければ :exc:`TypeError` が出ます。
初期値 ``initial_value`` があるときには、
``func(initial_value, A)`` がスタート地点として実行されます。
>>> import operator
>>> reduce(operator.concat, ['A', 'BB', 'C'])
'ABBC'
>>> reduce(operator.concat, [])
Traceback (most recent call last):
...
TypeError: reduce() of empty sequence with no initial value
>>> reduce(operator.mul, [1,2,3], 1)
6
>>> reduce(operator.mul, [], 1)
1
:func:`operator.add` を :func:`reduce` で使うと、イテラブルの全要素を
合計することになります。これは使用頻度が高いので、そのためだけの
:func:`sum` というビルトインがあるほどです:
>>> reduce(operator.add, [1,2,3,4], 0)
10
>>> sum([1,2,3,4])
10
>>> sum([])
0
とはいえ、多くの場合 :func:`reduce` を使うよりは単に
:keyword:`for` ループを書いたほうがわかりやすくなるかもしれません::
# こう書く代わりに
product = reduce(operator.mul, [1,2,3], 1)
# こう書けます
product = 1
for i in [1,2,3]:
product *= i
``enumerate(iter)`` はイテラブルの要素を数え上げて、それぞれの
番号と要素の入った 2-タプルを返します。
>>> for item in enumerate(['subject', 'verb', 'object']):
... print item
(0, 'subject')
(1, 'verb')
(2, 'object')
:func:`enumerate` はよく、リストに対してループさせて、
条件に合う所に印を付けていくときに使われます::
f = open('data.txt', 'r')
for i, line in enumerate(f):
if line.strip() == '':
print 'Blank line at line #%i' % i
``sorted(iterable, [cmp=None], [key=None], [reverse=false])`` は
イテラブルの要素をすべて集めたリストを作り、ソートして返します。
引数 ``cmp``, ``key``, ``reverse`` は、リストの ``.sort()``
メソッドにそのまま渡されます。 ::
>>> import random
>>> # 0 以上 10000 未満の乱数を 8 個生成
>>> rand_list = random.sample(range(10000), 8)
>>> rand_list
[769, 7953, 9828, 6431, 8442, 9878, 6213, 2207]
>>> sorted(rand_list)
[769, 2207, 6213, 6431, 7953, 8442, 9828, 9878]
>>> sorted(rand_list, reverse=True)
[9878, 9828, 8442, 7953, 6431, 6213, 2207, 769]
(ソートに関する詳細な論議は Python wiki の Sorting mini-HOWTO
を参照: http://wiki.python.org/moin/HowTo/Sorting
[訳注: 古い版の和訳が http://www.python.jp/Zope/articles/tips/sorthowto にあります])
ビルトインの ``any(iter)`` および ``all(iter)`` はイテラブルの真値を調べます。
:func:`any` は要素のどれかが真値なら True を返し、
:func:`all` は要素がどれも真値なら True を返します:
>>> any([0,1,0])
True
>>> any([0,0,0])
False
>>> any([1,1,1])
True
>>> all([0,1,0])
False
>>> all([0,0,0])
False
>>> all([1,1,1])
True
小さな関数とラムダ式
====================
関数型スタイルのプログラムを書いていると、述語として働いたり、何らかの形で
要素をつなぎ合わせたりするミニサイズの関数を必要とすることがよくあります。
ちょうど良い関数がビルトインやモジュールで存在していれば、
新しい関数を定義する必要はまったくありません::
stripped_lines = [line.strip() for line in lines]
existing_files = filter(os.path.exists, file_list)
しかし、欲しい関数がないなら書くしかありません。そうした小さな関数を書く方法の
一つが ``lambda`` 文です。 ``lambda`` は引数として複数のパラメータと
それをつなぐ式を取り、その式の値を返す小さな関数を作ります::
lowercase = lambda x: x.lower()
print_assign = lambda name, value: name + '=' + str(value)
adder = lambda x, y: x+y
もう一つの選択肢は、ふつうに ``def`` 文で関数を定義するだけです::
def lowercase(x):
return x.lower()
def print_assign(name, value):
return name + '=' + str(value)
def adder(x,y):
return x + y
どちらのほうが良いのでしょうか。それは好みの問題です; 著者のスタイルとしては
できるだけ ``lambda`` を使わないようにしています。
そのようにしている理由の一つに、 ``lambda`` は定義できる関数が非常に
限られているという点があります。一つの式として算出できる結果に
しなければいけませんので、 ``if... elif... else`` や ``try... except``
のような分岐を持つことができないのです。 ``lambda`` 文の中で
たくさんのことをやろうとしすぎると、ごちゃごちゃして読みにくい式に
なってしまいます。さて、次のコードは何をしているでしょうか、
素早くお答えください!
::
total = reduce(lambda a, b: (0, a[1] + b[1]), items)[1]
わかるにはわかるでしょうが、何がどうなっているのか紐解いていくには時間が
かかるはずです。短い ``def`` 文で入れ子にすると、少し見通しが良くなりますが::
def combine (a, b):
return 0, a[1] + b[1]
total = reduce(combine, items)[1]
でも単純に ``for`` ループにすれば良かったのです::
total = 0
for a, b in items:
total += b
あるいは :func:`sum` ビルトインとジェネレータ式でも良いですね::
total = sum(b for a,b in items)
多くの場合、 :func:`reduce` を使っているところは ``for`` ループに
書き直したほうが見やすいです。
Fredrik Lundh は以前 ``lambda`` 利用のリファクタリング
に関して以下の指針を提案したことがあります:
1) ラムダ関数を書く。
2) そのラムダが一体ぜんたい何をしているのかコメントで説明する。
3) そのコメントをしばらく研究して、本質をとらえた名前を考える。
4) ラムダをその名前で def 文に書き換える。
5) コメントを消す。
著者はこの指針を本当に気に入っていますが、こうしたラムダなし
スタイルが他より優れているかどうかについて、異論は認めます。
itertools モジュール
====================
:mod:`itertools` モジュールには、よく使うイテレータや、イテレータ同士の
連結に使う関数がたくさん含まれています。この章では、そのモジュールの内容を
小さな例で紹介していきたいと思います。
このモジュールの関数を大まかに分けるとこうなります:
* 既存のイテレータに基づいて新しいイテレータを作る関数
* イテレータの要素を引数として扱う関数
* イテレータの出力から一部を取り出す関数
* イテレータの出力をグループ分けする関数
新しいイテレータを作る
----------------------
``itertools.count(n)`` は整数を 1 ずつ増やして無限長ストリームを返します。
開始地点となる数を渡すこともでき、既定は 0 になっています::
itertools.count() =>
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ...
itertools.count(10) =>
10, 11, 12, 13, 14, 15, 16, 17, 18, 19, ...
``itertools.cycle(iter)`` は与えられたイテラブルの内容をコピーして、
その要素を最初から最後まで無限に繰り返していくイテレータを返します。 ::
itertools.cycle([1,2,3,4,5]) =>
1, 2, 3, 4, 5, 1, 2, 3, 4, 5, ...
``itertools.repeat(elem, [n])`` は、差し出された要素を ``n``
回返しますが、 ``n`` がなければ永遠に返し続けます。 ::
itertools.repeat('abc') =>
abc, abc, abc, abc, abc, abc, abc, abc, abc, abc, ...
itertools.repeat('abc', 5) =>
abc, abc, abc, abc, abc
``itertools.chain(iterA, iterB, ...)`` はイテラブルを好きな数だけ
受け取って、最初のイテレータから要素をすべて返し、次に二番目から
要素をすべて返し、ということを要素がなくなるまで続けます。 ::
itertools.chain(['a', 'b', 'c'], (1, 2, 3)) =>
a, b, c, 1, 2, 3
``itertools.izip(iterA, iterB, ...)`` は各イテラブルから
要素を一つずつ取り、タプルに入れて返します::
itertools.izip(['a', 'b', 'c'], (1, 2, 3)) =>
('a', 1), ('b', 2), ('c', 3)
これはビルトインの :func:`zip` 関数と似ていますが、メモリ内に
リストを構築したり、入力イテレータを使い切ってから返したり
しない点が違います; これがタプルを作って返すのは、要求を受けたとき
だけなのです。(この振る舞いを専門用語で `遅延評価
`__
と言います。)
このイテレータの用途には、すべて同じ長さのイテラブルを想定しています。
長さが違っていれば、出力されるストリームは一番短いイテラブルと
同じ長さになります。 ::
itertools.izip(['a', 'b'], (1, 2, 3)) =>
('a', 1), ('b', 2)
とは言え、これをやってしまうと長いイテレータから要素をひとつ無駄に多く
取って捨ててしまうかもしれませんので、やめておいたほうが良いです。
その捨てられた要素を抜かしてしまう危険があるので、
もうそのイテレータはそれ以上使えなくなってしまいます。
``itertools.islice(iter, [start], stop, [step])`` は、イテレータの
スライスをストリームで返します。 ``stop`` 引数だけだと、最初の
``stop`` 個の要素を返します。開始インデックスを渡すと
``stop - start`` 個で、 ``step`` の値も渡せばそれに応じて
要素を抜かします。Python における文字列やリストのスライスとは違って、
マイナスの値は ``start``, ``stop``, ``step`` に使えません。 ::
itertools.islice(range(10), 8) =>
0, 1, 2, 3, 4, 5, 6, 7
itertools.islice(range(10), 2, 8) =>
2, 3, 4, 5, 6, 7
itertools.islice(range(10), 2, 8, 2) =>
2, 4, 6
``itertools.tee(iter, [n])`` はイテレータを複製します; 元のイテレータの
内容を同じように返す、独立した ``n`` 個のイテレータを返すのです。
``n`` の値は、指定しなければ既定が 2 になっています。複製するには元の
イテレータの内容を一部保存しておく必要がありますから、大きな
イテレータから複製したうちの一つが他よりも進んでいってしまうと、
大量のメモリを消費することがあります。 ::
itertools.tee( itertools.count() ) =>
iterA, iterB
where iterA ->
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ...
and iterB ->
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ...
要素に対して関数を呼ぶ
----------------------
イテラブルの中身に対して他の関数を呼ぶための関数が二つあります。
``itertools.imap(f, iterA, iterB, ...)`` は
``f(iterA[0], iterB[0]), f(iterA[1], iterB[1]), f(iterA[2], iterB[2]), ...``
というストリームを返します::
itertools.imap(operator.add, [5, 6, 5], [1, 2, 3]) =>
6, 8, 8
いま使った ``operator`` モジュールには、Python の演算子に対応する関数が入って
います。いくつか例を挙げると、 ``operator.add(a, b)`` (二つの値を加算)、
``operator.ne(a, b)`` (``a!=b`` と同じ)、 ``operator.attrgetter('id')``
(``"id"`` 属性を取得するコーラブルを返す) といった関数です。
``itertools.starmap(func, iter)`` は、イテラブルがタプルを返すものとして、
そのタプルを引数に使って ``func()`` を呼びます::
itertools.starmap(os.path.join,
[('/usr', 'bin', 'java'), ('/bin', 'python'),
('/usr', 'bin', 'perl'),('/usr', 'bin', 'ruby')])
=>
/usr/bin/java, /bin/python, /usr/bin/perl, /usr/bin/ruby
要素を選択する
--------------
さらに別のグループとして、述語 (predicate) に基づいて
イテレータの要素からサブセットを選び出す関数があります。
``itertools.ifilter(predicate, iter)`` は述語が真を返す要素をすべて返します::
def is_even(x):
return (x % 2) == 0
itertools.ifilter(is_even, itertools.count()) =>
0, 2, 4, 6, 8, 10, 12, 14, ...
``itertools.ifilterfalse(predicate, iter)`` は反対に、
述語が偽を返す要素をすべて返します::
itertools.ifilterfalse(is_even, itertools.count()) =>
1, 3, 5, 7, 9, 11, 13, 15, ...
``itertools.takewhile(predicate, iter)`` は述語が真を返している間だけ要素
を返します。一度でも述語が偽を返すと、イテレータは出力終了の合図をします。
::
def less_than_10(x):
return (x < 10)
itertools.takewhile(less_than_10, itertools.count()) =>
0, 1, 2, 3, 4, 5, 6, 7, 8, 9
itertools.takewhile(is_even, itertools.count()) =>
0
``itertools.dropwhile(predicate, iter)`` は、述語が真を返しているうちは
要素を無視し、偽になってから残りの出力をすべて返します。
::
itertools.dropwhile(less_than_10, itertools.count()) =>
10, 11, 12, 13, 14, 15, 16, 17, 18, 19, ...
itertools.dropwhile(is_even, itertools.count()) =>
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ...
要素をグループ分けする
----------------------
最後に議題に上げる関数 ``itertools.groupby(iter, key_func=None)`` は、
これまでで最も複雑です。 ``key_func(elem)`` は、イテラブルから返ってきた要素
それぞれのキー値を計算する関数です。この関数が指定されていなければ、
キーは単に各要素そのものになります。
``groupby()`` は、下敷きになっているイテラブルから、
連続して同じキー値を持つ要素を集めて、キー値とイテレータの 2-タプルを
返していきます。イテレータは、それぞれのキーに対応する要素を出します。
::
city_list = [('Decatur', 'AL'), ('Huntsville', 'AL'), ('Selma', 'AL'),
('Anchorage', 'AK'), ('Nome', 'AK'),
('Flagstaff', 'AZ'), ('Phoenix', 'AZ'), ('Tucson', 'AZ'),
...
]
def get_state ((city, state)):
return state
itertools.groupby(city_list, get_state) =>
('AL', iterator-1),
('AK', iterator-2),
('AZ', iterator-3), ...
where
iterator-1 =>
('Decatur', 'AL'), ('Huntsville', 'AL'), ('Selma', 'AL')
iterator-2 =>
('Anchorage', 'AK'), ('Nome', 'AK')
iterator-3 =>
('Flagstaff', 'AZ'), ('Phoenix', 'AZ'), ('Tucson', 'AZ')
``groupby()`` は、下敷きにするイテラブルの中身がキー値でソート済みに
なって与えられることを想定しています。さて、こうして出力される
イテレータ自体も下敷きのイテラブルを使うということに注意してください。
ですから iterator-1 に出力し切ってしまうまで、iterator-2
およびそのキー値を要求することはできません。
functools モジュール
====================
Python 2.5 からの :mod:`functools` モジュールには、高階関数がいくつか入って
います。 **高階関数** とは、入力として関数を受け取って新たな関数を返す関数
です。このモジュールで一番便利なツールは :func:`functools.partial` 関数です。
関数型スタイルのプログラムでは時折、既存の関数から一部のパラメータを埋めた
変種を作りたくなることがあります。Python の関数 ``f(a, b, c)`` というものが
あるとしてください; ``f(1, b, c)`` と同じ意味の ``g(b, c)`` という関数を
作りたくなることがあります; つまり ``f()`` のパラメータを一つ埋めるわけです。
これは「関数の部分適用」と呼ばれています。
``partial`` のコンストラクタは
``(関数, 引数1, 引数2, ... キーワード引数1=既定値1, キーワード引数2=既定値2)``
という引数を取ります。できあがったオブジェクトはコーラブルですので、それを
呼べば、引数の埋まった ``function`` を実行したのと同じことになります。
以下にあるのは、小さいけれども現実的な一つの例です::
import functools
def log (message, subsystem):
"Write the contents of 'message' to the specified subsystem."
print '%s: %s' % (subsystem, message)
...
server_log = functools.partial(log, subsystem='server')
server_log('Unable to open socket')
operator モジュール
-------------------
:mod:`operator` モジュールは、既に取り上げましたが、Python の演算子に対応する
関数が入っているモジュールです。関数型スタイルのコードにおいて、演算を一つ
実行するだけのくだらない関数を書かずに済むので、よく世話になります。
このモジュールの関数を一部だけ紹介しましょう:
* 数学演算子: ``add()``, ``sub()``, ``mul()``, ``div()``, ``floordiv()``,
``abs()``, ...
* 論理演算子: ``not_()``, ``truth()``
* ビット演算子: ``and_()``, ``or_()``, ``invert()``
* 比較: ``eq()``, ``ne()``, ``lt()``, ``le()``, ``gt()``, ``ge()``
* オブジェクト識別: ``is_()``, ``is_not()``
ちゃんとした一覧は operator モジュールの文書でご覧ください。
functional モジュール
---------------------
Collin Winter の
`functional モジュール `__
には関数型プログラミング用の上級ツールが多数備わっています。さらには、
いくつかの Python ビルトインを再実装して、既に他言語で関数型プログラミングに
親しんでいる人たちにとってより直感的なようにしてあります。
この章では、 ``functional`` の中で最も重要な関数をいくつか紹介します;
完全版の文書は `プロジェクトのウェブサイト
`__ にあります。
``compose(outer, inner, unpack=False)``
``compose()`` 関数は、関数合成を実装しています。言い換えると、
``inner`` と ``outer`` の両コーラブルを囲んで、 ``inner`` からの返り値を
すぐ ``outer`` に渡すようなラッパを返します。つまり、 ::
>>> def add(a, b):
... return a + b
...
>>> def double(a):
... return 2 * a
...
>>> compose(double, add)(5, 6)
22
は下と同じことをしています。 ::
>>> double(add(5, 6))
22
``unpack`` キーワードが用意されているのは、Python には完全に `カリー化
`__ されていない関数があるという
現実に対処するためです。既定では ``inner`` 関数も単一オブジェクトを返し
``outer`` 関数も単一の引数を取るものと期待されていますが、 ``unpack``
引数を設定すると、 ``compose`` は ``inner`` からタプルが来るものとして、
``outer`` に渡す前に展開するようになります。ですから単なる ::
compose(f, g)(5, 6)
は次の書き方と同じことです::
f(g(5, 6))
けれども ::
compose(f, g, unpack=True)(5, 6)
は次と同じ意味になります::
f(*g(5, 6))
``compose()`` は二つしか関数を受け付けませんが、
好きなだけ合成できるバージョンを作るのは簡単なことです。それには
``reduce()``, ``compose()``, ``partial()`` を使います (最後のは
``functional`` でも ``functools`` でも提供されています)。 ::
from functional import compose, partial
multi_compose = partial(reduce, compose)
``map()``, ``compose()``, ``partial()`` を使って、引数を文字列に
変換するバージョンの ``"".join(...)`` を組み立てることもできます::
from functional import compose, partial
join = compose("".join, partial(map, str))
``flip(func)``
``flip()`` は、 ``func`` に指定したコーラブルのラッパを返し、
キーワードなし引数を逆の順番で受け取るようにします。 ::
>>> def triple(a, b, c):
... return (a, b, c)
...
>>> triple(5, 6, 7)
(5, 6, 7)
>>>
>>> flipped_triple = flip(triple)
>>> flipped_triple(5, 6, 7)
(7, 6, 5)
``foldl(func, start, iterable)``
``foldl()`` は引数として二引数関数、初期値 (たいていは「ある種の」ゼロ)、
イテラブルを取ります。その二引数関数を初期値とリスト第一要素に適用し、その結果と
リスト第二要素、さらにその結果と第三要素、というように適用していくのです。
つまり、こういうコールは ::
foldl(f, 0, [1, 2, 3])
これと同じことになります::
f(f(f(0, 1), 2), 3)
``foldl()`` は以下の再帰関数とほぼ同じです::
def foldl(func, start, seq):
if len(seq) == 0:
return start
return foldl(func, func(start, seq[0]), seq[1:])
「同じ」と言えば、さきほどの ``foldl`` コールの例は、ビルトインの
``reduce`` を使ってこのように表現することもできます::
reduce(f, [1, 2, 3], 0)
``foldl()``, ``operator.concat()``, ``partial()`` を使えば、
スッキリして見やすいバージョンの ``"".join(...)`` を書くことができます::
from functional import foldl, partial from operator import concat
join = partial(foldl, concat, "")
Revision History and Acknowledgements
=====================================
The author would like to thank the following people for offering suggestions,
corrections and assistance with various drafts of this article: Ian Bicking,
Nick Coghlan, Nick Efford, Raymond Hettinger, Jim Jewett, Mike Krell, Leandro
Lameiro, Jussi Salmela, Collin Winter, Blake Winton.
Version 0.1: posted June 30 2006.
Version 0.11: posted July 1 2006. Typo fixes.
Version 0.2: posted July 10 2006. Merged genexp and listcomp sections into one.
Typo fixes.
Version 0.21: Added more references suggested on the tutor mailing list.
Version 0.30: Adds a section on the ``functional`` module written by Collin
Winter; adds short section on the operator module; a few other edits.
参照資料
========
一般論
------
**Structure and Interpretation of Computer Programs**, by Harold Abelson and
Gerald Jay Sussman with Julie Sussman. Full text at
http://mitpress.mit.edu/sicp/. In this classic textbook of computer science,
chapters 2 and 3 discuss the use of sequences and streams to organize the data
flow inside a program. The book uses Scheme for its examples, but many of the
design approaches described in these chapters are applicable to functional-style
Python code.
http://www.defmacro.org/ramblings/fp.html: A general introduction to functional
programming that uses Java examples and has a lengthy historical introduction.
http://en.wikipedia.org/wiki/Functional_programming: General Wikipedia entry
describing functional programming.
(日本語は http://ja.wikipedia.org/wiki/%E9%96%A2%E6%95%B0%E5%9E%8B%E8%A8%80%E8%AA%9E
に「関数型言語」という項目で説明しています。)
http://en.wikipedia.org/wiki/Coroutine: Entry for coroutines.
(日本語は
http://ja.wikipedia.org/wiki/%E3%82%B3%E3%83%AB%E3%83%BC%E3%83%81%E3%83%B3 です。)
http://en.wikipedia.org/wiki/Currying: Entry for the concept of currying.
(日本語は http://ja.wikipedia.org/wiki/%E3%82%AB%E3%83%AA%E3%83%BC%E5%8C%96 です。)
Python 特有の話
---------------
http://gnosis.cx/TPiP/: The first chapter of David Mertz's book
:title-reference:`Text Processing in Python` discusses functional programming
for text processing, in the section titled "Utilizing Higher-Order Functions in
Text Processing".
David Mertz は IBM の DeveloperWorks サイトにも、
三部構成で関数型プログラミングの記事を書いています:
`第1回 `__ /
`第2回 `__ /
`第3回 `__
Python 文書
-----------
:mod:`itertools` モジュールの文書。
:mod:`operator` モジュールの文書。
:pep:`289`: "Generator Expressions"
:pep:`342`: "Coroutines via Enhanced Generators" describes the new generator
features in Python 2.5.
.. comment
Topics to place
-----------------------------
XXX os.walk()
XXX Need a large example.
But will an example add much? I'll post a first draft and see
what the comments say.
.. comment
Original outline:
Introduction
Idea of FP
Programs built out of functions
Functions are strictly input-output, no internal state
Opposed to OO programming, where objects have state
Why FP?
Formal provability
Assignment is difficult to reason about
Not very relevant to Python
Modularity
Small functions that do one thing
Debuggability:
Easy to test due to lack of state
Easy to verify output from intermediate steps
Composability
You assemble a toolbox of functions that can be mixed
Tackling a problem
Need a significant example
Iterators
Generators
The itertools module
List comprehensions
Small functions and the lambda statement
Built-in functions
map
filter
reduce
.. comment
Handy little function for printing part of an iterator -- used
while writing this document.
import itertools
def print_iter(it):
slice = itertools.islice(it, 10)
for elem in slice[:-1]:
sys.stdout.write(str(elem))
sys.stdout.write(', ')
print elem[-1]
Python-2.6.2-DocJa-1/_sources/howto/advocacy.txt 0000644 0001750 0001750 00000043276 11476415316 021056 0 ustar inada-n inada-n *******************************
Python Advocacy HOWTO (英語)
*******************************
:Author: A.M. Kuchling
:Release: 0.03
.. topic:: Abstract
It's usually difficult to get your management to accept open source software,
and Python is no exception to this rule. This document discusses reasons to use
Python, strategies for winning acceptance, facts and arguments you can use, and
cases where you *shouldn't* try to use Python.
Reasons to Use Python
=====================
There are several reasons to incorporate a scripting language into your
development process, and this section will discuss them, and why Python has some
properties that make it a particularly good choice.
Programmability
---------------
Programs are often organized in a modular fashion. Lower-level operations are
grouped together, and called by higher-level functions, which may in turn be
used as basic operations by still further upper levels.
For example, the lowest level might define a very low-level set of functions for
accessing a hash table. The next level might use hash tables to store the
headers of a mail message, mapping a header name like ``Date`` to a value such
as ``Tue, 13 May 1997 20:00:54 -0400``. A yet higher level may operate on
message objects, without knowing or caring that message headers are stored in a
hash table, and so forth.
Often, the lowest levels do very simple things; they implement a data structure
such as a binary tree or hash table, or they perform some simple computation,
such as converting a date string to a number. The higher levels then contain
logic connecting these primitive operations. Using the approach, the primitives
can be seen as basic building blocks which are then glued together to produce
the complete product.
Why is this design approach relevant to Python? Because Python is well suited
to functioning as such a glue language. A common approach is to write a Python
module that implements the lower level operations; for the sake of speed, the
implementation might be in C, Java, or even Fortran. Once the primitives are
available to Python programs, the logic underlying higher level operations is
written in the form of Python code. The high-level logic is then more
understandable, and easier to modify.
John Ousterhout wrote a paper that explains this idea at greater length,
entitled "Scripting: Higher Level Programming for the 21st Century". I
recommend that you read this paper; see the references for the URL. Ousterhout
is the inventor of the Tcl language, and therefore argues that Tcl should be
used for this purpose; he only briefly refers to other languages such as Python,
Perl, and Lisp/Scheme, but in reality, Ousterhout's argument applies to
scripting languages in general, since you could equally write extensions for any
of the languages mentioned above.
Prototyping
-----------
In *The Mythical Man-Month*, Fredrick Brooks suggests the following rule when
planning software projects: "Plan to throw one away; you will anyway." Brooks
is saying that the first attempt at a software design often turns out to be
wrong; unless the problem is very simple or you're an extremely good designer,
you'll find that new requirements and features become apparent once development
has actually started. If these new requirements can't be cleanly incorporated
into the program's structure, you're presented with two unpleasant choices:
hammer the new features into the program somehow, or scrap everything and write
a new version of the program, taking the new features into account from the
beginning.
Python provides you with a good environment for quickly developing an initial
prototype. That lets you get the overall program structure and logic right, and
you can fine-tune small details in the fast development cycle that Python
provides. Once you're satisfied with the GUI interface or program output, you
can translate the Python code into C++, Fortran, Java, or some other compiled
language.
Prototyping means you have to be careful not to use too many Python features
that are hard to implement in your other language. Using ``eval()``, or regular
expressions, or the :mod:`pickle` module, means that you're going to need C or
Java libraries for formula evaluation, regular expressions, and serialization,
for example. But it's not hard to avoid such tricky code, and in the end the
translation usually isn't very difficult. The resulting code can be rapidly
debugged, because any serious logical errors will have been removed from the
prototype, leaving only more minor slip-ups in the translation to track down.
This strategy builds on the earlier discussion of programmability. Using Python
as glue to connect lower-level components has obvious relevance for constructing
prototype systems. In this way Python can help you with development, even if
end users never come in contact with Python code at all. If the performance of
the Python version is adequate and corporate politics allow it, you may not need
to do a translation into C or Java, but it can still be faster to develop a
prototype and then translate it, instead of attempting to produce the final
version immediately.
One example of this development strategy is Microsoft Merchant Server. Version
1.0 was written in pure Python, by a company that subsequently was purchased by
Microsoft. Version 2.0 began to translate the code into C++, shipping with some
C++code and some Python code. Version 3.0 didn't contain any Python at all; all
the code had been translated into C++. Even though the product doesn't contain
a Python interpreter, the Python language has still served a useful purpose by
speeding up development.
This is a very common use for Python. Past conference papers have also
described this approach for developing high-level numerical algorithms; see
David M. Beazley and Peter S. Lomdahl's paper "Feeding a Large-scale Physics
Application to Python" in the references for a good example. If an algorithm's
basic operations are things like "Take the inverse of this 4000x4000 matrix",
and are implemented in some lower-level language, then Python has almost no
additional performance cost; the extra time required for Python to evaluate an
expression like ``m.invert()`` is dwarfed by the cost of the actual computation.
It's particularly good for applications where seemingly endless tweaking is
required to get things right. GUI interfaces and Web sites are prime examples.
The Python code is also shorter and faster to write (once you're familiar with
Python), so it's easier to throw it away if you decide your approach was wrong;
if you'd spent two weeks working on it instead of just two hours, you might
waste time trying to patch up what you've got out of a natural reluctance to
admit that those two weeks were wasted. Truthfully, those two weeks haven't
been wasted, since you've learnt something about the problem and the technology
you're using to solve it, but it's human nature to view this as a failure of
some sort.
Simplicity and Ease of Understanding
------------------------------------
Python is definitely *not* a toy language that's only usable for small tasks.
The language features are general and powerful enough to enable it to be used
for many different purposes. It's useful at the small end, for 10- or 20-line
scripts, but it also scales up to larger systems that contain thousands of lines
of code.
However, this expressiveness doesn't come at the cost of an obscure or tricky
syntax. While Python has some dark corners that can lead to obscure code, there
are relatively few such corners, and proper design can isolate their use to only
a few classes or modules. It's certainly possible to write confusing code by
using too many features with too little concern for clarity, but most Python
code can look a lot like a slightly-formalized version of human-understandable
pseudocode.
In *The New Hacker's Dictionary*, Eric S. Raymond gives the following definition
for "compact":
.. epigraph::
Compact *adj.* Of a design, describes the valuable property that it can all be
apprehended at once in one's head. This generally means the thing created from
the design can be used with greater facility and fewer errors than an equivalent
tool that is not compact. Compactness does not imply triviality or lack of
power; for example, C is compact and FORTRAN is not, but C is more powerful than
FORTRAN. Designs become non-compact through accreting features and cruft that
don't merge cleanly into the overall design scheme (thus, some fans of Classic C
maintain that ANSI C is no longer compact).
(From http://www.catb.org/~esr/jargon/html/C/compact.html)
In this sense of the word, Python is quite compact, because the language has
just a few ideas, which are used in lots of places. Take namespaces, for
example. Import a module with ``import math``, and you create a new namespace
called ``math``. Classes are also namespaces that share many of the properties
of modules, and have a few of their own; for example, you can create instances
of a class. Instances? They're yet another namespace. Namespaces are currently
implemented as Python dictionaries, so they have the same methods as the
standard dictionary data type: .keys() returns all the keys, and so forth.
This simplicity arises from Python's development history. The language syntax
derives from different sources; ABC, a relatively obscure teaching language, is
one primary influence, and Modula-3 is another. (For more information about ABC
and Modula-3, consult their respective Web sites at http://www.cwi.nl/~steven/abc/
and http://www.m3.org.) Other features have come from C, Icon,
Algol-68, and even Perl. Python hasn't really innovated very much, but instead
has tried to keep the language small and easy to learn, building on ideas that
have been tried in other languages and found useful.
Simplicity is a virtue that should not be underestimated. It lets you learn the
language more quickly, and then rapidly write code -- code that often works the
first time you run it.
Java Integration
----------------
If you're working with Java, Jython (http://www.jython.org/) is definitely worth
your attention. Jython is a re-implementation of Python in Java that compiles
Python code into Java bytecodes. The resulting environment has very tight,
almost seamless, integration with Java. It's trivial to access Java classes
from Python, and you can write Python classes that subclass Java classes.
Jython can be used for prototyping Java applications in much the same way
CPython is used, and it can also be used for test suites for Java code, or
embedded in a Java application to add scripting capabilities.
Arguments and Rebuttals
=======================
Let's say that you've decided upon Python as the best choice for your
application. How can you convince your management, or your fellow developers,
to use Python? This section lists some common arguments against using Python,
and provides some possible rebuttals.
**Python is freely available software that doesn't cost anything. How good can
it be?**
Very good, indeed. These days Linux and Apache, two other pieces of open source
software, are becoming more respected as alternatives to commercial software,
but Python hasn't had all the publicity.
Python has been around for several years, with many users and developers.
Accordingly, the interpreter has been used by many people, and has gotten most
of the bugs shaken out of it. While bugs are still discovered at intervals,
they're usually either quite obscure (they'd have to be, for no one to have run
into them before) or they involve interfaces to external libraries. The
internals of the language itself are quite stable.
Having the source code should be viewed as making the software available for
peer review; people can examine the code, suggest (and implement) improvements,
and track down bugs. To find out more about the idea of open source code, along
with arguments and case studies supporting it, go to http://www.opensource.org.
**Who's going to support it?**
Python has a sizable community of developers, and the number is still growing.
The Internet community surrounding the language is an active one, and is worth
being considered another one of Python's advantages. Most questions posted to
the comp.lang.python newsgroup are quickly answered by someone.
Should you need to dig into the source code, you'll find it's clear and
well-organized, so it's not very difficult to write extensions and track down
bugs yourself. If you'd prefer to pay for support, there are companies and
individuals who offer commercial support for Python.
**Who uses Python for serious work?**
Lots of people; one interesting thing about Python is the surprising diversity
of applications that it's been used for. People are using Python to:
* Run Web sites
* Write GUI interfaces
* Control number-crunching code on supercomputers
* Make a commercial application scriptable by embedding the Python interpreter
inside it
* Process large XML data sets
* Build test suites for C or Java code
Whatever your application domain is, there's probably someone who's used Python
for something similar. Yet, despite being useable for such high-end
applications, Python's still simple enough to use for little jobs.
See http://wiki.python.org/moin/OrganizationsUsingPython for a list of some of
the organizations that use Python.
**What are the restrictions on Python's use?**
They're practically nonexistent. Consult the :file:`Misc/COPYRIGHT` file in the
source distribution, or the section :ref:`history-and-license` for the full
language, but it boils down to three conditions:
* You have to leave the copyright notice on the software; if you don't include
the source code in a product, you have to put the copyright notice in the
supporting documentation.
* Don't claim that the institutions that have developed Python endorse your
product in any way.
* If something goes wrong, you can't sue for damages. Practically all software
licenses contain this condition.
Notice that you don't have to provide source code for anything that contains
Python or is built with it. Also, the Python interpreter and accompanying
documentation can be modified and redistributed in any way you like, and you
don't have to pay anyone any licensing fees at all.
**Why should we use an obscure language like Python instead of well-known
language X?**
I hope this HOWTO, and the documents listed in the final section, will help
convince you that Python isn't obscure, and has a healthily growing user base.
One word of advice: always present Python's positive advantages, instead of
concentrating on language X's failings. People want to know why a solution is
good, rather than why all the other solutions are bad. So instead of attacking
a competing solution on various grounds, simply show how Python's virtues can
help.
Useful Resources
================
http://www.pythonology.com/success
The Python Success Stories are a collection of stories from successful users of
Python, with the emphasis on business and corporate users.
.. http://www.fsbassociates.com/books/pythonchpt1.htm
The first chapter of \emph{Internet Programming with Python} also
examines some of the reasons for using Python. The book is well worth
buying, but the publishers have made the first chapter available on
the Web.
http://home.pacbell.net/ouster/scripting.html
John Ousterhout's white paper on scripting is a good argument for the utility of
scripting languages, though naturally enough, he emphasizes Tcl, the language he
developed. Most of the arguments would apply to any scripting language.
http://www.python.org/workshops/1997-10/proceedings/beazley.html
The authors, David M. Beazley and Peter S. Lomdahl, describe their use of
Python at Los Alamos National Laboratory. It's another good example of how
Python can help get real work done. This quotation from the paper has been
echoed by many people:
.. epigraph::
Originally developed as a large monolithic application for massively parallel
processing systems, we have used Python to transform our application into a
flexible, highly modular, and extremely powerful system for performing
simulation, data analysis, and visualization. In addition, we describe how
Python has solved a number of important problems related to the development,
debugging, deployment, and maintenance of scientific software.
http://pythonjournal.cognizor.com/pyj1/Everitt-Feit_interview98-V1.html
This interview with Andy Feit, discussing Infoseek's use of Python, can be used
to show that choosing Python didn't introduce any difficulties into a company's
development process, and provided some substantial benefits.
.. http://www.python.org/psa/Commercial.html
Robin Friedrich wrote this document on how to support Python's use in
commercial projects.
http://www.python.org/workshops/1997-10/proceedings/stein.ps
For the 6th Python conference, Greg Stein presented a paper that traced Python's
adoption and usage at a startup called eShop, and later at Microsoft.
http://www.opensource.org
Management may be doubtful of the reliability and usefulness of software that
wasn't written commercially. This site presents arguments that show how open
source software can have considerable advantages over closed-source software.
http://www.faqs.org/docs/Linux-mini/Advocacy.html
The Linux Advocacy mini-HOWTO was the inspiration for this document, and is also
well worth reading for general suggestions on winning acceptance for a new
technology, such as Linux or Python. In general, you won't make much progress
by simply attacking existing systems and complaining about their inadequacies;
this often ends up looking like unfocused whining. It's much better to point
out some of the many areas where Python is an improvement over other systems.
Python-2.6.2-DocJa-1/_sources/howto/unicode.txt 0000644 0001750 0001750 00000076453 11476415417 020720 0 ustar inada-n inada-n ***********************
Unicode HOWTO (英語)
***********************
:Release: 1.02
This HOWTO discusses Python's support for Unicode, and explains various problems
that people commonly encounter when trying to work with Unicode.
Introduction to Unicode
=======================
History of Character Codes
--------------------------
In 1968, the American Standard Code for Information Interchange, better known by
its acronym ASCII, was standardized. ASCII defined numeric codes for various
characters, with the numeric values running from 0 to
127. For example, the lowercase letter 'a' is assigned 97 as its code
value.
ASCII was an American-developed standard, so it only defined unaccented
characters. There was an 'e', but no 'é' or 'Í'. This meant that languages
which required accented characters couldn't be faithfully represented in ASCII.
(Actually the missing accents matter for English, too, which contains words such
as 'naïve' and 'café', and some publications have house styles which require
spellings such as 'coöperate'.)
For a while people just wrote programs that didn't display accents. I remember
looking at Apple ][ BASIC programs, published in French-language publications in
the mid-1980s, that had lines like these::
PRINT "FICHER EST COMPLETE."
PRINT "CARACTERE NON ACCEPTE."
Those messages should contain accents, and they just look wrong to someone who
can read French.
In the 1980s, almost all personal computers were 8-bit, meaning that bytes could
hold values ranging from 0 to 255. ASCII codes only went up to 127, so some
machines assigned values between 128 and 255 to accented characters. Different
machines had different codes, however, which led to problems exchanging files.
Eventually various commonly used sets of values for the 128-255 range emerged.
Some were true standards, defined by the International Standards Organization,
and some were **de facto** conventions that were invented by one company or
another and managed to catch on.
255 characters aren't very many. For example, you can't fit both the accented
characters used in Western Europe and the Cyrillic alphabet used for Russian
into the 128-255 range because there are more than 127 such characters.
You could write files using different codes (all your Russian files in a coding
system called KOI8, all your French files in a different coding system called
Latin1), but what if you wanted to write a French document that quotes some
Russian text? In the 1980s people began to want to solve this problem, and the
Unicode standardization effort began.
Unicode started out using 16-bit characters instead of 8-bit characters. 16
bits means you have 2^16 = 65,536 distinct values available, making it possible
to represent many different characters from many different alphabets; an initial
goal was to have Unicode contain the alphabets for every single human language.
It turns out that even 16 bits isn't enough to meet that goal, and the modern
Unicode specification uses a wider range of codes, 0-1,114,111 (0x10ffff in
base-16).
There's a related ISO standard, ISO 10646. Unicode and ISO 10646 were
originally separate efforts, but the specifications were merged with the 1.1
revision of Unicode.
(This discussion of Unicode's history is highly simplified. I don't think the
average Python programmer needs to worry about the historical details; consult
the Unicode consortium site listed in the References for more information.)
Definitions
-----------
A **character** is the smallest possible component of a text. 'A', 'B', 'C',
etc., are all different characters. So are 'È' and 'Í'. Characters are
abstractions, and vary depending on the language or context you're talking
about. For example, the symbol for ohms (Ω) is usually drawn much like the
capital letter omega (Ω) in the Greek alphabet (they may even be the same in
some fonts), but these are two different characters that have different
meanings.
The Unicode standard describes how characters are represented by **code
points**. A code point is an integer value, usually denoted in base 16. In the
standard, a code point is written using the notation U+12ca to mean the
character with value 0x12ca (4810 decimal). The Unicode standard contains a lot
of tables listing characters and their corresponding code points::
0061 'a'; LATIN SMALL LETTER A
0062 'b'; LATIN SMALL LETTER B
0063 'c'; LATIN SMALL LETTER C
...
007B '{'; LEFT CURLY BRACKET
Strictly, these definitions imply that it's meaningless to say 'this is
character U+12ca'. U+12ca is a code point, which represents some particular
character; in this case, it represents the character 'ETHIOPIC SYLLABLE WI'. In
informal contexts, this distinction between code points and characters will
sometimes be forgotten.
A character is represented on a screen or on paper by a set of graphical
elements that's called a **glyph**. The glyph for an uppercase A, for example,
is two diagonal strokes and a horizontal stroke, though the exact details will
depend on the font being used. Most Python code doesn't need to worry about
glyphs; figuring out the correct glyph to display is generally the job of a GUI
toolkit or a terminal's font renderer.
Encodings
---------
To summarize the previous section: a Unicode string is a sequence of code
points, which are numbers from 0 to 0x10ffff. This sequence needs to be
represented as a set of bytes (meaning, values from 0-255) in memory. The rules
for translating a Unicode string into a sequence of bytes are called an
**encoding**.
The first encoding you might think of is an array of 32-bit integers. In this
representation, the string "Python" would look like this::
P y t h o n
0x50 00 00 00 79 00 00 00 74 00 00 00 68 00 00 00 6f 00 00 00 6e 00 00 00
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
This representation is straightforward but using it presents a number of
problems.
1. It's not portable; different processors order the bytes differently.
2. It's very wasteful of space. In most texts, the majority of the code points
are less than 127, or less than 255, so a lot of space is occupied by zero
bytes. The above string takes 24 bytes compared to the 6 bytes needed for an
ASCII representation. Increased RAM usage doesn't matter too much (desktop
computers have megabytes of RAM, and strings aren't usually that large), but
expanding our usage of disk and network bandwidth by a factor of 4 is
intolerable.
3. It's not compatible with existing C functions such as ``strlen()``, so a new
family of wide string functions would need to be used.
4. Many Internet standards are defined in terms of textual data, and can't
handle content with embedded zero bytes.
Generally people don't use this encoding, instead choosing other encodings that
are more efficient and convenient.
Encodings don't have to handle every possible Unicode character, and most
encodings don't. For example, Python's default encoding is the 'ascii'
encoding. The rules for converting a Unicode string into the ASCII encoding are
simple; for each code point:
1. If the code point is < 128, each byte is the same as the value of the code
point.
2. If the code point is 128 or greater, the Unicode string can't be represented
in this encoding. (Python raises a :exc:`UnicodeEncodeError` exception in this
case.)
Latin-1, also known as ISO-8859-1, is a similar encoding. Unicode code points
0-255 are identical to the Latin-1 values, so converting to this encoding simply
requires converting code points to byte values; if a code point larger than 255
is encountered, the string can't be encoded into Latin-1.
Encodings don't have to be simple one-to-one mappings like Latin-1. Consider
IBM's EBCDIC, which was used on IBM mainframes. Letter values weren't in one
block: 'a' through 'i' had values from 129 to 137, but 'j' through 'r' were 145
through 153. If you wanted to use EBCDIC as an encoding, you'd probably use
some sort of lookup table to perform the conversion, but this is largely an
internal detail.
UTF-8 is one of the most commonly used encodings. UTF stands for "Unicode
Transformation Format", and the '8' means that 8-bit numbers are used in the
encoding. (There's also a UTF-16 encoding, but it's less frequently used than
UTF-8.) UTF-8 uses the following rules:
1. If the code point is <128, it's represented by the corresponding byte value.
2. If the code point is between 128 and 0x7ff, it's turned into two byte values
between 128 and 255.
3. Code points >0x7ff are turned into three- or four-byte sequences, where each
byte of the sequence is between 128 and 255.
UTF-8 has several convenient properties:
1. It can handle any Unicode code point.
2. A Unicode string is turned into a string of bytes containing no embedded zero
bytes. This avoids byte-ordering issues, and means UTF-8 strings can be
processed by C functions such as ``strcpy()`` and sent through protocols that
can't handle zero bytes.
3. A string of ASCII text is also valid UTF-8 text.
4. UTF-8 is fairly compact; the majority of code points are turned into two
bytes, and values less than 128 occupy only a single byte.
5. If bytes are corrupted or lost, it's possible to determine the start of the
next UTF-8-encoded code point and resynchronize. It's also unlikely that
random 8-bit data will look like valid UTF-8.
References
----------
The Unicode Consortium site at has character charts, a
glossary, and PDF versions of the Unicode specification. Be prepared for some
difficult reading. is a chronology of the
origin and development of Unicode.
To help understand the standard, Jukka Korpela has written an introductory guide
to reading the Unicode character tables, available at
.
Two other good introductory articles were written by Joel Spolsky
and Jason Orendorff
. If this introduction didn't make
things clear to you, you should try reading one of these alternate articles
before continuing.
Wikipedia entries are often helpful; see the entries for "character encoding"
and UTF-8
, for example.
Python's Unicode Support
========================
Now that you've learned the rudiments of Unicode, we can look at Python's
Unicode features.
The Unicode Type
----------------
Unicode strings are expressed as instances of the :class:`unicode` type, one of
Python's repertoire of built-in types. It derives from an abstract type called
:class:`basestring`, which is also an ancestor of the :class:`str` type; you can
therefore check if a value is a string type with ``isinstance(value,
basestring)``. Under the hood, Python represents Unicode strings as either 16-
or 32-bit integers, depending on how the Python interpreter was compiled.
The :func:`unicode` constructor has the signature ``unicode(string[, encoding,
errors])``. All of its arguments should be 8-bit strings. The first argument
is converted to Unicode using the specified encoding; if you leave off the
``encoding`` argument, the ASCII encoding is used for the conversion, so
characters greater than 127 will be treated as errors::
>>> unicode('abcdef')
u'abcdef'
>>> s = unicode('abcdef')
>>> type(s)
>>> unicode('abcdef' + chr(255))
Traceback (most recent call last):
File "", line 1, in ?
UnicodeDecodeError: 'ascii' codec can't decode byte 0xff in position 6:
ordinal not in range(128)
The ``errors`` argument specifies the response when the input string can't be
converted according to the encoding's rules. Legal values for this argument are
'strict' (raise a ``UnicodeDecodeError`` exception), 'replace' (add U+FFFD,
'REPLACEMENT CHARACTER'), or 'ignore' (just leave the character out of the
Unicode result). The following examples show the differences::
>>> unicode('\x80abc', errors='strict')
Traceback (most recent call last):
File "", line 1, in ?
UnicodeDecodeError: 'ascii' codec can't decode byte 0x80 in position 0:
ordinal not in range(128)
>>> unicode('\x80abc', errors='replace')
u'\ufffdabc'
>>> unicode('\x80abc', errors='ignore')
u'abc'
Encodings are specified as strings containing the encoding's name. Python 2.4
comes with roughly 100 different encodings; see the Python Library Reference at
:ref:`standard-encodings` for a list. Some encodings
have multiple names; for example, 'latin-1', 'iso_8859_1' and '8859' are all
synonyms for the same encoding.
One-character Unicode strings can also be created with the :func:`unichr`
built-in function, which takes integers and returns a Unicode string of length 1
that contains the corresponding code point. The reverse operation is the
built-in :func:`ord` function that takes a one-character Unicode string and
returns the code point value::
>>> unichr(40960)
u'\ua000'
>>> ord(u'\ua000')
40960
Instances of the :class:`unicode` type have many of the same methods as the
8-bit string type for operations such as searching and formatting::
>>> s = u'Was ever feather so lightly blown to and fro as this multitude?'
>>> s.count('e')
5
>>> s.find('feather')
9
>>> s.find('bird')
-1
>>> s.replace('feather', 'sand')
u'Was ever sand so lightly blown to and fro as this multitude?'
>>> s.upper()
u'WAS EVER FEATHER SO LIGHTLY BLOWN TO AND FRO AS THIS MULTITUDE?'
Note that the arguments to these methods can be Unicode strings or 8-bit
strings. 8-bit strings will be converted to Unicode before carrying out the
operation; Python's default ASCII encoding will be used, so characters greater
than 127 will cause an exception::
>>> s.find('Was\x9f')
Traceback (most recent call last):
File "", line 1, in ?
UnicodeDecodeError: 'ascii' codec can't decode byte 0x9f in position 3: ordinal not in range(128)
>>> s.find(u'Was\x9f')
-1
Much Python code that operates on strings will therefore work with Unicode
strings without requiring any changes to the code. (Input and output code needs
more updating for Unicode; more on this later.)
Another important method is ``.encode([encoding], [errors='strict'])``, which
returns an 8-bit string version of the Unicode string, encoded in the requested
encoding. The ``errors`` parameter is the same as the parameter of the
``unicode()`` constructor, with one additional possibility; as well as 'strict',
'ignore', and 'replace', you can also pass 'xmlcharrefreplace' which uses XML's
character references. The following example shows the different results::
>>> u = unichr(40960) + u'abcd' + unichr(1972)
>>> u.encode('utf-8')
'\xea\x80\x80abcd\xde\xb4'
>>> u.encode('ascii')
Traceback (most recent call last):
File "", line 1, in ?
UnicodeEncodeError: 'ascii' codec can't encode character '\ua000' in position 0: ordinal not in range(128)
>>> u.encode('ascii', 'ignore')
'abcd'
>>> u.encode('ascii', 'replace')
'?abcd?'
>>> u.encode('ascii', 'xmlcharrefreplace')
'ꀀabcd'
Python's 8-bit strings have a ``.decode([encoding], [errors])`` method that
interprets the string using the given encoding::
>>> u = unichr(40960) + u'abcd' + unichr(1972) # Assemble a string
>>> utf8_version = u.encode('utf-8') # Encode as UTF-8
>>> type(utf8_version), utf8_version
(, '\xea\x80\x80abcd\xde\xb4')
>>> u2 = utf8_version.decode('utf-8') # Decode using UTF-8
>>> u == u2 # The two strings match
True
The low-level routines for registering and accessing the available encodings are
found in the :mod:`codecs` module. However, the encoding and decoding functions
returned by this module are usually more low-level than is comfortable, so I'm
not going to describe the :mod:`codecs` module here. If you need to implement a
completely new encoding, you'll need to learn about the :mod:`codecs` module
interfaces, but implementing encodings is a specialized task that also won't be
covered here. Consult the Python documentation to learn more about this module.
The most commonly used part of the :mod:`codecs` module is the
:func:`codecs.open` function which will be discussed in the section on input and
output.
Unicode Literals in Python Source Code
--------------------------------------
In Python source code, Unicode literals are written as strings prefixed with the
'u' or 'U' character: ``u'abcdefghijk'``. Specific code points can be written
using the ``\u`` escape sequence, which is followed by four hex digits giving
the code point. The ``\U`` escape sequence is similar, but expects 8 hex
digits, not 4.
Unicode literals can also use the same escape sequences as 8-bit strings,
including ``\x``, but ``\x`` only takes two hex digits so it can't express an
arbitrary code point. Octal escapes can go up to U+01ff, which is octal 777.
::
>>> s = u"a\xac\u1234\u20ac\U00008000"
^^^^ two-digit hex escape
^^^^^^ four-digit Unicode escape
^^^^^^^^^^ eight-digit Unicode escape
>>> for c in s: print ord(c),
...
97 172 4660 8364 32768
Using escape sequences for code points greater than 127 is fine in small doses,
but becomes an annoyance if you're using many accented characters, as you would
in a program with messages in French or some other accent-using language. You
can also assemble strings using the :func:`unichr` built-in function, but this is
even more tedious.
Ideally, you'd want to be able to write literals in your language's natural
encoding. You could then edit Python source code with your favorite editor
which would display the accented characters naturally, and have the right
characters used at runtime.
Python supports writing Unicode literals in any encoding, but you have to
declare the encoding being used. This is done by including a special comment as
either the first or second line of the source file::
#!/usr/bin/env python
# -*- coding: latin-1 -*-
u = u'abcdé'
print ord(u[-1])
The syntax is inspired by Emacs's notation for specifying variables local to a
file. Emacs supports many different variables, but Python only supports
'coding'. The ``-*-`` symbols indicate that the comment is special; within
them, you must supply the name ``coding`` and the name of your chosen encoding,
separated by ``':'``.
If you don't include such a comment, the default encoding used will be ASCII.
Versions of Python before 2.4 were Euro-centric and assumed Latin-1 as a default
encoding for string literals; in Python 2.4, characters greater than 127 still
work but result in a warning. For example, the following program has no
encoding declaration::
#!/usr/bin/env python
u = u'abcdé'
print ord(u[-1])
When you run it with Python 2.4, it will output the following warning::
amk:~$ python p263.py
sys:1: DeprecationWarning: Non-ASCII character '\xe9'
in file p263.py on line 2, but no encoding declared;
see http://www.python.org/peps/pep-0263.html for details
Unicode Properties
------------------
The Unicode specification includes a database of information about code points.
For each code point that's defined, the information includes the character's
name, its category, the numeric value if applicable (Unicode has characters
representing the Roman numerals and fractions such as one-third and
four-fifths). There are also properties related to the code point's use in
bidirectional text and other display-related properties.
The following program displays some information about several characters, and
prints the numeric value of one particular character::
import unicodedata
u = unichr(233) + unichr(0x0bf2) + unichr(3972) + unichr(6000) + unichr(13231)
for i, c in enumerate(u):
print i, '%04x' % ord(c), unicodedata.category(c),
print unicodedata.name(c)
# Get numeric value of second character
print unicodedata.numeric(u[1])
When run, this prints::
0 00e9 Ll LATIN SMALL LETTER E WITH ACUTE
1 0bf2 No TAMIL NUMBER ONE THOUSAND
2 0f84 Mn TIBETAN MARK HALANTA
3 1770 Lo TAGBANWA LETTER SA
4 33af So SQUARE RAD OVER S SQUARED
1000.0
The category codes are abbreviations describing the nature of the character.
These are grouped into categories such as "Letter", "Number", "Punctuation", or
"Symbol", which in turn are broken up into subcategories. To take the codes
from the above output, ``'Ll'`` means 'Letter, lowercase', ``'No'`` means
"Number, other", ``'Mn'`` is "Mark, nonspacing", and ``'So'`` is "Symbol,
other". See
for a
list of category codes.
References
----------
The Unicode and 8-bit string types are described in the Python library reference
at :ref:`typesseq`.
The documentation for the :mod:`unicodedata` module.
The documentation for the :mod:`codecs` module.
Marc-André Lemburg gave a presentation at EuroPython 2002 titled "Python and
Unicode". A PDF version of his slides is available at
, and is an
excellent overview of the design of Python's Unicode features.
Reading and Writing Unicode Data
================================
Once you've written some code that works with Unicode data, the next problem is
input/output. How do you get Unicode strings into your program, and how do you
convert Unicode into a form suitable for storage or transmission?
It's possible that you may not need to do anything depending on your input
sources and output destinations; you should check whether the libraries used in
your application support Unicode natively. XML parsers often return Unicode
data, for example. Many relational databases also support Unicode-valued
columns and can return Unicode values from an SQL query.
Unicode data is usually converted to a particular encoding before it gets
written to disk or sent over a socket. It's possible to do all the work
yourself: open a file, read an 8-bit string from it, and convert the string with
``unicode(str, encoding)``. However, the manual approach is not recommended.
One problem is the multi-byte nature of encodings; one Unicode character can be
represented by several bytes. If you want to read the file in arbitrary-sized
chunks (say, 1K or 4K), you need to write error-handling code to catch the case
where only part of the bytes encoding a single Unicode character are read at the
end of a chunk. One solution would be to read the entire file into memory and
then perform the decoding, but that prevents you from working with files that
are extremely large; if you need to read a 2Gb file, you need 2Gb of RAM.
(More, really, since for at least a moment you'd need to have both the encoded
string and its Unicode version in memory.)
The solution would be to use the low-level decoding interface to catch the case
of partial coding sequences. The work of implementing this has already been
done for you: the :mod:`codecs` module includes a version of the :func:`open`
function that returns a file-like object that assumes the file's contents are in
a specified encoding and accepts Unicode parameters for methods such as
``.read()`` and ``.write()``.
The function's parameters are ``open(filename, mode='rb', encoding=None,
errors='strict', buffering=1)``. ``mode`` can be ``'r'``, ``'w'``, or ``'a'``,
just like the corresponding parameter to the regular built-in ``open()``
function; add a ``'+'`` to update the file. ``buffering`` is similarly parallel
to the standard function's parameter. ``encoding`` is a string giving the
encoding to use; if it's left as ``None``, a regular Python file object that
accepts 8-bit strings is returned. Otherwise, a wrapper object is returned, and
data written to or read from the wrapper object will be converted as needed.
``errors`` specifies the action for encoding errors and can be one of the usual
values of 'strict', 'ignore', and 'replace'.
Reading Unicode from a file is therefore simple::
import codecs
f = codecs.open('unicode.rst', encoding='utf-8')
for line in f:
print repr(line)
It's also possible to open files in update mode, allowing both reading and
writing::
f = codecs.open('test', encoding='utf-8', mode='w+')
f.write(u'\u4500 blah blah blah\n')
f.seek(0)
print repr(f.readline()[:1])
f.close()
Unicode character U+FEFF is used as a byte-order mark (BOM), and is often
written as the first character of a file in order to assist with autodetection
of the file's byte ordering. Some encodings, such as UTF-16, expect a BOM to be
present at the start of a file; when such an encoding is used, the BOM will be
automatically written as the first character and will be silently dropped when
the file is read. There are variants of these encodings, such as 'utf-16-le'
and 'utf-16-be' for little-endian and big-endian encodings, that specify one
particular byte ordering and don't skip the BOM.
Unicode filenames
-----------------
Most of the operating systems in common use today support filenames that contain
arbitrary Unicode characters. Usually this is implemented by converting the
Unicode string into some encoding that varies depending on the system. For
example, Mac OS X uses UTF-8 while Windows uses a configurable encoding; on
Windows, Python uses the name "mbcs" to refer to whatever the currently
configured encoding is. On Unix systems, there will only be a filesystem
encoding if you've set the ``LANG`` or ``LC_CTYPE`` environment variables; if
you haven't, the default encoding is ASCII.
The :func:`sys.getfilesystemencoding` function returns the encoding to use on
your current system, in case you want to do the encoding manually, but there's
not much reason to bother. When opening a file for reading or writing, you can
usually just provide the Unicode string as the filename, and it will be
automatically converted to the right encoding for you::
filename = u'filename\u4500abc'
f = open(filename, 'w')
f.write('blah\n')
f.close()
Functions in the :mod:`os` module such as :func:`os.stat` will also accept Unicode
filenames.
:func:`os.listdir`, which returns filenames, raises an issue: should it return
the Unicode version of filenames, or should it return 8-bit strings containing
the encoded versions? :func:`os.listdir` will do both, depending on whether you
provided the directory path as an 8-bit string or a Unicode string. If you pass
a Unicode string as the path, filenames will be decoded using the filesystem's
encoding and a list of Unicode strings will be returned, while passing an 8-bit
path will return the 8-bit versions of the filenames. For example, assuming the
default filesystem encoding is UTF-8, running the following program::
fn = u'filename\u4500abc'
f = open(fn, 'w')
f.close()
import os
print os.listdir('.')
print os.listdir(u'.')
will produce the following output::
amk:~$ python t.py
['.svn', 'filename\xe4\x94\x80abc', ...]
[u'.svn', u'filename\u4500abc', ...]
The first list contains UTF-8-encoded filenames, and the second list contains
the Unicode versions.
Tips for Writing Unicode-aware Programs
---------------------------------------
This section provides some suggestions on writing software that deals with
Unicode.
The most important tip is:
Software should only work with Unicode strings internally, converting to a
particular encoding on output.
If you attempt to write processing functions that accept both Unicode and 8-bit
strings, you will find your program vulnerable to bugs wherever you combine the
two different kinds of strings. Python's default encoding is ASCII, so whenever
a character with an ASCII value > 127 is in the input data, you'll get a
:exc:`UnicodeDecodeError` because that character can't be handled by the ASCII
encoding.
It's easy to miss such problems if you only test your software with data that
doesn't contain any accents; everything will seem to work, but there's actually
a bug in your program waiting for the first user who attempts to use characters
> 127. A second tip, therefore, is:
Include characters > 127 and, even better, characters > 255 in your test
data.
When using data coming from a web browser or some other untrusted source, a
common technique is to check for illegal characters in a string before using the
string in a generated command line or storing it in a database. If you're doing
this, be careful to check the string once it's in the form that will be used or
stored; it's possible for encodings to be used to disguise characters. This is
especially true if the input data also specifies the encoding; many encodings
leave the commonly checked-for characters alone, but Python includes some
encodings such as ``'base64'`` that modify every single character.
For example, let's say you have a content management system that takes a Unicode
filename, and you want to disallow paths with a '/' character. You might write
this code::
def read_file (filename, encoding):
if '/' in filename:
raise ValueError("'/' not allowed in filenames")
unicode_name = filename.decode(encoding)
f = open(unicode_name, 'r')
# ... return contents of file ...
However, if an attacker could specify the ``'base64'`` encoding, they could pass
``'L2V0Yy9wYXNzd2Q='``, which is the base-64 encoded form of the string
``'/etc/passwd'``, to read a system file. The above code looks for ``'/'``
characters in the encoded form and misses the dangerous character in the
resulting decoded form.
References
----------
The PDF slides for Marc-André Lemburg's presentation "Writing Unicode-aware
Applications in Python" are available at
and discuss questions of character encodings as well as how to internationalize
and localize an application.
Revision History and Acknowledgements
=====================================
Thanks to the following people who have noted errors or offered suggestions on
this article: Nicholas Bastin, Marius Gedminas, Kent Johnson, Ken Krugler,
Marc-André Lemburg, Martin von Löwis, Chad Whitacre.
Version 1.0: posted August 5 2005.
Version 1.01: posted August 7 2005. Corrects factual and markup errors; adds
several links.
Version 1.02: posted August 16 2005. Corrects factual errors.
.. comment Additional topic: building Python w/ UCS2 or UCS4 support
.. comment Describe obscure -U switch somewhere?
.. comment Describe use of codecs.StreamRecoder and StreamReaderWriter
.. comment
Original outline:
- [ ] Unicode introduction
- [ ] ASCII
- [ ] Terms
- [ ] Character
- [ ] Code point
- [ ] Encodings
- [ ] Common encodings: ASCII, Latin-1, UTF-8
- [ ] Unicode Python type
- [ ] Writing unicode literals
- [ ] Obscurity: -U switch
- [ ] Built-ins
- [ ] unichr()
- [ ] ord()
- [ ] unicode() constructor
- [ ] Unicode type
- [ ] encode(), decode() methods
- [ ] Unicodedata module for character properties
- [ ] I/O
- [ ] Reading/writing Unicode data into files
- [ ] Byte-order marks
- [ ] Unicode filenames
- [ ] Writing Unicode programs
- [ ] Do everything in Unicode
- [ ] Declaring source code encodings (PEP 263)
- [ ] Other issues
- [ ] Building Python (UCS2, UCS4)
Python-2.6.2-DocJa-1/_sources/howto/sockets.txt 0000644 0001750 0001750 00000130427 11474251541 020727 0 ustar inada-n inada-n ********************************
ソケットプログラミング HOWTO
********************************
:Author: Gordon McMillan
.. topic:: 概要
ソケットはそこかしこで使われているが、最大級に誤解されている技術でもある。
この文書はソケットの全体像を俯瞰しており、チュートリアルとしてはあまり役に立たない。
実際に動くモノを完成させるには、他にもやらなければいけないことがあるからだ。
この文書はソケットの微妙なところ (たくさんある) まではカバーしていないが、
恥ずかしくない使い方ができるようになる程度の情報は得られるはずだ。
ソケット
========
..
Sockets are used nearly everywhere, but are one of the most severely
misunderstood technologies around. This is a 10,000 foot overview of sockets.
It's not really a tutorial - you'll still have work to do in getting things
working. It doesn't cover the fine points (and there are a lot of them), but I
hope it will give you enough background to begin using them decently.
ソケットはそこかしこで使われているが、最大級に誤解されている技術でもある。
この文書はソケットの全体像を俯瞰しており、チュートリアルとしてはあまり役に立たない。
実際に動くモノを完成させるには、他にもやらなければいけないことがあるからだ。
この文書はソケットの微妙なところ (たくさんある) まではカバーしていないが、
恥ずかしくない使い方ができるようになる程度の情報は得られるはずだ。
..
I'm only going to talk about INET sockets, but they account for at least 99% of
the sockets in use. And I'll only talk about STREAM sockets - unless you really
know what you're doing (in which case this HOWTO isn't for you!), you'll get
better behavior and performance from a STREAM socket than anything else. I will
try to clear up the mystery of what a socket is, as well as some hints on how to
work with blocking and non-blocking sockets. But I'll start by talking about
blocking sockets. You'll need to know how they work before dealing with
non-blocking sockets.
INET ソケットのことしか語らないつもりだが、利用率でいうとソケットの 99% 以上はこれだ。
さらに中でも STREAM ソケットに話題を絞ろうと思う - 自分が何をしているのか分かっているのでない限り
(分かってるならこの HOWTO なんて要らないだろ!)、
STREAM ソケットが一番分かりやすく、一番性能が出るのだ。
そうやって謎に包まれたソケットの正体を明らかにしてゆくと共に、
ブロッキングおよびノンブロッキングなソケットの扱いに関するいくつかのヒントを提示しよう。
だが、まずはブロッキングソケットから始めることにする。
ノンブロッキングを扱うより先に、ブロッキングの仕組みを知っておかなくてはならないのだ。
..
Part of the trouble with understanding these things is that "socket" can mean a
number of subtly different things, depending on context. So first, let's make a
distinction between a "client" socket - an endpoint of a conversation, and a
"server" socket, which is more like a switchboard operator. The client
application (your browser, for example) uses "client" sockets exclusively; the
web server it's talking to uses both "server" sockets and "client" sockets.
話を理解しにくくしている要因として、
「ソケット」という言葉が文脈によって微妙に違うものを指すことが挙げられる。
そこでまず、「クライアント」ソケット - 対話の両端 - と
「サーバ」ソケット - 電話交換手みたいなもの - の区別を付けておこう。
クライアント側アプリケーション (たとえばブラウザ) は「クライアント」ソケットだけを使うが、
話し相手のウェブサーバは「サーバ」ソケットと「クライアント」ソケットの両方を使う。
歴史
----
..
Of the various forms of IPC (*Inter Process Communication*), sockets are by far
the most popular. On any given platform, there are likely to be other forms of
IPC that are faster, but for cross-platform communication, sockets are about the
only game in town.
各種 IPC (*Inter Process Communication* = プロセス間通信) の中でも、ソケットは群を抜いて人気がある。
どのプラットフォームにも、ソケットより速い IPC はあるだろう。
だが、プラットフォームをまたぐ通信はソケットの独擅場だ。
..
They were invented in Berkeley as part of the BSD flavor of Unix. They spread
like wildfire with the Internet. With good reason --- the combination of sockets
with INET makes talking to arbitrary machines around the world unbelievably easy
(at least compared to other schemes).
ソケットは BSD Unix の一部としてバークレイで発明され、
インターネットの普及と共に野火のごとく広まった。
それももっともなことで、ソケットと INET のコンビによって世界中どんなマシンとも、
信じられないほど簡単 (少なくとも他のスキームと比べて) に通信できるようになったのだ。
ソケットの作成
==============
..
Roughly speaking, when you clicked on the link that brought you to this page,
your browser did something like the following::
あなたがリンクをクリックしてこのページに来たとき、
ブラウザは大雑把に言って次のようなことをしたのである::
#INET の STREAM ソケットを作る
s = socket.socket(
socket.AF_INET, socket.SOCK_STREAM)
#ここでウェブサーバに 80 番 (http の標準) ポートで接続
s.connect(("www.mcmillan-inc.com", 80))
..
When the ``connect`` completes, the socket ``s`` can now be used to send in a
request for the text of this page. The same socket will read the reply, and then
be destroyed. That's right - destroyed. Client sockets are normally only used
for one exchange (or a small set of sequential exchanges).
この ``connect`` が完了すると、ソケット ``s`` を使ってこのページ文章への要求を送ることができるようになる。
その同じソケットが返答を読み、そして破壊される。そう、破壊される。
クライアントソケットは通常、一回 (か少数の) やり取りで使い捨てになるのだ。
..
What happens in the web server is a bit more complex. First, the web server
creates a "server socket". ::
ウェブサーバで起こる事柄はもう少し複雑だ。まず「サーバソケット」を作る。 ::
#INET の STREAM ソケットを作る
serversocket = socket.socket(
socket.AF_INET, socket.SOCK_STREAM)
#そのソケットを公開ホストのウェルノウンポートにつなぐ
serversocket.bind((socket.gethostname(), 80))
#サーバソケットになる
serversocket.listen(5)
..
A couple things to notice: we used ``socket.gethostname()`` so that the socket
would be visible to the outside world. If we had used ``s.bind(('', 80))`` or
``s.bind(('localhost', 80))`` or ``s.bind(('127.0.0.1', 80))`` we would still
have a "server" socket, but one that was only visible within the same machine.
ここで注意すべき点がいくつかある:
今回はソケットが外界に見えるよう、 ``socket.gethostname()`` を使った。
``s.bind(('', 80))`` や ``s.bind(('localhost', 80))`` でも「サーバ」ソケットにはなるが、
それだと同じマシン内にしか見えないものになってしまう。
..
A second thing to note: low number ports are usually reserved for "well known"
services (HTTP, SNMP etc). If you're playing around, use a nice high number (4
digits).
ふたつめ: 小さな番号のポートは大抵、「ウェルノウン (有名)」なサービス (HTTP, SNMP 等々) のために取ってある。
お遊びで使うのなら適当に大きな数 (4桁) を使おう。
..
Finally, the argument to ``listen`` tells the socket library that we want it to
queue up as many as 5 connect requests (the normal max) before refusing outside
connections. If the rest of the code is written properly, that should be plenty.
最後に: ``listen`` の引数はソケットライブラリに、
接続要求を 5 個 (通常の最大値) まで順番待ちさせるように命じている。
これ以降の外部接続は拒否するのだが、
コードが適切に書かれていれば、それで十分すぎるほどだ。
..
OK, now we have a "server" socket, listening on port 80. Now we enter the
mainloop of the web server::
よし、「サーバ」ソケットができて、80 番ポートで耳を澄ましているところまで来た。
では、ウェブサーバのメインループに入ろう::
while 1:
#外からの接続を受け入れる
(clientsocket, address) = serversocket.accept()
#ここで clientsocket に何かをする。
#今回はスレッド化サーバということにしよう
ct = client_thread(clientsocket)
ct.run()
..
There's actually 3 general ways in which this loop could work - dispatching a
thread to handle ``clientsocket``, create a new process to handle
``clientsocket``, or restructure this app to use non-blocking sockets, and
mulitplex between our "server" socket and any active ``clientsocket``\ s using
``select``. More about that later. The important thing to understand now is
this: this is *all* a "server" socket does. It doesn't send any data. It doesn't
receive any data. It just produces "client" sockets. Each ``clientsocket`` is
created in response to some *other* "client" socket doing a ``connect()`` to the
host and port we're bound to. As soon as we've created that ``clientsocket``, we
go back to listening for more connections. The two "clients" are free to chat it
up - they are using some dynamically allocated port which will be recycled when
the conversation ends.
このループには実際のところ、3 通りの一般的な動作方法がある -
``clientsocket`` を扱うようにスレッドを割り当てたり、
``clientsocket`` を扱う新しいプロセスを作ったり、
あるいはノンブロッキングソケットを使うようにアプリを作り直して ``select`` で
「サーバ」ソケットとアクティブな ``clientsocket`` の間を多重化したりするのだ。
最後のについてはまた後にしよう。ここで理解しておくべき要点はこれだ:
以上が「サーバ」ソケットの仕事の *すべて* である。
データは一切送信しないし、受信しない。「クライアント」ソケットを生み出すだけ。
我々のバインドされているホストとポートに ``connect()`` してくる *他の*
「クライアント」ソケットに応える形で ``clientsocket`` を作り、
作るや否や、さらなる接続を聞きに戻っていくのだ。
このふたつの「クライアント」は、あとは勝手に喋っていればいい -
使うポートは動的に割り当てられ、会話が終わればリサイクルに廻される。
IPC
---
..
If you need fast IPC between two processes on one machine, you should look into
whatever form of shared memory the platform offers. A simple protocol based
around shared memory and locks or semaphores is by far the fastest technique.
同一マシンのプロセス間で高速な IPC が必要なのであれば、
そのプラットフォームが提供している何らかの共有メモリに目を向けるべきだ。
共有メモリとロックやセマフォに基づいた簡素なプロトコルが断然一番速い。
..
If you do decide to use sockets, bind the "server" socket to ``'localhost'``. On
most platforms, this will take a shortcut around a couple of layers of network
code and be quite a bit faster.
ソケットを使うことにしたのであれば、「サーバ」ソケットは
``'localhost'`` にバインドすることだ。こうすると、ほとんどのプラットフォームでは
ネットワーク関連コードを何層かスキップすることになり、かなり速くなる。
ソケットの利用
==============
..
The first thing to note, is that the web browser's "client" socket and the web
server's "client" socket are identical beasts. That is, this is a "peer to peer"
conversation. Or to put it another way, *as the designer, you will have to
decide what the rules of etiquette are for a conversation*. Normally, the
``connect``\ ing socket starts the conversation, by sending in a request, or
perhaps a signon. But that's a design decision - it's not a rule of sockets.
はじめに憶えておくべきなのは、ウェブブラウザの「クライアント」ソケットと
ウェブサーバの「クライアント」ソケットがまったく同じ種族だということだ。
つまり、これは「ピア・トゥ・ピア」(1 対 1) の会話である。別の言い方をすると、
*設計者として自分で会話のエチケット規則を決めなくてはいけない* ということでもある。
通常は、 ``connect`` してくるソケットが要求あるいは宣言をして会話を始める。
だが、それはそう設計しただけのことだ - ソケットの規則ではない。
..
Now there are two sets of verbs to use for communication. You can use ``send``
and ``recv``, or you can transform your client socket into a file-like beast and
use ``read`` and ``write``. The latter is the way Java presents their sockets.
I'm not going to talk about it here, except to warn you that you need to use
``flush`` on sockets. These are buffered "files", and a common mistake is to
``write`` something, and then ``read`` for a reply. Without a ``flush`` in
there, you may wait forever for the reply, because the request may still be in
your output buffer.
さて、コミュニケーションに使う動詞は二組ある。 ``send`` と ``recv`` を使うこともできるし、
クライアントソケットをファイルっぽい種族に変形して ``read`` と ``write`` を使っても良い。
後者は Java のソケットの表現方法だ。ここで詳しく語るつもりはないが、
その場合はソケットも ``flush`` しなければいけない、とだけ言っておく。
これはバッファリングした「ファイル」なので、何かを
``write`` してすぐに返答を ``read`` するというのはよくある間違いだ。
間に ``flush`` を入れないと、要求がまだ出力バッファにあって永遠に返事が来ない、という可能性がある。
..
Now we come the major stumbling block of sockets - ``send`` and ``recv`` operate
on the network buffers. They do not necessarily handle all the bytes you hand
them (or expect from them), because their major focus is handling the network
buffers. In general, they return when the associated network buffers have been
filled (``send``) or emptied (``recv``). They then tell you how many bytes they
handled. It is *your* responsibility to call them again until your message has
been completely dealt with.
さあ、ソケットの主要な難関に進もう -
``send`` と ``recv`` はネットワークバッファに働きかけるものだ。だから、
手渡したもの (や返してもらいたいもの) を 1 バイトも残さず実際に処理してくれているとは限らない。
一般的に言って、 ``send`` はバッファが埋まったとき、
``recv`` はバッファが空になったときに実際の処理をして、そのバイト数を返す。
メッセージが完全に処理されるまでコールを繰り返すのは *自分の* 責任なのだ。
..
When a ``recv`` returns 0 bytes, it means the other side has closed (or is in
the process of closing) the connection. You will not receive any more data on
this connection. Ever. You may be able to send data successfully; I'll talk
about that some on the next page.
``recv`` が 0 バイトを返したときは、向こう側が接続を閉じてしまった (または閉じようとしている途中) という意味だ。
もうこの接続でデータを受け取ることはない。永遠にだ。
ただ、データ送信は成功するかもしれない; これについては次のページで語ることにしよう。
..
A protocol like HTTP uses a socket for only one transfer. The client sends a
request, the reads a reply. That's it. The socket is discarded. This means that
a client can detect the end of the reply by receiving 0 bytes.
HTTP のようなプロトコルでは、ひとつのソケットを転送ひとつにしか使わない。
クライアントは要求を送り、返答を受ける。以上だ。これでソケットは破棄される。
だからこの場合、クライアントは受信 0 バイトの時点で返答の末尾を検出することができる。
..
But if you plan to reuse your socket for further transfers, you need to realize
that *there is no "EOT" (End of Transfer) on a socket.* I repeat: if a socket
``send`` or ``recv`` returns after handling 0 bytes, the connection has been
broken. If the connection has *not* been broken, you may wait on a ``recv``
forever, because the socket will *not* tell you that there's nothing more to
read (for now). Now if you think about that a bit, you'll come to realize a
fundamental truth of sockets: *messages must either be fixed length* (yuck), *or
be delimited* (shrug), *or indicate how long they are* (much better), *or end by
shutting down the connection*. The choice is entirely yours, (but some ways are
righter than others).
だが、以降の転送にもそのソケットを使い回すつもりなら、
*ソケットに "EOT" (End of Transfer) など存在しない* ことを認める必要がある。
もう一度言おう: ソケットの ``send`` や ``recv`` が 0 バイト処理で返ってきたなら、その接続は終わっている。
終わって *いない* なら、いつまで ``recv`` を待てばいいかは分からない。
ソケットは「もう読むものが (今のところ) ないぜ」などと *言わない* のだから。
このことを少し考えれば、ソケットの真実を悟ることになるだろう:
*メッセージは必ず固定長か* (うげぇ) *区切り文字を使うか* (やれやれ)
*長さ標識を付けておくか* (かなりマシ)
*接続を閉じて終わらせるかのいずれかでなければいけない* のだ。
選ぶ権利と責任はまったくもって自分にある (が、正しさの程度に違いはある)。
..
Assuming you don't want to end the connection, the simplest solution is a fixed
length message::
毎回接続を終わらせるのはイヤだとして、
最も単純な解決策は固定長メッセージだろう::
class mysocket:
'''demonstration class only
- coded for clarity, not efficiency
'''
def __init__(self, sock=None):
if sock is None:
self.sock = socket.socket(
socket.AF_INET, socket.SOCK_STREAM)
else:
self.sock = sock
def connect(self, host, port):
self.sock.connect((host, port))
def mysend(self, msg):
totalsent = 0
while totalsent < MSGLEN:
sent = self.sock.send(msg[totalsent:])
if sent == 0:
raise RuntimeError, \
"socket connection broken"
totalsent = totalsent + sent
def myreceive(self):
msg = ''
while len(msg) < MSGLEN:
chunk = self.sock.recv(MSGLEN-len(msg))
if chunk == '':
raise RuntimeError, \
"socket connection broken"
msg = msg + chunk
return msg
..
The sending code here is usable for almost any messaging scheme - in Python you
send strings, and you can use ``len()`` to determine its length (even if it has
embedded ``\0`` characters). It's mostly the receiving code that gets more
complex. (And in C, it's not much worse, except you can't use ``strlen`` if the
message has embedded ``\0``\ s.)
この送信コードは、ほぼあらゆるメッセージ通信スキームで使える -
文字列を送るとき、Python なら長さを ``len()`` で見極めることができる
(中に ``\0`` が埋め込まれていても大丈夫)。
難しくしているのは、おもに受信コードである。
(なお、C でも事態はあまり悪くならないが、メッセージに ``\0`` が埋め込まれていると
``strlen`` が使えないのは面倒だ。)
..
The easiest enhancement is to make the first character of the message an
indicator of message type, and have the type determine the length. Now you have
two ``recv``\ s - the first to get (at least) that first character so you can
look up the length, and the second in a loop to get the rest. If you decide to
go the delimited route, you'll be receiving in some arbitrary chunk size, (4096
or 8192 is frequently a good match for network buffer sizes), and scanning what
you've received for a delimiter.
最も簡単な改良法は、メッセージの最初の一文字をタイプ標識にして、
そのタイプで長さを決定するというものだ。この場合ふたつの ``recv`` があることになる -
一番目でその一文字 (だけじゃなくても可) を取って長さを調べ、
二番目でループして残りを取るのだ。
あるいはもし区切り方式の道を行くのであれば、任意のサイズ
(4096 か 8192 がネットワークバッファには最適なことが多い) で
受信して区切り文字を走査していくことになる。
..
One complication to be aware of: if your conversational protocol allows multiple
messages to be sent back to back (without some kind of reply), and you pass
``recv`` an arbitrary chunk size, you may end up reading the start of a
following message. You'll need to put that aside and hold onto it, until it's
needed.
心に留めておくべき面倒な点がひとつ: 複数メッセージが次々に (何らかの返事を待たずに)
返ってくることのある会話プロトコルなら、そして任意のサイズを
``recv`` に渡しているなら、次のメッセージの冒頭部分まで読んでしまうことがあるかもしれない。
そのときは、必要になるまで脇によけて、大切に保管しておく必要がある。
..
Prefixing the message with it's length (say, as 5 numeric characters) gets more
complex, because (believe it or not), you may not get all 5 characters in one
``recv``. In playing around, you'll get away with it; but in high network loads,
your code will very quickly break unless you use two ``recv`` loops - the first
to determine the length, the second to get the data part of the message. Nasty.
This is also when you'll discover that ``send`` does not always manage to get
rid of everything in one pass. And despite having read this, you will eventually
get bit by it!
メッセージ冒頭に長さを (たとえば 5 桁の数字で) 付けるのは、
それよりもさらに複雑になる。というのも、(信じられないかもしれないが)
一回の ``recv`` で 5 文字を全部受け取ることができるとは限らないからだ。
お遊びでやっている間はごまかせても、高負荷ネットワークのもとでは、
``recv`` ループをふたつ使わないコードは、あっと言う間にダメになってしまう -
一番目は長さを見定める用で、二番目はデータ部分を受け取る用だ。うーむ、いやらしい。
さらにこのとき、 ``send`` も一発で全部を出し切れるとは限らないことに気付くだろう。
なお、今こうやって読んでいても、いつか誰もが痛い目を見るのである!
..
In the interests of space, building your character, (and preserving my
competitive position), these enhancements are left as an exercise for the
reader. Lets move on to cleaning up.
紙面の都合および教育的配慮 (と著者の地位確保)
のため、こうした改良は練習問題として残しておく。さあ片付けてしまおう。
バイナリデータ
--------------
..
It is perfectly possible to send binary data over a socket. The major problem is
that not all machines use the same formats for binary data. For example, a
Motorola chip will represent a 16 bit integer with the value 1 as the two hex
bytes 00 01. Intel and DEC, however, are byte-reversed - that same 1 is 01 00.
Socket libraries have calls for converting 16 and 32 bit integers - ``ntohl,
htonl, ntohs, htons`` where "n" means *network* and "h" means *host*, "s" means
*short* and "l" means *long*. Where network order is host order, these do
nothing, but where the machine is byte-reversed, these swap the bytes around
appropriately.
バイナリデータはまったく問題なくソケットに乗せられる。問題は、
すべてのマシンで同じ形式を使っているわけではないことにある。
たとえば Motorola のチップなら 16 ビット整数の 1 という値をふたつの
16 進バイト列 00 01 で表現するが、Intel や DEC は逆バイトだ -
同じ 1 が 01 00 になるのだ。ソケットライブラリは 16 ビットや
32 ビット整数の変換用コールを持っている - ``ntohl, htonl,
ntohs, htons`` である。"n" は *network*\ 、 "h" は *host* を意味する。
"s" は *short* で "l" は *long* だ。これらのコールは、
「ネットワーク並び = ホスト並び」なら何もしないが、
マシンが逆バイトならそれに合わせてぐるっと交換してくれる。
..
In these days of 32 bit machines, the ascii representation of binary data is
frequently smaller than the binary representation. That's because a surprising
amount of the time, all those longs have the value 0, or maybe 1. The string "0"
would be two bytes, while binary is four. Of course, this doesn't fit well with
fixed-length messages. Decisions, decisions.
この 32 ビット時代、バイナリデータは ASCII 表現のほうが小さくなることが多い。
というのも、long なのに値が 0 ばっかりでたまに 1 だとかいうことは驚くほど多いからだ。
文字列なら "0" は 2 バイトなのに、バイナリは 4 バイトも喰う。
もちろんこれは固定長メッセージには合わないが。さあ、どうする、どうする。
切断
====
..
Strictly speaking, you're supposed to use ``shutdown`` on a socket before you
``close`` it. The ``shutdown`` is an advisory to the socket at the other end.
Depending on the argument you pass it, it can mean "I'm not going to send
anymore, but I'll still listen", or "I'm not listening, good riddance!". Most
socket libraries, however, are so used to programmers neglecting to use this
piece of etiquette that normally a ``close`` is the same as ``shutdown();
close()``. So in most situations, an explicit ``shutdown`` is not needed.
厳密には、ソケットを ``close`` する前には ``shutdown`` する
ことになっている。 ``shutdown`` は相手ソケットに対する報告であり、
渡す引数によって「これ以上こっちからは送らないけど、まだ聞いてるぜ」
という意味になったり、「もう聞かない。せいせいした!」だったりする。
しかしほとんどのソケットライブラリは、
このエチケットを怠るプログラマに慣れてしまって、通常 ``close`` だけで
``shutdown(); close()`` と同じことになる。だから大抵はわざわざ
``shutdown`` しなくてもいい。
..
One way to use ``shutdown`` effectively is in an HTTP-like exchange. The client
sends a request and then does a ``shutdown(1)``. This tells the server "This
client is done sending, but can still receive." The server can detect "EOF" by
a receive of 0 bytes. It can assume it has the complete request. The server
sends a reply. If the ``send`` completes successfully then, indeed, the client
was still receiving.
``shutdown`` の効果的な使い方のひとつは、HTTP 風のやりとりだ。
クライアントは要求を出してすぐに ``shutdown(1)`` する。これでサーバに、
「クライアントは送信完了ですが、まだ受信可能です」と伝わる。
サーバは 0 バイト受信で "EOF" を検出することができる。
要求を残さず受け取ったことにして良いのだ。対してサーバは返答を送る。
その ``send`` が成功したなら、クライアントは実際にまだ受信していたことになる。
..
Python takes the automatic shutdown a step further, and says that when a socket
is garbage collected, it will automatically do a ``close`` if it's needed. But
relying on this is a very bad habit. If your socket just disappears without
doing a ``close``, the socket at the other end may hang indefinitely, thinking
you're just being slow. *Please* ``close`` your sockets when you're done.
Python はこの自動 shutdown をもう一歩進めて、ソケットが GC
されるときに必要なら自動で ``close`` してくれると言っている。
しかしこれに頼るクセをつけてはいけない。もしソケットが ``close`` せずに姿を消せば、
相手ソケットはこちらが遅いだけだと思ってハングしてしまうかもしれない。
*お願いだから* 終わったらちゃんと ``close`` してくれ。
ソケットが死ぬと
----------------
..
Probably the worst thing about using blocking sockets is what happens when the
other side comes down hard (without doing a ``close``). Your socket is likely to
hang. SOCKSTREAM is a reliable protocol, and it will wait a long, long time
before giving up on a connection. If you're using threads, the entire thread is
essentially dead. There's not much you can do about it. As long as you aren't
doing something dumb, like holding a lock while doing a blocking read, the
thread isn't really consuming much in the way of resources. Do *not* try to kill
the thread - part of the reason that threads are more efficient than processes
is that they avoid the overhead associated with the automatic recycling of
resources. In other words, if you do manage to kill the thread, your whole
process is likely to be screwed up.
ブロッキングソケットを使っていて一番いやなのは多分、
相手側が意地悪く (``close`` せずに) ダウンするときに起こる事柄だ。
自分側のソケットは高確率でハングするだろう。SOCKSTREAM は信頼性の高いプロトコルなので、
ずっとずっと待ち続けて、なかなか見捨てないのだ。スレッドを使っているのであれば、
そのスレッド全体が根本から死んだ状態になる。こうなると、もう手の施しようがない。
まあ、ブロッキング読み出しの間ロックし続けるといった馬鹿げたことをしていない限り、
リソースの点ではたいして消費にならない。だから *ぜったいに* そのスレッドを
殺そうとしてはいけない - プロセスよりスレッドが効率的である理由のひとつは、
自動リソース回収にまつわるオーバヘッドを避けられるという点にあるのだ。
つまり別の言い方をすると、どうにかしてそのスレッドを殺したなら、
プロセス全体がぐちゃぐちゃになってしまうだろうということだ。
ノンブロッキングソケット
========================
..
If you've understood the preceeding, you already know most of what you need to
know about the mechanics of using sockets. You'll still use the same calls, in
much the same ways. It's just that, if you do it right, your app will be almost
inside-out.
ここまで理解してきたなら、もうソケットの仕組みについて必要なことはほとんど知っていることになる。
これからも同じコールを、ほぼ同じように使っていくだけ、それだけだ。
これをちゃんとやっていれば、そのアプリはだいたい完璧であろう。
..
In Python, you use ``socket.setblocking(0)`` to make it non-blocking. In C, it's
more complex, (for one thing, you'll need to choose between the BSD flavor
``O_NONBLOCK`` and the almost indistinguishable Posix flavor ``O_NDELAY``, which
is completely different from ``TCP_NODELAY``), but it's the exact same idea. You
do this after creating the socket, but before using it. (Actually, if you're
nuts, you can switch back and forth.)
Python の場合、ノンブロッキングにするには ``socket.setblocking(0)`` を使う。
C ならもっと複雑だ (一例を挙げると、BSD 方式の ``O_NONBLOCK`` およびほぼ違いのない
POSIX 方式 ``O_NDELAY`` のどちらを選ぶか決めなくてはならなくて、後者は
``TCP_NODELAY`` とは全然別物だったりする) が、考え方はまったく一緒だ。
..
The major mechanical difference is that ``send``, ``recv``, ``connect`` and
``accept`` can return without having done anything. You have (of course) a
number of choices. You can check return code and error codes and generally drive
yourself crazy. If you don't believe me, try it sometime. Your app will grow
large, buggy and suck CPU. So let's skip the brain-dead solutions and do it
right.
構造上の大きな違いは、 ``send``, ``recv``, ``connect``, ``accept``
が何もしないで戻ってくるかもしれないという点である。
選択肢は (当然ながら) いくつかある。
返り値とエラーコードをチェックするという方法もある。が、発狂すること請け合いだ。
信じないなら、いつかやってみるといい。
アプリは肥大化し、バグが増え、CPU を喰い尽くすだろう。
だからそんな愚かな解法は飛ばして、正解に進もう。
..
Use ``select``.
``select`` を使え。
..
In C, coding ``select`` is fairly complex. In Python, it's a piece of cake, but
it's close enough to the C version that if you understand ``select`` in Python,
you'll have little trouble with it in C. ::
C において ``select`` でコードを書くのはかなり面倒だが、Python
なら造作もない。しかし Python で ``select`` を理解しておけば
C でもほとんど問題なく書ける、という程度には似ている。 ::
readable, writable, in_error = \
select.select(
potential_readers,
potential_writers,
potential_errs,
timeout)
..
You pass ``select`` three lists: the first contains all sockets that you might
want to try reading; the second all the sockets you might want to try writing
to, and the last (normally left empty) those that you want to check for errors.
You should note that a socket can go into more than one list. The ``select``
call is blocking, but you can give it a timeout. This is generally a sensible
thing to do - give it a nice long timeout (say a minute) unless you have good
reason to do otherwise.
``select`` に三つのリストを渡しているが、
一番目にはあとで読みたくなるかもしれないソケットすべて、
二番目には書き込みたくなるかもしれないソケットすべて、
最後に (通常は空のままだが) エラーをチェックしたいソケットが入っている。
ひとつのソケットが複数にまたがってリストされても構わないことを憶えておくと良い。
なお、 ``select`` コールはブロックするが、時間制限を与えることができる。
これは、やっておいて損はない - 特に理由がなければ、
かなり長い (たとえば 1 分とかの) 時間制限を付けておくことだ。
..
In return, you will get three lists. They have the sockets that are actually
readable, writable and in error. Each of these lists is a subset (possibly
empty) of the corresponding list you passed in. And if you put a socket in more
than one input list, it will only be (at most) in one output list.
それら引数の見返りとして手に入るのは三つのリストである。
それぞれには、実際に読めるソケット、書けるソケット、エラー中のソケットが入っていて、
渡したリストの部分集合 (空集合かもしれない) になっている。
ひとつのソケットを入力リストのうち複数に入れても、
出力リストには (最大でも) ひとつにしか入らない。
..
If a socket is in the output readable list, you can be
as-close-to-certain-as-we-ever-get-in-this-business that a ``recv`` on that
socket will return *something*. Same idea for the writable list. You'll be able
to send *something*. Maybe not all you want to, but *something* is better than
nothing. (Actually, any reasonably healthy socket will return as writable - it
just means outbound network buffer space is available.)
出力のうち、readable リストにあるソケットについては、
``recv`` がとりあえず *何か* を返すであろう、ということは史上最高度に確信できる。
writable リストも考え方は同じで、 *何か* は送れる。
送りたいもの全体は無理かもしれないが、 *何も* ないよりはマシだろう。
(実のところ、ふつうに健康なソケットなら writable で返ってくることができる -
それは外向きネットワークバッファに空きがあるというだけの意味しかないのだから)
..
If you have a "server" socket, put it in the potential_readers list. If it comes
out in the readable list, your ``accept`` will (almost certainly) work. If you
have created a new socket to ``connect`` to someone else, put it in the
potential_writers list. If it shows up in the writable list, you have a decent
chance that it has connected.
「サーバ」ソケットは potential_readers リストに入れておこう。
それが readable リストに入って出てきたら、 ``accept`` は (ほぼ) 確実に成功するはずだ。
どこかへ ``connect`` するために作った新しいソケットは potential_writers リストに入れる。
それが writable リストに現れたら、接続が成功している可能性は高いと言える。
..
One very nasty problem with ``select``: if somewhere in those input lists of
sockets is one which has died a nasty death, the ``select`` will fail. You then
need to loop through every single damn socket in all those lists and do a
``select([sock],[],[],0)`` until you find the bad one. That timeout of 0 means
it won't take long, but it's ugly.
``select`` の実にいやらしい問題がひとつ:
突然死したソケットが入力側リストのどこかにあれば、 ``select`` は失敗してしまう。
そうなると、見つけるまですべてのリストでループしてソケットをひとつひとつ
``select([sock],[],[],0)`` していく必要がある。
時間制限を 0 にしてあるので長くはかからないが、これは美しくない。
..
Actually, ``select`` can be handy even with blocking sockets. It's one way of
determining whether you will block - the socket returns as readable when there's
something in the buffers. However, this still doesn't help with the problem of
determining whether the other end is done, or just busy with something else.
じつは ``select`` はブロッキングソケットにも便利に使える。
それはブロックするかどうかを見極める方法のひとつである -
バッファに何かがあれば readable として返ってくるのだ。
しかしこれも、相手の用事がもう済んでいるのか、
それとも単に他のことで忙しいだけなのかを見極める役には立たない。
..
**Portability alert**: On Unix, ``select`` works both with the sockets and
files. Don't try this on Windows. On Windows, ``select`` works with sockets
only. Also note that in C, many of the more advanced socket options are done
differently on Windows. In fact, on Windows I usually use threads (which work
very, very well) with my sockets. Face it, if you want any kind of performance,
your code will look very different on Windows than on Unix.
**非互換警報**: Unix ではソケットにもファイルにも ``select`` が使える。
これを Windows でやろうとしてはいけない。Windows で ``select`` はソケットにしか使えない。
また C の場合、高度なソケットオプションの多くは、やり方が Windows では違っている。
実際、Windows なら著者は通常、ソケットにスレッドを使っている (これは実に、実にうまくいく)。
認めたくないが、何らかの性能を求めるなら Windows のコードは
Unix のコードとはかなり異なるものになってしまうだろう。
性能
----
..
There's no question that the fastest sockets code uses non-blocking sockets and
select to multiplex them. You can put together something that will saturate a
LAN connection without putting any strain on the CPU. The trouble is that an app
written this way can't do much of anything else - it needs to be ready to
shuffle bytes around at all times.
最速のソケットコードはノンブロッキングソケットを使って
select で多重化するものだということに疑問の余地はない。
CPU に負荷をかけることなく LAN 接続を使いきるアプリは作れる。
問題は、そうやって書かれたものはあまり他のことができなくなるということだ -
いつでもデータをあちらこちらへ廻せるようにしている必要があるのだ。
..
Assuming that your app is actually supposed to do something more than that,
threading is the optimal solution, (and using non-blocking sockets will be
faster than using blocking sockets). Unfortunately, threading support in Unixes
varies both in API and quality. So the normal Unix solution is to fork a
subprocess to deal with each connection. The overhead for this is significant
(and don't do this on Windows - the overhead of process creation is enormous
there). It also means that unless each subprocess is completely independent,
you'll need to use another form of IPC, say a pipe, or shared memory and
semaphores, to communicate between the parent and child processes.
もっと他にやることがあるアプリなのだとすれば、スレッドが最適解だ
(さらにノンブロッキングソケットを使えばブロッキングより速い)。
しかし残念ながら、各種 Unix のスレッド対応は API も品質もバラバラである。
そのため Unix の一般解は、それぞれの接続を取り扱う子プロセスをフォークするというものだ。
このオーバヘッドは甚大 (Windows ではプロセス生成のオーバヘッドが洒落にならないので無理) だ。
それに、子プロセスがお互い完全に独立しているのでない限り、
親子のプロセス間で通信するために他の IPC, たとえばパイプとか、
共有メモリとセマフォだとかを使う必要が出てくる。
..
Finally, remember that even though blocking sockets are somewhat slower than
non-blocking, in many cases they are the "right" solution. After all, if your
app is driven by the data it receives over a socket, there's not much sense in
complicating the logic just so your app can wait on ``select`` instead of
``recv``.
最後に、これを憶えておいてほしい。
ブロッキングソケットはノンブロッキングよりも幾分遅いとはいえ、
多くの場合そちらが「正解」である。
結局のところ、ソケットから受け取るデータに基づいて動くアプリなら、
``recv`` のかわりに ``select`` で待てるようにするためだけにロジックを複雑化する意味はあまりない。
Python-2.6.2-DocJa-1/_sources/howto/webservers.txt 0000644 0001750 0001750 00000100441 11476415437 021444 0 ustar inada-n inada-n **************************************
HOWTO Use Python in the web (英語)
**************************************
:Author: Marek Kubica
.. topic:: Abstract
This document shows how Python fits into the web. It presents some ways on
how to integrate Python with the web server and general practices useful for
developing web sites.
Programming for the Web has become a hot topic since the raise of the "Web 2.0",
which focuses on user-generated content on web sites. It has always been
possible to use Python for creating web sites, but it was a rather tedious task.
Therefore, many so-called "frameworks" and helper tools were created to help
developers creating sites faster and these sites being more robust. This HOWTO
describes some of the methods used to combine Python with a web server to create
dynamic content. It is not meant as a general introduction as this topic is far
too broad to be covered in one single document. However, a short overview of
the most popular libraries is provided.
.. seealso::
While this HOWTO tries to give an overview over Python in the Web, it cannot
always be as up to date as desired. Web development in Python is moving
forward rapidly, so the wiki page on `Web Programming
`_ might be more in sync with
recent development.
The low-level view
==================
.. .. image:: http.png
When a user enters a web site, his browser makes a connection to the site's
webserver (this is called the *request*). The server looks up the file in the
file system and sends it back to the user's browser, which displays it (this is
the *response*). This is roughly how the unterlying protocol, HTTP works.
Now, dynamic web sites are not files in the file system, but rather programs
which are run by the web server when a request comes in. They can do all sorts
of useful things, like display the postings of a bulletin board, show your
mails, configurate software or just display the current time. These programs
can be written in about any programming language the server supports, so it is
easy to use Python for creating dynamic web sites.
As most of HTTP servers are written in C or C++, they cannot execute Python code
in a simple way -- a bridge is needed between the server and the program. These
bridges or rather interfaces define how programs interact with the server. In
the past there have been numerous attempts to create the best possible
interface, but there are only a few worth mentioning.
Not every web server supports every interface. Many web servers do support only
old, now-obsolete interfaces. But they can often be extended using some
third-party modules to support new interfaces.
Common Gateway Interface
------------------------
This interface is the oldest one, supported by nearly every web server out of
the box. Programs using CGI to communicate with their web server need to be
started by the server for every request. So, every request starts a new Python
interpreter -- which takes some time to start up -- thus making the whole
interface only usable for low load situations.
The upside of CGI is that it is simple -- writing a program which uses CGI is a
matter of about three lines of code. But this simplicity comes at a price: it
does very few things to help the developer.
Writing CGI programs, while still possible, is not recommended anymore. With
WSGI (more on that later) it is possible to write programs that emulate CGI, so
they can be run as CGI if no better option is available.
.. seealso::
The Python standard library includes some modules that are helpful for
creating plain CGI programs:
* :mod:`cgi` -- Handling of user input in CGI scripts
* :mod:`cgitb` -- Displays nice tracebacks when errors happen in of CGI
applications, instead of presenting a "500 Internal Server Error" message
The Python wiki features a page on `CGI scripts
`_ with some additional information
about CGI in Python.
Simple script for testing CGI
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
To test whether your web server works with CGI, you can use this short and
simple CGI program::
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
# enable debugging
import cgitb; cgitb.enable()
print "Content-Type: text/plain;charset=utf-8"
print
print "Hello World!"
You need to write this code into a file with a ``.py`` or ``.cgi`` extension,
this depends on your web server configuration. Depending on your web server
configuration, this file may also need to be in a ``cgi-bin`` folder, for
security reasons.
You might wonder what the ``cgitb`` line is about. This line makes it possible
to display a nice traceback instead of just crashing and displaying an "Internal
Server Error" in the user's browser. This is useful for debugging, but it might
risk exposing some confident data to the user. Don't use it when the script is
ready for production use. Still, you should *always* catch exceptions, and
display proper error pages -- end-users don't like to see nondescript "Internal
Server Errors" in their browsers.
Setting up CGI on your own server
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
If you don't have your own web server, this does not apply to you. You can
check whether if works as-is and if not you need to talk to the administrator of
your web server anyway. If it is a big hoster, you can try filing a ticket
asking for Python support.
If you're your own administrator or want to install it for testing purposes on
your own computers, you have to configure it by yourself. There is no one and
single way on how to configure CGI, as there are many web servers with different
configuration options. The currently most widely used free web server is
`Apache HTTPd `_, Apache for short -- this is the one
that most people use, it can be easily installed on nearly every system using
the systems' package management. But `lighttpd `_ has
been gaining attention since some time and is said to have a better performance.
On many systems this server can also be installed using the package management,
so manually compiling the web server is never needed.
* On Apache you can take a look into the `Dynamic Content with CGI
`_ tutorial, where everything
is described. Most of the time it is enough just to set ``+ExecCGI``. The
tutorial also describes the most common gotchas that might arise.
* On lighttpd you need to use the `CGI module
`_ which can be configured
in a straightforward way. It boils down to setting ``cgi.assign`` properly.
Common problems with CGI scripts
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Trying to use CGI sometimes leads to small annoyances that one might experience
while trying to get these scripts to run. Sometimes it happens that a seemingly
correct script does not work as expected, which is caused by some small hidden
reason that's difficult to spot.
Some of these reasons are:
* The Python script is not marked executable. When CGI scripts are not
executable most of the web servers will let the user download it, instead of
running it and sending the output to the user. For CGI scripts to run
properly the ``+x`` bit needs to be set. Using ``chmod a+x your_script.py``
might already solve the problem.
* The line endings must be of Unix-type. This is important because the web
server checks the first line of the script (called shebang) and tries to run
the program specified there. It gets easily confused by Windows line endings
(Carriage Return & Line Feed, also called CRLF), so you have to convert the
file to Unix line endings (only Line Feed, LF). This can be done
automatically by uploading the file via FTP in text mode instead of binary
mode, but the preferred way is just telling your editor to save the files with
Unix line endings. Most proper editors support this.
* Your web server must be able to read the file, you need to make sure the
permissions are fine. Often the server runs as user and group ``www-data``,
so it might be worth a try to change the file ownership or making the file
world readable by using ``chmod a+r your_script.py``.
* The webserver must be able to know that the file you're trying to access is a
CGI script. Check the configuration of your web server, maybe there is some
mistake.
* The path to the interpreter in the shebang (``#!/usr/bin/env python``) must be
currect. This line calls ``/usr/bin/env`` to find Python, but it'll fail if
there is no ``/usr/bin/env``. If you know where your Python is installed, you
can also use that path. The commands ``whereis python`` and ``type -p
python`` might also help to find where it is installed. Once this is known,
the shebang line can be changed accordingly: ``#!/usr/bin/python``.
* The file must not contain a BOM (Byte Order Mark). The BOM is meant for
determining the byte order of UTF-16 encodings, but some editors write this
also into UTF-8 files. The BOM interferes with the shebang line, so be sure
to tell your editor not to write the BOM.
* :ref:`mod-python` might be making problems. mod_python is able to handle CGI
scripts by itself, but it can also be a source for problems. Be sure you
disable it.
.. _mod-python:
mod_python
----------
People coming from PHP often find it hard to grasp how to use Python in the web.
Their first thought is mostly `mod_python `_ because
they think that this is the equivalent to ``mod_php``. Actually it is not
really. It does embed the interpreter into the Apache process, thus speeding up
requests by not having to start a Python interpreter every request. On the
other hand, it is by far not "Python intermixed with HTML" as PHP often does.
The Python equivalent of that is a template engine. mod_python itself is much
more powerful and gives more access to Apache internals. It can emulate CGI, it
can work an a "Python Server Pages" mode similar to JSP which is "HTML
intermangled with Python" and it has a "Publisher" which destignates one file to
accept all requests and decide on what to do then.
But mod_python has some problems. Unlike the PHP interpreter the Python
interpreter uses caching when executing files, so when changing a file the whole
web server needs to be re-started to update. Another problem ist the basic
concept -- Apache starts some child processes to handle the requests and
unfortunately every child process needs to load the whole Python interpreter
even if it does not use it. This makes the whole web server slower. Another
problem is that as mod_python is linked against a specific version of
``libpython``, it is not possible to switch from an older version to a newer
(e.g. 2.4 to 2.5) without recompiling mod_python. mod_python is also bound to
the Apache web server, so programs written for mod_python cannot easily run on
other web servers.
These are the reasons why mod_python should be avoided when writing new
programs. In some circumstances it might be still a good idea to use mod_python
for deployment, but WSGI makes it possible to run WSGI programs under mod_python
as well.
FastCGI and SCGI
----------------
FastCGI and SCGI try to solve the performance problem of CGI in another way.
Instead of embedding the interpreter into the web server, they create
long-running processes which run in the background. There still is some module
in the web server which makes it possible for the web server to "speak" with the
background process. As the background process is independent from the server,
it can be written in any language of course also in Python. The language just
needs to have a library which handles the communication with the web server.
The difference between FastCGI and SCGI is very small, as SCGI is essentially
just a "simpler FastCGI". But as the web server support for SCGI is limited
most people use FastCGI instead, which works the same way. Almost everything
that applies to SCGI also applies to FastCGI as well, so we'll only write about
the latter.
These days, FastCGI is never used directly. Just like ``mod_python`` it is only
used for the deployment of WSGI applications.
.. seealso::
* `FastCGI, SCGI, and Apache: Background and Future
`_
is a discussion on why the concept of FastCGI and SCGI is better that that
of mod_python.
Setting up FastCGI
^^^^^^^^^^^^^^^^^^
Depending on the web server you need to have a special module.
* Apache has both `mod_fastcgi `_ and `mod_fcgid
`_. ``mod_fastcgi`` is the original one, but it
has some licensing issues that's why it is sometimes considered non-free.
``mod_fcgid`` is a smaller, compatible alternative. One of these modules needs
to be loaded by Apache.
* lighttpd ships its own `FastCGI module
`_ as well as an `SCGI
module `_.
* nginx also supports `FastCGI
`_.
Once you have installed and configured the module, you can test it with the
following WSGI-application::
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
from cgi import escape
import sys, os
from flup.server.fcgi import WSGIServer
def app(environ, start_response):
start_response('200 OK', [('Content-Type', 'text/html')])
yield '
FastCGI Environment
'
yield '
'
for k, v in sorted(environ.items()):
yield '
%s
%s
' % (escape(k), escape(v))
yield '
'
WSGIServer(app).run()
This is a simple WSGI application, but you need to install `flup
`_ first, as flup handles the low level
FastCGI access.
.. seealso::
There is some documentation on `setting up Django with FastCGI
`_, most of which can be
reused for other WSGI-compliant frameworks and libraries. Only the
``manage.py`` part has to be changed, the example used here can be used
instead. Django does more or less the exact same thing.
mod_wsgi
--------
`mod_wsgi `_ is an attempt to get rid of the low level
gateways. As FastCGI, SCGI, mod_python are mostly used to deploy WSGI
applications anyway, mod_wsgi was started to directly embed WSGI aplications
into the Apache web server. The benefit from this approach is that WSGI
applications can be deployed much easier as is is specially designed to host
WSGI applications -- unlike the other low level methods which have glue code to
host WSGI applications (like flup which was mentioned before). The downside is
that mod_wsgi is limited to the Apache web server, other servers would need
their own implementations of mod_wsgi.
It supports two modes: the embedded mode in which it integrates with the Apache
process and the daemon mode which is more FastCGI-like. Contrary to FastCGI,
mod_wsgi handles the worker-processes by itself which makes administration
easier.
.. _WSGI:
Step back: WSGI
===============
WSGI was already mentioned several times so it has to be something important.
In fact it really is, so now it's time to explain.
The *Web Server Gateway Interface*, :pep:`333` or WSGI for short is currently
the best possible way to Python web programming. While it is great for
programmers writing frameworks, the normal person does not need to get in direct
contact with it. But when choosing a framework for web development it is a good
idea to take one which supports WSGI.
The big profit from WSGI is the unification. When your program is compatible
with WSGI -- that means that your framework has support for WSGI, your program
can be deployed on every web server interface for which there are WSGI wrappers.
So you do not need to care about whether the user uses mod_python or FastCGI --
with WSGI it just works on any gateway interface. The Python standard library
contains its own WSGI server :mod:`wsgiref`, which is a small web server that
can be used for testing.
A really great WSGI feature are the middlewares. Middlewares are layers around
your program which can add various functionality to it. There is a `number of
middlewares `_ already available.
For example, instead of writing your own session management (to identify a user
in subsequent requests, as HTTP does not maintain state, so it does now know
that the requests belong to the same user) you can just take one middleware,
plug it in and you can rely an already existing functionality. The same thing
is compression -- say you want to compress your HTML using gzip, to save your
server's bandwidth. So you only need to plug-in a middleware and you're done.
Authentication is also a problem easily solved using a middleware.
So, generally -- although WSGI may seem complex, the initial phase of learning
can be very rewarding as WSGI does already have solutions to many problems that
might arise while writing web sites.
WSGI Servers
------------
The code that is used to connect to various low level gateways like CGI or
mod_python is called *WSGI server*. One of these servers is ``flup`` which was
already mentioned and supports FastCGI, SCGI as well as `AJP
`_. Some of these servers
are written in Python as ``flup`` is, but there also exist others which are
written in C and can be used as drop-in replacements.
There are quite a lot of servers already available, so a Python web application
can be deployed nearly everywhere. This is one big advantage that Python has
compared with other web techniques.
.. seealso::
A good overview of all WSGI-related code can be found in the `WSGI wiki
`_, which contains an extensive list of `WSGI servers
`_, which can be used by *every* application
supporting WSGI.
You might be interested in some WSGI-supporting modules already contained in
the standard library, namely:
* :mod:`wsgiref` -- some tiny utilities and servers for WSGI
Case study: MoinMoin
--------------------
What does WSGI give the web application developer? Let's take a look on one
long existing web application written in Python without using WSGI.
One of the most widely used wiki software is `MoinMoin `_.
It was created in 2000, so it predates WSGI by about three years. While it now
includes support for WSGI, older versions needed separate code to run on CGI,
mod_python, FastCGI and standalone. Now, this all is possible by using WSGI and
the already-written gateways. For running with on FastCGI ``flup`` can be used,
for running a standalone server :mod:`wsgiref` is the way to go.
Model-view-controller
=====================
The term *MVC* is often heard in statements like "framework *foo* supports MVC".
While MVC is not really something technical but rather organisational, many web
frameworks use this model to help the developer to bring structure into his
program. Bigger web applications can have lots of code so it is a good idea to
have structure in the program right from the beginnings. That way, even users
of other frameworks (or even languages, as MVC is nothing Python-specific) can
understand the existing code easier, as they are already familiar with the
structure.
MVC stands for three components:
* The *model*. This is the data that is meant to modify. In Python frameworks
this component is often represented by the classes used by the
object-relational mapper. So, all declarations go here.
* The *view*. This component's job is to display the data of the model to the
user. Typically this component is represented by the templates.
* The *controller*. This is the layer between the user and the model. The
controller reacts on user actions (like opening some specific URL) and tells
the model to modify the data if neccessary.
While one might think that MVC is a complex design pattern, in fact it is not.
It is used in Python because it has turned out to be useful for creating clean,
maintainable web sites.
.. note::
While not all Python frameworks explicitly support MVC, it is often trivial
to create a web site which uses the MVC pattern by seperating the data logic
(the model) from the user interaction logic (the controller) and the
templates (the view). That's why it is important not to write unneccessary
Python code in the templates -- it is against MVC and creates more chaos.
.. seealso::
The english Wikipedia has an article about the `Model-View-Controller pattern
`_, which includes a long
list of web frameworks for different programming languages.
Ingredients for web sites
=========================
Web sites are complex constructs, so tools were created to help the web site
developer to make his work maintainable. None of these tools are in any way
Python specific, they also exist for other programming languages as well. Of
course, developers are not forced to use these tools and often there is no
"best" tool, but it is worth informing yourself before choosing something
because of the big number of helpers that the developer can use.
.. seealso::
People have written far more components that can be combined than these
presented here. The Python wiki has a page about these components, called
`Web Components `_.
Templates
---------
Mixing of HTML and Python code is possible with some libraries. While
convenient at first, it leads to horribly unmaintainable code. That's why
templates exist. Templates are, in the simplest case, just HTML files with
placeholders. The HTML is sent to the user's browser after filling out the
placeholders.
Python already includes such simple templates::
# a simple template
template = "
Hello %s!
"
print template % "Reader"
The Python standard library also includes some more advanced templates usable
through :class:`string.Template`, but in HTML templates it is needed to use
conditional and looping contructs like Python's *for* and *if*. So, some
*template engine* is needed.
Now, Python has a lot of template engines which can be used with or without a
`framework`_. Some of these are using a plain-text programming language which
is very easy to learn as it is quite limited while others use XML so the
template output is always guaranteed to be valid XML. Some `frameworks`_ ship
their own template engine or recommend one particular. If one is not yet sure,
using these is a good idea.
.. note::
While Python has quite a lot of different template engines it usually does
not make sense to use a homebrewed template system. The time needed to
evaluate all templating systems is not really worth it, better invest the
time in looking through the most popular ones. Some frameworks have their
own template engine or have a recommentation for one. It's wise to use
these.
Popular template engines include:
* Mako
* Genshi
* Jinja
.. seealso::
Lots of different template engines divide the attention between themselves
because it's easy to create them in Python. The page `Templating
`_ in the wiki lists a big,
ever-growing number of these.
Data persistence
----------------
*Data persistence*, while sounding very complicated is just about storing data.
This data might be the text of blog entries, the postings of a bulletin board or
the text of a wiki page. As always, there are different ways to store
informations on a web server.
Often relational database engines like `MySQL `_ or
`PostgreSQL `_ are used due to their good
performance handling very large databases consisting of up to millions of
entries. These are *queried* using a language called `SQL
`_. Python programmers in general do not like
SQL too much, they prefer to work with objects. It is possible to save Python
objects into a database using a technology called `ORM
`_. ORM translates all
object-oriented access into SQL code under the hood, the user does not need to
think about it. Most `frameworks`_ use ORMs and it works quite well.
A second possibility is using files that are saved on the hard disk (sometimes
called flatfiles). This is very easy, but is not too fast. There is even a
small database engine called `SQLite `_ which is bundled
with Python in the :mod:`sqlite` module and uses only one file. This database
can be used to store objects via an ORM and has no other dependencies. For
smaller sites SQLite is just enough. But it is not the only way in which data
can be saved into the file systems. Sometimes normal, plain text files are
enough.
The third and least used possibility are so-called object oriented databases.
These databases store the *actual objects* instead of the relations that
OR-mapping creates between rows in a database. This has the advantage that
nearly all objects can be saven in a straightforward way, unlike in relational
databases where some objects are very hard to represent with ORMs.
`Frameworks`_ often give the users hints on which method to choose, it is
usually a good idea to stick to these unless there are some special requirements
which require to use the one method and not the other.
.. seealso::
* `Persistence Tools `_ lists
possibilities on how to save data in the file system, some of these modules
are part of the standard library
* `Database Programming `_
helps on choosing a method on how to save the data
* `SQLAlchemy `_, the most powerful OR-Mapper for
Python and `Elixir `_ which makes it easier to
use
* `SQLObject `_, another popular OR-Mapper
* `ZODB `_ and `Durus
`_, two object oriented
databases
.. _framework:
Frameworks
==========
As web sites can easily become quite large, there are so-called frameworks which
were created to help the developer with making these sites. Although the most
well-known framework is Ruby on Rails, Python does also have its own frameworks
which are partly inspired by Rails or which were existing a long time before
Rails.
Two possible approaches to web frameworks exist: the minimalistic approach and
the all-inclusive approach (somtimes called *full-stack*). Frameworks which are
all-inclusive give you everything you need to start working, like a template
engine, some way to save and access data in databases and many features more.
Most users are best off using these as they are widely used by lots of other
users and well documented in form of books and tutorials. Other web frameworks
go the minimalistic approach trying to be as flexible as possible leaving the
user the freedom to choose what's best for him.
The majority of users is best off with all-inclusive framewors. They bring
everything along so a user can just jump in and start to code. While they do
have some limitations they can fullfill 80% of what one will ever want to
perfectly. They consist of various components which are designed to work
together as good as possible.
The multitude of web frameworks written in Python demonstrates that it is really
easy to write one. One of the most well-known web applications written in
Python is `Zope `_ which can be regarded as some kind of
big framework. But Zope was not the only framework, there were some others
which are by now nearly forgotten. These do not need to be mentioned anymore,
because most people that used them moved on to newer ones.
Some notable frameworks
-----------------------
There is an incredible number of frameworks, so there is no way to describe them
all. It is not even neccessary, as most of these frameworks are nothing special
and everything that can be done with these can also be done with one of the
popular ones.
Django
^^^^^^
`Django `_ is a framework consisting of several
tightly coupled elements which were written from scratch and work together very
well. It includes an ORM which is quite powerful while being simple to use and
has a great online administration interface which makes it possible to edit the
data in the database with a browser. The template engine is text-based and is
designed to be usable for page designers who cannot write Python. It supports
so-called template inheritance and filters (which work like Unix pipes). Django
has many handy features bundled, like creation of RSS feeds or generic views
which make it possible to write web sites nearly without any Python code.
It has a big, international community which has created many sites using Django.
There are also quite a lot of add-on projects which extend Django's normal
functionality. This is partly due to Django's well written `online
documentation `_ and the `Django book
`_.
.. note::
Although Django is an MVC-style framework, it calls the components
differently, which is described in the `Django FAQ
`_.
TurboGears
^^^^^^^^^^
The other popular web framework in Python is `TurboGears
`_. It takes the approach of using already existing
components and combining them with glue code to create a seamless experience.
TurboGears gives the user more flexibility on which components to choose, the
ORM can be switched between some easy to use but limited and complex but very
powerful. Same goes for the template engine. One strong point about TurboGears
is that the components that it consists of can be used easily in other projects
without depending on TurboGears, for example the underlying web server CherryPy.
The documentation can be found in the `TurboGears wiki
`_, where links to screencasts can be found.
TurboGears has also an active user community which can respond to most related
questions. There is also a `TurboGears book `_
published, which is a good starting point.
The plan for the next major version of TurboGears, version 2.0 is to switch to a
more flexible base provided by another very flexible web framework called
`Pylons `_.
Other notable frameworks
^^^^^^^^^^^^^^^^^^^^^^^^
These two are of course not the only frameworks that are available, there are
also some less-popular frameworks worth mentioning.
One of these is the already mentioned Zope, which has been around for quite a
long time. With Zope 2.x having been known as rather un-pythonic, the newer
Zope 3.x tries to change that and therefore gets more acceptance from Python
programmers. These efforts already showed results, there is a project which
connects Zope with WSGI called `Repoze `_ and another
project called `Grok `_ which makes it possible for
"normal" Python programmers use the very mature Zope components.
Another framework that's already been mentioned is `Pylons`_. Pylons is much
like TurboGears with ab even stronger emphasis on flexibility, which is bought
at the cost of being more difficult to use. Nearly every component can be
exchanged, which makes it neccessary to use the documentation of every single
component, because there are so many Pylons combinations possible that can
satisfy every requirement. Pylons builds upon `Paste
`_, an extensive set of tools which are handy for WSGI.
And that's still not everything. The most up-to-date information can always be
found in the Python wiki.
.. seealso::
The Python wiki contains an extensive list of `web frameworks
`_.
Most frameworks also have their own mailing lists and IRC channels, look out
for these on the projects' websites. There is also a general "Python in the
Web" IRC channel on freenode called `#python.web
`_.
Python-2.6.2-DocJa-1/_sources/howto/doanddont.txt 0000644 0001750 0001750 00000033014 11474251541 021220 0 ustar inada-n inada-n *********************************
Python 良い慣用句、悪い慣用句
*********************************
:Author: Moshe Zadka
This document is placed in the public domain.
(この文書はパブリックドメインです。)
.. topic:: 概要
この文書はチュートリアルのおまけと考えてもらって結構です。
Python をどう使うべきか、そして更に重要なこととして、どう
使うべきで *ない* かを例示しています。
使うべきでない構文
==================
Python の落とし穴は他言語と比べればほとんどないようなものですが、
中には特殊な場面でしか役に立たなかったり、単に危険なだけの構文も
存在しています。
from モジュール import \*
-------------------------
関数定義の中で
^^^^^^^^^^^^^^
関数定義内での ``from モジュール import *`` は *不正* です。
多くの古い Python では不正としてチェックされないものの、
だからと言って有効になるわけではありません。
やり手の弁護士を雇って無罪になっても、潔白になれるわけではないのと同じですね。
ですから絶対にそういう使い方をしないでください。
不正にされないバージョンでも、コンパイラはどの名前がローカルで
どの名前がグローバルなのか判然としなくなるので、関数の実行が
遅くなってしまいます。Python 2.1 で、この構文は警告や、
場合によってはエラーも出すようになりました。
モジュールレベルで
^^^^^^^^^^^^^^^^^^
モジュールレベルで ``from モジュール import *`` を使うのは
有効ではありますが、大抵は、やめたほうが良いですよ。
理由のひとつとして、それをやると本来 Python が持っている
大事な特徴を失ってしまうということが挙げられます。
その特徴とは、トップレベルの名前がそれぞれどこで定義されているのか、
エディタの検索機能だけでわかるというものです。
それに、将来モジュールに関数やクラスが増えていくと、
ややこしいことになりかねません。
ニュースグループで出てくる最低の質問には、なぜこのコード::
f = open("www")
f.read()
が動かないのか、というものがあります。もちろんこれで動きますよ
(ただし "www" というファイルがあれば)。でもモジュールのどこかに
``from os import *`` があればダメです。 :mod:`os` モジュール
は、整数を返す :func:`open` 関数を持っているのです。これは
とても便利ではありますが、ビルトインを隠してしまうのは、
非常に不便な特徴のひとつと言えます。
モジュールがエクスポートする名前は確実にはわからないのですから、必要なものだけ
``from モジュール import 名前1, 名前2`` で取るか、モジュールから出さずに
``import モジュール;print モジュール.name`` としておいて必要に応じてアクセスする
ようにしましょう。
問題ない状況
^^^^^^^^^^^^
``from モジュール import *`` が問題とならない状況もあります:
* 対話的プロンプト。たとえば ``from math import *`` すれば
Python がスーパー関数電卓に変身します。
* C のモジュールを Python のモジュールで拡張するとき。
* そのモジュールは ``from import *`` 可だ、と作者が言っているとき。
そのまんまな :keyword:`exec`, :func:`execfile` と仲間たち
---------------------------------------------------------
「そのまんま」という言葉は辞書を明示せずに使うという意味で、
そういう構文ではコードが *その時点の* 環境に対して評価されます。
これは ``from import *`` と同じ理由で危険です --- 使っている最中の変数を
土足で踏んで行って、コード全体をメチャクチャにしてしまう可能性があるからです。
これは、とにかくやめてください。
悪い見本::
>>> for name in sys.argv[1:]:
>>> exec "%s=1" % name
>>> def func(s, **kw):
>>> for var, val in kw.items():
>>> exec "s.%s=val" % var # ダメ!
>>> execfile("handler.py")
>>> handle()
良い見本::
>>> d = {}
>>> for name in sys.argv[1:]:
>>> d[name] = 1
>>> def func(s, **kw):
>>> for var, val in kw.items():
>>> setattr(s, var, val)
>>> d={}
>>> execfile("handle.py", d, d)
>>> handle = d['handle']
>>> handle()
from モジュール import 名前1, 名前2
-----------------------------------
今回のは、これまでの「ダメ」よりかなり弱い「ダメ」ですが、やはりそれなりの
理由がなければ、やめておいたほうが良いことに変わりありません。
これが大抵うまくないのは、いつの間にか
二つ別々の名前空間に住む一つのオブジェクトを持つことになるからです。
一方の名前空間でそのバインディングが変更されたとき、もう一方の
バインディングは変更されないので、食い違いができてしまいます。
これが起こるのは、たとえば、モジュールを読み直したり、
ランタイムで関数の定義を変更したときなどです。
悪い見本::
# foo.py
a = 1
# bar.py
from foo import a
if something():
a = 2 # 危険: foo.a != a
良い見本::
# foo.py
a = 1
# bar.py
import foo
if something():
foo.a = 2
except:
-------
Python には ``except:`` 節があり、これはあらゆる例外を捕捉します。
Python のエラーは *すべて* 例外を出しますから、こんなことをすれば
各種のプログラミングエラーがランタイムの問題のように見えてしまい、
デバグの邪魔になります。
以下のコードが好例です::
try:
foo = opne("file") # "open" を打ち間違えた
except:
sys.exit("could not open file!")
この 2 行目は :exc:`NameError` を引き起こし、続く except 節で捕捉されます。
プログラムがエラー終了しますが、実際の問題は ``"file"`` の読み出しと
関係ないことなど、これではまったくわかりません。
前述の例はこう書けばマシになります::
try:
foo = opne("file") # 実行すればすぐ "open" に直すことになる
except IOError:
sys.exit("could not open file")
``except:`` 節が役立つ状況もあります: たとえば、フレームワークで
コールバックを実行するとき、コールバックがフレームワーク自体の
邪魔をしないようにするのは良いことです。
例外
====
例外は Python の有用な機能です。何か期待している以外のことが
起これば例外を出す、という習慣を持つべきですが、それと同時に、
何か対処できるときにだけ捕捉する、ということも習慣にしてください。
以下は非常にありがちな悪い見本です::
def get_status(file):
if not os.path.exists(file):
print "file not found"
sys.exit(1)
return open(file).readline()
ここで、 :func:`os.path.exists` を呼んでから :func:`open` を呼ぶまでの間に
ファイルが消された場合を考えてください。そうなれば最後の行は :exc:`IOError` を
投げるでしょう。同じことは、 *file* は存在しているけれど読み出し権限がなかった、
という場合にも起こります。これをテストする際、ふつうのマシンで、存在するファイル
と存在しないファイルに対してだけやったのではバグがないように見えてしまい、テスト
結果が大丈夫そうなのでコードはそのまま出荷されてしまうことになります。こうして、
対処されない :exc:`IOError` はユーザの所まで逃げのびて、
汚いトレースバックを見せることになるのです。
もっと良い方法はこちら::
def get_status(file):
try:
return open(file).readline()
except (IOError, OSError):
print "file not found"
sys.exit(1)
このバージョンでは、ファイルが開かれて一行目も読まれる (だから、あてにならない
NFS や SMB 接続でも動く) か、あるいはメッセージが表示されてアプリケーションが
強制終了するかの \*いずれか\* 一方しか起こりません。
とはいえ、このバージョンの :func:`get_status` でさえ、前提としている条件が
多過ぎます --- すぐ終わるスクリプトでだけ使って、長く動作させる、いわゆる
サーバでは使わない前提なのです。もちろん呼び出し側はこうすることもできます::
try:
status = get_status(log)
except SystemExit:
status = None
でも、もっと良い方法があります。コードで使う ``except`` 節を、
できるだけ少なくするのです --- 使うとすれば、
必ず成功するはずの呼び出し内か、main 関数での全捕捉ですね。
というわけで、たぶんもっと良い :func:`get_status` はこちら::
def get_status(file):
return open(file).readline()
呼び出した側は、望むなら例外を処理することもできますし (たとえばループで
複数ファイルに試行するときとか)、そのまま *自分の* 呼び出し親まで上げる
こともできます。
しかし、この最終バージョンにも深刻な問題があります --- CPython 実装の
細部に原因があるのですが、例外が起きたときにはその例外ハンドラが
終了するまでファイルが閉じられないのです; しかも、なお悪いことに、
他の実装 (たとえば Jython) では例外の有無に関わらず閉じられません。
この関数の一番良いバージョンでは :func:`open` をコンテクストマネジャ
として使って、関数が返るとすぐにファイルが閉じられるようにしています::
def get_status(file):
with open(file) as fp:
return fp.readline()
使い捨てじゃなくて充電池を使う
==============================
どうも皆、Python ライブラリに最初からあるものを自分で書こうとして、
大抵うまくいっていないようです。そういう場当たりなモジュールには
貧弱なインタフェースしかないことを考えると、ふつうは Python に付いてくる
高機能な標準ライブラリとデータ型を使うほうが、自分でひねり出すより
格段に良いですよ。
便利なのにほとんど知られていないモジュールに :mod:`os.path` があります。
このモジュールには OS に合ったパス演算が備わっていて、大抵は
自分でどれだけ苦労して作ったものよりもずっと良いものです。
比べてください::
# うげえ!
return dir+"/"+file
# 改良版
return os.path.join(dir, file)
:mod:`os.path` にはさらに便利な関数が他にもあります: :func:`basename` や
:func:`dirname`, :func:`splitext` などです。
加えて、なぜか気付かれていない多くのビルトイン関数があります:
たとえば :func:`min` と :func:`max` を使えば、大小比較のできるシーケンスなら
何からでも最小値/最大値を見つけることができるのに、多くの人々が自家製の
:func:`max`/:func:`min` を書いています。また別の超便利な関数は
:func:`reduce` です。古典的な使い方はこういった感じです::
import sys, operator
nums = map(float, sys.argv[1:])
print reduce(operator.add, nums)/len(nums)
このキュートな小っちゃいスクリプトが、コマンドラインで与えられた数値
すべての平均値を表示するのです。 :func:`reduce` がすべての数を
合計する部分で、残りは単なる準備や後処理に過ぎません。
ついでにメモ。 :func:`float` と :func:`int` と :func:`long` はすべて
文字列型の引数を受け付けますから、パース処理にピッタリです --- ただし
:exc:`ValueError` に対応できるよう準備は必要ですが。
バックスラッシュで文を続ける
============================
Python は改行を文の終わりとして扱いますので、そして文は一行
にうまく収まらないことがよくありますので、こうする人が多いです::
if foo.bar()['first'][0] == baz.quux(1, 2)[5:9] and \
calculate_number(10, 20) != forbulate(500, 360):
pass
これは危険だということに気づいたほうが良いですよ: はぐれスペースが ``\``
の後に来ればその行の意味が変わってしまいますが、
スペースはエディタで見えにくいことに定評があるのです。
今回の場合は構文エラーにはなりますが、もしこうなら::
value = foo.bar()['first'][0]*baz.quux(1, 2)[5:9] \
+ calculate_number(10, 20)*forbulate(500, 360)
微妙に違う意味になるだけで、エラーが出ません。
それで、ふつうは括弧に入れて暗黙のうちに行をつなげるほうが賢明です:
このバージョンで鉄壁です::
value = (foo.bar()['first'][0]*baz.quux(1, 2)[5:9]
+ calculate_number(10, 20)*forbulate(500, 360))
Python-2.6.2-DocJa-1/_sources/howto/jptranslation.txt 0000644 0001750 0001750 00000001177 11476415633 022151 0 ustar inada-n inada-n .. highlightlang:: c
このドキュメントについて
========================
この文書は、Pythonドキュメント翻訳プロジェクトによる "Python HOWTO"
の日本語訳版です。
日本語訳に対する質問や提案などがありましたら、Pythonドキュメント
翻訳プロジェクトのメーリングリスト
``_
または、プロジェクトのバグ管理ページ
``_
までご報告ください。
翻訳者一覧 (敬称略)
===================
* TAKAHASHI Tamotsu
Python-2.6.2-DocJa-1/_sources/howto/regex.txt 0000644 0001750 0001750 00000167216 11476415372 020402 0 ustar inada-n inada-n .. _regex-howto:
***********************************
Regular Expression HOWTO (英語)
***********************************
:Author: A.M. Kuchling
:Release: 0.05
.. TODO:
Document lookbehind assertions
Better way of displaying a RE, a string, and what it matches
Mention optional argument to match.groups()
Unicode (at least a reference)
.. topic:: Abstract
This document is an introductory tutorial to using regular expressions in Python
with the :mod:`re` module. It provides a gentler introduction than the
corresponding section in the Library Reference.
Introduction
============
The :mod:`re` module was added in Python 1.5, and provides Perl-style regular
expression patterns. Earlier versions of Python came with the :mod:`regex`
module, which provided Emacs-style patterns. The :mod:`regex` module was
removed completely in Python 2.5.
Regular expressions (called REs, or regexes, or regex patterns) are essentially
a tiny, highly specialized programming language embedded inside Python and made
available through the :mod:`re` module. Using this little language, you specify
the rules for the set of possible strings that you want to match; this set might
contain English sentences, or e-mail addresses, or TeX commands, or anything you
like. You can then ask questions such as "Does this string match the pattern?",
or "Is there a match for the pattern anywhere in this string?". You can also
use REs to modify a string or to split it apart in various ways.
Regular expression patterns are compiled into a series of bytecodes which are
then executed by a matching engine written in C. For advanced use, it may be
necessary to pay careful attention to how the engine will execute a given RE,
and write the RE in a certain way in order to produce bytecode that runs faster.
Optimization isn't covered in this document, because it requires that you have a
good understanding of the matching engine's internals.
The regular expression language is relatively small and restricted, so not all
possible string processing tasks can be done using regular expressions. There
are also tasks that *can* be done with regular expressions, but the expressions
turn out to be very complicated. In these cases, you may be better off writing
Python code to do the processing; while Python code will be slower than an
elaborate regular expression, it will also probably be more understandable.
Simple Patterns
===============
We'll start by learning about the simplest possible regular expressions. Since
regular expressions are used to operate on strings, we'll begin with the most
common task: matching characters.
For a detailed explanation of the computer science underlying regular
expressions (deterministic and non-deterministic finite automata), you can refer
to almost any textbook on writing compilers.
Matching Characters
-------------------
Most letters and characters will simply match themselves. For example, the
regular expression ``test`` will match the string ``test`` exactly. (You can
enable a case-insensitive mode that would let this RE match ``Test`` or ``TEST``
as well; more about this later.)
There are exceptions to this rule; some characters are special
:dfn:`metacharacters`, and don't match themselves. Instead, they signal that
some out-of-the-ordinary thing should be matched, or they affect other portions
of the RE by repeating them or changing their meaning. Much of this document is
devoted to discussing various metacharacters and what they do.
Here's a complete list of the metacharacters; their meanings will be discussed
in the rest of this HOWTO. ::
. ^ $ * + ? { [ ] \ | ( )
The first metacharacters we'll look at are ``[`` and ``]``. They're used for
specifying a character class, which is a set of characters that you wish to
match. Characters can be listed individually, or a range of characters can be
indicated by giving two characters and separating them by a ``'-'``. For
example, ``[abc]`` will match any of the characters ``a``, ``b``, or ``c``; this
is the same as ``[a-c]``, which uses a range to express the same set of
characters. If you wanted to match only lowercase letters, your RE would be
``[a-z]``.
Metacharacters are not active inside classes. For example, ``[akm$]`` will
match any of the characters ``'a'``, ``'k'``, ``'m'``, or ``'$'``; ``'$'`` is
usually a metacharacter, but inside a character class it's stripped of its
special nature.
You can match the characters not listed within the class by :dfn:`complementing`
the set. This is indicated by including a ``'^'`` as the first character of the
class; ``'^'`` outside a character class will simply match the ``'^'``
character. For example, ``[^5]`` will match any character except ``'5'``.
Perhaps the most important metacharacter is the backslash, ``\``. As in Python
string literals, the backslash can be followed by various characters to signal
various special sequences. It's also used to escape all the metacharacters so
you can still match them in patterns; for example, if you need to match a ``[``
or ``\``, you can precede them with a backslash to remove their special
meaning: ``\[`` or ``\\``.
Some of the special sequences beginning with ``'\'`` represent predefined sets
of characters that are often useful, such as the set of digits, the set of
letters, or the set of anything that isn't whitespace. The following predefined
special sequences are available:
``\d``
Matches any decimal digit; this is equivalent to the class ``[0-9]``.
``\D``
Matches any non-digit character; this is equivalent to the class ``[^0-9]``.
``\s``
Matches any whitespace character; this is equivalent to the class ``[
\t\n\r\f\v]``.
``\S``
Matches any non-whitespace character; this is equivalent to the class ``[^
\t\n\r\f\v]``.
``\w``
Matches any alphanumeric character; this is equivalent to the class
``[a-zA-Z0-9_]``.
``\W``
Matches any non-alphanumeric character; this is equivalent to the class
``[^a-zA-Z0-9_]``.
These sequences can be included inside a character class. For example,
``[\s,.]`` is a character class that will match any whitespace character, or
``','`` or ``'.'``.
The final metacharacter in this section is ``.``. It matches anything except a
newline character, and there's an alternate mode (``re.DOTALL``) where it will
match even a newline. ``'.'`` is often used where you want to match "any
character".
Repeating Things
----------------
Being able to match varying sets of characters is the first thing regular
expressions can do that isn't already possible with the methods available on
strings. However, if that was the only additional capability of regexes, they
wouldn't be much of an advance. Another capability is that you can specify that
portions of the RE must be repeated a certain number of times.
The first metacharacter for repeating things that we'll look at is ``*``. ``*``
doesn't match the literal character ``*``; instead, it specifies that the
previous character can be matched zero or more times, instead of exactly once.
For example, ``ca*t`` will match ``ct`` (0 ``a`` characters), ``cat`` (1 ``a``),
``caaat`` (3 ``a`` characters), and so forth. The RE engine has various
internal limitations stemming from the size of C's ``int`` type that will
prevent it from matching over 2 billion ``a`` characters; you probably don't
have enough memory to construct a string that large, so you shouldn't run into
that limit.
Repetitions such as ``*`` are :dfn:`greedy`; when repeating a RE, the matching
engine will try to repeat it as many times as possible. If later portions of the
pattern don't match, the matching engine will then back up and try again with
few repetitions.
A step-by-step example will make this more obvious. Let's consider the
expression ``a[bcd]*b``. This matches the letter ``'a'``, zero or more letters
from the class ``[bcd]``, and finally ends with a ``'b'``. Now imagine matching
this RE against the string ``abcbd``.
+------+-----------+---------------------------------+
| Step | Matched | Explanation |
+======+===========+=================================+
| 1 | ``a`` | The ``a`` in the RE matches. |
+------+-----------+---------------------------------+
| 2 | ``abcbd`` | The engine matches ``[bcd]*``, |
| | | going as far as it can, which |
| | | is to the end of the string. |
+------+-----------+---------------------------------+
| 3 | *Failure* | The engine tries to match |
| | | ``b``, but the current position |
| | | is at the end of the string, so |
| | | it fails. |
+------+-----------+---------------------------------+
| 4 | ``abcb`` | Back up, so that ``[bcd]*`` |
| | | matches one less character. |
+------+-----------+---------------------------------+
| 5 | *Failure* | Try ``b`` again, but the |
| | | current position is at the last |
| | | character, which is a ``'d'``. |
+------+-----------+---------------------------------+
| 6 | ``abc`` | Back up again, so that |
| | | ``[bcd]*`` is only matching |
| | | ``bc``. |
+------+-----------+---------------------------------+
| 6 | ``abcb`` | Try ``b`` again. This time |
| | | the character at the |
| | | current position is ``'b'``, so |
| | | it succeeds. |
+------+-----------+---------------------------------+
The end of the RE has now been reached, and it has matched ``abcb``. This
demonstrates how the matching engine goes as far as it can at first, and if no
match is found it will then progressively back up and retry the rest of the RE
again and again. It will back up until it has tried zero matches for
``[bcd]*``, and if that subsequently fails, the engine will conclude that the
string doesn't match the RE at all.
Another repeating metacharacter is ``+``, which matches one or more times. Pay
careful attention to the difference between ``*`` and ``+``; ``*`` matches
*zero* or more times, so whatever's being repeated may not be present at all,
while ``+`` requires at least *one* occurrence. To use a similar example,
``ca+t`` will match ``cat`` (1 ``a``), ``caaat`` (3 ``a``'s), but won't match
``ct``.
There are two more repeating qualifiers. The question mark character, ``?``,
matches either once or zero times; you can think of it as marking something as
being optional. For example, ``home-?brew`` matches either ``homebrew`` or
``home-brew``.
The most complicated repeated qualifier is ``{m,n}``, where *m* and *n* are
decimal integers. This qualifier means there must be at least *m* repetitions,
and at most *n*. For example, ``a/{1,3}b`` will match ``a/b``, ``a//b``, and
``a///b``. It won't match ``ab``, which has no slashes, or ``a////b``, which
has four.
You can omit either *m* or *n*; in that case, a reasonable value is assumed for
the missing value. Omitting *m* is interpreted as a lower limit of 0, while
omitting *n* results in an upper bound of infinity --- actually, the upper bound
is the 2-billion limit mentioned earlier, but that might as well be infinity.
Readers of a reductionist bent may notice that the three other qualifiers can
all be expressed using this notation. ``{0,}`` is the same as ``*``, ``{1,}``
is equivalent to ``+``, and ``{0,1}`` is the same as ``?``. It's better to use
``*``, ``+``, or ``?`` when you can, simply because they're shorter and easier
to read.
Using Regular Expressions
=========================
Now that we've looked at some simple regular expressions, how do we actually use
them in Python? The :mod:`re` module provides an interface to the regular
expression engine, allowing you to compile REs into objects and then perform
matches with them.
Compiling Regular Expressions
-----------------------------
Regular expressions are compiled into :class:`RegexObject` instances, which have
methods for various operations such as searching for pattern matches or
performing string substitutions. ::
>>> import re
>>> p = re.compile('ab*')
>>> print p
:func:`re.compile` also accepts an optional *flags* argument, used to enable
various special features and syntax variations. We'll go over the available
settings later, but for now a single example will do::
>>> p = re.compile('ab*', re.IGNORECASE)
The RE is passed to :func:`re.compile` as a string. REs are handled as strings
because regular expressions aren't part of the core Python language, and no
special syntax was created for expressing them. (There are applications that
don't need REs at all, so there's no need to bloat the language specification by
including them.) Instead, the :mod:`re` module is simply a C extension module
included with Python, just like the :mod:`socket` or :mod:`zlib` modules.
Putting REs in strings keeps the Python language simpler, but has one
disadvantage which is the topic of the next section.
The Backslash Plague
--------------------
As stated earlier, regular expressions use the backslash character (``'\'``) to
indicate special forms or to allow special characters to be used without
invoking their special meaning. This conflicts with Python's usage of the same
character for the same purpose in string literals.
Let's say you want to write a RE that matches the string ``\section``, which
might be found in a LaTeX file. To figure out what to write in the program
code, start with the desired string to be matched. Next, you must escape any
backslashes and other metacharacters by preceding them with a backslash,
resulting in the string ``\\section``. The resulting string that must be passed
to :func:`re.compile` must be ``\\section``. However, to express this as a
Python string literal, both backslashes must be escaped *again*.
+-------------------+------------------------------------------+
| Characters | Stage |
+===================+==========================================+
| ``\section`` | Text string to be matched |
+-------------------+------------------------------------------+
| ``\\section`` | Escaped backslash for :func:`re.compile` |
+-------------------+------------------------------------------+
| ``"\\\\section"`` | Escaped backslashes for a string literal |
+-------------------+------------------------------------------+
In short, to match a literal backslash, one has to write ``'\\\\'`` as the RE
string, because the regular expression must be ``\\``, and each backslash must
be expressed as ``\\`` inside a regular Python string literal. In REs that
feature backslashes repeatedly, this leads to lots of repeated backslashes and
makes the resulting strings difficult to understand.
The solution is to use Python's raw string notation for regular expressions;
backslashes are not handled in any special way in a string literal prefixed with
``'r'``, so ``r"\n"`` is a two-character string containing ``'\'`` and ``'n'``,
while ``"\n"`` is a one-character string containing a newline. Regular
expressions will often be written in Python code using this raw string notation.
+-------------------+------------------+
| Regular String | Raw string |
+===================+==================+
| ``"ab*"`` | ``r"ab*"`` |
+-------------------+------------------+
| ``"\\\\section"`` | ``r"\\section"`` |
+-------------------+------------------+
| ``"\\w+\\s+\\1"`` | ``r"\w+\s+\1"`` |
+-------------------+------------------+
Performing Matches
------------------
Once you have an object representing a compiled regular expression, what do you
do with it? :class:`RegexObject` instances have several methods and attributes.
Only the most significant ones will be covered here; consult the :mod:`re` docs
for a complete listing.
+------------------+-----------------------------------------------+
| Method/Attribute | Purpose |
+==================+===============================================+
| ``match()`` | Determine if the RE matches at the beginning |
| | of the string. |
+------------------+-----------------------------------------------+
| ``search()`` | Scan through a string, looking for any |
| | location where this RE matches. |
+------------------+-----------------------------------------------+
| ``findall()`` | Find all substrings where the RE matches, and |
| | returns them as a list. |
+------------------+-----------------------------------------------+
| ``finditer()`` | Find all substrings where the RE matches, and |
| | returns them as an :term:`iterator`. |
+------------------+-----------------------------------------------+
:meth:`match` and :meth:`search` return ``None`` if no match can be found. If
they're successful, a ``MatchObject`` instance is returned, containing
information about the match: where it starts and ends, the substring it matched,
and more.
You can learn about this by interactively experimenting with the :mod:`re`
module. If you have Tkinter available, you may also want to look at
:file:`Tools/scripts/redemo.py`, a demonstration program included with the
Python distribution. It allows you to enter REs and strings, and displays
whether the RE matches or fails. :file:`redemo.py` can be quite useful when
trying to debug a complicated RE. Phil Schwartz's `Kodos
`_ is also an interactive tool for developing and
testing RE patterns.
This HOWTO uses the standard Python interpreter for its examples. First, run the
Python interpreter, import the :mod:`re` module, and compile a RE::
Python 2.2.2 (#1, Feb 10 2003, 12:57:01)
>>> import re
>>> p = re.compile('[a-z]+')
>>> p
<_sre.SRE_Pattern object at 80c3c28>
Now, you can try matching various strings against the RE ``[a-z]+``. An empty
string shouldn't match at all, since ``+`` means 'one or more repetitions'.
:meth:`match` should return ``None`` in this case, which will cause the
interpreter to print no output. You can explicitly print the result of
:meth:`match` to make this clear. ::
>>> p.match("")
>>> print p.match("")
None
Now, let's try it on a string that it should match, such as ``tempo``. In this
case, :meth:`match` will return a :class:`MatchObject`, so you should store the
result in a variable for later use. ::
>>> m = p.match('tempo')
>>> print m
<_sre.SRE_Match object at 80c4f68>
Now you can query the :class:`MatchObject` for information about the matching
string. :class:`MatchObject` instances also have several methods and
attributes; the most important ones are:
+------------------+--------------------------------------------+
| Method/Attribute | Purpose |
+==================+============================================+
| ``group()`` | Return the string matched by the RE |
+------------------+--------------------------------------------+
| ``start()`` | Return the starting position of the match |
+------------------+--------------------------------------------+
| ``end()`` | Return the ending position of the match |
+------------------+--------------------------------------------+
| ``span()`` | Return a tuple containing the (start, end) |
| | positions of the match |
+------------------+--------------------------------------------+
Trying these methods will soon clarify their meaning::
>>> m.group()
'tempo'
>>> m.start(), m.end()
(0, 5)
>>> m.span()
(0, 5)
:meth:`group` returns the substring that was matched by the RE. :meth:`start`
and :meth:`end` return the starting and ending index of the match. :meth:`span`
returns both start and end indexes in a single tuple. Since the :meth:`match`
method only checks if the RE matches at the start of a string, :meth:`start`
will always be zero. However, the :meth:`search` method of :class:`RegexObject`
instances scans through the string, so the match may not start at zero in that
case. ::
>>> print p.match('::: message')
None
>>> m = p.search('::: message') ; print m
>>> m.group()
'message'
>>> m.span()
(4, 11)
In actual programs, the most common style is to store the :class:`MatchObject`
in a variable, and then check if it was ``None``. This usually looks like::
p = re.compile( ... )
m = p.match( 'string goes here' )
if m:
print 'Match found: ', m.group()
else:
print 'No match'
Two :class:`RegexObject` methods return all of the matches for a pattern.
:meth:`findall` returns a list of matching strings::
>>> p = re.compile('\d+')
>>> p.findall('12 drummers drumming, 11 pipers piping, 10 lords a-leaping')
['12', '11', '10']
:meth:`findall` has to create the entire list before it can be returned as the
result. The :meth:`finditer` method returns a sequence of :class:`MatchObject`
instances as an :term:`iterator`. [#]_ ::
>>> iterator = p.finditer('12 drummers drumming, 11 ... 10 ...')
>>> iterator
>>> for match in iterator:
... print match.span()
...
(0, 2)
(22, 24)
(29, 31)
Module-Level Functions
----------------------
You don't have to create a :class:`RegexObject` and call its methods; the
:mod:`re` module also provides top-level functions called :func:`match`,
:func:`search`, :func:`findall`, :func:`sub`, and so forth. These functions
take the same arguments as the corresponding :class:`RegexObject` method, with
the RE string added as the first argument, and still return either ``None`` or a
:class:`MatchObject` instance. ::
>>> print re.match(r'From\s+', 'Fromage amk')
None
>>> re.match(r'From\s+', 'From amk Thu May 14 19:12:10 1998')
Under the hood, these functions simply produce a :class:`RegexObject` for you
and call the appropriate method on it. They also store the compiled object in a
cache, so future calls using the same RE are faster.
Should you use these module-level functions, or should you get the
:class:`RegexObject` and call its methods yourself? That choice depends on how
frequently the RE will be used, and on your personal coding style. If the RE is
being used at only one point in the code, then the module functions are probably
more convenient. If a program contains a lot of regular expressions, or re-uses
the same ones in several locations, then it might be worthwhile to collect all
the definitions in one place, in a section of code that compiles all the REs
ahead of time. To take an example from the standard library, here's an extract
from :file:`xmllib.py`::
ref = re.compile( ... )
entityref = re.compile( ... )
charref = re.compile( ... )
starttagopen = re.compile( ... )
I generally prefer to work with the compiled object, even for one-time uses, but
few people will be as much of a purist about this as I am.
Compilation Flags
-----------------
Compilation flags let you modify some aspects of how regular expressions work.
Flags are available in the :mod:`re` module under two names, a long name such as
:const:`IGNORECASE` and a short, one-letter form such as :const:`I`. (If you're
familiar with Perl's pattern modifiers, the one-letter forms use the same
letters; the short form of :const:`re.VERBOSE` is :const:`re.X`, for example.)
Multiple flags can be specified by bitwise OR-ing them; ``re.I | re.M`` sets
both the :const:`I` and :const:`M` flags, for example.
Here's a table of the available flags, followed by a more detailed explanation
of each one.
+---------------------------------+--------------------------------------------+
| Flag | Meaning |
+=================================+============================================+
| :const:`DOTALL`, :const:`S` | Make ``.`` match any character, including |
| | newlines |
+---------------------------------+--------------------------------------------+
| :const:`IGNORECASE`, :const:`I` | Do case-insensitive matches |
+---------------------------------+--------------------------------------------+
| :const:`LOCALE`, :const:`L` | Do a locale-aware match |
+---------------------------------+--------------------------------------------+
| :const:`MULTILINE`, :const:`M` | Multi-line matching, affecting ``^`` and |
| | ``$`` |
+---------------------------------+--------------------------------------------+
| :const:`VERBOSE`, :const:`X` | Enable verbose REs, which can be organized |
| | more cleanly and understandably. |
+---------------------------------+--------------------------------------------+
.. data:: I
IGNORECASE
:noindex:
Perform case-insensitive matching; character class and literal strings will
match letters by ignoring case. For example, ``[A-Z]`` will match lowercase
letters, too, and ``Spam`` will match ``Spam``, ``spam``, or ``spAM``. This
lowercasing doesn't take the current locale into account; it will if you also
set the :const:`LOCALE` flag.
.. data:: L
LOCALE
:noindex:
Make ``\w``, ``\W``, ``\b``, and ``\B``, dependent on the current locale.
Locales are a feature of the C library intended to help in writing programs that
take account of language differences. For example, if you're processing French
text, you'd want to be able to write ``\w+`` to match words, but ``\w`` only
matches the character class ``[A-Za-z]``; it won't match ``'é'`` or ``'ç'``. If
your system is configured properly and a French locale is selected, certain C
functions will tell the program that ``'é'`` should also be considered a letter.
Setting the :const:`LOCALE` flag when compiling a regular expression will cause
the resulting compiled object to use these C functions for ``\w``; this is
slower, but also enables ``\w+`` to match French words as you'd expect.
.. data:: M
MULTILINE
:noindex:
(``^`` and ``$`` haven't been explained yet; they'll be introduced in section
:ref:`more-metacharacters`.)
Usually ``^`` matches only at the beginning of the string, and ``$`` matches
only at the end of the string and immediately before the newline (if any) at the
end of the string. When this flag is specified, ``^`` matches at the beginning
of the string and at the beginning of each line within the string, immediately
following each newline. Similarly, the ``$`` metacharacter matches either at
the end of the string and at the end of each line (immediately preceding each
newline).
.. data:: S
DOTALL
:noindex:
Makes the ``'.'`` special character match any character at all, including a
newline; without this flag, ``'.'`` will match anything *except* a newline.
.. data:: X
VERBOSE
:noindex:
This flag allows you to write regular expressions that are more readable by
granting you more flexibility in how you can format them. When this flag has
been specified, whitespace within the RE string is ignored, except when the
whitespace is in a character class or preceded by an unescaped backslash; this
lets you organize and indent the RE more clearly. This flag also lets you put
comments within a RE that will be ignored by the engine; comments are marked by
a ``'#'`` that's neither in a character class or preceded by an unescaped
backslash.
For example, here's a RE that uses :const:`re.VERBOSE`; see how much easier it
is to read? ::
charref = re.compile(r"""
&[#] # Start of a numeric entity reference
(
0[0-7]+ # Octal form
| [0-9]+ # Decimal form
| x[0-9a-fA-F]+ # Hexadecimal form
)
; # Trailing semicolon
""", re.VERBOSE)
Without the verbose setting, the RE would look like this::
charref = re.compile("&#(0[0-7]+"
"|[0-9]+"
"|x[0-9a-fA-F]+);")
In the above example, Python's automatic concatenation of string literals has
been used to break up the RE into smaller pieces, but it's still more difficult
to understand than the version using :const:`re.VERBOSE`.
More Pattern Power
==================
So far we've only covered a part of the features of regular expressions. In
this section, we'll cover some new metacharacters, and how to use groups to
retrieve portions of the text that was matched.
.. _more-metacharacters:
More Metacharacters
-------------------
There are some metacharacters that we haven't covered yet. Most of them will be
covered in this section.
Some of the remaining metacharacters to be discussed are :dfn:`zero-width
assertions`. They don't cause the engine to advance through the string;
instead, they consume no characters at all, and simply succeed or fail. For
example, ``\b`` is an assertion that the current position is located at a word
boundary; the position isn't changed by the ``\b`` at all. This means that
zero-width assertions should never be repeated, because if they match once at a
given location, they can obviously be matched an infinite number of times.
``|``
Alternation, or the "or" operator. If A and B are regular expressions,
``A|B`` will match any string that matches either ``A`` or ``B``. ``|`` has very
low precedence in order to make it work reasonably when you're alternating
multi-character strings. ``Crow|Servo`` will match either ``Crow`` or ``Servo``,
not ``Cro``, a ``'w'`` or an ``'S'``, and ``ervo``.
To match a literal ``'|'``, use ``\|``, or enclose it inside a character class,
as in ``[|]``.
``^``
Matches at the beginning of lines. Unless the :const:`MULTILINE` flag has been
set, this will only match at the beginning of the string. In :const:`MULTILINE`
mode, this also matches immediately after each newline within the string.
For example, if you wish to match the word ``From`` only at the beginning of a
line, the RE to use is ``^From``. ::
>>> print re.search('^From', 'From Here to Eternity')
>>> print re.search('^From', 'Reciting From Memory')
None
.. To match a literal \character{\^}, use \regexp{\e\^} or enclose it
.. inside a character class, as in \regexp{[{\e}\^]}.
``$``
Matches at the end of a line, which is defined as either the end of the string,
or any location followed by a newline character. ::
>>> print re.search('}$', '{block}')
>>> print re.search('}$', '{block} ')
None
>>> print re.search('}$', '{block}\n')
To match a literal ``'$'``, use ``\$`` or enclose it inside a character class,
as in ``[$]``.
``\A``
Matches only at the start of the string. When not in :const:`MULTILINE` mode,
``\A`` and ``^`` are effectively the same. In :const:`MULTILINE` mode, they're
different: ``\A`` still matches only at the beginning of the string, but ``^``
may match at any location inside the string that follows a newline character.
``\Z``
Matches only at the end of the string.
``\b``
Word boundary. This is a zero-width assertion that matches only at the
beginning or end of a word. A word is defined as a sequence of alphanumeric
characters, so the end of a word is indicated by whitespace or a
non-alphanumeric character.
The following example matches ``class`` only when it's a complete word; it won't
match when it's contained inside another word. ::
>>> p = re.compile(r'\bclass\b')
>>> print p.search('no class at all')
>>> print p.search('the declassified algorithm')
None
>>> print p.search('one subclass is')
None
There are two subtleties you should remember when using this special sequence.
First, this is the worst collision between Python's string literals and regular
expression sequences. In Python's string literals, ``\b`` is the backspace
character, ASCII value 8. If you're not using raw strings, then Python will
convert the ``\b`` to a backspace, and your RE won't match as you expect it to.
The following example looks the same as our previous RE, but omits the ``'r'``
in front of the RE string. ::
>>> p = re.compile('\bclass\b')
>>> print p.search('no class at all')
None
>>> print p.search('\b' + 'class' + '\b')
Second, inside a character class, where there's no use for this assertion,
``\b`` represents the backspace character, for compatibility with Python's
string literals.
``\B``
Another zero-width assertion, this is the opposite of ``\b``, only matching when
the current position is not at a word boundary.
Grouping
--------
Frequently you need to obtain more information than just whether the RE matched
or not. Regular expressions are often used to dissect strings by writing a RE
divided into several subgroups which match different components of interest.
For example, an RFC-822 header line is divided into a header name and a value,
separated by a ``':'``, like this::
From: author@example.com
User-Agent: Thunderbird 1.5.0.9 (X11/20061227)
MIME-Version: 1.0
To: editor@example.com
This can be handled by writing a regular expression which matches an entire
header line, and has one group which matches the header name, and another group
which matches the header's value.
Groups are marked by the ``'('``, ``')'`` metacharacters. ``'('`` and ``')'``
have much the same meaning as they do in mathematical expressions; they group
together the expressions contained inside them, and you can repeat the contents
of a group with a repeating qualifier, such as ``*``, ``+``, ``?``, or
``{m,n}``. For example, ``(ab)*`` will match zero or more repetitions of
``ab``. ::
>>> p = re.compile('(ab)*')
>>> print p.match('ababababab').span()
(0, 10)
Groups indicated with ``'('``, ``')'`` also capture the starting and ending
index of the text that they match; this can be retrieved by passing an argument
to :meth:`group`, :meth:`start`, :meth:`end`, and :meth:`span`. Groups are
numbered starting with 0. Group 0 is always present; it's the whole RE, so
:class:`MatchObject` methods all have group 0 as their default argument. Later
we'll see how to express groups that don't capture the span of text that they
match. ::
>>> p = re.compile('(a)b')
>>> m = p.match('ab')
>>> m.group()
'ab'
>>> m.group(0)
'ab'
Subgroups are numbered from left to right, from 1 upward. Groups can be nested;
to determine the number, just count the opening parenthesis characters, going
from left to right. ::
>>> p = re.compile('(a(b)c)d')
>>> m = p.match('abcd')
>>> m.group(0)
'abcd'
>>> m.group(1)
'abc'
>>> m.group(2)
'b'
:meth:`group` can be passed multiple group numbers at a time, in which case it
will return a tuple containing the corresponding values for those groups. ::
>>> m.group(2,1,2)
('b', 'abc', 'b')
The :meth:`groups` method returns a tuple containing the strings for all the
subgroups, from 1 up to however many there are. ::
>>> m.groups()
('abc', 'b')
Backreferences in a pattern allow you to specify that the contents of an earlier
capturing group must also be found at the current location in the string. For
example, ``\1`` will succeed if the exact contents of group 1 can be found at
the current position, and fails otherwise. Remember that Python's string
literals also use a backslash followed by numbers to allow including arbitrary
characters in a string, so be sure to use a raw string when incorporating
backreferences in a RE.
For example, the following RE detects doubled words in a string. ::
>>> p = re.compile(r'(\b\w+)\s+\1')
>>> p.search('Paris in the the spring').group()
'the the'
Backreferences like this aren't often useful for just searching through a string
--- there are few text formats which repeat data in this way --- but you'll soon
find out that they're *very* useful when performing string substitutions.
Non-capturing and Named Groups
------------------------------
Elaborate REs may use many groups, both to capture substrings of interest, and
to group and structure the RE itself. In complex REs, it becomes difficult to
keep track of the group numbers. There are two features which help with this
problem. Both of them use a common syntax for regular expression extensions, so
we'll look at that first.
Perl 5 added several additional features to standard regular expressions, and
the Python :mod:`re` module supports most of them. It would have been
difficult to choose new single-keystroke metacharacters or new special sequences
beginning with ``\`` to represent the new features without making Perl's regular
expressions confusingly different from standard REs. If you chose ``&`` as a
new metacharacter, for example, old expressions would be assuming that ``&`` was
a regular character and wouldn't have escaped it by writing ``\&`` or ``[&]``.
The solution chosen by the Perl developers was to use ``(?...)`` as the
extension syntax. ``?`` immediately after a parenthesis was a syntax error
because the ``?`` would have nothing to repeat, so this didn't introduce any
compatibility problems. The characters immediately after the ``?`` indicate
what extension is being used, so ``(?=foo)`` is one thing (a positive lookahead
assertion) and ``(?:foo)`` is something else (a non-capturing group containing
the subexpression ``foo``).
Python adds an extension syntax to Perl's extension syntax. If the first
character after the question mark is a ``P``, you know that it's an extension
that's specific to Python. Currently there are two such extensions:
``(?P...)`` defines a named group, and ``(?P=name)`` is a backreference to
a named group. If future versions of Perl 5 add similar features using a
different syntax, the :mod:`re` module will be changed to support the new
syntax, while preserving the Python-specific syntax for compatibility's sake.
Now that we've looked at the general extension syntax, we can return to the
features that simplify working with groups in complex REs. Since groups are
numbered from left to right and a complex expression may use many groups, it can
become difficult to keep track of the correct numbering. Modifying such a
complex RE is annoying, too: insert a new group near the beginning and you
change the numbers of everything that follows it.
Sometimes you'll want to use a group to collect a part of a regular expression,
but aren't interested in retrieving the group's contents. You can make this fact
explicit by using a non-capturing group: ``(?:...)``, where you can replace the
``...`` with any other regular expression. ::
>>> m = re.match("([abc])+", "abc")
>>> m.groups()
('c',)
>>> m = re.match("(?:[abc])+", "abc")
>>> m.groups()
()
Except for the fact that you can't retrieve the contents of what the group
matched, a non-capturing group behaves exactly the same as a capturing group;
you can put anything inside it, repeat it with a repetition metacharacter such
as ``*``, and nest it within other groups (capturing or non-capturing).
``(?:...)`` is particularly useful when modifying an existing pattern, since you
can add new groups without changing how all the other groups are numbered. It
should be mentioned that there's no performance difference in searching between
capturing and non-capturing groups; neither form is any faster than the other.
A more significant feature is named groups: instead of referring to them by
numbers, groups can be referenced by a name.
The syntax for a named group is one of the Python-specific extensions:
``(?P...)``. *name* is, obviously, the name of the group. Named groups
also behave exactly like capturing groups, and additionally associate a name
with a group. The :class:`MatchObject` methods that deal with capturing groups
all accept either integers that refer to the group by number or strings that
contain the desired group's name. Named groups are still given numbers, so you
can retrieve information about a group in two ways::
>>> p = re.compile(r'(?P\b\w+\b)')
>>> m = p.search( '(((( Lots of punctuation )))' )
>>> m.group('word')
'Lots'
>>> m.group(1)
'Lots'
Named groups are handy because they let you use easily-remembered names, instead
of having to remember numbers. Here's an example RE from the :mod:`imaplib`
module::
InternalDate = re.compile(r'INTERNALDATE "'
r'(?P[ 123][0-9])-(?P[A-Z][a-z][a-z])-'
r'(?P[0-9][0-9][0-9][0-9])'
r' (?P[0-9][0-9]):(?P[0-9][0-9]):(?P[0-9][0-9])'
r' (?P[-+])(?P[0-9][0-9])(?P[0-9][0-9])'
r'"')
It's obviously much easier to retrieve ``m.group('zonem')``, instead of having
to remember to retrieve group 9.
The syntax for backreferences in an expression such as ``(...)\1`` refers to the
number of the group. There's naturally a variant that uses the group name
instead of the number. This is another Python extension: ``(?P=name)`` indicates
that the contents of the group called *name* should again be matched at the
current point. The regular expression for finding doubled words,
``(\b\w+)\s+\1`` can also be written as ``(?P\b\w+)\s+(?P=word)``::
>>> p = re.compile(r'(?P\b\w+)\s+(?P=word)')
>>> p.search('Paris in the the spring').group()
'the the'
Lookahead Assertions
--------------------
Another zero-width assertion is the lookahead assertion. Lookahead assertions
are available in both positive and negative form, and look like this:
``(?=...)``
Positive lookahead assertion. This succeeds if the contained regular
expression, represented here by ``...``, successfully matches at the current
location, and fails otherwise. But, once the contained expression has been
tried, the matching engine doesn't advance at all; the rest of the pattern is
tried right where the assertion started.
``(?!...)``
Negative lookahead assertion. This is the opposite of the positive assertion;
it succeeds if the contained expression *doesn't* match at the current position
in the string.
To make this concrete, let's look at a case where a lookahead is useful.
Consider a simple pattern to match a filename and split it apart into a base
name and an extension, separated by a ``.``. For example, in ``news.rc``,
``news`` is the base name, and ``rc`` is the filename's extension.
The pattern to match this is quite simple:
``.*[.].*$``
Notice that the ``.`` needs to be treated specially because it's a
metacharacter; I've put it inside a character class. Also notice the trailing
``$``; this is added to ensure that all the rest of the string must be included
in the extension. This regular expression matches ``foo.bar`` and
``autoexec.bat`` and ``sendmail.cf`` and ``printers.conf``.
Now, consider complicating the problem a bit; what if you want to match
filenames where the extension is not ``bat``? Some incorrect attempts:
``.*[.][^b].*$`` The first attempt above tries to exclude ``bat`` by requiring
that the first character of the extension is not a ``b``. This is wrong,
because the pattern also doesn't match ``foo.bar``.
``.*[.]([^b]..|.[^a].|..[^t])$``
The expression gets messier when you try to patch up the first solution by
requiring one of the following cases to match: the first character of the
extension isn't ``b``; the second character isn't ``a``; or the third character
isn't ``t``. This accepts ``foo.bar`` and rejects ``autoexec.bat``, but it
requires a three-letter extension and won't accept a filename with a two-letter
extension such as ``sendmail.cf``. We'll complicate the pattern again in an
effort to fix it.
``.*[.]([^b].?.?|.[^a]?.?|..?[^t]?)$``
In the third attempt, the second and third letters are all made optional in
order to allow matching extensions shorter than three characters, such as
``sendmail.cf``.
The pattern's getting really complicated now, which makes it hard to read and
understand. Worse, if the problem changes and you want to exclude both ``bat``
and ``exe`` as extensions, the pattern would get even more complicated and
confusing.
A negative lookahead cuts through all this confusion:
``.*[.](?!bat$).*$`` The negative lookahead means: if the expression ``bat``
doesn't match at this point, try the rest of the pattern; if ``bat$`` does
match, the whole pattern will fail. The trailing ``$`` is required to ensure
that something like ``sample.batch``, where the extension only starts with
``bat``, will be allowed.
Excluding another filename extension is now easy; simply add it as an
alternative inside the assertion. The following pattern excludes filenames that
end in either ``bat`` or ``exe``:
``.*[.](?!bat$|exe$).*$``
Modifying Strings
=================
Up to this point, we've simply performed searches against a static string.
Regular expressions are also commonly used to modify strings in various ways,
using the following :class:`RegexObject` methods:
+------------------+-----------------------------------------------+
| Method/Attribute | Purpose |
+==================+===============================================+
| ``split()`` | Split the string into a list, splitting it |
| | wherever the RE matches |
+------------------+-----------------------------------------------+
| ``sub()`` | Find all substrings where the RE matches, and |
| | replace them with a different string |
+------------------+-----------------------------------------------+
| ``subn()`` | Does the same thing as :meth:`sub`, but |
| | returns the new string and the number of |
| | replacements |
+------------------+-----------------------------------------------+
Splitting Strings
-----------------
The :meth:`split` method of a :class:`RegexObject` splits a string apart
wherever the RE matches, returning a list of the pieces. It's similar to the
:meth:`split` method of strings but provides much more generality in the
delimiters that you can split by; :meth:`split` only supports splitting by
whitespace or by a fixed string. As you'd expect, there's a module-level
:func:`re.split` function, too.
.. method:: .split(string [, maxsplit=0])
:noindex:
Split *string* by the matches of the regular expression. If capturing
parentheses are used in the RE, then their contents will also be returned as
part of the resulting list. If *maxsplit* is nonzero, at most *maxsplit* splits
are performed.
You can limit the number of splits made, by passing a value for *maxsplit*.
When *maxsplit* is nonzero, at most *maxsplit* splits will be made, and the
remainder of the string is returned as the final element of the list. In the
following example, the delimiter is any sequence of non-alphanumeric characters.
::
>>> p = re.compile(r'\W+')
>>> p.split('This is a test, short and sweet, of split().')
['This', 'is', 'a', 'test', 'short', 'and', 'sweet', 'of', 'split', '']
>>> p.split('This is a test, short and sweet, of split().', 3)
['This', 'is', 'a', 'test, short and sweet, of split().']
Sometimes you're not only interested in what the text between delimiters is, but
also need to know what the delimiter was. If capturing parentheses are used in
the RE, then their values are also returned as part of the list. Compare the
following calls::
>>> p = re.compile(r'\W+')
>>> p2 = re.compile(r'(\W+)')
>>> p.split('This... is a test.')
['This', 'is', 'a', 'test', '']
>>> p2.split('This... is a test.')
['This', '... ', 'is', ' ', 'a', ' ', 'test', '.', '']
The module-level function :func:`re.split` adds the RE to be used as the first
argument, but is otherwise the same. ::
>>> re.split('[\W]+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split('([\W]+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split('[\W]+', 'Words, words, words.', 1)
['Words', 'words, words.']
Search and Replace
------------------
Another common task is to find all the matches for a pattern, and replace them
with a different string. The :meth:`sub` method takes a replacement value,
which can be either a string or a function, and the string to be processed.
.. method:: .sub(replacement, string[, count=0])
:noindex:
Returns the string obtained by replacing the leftmost non-overlapping
occurrences of the RE in *string* by the replacement *replacement*. If the
pattern isn't found, *string* is returned unchanged.
The optional argument *count* is the maximum number of pattern occurrences to be
replaced; *count* must be a non-negative integer. The default value of 0 means
to replace all occurrences.
Here's a simple example of using the :meth:`sub` method. It replaces colour
names with the word ``colour``::
>>> p = re.compile( '(blue|white|red)')
>>> p.sub( 'colour', 'blue socks and red shoes')
'colour socks and colour shoes'
>>> p.sub( 'colour', 'blue socks and red shoes', count=1)
'colour socks and red shoes'
The :meth:`subn` method does the same work, but returns a 2-tuple containing the
new string value and the number of replacements that were performed::
>>> p = re.compile( '(blue|white|red)')
>>> p.subn( 'colour', 'blue socks and red shoes')
('colour socks and colour shoes', 2)
>>> p.subn( 'colour', 'no colours at all')
('no colours at all', 0)
Empty matches are replaced only when they're not adjacent to a previous match.
::
>>> p = re.compile('x*')
>>> p.sub('-', 'abxd')
'-a-b-d-'
If *replacement* is a string, any backslash escapes in it are processed. That
is, ``\n`` is converted to a single newline character, ``\r`` is converted to a
carriage return, and so forth. Unknown escapes such as ``\j`` are left alone.
Backreferences, such as ``\6``, are replaced with the substring matched by the
corresponding group in the RE. This lets you incorporate portions of the
original text in the resulting replacement string.
This example matches the word ``section`` followed by a string enclosed in
``{``, ``}``, and changes ``section`` to ``subsection``::
>>> p = re.compile('section{ ( [^}]* ) }', re.VERBOSE)
>>> p.sub(r'subsection{\1}','section{First} section{second}')
'subsection{First} subsection{second}'
There's also a syntax for referring to named groups as defined by the
``(?P...)`` syntax. ``\g`` will use the substring matched by the
group named ``name``, and ``\g`` uses the corresponding group number.
``\g<2>`` is therefore equivalent to ``\2``, but isn't ambiguous in a
replacement string such as ``\g<2>0``. (``\20`` would be interpreted as a
reference to group 20, not a reference to group 2 followed by the literal
character ``'0'``.) The following substitutions are all equivalent, but use all
three variations of the replacement string. ::
>>> p = re.compile('section{ (?P [^}]* ) }', re.VERBOSE)
>>> p.sub(r'subsection{\1}','section{First}')
'subsection{First}'
>>> p.sub(r'subsection{\g<1>}','section{First}')
'subsection{First}'
>>> p.sub(r'subsection{\g}','section{First}')
'subsection{First}'
*replacement* can also be a function, which gives you even more control. If
*replacement* is a function, the function is called for every non-overlapping
occurrence of *pattern*. On each call, the function is passed a
:class:`MatchObject` argument for the match and can use this information to
compute the desired replacement string and return it.
In the following example, the replacement function translates decimals into
hexadecimal::
>>> def hexrepl( match ):
... "Return the hex string for a decimal number"
... value = int( match.group() )
... return hex(value)
...
>>> p = re.compile(r'\d+')
>>> p.sub(hexrepl, 'Call 65490 for printing, 49152 for user code.')
'Call 0xffd2 for printing, 0xc000 for user code.'
When using the module-level :func:`re.sub` function, the pattern is passed as
the first argument. The pattern may be a string or a :class:`RegexObject`; if
you need to specify regular expression flags, you must either use a
:class:`RegexObject` as the first parameter, or use embedded modifiers in the
pattern, e.g. ``sub("(?i)b+", "x", "bbbb BBBB")`` returns ``'x x'``.
Common Problems
===============
Regular expressions are a powerful tool for some applications, but in some ways
their behaviour isn't intuitive and at times they don't behave the way you may
expect them to. This section will point out some of the most common pitfalls.
Use String Methods
------------------
Sometimes using the :mod:`re` module is a mistake. If you're matching a fixed
string, or a single character class, and you're not using any :mod:`re` features
such as the :const:`IGNORECASE` flag, then the full power of regular expressions
may not be required. Strings have several methods for performing operations with
fixed strings and they're usually much faster, because the implementation is a
single small C loop that's been optimized for the purpose, instead of the large,
more generalized regular expression engine.
One example might be replacing a single fixed string with another one; for
example, you might replace ``word`` with ``deed``. ``re.sub()`` seems like the
function to use for this, but consider the :meth:`replace` method. Note that
:func:`replace` will also replace ``word`` inside words, turning ``swordfish``
into ``sdeedfish``, but the naive RE ``word`` would have done that, too. (To
avoid performing the substitution on parts of words, the pattern would have to
be ``\bword\b``, in order to require that ``word`` have a word boundary on
either side. This takes the job beyond :meth:`replace`'s abilities.)
Another common task is deleting every occurrence of a single character from a
string or replacing it with another single character. You might do this with
something like ``re.sub('\n', ' ', S)``, but :meth:`translate` is capable of
doing both tasks and will be faster than any regular expression operation can
be.
In short, before turning to the :mod:`re` module, consider whether your problem
can be solved with a faster and simpler string method.
match() versus search()
-----------------------
The :func:`match` function only checks if the RE matches at the beginning of the
string while :func:`search` will scan forward through the string for a match.
It's important to keep this distinction in mind. Remember, :func:`match` will
only report a successful match which will start at 0; if the match wouldn't
start at zero, :func:`match` will *not* report it. ::
>>> print re.match('super', 'superstition').span()
(0, 5)
>>> print re.match('super', 'insuperable')
None
On the other hand, :func:`search` will scan forward through the string,
reporting the first match it finds. ::
>>> print re.search('super', 'superstition').span()
(0, 5)
>>> print re.search('super', 'insuperable').span()
(2, 7)
Sometimes you'll be tempted to keep using :func:`re.match`, and just add ``.*``
to the front of your RE. Resist this temptation and use :func:`re.search`
instead. The regular expression compiler does some analysis of REs in order to
speed up the process of looking for a match. One such analysis figures out what
the first character of a match must be; for example, a pattern starting with
``Crow`` must match starting with a ``'C'``. The analysis lets the engine
quickly scan through the string looking for the starting character, only trying
the full match if a ``'C'`` is found.
Adding ``.*`` defeats this optimization, requiring scanning to the end of the
string and then backtracking to find a match for the rest of the RE. Use
:func:`re.search` instead.
Greedy versus Non-Greedy
------------------------
When repeating a regular expression, as in ``a*``, the resulting action is to
consume as much of the pattern as possible. This fact often bites you when
you're trying to match a pair of balanced delimiters, such as the angle brackets
surrounding an HTML tag. The naive pattern for matching a single HTML tag
doesn't work because of the greedy nature of ``.*``. ::
>>> s = 'Title'
>>> len(s)
32
>>> print re.match('<.*>', s).span()
(0, 32)
>>> print re.match('<.*>', s).group()
Title
The RE matches the ``'<'`` in ````, and the ``.*`` consumes the rest of
the string. There's still more left in the RE, though, and the ``>`` can't
match at the end of the string, so the regular expression engine has to
backtrack character by character until it finds a match for the ``>``. The
final match extends from the ``'<'`` in ```` to the ``'>'`` in
````, which isn't what you want.
In this case, the solution is to use the non-greedy qualifiers ``*?``, ``+?``,
``??``, or ``{m,n}?``, which match as *little* text as possible. In the above
example, the ``'>'`` is tried immediately after the first ``'<'`` matches, and
when it fails, the engine advances a character at a time, retrying the ``'>'``
at every step. This produces just the right result::
>>> print re.match('<.*?>', s).group()
(Note that parsing HTML or XML with regular expressions is painful.
Quick-and-dirty patterns will handle common cases, but HTML and XML have special
cases that will break the obvious regular expression; by the time you've written
a regular expression that handles all of the possible cases, the patterns will
be *very* complicated. Use an HTML or XML parser module for such tasks.)
Not Using re.VERBOSE
--------------------
By now you've probably noticed that regular expressions are a very compact
notation, but they're not terribly readable. REs of moderate complexity can
become lengthy collections of backslashes, parentheses, and metacharacters,
making them difficult to read and understand.
For such REs, specifying the ``re.VERBOSE`` flag when compiling the regular
expression can be helpful, because it allows you to format the regular
expression more clearly.
The ``re.VERBOSE`` flag has several effects. Whitespace in the regular
expression that *isn't* inside a character class is ignored. This means that an
expression such as ``dog | cat`` is equivalent to the less readable ``dog|cat``,
but ``[a b]`` will still match the characters ``'a'``, ``'b'``, or a space. In
addition, you can also put comments inside a RE; comments extend from a ``#``
character to the next newline. When used with triple-quoted strings, this
enables REs to be formatted more neatly::
pat = re.compile(r"""
\s* # Skip leading whitespace
(?P[^:]+) # Header name
\s* : # Whitespace, and a colon
(?P.*?) # The header's value -- *? used to
# lose the following trailing whitespace
\s*$ # Trailing whitespace to end-of-line
""", re.VERBOSE)
This is far more readable than::
pat = re.compile(r"\s*(?P[^:]+)\s*:(?P.*?)\s*$")
Feedback
========
Regular expressions are a complicated topic. Did this document help you
understand them? Were there parts that were unclear, or Problems you
encountered that weren't covered here? If so, please send suggestions for
improvements to the author.
The most complete book on regular expressions is almost certainly Jeffrey
Friedl's Mastering Regular Expressions, published by O'Reilly. Unfortunately,
it exclusively concentrates on Perl and Java's flavours of regular expressions,
and doesn't contain any Python material at all, so it won't be useful as a
reference for programming in Python. (The first edition covered Python's
now-removed :mod:`regex` module, which won't help you much.) Consider checking
it out from your library.
.. rubric:: Footnotes
.. [#] Introduced in Python 2.2.2.
Python-2.6.2-DocJa-1/_sources/howto/urllib2.txt 0000644 0001750 0001750 00000055720 11476415427 020640 0 ustar inada-n inada-n ******************************************************
HOWTO Fetch Internet Resources Using urllib2 (英語)
******************************************************
:Author: `Michael Foord
