\chapter{組み込み型 \label{types}}

以下のセクションでは、インタプリタに組み込まれている標準の型に
ついて記述します。
\note{これまでの(リリース 2.2 までの) Python の歴史では、組み込み型は
オブジェクト指向における継承を行う際に雛型にできないという点で、
ユーザ定義型とは異なっていました。いまではこのような制限はなくなっています。}

主要な組み込み型は数値型、シーケンス型、マッピング型、ファイル、クラス、
インスタンス型、および例外です。
\indexii{built-in}{types}

演算によっては、複数の型でサポートされているものがあります;
特に、ほぼ全てのオブジェクトについて、比較、真値テスト、
(\function{repr()} 関数や、わずかに異なる \function{str()} 関数
による) 文字列への
変換を行うことができます。オブジェクトが\keyword{print}\stindex{print} 
によって書かれていると、後の方の文字列への変換が暗黙に行われます
(Information on \ulink{\keyword{print} 文}{../ref/print.html}
やその他の文に関する情報は
\citetitle[../ref/ref.html]{Python リファレンスマニュアル} および
\citetitle[../tut/tut.html]{Python チュートリアル}
で見つけることができます。)


\section{真値テスト\label{truth} } 

どのオブジェクトも \keyword{if} または \keyword{while} 条件文の中や、
以下のブール演算における被演算子として真値テストを行うことができます。
以下の値は偽であると見なされます:
\stindex{if}
\stindex{while}
\indexii{truth}{value}
\indexii{Boolean}{operations}
\index{false}

\begin{itemize}

\item	\code{None}
        \withsubitem{(Built-in object)}{\ttindex{None}}

\item	\code{False}
        \withsubitem{(Built-in object)}{\ttindex{False}}

\item	数値型におけるゼロ。例えば \code{0} 、 \code{0L} 、
        \code{0.0} 、 \code{0j} 。

\item	空のシーケンス型。例えば \code{''} 、 \code{()} 、 \code{[]} 。

\item	空のマッピング型。例えば \code{\{\}} 。

\item	\method{__nonzero__()} または \method{__len__()} メソッドが
定義されているようなユーザ定義クラスのインスタンスで、それらのメソッド
が整数値ゼロまたは \class{bool} 値の \code{False} を返すとき。
\footnote{これらの特殊なメソッドに関する追加情報は \citetitle[../ref/ref.html]{Python リファレンスマニュアル}に記載されています。}

\end{itemize}

それ以外の値は全て真であると見なされます --- 従って、ほとんどの型
のオブジェクトは常に真です。
\index{true}

ブール値の結果を返す演算および組み込み関数は、特に注釈のない限り常に
偽値として \code{0} または\code{False} を返し、真値として \code{1} 
または \code{True} を返します (重要な例外: ブール演算
\samp{or}\opindex{or} および \samp{and}\opindex{and} は常に被演算子
の中の一つを返します)。
\index{False}
\index{True}

\section{ブール演算 ---
	\keyword{and}, \keyword{or}, \keyword{not}
	\label{boolean}}

以下にブール演算子を示します。優先度の低いものから順に並んでいます。:
\indexii{Boolean}{operations}

\begin{tableiii}{c|l|c}{code}{演算}{結果}{注釈}
  \lineiii{\var{x} or \var{y}}
          {\var{x} が偽なら \var{y} 、そうでなければ \var{x}}{(1)}
  \lineiii{\var{x} and \var{y}}
          {\var{x} が偽なら \var{x} 、そうでなければ \var{y}}{(1)}
  \hline
  \lineiii{not \var{x}}
          {\var{x} が偽なら \code{True} 、そうでなければ \code{False}}{(2)}
\end{tableiii}
\opindex{and}
\opindex{or}
\opindex{not}

\noindent
注釈:

\begin{description}

\item[(1)]
これらの演算子は、演算を行う上で必要がない限り、二つ目の引数を評価しません。

\item[(2)]
\samp{not} は非ブール演算子よりも低い演算優先度なので、
\code{not \var{a} == \var{b}} は \code{not (\var{a} == \var{b})} 
と評価され、 \code{\var{a} == not \var{b}} は構文エラーとなります。
\end{description}


\section{比較 \label{comparisons}}

比較演算は全てのオブジェクトでサポートされています。比較演算子は
全て同じ演算優先度を持っています (ブール演算より高い演算優先度です)。
比較は任意の形で連鎖させることができます; 例えば、\code{\var{x} <
\var{y} <= \var{z}} は \code{\var{x} < \var{y} および 
\var{y} <= \var{z}} と等価で、違うのは \var{y} が一度だけしか評価
されないということです (どちらの場合でも、 
\code{\var{x} < \var{y}} が偽となった場合には \var{z} は評価されません) 。
\indexii{chaining}{comparisons}

以下のテーブルに比較演算をまとめます:

\begin{tableiii}{c|l|c}{code}{演算}{意味}{注釈}
  \lineiii{<}{より小さい}{}
  \lineiii{<=}{以下}{}
  \lineiii{>}{より大きい}{}
  \lineiii{>=}{以上}{}
  \lineiii{==}{等しい}{}
  \lineiii{!=}{等しくない}{(1)}
  \lineiii{<>}{等しくない}{(1)}
  \lineiii{is}{同一のオブジェクトである}{}
  \lineiii{is not}{同一のオブジェクトでない}{}
\end{tableiii}
\indexii{operator}{comparison}
\opindex{==} % XXX *All* others have funny characters < ! >
\opindex{is}
\opindex{is not}

\noindent
注釈:

\begin{description}

\item[(1)]
\code{<>} および \code{!=} は同じ演算子を別の書き方にしたものです。
\code{!=} のほうが望ましい書き方です; \code{<>} は廃止すべき書き方です。

\end{description}

数値型間の比較か文字列間の比較でないかぎり、異なる型のオブジェクトを
比較しても等価になることはありません; これらのオブジェクトの順番付けは
一貫してはいますが任意のものです (従って要素の型が一様でないシーケンスを
ソートした結果は一貫したものになります)。
さらに、(例えばファイルオブジェクトのように) 型によっては、
その型の 2 つのオブジェクトの不等性だけの、縮退した比較の概念
しかサポートしないものもあります。繰り返しますが、
そのようなオブジェクトも任意の順番付けをされていますが、
それは一貫したものです。被演算子が複素数の場合、演算子
\code{<} 、 \code{<=} 、 \code{>} および \code{>=} は
例外 \exception{TypeError} を送出します。
\indexii{object}{numeric}
\indexii{objects}{comparing}

あるクラスのインスタンス間の比較は、そのクラスで \method{__cmp__()}
メソッドが定義されていない限り等しくなりません。
\withsubitem{(instance method)}{\ttindex{__cmp__()}}
このメソッドを使ってオブジェクトの比較方法に影響を及ぼすための
情報については
\citetitle[../ref/customization.html]{Python リファレンスマニュアル} 
を参照してください。

\strong{実装に関する注釈:} 数値型を除き、異なる型のオブジェクトは
型の名前で順番付けされます; 適当な比較をサポートしていないある型の
オブジェクトはアドレスによって順番付けされます。

同じ優先度を持つ演算子としてさらに 2 つ、シーケンス型でのみ
\samp{in}\opindex{in} および \samp{not in}\opindex{not in} が
サポートされています (以下を参照)。

\section{数値型
	\class{int}, \class{float}, \class{long}, \class{complex}
	\label{typesnumeric}}

4 つの異なる数値型があります: \dfn{通常の整数型} 、
\dfn{長整数型} 、\dfn{浮動小数点型} 、および \dfn{複素数型} です。

さらに、ブール方は通常の整数型のサブタイプです。通常の整数
(単に \dfn{整数型} とも呼ばれます) は C では \ctype{long} を
使って実装されており、少なくとも 32 ビットの精度があります
(\code{sys.maxint} は常に通常の整数の各プラットフォームにおける
最大値にセットされており、最小値は \code{-sys.maxint - 1} になります)。
長整数型には精度の制限がありません。浮動小数点型は C では
\ctype{double} を使って実装されています。しかし使っている計算機
が何であるか分からないなら、これらの数値型の精度に関して断言はできません。
\obindex{numeric}
\obindex{Boolean}
\obindex{integer}
\obindex{long integer}
\obindex{floating point}
\obindex{complex number}
\indexii{C}{language}

複素数型は実数部と虚数部を持ち、それぞれの C では \ctype{double} を
使って実装されています。複素数 \var{z} から実数および虚数部を取り出す
には、\code{\var{z}.real} および \code{\var{z}.imag} を使います。

数値は、数値リテラルや組み込み関数や演算子の戻り値として生成されます。
修飾のない整数リテラル (16 進表現や 8 進表現の値も含みます) は、
通常の整数値を表します。値が通常の整数で表すには大きすぎる場合、
\character{L} または \character{l} が末尾につく整数リテラル
は長整数型を表します (\character{L} が望ましいです。というのは
\samp{1l} は 11 と非常に紛らわしいからです！) 小数点または
指数表記のある数値リテラルは浮動小数点数を表します。
数値リテラルに \character{j} または \character{J} をつけると
実数部がゼロの複素数を表します。複素数の数値リテラルは実数部と
虚数部を足したものです。

\indexii{numeric}{literals}
\indexii{integer}{literals}
\indexiii{long}{integer}{literals}
\indexii{floating point}{literals}
\indexii{complex number}{literals}
\indexii{hexadecimal}{literals}
\indexii{octal}{literals}

Python は型混合の演算を完全にサポートします: ある 2 項演算子が
互いに異なる数値型の被演算子を持つ場合、より ``制限された'' 型の
被演算子は他方の型に合わせて広げられます。ここで通常の整数は
長整数より制限されており、長整数は浮動小数点数より制限されており、
浮動小数点は複素数より制限されています。
型混合の数値間での比較も同じ規則に従います。
\footnote{この結果として、リスト \code{[1, 2]} は \code{[1.0, 2.0]}
と等しいと見なされます。タプルの場合も同様です}
コンストラクタ \function{int()} 、\function{long()} 、\function{float()}、
および \function{complex()} を使って、特定の型の数を生成することが
できます。
\index{arithmetic}
\bifuncindex{int}
\bifuncindex{long}
\bifuncindex{float}
\bifuncindex{complex}

全ての数値型（complex は例外）は以下の演算をサポートします。これらの演算は
優先度の低いものから順に並べられています (同じボックスにある演算は
同じ優先度を持っています; 全ての数値演算は比較演算よりも
高い優先度を持っています):

\begin{tableiii}{c|l|c}{code}{演算}{結果}{注釈}
  \lineiii{\var{x} + \var{y}}{\var{x} と \var{y} の和}{}
  \lineiii{\var{x} - \var{y}}{\var{x} と \var{y} の差}{}
  \hline
  \lineiii{\var{x} * \var{y}}{\var{x} と \var{y} の積}{}
  \lineiii{\var{x} / \var{y}}{\var{x} と \var{y} の商}{(1)}
  \lineiii{\var{x} // \var{y}}{\var{x} と \var{y} の商(を切り下げたもの)}{(5)}
  \lineiii{\var{x} \%{} \var{y}}{\code{\var{x} / \var{y}} の剰余}{(4)}
  \hline
  \lineiii{-\var{x}}{\var{x} の符号反転}{}
  \lineiii{+\var{x}}{\var{x} の符号不変}{}
  \hline
  \lineiii{abs(\var{x})}{\var{x} の絶対値または大きさ}{}
  \lineiii{int(\var{x})}{\var{x} の通常整数への変換}{(2)}
  \lineiii{long(\var{x})}{\var{x} の長整数への変換}{(2)}
  \lineiii{float(\var{x})}{\var{x} の浮動小数点数への変換}{}
  \lineiii{complex(\var{re},\var{im})}{実数部 \var{re} 、虚数部 \var{im} の複素数。 \var{im} のデフォルト値はゼロ。}{}
  \lineiii{\var{c}.conjugate()}{複素数 \var{c} の共役複素数}{}
  \lineiii{divmod(\var{x}, \var{y})}{\code{(\var{x} // \var{y}, \var{x} \%{} \var{y})} からなるペア}{(3)}
  \lineiii{pow(\var{x}, \var{y})}{\var{x} の \var{y} 乗}{}
  \lineiii{\var{x} ** \var{y}}{\var{x} の \var{y} 乗}{}
\end{tableiii}
\indexiii{operations on}{numeric}{types}
\withsubitem{(complex number method)}{\ttindex{conjugate()}}

\noindent
注釈:
\begin{description}

\item[(1)]
(通常および長) 整数の割り算では、結果は整数になります。
この場合値は常にマイナス無限大の方向に丸められます: つまり、1/2 は 0、
(-1)/2 は -1、1/(-1) は -1、そして (-1)/(-2) は 0 になります。
被演算子の両方が長整数の場合、計算値に関わらず結果は長整数で返される
ので注意してください。
\indexii{integer}{division}
\indexiii{long}{integer}{division}

\item[(2)]
浮動小数点数から (通常または長) 整数への変換では、C におけるのと同様の
値の丸めまたは切り詰めが行われるかもしれません; きちんと定義された
変換については、\refmodule{math} \refbimodindex{math} モジュールの
\function{floor()} および \function{ceil()} を参照してください。
\withsubitem{(in module math)}{\ttindex{floor()}\ttindex{ceil()}}
\indexii{numeric}{conversions}
\indexii{C}{language}

\item[(3)]
完全な記述については、\ref{built-in-funcs}、``組み込み関数'' 
を参照してください。

\item[(4)]
複素数の切り詰め除算演算子、モジュロ演算子、および \function{divmod()}。

\deprecated{2.3}{適切であれば、\function{abs()} を使って浮動小数点に変換してください。}

\item[(5)]
整数の除算とも呼ばれます。結果の値は整数ですが、整数型(int)とは限りません。 
\end{description}
% XXXJH exceptions: overflow (when? what operations?) zerodivision

\subsection{整数型におけるビット列演算 \label{bitstring-ops}}
\nodename{Bit-string Operations}

通常および長整数型ではさらに、ビット列に対してのみ意味のある
演算をサポートしています。負の数はその値の 2 の補数の値として扱われます
(長整数の場合、演算操作中にオーバフローが起こらないように十分なビット数
があるものと仮定します) 。

2 進のビット単位演算は全て、数値演算よりも低く、比較演算子よりも高い
優先度です; 単項演算 \samp{~} は他の単項数値演算
(\samp{+} および \samp{-}) と同じ優先度です。

以下のテーブルでは、ビット列演算を優先度の低いものから順に並べています
(同じボックス内の演算は同じ優先度です):

\begin{tableiii}{c|l|c}{code}{演算}{結果}{注釈}
  \lineiii{\var{x} | \var{y}}{ビット単位の \var{x} と \var{y} の \dfn{論理和} }{}
  \lineiii{\var{x} \^{} \var{y}}{ビット単位の \var{x} と \var{y} の \dfn{排他的論理和}}{}
  \lineiii{\var{x} \&{} \var{y}}{ビット単位の \var{x} と \var{y} の \dfn{論理積}}{}
  % 以下の空のグループはギルメットが変換されるのを防いでいます
  \lineiii{\var{x} <{}< \var{n}}{\var{x} の \var{n} ビット左シフト}{(1), (2)}
  \lineiii{\var{x} >{}> \var{n}}{\var{x} の \var{n} ビット右シフト}{(1), (3)}
  \hline
  \lineiii{\~\var{x}}{\var{x} のビット反転}{}
\end{tableiii}
\indexiii{operations on}{integer}{types}
\indexii{bit-string}{operations}
\indexii{shifting}{operations}
\indexii{masking}{operations}

\noindent
注釈:
\begin{description}
\item[(1)] 負値のシフト数は不正であり、\exception{ValueError} が送出
されます。
\item[(2)] \var{n} ビットの左シフトは、オーバフローチェックを行わない
\code{pow(2, \var{n})} による乗算と等価です。
\item[(3)] \var{n} ビットの右シフトは、オーバフローチェックを行わない
\code{pow(2, \var{n})} による除算と等価です。
\end{description}


\section{イテレータ型 \label{typeiter}}

\versionadded{2.2}
\index{iterator protocol}
\index{protocol!iterator}
\index{sequence!iteration}
\index{container!iteration over}

Python はコンテナの内容にわたって反復処理を行う概念をサポートして
います。この概念は 2 つの別々のメソッドを使って実装されています;
これらのメソッドはユーザ定義のクラスで反復を行えるようにするために
使われます。後に詳しく述べるシーケンス型はすべて反復処理メソッドを
サポートしています。

以下はコンテナオブジェクトに反復処理をサポートさせるために定義しなければ
ならないメソッドです:

\begin{methoddesc}[container]{__iter__}{}
  イテレータオブジェクトを返します。イテレータオブジェクトは以下で述べる
イテレータプロトコルをサポートする必要があります。あるコンテナが
異なる形式の反復処理をサポートする場合、それらの反復処理形式
のイテレータを特定的に要求するようなメソッドを追加することができます
(複数の形式での反復処理をサポートするようなオブジェクトとして
木構造の例があります。木構造は幅優先走査と深さ優先走査の両方を
サポートします)。
このメソッドは Python/C API において Python オブジェクトを表す
型構造体の \member{tp_iter} スロットに対応します。
\end{methoddesc}

イテレータオブジェクト自体は以下の 2 のメソッドをサポートする必要
があります。これらのメソッドは 2 つ合わせて \dfn{イテレータプロトコル}
を成します:

\begin{methoddesc}[iterator]{__iter__}{}
  イテレータオブジェクト自体を返します。このメソッドはコンテナとイテレータの
両方を\keyword{for} および \keyword{in} 文で使えるようにするために
必要です。このメソッドは Python/C API において Python オブジェクトを表す
型構造体の \member{tp_iter} スロットに対応します。
\end{methoddesc}

\begin{methoddesc}[iterator]{next}{}
  コンテナ内の次の要素を返します。もう要素が残っていない場合、
例外 \exception{StopIteration} を送出します。このメソッドは
Python/C API において Python オブジェクトを表す型構造体の 
\member{tp_iternext} スロットに対応します。
\end{methoddesc}

Python では、いくつかのイテレータオブジェクトを定義しています。これらは
一般的および特殊化されたシーケンス型、辞書型、そして他のさらに特殊化
された形式をサポートします。特殊型であることはイテレータプロトコル
の実装が特殊になること以外は重要なことではありません。

このプロトコルの趣旨は、
一度イテレータの \method{next()} メソッドが \exception{StopIteration}
例外を送出した場合、以降の呼び出しでもずっと例外を送出しつづける
ところにあります。この特性に従わないような実装は変則であると
みなされます (この制限は Python 2.3 で追加されました; Python
2.2 では、この規則に従うと多くのイテレータが変則となります)。

Python におけるジェネレータ (generator) は、イテレータプロトコル
を実装する簡便な方法を提供します。コンテナオブジェクトの
\method{__iter__()} メソッドがジェネレータとして実装されて
いれば、メソッドは \method{__iter__()} および \method{next()} 
メソッドを提供するイテレータオブジェクト (技術的にはジェネレータ
オブジェクト) を自動的に返します。


\section{シーケンス型
	    \class{str}, \class{unicode}, \class{list},
	    \class{tuple}, \class{buffer}, \class{xrange}
	    \label{typesseq}}

組み込み型には 6 つのシーケンス型があります: 文字列、ユニコード文字列、
リスト、タプル、バッファ、そして xrange オブジェクトです。

文字列リテラルは \code{'xyzzy'}、\code{"frobozz"} といったように、
単引用符または二重引用符の中に書かれます。
文字列リテラルについての詳細はは、
\citetitle[../ref/strings.html]{Python リファレンスマニュアル}
の第 2 章を読んで下さい。
Unicode 文字列はほとんど文字列と同じですが、\code{u'abc'} 、
\code{u"def"} といったように先頭に文字 \character{u} を付けて
指定します。
リストは \code{[a, b, c]} のように要素をコンマで区切り角括弧で
囲って生成します。タプルは \code{a, b, c} のようにコンマ演算子で
区切って生成します (角括弧の中には入れません)。
丸括弧で囲っても囲わなくてもかまいませんが、空のタプルは 
\code{()} のように丸括弧で囲わなければなりません。
要素が一つのタプルでは、例えば \code{(d,)} のように、要素の後ろに
コンマをつけなければなりません。
\obindex{sequence}
\obindex{string}
\obindex{Unicode}
\obindex{tuple}
\obindex{list}

バッファオブジェクトは Python の構文上では直接サポートされていませんが、
組み込み関数 \function{buffer()}\bifuncindex{buffer} 
で生成することができます。バッファオブジェクトは結合や反復をサポート
していません。
\obindex{buffer}

xrange オブジェクトは、オブジェクトを生成するための特殊な構文がない
点でバッファに似ていて、関数 \function{xrange()}\bifuncindex{xrange}
で生成します。
xrange オブジェクトはスライス、結合、反復をサポートせず、
\code{in} 、 \code{not in} 、\function{min()} または \function{max()} 
は効率的ではありません。
\obindex{xrange}

ほとんどのシーケンス型は以下の演算操作をサポートします。\samp{in} および 
\samp{not in} は比較演算とおなじ優先度を持っています。
\samp{+} および \samp{*} は対応する数値演算とおなじ優先度です。
\footnote{パーザが被演算子の型を識別できるようにするために、このような優先度でなければならないのです。}

以下のテーブルはシーケンス型の演算を優先度の低いものから順に挙げたものです
(同じボックス内の演算は同じ優先度です)。テーブル内の
\var{s} および \var{t} は同じ型のシーケンスです; \var{n}、\var{i}
および \var{j} は整数です:

\begin{tableiii}{c|l|c}{code}{演算}{結果}{注釈}
  \lineiii{\var{x} in \var{s}}{\var{s} のある要素 \var{x} と等しい場合 \code{True} 、そうでない場合 \code{False}}{(1)}
  \lineiii{\var{x} not in \var{s}}{\var{s} のある要素が \var{x} と等しい場合 \code{False} 、そうでない場合 \code{True}}{(1)}
  \hline
  \lineiii{\var{s} + \var{t}}{\var{s} および \var{t} の結合}{(6)}
  \lineiii{\var{s} * \var{n}\textrm{,} \var{n} * \var{s}}{\var{s} の浅いコピー \var{n} 個からなる結合}{(2)}
  \hline
  \lineiii{\var{s}[\var{i}]}{\var{s} の 0 から数えて \var{i} 番目の要素}{(3)}
  \lineiii{\var{s}[\var{i}:\var{j}]}{\var{s} の \var{i} 番目から \var{j} 番目までのスライス}{(3), (4)}
  \lineiii{\var{s}[\var{i}:\var{j}:\var{k}]}{\var{s} の \var{i} 番目から \var{j}  番目まで、\var{k} 毎のスライス}{(3), (5)}
  \hline
  \lineiii{len(\var{s})}{\var{s} の長さ}{}
  \lineiii{min(\var{s})}{\var{s} の最小の要素}{}
  \lineiii{max(\var{s})}{\var{s} の最大の要素}{}
\end{tableiii}
\indexiii{operations on}{sequence}{types}
\bifuncindex{len}
\bifuncindex{min}
\bifuncindex{max}
\indexii{concatenation}{operation}
\indexii{repetition}{operation}
\indexii{subscript}{operation}
\indexii{slice}{operation}
\indexii{extended slice}{operation}
\opindex{in}
\opindex{not in}

\noindent
注釈:

\begin{description}
\item[(1)] \var{s} が文字列または Unicode 文字列の場合、 
演算操作 \code{in} および \code{not in} は部分文字列の一致テスト
と同じように動作します。バージョン 2.3 以前の Python では、
\var{x} は長さ 1 の文字列でした。Python 2.3 以降では、\var{x} 
はどの長さでもかまいません。

\item[(2)] \var{n} が \code{0} 以下の値の場合、\code{0} として
扱われます (これは \var{s} と同じ型の空のシーケンスを表します)。
コピーは浅いコピーなので注意してください; 入れ子になったデータ
構造はコピーされません。これは Python に慣れていないプログラマを
よく悩ませます。例えば以下のコードを考えます:

\begin{verbatim}
>>> lists = [[]] * 3
>>> lists
[[], [], []]
>>> lists[0].append(3)
>>> lists
[[3], [3], [3]]
\end{verbatim}

上のコードでは、 \code{lists} はリスト \code{[[]]} (空のリストを唯一の
要素として含んでいるリスト) の3つのコピーを要素とするリストです。
しかし、リスト内の要素に含まれているリストは各コピー間で共有されています。
以下のようにすると、異なるリストを要素とするリストを生成できます:
上のコードで、\code{[[]]} は空のリストを要素として含んでいるリストですから、 \code{[[]] * 3} の3つの要素の全てが、空のリスト（への参照）になります。 \code{lists} のいずれかの要素を修正することでこの単一のリストが変更されます。以下のようにすると、異なる個別のリストを生成できます:

\begin{verbatim}
>>> lists = [[] for i in range(3)]
>>> lists[0].append(3)
>>> lists[1].append(5)
>>> lists[2].append(7)
>>> lists
[[3], [5], [7]]
\end{verbatim}

\item[(3)] \var{i} または \var{j} が負の数の場合、インデクスは文字列の
末端からの相対インデクスになります: \code{len(\var{s}) + \var{i}} 
または \code{len(\var{s}) + \var{j}} が代入されます。
しかし \code{-0} は \code{0} のままなので注意してください。

\item[(4)] \var{s} の \var{i} から \var{j} へのスライスは
\code{\var{i} <= \var{k} < \var{j}} となるようなインデクス \var{k}
を持つ要素からなるシーケンスとして定義されます。\var{i} または \var{j} が
\code{len(\var{s})} よりも大きい場合、\code{len(\var{s})} を使います。
\var{i} が省略されるか \code{None} だった場合、\code{0} を使います。
\var{j} が省略されるか \code{None} だった場合、\code{len(\var{s})} を使います。
\var{i} が \var{j} 以上の場合、スライスは空のシーケンスになります。

\item[(5)] \var{s} の \var{i} 番目から \var{j} 番目まで 
\var{k} 毎のスライスは、$0 \leq n < \frac{j-i}{k}$ となるような、
インデクス\code{\var{x} = \var{i} + \var{n}*\var{k}} を持つ要素からなる
シーケンスとして定義されます。言い換えるとインデクスは \code{i}、\code{i+k}、
\code{i+2*k}、\code{i+3*k} などであり、\var{j} に達したところ
(しかし \var{j} は含みません)でストップします。
\var{i} または \var{j} が \code{len(\var{s})} より大きい場合、\code{len(\var{s})} 
を使います。\var{i} または \var{j} を省略するか \code{None} だった場合、``最後''
(\var{k} の符号に依存)を示す値を使います。\var{k} はゼロにできないので
注意してください。\var{k} が \code{None} だった場合、\code{1} として扱われます。

\item[(6)] \var{s} と \var{t} の両者が文字列であるとき、CPythonのような実装では、 
\code{\var{s}=\var{s}+\var{t}} や \code{\var{s}+=\var{t}}という書式で
代入をするのにin-place optimizationが働きます。このような時、最適化は二
乗の実行時間の低減をもたらします。この最適化はバージョンや実装に依存し
ます。実行効率が必要なコードでは、バージョンと実装が変わっても、直線的
な連結の実行効率を保証する\method{str.join()} を使うのがより望ましいで
しょう。
\versionchanged[以前、文字列の連結はin-placeで再帰されませんでした]{2.4}

\end{description}

\subsection{文字列メソッド \label{string-methods}}
\indexii{string}{methods}

以下は 8 ビット文字列および Unicode オブジェクトでサポートされる
メソッドです:

\begin{methoddesc}[string]{capitalize}{}
最初の文字を大文字にした文字列のコピーを返します。

8ビット文字列では、メソッドはロケール依存になります。
\end{methoddesc}

\begin{methoddesc}[string]{center}{width\optional{, fillchar}}
\var{width} の長さをもつ中央寄せされた文字列を返します。パディングには
\var{fillchar} で指定された値（デフォルトではスペース）が使われます。
\versionchanged[引数 \var{fillchar} に対応]{2.4}
\end{methoddesc}

\begin{methoddesc}[string]{count}{sub\optional{, start\optional{, end}}}
文字列 S\code{[\var{start}:\var{end}]} 中に部分文字列 \var{sub} 
が出現する回数を返します。オプション引数 \var{start} および \var{end}
はスライス表記と同じように解釈されます。
\end{methoddesc}

\begin{methoddesc}[string]{decode}{\optional{encoding\optional{, errors}}}
codec に登録された文字コード系 \var{encoding} を使って文字列をデコード
します。\var{encoding} は標準でデフォルトの文字列エンコーディング
になります。標準とは異なるエラー処理を行うために \var{errors} を
与えることができます。標準のエラー処理は \code{'strict'} で、エンコード
に関するエラーは \exception{UnicodeError} を送出します。
他に利用できる値は \code{'ignore'} 、 \code{'replace'} および
関数 \function{codecs.register_error} によって登録された名前です。
これについてはセクション~\ref{codec-base-classes}節を参照してください。
\versionadded{2.2}
\versionchanged[その他のエラーハンドリングスキーマがサポートされました]{2.3}
\end{methoddesc}

\begin{methoddesc}[string]{encode}{\optional{encoding\optional{,errors}}}
文字列のエンコードされたバージョンを返します。標準のエンコーディング
は現在のデフォルト文字列エンコーディングです。
標準とは異なるエラー処理を行うために \var{errors} を
与えることができます。標準のエラー処理は \code{'strict'} で、エンコード
に関するエラーは \exception{UnicodeError} を送出します。
他に利用できる値は \code{'ignore'} 、 \code{'replace'} 、
\code{'xmlcharrefreplace'}、 \code{'backslashreplace'} および
関数 \function{codecs.register_error} によって登録された名前です。
これについてはセクション~\ref{codec-base-classes}を参照してください。
利用可能なエンコーディングの一覧は、セクション~\ref{standard-encodings}
を参照してください。

\versionadded{2.0}
\versionchanged[\code{'xmlcharrefreplace'} 、 \code{'backslashreplace'} 
およびその他のエラーハンドリングスキーマがサポートされました]{2.3}
\end{methoddesc}

\begin{methoddesc}[string]{endswith}{suffix\optional{, start\optional{, end}}}
文字列の一部が \var{suffix} で終わるときに \code{True} を返します。そう
でない場合 \code{False} を返します。\var{suffix} は見つけたい複数の接尾語
のタプルでも構いません。オプション引数 \var{start} がある場
合、文字列の \var{start} から比較を始めます。\var{end} がある場合、文字
列の \var{end} で比較を終えます。

\versionchanged[\var{suffix} でタプルを受け付けるようになりました]{2.5}
\end{methoddesc}

\begin{methoddesc}[string]{expandtabs}{\optional{tabsize}}
全てのタブ文字が空白で展開された文字列のコピーを返します。
\var{tabsize} が与えられていない場合、タブ幅は \code{8} 文字分
と仮定します。
\end{methoddesc}

\begin{methoddesc}[string]{find}{sub\optional{, start\optional{, end}}}
文字列中の領域 [\var{start}, \var{end}] に \var{sub} が含まれる場合、
その最小のインデクスを返します。
% [\var{start}, \var{end}) をなぜ [\var{start}, \var{end}] に直すのか?
オプション引数 \var{start} および \var{end} はスライス表記と
同様に解釈されます。\var{sub} が見つからなかった場合 \code{-1} 
を返します。
\end{methoddesc}

\begin{methoddesc}[string]{index}{sub\optional{, start\optional{, end}}}
\method{find()} と同様ですが、\var{sub} が見つからなかった場合
\exception{ValueError} を送出します。
\end{methoddesc}

\begin{methoddesc}[string]{isalnum}{}
文字列中の全ての文字が英数文字で、かつ 1 文字以上ある場合には真を返し、
そうでない場合は偽を返します。

8ビット文字列では、メソッドはロケール依存になります。
\end{methoddesc}

\begin{methoddesc}[string]{isalpha}{}
文字列中の全ての文字が英文字で、かつ 1 文字以上ある場合には真を返し、
そうでない場合はを返します。

8ビット文字列では、メソッドはロケール依存になります。
\end{methoddesc}

\begin{methoddesc}[string]{isdigit}{}
文字列中に数字しかない場合には真を返し、その他の場合は偽を返します。

8ビット文字列では、メソッドはロケール依存になります。
\end{methoddesc}

\begin{methoddesc}[string]{islower}{}
文字列中の大小文字の区別のある文字全てが小文字で、かつ 1 文字以上
ある場合には真を返し、そうでない場合は偽を返します。

8ビット文字列では、メソッドはロケール依存になります。
\end{methoddesc}

\begin{methoddesc}[string]{isspace}{}
文字列が空白文字だけからなり、かつ 1 文字以上ある場合には真を返し、
そうでない場合は偽を返します。

8ビット文字列では、メソッドはロケール依存になります。
\end{methoddesc}

\begin{methoddesc}[string]{istitle}{}
文字列がタイトルケース文字列であり、かつ 1 文字以上ある場合、
例えば大文字は大小文字の区別のない文字の後にのみ続き、
小文字は大小文字の区別のある文字の後ろにのみ続く場合には真を返します。
そうでない場合は偽を返します。

8ビット文字列では、メソッドはロケール依存になります。
\end{methoddesc}

\begin{methoddesc}[string]{isupper}{}
文字列中の大小文字の区別のある文字全てが大文字で、かつ 1 文字以上
ある場合には真を返し、そうでない場合は偽を返します。

8ビット文字列では、メソッドはロケール依存になります。
\end{methoddesc}

\begin{methoddesc}[string]{join}{seq}
シーケンス \var{seq} 中の文字列を結合した文字列を返します。文字列を
結合するときの区切り文字は、このメソッドを適用する対象の文字列に
なります。
\end{methoddesc}

\begin{methoddesc}[string]{ljust}{width\optional{, fillchar}}
\var{width} の長さをもつ左寄せした文字列を返します。
パディングには \var{fillchar} で指定された文字(デフォルトではスペース）
が使われます。\var{width} が \code{len(\var{s})}
よりも小さい場合、元の文字列が返されます。
\versionchanged[引数 \var{fillchar} が追加されました]{2.4}
\end{methoddesc}

\begin{methoddesc}[string]{lower}{}
文字列をコピーし、小文字に変換して返します。

8ビット文字列では、メソッドはロケール依存になります。
\end{methoddesc}

\begin{methoddesc}[string]{lstrip}{\optional{chars}}
文字列の先頭部分を除去したコピーを返します。
引数 \var{chars} は除去される文字集合を指定する文字列です。
\var{chars} が省略されるか \code{None} の場合、空白文字が
除去されます。\var{chars} 文字列は接頭語ではなく、そこに
含まれる文字の組み合わせ全てがはぎ取られます。
\begin{verbatim}
    >>> '   spacious   '.lstrip()
    'spacious   '
    >>> 'www.example.com'.lstrip('cmowz.')
    'example.com'
\end{verbatim}
\versionchanged[引数 \var{chars} をサポートしました]{2.2.2}
\end{methoddesc}

\begin{methoddesc}[string]{partition}{sep}
文字列を \var{sep} の最初の出現位置で区切り、3要素のタプルを返します。
タプルの内容は、区切りの前の部分、区切り文字列そのもの、そして区切りの後ろの部分です。
もし区切れなければ、タプルには元の文字列そのものとその後ろに二つの空文字列が入ります。
\versionadded{2.5}
\end{methoddesc}

\begin{methoddesc}[string]{replace}{old, new\optional{, count}}
文字列をコピーし、部分文字列 \var{old} のある部分全てを \var{new}
に置換して返します。オプション引数 \var{count} が与えられて
いる場合、先頭から \var{count} 個の \var{old} だけを置換します。
\end{methoddesc}

\begin{methoddesc}[string]{rfind}{sub \optional{,start \optional{,end}}}
文字列中の領域 [\var{start}, \var{end}) に \var{sub} が含まれる場合、
その最大のインデクスを返します。
オプション引数 \var{start} および \var{end} はスライス表記と
同様に解釈されます。\var{sub} が見つからなかった場合 \code{-1} 
を返します。
\end{methoddesc}

\begin{methoddesc}[string]{rindex}{sub\optional{, start\optional{, end}}}
\method{find()} と同様ですが、\var{sub} が見つからなかった場合
\exception{ValueError} を送出します。
\end{methoddesc}

\begin{methoddesc}[string]{rjust}{width\optional{, fillchar}}
\var{width} の長さをもつ右寄せした文字列を返します。
パディングには \var{fillchar} で指定された文字(デフォルトではスペース）
が使われます。\var{width} が \code{len(\var{s})}
よりも小さい場合、元の文字列が返されます。
\versionchanged[引数 \var{fillchar} が追加されました]{2.4}
\end{methoddesc}

\begin{methoddesc}[string]{rpartition}{sep}
文字列を \var{sep} の最後の出現位置で区切り、3要素のタプルを返します。
タプルの内容は、区切りの前の部分、区切り文字列そのもの、そして区切りの後ろの部分です。
もし区切れなければ、タプルには二つの空文字列とその後ろに元の文字列そのものが入ります。
\versionadded{2.5}
\end{methoddesc}

\begin{methoddesc}[string]{rsplit}{\optional{sep \optional{,maxsplit}}}
\var{sep} を区切り文字とした、文字列中の単語のリストを返します。
\var{maxsplit} が与えられた場合、最大で \var{maxsplit} 個になるように
分割が行なわれます、\emph{最も右側} （の単語）は1つになります。
\var{sep} が指定されていない、あるいは \code{None}のとき、全ての
空白文字が区切り文字となります。右から分割していくことを除けば、
\method{rsplit()} は後ほど詳しく述べる \method{split()} と同様に振る舞います。
\versionadded{2.4}
\end{methoddesc}

\begin{methoddesc}[string]{rstrip}{\optional{chars}}
文字列の末尾部分を除去したコピーを返します。
引数 \var{chars} は除去される文字集合を指定する文字列です。
\var{chars} が省略されるか \code{None} の場合、空白文字が
除去されます。\var{chars} 文字列は接尾語ではなく、そこに
含まれる文字の組み合わせ全てがはぎ取られます。
\begin{verbatim}
    >>> '   spacious   '.rstrip()
    '   spacious'
    >>> 'mississippi'.rstrip('ipz')
    'mississ'
\end{verbatim}
\versionchanged[引数 \var{chars} をサポートしました]{2.2.2}
\end{methoddesc}

\begin{methoddesc}[string]{split}{\optional{sep \optional{,maxsplit}}}
\var{sep} を単語の境界として文字列を単語に分割し、分割された単語
からなるリストを返します。
(したがって返されるリストは\code{\var{maxsplit}+1} の要素を持ちます）
\var{maxsplit} が与えられていない場合、無制限に分割が行なわれます
（全ての可能な分割が行なわれる）。連続した区切り文字はグループ化されず、
空の文字列を区切っていると判断されます(例えば \samp{'1,,2'.split(',')} は
\samp{['1', '', '2']} を返します)。引数 \var{sep} は複数の文字にも
できます(例えば \samp{'1, 2, 3'.split(', ')} は
\samp{['1', '2', '3']} を返します)。区切り文字を指定して空の文字列を
分割すると、\samp{['']} を返します。

\var{sep} が指定されていないか \code{None} が指定されている場合、異なる分割
アルゴリズムが適用されます。最初に空白文字（スペース、タブ、改行(newline)、
復帰(return)、改ページ(formfeed)) が文字列の両端から除去されます。
次に任意の長さの空白文字列によって単語に分割されます。
連続した空白の区切り文字は単一の区切り文字として扱われます
（\samp{'1   2  3'.split()} は \samp{['1', '2', '3']} を返します）。
空の文字列や空白文字だけから成る文字列を分割する場合には空のリストを返します。
\end{methoddesc}

\begin{methoddesc}[string]{splitlines}{\optional{keepends}}
文字列を改行部分で分解し、各行からなるリストを返します。
\var{keepends} が与えられていて、かつその値が真でない限り、
返されるリストには改行文字は含まれません。

8ビット文字列では、メソッドはロケール依存になります。
\end{methoddesc}

\begin{methoddesc}[string]{startswith}{prefix\optional{,
                                       start\optional{, end}}}
文字列の一部が \var{prefix} で始まるときに \code{True} を返します。そう
でない場合 \code{False} を返します。\var{prefix} は複数の接頭語の
タプルにしても構いません。オプション引数 \var{start} がある場
合、文字列の \var{start} から比較を始めます。\var{end} がある場合、文字
列の \var{end} で比較を終えます。

\versionchanged[\var{prefix} でタプルを受け付けるようになりました]{2.5}
\end{methoddesc}

\begin{methoddesc}[string]{strip}{\optional{chars}}
文字列の先頭および末尾部分を除去したコピーを返します。
引数 \var{chars} は除去される文字集合を指定する文字列です。
\var{chars} が省略されるか \code{None} の場合、空白文字が
除去されます。\var{chars} 文字列は接頭語でも接尾語でもなく、
そこに含まれる文字の組み合わせ全てがはぎ取られます。
\begin{verbatim}
    >>> '   spacious   '.strip()
    'spacious'
    >>> 'www.example.com'.strip('cmowz.')
    'example'
\end{verbatim}
\versionchanged[引数 \var{chars} をサポートしました]{2.2.2}
\end{methoddesc}

\begin{methoddesc}[string]{swapcase}{}
文字列をコピーし、大文字は小文字に、小文字は大文字に変換して返します。
\end{methoddesc}

\begin{methoddesc}[string]{title}{}
文字列をタイトルケースにして返します: 大文字から始まり、残りの
文字のうち大小文字の区別があるものは全て小文字にします。
\end{methoddesc}

\begin{methoddesc}[string]{translate}{table\optional{, deletechars}}
文字列をコピーし、オプション引数の文字列 \var{deletechars} の中に
含まれる文字を全て除去します。その後、残った文字を変換テーブル
\var{table} に従ってマップして返します。変換テーブルは長さ 256 
の文字列でなければなりません。

Unicode オブジェクトの場合、\method{translate()} メソッドはオプションの
\var{deletechars} 引数を受理しません。その代わり、メソッドは
すべての文字が与えられた変換テーブルで対応付けされている \var{s} の
コピーを返します。この変換テーブルは Unicode 順 (ordinal) から
Unicode 順、Unicode 文字列、または \code{None} への対応付け
でなくてはなりません。対応付けされていない文字は何もせず放置されます。
\code{None} に対応付けられた文字は削除されます。ちなみに、
より柔軟性のあるアプローチは、自作の文字対応付けを行う codec
を \refmodule{codecs} モジュールを使って作成することです 
(例えば \module{encodings.cp1251} を参照してください。
\end{methoddesc}


\begin{methoddesc}[string]{upper}{}
文字列をコピーし、大文字に変換して返します。

8ビット文字列では、メソッドはロケール依存になります。
\end{methoddesc}

\begin{methoddesc}[string]{zfill}{width}
数値文字列の左側をゼロ詰めし、幅 \var{width} にして返します。
\var{width} が \code{len(\var{s})} よりも短い場合もとの文字列自体が
返されます。
\versionadded{2.2.2}
\end{methoddesc}


\subsection{文字列フォーマット操作 \label{typesseq-strings}}

\index{formatting, string (\%{})}
\index{interpolation, string (\%{})}
\index{string!formatting}
\index{string!interpolation}
\index{printf-style formatting}
\index{sprintf-style formatting}
\index{\protect\%{} formatting}
\index{\protect\%{} interpolation}

文字列および Unicode オブジェクトには固有の操作: \code{\%} 演算子 
(モジュロ) があります。この演算子は文字列 \emph{フォーマット化} 
または \emph{補間} 演算としても知られています。
\code{\var{format} \% \var{values}} (\var{format} は文字列または
Unicode オブジェクト)とすると、\var{format} 中の \code{\%} 変換指定は 
\var{values} 中のゼロ個またはそれ以上の要素で置換されます。
この動作は C 言語における \cfunction{sprintf()} に似ています。
\var{format} が Unicode オブジェクトであるか、または \code{\%s} 
変換を使って Unicode オブジェクトが変換される場合、その結果も
Unicode オブジェクトになります。

\var{format} が単一の引数しか要求しない場合、\var{values} は
タプルでない単一のオブジェクトでもかまいません。
\footnote{従って、一個のタプルだけをフォーマット出力したい場合には出力したいタプルを唯一の要素とする単一のタプルを \var{values} に与えなくてはなりません。}
それ以外の場合、\var{values} はフォーマット文字列中で指定された項目と
正確に同じ数の要素からなるタプルか、単一のマップオブジェクトでなければ
なりません。

一つの変換指定子は 2 またはそれ以上の文字を含み、その構成要素は
以下からなりますが、示した順に出現しなければなりません:

\begin{enumerate}
  \item  変換指定子が開始することを示す文字 \character{\%}。
  \item  マップキー (オプション)。 丸括弧で囲った文字列からなります
(例えば \code{(someone)}) 。
  \item  変換フラグ (オプション)。一部の変換型の結果に影響します。
  \item  最小のフィールド幅 (オプション).  \character{*} (アスタリスク) 
を指定した場合、実際の文字列幅が \var{values} タプルの次の要素から読み
出されます。タプルには最小フィールド幅やオプションの精度指定の後に
変換したいオブジェクトがくるようにします。
  \item  精度 (オプション)。\character{.} (ドット) とその後に続く精度
で与えられます。\character{*} (アスタリスク) を指定した場合、精度
の桁数はタプルの次の要素から読み出されます。タプルには精度指定の
後に変換したい値がくるようにします。
  \item  精度長変換子 (オプション)。
  \item  変換型。
\end{enumerate}

\code{\%} 演算子の右側の引数が辞書の場合 (またはその他のマップ型の場合)、
文字列中のフォーマットには、辞書に挿入されているキーを丸括弧で囲い、文字
\character{\%} の直後にくるようにしたものが含まれていなければ
\emph{なりません} 。マップキーはフォーマット化したい値をマップから
選び出します。例えば:

\begin{verbatim}
>>> print '%(language)s has %(#)03d quote types.' % \
          {'language': "Python", "#": 2}
Python has 002 quote types.
\end{verbatim}

この場合、 \code{*} 指定子をフォーマットに含めてはいけません
(\code{*} 指定子は順番付けされたパラメタのリストが必要だからです。)

変換フラグ文字を以下に示します:

\begin{tableii}{c|l}{character}{フラグ}{意味}
  \lineii{\#}{値の変換に (下で定義されている) ``別の形式'' を使います。}
  \lineii{0}{数値型に対してゼロによるパディングを行います。}
  \lineii{-}{変換された値を左寄せにします (\character{0} と同時に与えた
場合、\character{0} を上書きします) 。}
  \lineii{{~}}{(スペース) 符号付きの変換で正の数の場合、前に一つスペースを空けます (そうでない場合は空文字になります)	。}
  \lineii{+}{変換の先頭に符号文字 (\character{+} または \character{-}) を付けます("スペース" フラグを上書きします) 。}
\end{tableii}

精度長変換子(\code{h} 、 \code{l} 、または \code{L}) を使う
ことができますが、Python では必要ないため無視されます。

変換型を以下に示します:

\begin{tableiii}{c|l|c}{character}{変換}{意味}{注釈}
  \lineiii{d}{符号付き 10 進整数。}{}
  \lineiii{i}{符号付き 10 進整数。}{}
  \lineiii{o}{符号なし 8 進数。}{(1)}
  \lineiii{u}{符号なし 10 進数。}{}
  \lineiii{x}{符号なし 16 進数 (小文字)。}{(2)}
  \lineiii{X}{符号なし 16 進数 (大文字)。}{(2)}
  \lineiii{e}{指数表記の浮動小数点数 (小文字)。}{(3)}
  \lineiii{E}{指数表記の浮動小数点数 (大文字)。}{(3)}
  \lineiii{f}{10 進浮動小数点数。}{(3)}
  \lineiii{F}{10 進浮動小数点数。}{(3)}
  \lineiii{g}{浮動小数点数。指数部が -4 以上または精度以下の場合には
    指数表記、それ以外の場合には10進表記。}{(4)}
  \lineiii{G}{浮動小数点数。指数部が -4 以上または精度以下の場合には
    指数表記、それ以外の場合には10進表記。}{(4)}
  \lineiii{c}{文字一文字 (整数または一文字からなる文字列を受理します)。}{}
  \lineiii{r}{文字列 (python オブジェクトを \function{repr()} で変換します)。}{(5)}
  \lineiii{s}{文字列 (python オブジェクトを \function{str()} で変換します)。}{(6)}
  \lineiii{\%}{引数を変換せず、返される文字列中では文字 \character{\%} になります。}{}
\end{tableiii}

\noindent
注釈:
\begin{description}
  \item[(1)]
この形式の出力にした場合、変換結果の先頭の数字がゼロ (\character{0}) 
でないときには、数字の先頭と左側のパディングとの間にゼロを挿入します。
  \item[(2)]
この形式にした場合、変換結果の先頭の数字がゼロでないときには、
数字の先頭と左側のパディングとの間に \code{'0x'} または \code{'0X'} 
(フォーマット文字が \character{x} か \character{X} かに依存します)
が挿入されます。
  \item[(3)]
この形式にした場合、変換結果には常に小数点が含まれ、
それはその後ろに数字が続かない場合にも適用されます。

指定精度は小数点の後の桁数を決定し、そのデフォルトは 6 です。
  \item[(4)] 
この形式にした場合、変換結果には常に小数点が含まれ
他の形式とは違って末尾の 0 は取り除かれません。

指定精度は小数点の前後の有効桁数を決定し、そのデフォルトは 6 です。
  \item[(5)]
\code{\%r} 変換は Python 2.0 で追加されました。

指定精度は最大文字数を決定します。
  \item[(6)]
オブジェクトや与えられた書式が \class{unicode} 文字列の場合、変換後の文字列も \class{unicode} になります。

指定精度は最大文字数を決定します。
\end{description}

% XXX Examples?

Python 文字列には明示的な長さ情報があるので、\code{\%s} 変換において
\code{'\e0'} を文字列の末端と仮定したりはしません。

安全上の理由から、浮動小数点数の精度は 50 桁でクリップされます; 
絶対値が 1e25 を超える値の \code{\%f} による変換は \code{\%g}
変換で置換されます \footnote{この範囲に関する値はかなり適当なものです。
この仕様は、正しい使い方では障害とならず、かつ特定のマシンにおける
浮動小数点数の正確な精度を知らなくても、際限なく長くて意味のない数字から
なる文字列を印字しないですむようにするためのものです。}
その他のエラーは例外を送出します。

その他の文字列操作は標準モジュール \refmodule{string}
\refstmodindex{string} および \refmodule{re}.\refstmodindex{re}
で定義されています。


\subsection{XRange 型 \label{typesseq-xrange}}

\class{xrange}\obindex{xrange} 型は値の変更不能なシーケンスで、広範なループ処理に
使われています。\class{xrange} 型の利点は、 \class{xrange} オブジェクトは
表現する値域の大きさにかかわらず常に同じ量のメモリしか占めないということです。
はっきりしたパフォーマンス上の利点はありません。

XRange オブジェクトは非常に限られた振る舞い、すなわち、インデクス検索、反復、 \function{len()} 関数のみをサポートしています。

\subsection{変更可能なシーケンス型 \label{typesseq-mutable}}

リストオブジェクトはオブジェクト自体の変更を可能にする追加の操作を
サポートします。他の変更可能なシーケンス型 (を言語に追加する場合) も、
それらの操作をサポートしなければなりません。
文字列およびタプルは変更不可能なシーケンス型です: これらのオブジェクトは
一度生成されたらそのオブジェクト自体を変更することができません。
以下の操作は変更可能なシーケンス型で定義されています (ここで \var{x} は
任意のオブジェクトとします):
\indexiii{mutable}{sequence}{types}
\obindex{list}

\begin{tableiii}{c|l|c}{code}{操作}{結果}{注釈}
  \lineiii{\var{s}[\var{i}] = \var{x}}
	{\var{s} の要素 \var{s} を \var{x} と入れ替えます}{}
  \lineiii{\var{s}[\var{i}:\var{j}] = \var{t}}
  	{\var{s} の \var{i} から \var{j} 番目までのスライスを
          イテラブル \var{t} の内容に入れ替えます}{}
  \lineiii{del \var{s}[\var{i}:\var{j}]}
	{\code{\var{s}[\var{i}:\var{j}] = []} と同じです}{}
  \lineiii{\var{s}[\var{i}:\var{j}:\var{k}] = \var{t}}
	{\code{\var{s}[\var{i}:\var{j}:\var{k}]} の要素を \var{t} と入れ替えます}{(1)}
  \lineiii{del \var{s}[\var{i}:\var{j}:\var{k}]}
	{リストから \code{\var{s}[\var{i}:\var{j}:\var{k}]} の要素を削除します}{}
  \lineiii{\var{s}.append(\var{x})}
	{\code{\var{s}[len(\var{s}):len(\var{s})] = [\var{x}]} と同じです}{(2)}
  \lineiii{\var{s}.extend(\var{x})}
        {\code{\var{s}[len(\var{s}):len(\var{s})] = \var{x}} と同じです}{(3)}
  \lineiii{\var{s}.count(\var{x})}
    {\code{\var{s}[\var{i}] == \var{x}} となる \var{i} の個数を返します}{}
  \lineiii{\var{s}.index(\var{x}\optional{, \var{i}\optional{, \var{j}}})}
    {\code{\var{s}[\var{k}] == \var{x}} かつ
    \code{\var{i} <= \var{k} < \var{j}} となる最小の \var{k} を返します。}{(4)}
  \lineiii{\var{s}.insert(\var{i}, \var{x})}
	{\code{\var{i} >= 0} の場合の \code{\var{s}[\var{i}:\var{i}] = [\var{x}]} と同じです}{(5)}
  \lineiii{\var{s}.pop(\optional{\var{i}})}
    {\code{\var{x} = \var{s}[\var{i}]; del \var{s}[\var{i}]; return \var{x}} と同じです}{(6)}
  \lineiii{\var{s}.remove(\var{x})}
	{\code{del \var{s}[\var{s}.index(\var{x})]} と同じです}{(4)}
  \lineiii{\var{s}.reverse()}
	{\var{s} の値の並びを反転します}{(7)}
  \lineiii{\var{s}.sort(\optional{\var{cmp}\optional{,
                        \var{key}\optional{, \var{reverse}}}})}
	{\var{s} の要素を並べ替えます}{(7), (8), (9), (10)}
\end{tableiii}
\indexiv{operations on}{mutable}{sequence}{types}
\indexiii{operations on}{sequence}{types}
\indexiii{operations on}{list}{type}
\indexii{subscript}{assignment}
\indexii{slice}{assignment}
\indexii{extended slice}{assignment}
\stindex{del}
\withsubitem{(list method)}{
  \ttindex{append()}\ttindex{extend()}\ttindex{count()}\ttindex{index()}
  \ttindex{insert()}\ttindex{pop()}\ttindex{remove()}\ttindex{reverse()}
  \ttindex{sort()}}
\noindent
Notes:
\begin{description}
\item[(1)] \var{t} は入れ替えるスライスと同じ長さでなければいけません。

\item[(2)] かつての Python の C 実装では、複数パラメタを受理し、
非明示的にそれらをタプルに結合していました。この間違った機能は
Python 1.4 で廃用され、Python 2.0 の導入とともにエラーにする
ようになりました。

\item[(3)] \var{x} は任意のイテラブル(繰り返し可能オブジェクト)にできます。

\item[(4)] \var{x} が \var{s} 中に見つからなかった場合
\exception{ValueError} を送出します。　
負のインデクスが二番目または三番目のパラメタとして \method{index()}
メソッドに渡されると、これらの値にはスライスのインデクスと同様に
リストの長さが加算されます。加算後もまだ負の場合、その値はスライス
のインデクスと同様にゼロに切り詰められます。
\versionchanged[以前は、\method{index()} は開始位置や終了位置を
指定するのに負の数を使うことができませんでした]{2.3}

\item[(5)] \method{insert()} の最初のパラメタとして負のインデクスが渡された場合、スライスのインデクスと同じく、リストの長さが加算されます。それでも負の値を取る場合、スライスのインデクスと同じく、0 に丸められます。\versionchanged[以前は、すべての負値は 0 に丸められていました。]{2.3}

\item[(6)] \method{pop()} メソッドはリストおよびアレイ型のみでサポート
されています。オプションの引数 \var{i} は標準で \code{-1} なので、
標準では最後の要素をリストから除去して返します。

\item[(7)] \method{sort()} および \method{reverse()} メソッドは
大きなリストを並べ替えたり反転したりする際、容量の節約のために
リストを直接変更します。副作用があることをユーザに思い出させるために、
これらの操作は並べ替えまたは反転されたリストを返しません。

\item[(8)] \method{sort()} メソッドは、比較を制御するためにオプションの
引数をとります。

\var{cmp} は2つの引数(list items)からなるカスタムの比較関数を指定します。
  これは始めの引数が2つ目の引数に比べて小さい、等しい、大きいかに応じて
  負数、ゼロ、正数を返します。
  \samp{\var{cmp}=\keyword{lambda} \var{x},\var{y}:
  \function{cmp}(x.lower(), y.lower())}

\var{key} は1つの引数からなる関数を指定します。これは個々のリストの要素から
  比較のキーを取り出すのに使われます。
  \samp{\var{key}=\function{str.lower}}

\var{reverse} は真偽値です。 \code{True} がセットされた場合、リストの要素は
  個々の比較が反転したものとして並び替えられます。

一般的に、 \var{key} および \var{reverse} の変換プロセスは同等の \var{cmp} 関数を
指定するより早く動作します。これは \var{key} および \var{reverse} がそれぞれの要素に
一度だけ触れる間に、\var{cmp} はリストのそれぞれの要素に対して複数回呼ばれることに
よるものです。

\versionchanged[\code{None} を渡すのと、\var{cmp} を省略した場合とで、
同等に扱うサポートを追加]{2.3}

\versionchanged[\var{key} および \var{reverse} のサポートを追加]{2.4}

\item[(9)] Python2.3 以降、\method{sort()} メソッドは安定していることが
保証されています。 ソートは等しいとされた要素の相対オーダーが変更されないことが
保証されれば、安定しています --- これは複合的なパス（例えば部署ごとにソートして、
それを給与の等級）でソートを行なうのに役立ちます。

\item[(10)] リストが並べ替えられている間は、リストの変更はもとより、
その値の閲覧すらその結果は未定義です。
Python 2.3以降 の C 実装では、この間リストは空に見えるようになり、
並べ替え中にリストが変更されたことが検出されると \exception{ValueError}
が送出されます。
\end{description}

\section{set（集合）型 ---
	    \class{set}, \class{frozenset}
	    \label{types-set}}
\obindex{set}

\dfn{set} オブジェクトは順序付けされていない変更不可能な値のコレクションです。
よくある使い方には、メンバーシップのテスト、数列から重複を削除する、
そして論理積、論理和、差集合、対称差など数学的演算の計算が含まれます。
\versionadded{2.4}

他のコレクションと同様、 setsは \code{\var{x} in \var{set}}、
\code{len(\var{set})}および \code{for \var{x} in \var{set}}
をサポートします。順序を持たないコレクションとして、setsは要素の位置と
（要素の）挿入位置を保持しません。したがって、setsはインデックス、スライス、
その他のシーケンス的な振る舞いをサポートしません。

\class{set} および \class{frozenset}という、2つの組み込みset型があります。
\class{set} は変更可能な ---  \method{add()} や \method{remove()}のような
メソッドを使って内容を変更できます。変更可能なため、ハッシュ値を持たず、また
辞書のキーや他のsetの要素として用いることができません。\class{frozenset} 型は
変更不能であり、ハッシュ化可能で --- 一度作成されると内容を改変することが
できません。一方で辞書のキーや他のsetの要素として用いることができます。

\class{set} および \class{frozenset} のインスタンスは、以下の演算を提供します。

\begin{tableiii}{c|c|l}{code}{Operation}{Equivalent}{Result}
  \lineiii{len(\var{s})}{}{set \var{s} の基数}

  \hline
  \lineiii{\var{x} in \var{s}}{}
         {\var{s} のメンバに \var{x} があるか調べる}
  \lineiii{\var{x} not in \var{s}}{}
         {\var{s} のメンバに \var{x} がないか調べる}
  \lineiii{\var{s}.issubset(\var{t})}{\code{\var{s} <= \var{t}}}
         {\var{t} に \var{s} の全ての要素が含まれるか調べる}
  \lineiii{\var{s}.issuperset(\var{t})}{\code{\var{s} >= \var{t}}}
         {\var{s} に \var{t} の全ての要素が含まれるか調べる}

  \hline
  \lineiii{\var{s}.union(\var{t})}{\var{s} | \var{t}}
         {\var{s} と \var{t}に含まれるすべての要素を持った新しいsetを作成}
  \lineiii{\var{s}.intersection(\var{t})}{\var{s} \&\ \var{t}}
         {\var{s} と \var{t}共通に含まれる要素を持った新しいsetを作成}
  \lineiii{\var{s}.difference(\var{t})}{\var{s} - \var{t}}
         {\var{s} には含まれるが \var{t}には含まれない要素を持った新しいsetを作成}
  \lineiii{\var{s}.symmetric_difference(\var{t})}{\var{s} \^\ \var{t}}
         {\var{s} と \var{t}のうち、両者には含まれない要素を持った新しいsetを作成}
  \lineiii{\var{s}.copy()}{}
         {\var{s}の浅いコピーを持った新しいsetを作成}
\end{tableiii}

注意すべき点として、演算子ではないバージョンのメソッド \method{union()}、 
\method{intersection()}、+\method{difference()}、\method{symmetric_difference()}、
\method{issubset()}および \method{issuperset()}はどの種類のiterableでも引数として
受け入れます。対照的に、（それぞれのメソッドに）対応する演算子は引数にsetsを
要求します。これはより読みやすい\code{set('abc').intersection('cbs')} という構文を
優先して \code{set('abc') \&\ 'cbs'} というような、エラーになりがちな構文を除外します。

\class{set} と \class{frozenset}の両者とも、setsとsetsの比較をサポートしています。
もし、あるいは少なくともそれぞれのsetsの全ての要素が他のsetsに含まれている
（それぞれのsetsがもう片方のサブセットである）場合、2つのsetsは等しいと言えます。
もし、あるいは少なくとも1つめのsetが2つめのsetの厳密なサブセットである
（サブセットではあるが等しくない）場合、setは他のsetより小さいと言えます。
もし、あるいは少なくとも1つめのsetが2つめのsetの厳密なスーパーセットである
（スーパーセットではあるが等しくない）場合、setは他のsetより大きいと言えます。

\class{set} のインスタンスは\class{frozenset} のインスタンスと、そのメンバを基に
比較されます。例えば \samp{set('abc') == frozenset('abc')} は \code{True}を返します。

サブセットと同一性の比較は完全な順序付け関数によって一般化されません。
例えば、どのような共通部分も持たない2つのsetsは、等しくもなく、互いのサブセットでもないので、
以下のコードの \emph{全て} に\code{False}を返します。
\code{\var{a}<\var{b}}、 \code{\var{a}==\var{b}}、 \code{\var{a}>\var{b}}。
それに応じて、setsは \method{__cmp__} メソッドを実装していません。

setsが部分的な順序付け（サブセットの関係）しか定義していないことから、
 \method{list.sort()} メソッドの結果は不確定のsetsのリストとなります。

set の要素は辞書のキーと同様に \method{__hash__} と \method{__eq__} の
両方を定義していることが必要です。

\class{set} と\class{frozenset}のインスタンスを混在させたバイナリ演算は
結果を1つめのオペランドの型で返します。例えば 
\samp{frozenset('ab') | set('bc')} は、\class{frozenset}のインスタンスを返します。

以下の表は\class{set}で可能なリスト操作です。これらの操作は変更不能な
\class{frozenset} のインスタンスには適用されません。

\begin{tableiii}{c|c|l}{code}{Operation}{Equivalent}{Result}
  \lineiii{\var{s}.update(\var{t})}
         {\var{s} |= \var{t}}
         {set \var{s} を \var{t} の要素を追加して更新します}
  \lineiii{\var{s}.intersection_update(\var{t})}
         {\var{s} \&= \var{t}}
         {set \var{s} を \var{s} と \var{t} の両方に属する要素だけ残すように更新します}
  \lineiii{\var{s}.difference_update(\var{t})}
         {\var{s} -= \var{t}}
         {set \var{s} を \var{t} に属する要素を削除するように更新します}
  \lineiii{\var{s}.symmetric_difference_update(\var{t})}
         {\var{s} \textasciicircum= \var{t}}
         {set \var{s} を \var{s} か \var{t} に属するが両方には属さない要素を持つように更新します}

  \hline
  \lineiii{\var{s}.add(\var{x})}{}
         {set \var{s} に要素 \var{x} を追加します}
  \lineiii{\var{s}.remove(\var{x})}{}
         {set \var{s} から要素 \var{x} を削除します。要素が存在しない場合は
           \exception{KeyError} を送出します}
  \lineiii{\var{s}.discard(\var{x})}{}
         {set \var{s} に要素 \var{x} が存在していれば削除します}
  \lineiii{\var{s}.pop()}{}
         {\var{s} から、任意の要素を返してその要素を削除します。空の場合は
         \exception{KeyError} を送出します}
  \lineiii{\var{s}.clear()}{}
         {set \var{s} から全ての要素を削除します}
\end{tableiii}

注意すべき点として、演算子ではないバージョンのメソッド \method{update()}、
\method{intersection_update()}、 \method{difference_update()} および
\method{symmetric_difference_update()} は、どんなiterableでも引数として
受け入れます。

set 型のデザインは \module{sets} で学んだことに基づいています。
     
\begin{seealso}     
  \seelink{comparison-to-builtin-set.html}
          {Comparison to the built-in set types}
          {\module{sets} モジュールと組み込み set 型の違い} 
\end{seealso}



\section{マップ型 \label{typesmapping}}
\obindex{mapping}
\obindex{dictionary}

\dfn{マップ型} (\dfn{mapping}) オブジェクトは変更不可能な値を任意の
オブジェクトに
対応付けます。対応付け自体は変更可能なオブジェクトです。
現在のところは標準のマップ型、\dfn{dictionary} だけです。
辞書のキーにはほとんど任意の値をつかうことができます。使うことが
できないのはリスト、辞書、その他の変更可能な型 (オブジェクトの一致
ではなく、その値で比較されるような型) です。
キーに使われた数値型は通常の数値比較規則に従います: 二つの数字を
比較した時等価であれば (例えば \code{1} と \code{1.0} のように)、
これらの値はお互いに同じ辞書のエントリを示すために使うことが
できます。

辞書は \code{\var{key}: \var{value}} からなるペアを
カンマで区切ったリストを波括弧の中に入れて作ります。
例えば:
\code{\{'jack': 4098, 'sjoerd': 4127\}} または
\code{\{4098: 'jack', 4127: 'sjoerd'\}} です。

以下の操作がマップ型で定義されています (ここで、\var{a} および \var{b}
はマップ型で、\var{k} はキー、 \var{v} および \var{x} は任意の
オブジェクトです):

\indexiii{operations on}{mapping}{types}
\indexiii{operations on}{dictionary}{type}
\stindex{del}
\bifuncindex{len}
\withsubitem{(dictionary method)}{
  \ttindex{clear()}
  \ttindex{copy()}
  \ttindex{has_key()}
  \ttindex{fromkeys()}
  \ttindex{items()}
  \ttindex{keys()}
  \ttindex{update()}
  \ttindex{values()}
  \ttindex{get()}
  \ttindex{setdefault()}
  \ttindex{pop()}
  \ttindex{popitem()}
  \ttindex{iteritems()}
  \ttindex{iterkeys()}
  \ttindex{itervalues()}}

\begin{tableiii}{c|l|c}{code}{操作}{結果}{注釈}
  \lineiii{len(\var{a})}{\var{a} 内の要素の数です}{}
  \lineiii{\var{a}[\var{k}]}{キー \var{k} を持つ\var{a} の要素です}{(1), (10)}
  \lineiii{\var{a}[\var{k}] = \var{v}}
          {\code{\var{a}[\var{k}]} を \var{v} に設定します}
          {}
  \lineiii{del \var{a}[\var{k}]}
          {\var{a} から \code{\var{a}[\var{k}]} を削除します}
          {(1)}
  \lineiii{\var{a}.clear()}{\code{a} から全ての要素を削除します}{}
  \lineiii{\var{a}.copy()}{\code{a} の(浅い)コピーです}{}
  \lineiii{\var{k} in \var{a}}
          {\var{a} にキー \var{k} があれば \code{True} 、
           そうでなければ \code{False} です}
          {(2)}
  \lineiii{\var{k} not in \var{a}}
          {\code{not} \var{k} in \var{a} と同じです}
          {(2)}
  \lineiii{\var{a}.has_key(\var{k})}
          {\var{k} \code{in} \var{a} と同じなので、新しく書くコードではその形を使ってください}
          {}
  \lineiii{\var{a}.items()}
          {\var{a} における (\var{key}, \var{value}) ペアのリストのコピーです}
          {(3)}
  \lineiii{\var{a}.keys()}{\var{a} におけるキーのリストのコピーです}{(3)}
  \lineiii{\var{a}.update(\optional{\var{b}})}
          {\var{b} によって key/value ペアを更新（上書き）}
          {(9)}
  \lineiii{\var{a}.fromkeys(\var{seq}\optional{, \var{value}})}
          {\var{seq} からキーを作り、値が \var{value} であるような、新しい辞書を作成します}
          {(7)}
  \lineiii{\var{a}.values()}{\var{a} における値のリストのコピーです}{(3)}
  \lineiii{\var{a}.get(\var{k}\optional{, \var{x}})}
          { もし \code{\var{k} in \var{a}}なら\code{\var{a}[\var{k}]}、
	    そうでなければ \var{x}を返します}
          {(4)}
  \lineiii{\var{a}.setdefault(\var{k}\optional{, \var{x}})}
          {もし \code{\var{k} in \var{a}}なら\code{\var{a}[\var{k}]}、
	    そうでなければ \var{x} (が与えられていた場合)を返します}
          {(5)}
  \lineiii{\var{a}.pop(\var{k}\optional{, \var{x}})}
          {もし \code{\var{k} in \var{a}} なら \code{\var{a}[\var{k}]} 、
           そうでなければ \var{x} を返して kを除去します}
          {(8)}
  \lineiii{\var{a}.popitem()}
          {任意の (\var{key}, \var{value}) ペアを除去して返します}
          {(6)}
  \lineiii{\var{a}.iteritems()}
          {(\var{key}, \var{value}) ペアにわたるイテレータを返します}
          {(2), (3)}
  \lineiii{\var{a}.iterkeys()}
          {マップのキー列にわたるイテレータを返します}
          {(2), (3)}
  \lineiii{\var{a}.itervalues()}
          {マップの値列にわたるイテレータを返します}
          {(2), (3)}
\end{tableiii}

\noindent
注釈:
\begin{description}
\item[(1)] \var{k} がマップ内にない場合、例外 \exception{KeyError} を
送出します。
\item[(2)] \versionadded{2.2}

\item[(3)] キーおよび値は任意の順序でリスト化されています。この順序は
ランダムではなく、Pythonの実装によって異なり、辞書の挿入、削除の履歴に
依存します。
\method{items()}、 \method{keys()}、 \method{values()}、
\method{iteritems()}、 \method{iterkeys()}および \method{itervalues()}が
途中で辞書を変更せずに呼ばれた場合、リストも直接対応するでしょう。
これにより、\code{(\var{value}, \var{key})} のペアを \function{zip()} を
使って: \samp{pairs = zip(\var{a}.values(), \var{a}.keys())} 
のように生成することができます。\method{iterkeys()} および
\method{itervalues()} メソッドの間でも同じ関係が成り立ちます:
\samp{pairs = zip(\var{a}.itervalues(), \var{a}.iterkeys())} 
は \code{pairs} と同じ値になります。
同じリストを生成するもう一つの方法は
\samp{pairs = [(v, k) for (k, v) in \var{a}.iteritems()]}
です。

\item[(4)] \var{k} がマップ中になくても例外を送出せず、代わりに
\var{x} を返します。\var{x} はオプションです; \var{x} が与えられて
おらず、かつ \var{k} がマップ中になければ、 \code{None} が返されます。

\item[(5)] \function{setdefault()} は \function{get()} に似ていますが、
\var{k} が見つからなかった場合、\var{x} が返されると同時に辞書の
\var{k} に対する値として挿入されます。デフォルトで \var{x} は \var{None}です。

\item[(6)] \function{popitem()} は、集合アルゴリズムでよく行われる
ような、辞書を取り崩しながらの反復を行うのに便利です。もし辞書が空なら
\function{popitem()} の呼び出しは \exception{KeyError} の送出を引き起こします。

\item[(7)] \function{fromkeys()} は、新しい辞書を返すクラスメソッドです。
\var{value} のデフォルト値は \code{None} です。 \versionadded{2.3}

\item[(8)] \function{pop()} は、デフォルト値が渡されず、かつ、キーが見つからない場合に、 \exception{KeyError} を送出します。 \versionadded{2.3}

\item[(9)] \function{update()} はその他のマッピングオブジェクトや反復可能な
キー/値のペア（タプルやその他2つの要素を持つ反復可能な要素）を受け入れます。
キーワードとなる引数が指定されている場合、マッピングはそれらのキー/値のペアで
更新されます。
\samp{d.update(red=1, blue=2)}
\versionchanged[キー／値のペアでできたイテレーション可能オブジェクトを引数に取るようになりました。また、キーワード引数をとるようになりました。]{2.4}

\item[(10)] dict のサブクラスが \method{__missing__} メソッドを定義しているならば、
キー \var{k} が無ければ \var{a}[\var{k}] は \var{k} を引数にそのメソッドを
呼び出します。したがってキーが無いときに \var{a}[\var{k}] が結果を返すのも
例外を送出するのも、\method{__missing__}(\var{k}) が結果を返すか
例外を送出するかで決まります。他のどんなメソッドも演算も
\method{__missing__}() を呼び出すことはありません。このような
\method{__missing__} が定義されていなければ、\exception{KeyError} が送出されます。
\method{__missing__} はメソッドでなければならず、インスタンス変数では駄目です。
例として \module{collections}.\class{defaultdict} を見てください。
\versionadded{2.5}

\end{description}


\section{ファイルオブジェクト
            \label{bltin-file-objects}}

ファイルオブジェクト \obindex{file} は C の\code{stdio}
パッケージを使って実装されており、
\ref{built-in-funcs} 節の 
``組み込み関数'' で解説されている組み込みのコンストラクタ
\function{file()}\bifuncindex{file} で生成することができます。
\footnote{ \function{file()} は Python 2.2 で新しく追加されました。
古いバージョンの組み込み関数 \function{open()} は \function{file()}
の別名です。} ファイルオブジェクトはまた、\function{os.popen()} や
\function{os.fdopen()} 、ソケットオブジェクトの \method{makefile()}
メソッドのような、他の組み込み関数およびメソッドによっても返されます。
\refstmodindex{os}
\refbimodindex{socket}

ファイル操作が I/O 関連の理由で失敗した場合例外 \exception{IOError}	
が送出されます。この理由には例えば \method{seek()} を端末デバイスに
行ったり、読み出し専用で開いたファイルに書き込みを行うといった、
何らかの理由によってそのファイルで定義されていない操作を行った
ような場合も含まれます。

ファイルは以下のメソッドを持ちます:


\begin{methoddesc}[file]{close}{}
ファイルを閉じます。閉じられたファイルはそれ以後読み書きすることは
できません。ファイルが開かれていることが必要な操作は、ファイルが
閉じられた後はすべて \exception{ValueError} を送出します。
\method{close} を一度以上呼び出してもかまいません。

Python 2.5 から \keyword{with} 文を使えばこのメソッドを直接呼び出す必要
はなくなりました。たとえば、以下のコードは \code{f} を \keyword{with}
ブロックを抜ける際に自動的に閉じます。

\begin{verbatim}
from __future__ import with_statement

with open("hello.txt") as f:
    for line in f:
        print line
\end{verbatim}

古いバージョンの Python では同じ効果を得るために次のようにしなければい
けませんでした。

\begin{verbatim}
f = open("hello.txt")
try:
    for line in f:
        print line
finally:
    f.close()
\end{verbatim}

\note{全ての Python の ``ファイル的'' 型が \keyword{with} 文用の
コンテキスト・マネージャとして使えるわけではありません。もし、全ての
ファイル的オブジェクトで動くようにコードを書きたいのならば、オブジェクトを
直接使うのではなく \module{contextlib} にある \function{closing()} を
使うと良いでしょう。詳細はセクション~\ref{context-closing} を参照してください。}
  
\end{methoddesc}

\begin{methoddesc}[file]{flush}{}
\code{stdio} の \cfunction{fflush()} のように、内部バッファを
フラッシュします。ファイル類似のオブジェクトによっては、この
操作は何も行いません。
\end{methoddesc}

\begin{methoddesc}[file]{fileno}{}
  \index{file descriptor}
  \index{descriptor, file}
背後にある実装系がオペレーティングシステムに I/O 操作を要求するために
用いる、整数の ``ファイル記述子'' を返します。この値は他の用途として、
\refmodule{fcntl}\refbimodindex{fcntl} モジュールや \function{os.read()}
やその仲間のような、ファイル記述子を必要とする低レベルのインタフェース
で役に立ちます。
\note{ファイル類似のオブジェクトが実際のファイルに関連付けられていない
場合、このメソッドを提供すべきでは\emph{ありません。}}
\end{methoddesc}

\begin{methoddesc}[file]{isatty}{}
ファイルが tty (または類似の) デバイスに接続されている場合 
\code{True} を返し、そうでない場合 \code{False} を返します。
\note{ファイル類似のオブジェクトが実際のファイルに関連付けられていない
場合、このメソッドを実装\emph{すべきではありません。}}
\end{methoddesc}

\begin{methoddesc}[file]{next}{}
ファイルオブジェクトはそれ自身がイテレータです。すなわち、
\code{iter(\var{f})} は (\var{f} が閉じられていない限り) 
\var{f} を返します。\keyword{for} ループ (例えば 
\code{for line in f: print line}) のようにファイルがイテレータとして
使われた場合、\method{next()} メソッドが繰り返し呼び出されます。
個のメソッドは次の入力行を返すか、または \EOF{} に到達したときに
\exception{StopIteration} を送出します。ファイル内の各行に対する
\keyword{for} ループ (非常によくある操作です) を効率的な方法で
行うために、\method{next()} メソッドは隠蔽された先読みバッファ
を使います。先読みバッファを使った結果として、(\method{readline()} 
のような) 他のファイルメソッドと \method{next()} を組み合わせて使うと
うまく動作しません。しかし、\method{seek()} を使ってファイル位置
を絶対指定しなおすと、先読みバッファはフラッシュされます。

\versionadded{2.3}
\end{methoddesc}

\begin{methoddesc}[file]{read}{\optional{size}}
最大で \var{size} バイトをファイルから読み込みます (\var{size} バイト
を取得する前に \EOF{} に到達した場合、それ以下の長さになります)
\var{size} 引数が負であるか省略された場合、\EOF{} に到達するまでの
全てのデータを読み込みます。読み出されたバイト列は文字列オブジェクト
として返されます。直後に \EOF{} に到達した場合、空の文字列が返されます。
(端末のようなある種のファイルでは、 \EOF{} に到達した後でファイルを
読みつづけることにも意味があります。) このメソッドは、\var{size} 
バイトに可能な限り近くデータを取得するために、背後の C 関数
\cfunction{fread()} を 1 度以上呼び出すかもしれないので注意してください。
また、非ブロック・モードでは、\var{size} パラメータが与えられなくても、
要求されたよりも少ないデータが返される場合があることに注意してください。
\end{methoddesc}

\begin{methoddesc}[file]{readline}{\optional{size}}
ファイルから一行を読み出します。末尾の改行文字は文字列中に
残されます（ですが、ファイルが不完全な行で終わっている場合は
何も残らないかもしれません）。 \footnote{改行を残す利点は、空の文字列が返ると
\EOF{} を示し、紛らわしくなくなるからです。また、ファイルの最後の行
が改行で終わっているかそうでない (ありえることです！) か
(例えば、ファイルを行単位で読みながらその完全なコピーを作成
した場合には問題になります) を調べることができます。}
引数 \var{size} が指定されていて負数でない場合、
(末尾の改行を含めて) 読み込む最大のバイト数です。この場合、
不完全な行が返されるかもしれません。空文字列が返されるのは、
直後に \EOF{} に到達した場合 \emph{だけ} です。
\note{\code{stdio} の \cfunction{fgets()} と違い、入力中に
ヌル文字 (\code{'\e 0'}) が含まれていれば、ヌル文字を含んだ
文字列が返されます。}
\end{methoddesc}

\begin{methoddesc}[file]{readlines}{\optional{sizehint}}
\method{readline()} を使ってに到達するまで読み出し、\EOF{}
読み出された行を含むリストを返します。オプションの 
\var{sizehint} 引数が存在すれば、\EOF まで読み出す代わりに
完全な行を全体で大体 \var{sizehint} バイトになるように
(おそらく内部バッファサイズを切り詰めて) 読み出します。
ファイル類似のインタフェースを実装しているオブジェクトは、
\var{sizehint} を実装できないか効率的に実装できない場合には
無視してもかまいません。
\end{methoddesc}

\begin{methoddesc}[file]{xreadlines}{}
個のメソッドは \code{iter(f)} と同じ結果を返します。
  \versionadded{2.1}
  \deprecated{2.3}{代わりに \samp{for \var{line} in \var{file}} を使ってください。}
\end{methoddesc}

\begin{methoddesc}[file]{seek}{offset\optional{, whence}}
\code{stdio} の \cfunction{fseek()} と同様に、ファイルの現在位置を
返します。\var{whence} 引数はオプションで、標準の値は \code{0}
(絶対位置指定) です; 他に取り得る値は \code{1} (現在のファイル位置
から相対的に seek する) および \code{2} (ファイルの末端から相対的に
seek する) です。戻り値はありません。ファイルを追記モード
(モード \code{'a'} または \code{'a+'}) で開いた場合、書き込みを行う
までに行った\method{seek()} 操作はすべて元に戻されるので注意してください。
ファイルが追記のみの書き込みモード (\code{'a'}) で開かれた場合、
このメソッドは実質何も行いませんが、読み込みが可能な追記モード
(\code{'a+'}) で開かれたファイルでは役に立ちます。
ファイルをテキストモードで (\code{'b'} なしで) 開いた場合、
\method{tell()} が返すオフセットのみが正しい値になります。
他のオフセット値を使った場合、その振る舞いは未定義です。

全てのファイルオブジェクトが seek できるとは限らないので注意してください。
\end{methoddesc}

\begin{methoddesc}[file]{tell}{}
\code{stdio} の \cfunction{ftell()} と同様、ファイルの現在位置を
返します。

\note{Windows では、(\cfunction{fgets()} の後で) \UNIX{}-スタイルの改行
のファイルを読むときに\method{tell()} が不正な値を返すことがあります。
この問題に遭遇しないためにはバイナリーモード (\code{'rb'}) を使うよう
にしてください。}
\end{methoddesc}

\begin{methoddesc}[file]{truncate}{\optional{size}}
ファイルのサイズを切り詰めます。オプションの \var{size} が存在
すれば、ファイルは (最大で) 指定されたサイズに切り詰められます。
標準設定のサイズの値は、現在のファイル位置までのファイルサイズです。
現在のファイル位置は変更されません。指定されたサイズがファイルの
現在のサイズを越える場合、その結果はプラットフォーム依存なので
注意してください: 可能性としては、ファイルは変更されないか、
指定されたサイズまでゼロで埋められるか、指定されたサイズまで
未定義の新たな内容で埋められるか、があります。
  利用可能な環境:  Windows, 多くの \UNIX{} 系。
\end{methoddesc}

\begin{methoddesc}[file]{write}{str}
文字列をファイルに書き込みます。戻り値はありません。バッファリング
によって、\method{flush()} または \method{close()} が呼び出されるまで
実際にファイル中に文字列が書き込まれないこともあります。
\end{methoddesc}

\begin{methoddesc}[file]{writelines}{sequence}
文字列からなるシーケンスをファイルに書き込みます。シーケンスは文字列を生成
する反復可能なオブジェクトなら何でもかまいません。よくあるのは
文字列からなるリストです。戻り値はありません。
(関数の名前は \method{readlines()} と対応づけてつけられました;
  \method{writelines()} は行間の区切りを追加しません)
\end{methoddesc}


ファイルはイテレータプロトコルをサポートします。各反復操作では 
\code{\var{file}.readline()} と同じ結果を返し、反復は
\method{readline()} メソッドが空文字列を返した際に終了します。


ファイルオブジェクトはまた、多くの興味深い属性を提供します。
これらはファイル類似オブジェクトでは必要ではありませんが、
特定のオブジェクトにとって意味を持たせたいなら実装しなければ
なりません。

\begin{memberdesc}[file]{closed}
現在のファイルオブジェクトの状態を示すブール値です。この値は
読み出し専用の属性です; \method{close()} メソッドがこの値を
変更します。全てのファイル類似オブジェクトで利用可能とは
限りません。
\end{memberdesc}

\begin{memberdesc}[file]{encoding}
このファイルが使っているエンコーディングです。Unicode 文字列が
ファイルに書き込まれる際、Unicode 文字列はこのエンコーディングを
使ってバイト文字列に変換されます。さらに、ファイルが端末に
接続されている場合、この属性は端末が使っているとおぼしきエンコーディング
(この情報は端末がうまく設定されていない場合には不正確なこともあります)
を与えます。この属性は読み出し専用で、すべてのファイル類似オブジェクト
にあるとは限りません。またこの値は \code{None} のこともあり、
この場合、ファイルはUnicode 文字列の変換のためにシステムのデフォルト
エンコーディングを使います。

\versionadded{2.3}
\end{memberdesc}



\begin{memberdesc}[file]{mode}
ファイルの I/O モードです。ファイルが組み込み関数 \function{open()} 
で作成された場合、この値は引数 \var{mode} の値になります。
この値は読み出し専用の属性で、全てのファイル類似オブジェクトに
存在するとは限りません。
\end{memberdesc}

\begin{memberdesc}[file]{name}
ファイルオブジェクトが \function{open()} を使って生成された時の
ファイルの名前です。そうでなければ、ファイルオブジェクト生成の
起源を示す何らかの文字列になり、\samp{<\mbox{\ldots}>} の形式を
とります。この値は読み出し専用の属性で、全てのファイル類似オブジェクトに
存在するとは限りません。
\end{memberdesc}

\begin{memberdesc}[file]{newlines}
Python をビルドするとき、\longprogramopt{with-universal-newlines} 
オプションが\program{configure} に指定された場合（デフォルト）、
この読み出し専用の属性が存在します。一般的な
改行に変換する読み出しモードで開かれたファイルにおいて、この属性はファイ
ルの読み出し中に遭遇した改行コードを追跡します。取り得る値は \code{'\e 
r'}、\code{'\e n'}、\code{'\e r\e n'}、\code{None} (不明または、まだ改行
していない）、見つかった全ての改行文字を含むタプルのいずれかです。最後の
タプルは、複数の改行慣例に遭遇したことを示します。一般的な改行文字を使う
読み出しモードで開かれていないファイルの場合、この属性の値は \code{None} 
です。
\end{memberdesc}

\begin{memberdesc}[file]{softspace}
\keyword{print} 文を使った場合、他の値を出力する前にスペース文字を
出力する必要があるかどうかを示すブール値です。
ファイルオブジェクトをシミュレート仕様とするクラスは書き込み可能な
\member{softspace} 属性を持たなければならず、この値はゼロに初期化
されなければなりません。この値は Python で実装されているほとんどの
クラスで自動的に初期化されます (属性へのアクセス手段を上書きする
ようなオブジェクトでは注意が必要です); C で実装された型では、
書き込み可能な \member{softspace} 属性を提供しなければなりません。
\note{この属性は \keyword{print} 文を制御するために用いられますが、
\keyword{print} の内部状態を乱さないために、その実装を行うことは
できません。}
\end{memberdesc}


\section{コンテキストマネージャ型 \label{typecontextmanager}}

\versionadded{2.5}
\index{context manager}
\index{context management protocol}
\index{protocol!context management}

Python の \keyword{with} 文はコンテキストマネージャによって定義される
実行時コンテキストの概念をサポートします。これは、ユーザ定義クラスが文の本体
が実行される前に進入し文の終わりで脱出する実行時コンテキストを定義することを許す
二つの別々のメソッドを使って実装されます。

\dfn{コンテキスト管理プロトコル} (\dfn{context management protocol}) は
実行時コンテキストを定義するコンテキストマネージャオブジェクトが提供すべき
一対のメソッドから成ります。

\begin{methoddesc}[context manager]{__enter__}{}
実行時コンテキストに入り、このオブジェクトまたは他の実行時コンテキストに関連した
オブジェクトを返します。このメソッドが返す値はこのコンテキストマネージャを使う
\keyword{with} 文の \keyword{as} 節の識別子に束縛されます。

自分自身を返すコンテキストマネージャの例としてファイルオブジェクトがあります。
ファイルオブジェクトは \method{__enter__()} から自分自身を返して
\function{open()} が \keyword{with} 文のコンテキスト式として使われる
ようにします。

関連オブジェクトを返すコンテキストマネージャの例としては
\code{decimal.localcontext()} が返すものがあります。
このマネージャはアクティブな10進数コンテキストをオリジナルのコンテキストのコピーに
セットしてそのコピーを返します。こうすることで、\keyword{with} 文の本体の
内部で、外側のコードに影響を与えずに、10進数コンテキストを変更できます。
\end{methoddesc}

\begin{methoddesc}[context manager]{__exit__}{exc_type, exc_val, exc_tb}
実行時コンテキストから抜け、例外(がもし起こっていたとしても)を抑制することを示す
ブール値フラグを返します。\keyword{with} 文の本体を実行中に例外が起こったならば、引数には
その例外の型と値とトレースバック情報を渡します。そうでなければ、引数は全て \var{None}
です。

このメソッドから真となる値が返されると \keyword{with} 文は例外の発生を抑え、
\keyword{with} 文の直後の文に実行を続けます。そうでなければ、このメソッドの実行を
終えると例外の伝播が続きます。このメソッドの実行中に起きた例外は \keyword{with}
文の本体の実行中に起こった例外を置き換えてしまいます。

渡された例外を直接的に再送出すべきではありません。その代わりに、このメソッドが偽の
値を返すことでメソッドの正常終了と送出された例外を抑制しないことを伝えるべきです。
このようにすれば(\code{contextlib.nested} のような)コンテキストマネージャは
\method{__exit__()} メソッド自体が失敗したのかどうかを簡単に見分けることができます。
\end{methoddesc}

Python は幾つかのコンテキストマネージャを、易しいスレッド同期・ファイル
などのオブジェクトの即時クローズ・単純化されたアクティブな10進算術コン
テキストのサポートのために用意しています。各型はコンテキスト管理プロトコル
を実装しているという以上の特別の取り扱いを受けるわけではありません。

Python のジェネレータと \code{contextlib.contextfactory} デコレータはこの
プロトコルの簡便な実装方法を提供します。ジェネレータ関数を
\code{contextlib.contextfactory} でデコレートすると、デコレートしなければ
返されるイテレータを返す代わりに、必要な \method{__enter__()} および
\method{__exit__()} メソッドを実装したコンテキストマネージャを返すようになります。

これらのメソッドのために Python/C API の中の Python オブジェクトの型構
造体に特別なスロットが作られたわけではないことに注意してください。これ
らのメソッドを定義したい拡張型については通常の Python からアクセスでき
るメソッドとして提供しなければなりません。実行時コンテキストを準備する
ことに比べたら、一つのクラスの辞書引きは無視できるオーバーヘッドです。

\section{他の組み込み型 \label{typesother}}

インタプリタはその他の種類のオブジェクトをいくつかサポート
します。これらのほとんどは 1 または 2 つの演算だけをサポート
します。
	

\subsection{モジュール \label{typesmodules}}

モジュールに対する唯一の特殊な演算は属性へのアクセス:
\code{\var{m}.\var{name}} です。ここで \var{m} はモジュールで、
\var{name} は \var{m} のシンボルテーブル上に定義された名前に
アクセスします。モジュール属性も代入することができます。
(\keyword{import} 文は、厳密にいえば、モジュールオブジェクトに
対する演算です; \code{import \var{foo}} は \var{foo} と名づけられた
モジュールオブジェクトが存在することを必要とはせず、
むしろ \var{foo} と名づけられた (外部の) モジュールの\emph{定義} 
を必要とします。)

各モジュールの特殊なメンバは \member{__dict__} です。
これはモジュールのシンボルテーブルを含む辞書です。
この辞書を修正すると、実際にはモジュールのシンボルテーブルを変更
しますが、\member{__dict__} 属性を直接代入することはできません
(\code{\var{m}.__dict__['a'] = 1} と書いて \code{\var{m}.a} を \code{1}
に定義することはできますが、\code{\var{m}.__dict__ = \{\}} と
書くことはできません) 。 \member{__dict__} を直接編集するのは推奨されません。

インタプリタ内に組み込まれたモジュールは、
\code{<module 'sys' (built-in)>} のように書かれます。
ファイルから読み出された場合、 \code{<module 'os' from
'/usr/local/lib/python\shortversion/os.pyc'>} と書かれます。


\subsection{クラスおよびクラスインスタンス \label{typesobjects}}
\nodename{Classes and Instances}

これらに関しては、\citetitle[../ref/ref.html]{Python リファレンスマニュアル} 
の 3 章および 7 章を読んで下さい。


\subsection{関数 \label{typesfunctions}}

関数オブジェクトは関数定義によって生成されます。関数オブジェクトに
対する唯一の操作は、それを呼び出すことです:
\code{\var{func}(\var{argument-list})}.

関数オブジェクトには実際には 2 つの種: 組み込み関数とユーザ定義関数
があります。両方とも同じ操作 (関数の呼び出し) をサポートしますが、
実装は異なるので、オブジェクトの型も異なります。

より詳しい情報は \citetitle[../ref/ref.html]{Python リファレンスマニュアル} を
参照してください。

\subsection{メソッド \label{typesmethods}}
\obindex{method}

メソッドは属性表記を使って呼び出される関数です。メソッドには二つの
種類があります: (リストへの\method{append()}のような) 組み込みメソッド
と、クラスインスタンスのメソッドです。組み込みメソッドはそれをサポート
する型と一緒に記述されています。

実装では、クラスインスタンスのメソッドに 2 つの読み込み専用の属性
を追加しています: \code{\var{m}.im_self} はメソッドが操作するオブジェクト
で、\code{\var{m}.im_func} はメソッドを実装している関数です。
\code{\var{m}(\var{arg-1}, \var{arg-2}, \textrm{\ldots}, \var{arg-n})}
の呼び出しは、\code{\var{m}.im_func(\var{m}.im_self, \var{arg-1},
\var{arg-2}, \textrm{\ldots}, \var{arg-n})} の呼び出しと完全に等価です。

クラスインスタンスメソッドには、 メソッドがインスタンスからアクセス
されるかクラスからアクセスされるかによって、それぞれ\emph{バインド} 
または \emph{非バインド}　があります。メソッドが非バインドメソッドの
場合、\code{im_self} 属性は \code{None} になるため、呼び出す際
には \code{self} オブジェクトを明示的に第一引数として指定しなければ
なりません。この場合、\code{self} は非バインドメソッドのクラス
(サブクラス) のインスタンスでなければならず、そうでなければ
\exception{TypeError} が送出されます。

関数オブジェクトと同じく、メソッドオブジェクトは任意の属性を取得
できます。しかし、メソッド属性は実際には背後の関数オブジェクト
(\code{meth.im_func}) に記憶されているので、バインド、ヒバインド
メソッドへのメソッド属性の設定は許されていません。
メソッド属性の設定を試みると \exception{TypeError} が送出されます。
メソッド属性を設定するためには、その背後の関数オブジェクトで
明示的に:

\begin{verbatim}
class C:
    def method(self):
        pass

c = C()
c.method.im_func.whoami = 'my name is c'
\end{verbatim}

のように設定しなければなりません。
詳しくは
\citetitle[../ref/ref.html]{Python リファレンスマニュアル} 
を読んで下さい。


\subsection{コードオブジェクト \label{bltin-code-objects}}
\obindex{code}

コードオブジェクトは、関数本体のような ``擬似コンパイルされた''
Python の実行可能コードを表すために実装系によって使われます。
コードオブジェクトはグローバルな実行環境への参照を持たない点で
関数オブジェクトとは異なります。コードオブジェクトは
組み込み関数 \function{compile()} によって返され、関数オブジェクト
の \member{func_code} 属性として取り出すことができます。
\bifuncindex{compile}
\withsubitem{(function object attribute)}{\ttindex{func_code}}

コードオブジェクトは \keyword{exec} 文や組み込み関数 \function{eval()}
に(ソースコード文字列の代わりに) 渡すことで、実行したり値評価したり
することができます。
\stindex{exec}
\bifuncindex{eval}

詳しくは
\citetitle[../ref/ref.html]{Python リファレンスマニュアル} 
を読んで下さい。


\subsection{型オブジェクト \label{bltin-type-objects}}

型オブジェクトは様々なオブジェクト型を表します。オブジェクトの型は
組み込み関数 \function{type()} でアクセスされます。型オブジェクトには
特有の操作はありません。標準モジュール \refmodule{types} には全ての
組み込み型名が定義されています。
\bifuncindex{type}
\refstmodindex{types}

型は \code{<type 'int'>} のように書き表されます。


\subsection{ヌルオブジェクト \label{bltin-null-object}}

このオブジェクトは明示的に値を返さない関数によって返されます。
このオブジェクトには特有の操作はありません。ヌルオブジェクト
は一つだけで、\code{None} (組み込み名) と名づけられています。

\code{None} と書き表されます。


\subsection{省略表記オブジェクト \label{bltin-ellipsis-object}}

このオブジェクトは拡張スライス表記によって使われます 
(\citetitle[../ref/ref.html]{Python Reference Manual} を参照して
ください)。特殊な操作は何もサポートしていません。省略表記オブジェクト
は一つだけで、その名前は \constant{Ellipsis} (組み込み名) です。

\code{Ellipsis} と書き表されます。

\subsection{ブール値}

ブール値とは二つの定数オブジェクト \code{False} および \code{True} です。
これらは真偽値を表すために使われます (他の値も偽または真とみなされ
ます) 数値処理のコンテキスト (例えば算術演算子の引数として使われた
場合) では、これらはそれぞれ 0 および 1 と同様に振舞います。
任意の値に対して真偽値を変換できる場合、組み込み関数 \function{bool()} は
値をブール値にキャストするのに使われます (真値テストの節を参照
してください)

これらはそれぞれ \code{False} および \code{True} と書き表されます。
\index{False}
\index{True}
\indexii{Boolean}{values}


\subsection{内部オブジェクト \label{typesinternal}}

この情報については
\citetitle[../ref/ref.html]{Python リファレンスマニュアル} を読んで
下さい。このオブジェクトではスタックフレーム、トレースバック、
スライスオブジェクトを記述しています。


\section{特殊な属性 \label{specialattrs}}

実装では、いくつかのオブジェクト型に対して、数個の読み出し専用の特殊な
属性を追加しています。それぞれ:

\begin{memberdesc}[object]{__dict__}
オブジェクトの (書き込み可能な) 属性を保存するために使われる辞書または
他のマップ型オブジェクトです。
\end{memberdesc}

\begin{memberdesc}[object]{__methods__}
\deprecated{2.2}{オブジェクトの属性からなるリストを取得するには、
組み込み関数 \function{dir()} を使ってください。この属性はもう
利用できません。}
\end{memberdesc}

\begin{memberdesc}[object]{__members__}
\deprecated{2.2}{オブジェクトの属性からなるリストを取得するには、
組み込み関数 \function{dir()} を使ってください。この属性はもう
利用できません。}
\end{memberdesc}

\begin{memberdesc}[instance]{__class__}
クラスインスタンスが属しているクラスです。
\end{memberdesc}

\begin{memberdesc}[class]{__bases__}
クラスオブジェクトの基底クラスからなるタプルです。基底クラスを
持たない場合、空のタプルになります。
\end{memberdesc}

