静岡理工科大学 菅沼ホーム 目次 索引

複合データ

  この章では,複数のデータの集まりからなるデータ(複合データ)について説明します.急がれる方は,この章を飛ばし,次章「入出力と文」に進んでください.次章における必要な箇所で,この章の対応する箇所を読む方法も良いかと思います.

  1. C/C++ における複合データ( C/C++ )

    1. 配列(C/C++)

        C/C++ の配列と 1 : 1 に対応するデータ型が存在しないなど,大きな違いはありますが,Python にも,複合データを扱うためのデータ型が存在します.この節では,複合データの必要性と,配列など,C/C++ における複合データの取り扱いについて説明します.Python の複合データを理解するためにも必要だと思いますが,C/C++ との関係に興味のない方はこの節を読み飛ばしてください.

        単純な変数を使用して複数のデータを記憶しておきたい場合,記憶したいデータの数だけ変数を用意する必要があります.データの数が少なく,かつ,その数が前もって分かっているような場合は通常の変数によって対応できますが,データ数が多くなり,かつ,その数が前もって分からないような場合はほとんど不可能です.そこで,登場するのが,配列( array )変数という考え方です.数学的な例えをすれば,通常の変数はスカラー変数であり,配列変数はベクトルに対応します(行列等に対応する配列変数も存在しますが,それについては,後ほど述べます).配列変数を定義し,その各要素(ベクトルの各要素)にデータを記憶しておけば上の問題を解決できることになります.

        ある変数がスカラー(単純変数)でなく,配列変数であることを定義するためには,例えば,以下のように記述します.
      int x[10];   // 要素の数 10 の部分は定数である必要がある
      				
        このように定義することにより,変数 x は 10 個の要素を持った配列変数( 10 次元のベクトル)とみなされ,この場合は,10 個の整数を記憶するために 80( 8×10 )バイトの連続した領域が確保されます.なお,基本的に,要素の数は定数でなければなりません.

        配列の各要素を参照するためには,ベクトルの場合と同様に,x[i] のように記述すればよいことになります.ただし,添え字 i は,ベクトルとは異なり,上のように定義した場合,0 から 9 まで変化します.従って,
      x[5] = 3.0;
      y    = x[3];
      				
      と書くと,配列 x の 6 番目の要素( 5 番目でないことに注意)に値 3.0 が代入され,4 番目の要素に記憶されている値が変数 y に代入されます.また,整数などの数値だけでなく,文字列も複数の文字(データ)の集まりですので,配列によって表現可能です.

        ポインタと配列とは非常に深い関係があります.例えば,
      int x[4] = {100, 200, 300, 400};
      int *y;   // int y[4]; と宣言した場合は,y = x; は実行できない
      				
      のような宣言がなされていたとして,以下の説明を行います.100 ~ 400 は,各要素に記憶される値の初期値です.このとき,配列変数 x に対しては,下図の左に示すようなイメージを浮かべると理解しやすいと思います.つまり,x がポインタ変数であり,この変数の値が,連続した領域にある 4 つの変数 x[0],x[1],x[2],及び,x[3] の先頭アドレスを指しているというイメージです.従って,ポインタ変数 x の値を同じポインタ変数である y に代入,つまり,
      y = x; または y = &(x[0]);
      				
      という文を実行してやれば,下図の右に示すように,変数 x と変数 y はほとんど同じものになります.例えば,y[2] は x[2] と同じ箇所を参照することになります.ただし,厳密には,全く同じではありません.例えば,「y++」などの演算は可能ですが,「x++」は不可能です.

        2 次元以上の配列に対しても,1 次元の場合と同様に,ポインタを介して参照等が可能です.例えば,2 次元配列として下のような宣言がなされていたとします.このとき,配列とポインタの関係は,概念的に,下図の左側のような関係になります.
      int x[3][2] = {{100, 200}, {300, 400}, {500, 600}};
      				

        まず,実際にデータが記憶される場所として,x[0][0] から x[2][1] の連続した 6 個の領域がとられます(この例では,それらが,20 番地からの領域であるとしています).添え字が最も右側から変化していることに注意して下さい(この点は,3 次元以上の配列の場合も同様です).次に,x[0] から x[2] のポインタを要素とする配列があり,その各要素は,配列の各行の値が保存されている場所の先頭を指しています.変数 x は,このポインタ配列の先頭を指していることになります.

        配列に対し連続的な領域が確保されていますので,上図の右に示すように,2 次元の配列を 1 次元の配列として処理することも可能です.例えば,
      int *z = (int *)x;   // z = &x[0][0]; でも良い
      				
      のような処理をすれば,z[3] と x[1][1] が同じ場所を指すことになります.一般に,x[i][j] と z[(i×k) + j] は,同じ場所を指すことになります.ただし,k は,配列変数 x の宣言における列の数です(上の例では 2 ).

        配列においては,データの数を定数で指定しなければなりません.そのため,必要なデータ数が,問題によって異なるような場合は,大きめのサイズの配列を準備しておかなければなりません.しかし,C++ では,new 演算子を使用して,以下に示すように,メモリの動的確保を行うことが可能です(計算時間の犠牲は伴う).new 演算子は,指定された型のデータを指定された数だけ記憶できる領域を確保し,そのアドレスを返します.
      int *x = new int [n];   // 要素の数 n は変数でも構わない
      				
        2 次元以上の配列も同様にして確保できます.例えば,2 行 3 列(行や列の数は変数でも構わない)の配列を確保するためには,以下のように記述します.この結果,概念的には,右図に示すような領域が確保されます(配列のように,データ領域が連続した領域になるとは限らない).なお,上で述べた変数 x や変数 pd は,配列と同様の方法で各要素を参照することができます.
      double** pd = new double* [2];
      for (i1 = 0; i1 < 2; i1++)
      	pd[i1] = new double [3];
      				

    2. 複合データ(C++)

        前節の方法においても,データの数が n より多くなった場合は対応できなくなります.それを解決する方法の一つが C++ 標準ライブラリ内の多くのクラスです.以下の節において,Python の複合データをシーケンス型,集合型,マッピング型(辞書型)に分類していますが,C++ 内のクラスを,このような形で分類し,正確に対応させることはできません.シーケンス型に対しては,添え字 [ ] で参照可能であることから見ると,string クラスarray クラスvector クラスtuple クラス(添え字での参照は不可)などが対応します.また,ハッシュを使用している点から見ると,集合型に対しては,unordered_map クラスunordered_multimap クラスunordered_set クラスunordered_multiset クラスなどが対応します.さらに,キーと値を別々に扱う点では,マッピング型(辞書型)に対しては,map クラスmultimap クラス,unordered_map クラス,unordered_multimap クラスが対応します.forward_list クラス(単方向リス)や list クラス(双方向リスト)は,シーケンシャルアクセスだけが可能である点から,シーケンス型に似ていますが,取り扱い方法はかなり異なっています.なお,map クラス,multimap クラス,set クラスmultiset クラスは,二分木として実装されており,データが追加・削除されるたびに,自動的にソートされます.

        上で述べた C++ のクラスと Python の複合データとの違いは,Python の複合データにおいては,複数の型のデータを同じ変数に保存できる点です.C++ の場合は,tuple クラスを除き,同じ型のデータだけを記憶できます.誤りの原因となりやすいので,一つ複合データ内には同じ型のデータだけを記憶するようにした方が良いと思います.

  2. シーケンス型

      シーケンス型は,有限の順序集合を表現します.要素の値等を変更できない(イミュータブル)シーケンス型として文字列型,タプル型( tuple ),bytes 型が存在します.また,変更可能な(ミュータブル)シーケンス型として,リスト型( list ),range 型,bytearray 型が存在します.なお,前章で述べた複素数も,変更不可能なシーケンス型の一種とみなすことができますが,ここでは説明を省略します.

    1. 要素の参照(添え字とスライス)

        シーケンス型のデータを参照する基本的な方法は,C/C++ における配列と同様,添え字です.ただし,Python においては,負の添え字も使用することができます(このような機能,必要?).ここでは,文字列,
      test = "Suganuma"
      				
      を例として,説明していきます.正の添え字を使用する場合,先頭の文字に対応する添え字は 0,最後の文字に対応する添え字が (n-1) (文字数が n の場合)になります.また,負の添え字を使用する場合は,最後の文字に対応する添え字が -1,先頭の文字に対応する添え字が -n (文字数が n の場合)になります.上に示した文字列に対して,その添え字は,
      +---+---+---+---+---+---+---+---+
      | S | u | g | a | n | u | m | a |
      +---+---+---+---+---+---+---+---+
        0   1   2   3   4   5   6   7
       -8  -7  -6  -5  -4  -3  -2  -1
      				
      となり,
      >>> test = "Suganuma"
      >>> test[0]
      'S'
      >>> test[-2]
      'm'
      				
      のような結果が得られます.

        Python においては,スライス( slice )という表現を使用し,部分文字列を指定することが可能です(このような機能,必要?).スライスは,
      [m1:m2[:m3]]
      				
      のように記述され,添え字 m が m1 <= m < m2 である部分文字列を指定することができます.開始インデックス m1 を省略すると 0,終了インデックスを省略すると文字列の長さと見なされます.なお,m3 を入力すると,m1 から m2 までの m3 個ごとの要素という意味になります.この結果,上に示した例に対しては,以下に示すような結果が得られます.
      >>> test = "Suganuma"
      >>> test[0:4]
      'Suga'
      >>> test[:4]
      'Suga'
      >>> test[4:]
      'numa'
      >>> test[4:-1]
      'num'
      >>> test[0:8:2]
      'Sgnm'
      				
        C/C++ には,負の添え字やスライスに対応する参照方法がありません.特に,スライスに関しては後に述べる for 文などの繰り返し文を使用する必要があり,例えば,以下に示すように記述する必要があります.上で述べた参照方法だけを採り上げても,Python のように,プログラムの記述を簡単にするために多くの規則を導入する方が良いのか,疑問を感じます.少なくとも,Python に対する知識がない人には,理解しにくくなることは確かです.なお,以下に示すプログラムにおいて,cout は出力を行い,strlen や length() は文字列の長さを返す関数です.
      				// 配列を使用
      char test1[] = "Suganuma";
      cout << test1[0] << endl;   // test[0] に対応
      cout << test1[strlen(test1)-2] << endl;   // test[-2] に対応
      for (int i1 = 0; i1 < 8; i1 += 2)   // test[0:8:2] に対応
      	cout << test1[i1];
      cout << endl;
      				// string クラスを使用
      string test2 = "Suganuma";
      cout << test2[0] << endl;   // test[0] に対応
      cout << test2[test2.length()-2] << endl;   // test[-2] に対応
      for (int i1 = 0; i1 < 8; i1 += 2)   // test[0:8:2] に対応
      	cout << test2[i1];
      cout << endl;
      				

    2. シーケンス型に共通の演算

        以下に示す演算は,ほとんどの変更不可能及び変更可能なシーケンス型でサポートされています.同じ型のシーケンス同士に対しては,比較もサポートしています.等しいとされるためには,すべての要素が等しく,両シーケンスの型も長さも等しくなければなりません.C++ においても,C++ 標準ライブラリ内の各クラスのメンバー関数やアルゴリズムに,似た機能を持つ関数が存在します.適宜,string クラスを利用して,C++ に対するプログラム例も併記していきます.なお,すぐ下に示すのは,それ以降に詳細説明を行っている項目の目次になっています.

            • + : 結合
            • * : 繰り返し(このような機能,必要?
            • count : 出現回数
            • in : 包含関係
            • index : 検索
            • len : 長さ(組み込み関数)
            • max : 最大(組み込み関数)
            • min : 最小(組み込み関数)
            • not in : 包含関係でない

      • x in s : s 内のある要素が x と等しければ True,そうでなければ False.一般に,x と s との包含関係であるが,文字列( str ),bytes 型, bytearray 型に対しては,部分シーケンスに対する包含関係の判定にも使用可能(後に示す not in も同様).C/C++ においては,標準関数の strstrstring クラスのメンバー関数 find,アルゴリズムの search などが対応.
        >>> test = "Suganuma"
        >>> "x" in test
        False
        >>> "ma" in test   # 部分文字列に対する包含関係
        True
        					

      • x not in s : s 内のある要素が x と等しければ False,そうでなければ True.

      • s + t : s と t の結合.range 型に対してはサポートしない.C++ の場合,文字列( string クラス)に対しては,同様の演算が許されている.

      • s * n または n * s : s を n 個結合.range 型に対してはサポートしない.なお,C++ の例においては,アルゴリズムの copy を使用しており,文字列が修正される.
        >>> test = "Suganuma"
        >>> 3*test
        'SuganumaSuganumaSuganuma'
        					

        C++ の場合

        string test = "";
        string str  = "Suganuma";
        for (int i1 = 0; i1 < 3; i1++)
        	copy(str.begin(), str.end(), inserter(test, test.end()));
        cout << test << endl;
        					

      • len(s) : s の長さ(組み込み関数).C++ においては,string クラスのメンバー関数 length() や size() などが対応.

      • min(s) : s の最小の要素(組み込み関数).C++ においては,アルゴリズムの minmin_element が対応.

      • max(s) : s の最大の要素(組み込み関数).C++ においては,アルゴリズムの maxmax_element が対応.

      • s.index(x[, i[, j]]) : s 中のスライス [i : j] に,x が最初に出現するインデックス
        >>> test = "Suganuma"
        >>> test.index("a")
        3
        					

        C++ の場合

        string test = "Suganuma";
        if (test.find("x") < 8)
        	cout << test.find("x") << endl;   // 出力無し
        if (test.find("ma") < 8)
        	cout << test.find("ma") << endl;   // 6 を出力
        					

      • s.count(x) : s 中に x が出現する回数
        >>> test = "Suganuma"
        >>> test.count("a")
        2
        					

        C++ の場合

        string test = "Suganuma";
        cout << count(test.begin(), test.end(), 'a') << endl;
        					

    3. 変更不可能なシーケンス

      1. 文字列型
          文字列str オブジェクトであり,一重引用符「 ' 」または二重引用符「 " 」で囲み,結果はどちらも同じ文字列になります.また,一重引用符または二重引用符を 3 つ続ける(「 ''' 」または「 """ 」)ことによって,複数行にわたる文字列も表現できます.文字列リテラルに関しては,「文字列およびバイト列リテラル」も参考にしてください.文字列を修正したい場合は,修正した内容を持つ新しい文字列を生成することによって対応可能です.

          C++ における配列を使用した文字列や C++ 標準ライブラリ内の string クラスと似ていますが,配列や string クラスにおいては,下のプログラム例に示すように,文字列の修正も可能です.ただし,const 指定を行えば,修正不可能になります.配列を使用して文字列を表した場合は C/C++ の標準関数,string クラスを使用して文字列を表した場合はそのメンバー関数やアルゴリズムを使用することによって,以下に示す関数と同等の処理が可能になります.なお,string クラスを使用した場合は,+ 演算子による文字列の結合,比較演算子や等値演算子による文字列の比較なども可能になります.
        			// 配列の利用
        char x[] = "abcd";   // const char x[] = "abcd"; とすれば修正不可能
        x[1]     = 'x';   // 修正もOK
        cout << x << endl;   // axcd を出力
        			// String クラスの利用
        string y = "abcd";   // const string y = "abcd"; とすれば y の修正は不可能
        string z = y + "xyz";   // + 演算子による結合もOK
        z[0]     = 'A';   // 修正もOK
        cout << z << endl;   // Abcdxyz を出力
        					
          文字列に対しては,先に述べたシーケンス型に共通の演算全てに加え,以下に述べるメソッドを使用することができます.なお,すぐ下に示すのは,それ以降に詳細説明を行っている項目の目次になっています.

              • capitalize : 最初の文字だけを大文字に変換
              • center : 中央揃い
              • count : 出現回数
              • endswith : 指定した文字で終わっているか?
              • expandtabs : タブを半角スペースに変換
              • find : 文字列の探索
              • format : 書式化
              • index : 文字列の探索
              • isalnum : 英数字か?
              • isalpha : 英字か?
              • isdecimal : 十進数字か?
              • isdigit : 数字か?
              • isidentifier : 識別子として有効か?
              • islower : 小文字か?
              • isnumeric : 数を表す文字か?
              • isprintable : 印刷可能か?
              • isspace : スペースか?
              • istitle : タイトルケースか?
              • isupper : 大文字か?
              • join : 文字列の結合
              • ljust : 左揃え
              • lower : 小文字に変換
              • lstrip : 先頭文字の削除
              • partition : 文字列を前から見た最初の区切り文字で 3 分割
              • replace : 文字列の置換
              • rfind : 文字列の後方からの探索
              • rindex : 文字列の後方からの探索
              • rjust : 右揃え
              • rpartition : 文字列を後ろから見た最初の区切り文字で 3 分割
              • rsplit : 区切り文字で文字列を分割
              • rstrip : 末尾の文字の削除
              • split : 区切り文字で文字列を分割
              • splitlines : 文字列を改行で分割
              • startswith : 指定した文字で始まっているか?
              • strip : 先頭及び末尾の文字を削除
              • swapcase : 大文字と小文字の変換
              • title : タイトルケースに変換
              • upper : 大文字に変換
              • zfill : 0 で左詰

        • str.capitalize() : 最初の文字を大文字に,残りを小文字にした文字列のコピーを返す.
          >>> "suGanuma".capitalize()
          'Suganuma'
          						

        • str.center(width[, fillchar]) : 文字列の左右を fillchar で埋め,中央寄せした長さ width の文字列を返す.width が与えられた文字列の長さ以下の場合は,与えられた文字列そのものを返す.
          >>> "test".center(8, "*")
          '**test**'
          						

        • str.ljust(width[, fillchar]) : 文字列の右を fillchar で埋め,左揃えさせた長さ width の文字列を返す.width が与えられた文字列の長さ以下の場合は,与えられた文字列そのものを返す.
          >>> "test".ljust(8, "*")
          'test****'
          						

        • str.rjust(width[, fillchar]) : 文字列の左を fillchar で埋め,右揃えさせた長さ width の文字列を返す.width が与えられた文字列の長さ以下の場合は,与えられた文字列そのものを返す.
          >>> "test".rjust(8, "*")
          '****test'
          						

        • str.zfill(width) : 長さが width になるよう ASCII '0' で左詰めした文字列を返す.先頭が符号接頭辞( '+' or '-' )だった場合,'0' は符号の前ではなく後に挿入される.width が与えられた文字列の長さ以下の場合,元の文字列を返す.
          >>> "-123".zfill(7)
          '-000123'
          						

        • str.count(sub[, start[, end]]) : 文字列のスライス [start:end] に文字列 sub が含まれる回数.
          >>> "abcabcabc".count("ab")
          3
          						

        • str.expandtabs(tabsize=8) : 文字列内のすべてのタブを,表示が同じようになるように半角スペースで置き換える.
          >>> "\t12\t1234".expandtabs()
          '        12      1234'
          >>> "\t12\t1234".expandtabs(4)
          '    12  1234'
          						

        • str.find(sub[, start[, end]]) : 文字列のスライス [start:end] に文字列 sub が含まれる場合,その最初の位置を返す.sub が見つからなかった場合は -1 を返す.
          >>> "ttaatttaaa".find("aa")
          2
          						

        • str.index(sub[, start[, end]]) : find() と同様だが,文字列が見つからなかったとき ValueError を返す.

        • str.rfind(sub[, start[, end]]) : 文字列のスライス [start:end] に文字列 sub が含まれる場合,その最後の位置を返す.sub が見つからなかった場合は -1 を返す.
          >>> "ttaatttaaa".rfind("aa")
          8
          						

        • str.rindex(sub[, start[, end]]) : rfind() と同様だが,文字列が見つからなかったとき ValueError を返す.

        • str.format(*args, **kwargs) : 文字列の書式化操作.文字列を,C/C++ の printf に似た方法で書式化する.下の例においては,123 が 5 桁で,また,3.141592654 が小数点以下 2 桁で表現される.
          >>> "a = {0:5d}, b = {1:.2f}".format(123, 3.141592654)
          'a =   123, b = 3.14'
          						

        • str.isalnum() : 文字列中の全ての文字が英数字で,かつ,1 文字以上あるなら True を,そうでなければ False を返す.文字 c は,c.isalpha(),c.isdecimal(),c.isdigit(),または,c.isnumeric() のいずれかが True を返せば英数字である.
          >>> "Abc12".isalnum()
          True
          						

        • str.isalpha() : 文字列中の全ての文字が英字で,かつ,1 文字以上あるなら True を,そうでなければ False を返す.

        • str.isdecimal() : 文字列中の全ての文字が十進数字で,かつ,1 文字以上あるなら True を,そうでなければ False を返す.

        • str.isdigit() : 文字列中の全ての文字が数字で,かつ,1 文字以上あるなら True を,そうでなければ False を返す.

        • str.isnumeric() : 文字列中の全ての文字が数を表す文字で,かつ,1 文字以上あるなら True を,そうでなければ False を返す.

        • str.isidentifier() : 文字列が,識別子やキーワードとして有効な文字列である場合に True を返す.
          >>> "xxx".isidentifier()
          True
          >>> "xx yy".isidentifier()
          False
          >>> "if".isidentifier()
          True
          						

        • str.islower() : 文字列中の全ての文字が小文字で,かつ,1 文字以上あるなら True を,そうでなければ False を返す.

        • str.isupper() : 文字列中の全ての文字が大文字で,かつ,1 文字以上あるなら True を,そうでなければ False を返す.

        • str.isprintable() : 文字列中のすべての文字が印字可能であるか,または,文字列が空であれば True を,そうでなければ False を返す.

        • str.isspace() : 文字列が空白文字のみで構成され,かつ,1 文字以上ある場合には True を,そうでなければ False を返す.

        • str.istitle() : 文字列がタイトルケース文字列であり,かつ,1 文字以上ある場合には True を,そうでなければ False を返す.
          >>> "Abc Efg".istitle()
          True
          >>> "Abc EFG".istitle()
          False
          						

        • str.join(iterable) : iterable 中の文字列を str で結合した文字列を返す.iterableイテラブル)とは,構成要素を一度に一つずつ返すことができるオブジェクトである.下の例では,リストを使用している.
          >>> a = ["abc", "def", "ghi"]
          >>> a
          ['abc', 'def', 'ghi']
          >>> "**".join(a)
          'abc**def**ghi'
          >>> "".join(a)
          'abcdefghi'
          						

        • str.lower() : すべての文字を小文字に変換する.

        • str.upper() : すべての文字を大文字に変換する.

        • str.swapcase() : 大文字を小文字に,小文字を大文字に変換
          >>> "aaaXXX".swapcase()
          'AAAxxx'
          						

        • str.title() : 文字列を,単語ごとにタイトルケースにして返す.
          >>> "this is a pen".title()
          'This Is A Pen'
          						

        • str.partition(sep) : 文字列を sep の最初の出現位置で区切り,3 要素のタプルを返す.タプルの内容は,区切りの前の部分,区切り文字列そのもの,及び,区切りの後ろの部分である.もし区切れなければ,タプルには元の文字列そのものとその後ろに 2 つの空白文字列が入る.
          >>> "abc\tefg\txxx".partition("\t")
          ('abc', '\t', 'efg\txxx')
          						

        • str.rpartition(sep) : 文字列を sep の最後の出現位置で区切り,3 要素のタプルを返す.タプルの内容は,区切りの前の部分,区切り文字列そのもの,及び,区切りの後ろの部分である.もし区切れなければ,タプルには 2 つの空白文字列とその後ろに元の文字列そのものが入る.
          >>> "abc\tefg\txxx".rpartition("\t")
          ('abc\tefg', '\t', 'xxx')
          						

        • str.replace(old, new[, count]) : 文字列に現れる部分文字列 old 全てを new に置換して返す.count が与えられている場合,先頭から count 個の old だけを置換する.
          >>> "abc..abc..abc".replace("abc", "xx", 2)
          'xx..xx..abc'
          						

        • str.split(sep=None, maxsplit=-1) : sep を区切り文字とした文字列中の単語のリストを返す.maxsplit が与えられた場合,文字列の先頭から最大 maxsplit 回分割を行う.sep が指定されていない,または,None のとき,全ての空白文字が区切り文字となる.引数 sep は複数文字で構成されていても構わない.
          >>> "abc,xxx,,yyy,zzz".split(",", 3)
          ['abc', 'xxx', '', 'yyy,zzz']
          						

        • str.rsplit(sep=None, maxsplit=-1) : sep を区切り文字とした文字列中の単語のリストを返す.maxsplit が与えられた場合,文字列の右端から最大 maxsplit 回分割を行う.sep が指定されていない,または,None のとき,全ての空白文字が区切り文字となる.引数 sep は複数文字で構成されていても構わない.
          >>> "abc,xxx,,yyy,zzz".rsplit(",", 3)
          ['abc,xxx', '', 'yyy', 'zzz']
          						

        • str.splitlines([keepends]) : 文字列を改行部分で分解し,各行からなるリストを返す.keepends に True が与えらない限り,返されるリストに改行は含まれない.
          >>> "abc\nefg\n\nxxx".splitlines()
          ['abc', 'efg', '', 'xxx']
          						

        • str.startswith(prefix[, start[, end]]) : 文字列のスライス [start:end] が,指定された prefix で始まるなら True を,そうでなければ False を返す.prefix は見つけたい複数の接頭語のタプルでも構わない.
          >>> a = ("a", "b")
          >>> a
          ('a', 'b')
          >>> "abc".startswith(a)
          True
          >>> "bca".startswith(a)
          True
          >>> "cab".startswith(a)
          False
          						

        • str.endswith(suffix[, start[, end]]) : 文字列のスライス [start:end] が指定された suffix で終わる場合は True を,そうでなければ False を返す.suffix は検索対象の複数の接尾語のタプルでも構わない.
          >>> "abcdef".endswith("f")
          True
          						

        • str.strip([chars]) : 文字列の先頭及び末尾の文字を除去したコピーを返す.引数 chars は除去される文字の集合を指定する文字列であり,省略されるか None の場合,空白文字が除去される.
          >>> "   abc   abc   ".strip()
          'abc   abc'
          >>> "...abc...aba...".strip("a.")
          'bc...ab'
          						

        • str.lstrip([chars]) : 文字列の先頭の文字を除去したコピーを返す.引数 chars は除去される文字の集合を指定する文字列であり,省略されるか None の場合,空白文字が除去される.
          >>> "   abc   abc   ".lstrip()
          'abc   abc   '
          >>> "...abc...aba...".lstrip("a.")
          'bc...aba...'
          						

        • str.rstrip([chars]) : 文字列の末尾の文字を除去したコピーを返す.引数 chars は除去される文字の集合を指定する文字列であり,省略されるか None の場合,空白文字が除去される.
          >>> "   abc   abc   ".rstrip()
          '   abc   abc'
          >>> "...abc...aba...".rstrip("a.")
          '...abc...ab'
          						

      2. タプル型( tuple )

          タプルtuple )の要素は任意の Python オブジェクトです.タプルは,以下に示すような方法で生成することができます.なお,タプルを生成するのはカンマであり,問題がなければ,丸括弧 () を省略してかまいません.以下に示すように,C/C++ における const 指定(修正不可能な定数)した配列に似ていますが,タプルでは,異なる型のオブジェクトを要素として持つことができます.C++ には,異なる要素を記憶可能な tuple クラス が存在しますが,Python におけるタプルとはかなり異なったものです.リスト型集合型辞書型なども同様ですが,「異なる型のオブジェクトを要素として持つことができる」という仕様には疑問を感じます.誤りの原因となりやすく,避けた方が良いと思います.
        const int x[] = {10, 20, 30};
        					

        • 空のタプル  (),または,組み込み関数 tuple() の使用
          >>> ()
          ()
          >>> tuple()
          ()
          						

        • 単要素のタプル  (a,),または,組み込み関数 tuple(単要素の iterable) の使用.iterableイテラブル)とは,構成要素を一度に一つずつ返すことができるオブジェクトである.下に示す 3 番目の例では,リストを使用している.
          >>> ("abc",)
          ('abc',)
          >>> "abc",
          ('abc',)
          >>> tuple(["abc"])
          ('abc',)
          						

        • 一般的なタプル  (a, b, ・・・),または,組み込み関数 tuple(iterable) の使用.tuple() は,iterable の項目と同じ項目で同じ順のタプルを構築する.最後の 3 行のように,タプルの要素をタプルとして,2 次元配列に対応したタプルを生成することも可能である.
          >>> ("abc", 10, "xxx")
          ('abc', 10, 'xxx')
          >>> "abc",10,"xxx",
          ('abc', 10, 'xxx')
          >>> tuple(["abc", 10, complex(1,3)])
          ('abc', 10, (1+3j))
          >>> tuple("abc")
          ('a', 'b', 'c')
          >>> a = ((1, 2, 3), (10, 20, 30))
          >>> a[0][1]
          2
          						

      3. bytes 型

          bytes オブジェクトの要素は,8-bit,1 バイトであり,0 <= x < 256 の範囲の整数で表現されます.以下に示すような方法で生成することができます.以下に示すように,C/C++ においては,半角文字だけを対象とし,const 指定(修正不可能な定数)された char 型の配列C++ 標準ライブラリ内の string クラスに似ています.
        const char x[] = "abcd";
        const string x = "abcd";
        					

        • リテラルの利用  文字列リテラルと同様の方法で生成可能.ただし,文字列の前に b を付加する必要がある.
          >>> b"abc"
          b'abc'
          						

        • 組み込み関数 bytes() を使用し,指定された長さの 0 で埋められた bytes オブジェクトを生成
          >>> bytes(5)
          b'\x00\x00\x00\x00\x00'
          						

        • 組み込み関数 bytes() と整数を要素とする iterable の利用.iterableイテラブル)とは,構成要素を一度に一つずつ返すことができるオブジェクトである.下の例では,rangeリストを使用している.
          >>> bytes(range(5))
          b'\x00\x01\x02\x03\x04'
          >>> bytes([1, 2, 3, 4, 5])
          b'\x01\x02\x03\x04\x05'
          						

          bytes に対しては,先に述べたシーケンス型に共通の演算全てに加え,以下に述べるメソッドを使用することができます.なお,すぐ下に示すのは,それ以降に詳細説明を行っている項目の目次になっています.

              • capitalize : 最初の文字だけを大文字に変換
              • center : 中央揃い
              • count : 出現回数
              • decode : bytes を文字列に変換
              • endswith : 指定した文字で終わっているか?
              • expandtabs : タブを半角スペースに変換
              • find : 文字列の探索
              • fromhex : 16 進表記文字列を bytes に変換
              • hex : bytes を 16 進表記に変換
              • index : 文字列の探索
              • isalnum : 英数字か?
              • isalpha : 英字か?
              • isdigit : 数字か?
              • islower : 小文字か?
              • isspace : スペースか?
              • istitle : タイトルケースか?
              • isupper : 大文字か?
              • join : 文字列の結合
              • ljust : 左揃え
              • lower : 小文字に変換
              • lstrip : 先頭文字の削除
              • partition : 文字列を前から見た最初の区切り文字で 3 分割
              • replace : 文字列の置換
              • rfind : 文字列の後方からの探索
              • rindex : 文字列の後方からの探索
              • rjust : 右揃え
              • rpartition : 文字列を後ろから見た最初の区切り文字で 3 分割
              • rsplit : 区切り文字で文字列を分割
              • rstrip : 末尾の文字の削除
              • split : 区切り文字で文字列を分割
              • splitlines : 文字列を改行で分割
              • startswith : 指定した文字で始まっているか?
              • strip : 先頭及び末尾の文字を削除
              • swapcase : 大文字と小文字の変換
              • title : タイトルケースに変換
              • upper : 大文字に変換
              • zfill : 0 で左詰

        • bytes.capitalize() : 最初の文字を大文字に,残りを小文字にした bytes を返す
          >>> b"suGanuma".capitalize()
          b'Suganuma'
          						

        • bytes.center(width[, fillchar]) : bytes の左右を fillchar で埋め,中央寄せした長さ width の bytes を返す.width が与えられた bytes の長さ以下の場合は,与えられた bytes そのものを返す.
          >>> b"test".center(8, b"*")
          b'**test**'
          						

        • bytes.ljust(width[, fillchar]) : bytes の右を fillchar で埋め,左揃えさせた長さ width の bytes を返す.width が与えられた bytes の長さ以下の場合は,与えられた bytes そのものを返す.
          >>> b"test".ljust(8, b"*")
          b'test****'
          						

        • bytes.rjust(width[, fillchar]) : bytes の左を fillchar で埋め,右揃えさせた長さ width の bytes を返す.width が与えられた bytes の長さ以下の場合は,与えられた bytes そのものを返す.
          >>> b"test".rjust(8, b"*")
          b'****test'
          						

        • bytes.zfill(width) : 長さが width になるよう ASCII '0' で左詰めした bytes を返す.先頭が符号接頭辞( '+' or '-' )だった場合,'0' は符号の前ではなく後に挿入される.width が与えられた bytes の長さ以下の場合元の bytes を返す.
          >>> b"-123".zfill(7)
          b'-000123'
          						

        • bytes.count(sub[, start[, end]]) : bytes のスライス [start:end] にシーケンス sub が含まれる回数.
          >>> b"abcabcabc".count(b"ab")
          3
          						

        • bytes.decode(encoding="utf-8", errors="strict") : bytes を文字列に変換
          >>> b"abc".decode()
          'abc'
          						

        • bytes.expandtabs(tabsize=8) : bytes 内のすべてのタブを,表示が同じようになるように半角スペースで置き換える.
          >>> b"\t12\t1234".expandtabs()
          b'        12      1234'
          >>> b"\t12\t1234".expandtabs(4)
          b'    12  1234'
          						

        • bytes.find(sub[, start[, end]]) : bytes のスライス [start:end] に,シーケンス sub が含まれる場合,最小のインデックスを返す.sub が見つからなかった場合,-1 を返す.
          >>> b"xxabcabc".find(b"ab")
          2
          						

        • bytes.index(sub[, start[, end]]) : find() と同様だが,部分シーケンスが見つからなかった場合 ValueError を返す.

        • bytes.rfind(sub[, start[, end]]) : bytes のスライス [start:end] に,シーケンス sub が含まれる場合,その最後の位置を返す.sub が見つからなかった場合は -1 を返す.
          >>> b"ttaatttaaa".rfind(b"aa")
          8
          						

        • bytes.rindex(sub[, start[, end]]) : rfind() と同様だが,文字列が見つからなかったとき ValueError を返す.

        • classmethod bytes.fromhex(string) : 与えられた文字列オブジェクトを変換して,bytes オブジェクトを返す.文字列は 1 バイトに 16 進数 2 桁を含まなければならず,ASCII 空白文字は無視される.
          >>> bytes.fromhex('f041f0F1f2')
          b'\xf0A\xf0\xf1\xf2'   # 16進数の41は10進数の65('A')
          						

        • bytes.hex() : bytes オブジェクトをその 16 進表記に変換する.
          >>> b'\xf0\x41\xf0\xf1\xf2'.hex()
          'f041f0f1f2'
          						

        • bytes.isalnum() : bytes 中の全ての文字が英数字で,かつ,1 文字以上あるなら True を,そうでなければ False を返す.文字 c は,c.isalpha(),c.isdecimal(),c.isdigit(),または,c.isnumeric() のいずれかが True を返せば英数字である.
          >>> b"Abc12".isalnum()
          True
          						

        • bytes.isalpha() : bytes 中の全ての文字が英字で,かつ,1 文字以上あるなら True を,そうでなければ False を返す.

        • bytes.isdigit() : bytes 中の全ての文字が数字で,かつ,1 文字以上あるなら True を,そうでなければ False を返す.

        • bytes.islower() : bytes 中の全ての文字が小文字で,かつ,1 文字以上あるなら True を,そうでなければ False を返す.

        • bytes.isspace() : bytes が空白文字のみで構成され,かつ,1 文字以上ある場合には True を,そうでなければ False を返す.

        • bytes.istitle() : bytes がタイトルケース文字列であり,かつ,1 文字以上ある場合には True を,そうでなければ False を返す.
          >>> b"Abc Efg".istitle()
          True
          >>> b"Abc EFG".istitle()
          False
          						

        • bytes.isupper() : bytes 中の全ての文字が大文字で,かつ,1 文字以上あるなら True を,そうでなければ False を返す.

        • bytes.join(iterable) : iterable 中の bytes を bytes で結合した bytes を返す.iterableイテラブル)とは,構成要素を一度に一つずつ返すことができるオブジェクトである.下の例では,リストを使用している.
          >>> a = [b"abc", b"def", b"ghi"]
          >>> a
          [b'abc', b'def', b'ghi']
          >>> b"**".join(a)
          b'abc**def**ghi'
          >>> b"".join(a)
          b'abcdefghi'
          						

        • bytes.lower() : すべての文字を小文字に変換する.

        • bytes.upper() : すべての文字を大文字に変換する.

        • bytes.swapcase() : 大文字を小文字に,小文字を大文字に変換
          >>> b"aaaXXX".swapcase()
          b'AAAxxx'
          						

        • bytes.title() : bytes を,単語ごとにタイトルケースにして返す.
          >>> b"this is a pen".title()
          b'This Is A Pen'
          						

        • bytes.partition(sep) : bytes を sep の最初の出現位置で区切り,3 要素のタプルを返す.タプルの内容は,区切りの前の部分,区切り bytes そのもの,及び,区切りの後ろの部分である.もし区切れなければ,タプルには元の bytes そのものとその後ろに 2 つの空白 bytes が入る.
          >>> b"abc\tefg\txxx".partition(b"\t")
          (b'abc', b'\t', b'efg\txxx')
          						

        • bytes.rpartition(sep) : bytes を sep の最後の出現位置で区切り,3 要素のタプルを返す.タプルの内容は,区切りの前の部分,区切り bytes そのもの,及び,区切りの後ろの部分である.もし区切れなければ,タプルには 2 つの空白 bytes とその後ろに元の bytes そのものが入る.
          >>> b"abc\tefg\txxx".rpartition(b"\t")
          (b'abc\tefg', b'\t', b'xxx')
          						

        • bytes.replace(old, new[, count]) : bytes に現れる部分シーケンス old 全てを new に置換して返す.count が与えられている場合,先頭から count 個の old だけを置換する.
          >>> b"abc..abc..abc".replace(b"abc", b"xx", 2)
          b'xx..xx..abc'
          						

        • bytes.split(sep=None, maxsplit=-1) : sep を区切り文字とした bytes 中の単語のリストを返す.maxsplit が与えられた場合,bytes の先頭から最大 maxsplit 回分割を行う.sep が指定されていない,または,None のとき,全ての空白文字が区切り文字となる.引数 sep は複数文字で構成されていても構わない.
          >>> b"abc,xxx,,yyy,zzz".split(b",", 3)
          [b'abc', b'xxx', b'', b'yyy,zzz']
          						

        • bytes.rsplit(sep=None, maxsplit=-1) : sep を区切り文字とした bytes 中の単語のリストを返す.maxsplit が与えられた場合,bytes の右端から最大 maxsplit 回分割を行う.sep が指定されていない,または,None のとき,全ての空白文字が区切り文字となる.引数 sep は複数文字で構成されていても構わない.
          >>> b"abc,xxx,,yyy,zzz".rsplit(b",", 3)
          [b'abc,xxx', b'', b'yyy', b'zzz']
          						

        • bytes.splitlines([keepends]) : bytes を改行部分で分解し,各行からなるリストを返す.keepends に True が与えらない限り,返されるリストに改行は含まれない.
          >>> b"abc\nefg\n\nxxx".splitlines()
          [b'abc', b'efg', b'', b'xxx']
          						

        • bytes.startswith(prefix[, start[, end]]) : bytes のスライス [start:end] が,指定された prefix で始まるなら True を,そうでなければ False を返す.prefix は見つけたい複数の接頭語のタプルでも構わない.
          >>> a = (b"a", b"b")
          >>> a
          (b'a', b'b')
          >>> b"abc".startswith(a)
          True
          >>> b"bca".startswith(a)
          True
          >>> b"cab".startswith(a)
          False
          						

        • bytes.endswith(suffix[, start[, end]]) : bytes のスライス [start:end] が指定された suffix で終わる場合は True を,そうでなければ False を返す.suffix は検索対象の複数の接尾語のタプルでも構わない.
          >>> b"abcdef".endswith(b"f")
          True
          						

        • bytes.strip([chars]) : bytes の先頭及び末尾の文字を除去したコピーを返す.引数 chars は除去される文字の集合を指定する bytes であり,省略されるか None の場合,空白文字が除去される.
          >>> b"   abc   abc   ".strip()
          b'abc   abc'
          >>> b"...abc...aba...".strip(b"a.")
          b'bc...ab'
          						

        • bytes.lstrip([chars]) : bytes の先頭の文字を除去したコピーを返す.引数 chars は除去される文字の集合を指定する bytes であり,省略されるか None の場合,空白文字が除去される.
          >>> b"   abc   abc   ".lstrip()
          b'abc   abc   '
          >>> b"...abc...aba...".lstrip(b"a.")
          b'bc...aba...'
          						

        • bytes.rstrip([chars]) : bytes の末尾の文字を除去したコピーを返す.引数 chars は除去される文字の集合を指定する bytes であり,省略されるか None の場合,空白文字が除去される.
          >>> b"   abc   abc   ".rstrip()
          b'   abc   abc'
          >>> b"...abc...aba...".rstrip(b"a.")
          b'...abc...ab'
          						

    4. 変更可能なシーケンス

      1. 変更可能シーケンスに固有の演算

          以下に示す演算は,ほとんどの変更可能なシーケンスで使用可能です.ここで,s は変更可能なシーケンス型のオブジェクト,t は任意のイテラブルオブジェクト,x は s に課せられた型と値の条件を満たす任意のオブジェクトです.ここで,iterableイテラブル)とは,リストタプルrange など,構成要素を一度に一つずつ返すことができるオブジェクトです.なお,すぐ下に示すのは,それ以降に詳細説明を行っている項目の目次になっています.

              • s *= n : n 回反復(このような機能,必要?
              • s[i] = x : 代入
              • s[i:j] = t : 代入(このような機能,必要?
              • s[i:j:k] = t : 代入(このような機能,必要?
              • del s[i:j] : 削除(このような機能,必要?
              • del s[i:j:k] : 削除(このような機能,必要?
              • append : 追加
              • clear : 全削除
              • copy : 浅いコピー
              • extend : 追加
              • insert : 挿入
              • pop : 取り出して削除
              • remove : 削除
              • reverse : 順序の逆転

          ここにおいても,記述の簡単さだけを目指して,あまり特殊な機能は使用しない方が良いと思います.特に,Python に対する知識のない人にとっては,理解しがたいプログラムになってしまいます.参考のため,いくつかの例に対しては,C++ 標準ライブラリ内の vector クラスを使用した C++ のプログラム例を載せておきます(出力結果は同じであるため除く).その際,出力文「 cout << 」に対しては,以下に示すように,<< 演算子のオーバーロードがされているものとします.
        ostream& operator << (ostream& stream, vector<int> &s)
        {
        	if (s.empty())
        		stream << "[]\n";
        	else {
        		stream << "[";
        		for (unsigned int i1 = 0; i1 < s.size(); i1++) {
        			stream << s[i1];
        			if (i1 < s.size()-1)
        				stream << ", ";
        		}
        		stream << "]\n";
        	}
        	return stream;
        }
        					

        • s[i] = x : s の要素 i に x を代入.

        • s[i:j] = t : s の i から j 番目までのスライスにイテラブル t の内容を代入.
          >>> s = [1, 2, 3]
          >>> t = (10, 20)
          >>> s[0 : 2] = t
          >>> s
          [10, 20, 3]
          						

          C++ の場合

          vector<int> s, t;
          for(int i1 = 1; i1 <= 3; i1++)
          	s.push_back(i1);
          for(int i1 = 1; i1 <= 2; i1++)
          	t.push_back(i1*10);
          copy(t.begin(), t.end(), s.begin());
          cout << s;
          						

        • s *= n : s をその内容を n 回繰り返したもので更新.
          >>> s = [1, 2]
          >>> s *= 3
          >>> s
          [1, 2, 1, 2, 1, 2]
          						

          C++ の場合

          vector<int> s, s1;
          for(int i1 = 1; i1 <= 2; i1++)
          	s.push_back(i1);
          vector<int>::iterator it1 = s.begin();
          vector<int>::iterator it2 = s.end();
          for(int i1 = 0; i1 < 3; i1++)
          	copy(it1, it2, inserter(s1, s1.end()));
          cout << s1;
          						

        • s[i:j:k] = t : s の i から j 番目までのスライスの k 番目ごとの要素に,t の要素を順に代入.
          >>> s = [1, 2, 3, 4, 5]
          >>> t = [10, 20, 30]
          >>> s[0 : 5 : 2] = t
          >>> s
          [10, 2, 20, 4, 30]
          						

          C++ の場合

          vector<int> s;
          for(int i1 = 1; i1 <= 5; i1++)
          	s.push_back(i1);
          int t[] = {10, 20, 30};
          int k = 0;
          for(int i1 = 0; i1 < 5; i1 += 2) {
          	s[i1] = t[k];
          	k++;
          }
          cout << s;
          						

        • del s[i:j] : s の i から j 番目までのスライスを削除.s[i:j] = [] と同じ.
          >>> s = [1, 2, 3, 4]
          >>> s[1 : 3] = []
          >>> s
          [1, 4]
          						

          C++ の場合

          vector<int> s;
          for(int i1 = 1; i1 <= 4; i1++)
          	s.push_back(i1);
          vector<int>::iterator it = s.begin();
          int i = 1, j = 3;
          for(int i1 = 0; i1 < 4; i1++) {
          	if (i1 == i) {
          		for(int i2 = i; i2 < j; i2++)
          			it = s.erase(it);
          		break;
          	}
          	else
          		it++;
          }
          cout << s;
          						

        • del s[i:j:k] : s の i から j 番目までのスライスの k 番目ごとの要素を削除.
          >>> s = [1, 2, 3, 4, 5]
          >>> del s[0 : 5 : 2]
          >>> s
          [2, 4]
          						

          C++ の場合

          vector<int> s;
          for(int i1 = 1; i1 <= 5; i1++)
          	s.push_back(i1);
          vector<int>::iterator it = s.begin();
          int i = 0, j = 5, k = 2;
          for(int i1 = 0; i1 < 5; i1++) {
          	if (i1 == i) {
          		for(int i2 = i; i2 < j; i2 += k) {
          			it = s.erase(it);
          			for(int i3 = 0; i3 < k-1; i3++)
          				it++;
          		}
          		break;
          	}
          	else
          		it++;
          }
          cout << s;
          						

        • s.pop([i]) : s の添え字 i で示された位置にある要素を取り出し,そして,削除する.i を省略すると -1 (最後の要素)とみなされる.
          >>> s = [1, 2, 3]
          >>> x = s.pop(1)
          >>> x
          2
          >>> s
          [1, 3]
          						

          C++ の場合

          vector<int> s;   // 最後の要素を削除する場合は pop_back() だけで良い
          for(int i1 = 1; i1 <= 3; i1++)
          	s.push_back(i1);
          vector<int>::iterator it = s.begin();
          int i = 1;
          for(int i1 = 0; i1 < 3; i1++) {
          	if (i1 == i) {
          		cout << s[i] << endl;
          		s.erase(it);
          	}
          	else
          		it++;
          }
          cout << s;
          						

        • s.remove(x) : s から s[i] == x となる最初の要素を削除
          >>> s = [1, 2, 3, 2]
          >>> s.remove(2)
          >>> s
          [1, 3, 2]
          						

          C++ の場合

          vector<int> s;
          for(int i1 = 1; i1 <= 3; i1++)
          	s.push_back(i1);
          s.push_back(2);
          vector<int>::iterator it = s.begin();
          int x = 2;
          for(int i1 = 0; i1 < 4; i1++) {
          	if (s[i1] == x) {
          		s.erase(it);
          		break;
          	}
          	else
          		it++;
          }
          cout << s;
          						

        • s.clear() : s の全ての要素を削除.del s[:] や s[:] = [] と同じ.
          >>> s = [1, 2, 3]
          >>> s.clear()
          >>> s
          []
          						

          C++ の場合

          vector<int> s;
          for(int i1 = 1; i1 <= 3; i1++)
          	s.push_back(i1);
          s.clear();
          cout << s;
          						

        • s.append(x) : x をシーケンスの最後に追加.s[len(s):len(s)] = [x] と同じ.
          >>> s = [1, 2, 3]
          >>> s.append(4)
          >>> s
          [1, 2, 3, 4]
          >>> s[len(s) : len(s)] = [5]
          >>> s
          [1, 2, 3, 4, 5]
          						

          C++ の場合

          vector<int> s;
          for(int i1 = 1; i1 <= 3; i1++)
          	s.push_back(i1);
          s.push_back(4);
          cout << s;
          						

        • s.extend(t) または s += t : s を t の内容で拡張.ほとんど,s[len(s):len(s)] = t と同じ.
          >>> s = [1, 2, 3]
          >>> t = [4, 5]
          >>> s.extend(t)
          >>> s
          [1, 2, 3, 4, 5]
          						

          C++ の場合

          vector<int> s, t;
          for(int i1 = 1; i1 <= 3; i1++)
          	s.push_back(i1);
          for(int i1 = 4; i1 <= 5; i1++)
          	t.push_back(i1);
          copy(t.begin(), t.end(), inserter(s, s.end()));
          cout << s;
          						

        • s.copy() : s の浅いコピーを作成 (s[:] と同じ).Python における代入文はオブジェクトをコピーしない.代入は,オブジェクトに対する参照を生成(アドレスをコピー)するに過ぎない.これは,先に述べたように,単純変数の場合においても同様である.従って,下の例に示す 2 行目のような代入を行っても,s1 と s2 は同じオブジェクトを参照しているため,3 行目のような変更を行えば,s1 及び s2 のいずれも変化してしまう.
          >>> s1 = [1, 2, 3]
          >>> s2 = s1
          >>> s2[0] = 10
          >>> s1
          [10, 2, 3]
          >>> s2
          [10, 2, 3]
          						
            浅いコピーにおいては,新たなオブジェクトを作成し,その後,元のオブジェクト中に見つかった他のオブジェクトに対する参照を代入する.従って,上に示したような現象は発生しない.
          >>> s1 = [1, 2, 3]
          >>> s2 = s1.copy()   # s2 = s1[:] と同じ
          >>> s2[0] = 100
          >>> s1
          [1, 2, 3]
          >>> s2
          [100, 2, 3]
          						
            しかし,元のオブジェクト中に見つかった他のオブジェクトに対する参照を代入しているので,以下の例( 2 次元配列に相当)に示すように,オブジェクト内に他のオブジェクトに対する参照が存在する場合は,単なる代入文と同じ結果になってしまう.この点は,上に述べた 1 次元配列に相当するような場合においても,各要素がクラスのオブジェクトなどの場合は,似たような結果になってしまう.
          >>> s1 = [[1, 2, 3], [4, 5, 6]]
          >>> s2 = s1.copy()
          >>> s2
          [[1, 2, 3], [4, 5, 6]]
          >>> s2[0][0] = 10
          >>> s2
          [[10, 2, 3], [4, 5, 6]]
          >>> s1
          [[10, 2, 3], [4, 5, 6]]
          						
            このような現象を避けるためには,オブジェクト内に存在する他のオブジェクトに対してもそのコピーを実行する深いコピーが必要になる.以下に示す例においては,深いコピー deepcopy (浅いコピーは copy )を利用してこの問題を解決している.浅いコピー,深いコピーの詳細については,copy モジュールを参照されたい.
          >>> import copy
          >>> s1 = [[1, 2, 3], [4, 5, 6]]
          >>> s2 = copy.deepcopy(s1)
          >>> s2[0][0] = 10
          >>> s1
          [[1, 2, 3], [4, 5, 6]]
          >>> s2
          [[10, 2, 3], [4, 5, 6]]
          						

          C++ の場合

          			// 通常の代入
          01	vector<int> s1, s2;
          02	for(int i1 = 1; i1 <= 3; i1++)
          03		s1.push_back(i1);
          04	s2 = s1;
          05	s2[0] = 10;
          06	cout << s1;
          07	cout << s2;
          			// ポインタの代入
          08	vector<int> *ps1, *ps2;
          09	ps1 = &s1;
          10	ps2 = ps1;
          11	(*ps2)[0] = 10;
          12	cout << *ps1;   // cout << s1; でも同じ
          13	cout << *ps2;
          			// 通常の代入( 2 次元配列)
          14	vector<int> s3[2], s4[2];
          15	for(int i1 = 1; i1 <= 3; i1++)
          16		s3[0].push_back(i1);
          17	for(int i1 = 4; i1 <= 6; i1++)
          18		s3[1].push_back(i1);
          19					// s4 = s3; はできない
          20	for(int i1 = 0; i1 < 2; i1++) {
          21		for(int i2 = 0; i2 < 3; i2++)
          22			s4[i1] = s3[i1];
          23	}
          24	s4[0][0] = 10;
          25	cout << s3[0];
          26	cout << s4[0];
          			// new 演算子の使用( 2 次元配列)
          27	vector<int> *s5 = new vector<int> [2], *s6;
          28	for(int i1 = 1; i1 <= 3; i1++)
          29		s5[0].push_back(i1);
          30	for(int i1 = 4; i1 <= 6; i1++)
          31		s5[1].push_back(i1);
          32	s6 = s5;
          33	s6[0][0] = 10;
          34	cout << s5[0];
          35	cout << s6[0];
          						
          01 行目~ 07 行目

            04 行目において,表面的には,Python の場合と同様の代入を行っている.しかし,C++ の場合は,オブジェクト自身がコピーされるため,s2 の値を変更しても,s1 の値は変化しない.06,07 行目の出力結果は以下に示すとおりである.

            [1, 2, 3]
            [10, 2, 3]

          08 行目~ 13 行目

            ps1 に s1 のアドレスを代入し( 09 行目),それを ps2 に代入している.ps1 と ps2 は同じ場所を指しているため,Python の場合と同様,ps2 を介して値を変更すると( 11 行目),s1 の値も変化する.これが,ほぼ,Python における単純な代入に相当する.12,13 行目の出力結果は以下に示すとおりである.

            [10, 2, 3]
            [10, 2, 3]

          14 行目~ 26 行目

            オブジェクト内に他のオブジェクトが存在する場合であり,C++ における 2 次元配列に対応する.配列に対して,s4 = s3 のような代入ができないため,20 行目~ 23 行目のような処理を行っている.この場合も,s4 の値を変更しても,s3 の値は変化しない.25,26 行目の出力結果は以下に示すとおりである.

            [1, 2, 3]
            [10, 2, 3]

          27 行目~ 35 行目

            2 次元配列を new 演算子を使用して生成した場合である.この場合は,s6 及び s5 がポインタであるため,s6 = s5 のような代入が可能となる.その結果,s6 と s5 は同じデータを指すことになり,s6 を介して値を変更すると,s5 が指す値も変化する.34,35 行目の出力結果は以下に示すとおりである.

            [10, 2, 3]
            [10, 2, 3]

        • s.insert(i, x) : s の添え字 i で示された位置の前に x を挿入.s[i:i] = [x] と同じ.
          >>> s = [1, 2, 3]
          >>> s.insert(1, 10)
          >>> s
          [1, 10, 2, 3]
          						

          C++ の場合

          vector<int> s;
          for(int i1 = 1; i1 <= 3; i1++)
          	s.push_back(i1);
          vector<int>::iterator it = s.begin();
          int i = 1;
          for(int i1 = 0; i1 < 3; i1++) {
          	if (i1 == i) {
          		s.insert(it, 10);
          		break;
          	}
          	else
          		it++;
          }
          cout << s;
          						

        • s.reverse() : s 内の要素の順序を逆転
          >>> s = [1, 2, 3]
          >>> s.reverse()
          >>> s
          [3, 2, 1]
          						

          C++ の場合

          vector<int> s;
          for(int i1 = 1; i1 <= 3; i1++)
          	s.push_back(i1);
          reverse(s.begin(), s.end());
          cout << s;
          						

      2. リスト型( list )

          リストlist )は変更可能なシーケンスであり,一般的に同種の項目の集まりを格納するために使われます.C++ における C++ 標準ライブラリ内の vector クラスと似ていますが,vector とは異なり,異なる型のオブジェクトを要素として持つことができます.タプル型集合型辞書型なども同様ですが,「異なる型のオブジェクトを要素として持つことができる」という仕様には疑問を感じます.誤りの原因となりやすく,避けた方が良いと思います.リストの生成には,以下に示すように,いくつかの方法があります.

        • [],または,組み込み関数 list() の使用  空のリスト
          >>> []
          []
          >>> list()
          []
          						

        • 角括弧とカンマの使用
          >>> [1, 2, 3]
          [1, 2, 3]
          >>> a = [1, 2, 3]
          >>> a[0]
          1
          >>> b = [[1, 2, 3], [4, 5, 6]]
          >>> b[1][0]
          4
          						

        • list(iterable) の使用
          >>> list("abcd")
          ['a', 'b', 'c', 'd']
          >>> list(("a", "b", "c", "d"))
          ['a', 'b', 'c', 'd']
          						

        • リスト内包表記( [x for x in iterable] など)の使用( iterableイテラブル)とは,構成要素を一度に一つずつ返すことができるオブジェクト)
          >>> [x for x in "abcd"]
          ['a', 'b', 'c', 'd']
          						

          リストに対しては,先に述べた共通のシーケンス演算全てに加え,以下に述べるメソッドを使用することができます.

        • sort(*, key=None, reverse=None) : 項目間の < 比較のみを用いてリストをソート.2 つの引数をキーワード引数としてのみ渡せる.key は 1 引数をとる関数を指定し,リストのそれぞれの要素から比較キーを取り出すのに使用(例えば,key=str.lower).また,reverse は,ブール値であり,True に設定された場合,リストの要素は各比較が反転したように並び替えられる.
          >>> s = [1, 4, 3, 2, 5]
          >>> s.sort()
          >>> s
          [1, 2, 3, 4, 5]
          >>> s.sort(reverse=True)
          >>> s
          [5, 4, 3, 2, 1]
          						

          C++ の場合

          vector<int> s;
          s.push_back(1);
          s.push_back(4);
          s.push_back(3);
          s.push_back(2);
          s.push_back(5);
          sort(s.begin(), s.end(), less<int>());
          cout << s;
          sort(s.begin(), s.end(), greater<int>());
          cout << s;
          						

      3. range 型

          range 型は,数の変更可能なシーケンスを表し,一般に for ループにおいて,特定の回数のループを実行するために使われます.range 型のオブジェクトは,組み込み関数,

        class range(stop)
        class range(start, stop[, step])

        によって生成可能です.ただし,start,stop,step 共に,整数である必要があります.step 引数が省略された場合のデフォルト値は 1,start 引数が省略された場合のデフォルト値は 0 です.各引数の値は,各々,インスタンス変数 start,stop,step によって知ることができます(変更不可能).なお,C/C++ には,直接対応する機能は存在しません.しかし,繰り返し文によって容易に実現可能です.
        >>> list(range(1, 10, 2))
        [1, 3, 5, 7, 9]
        >>> list(range(10, -3, -1))
        [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, -1, -2]
        >>> r = range(1, 10, 2)
        >>> r.step
        2
        >>> r[2]
        5
        					

        C++ の場合

        vector<int> s1, s2;
        for (int i1 = 1; i1 < 10; i1 += 2)
        	s1.push_back(i1);
        cout << s1;
        for (int i1 = 10; i1 > -3; i1--)
        	s2.push_back(i1);
        cout << s2;
        					

      4. bytearray 型

          bytearray オブジェクトの要素は,8-bit,1 バイトであり,0 <= x < 256 の範囲の整数で表現されます.C++ の C++ 標準ライブラリ内の string クラスに似ています(半角文字だけを対象とした場合).bytearray に専用のリテラル構文はありませんので,組み込み関数を使って作成します.

        • 組み込み関数 bytearray() を使用し,空のオブジェクトを作成
          >>> bytearray()
          bytearray(b'')
          						

        • 組み込み関数 bytearray() を使用し,指定された長さの 0 で埋められた bytearray オブジェクトの生成
          >>> bytearray(5)
          bytearray(b'\x00\x00\x00\x00\x00')
          						

        • 組み込み関数 bytearray() と整数を要素とする iterable の利用.iterableイテラブル)とは,構成要素を一度に一つずつ返すことができるオブジェクトである.下の例では,range を使用している.
          >>> bytearray(range(5))
          bytearray(b'\x00\x01\x02\x03\x04')
          >>> bytearray([1, 2, 3, 4, 5])
          bytearray(b'\x01\x02\x03\x04\x05')
          						

        • 組み込み関数 bytearray() を使用し,既存のバイナリデータから生成
          >>> bytearray(b"abc")
          bytearray(b'abc')
          						

          bytearray に対しては,先に述べた共通のシーケンス演算全てに加え,以下に述べるメソッドを使用することができます.なお,すぐ下に示すのは,それ以降に詳細説明を行っている項目の目次になっています.

              • capitalize : 最初の文字だけを大文字に変換
              • center : 中央揃い
              • count : 出現回数
              • decode : bytearray を文字列に変換
              • endswith : 指定した文字で終わっているか?
              • expandtabs : タブを半角スペースに変換
              • find : 文字列の探索
              • fromhex : 16 進表記文字列を bytearray に変換
              • hex : bytearray を 16 進表記に変換
              • index : 文字列の探索
              • isalnum : 英数字か?
              • isalpha : 英字か?
              • isdigit : 数字か?
              • islower : 小文字か?
              • isspace : スペースか?
              • istitle : タイトルケースか?
              • isupper : 大文字か?
              • join : 文字列の結合
              • ljust : 左揃え
              • lower : 小文字に変換
              • lstrip : 先頭文字の削除
              • partition : 文字列を前から見た最初の区切り文字で 3 分割
              • replace : 文字列の置換
              • rfind : 文字列の後方からの探索
              • rindex : 文字列の後方からの探索
              • rjust : 右揃え
              • rpartition : 文字列を後ろから見た最初の区切り文字で 3 分割
              • rsplit : 区切り文字で文字列を分割
              • rstrip : 末尾の文字の削除
              • split : 区切り文字で文字列を分割
              • splitlines : 文字列を改行で分割
              • startswith : 指定した文字で始まっているか?
              • strip : 先頭及び末尾の文字を削除
              • swapcase : 大文字と小文字の変換
              • title : タイトルケースに変換
              • upper : 大文字に変換
              • zfill : 0 で左詰

        • bytearray.capitalize() : 最初の文字を大文字に,残りを小文字にした bytearray を返す.
          >>> bytearray(b"suGanuma").capitalize()
          bytearray(b'Suganuma')
          						

        • bytearray.center(width[, fillchar]) : bytearray の左右を fillchar で埋め,中央寄せした長さ width の bytearray を返す.width が与えられた bytearray の長さ以下の場合は,与えられた bytearray そのものを返す.
          >>> bytearray(b"test").center(8, b"*")
          bytearray(b'**test**')
          						

        • bytearray.ljust(width[, fillchar]) : bytearray の右を fillchar で埋め,左揃えさせた長さ width の bytearray を返す.width が与えられた bytearray の長さ以下の場合は,与えられた bytearray そのものを返す.
          >>> bytearray(b"test").ljust(8, b"*")
          bytearray(b'test****')
          						

        • bytearray.rjust(width[, fillchar]) : bytearray の左を fillchar で埋め,右揃えさせた長さ width の bytearray を返す.width が与えられた bytearray の長さ以下の場合は,与えられた bytearray そのものを返す.
          >>> bytearray(b"test").rjust(8, b"*")
          bytearray(b'****test')
          						

        • bytearray.zfill(width) : 長さが width になるよう ASCII '0' で左詰めした bytearray を返す.先頭が符号接頭辞( '+' or '-' )だった場合,'0' は符号の前ではなく後に挿入される.width が与えられた bytearray の長さ以下の場合元の bytearray を返す.
          >>> bytearray(b"-123").zfill(7)
          bytearray(b'-000123')
          						

        • bytearray.count(sub[, start[, end]]) : bytearray のスライス [start:end] にシーケンス sub が含まれる回数.
          >>> bytearray(b"abcabcabc").count(b"ab")
          3
          						

        • bytearray.decode(encoding="utf-8", errors="strict") : bytearray を文字列に変換
          >>> bytearray(b"abc").decode()
          'abc'
          						

        • bytearray.expandtabs(tabsize=8) : bytearray 内のすべてのタブを,表示が同じようになるように半角スペースで置き換える.
          >>> bytearray(b"\t12\t1234").expandtabs()
          bytearray(b'        12      1234')
          >>> bytearray(b"\t12\t1234").expandtabs(4)
          bytearray(b'    12  1234')
          						

        • bytearray.find(sub[, start[, end]]) : bytearray のスライス [start:end] に,シーケンス sub が含まれる場合,最小のインデックスを返す.sub が見つからなかった場合,-1 を返す.
          >>> bytearray(b"xxabcabc").find(b"ab")
          2
          						

        • bytearray.index(sub[, start[, end]]) : find() と同様だが,部分シーケンスが見つからなかった場合 ValueError を返す.

        • bytearray.rfind(sub[, start[, end]]) : bytearray のスライス [start:end] に,シーケンス sub が含まれる場合,その最後の位置を返す.sub が見つからなかった場合は -1 を返す.
          >>> bytearray(b"ttaatttaaa").rfind(b"aa")
          8
          						

        • bytearray.rindex(sub[, start[, end]]) : rfind() と同様だが,文字列が見つからなかったとき ValueError を返す.

        • classmethod bytearray.fromhex(string) : 与えられた 16 進表記文字列オブジェクトを変換して,bytearray オブジェクトを返す.文字列は 1 バイトに 16 進数 2 桁を含まなければならず,ASCII 空白文字は無視される.
          >>> bytearray.fromhex('f041f0F1f2')
          bytearray(b'\xf0A\xf0\xf1\xf2')   # 16進数の41は10進数の65('A')
          						

        • bytearray.hex() : bytearray オブジェクトをその 16 進表記に変換する.
          >>> bytearray(b'\xf0\x41\xf0\xf1\xf2').hex()
          'f041f0f1f2'
          						

        • bytearray.isalnum() : bytearray 中の全ての文字が英数字で,かつ,1 文字以上あるなら True を,そうでなければ False を返す.文字 c は,c.isalpha(),c.isdecimal(),c.isdigit(),または,c.isnumeric() のいずれかが True を返せば英数字である.
          >>> bytearray(b"Abc12").isalnum()
          True
          						

        • bytearray.isalpha() : bytearray 中の全ての文字が英字で,かつ,1 文字以上あるなら True を,そうでなければ False を返す.

        • bytearray.isdigit() : bytearray 中の全ての文字が数字で,かつ,1 文字以上あるなら True を,そうでなければ False を返す.

        • bytearray.islower() : bytearray 中の全ての文字が小文字で,かつ,1 文字以上あるなら True を,そうでなければ False を返す.

        • bytearray.isspace() : bytearray が空白文字のみで構成され,かつ,1 文字以上ある場合には True を,そうでなければ False を返す.

        • bytearray.istitle() : bytearray がタイトルケース文字列であり,かつ,1 文字以上ある場合には True を,そうでなければ False を返す.
          >>> bytearray(b"Abc Efg").istitle()
          True
          >>> bytearray(b"Abc EFG").istitle()
          False
          						

        • bytearray.isupper() : bytearray 中の全ての文字が大文字で,かつ,1 文字以上あるなら True を,そうでなければ False を返す.

        • bytearray.join(iterable) : iterable 中の bytearray を bytearray で結合した bytearray を返す.iterableイテラブル)とは,構成要素を一度に一つずつ返すことができるオブジェクトである.下の例では,リストを使用している.
          >>> a = [bytearray(b"abc"), bytearray(b"def"), bytearray(b"ghi")]
          >>> a
          [bytearray(b'abc'), bytearray(b'def'), bytearray(b'ghi')]
          >>> bytearray(b"**").join(a)
          bytearray(b'abc**def**ghi')
          >>> bytearray(b"").join(a)
          bytearray(b'abcdefghi')
          						

        • bytearray.lower() : すべての文字を小文字に変換する.

        • bytearray.upper() : すべての文字を大文字に変換する.

        • bytearray.swapcase() : 大文字を小文字に,小文字を大文字に変換
          >>> bytearray(b"aaaXXX").swapcase()
          bytearray(b'AAAxxx')
          						

        • bytearray.title() : bytearray を,単語ごとにタイトルケースにして返す.
          >>> bytearray(b"this is a pen").title()
          bytearray(b'This Is A Pen')
          						

        • bytearray.partition(sep) : bytearray を sep の最初の出現位置で区切り,3 要素のタプルを返す.タプルの内容は,区切りの前の部分,区切り bytearray そのもの,及び,区切りの後ろの部分である.もし区切れなければ,タプルには元の bytearray そのものとその後ろに 2 つの空白 bytearray が入る.
          >>> bytearray(b"abc\tefg\txxx").partition(b"\t")
          (bytearray(b'abc'), bytearray(b'\t'), bytearray(b'efg\txxx'))
          						

        • bytearray.rpartition(sep) : bytearray を sep の最後の出現位置で区切り,3 要素のタプルを返す.タプルの内容は,区切りの前の部分,区切り bytearray そのもの,及び,区切りの後ろの部分である.もし区切れなければ,タプルには 2 つの空白 bytearray とその後ろに元の bytearray そのものが入る.
          >>> bytearray(b"abc\tefg\txxx").rpartition(b"\t")
          (bytearray(b'abc\tefg'), bytearray(b'\t'), bytearray(b'xxx'))
          						

        • bytearray.replace(old, new[, count]) : bytearray に現れる部分シーケンス old 全てを new に置換して返す.count が与えられている場合,先頭から count 個の old だけを置換する.
          >>> bytearray(b"abc..abc..abc").replace(b"abc", b"xx", 2)
          bytearray(b'xx..xx..abc')
          						

        • bytearray.split(sep=None, maxsplit=-1) : sep を区切り文字とした bytearray 中の単語のリストを返す.maxsplit が与えられた場合,bytearray の先頭から最大 maxsplit 回分割を行う.sep が指定されていない,または,None のとき,全ての空白文字が区切り文字となる.引数 sep は複数文字で構成されていても構わない.
          >>> bytearray(b"abc,xxx,,yyy,zzz").split(b",", 3)
          [bytearray(b'abc'), bytearray(b'xxx'), bytearray(b''), bytearray(b'yyy,zzz')]
          						

        • bytearray.rsplit(sep=None, maxsplit=-1) : sep を区切り文字とした bytearray 中の単語のリストを返す.maxsplit が与えられた場合,bytearray の右端から最大 maxsplit 回分割を行う.sep が指定されていない,または,None のとき,全ての空白文字が区切り文字となる.引数 sep は複数文字で構成されていても構わない.
          >>> bytearray(b"abc,xxx,,yyy,zzz").rsplit(b",", 3)
          [bytearray(b'abc,xxx'), bytearray(b''), bytearray(b'yyy'), bytearray(b'zzz')]
          						

        • bytearray.splitlines([keepends]) : bytearray を改行部分で分解し,各行からなるリストを返す.keepends に True が与えらない限り,返されるリストに改行は含まれない.
          >>> bytearray(b"abc\nefg\n\nxxx").splitlines()
          [bytearray(b'abc'), bytearray(b'efg'), bytearray(b''), bytearray(b'xxx')]
          						

        • bytearray.startswith(prefix[, start[, end]]) : bytearray のスライス [start:end] が,指定された prefix で始まるなら True を,そうでなければ False を返す.prefix は見つけたい複数の接頭語のタプルでも構わない.
          >>> a = (b"a", b"b")
          >>> a
          (b'a', b'b')
          >>> bytearray(b"abc").startswith(a)
          True
          >>> bytearray(b"bca").startswith(a)
          True
          >>> bytearray(b"cab").startswith(a)
          False
          						

        • bytearray.endswith(suffix[, start[, end]]) : bytearray のスライス [start:end] が指定された suffix で終わる場合は True を,そうでなければ False を返す.suffix は検索対象の複数の接尾語のタプルでも構わない.
          >>> bytearray(b"abcdef").endswith(b"f")
          True
          						

        • bytearray.strip([chars]) : bytearray の先頭及び末尾の文字を除去したコピーを返す.引数 chars は除去される文字の集合を指定する bytearray であり,省略されるか None の場合,空白文字が除去される.
          >>> bytearray(b"   abc   abc   ").strip()
          bytearray(b'abc   abc')
          >>> bytearray(b"...abc...aba...").strip(b"a.")
          bytearray(b'bc...ab')
          						

        • bytearray.lstrip([chars]) : bytearray の先頭の文字を除去したコピーを返す.引数 chars は除去される文字の集合を指定する bytearray であり,省略されるか None の場合,空白文字が除去される.
          >>> bytearray(b"   abc   abc   ").lstrip()
          bytearray(b'abc   abc   ')
          >>> bytearray(b"...abc...aba...").lstrip(b"a.")
          bytearray(b'bc...aba...')
          						

        • bytearray.rstrip([chars]) : bytearray の末尾の文字を除去したコピーを返す.引数 chars は除去される文字の集合を指定する bytearray であり,省略されるか None の場合,空白文字が除去される.
          >>> bytearray(b"   abc   abc   ").rstrip()
          bytearray(b'   abc   abc')
          >>> bytearray(b"...abc...aba...").rstrip(b"a.")
          bytearray(b'...abc...ab')
          						

  3. 集合型( set )

      set オブジェクトは,ハッシュ可能な(変更不可能な)オブジェクトの順序のない集まりであり,数学における集合に相当します.従って,ある要素が含まれる,要素の数等に相当する演算は可能ですが,添え字,スライスなど,シーケンス型に対して使用されるような操作は不可能です.C++ の C++ 標準ライブラリ内の unordered_set クラスと似ていますが,unordered_set とは異なり,異なる型のオブジェクトを要素として持つことができます.タプル型リスト型辞書型なども同様ですが,「異なる型のオブジェクトを要素として持つことができる」という仕様には疑問を感じます.誤りの原因となりやすく,避けた方が良いと思います.なお,C/C++ の set においては,要素(オブジェクト)を追加・削除するたびに,自動的にソートされます.

      ハッシュ可能なオブジェクトとは,そのオブジェクトが存在する期間中変わらないハッシュ値を持ち,他のオブジェクトと比較ができるオブジェクトです.ハッシュ可能なオブジェクトは辞書キーや集合のメンバーとして使えます.辞書や集合のデータ構造は内部でハッシュ値を使っているからです.Python の変更不可能なオブジェクトはハッシュ可能ですが,変更可能なオブジェクト,例えばリスト辞書はハッシュ不可能です.

      set および frozenset という 2 種類の集合型が存在します.set は変更可能な集合型であり,要素の追加や削除が可能です.変更可能なため,ハッシュ値を持たず,辞書のキーや他の集合の要素として用いることができません.一方,frozenset 型は変更不可能であり,ハッシュ可能です.作成後に内容を改変できないため,辞書のキーや他の集合の要素として用いることができます.

      set は,要素を波括弧中にカンマで区切って列挙する(空の set は波括弧だけ)ことによって生成できます.また,set および frozenset は,組み込み関数,

    class set([iterable])
    class frozenset([iterable])

    を使用して生成することも可能です.iterable が指定されないと,空の集合が作成されます.iterableイテラブル)とは,リストタプルrange など,構成要素を一度に一つずつ返すことができるオブジェクトです.
    >>> {}   # 空の set
    {}
    >>> {1, 2, 3}
    {1, 2, 3}
    >>> {1, 2, 3, 3, 3}   # 同じ要素は含まない
    {1, 2, 3}
    >>> set([1, 2, 3])
    {1, 2, 3}
    >>> frozenset([1, 2, 3])
    frozenset({1, 2, 3})
    			
      set および frozenset のオブジェクトに対しては,以下に示す操作が可能です.なお,union(),intersection(),difference(),symmetric_difference(),issubset(),issuperset() メソッドは,任意のイテラブルを引数(set1,set2,・・・)として受け付けますが,それらのメソッドを演算子を使用して実現した場合は,引数は集合でなくてはなりません.なお,すぐ下に示すのは,それ以降に詳細説明を行っている項目の目次になっています.

      ここにおいても,記述の簡単さだけを目指して,あまり特殊な機能は使用しない方が良いと思います.特に,Python に対する知識のない人にとっては,理解しがたいプログラムになってしまいます.参考のため,いくつかの例に対しては,C++ 標準ライブラリ内の set クラスを使用した C++ のプログラム例を載せておきます(出力結果は同じであるため除く).その際,出力文「 cout << 」に対しては,以下に示すように,<< 演算子のオーバーロードがされているものとします.
    ostream& operator << (ostream& stream, set<int> &s)
    {
    	if (s.empty())
    		stream << "{}\n";
    	else {
    		stream << "{";
    		set<int>::iterator it;
    		unsigned int k = 0;
    		for (it = s.begin(); it != s.end(); it++) {
    			stream << *it;
    			if (k < s.size()-1)
    				stream << ", ";
    			k++;
    		}
    		stream << "}\n";
    	}
    	return stream;
    }
    			

    • len(set) : 集合 set の要素数 ( set の濃度)
      >>> s = {1, 2, 3}
      >>> len(s)
      3
      				

      C++ の場合

      set<int> s;
      for (int i1 = 1; i1 <= 3; i1++)
      	s.insert(i1);
      cout << s.size();
      				

    • x in set : x が集合 set の要素であれば True
      >>> set = {1, 2, 3}
      >>> 1 in set
      True
      				

      C++ の場合

      set<int> s;
      set<int>::iterator it;
      for (int i1 = 1; i1 <= 3; i1++)
      	s.insert(i1);
      it = s.find(1);
      cout << (it != s.end()) << endl;   // 1,見つかった
      it = s.find(4);
      cout << (it != s.end()) << endl;   // 0,見つからない
      				

    • x not in set : x が集合 set の要素でなければ True
      >>> set = {1, 2, 3}
      >>> 4 not in set
      True
      				

    • set.isdisjoint(set1) : 集合 set と 集合 set1 の共通集合が空集合であれば True
      >>> set = {1, 2, 3}
      >>> set1 = {5, 6}
      >>> set.isdisjoint(set1)
      True
      				

      C++ の場合

      set<int> s1, s2, s3;
      for (int i1 = 1; i1 <= 3; i1++)
      	s1.insert(i1);
      for (int i1 = 5; i1 <= 6; i1++)
      	s2.insert(i1);
      set_intersection(s1.begin(), s1.end(), s2.begin(), s2.end(), inserter(s3, s3.begin()));
      cout << s3.size() << " " << s3;   // 0 {} を出力
      				

    • set.issubset(set1) : 集合 set が集合 set1 の部分集合であれば True
      set <= set1 : 上と同様
      >>> set = {1, 2, 3}
      >>> set1 = {1, 2, 3, 4, 5}
      >>> set.issubset(set1)
      True
      				

      C++ の場合

      set<int> s1, s2;
      for (int i1 = 1; i1 <= 3; i1++)
      	s1.insert(i1);
      for (int i1 = 1; i1 <= 5; i1++)
      	s2.insert(i1);
      cout << includes(s2.begin(), s2.end(), s1.begin(), s1.end());
      				

    • set.issuperset(set1) : 集合 set1 が集合 set の部分集合であれば True
      set >= set1 : 上と同様
      >>> set = {1, 2, 3, 4, 5}
      >>> set1 = {1, 2, 3}
      >>> set.issuperset(set1)
      True
      				

    • set < set1 : 集合 set が集合 set1 の真部分集合であれば True.set <= set1 and set != set1 と等価.
      >>> s1 = {1, 2, 3}
      >>> s2 = {1, 2, 3, 4, 5}
      >>> s1 <= s2 and s1 != s2
      True
      				

      C++ の場合

      set<int> s1, s2;
      for (int i1 = 1; i1 <= 3; i1++)
      	s1.insert(i1);
      for (int i1 = 1; i1 <= 5; i1++)
      	s2.insert(i1);
      bool b = includes(s2.begin(), s2.end(), s1.begin(), s1.end());
      cout << (b && (s1.size() < s2.size())) << endl;
      				

    • set > set1 : 集合 set1 が集合 set の真部分集合であれば True.set >= set1 and set != set1 と等価.

    • set.union(set1, set2, ...) : 集合 set,set1,set2,・・・の和集合
      set | set1 | set2 | ... : 上と同様
      >>> set = {1, 2, 3}
      >>> set1 = {2, 3, 4, 5}
      >>> set2 = {2, 3, 4}
      >>> set.union(set1, set2)
      {1, 2, 3, 4, 5}
      				

      C++ の場合

      set<int> s1, s2, s3, s4, s5;
      for (int i1 = 1; i1 <= 3; i1++)
      	s1.insert(i1);
      for (int i1 = 2; i1 <= 5; i1++)
      	s2.insert(i1);
      for (int i1 = 2; i1 <= 4; i1++)
      	s3.insert(i1);
      set_union(s1.begin(), s1.end(), s2.begin(), s2.end(), inserter(s4, s4.begin()));
      set_union(s3.begin(), s3.end(), s4.begin(), s4.end(), inserter(s5, s5.begin()));
      cout << s5;
      				

    • set.intersection(set1, set2, ...) : 集合 set,set1,set2,・・・の積集合(共通集合)
      set & set1 & set2 & ... : 上と同様
      >>> set = {1, 2, 3}
      >>> set1 = {2, 3, 4, 5}
      >>> set2 = {2, 3, 4}
      >>> set & set1 & set2
      {2, 3}
      				

      C++ の場合

      set<int> s1, s2, s3, s4, s5;
      for (int i1 = 1; i1 <= 3; i1++)
      	s1.insert(i1);
      for (int i1 = 2; i1 <= 5; i1++)
      	s2.insert(i1);
      for (int i1 = 2; i1 <= 4; i1++)
      	s3.insert(i1);
      set_intersection(s1.begin(), s1.end(), s2.begin(), s2.end(), inserter(s4, s4.begin()));
      set_intersection(s3.begin(), s3.end(), s4.begin(), s4.end(), inserter(s5, s5.begin()));
      cout << s5;
      				

    • set.difference(set1, set2, ...) : 集合 set に含まれて,かつ,set1,set2,・・・全てに含まれない要素を持つ集合
      set - set1 - set2 - ... : 上と同様
      >>> set = {1, 2, 3, 4, 5}
      >>> set1 = {1, 2, 6, 7}
      >>> set2 = {2, 4, 6}
      >>> set.difference(set1, set2)
      {3, 5}
      				

      C++ の場合

      set<int> s1, s2, s3, s4, s5;
      for (int i1 = 1; i1 <= 5; i1++)
      	s1.insert(i1);
      for (int i1 = 1; i1 <= 2; i1++)
      	s2.insert(i1);
      s2.insert(6);
      s2.insert(7);
      for (int i1 = 2; i1 <= 6; i1 += 2)
      	s3.insert(i1);
      set_difference(s1.begin(), s1.end(), s2.begin(), s2.end(), inserter(s4, s4.begin()));
      set_difference(s4.begin(), s4.end(), s3.begin(), s3.end(), inserter(s5, s5.begin()));
      cout << s5;
      				

    • set.symmetric_difference(set1) : 集合 set と set1 のいずれか一方だけに含まれる要素を持つ集合
      set ^ set1 : 上と同様
      >>> set = {1, 2, 3, 4}
      >>> set1 = {3, 4, 5}
      >>> set ^ set1
      {1, 2, 5}
      				

      C++ の場合

      set<int> s1, s2, s3;
      for (int i1 = 1; i1 <= 4; i1++)
      	s1.insert(i1);
      for (int i1 = 3; i1 <= 5; i1++)
      	s2.insert(i1);
      set_symmetric_difference(s1.begin(), s1.end(), s2.begin(), s2.end(), inserter(s3, s3.begin()));
      cout << s3;
      				

    • set.copy() : 集合 set の浅いコピー(シーケンスに対する浅いコピーも参照)

      以下に示す演算は set には適用できますが,変更不可能である frozenset のオブジェクトには適用できません.なお,update(),intersection_update(),difference_update(),および,symmetric_difference_update() メソッドは,任意のイテラブルを引数として設定できますが,それらのメソッドを演算子を使用して実現した場合は,引数は集合でなくてはなりません.また,remove(),および,discard() メソッドの引数は集合でも構いません.なお,すぐ下に示すのは,それ以降に詳細説明を行っている項目の目次になっています.

    • set.update(set1, set2, ...) : 集合 set,set1,set2,・・・の和集合で集合 set を更新
      set |= set1 | set2 | ... : 上と同様
      >>> set = {1, 2, 3}
      >>> set1 = {2, 3, 4, 5}
      >>> set2 = {2, 3}
      >>> set.update(set1, set2)
      >>> set
      {1, 2, 3, 4, 5}
      				

    • set.intersection_update(set1, set2, ...) : 集合 set,set1,set2,・・・の積集合(共通集合)で集合 set を更新
      set &= set1 & set2 & ... : 上と同様
      >>> set = {1, 2, 3}
      >>> set1 = {2, 3, 4, 5}
      >>> set2 = {2, 3}
      >>> set &= set1 & set2
      >>> set
      {2, 3}
      				

    • set.difference_update(set1, set2, ...) : 集合 set に含まれて,かつ,set1,set2,・・・全てに含まれない要素を持つ集合で集合 set を更新
      set -= set1 - set2 - ... : 上と同様
      >>> set = {1, 2, 3, 4, 5}
      >>> set1 = {1, 2, 6, 7}
      >>> set2 = {2, 4, 6}
      >>> set.difference_update(set1, set2)
      >>> set
      {3, 5}
      				

    • set.symmetric_difference_update(set1) : 集合 set と set1 のいずれか一方だけに含まれる要素を持つ集合で集合 set を更新
      set ^= set1 : 上と同様
      >>> set = {1, 2, 3, 4}
      >>> set1 = {3, 4, 5}
      >>> set ^= set1
      >>> set
      {1, 2, 5}
      				

    • set.add(elem) : 集合 set に要素 elem を追加( C++ における insert ).同じ要素がすでに存在する場合は無視される.
      >>> set = {3, 4}
      >>> set.add(1)
      >>> set
      {1, 3, 4}
      				

    • set.remove(elem) : 集合 set から要素 elem を削除.elem が set に含まれていなければ KeyError を返す.
      >>> set = {1, 2, 3}
      >>> set.remove(2)
      >>> set
      {1, 3}
      				

    • set.discard(elem) : 集合 set に要素 elem が含まれていれば削除
      >>> set = {1, 2, 3}
      >>> set.discard(4)
      >>> set
      {1, 2, 3}
      >>> set.discard(3)
      >>> set
      {1, 2}
      				

      C++ の場合

      set<int> s;
      for (int i1 = 1; i1 <= 3; i1++)
      	s.insert(i1);
      s.erase(2);
      cout << s;
      				

    • set.pop() : 集合 set から任意の要素を削除し,それを返す.集合が空の場合,KeyError を返す.
      >>> set = {1, 2, 3}
      >>> set.pop()
      1
      >>> set.pop()
      2
      >>> set.pop()
      3
      >>> set
      set()
      				

    • set.clear() : 集合 set のすべての要素を削除.
      >>> set = {1, 2, 3}
      >>> set.clear()
      >>> set
      set()
      				

      C++ の場合

      set<int> s;
      for (int i1 = 1; i1 <= 3; i1++)
      	s.insert(i1);
      s.clear();
      cout << s;
      				

  4. マッピング型(辞書型)

      マッピングmapping )オブジェクトは.ハッシュ可能な値であるキーと任意のオブジェクトのペアから構成されます.現在,標準のマッピング型は辞書dictionary )だけです.辞書のキーは,ほぼ,任意の値です.ただし,ハッシュ可能でない値,つまり,リストや辞書など変更可能な型はキーとして使用できません.C++ の C++ 標準ライブラリ内の map クラス と似ていますが,map とは異なり,異なる型のオブジェクトを要素として持つことができます.タプル型リスト型集合型なども同様ですが,「異なる型のオブジェクトを要素として持つことができる」という仕様には疑問を感じます.誤りの原因となりやすく,避けた方が良いと思います.なお,C++ における map は,データが入力されるたびに,自動的にソートされます.

      辞書は,key : value 対をカンマで区切り,波括弧「 { } 」でくくることで作成できます.また,組み込み関数,

    class dict(**kwarg)
    class dict(mapping, **kwarg)
    class dict(iterable, **kwarg)

    を使用することによっても可能です.iterable のそれぞれの要素自身は,2 個のオブジェクトを持つイテラブルでなければなりません.それぞれの要素の最初のオブジェクトは新しい辞書のキーになり,2 番目のオブジェクトはそれに対応する値になります.同一のキーが 2 回以上現れた場合は,そのキーの最後の値が新しい辞書での対応する値になります.iterableイテラブル)とは,リストタプルrange など,構成要素を一度に一つずつ返すことができるオブジェクトです.

      キーワード引数 kwarg が与えられた場合,キーワード引数とその値が mapping または iterable から作成された辞書に追加されます.既に存在しているキーが追加された場合,キーワード引数の値は位置引数の値を置き換えます.

      以下に示す例は,空の辞書を生成する場合を除き,すべて同じ辞書を生成します.
    >>> d = {}   # 空の辞書
    >>> d = dict()   # 空の辞書
    >>> d = {"aaa" : 10, "bbb" : 20, "ccc" : 30}   # key:value 対と波括弧の利用
    >>> d = dict(aaa = 10, bbb = 20, ccc = 30)   # kwarg の利用
    >>> d = dict({"aaa" : 10, "bbb" : 20, "ccc" : 30})   # mapping の利用
    >>> d = dict({"aaa" : 10, "bbb" : 20}, ccc = 30)   # mapping と kwarg
    >>> d = dict([("aaa" , 10), ("bbb" , 20), ("ccc" , 30)])   # iterable の利用
    			
      辞書型のオブジェクトに対しては,以下に示す操作が可能です.なお,すぐ下に示すのは,それ以降に詳細説明を行っている項目の目次になっています.

          • key in dic : key を持っているか?
          • key not in dic : key を持っていないか?
          • dic[key] : key に対応する値
          • dic[key] = value : key に対応する値を value に設定
          • clear : 全項目を削除
          • copy : 浅いコピー
          • del dic[key] : key で示される項目を削除
          • fromkeys : 新しい辞書を作成
          • get : キーに対応する値
          • items : 項目のビュー
          • iter : キーに関するイテレータ
          • kyes : キーのビュー
          • len : 項目数
          • pop : キーに対応する項目の取り出しと削除
          • popitem : 任意の項目を削除
          • setdefault : キーに対応する項目の取り出しまたは追加
          • update : 辞書の更新
          • values : 値のビュー

      ここにおいても,記述の簡単さだけを目指して,あまり特殊な機能は使用しない方が良いと思います.特に,Python に対する知識のない人にとっては,理解しがたいプログラムになってしまいます.参考のため,いくつかの例に対しては,C++ 標準ライブラリ内の map クラスを使用した C++ のプログラム例を載せておきます(出力結果は同じであるため除く).その際,出力文「 cout << 」に対しては,以下に示すように,<< 演算子のオーバーロードがされているものとします.
    ostream& operator << (ostream& stream, map<string, int> &m)
    {
    	if (m.empty())
    		stream << "{}\n";
    	else {
    		map<string, int>::iterator it;
    		unsigned int k = 0;
    		stream << "{";
    		for (it = m.begin(); it != m.end(); it++) {
    			stream << (*it).first << " : " << (*it).second;
    			if (k < m.size()-1)
    				stream << ", ";
    			k++;
    		}
    		stream << "}\n";
    	}
    	return stream;
    }
    			

    • len(dic) : 辞書 dic の項目数
      >>> dic = dict({"aaa" : 10, "bbb" : 20, "ccc" : 30})
      >>> len(dic)
      3
      				

      C++ の場合

      map<string, int> m;
      m.insert(pair<string, int>("aaa", 10));
      m.insert(pair<string, int>("bbb", 20));
      m.insert(pair<string, int>("ccc", 30));
      cout << m.size();   // 3 を出力
      				

    • key in dic : 辞書 dic がキー key を持っていれば True
      >>> dic = dict({"aaa" : 10, "bbb" : 20, "ccc" : 30})
      >>> "bbb" in dic
      True
      				

      C++ の場合

      map<string, int> m;
      map<string, int>::iterator it;
      m.insert(pair<string, int>("aaa", 10));
      m.insert(pair<string, int>("bbb", 60));
      m.insert(pair<string, int>("ccc", 70));
      it = m.find("bbb");
      if (it != m.end())
      	cout << (*it).first << " : " << (*it).second << endl;   // キーと値の出力
      else
      	cout << "存在しない\n";
      				

    • key not in dic : 辞書 dic がキー key を持っていなければ True
      >>> dic = dict({"aaa" : 10, "bbb" : 20, "ccc" : 30})
      >>> "xxx" not in dic
      True
      				

    • dic[key] : 辞書 dic のキー key に対応する値を返す.key が存在しなければ,KeyError を送出.
      >>> dic = dict({"aaa" : 10, "bbb" : 20, "ccc" : 30})
      >>> dic["bbb"]
      20
      				

    • dic.get(key[, default]) : key が辞書 dic にあれば key に対する値を,そうでなければ default を返す.default が与えられなかった場合,None となる.
      >>> dic = dict({"aaa" : 10, "bbb" : 20, "ccc" : 30})
      >>> dic.get("bbb")
      20
      				

    • dic[key] = value : 辞書 dic のキー key に対応する値を value に設定
      >>> dic = dict({"aaa" : 10, "bbb" : 20, "ccc" : 30})
      >>> dic["bbb"] = 200
      >>> dic
      {'bbb': 200, 'aaa': 10, 'ccc': 30}
      				

      C++ の場合

      map<string, int> m;
      map<string, int>::iterator it;
      m.insert(pair<string, int>("aaa", 10));
      m.insert(pair<string, int>("bbb", 20));
      m.insert(pair<string, int>("ccc", 30));
      it = m.find("ddd");
      if (it != m.end())   // 値の変更
      	(*it).second = 200;
      else   // 存在しない場合は追加
      	m.insert(pair<string, int>("ddd", 40));
      cout << m;
      				

    • dic.setdefault(key[, default]) : key が辞書 dic に存在すれば,キーに対応する値を返す.存在しなければ,値を default として key を挿入し,default を返す.default のデフォルトは None.
      >>> dic = dict({"aaa" : 10, "bbb" : 20})
      >>> dic.setdefault("aaa", 100)
      10
      >>> dic.setdefault("ccc", 30)
      30
      >>> dic
      {'bbb': 20, 'aaa': 10, 'ccc': 30}
      				

    • dic.update([other]) : 辞書 dic の内容を other のキーと値で更新.その際,既存のキーは上書きされる.なお,引数を省略すると何も行わない.other は,他の辞書オブジェクトでもキーと値の対のイテラブル(タプル,もしくは,長さが 2 のイテラブル)でも良い.キーワード引数が指定されれば,そのキーと値の対で辞書を更新する.
      >>> dic = dict({"aaa" : 10, "bbb" : 20})
      >>> dic.update([("aaa", 100), ("bbb", 200), ("ccc", 300)])
      >>> dic
      {'bbb': 200, 'aaa': 100, 'ccc': 300}
      >>> dic.update()
      >>> dic
      {'bbb': 200, 'aaa': 100, 'ccc': 300}
      >>> dic.update(aaa = 1, bbb = 2)
      >>> dic
      {'bbb': 2, 'aaa': 1, 'ccc': 300}
      				

    • classmethod fromkeys(seq[, value]) : シーケンス型 seq からキーを取り出し,それらの値を value に設定した新しい辞書を作成.value のデフォルト値は None.
      >>> dic1 = dict.fromkeys(["aaa", "bbb"])
      >>> dic1
      {'bbb': None, 'aaa': None}
      >>> dic2 = dict.fromkeys(["aaa", "bbb"], 100)
      >>> dic2
      {'bbb': 100, 'aaa': 100}
      				

    • del dic[key] : 辞書 dic のキー key で示される項目を削除.key が存在しなければ,KeyError を送出
      >>> dic = dict({"aaa" : 10, "bbb" : 20, "ccc" : 30})
      >>> del dic["bbb"]
      >>> dic
      {'aaa': 10, 'ccc': 30}
      				

      C++ の場合

      map<string, int> m;
      map<string, int>::iterator it;
      m.insert(pair<string, int>("aaa", 10));
      m.insert(pair<string, int>("bbb", 20));
      m.insert(pair<string, int>("ccc", 30));
      it = m.find("bbb");
      if (it != m.end())   // 削除
      	m.erase(it);
      cout << m;
      				

    • dic.pop(key[, default]) : key が辞書 dic に存在すればその値を返すとともに,対応する項目を削除.存在しなければ default を返す.default が与えらず,かつ,key が辞書に存在しなければ KeyError を送出.
      >>> dic = dict({"aaa" : 10, "bbb" : 20, "ccc" : 30})
      >>> dic.pop("aaa")
      10
      >>> dic
      {'bbb': 20, 'ccc': 30}
      				

    • dic.popitem() : 任意の項目を辞書から削除.辞書が空であれば,KeyError を送出.
      >>> dic = dict({"aaa" : 10, "bbb" : 20})
      >>> dic.popitem()
      ('bbb', 20)
      >>> dic.popitem()
      ('aaa', 10)
      				

    • dic.clear() : 辞書 dic のすべての項目を削除
      >>> dic = dict({"aaa" : 10, "bbb" : 20, "ccc" : 30})
      >>> dic.clear()
      >>> dic
      {}
      				

      C++ の場合

      map<string, int> m;
      m.insert(pair<string, int>("aaa", 10));
      m.insert(pair<string, int>("bbb", 20));
      m.insert(pair<string, int>("ccc", 30));
      m.clear();
      cout << m;
      				

    • iter(dic) : 辞書 dic のキーに関するイテレータを返す( iter(d.keys()) と同じ).
      >>> dic = {"aaa" : 1, "bbb" : 2, "ccc" : 3}
      >>> it = iter(dic)
      >>> next(it)
      'bbb'
      >>> next(it)
      'aaa'
      >>> next(it)
      'ccc'
      				

      C++ の場合

      map<string, int> m;
      map<string, int>::iterator it;
      m.insert(pair<string, int>("aaa", 10));
      m.insert(pair<string, int>("bbb", 20));
      m.insert(pair<string, int>("ccc", 30));
      for (it = m.begin(); it != m.end(); it++)
      	cout << (*it).first << ":" << (*it).second << " ";
      				

    • dic.copy() : 辞書 dic の浅いコピー(シーケンスに対する浅いコピーも参照)

    • dic.items() : 辞書の項目 ( (key, value) 対)の新しいビュー(集まり)を返す.辞書の変化と共に動的に変化する.
      >>> dic = dict({"aaa" : 10, "bbb" : 20, "ccc" : 30})
      >>> item = dic.items()
      >>> item
      dict_items([('bbb', 20), ('aaa', 10), ('ccc', 30)])
      >>> list(item)
      [('bbb', 20), ('aaa', 10), ('ccc', 30)]
      				

    • dic.kyes() : 辞書のキーの新しいビュー(集まり)を返す.辞書の変化と共に動的に変化する.
      >>> dic = dict({"aaa" : 10, "bbb" : 20, "ccc" : 30})
      >>> key = dic.keys()
      >>> key
      dict_keys(['bbb', 'aaa', 'ccc'])
      >>> list(key)
      ['bbb', 'aaa', 'ccc']
      				

    • dic.values() : 辞書の値の新しいビュー(集まり)を返す.辞書の変化と共に動的に変化する.
      >>> dic = dict({"aaa" : 10, "bbb" : 20, "ccc" : 30})
      >>> value = dic.values()
      >>> value
      dict_values([20, 10, 30])
      >>> list(value)
      [20, 10, 30]
      >>> sum = 0   # 以下,for 文に利用した例
      >>> for x in value:
      ...     sum += x
      ...
      >>> print(sum)
      60
      				

静岡理工科大学 菅沼ホーム 目次 索引