Pythonのリストとタプル

Pythonのリストとタプル

*リスト*と*タプル*は間違いなくPythonの最も用途が広く便利なhttps://realpython.com/python-data-types/[データ型]です。 それらは、ほとんどすべての非自明なPythonプログラムにあります。

*このチュートリアルで学習する内容は次のとおりです。*リストとタプルの重要な特徴について説明します。 これらの定義方法と操作方法を学習します。 終了したら、これらのオブジェクトタイプをPythonプログラムでいつ、どのように使用するかをよく理解する必要があります。

  • __クイズに挑戦:*インタラクティブな「Pythonリストとタプル」クイズで知識をテストします。 完了すると、学習の進捗状況を経時的に追跡できるようにスコアを受け取ります。

link:/quizzes/python-lists-tuples/[クイズに挑戦»]

Pythonリスト

要するに、リストは任意のオブジェクトのコレクションであり、他の多くのプログラミング言語の配列に似ていますが、より柔軟です。 リストは、以下に示すように、オブジェクトのコンマ区切りシーケンスを角括弧( + [] +)で囲むことによってPythonで定義されます。

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']

>>> print(a)
['foo', 'bar', 'baz', 'qux']
>>> a
['foo', 'bar', 'baz', 'qux']

Pythonリストの重要な特徴は次のとおりです。

  • リストは順序付けられています。

  • リストには任意のオブジェクトを含めることができます。

  • リスト要素にはインデックスでアクセスできます。

  • リストは任意の深さにネストできます。

  • リストは変更可能です。

  • リストは動的です。

これらの各機能については、以下で詳しく説明します。

リストが順序付けられています

リストは単なるオブジェクトのコレクションではありません。 オブジェクトの順序付きコレクションです。 リストを定義するときに要素を指定する順序は、そのリストの固有の特性であり、そのリストの存続期間中維持されます。 (辞書に関する次のチュートリアルでは順序付けられていないPythonデータ型が表示されます。)

異なる順序で同じ要素を持つリストは同じではありません:

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False

>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False

リストには任意のオブジェクトを含めることができます

リストには、あらゆる種類のオブジェクトを含めることができます。 リストの要素はすべて同じ型にすることができます。

>>>

>>> a = [2, 4, 6, 8]
>>> a
[2, 4, 6, 8]

または、要素はさまざまなタイプにすることができます。

>>>

>>> a = [21.42, 'foobar', 3, 4, 'bark', False, 3.14159]
>>> a
[21.42, 'foobar', 3, 4, 'bark', False, 3.14159]

リストには、次のチュートリアルで学習する関数、クラス、モジュールなどの複雑なオブジェクトを含めることもできます。

>>>

>>> int
<class 'int'>
>>> len
<built-in function len>
>>> def foo():
...     pass
...
>>> foo
<function foo at 0x035B9030>
>>> import math
>>> math
<module 'math' (built-in)>

>>> a = [int, len, foo, math]
>>> a
[<class 'int'>, <built-in function len>, <function foo at 0x02CA2618>,
<module 'math' (built-in)>]

リストには、0からコンピューターのメモリが許可する数までの任意の数のオブジェクトを含めることができます。

>>>

>>> a = []
>>> a
[]

>>> a = [ 'foo' ]
>>> a
['foo']

>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
... 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
... 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
... 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
... 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
97, 98, 99, 100]

(単一のオブジェクトを含むリストは、シングルトンリストと呼ばれることもあります。)

リストオブジェクトは一意である必要はありません。 特定のオブジェクトは、リストに複数回表示される場合があります。

>>>

>>> a = ['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']
>>> a
['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']

リスト要素にはインデックスでアクセスできます

リスト内の個々の要素には、角括弧内のインデックスを使用してアクセスできます。 これは、文字列内の個々の文字にアクセスするのとまったく同じです。 リストのインデックス付けは、文字列と同様にゼロベースです。

次のリストを考慮してください。

>>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

`+ a +`の要素のインデックスは次のとおりです。

`+ a +`のいくつかの要素にアクセスするPythonコードは次のとおりです。

>>>

>>> a[0]
'foo'
>>> a[2]
'baz'
>>> a[5]
'corge'

文字列のインデックス付けに関する事実上すべてがリストに対して同様に機能します。 たとえば、負のリストインデックスはリストの最後からカウントされます。

>>>

>>> a[-1]
'corge'
>>> a[-2]
'quux'
>>> a[-5]
'bar'

スライスも機能します。 「+ a 」がリストの場合、式「 a [m:n] 」は、インデックス「 m 」からインデックス「 n 」を含むがインデックス「 n 」を含まない「 a +」の一部を返します。

>>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> a[2:5]
['baz', 'qux', 'quux']

文字列スライスの他の機能は、リストスライスでも同様に機能します。

  • 正と負の両方のインデックスを指定できます。

>>>

>>> a[-5:-2]
['bar', 'baz', 'qux']
>>> a[1:4]
['bar', 'baz', 'qux']
>>> a[-5:-2] == a[1:4]
True
  • 最初のインデックスを省略すると、リストの先頭からスライスが開始され、2番目のインデックスを省略すると、スライスがリストの最後まで拡張されます。

>>>

>>> print(a[:4], a[0:4])
['foo', 'bar', 'baz', 'qux'] ['foo', 'bar', 'baz', 'qux']
>>> print(a[2:], a[2:len(a)])
['baz', 'qux', 'quux', 'corge'] ['baz', 'qux', 'quux', 'corge']

>>> a[:4] + a[4:]
['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a[:4] + a[4:] == a
True
  • ストライドは、正または負のいずれかで指定できます。

>>>

>>> a[0:6:2]
['foo', 'baz', 'quux']
>>> a[1:6:2]
['bar', 'qux', 'corge']
>>> a[6:0:-2]
['corge', 'qux', 'bar']
  • リストを逆にする構文は、文字列の場合と同じように機能します。

>>>

>>> a[::-1]
['corge', 'quux', 'qux', 'baz', 'bar', 'foo']
  • `+ [:] `構文はリストに対して機能します。 ただし、この操作がリストでどのように機能するかと、文字列でどのように機能するかには重要な違いがあります。 + ` s `が文字列の場合、 ` s [:] `は同じオブジェクトへの参照を返します: >>>

>>> s = 'foobar'
>>> s[:]
'foobar'
>>> s[:] is s
True

逆に、 ` a `がリストの場合、 ` a [:] `は ` a `のコピーである新しいオブジェクトを返します: >>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a[:]
['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a[:] is a
False

いくつかのPython演算子と組み込み関数は、文字列に類似した方法でリストで使用することもできます。

  • `+ in `および ` not in +`演算子:

>>>

>>> a
['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> 'qux' in a
True
>>> 'thud' not in a
True
*連結( `+++`)および複製( `+* +`)演算子:

>>>

>>> a
['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> a + ['grault', 'garply']
['foo', 'bar', 'baz', 'qux', 'quux', 'corge', 'grault', 'garply']
>>> a * 2
['foo', 'bar', 'baz', 'qux', 'quux', 'corge', 'foo', 'bar', 'baz',
'qux', 'quux', 'corge']
  • + len()++ min()+、および `+ max()+`関数:

>>>

>>> a
['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> len(a)
6
>>> min(a)
'bar'
>>> max(a)
'qux'

文字列とリストが同じように動作するのは偶然ではありません。 どちらも、反復可能と呼ばれるより一般的なオブジェクトタイプの特殊なケースです。これについては、今後の明確な反復に関するチュートリアルで詳しく説明します。

ところで、上記の各例では、操作が実行される前に、リストは常に変数に割り当てられます。 ただし、リストリテラルも操作できます。

>>>

>>> ['foo', 'bar', 'baz', 'qux', 'quux', 'corge'][2]
'baz'

>>> ['foo', 'bar', 'baz', 'qux', 'quux', 'corge'][::-1]
['corge', 'quux', 'qux', 'baz', 'bar', 'foo']

>>> 'quux' in ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
True

>>> ['foo', 'bar', 'baz'] + ['qux', 'quux', 'corge']
['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> len(['foo', 'bar', 'baz', 'qux', 'quux', 'corge'][::-1])
6

さらに、文字列リテラルを使用して同様に行うことができます。

>>>

>>> 'If Comrade Napoleon says it, it must be right.'[::-1]
'.thgir eb tsum ti ,ti syas noelopaN edarmoC fI'

リストはネスト可能

リスト内の要素は、あらゆる種類のオブジェクトになり得ることを見てきました。 別のリストが含まれます。 リストにはサブリストを含めることができ、サブリストにはサブリスト自体を含めることができます。

この(確かに不自然な)例について考えてみましょう:

>>>

>>> x = ['a', ['bb', ['ccc', 'ddd'], 'ee', 'ff'], 'g', ['hh', 'ii'], 'j']
>>> x
['a', ['bb', ['ccc', 'ddd'], 'ee', 'ff'], 'g', ['hh', 'ii'], 'j']

`+ x +`が参照するオブジェクト構造を以下に図示します:

+ x [0] ++ x [2] +、および `+ x [4] +`はそれぞれ1文字の文字列です。

>>>

>>> print(x[0], x[2], x[4])
a g j

しかし、 `+ x [1] `と ` x [3] +`はサブリストです。

>>>

>>> x[1]
['bb', ['ccc', 'ddd'], 'ee', 'ff']

>>> x[3]
['hh', 'ii']

サブリスト内のアイテムにアクセスするには、追加のインデックスを追加するだけです:

>>>

>>> x[1]
['bb', ['ccc', 'ddd'], 'ee', 'ff']

>>> x[1][0]
'bb'
>>> x[1][1]
['ccc', 'ddd']
>>> x[1][2]
'ee'
>>> x[1][3]
'ff'

>>> x[3]
['hh', 'ii']
>>> print(x[3][0], x[3][1])
hh ii

`+ x [1] [1] +`はさらに別のサブリストなので、さらにインデックスを追加するとその要素にアクセスします。

>>>

>>> x[1][1]
['ccc', 'ddd']
>>> print(x[1][1][0], x[1][1][1])
ccc ddd

この方法でリストをネストできる深さや複雑さに制限はありません。コンピューターのメモリの範囲に限りません。

インデックスとスライスに関する通常の構文はすべて、サブリストにも適用されます。

>>>

>>> x[1][1][-1]
'ddd'
>>> x[1][1:3]
[[ccc', 'ddd'], 'ee']
>>> x[3][::-1]
['ii', 'hh']

ただし、演​​算子と関数は指定したレベルのリストにのみ適用され、再帰的ではないことに注意してください。 `+ len()`を使用して ` x +`の長さを照会するとどうなるかを考えてみましょう。

>>>

>>> x
['a', ['bb', ['ccc', 'ddd'], 'ee', 'ff'], 'g', ['hh', 'ii'], 'j']
>>> len(x)
5

>>> x[0]
'a'
>>> x[1]
['bb', ['ccc', 'ddd'], 'ee', 'ff']
>>> x[2]
'g'
>>> x[3]
['hh', 'ii']
>>> x[4]
'j'

`+ x `には、3つの文字列と2つのサブリストの5つの要素しかありません。 サブリスト内の個々の要素は、「 x +」の長さにカウントされません。

「+ in +」演算子を使用すると、同様の状況が発生します。

>>>

>>> 'ddd' in x
False
>>> 'ddd' in x[1]
False
>>> 'ddd' in x[1][1]
True

`+ 'ddd' `は、 ` x `または ` x [1] `の要素の1つではありません。 サブリスト ` x [1] [1] +`の要素のみです。 サブリスト内の個々の要素は、親リストの要素としてカウントされません。

リストは変更可能です

これまでに遭遇したデータ型のほとんどは、アトミック型でした。 たとえば、整数オブジェクトまたはフロートオブジェクトは、これ以上分解できないプリミティブ単位です。 これらのタイプは不変です。つまり、割り当てられた後は変更できません。 整数の値を変更することを考えるのはあまり意味がありません。 別の整数が必要な場合は、別の整数を割り当てるだけです。

対照的に、文字列型は複合型です。 文字列は、より小さな部分、つまりコンポーネント文字に還元できます。 文字列の文字を変更することを考えるのは理にかなっているかもしれません。 しかし、できません。 Pythonでは、文字列も不変です。

このリストは、最初に遭遇した可変データ型です。 リストが作成されると、要素を自由に追加、削除、移動、および移動できます。 Pythonは、リストを変更するためのさまざまな方法を提供します。

単一のリスト値の変更

リスト内の単一の値は、インデックス付けと単純な割り当てで置き換えることができます。

>>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a
['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> a[2] = 10
>>> a[-1] = 20
>>> a
['foo', 'bar', 10, 'qux', 'quux', 20]

チュートリアルhttps://realpython.com/python-strings/#modifying-strings%5D[Pythonの文字列と文字データ]から、文字列ではこれを実行できないことを思い出してください。

>>>

>>> s = 'foobarbaz'
>>> s[2] = 'x'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

リスト項目は `+ del +`コマンドで削除できます:

>>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> del a[3]
>>> a
['foo', 'bar', 'baz', 'quux', 'corge']
複数のリスト値の変更

リスト内の連続する複数の要素を一度に変更したい場合はどうしますか? Pythonは、次の構文を持つスライス割り当てでこれを許可します。

a[m:n] = <iterable>

繰り返しになりますが、今のところ、反復可能なものをリストと考えてください。 この割り当てにより、指定された `+ a `のスライスが ` <iterable> +`に置き換えられます。

>>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> a[1:4]
['bar', 'baz', 'qux']
>>> a[1:4] = [1.1, 2.2, 3.3, 4.4, 5.5]
>>> a
['foo', 1.1, 2.2, 3.3, 4.4, 5.5, 'quux', 'corge']
>>> a[1:6]
[1.1, 2.2, 3.3, 4.4, 5.5]
>>> a[1:6] = ['Bark!']
>>> a
['foo', 'Bark!', 'quux', 'corge']

挿入される要素の数は、置き換えられる数と同じである必要はありません。 Pythonは必要に応じてリストを拡大または縮小するだけです。

1つの要素の代わりに複数の要素を挿入できます。1つの要素のみを示すスライスを使用するだけです。

>>>

>>> a = [1, 2, 3]
>>> a[1:2] = [2.1, 2.2, 2.3]
>>> a
[1, 2.1, 2.2, 2.3, 3]

これは、単一の要素をリストに置き換えることと同じではないことに注意してください。

>>>

>>> a = [1, 2, 3]
>>> a[1] = [2.1, 2.2, 2.3]
>>> a
[1, [2.1, 2.2, 2.3], 3]

また、何も削除せずに要素をリストに挿入することもできます。 目的のインデックスで + [n:n] +(長さゼロのスライス)の形式のスライスを指定するだけです:

>>>

>>> a = [1, 2, 7, 8]
>>> a[2:2] = [3, 4, 5, 6]
>>> a
[1, 2, 3, 4, 5, 6, 7, 8]

適切なスライスを空のリストに割り当てることにより、リストの中央から複数の要素を削除できます。 同じスライスで `+ del +`ステートメントを使用することもできます:

>>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a[1:5] = []
>>> a
['foo', 'corge']

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> del a[1:5]
>>> a
['foo', 'corge']
リストにアイテムを追加または追加する

`+`連結演算子または ` = +`拡張代入演算子を使用して、リストの先頭または末尾に追加のアイテムを追加できます。

>>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> a += ['grault', 'garply']
>>> a
['foo', 'bar', 'baz', 'qux', 'quux', 'corge', 'grault', 'garply']

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> a = [10, 20] + a
>>> a
[10, 20, 'foo', 'bar', 'baz', 'qux', 'quux', 'corge']

リストは別のリストと連結する必要があるため、要素を1つだけ追加する場合は、そのリストをシングルトンリストとして指定する必要があります。

>>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a += 20
Traceback (most recent call last):
  File "<pyshell#58>", line 1, in <module>
    a += 20
TypeError: 'int' object is not iterable

>>> a += [20]
>>> a
['foo', 'bar', 'baz', 'qux', 'quux', 'corge', 20]

*注:*技術的には、リストを別のリストと連結する必要があると言うのはまったく正しくありません。 より正確には、リストは反復可能なオブジェクトと連結する必要があります。 もちろん、リストは反復可能であるため、リストを別のリストと連結するように機能します。

文字列も反復可能です。 ただし、文字列をリストに連結するとどうなるかを見てください。

>>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux']
>>> a += 'corge'
>>> a
['foo', 'bar', 'baz', 'qux', 'quux', 'c', 'o', 'r', 'g', 'e']

この結果はおそらく期待したものとは異なります。 文字列が反復処理されると、結果はそのコンポーネント文字のリストになります。 上記の例では、リスト `+ a `に連結されるのは、文字列 ` 'corge' +`内の文字のリストです。

単一の文字列 `+ 'corge' +`だけをリストの最後に追加したい場合は、それをシングルトンリストとして指定する必要があります。

>>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux']
>>> a += ['corge']
>>> a
['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

これが不思議に思える場合、あまり心配しないでください。 反復の確定に関するチュートリアルで、イテラブルの詳細について学習します。

リストを変更するメソッド

最後に、Pythonはリストの変更に使用できるいくつかの組み込みメソッドを提供します。 これらの方法の詳細については、以下で説明します。

*注意:*前のチュートリアルで見た文字列メソッドは、ターゲット文字列を直接変更しませんでした。 文字列は不変だからです。 代わりに、文字列メソッドは、メソッドの指示に従って変更された新しい文字列オブジェクトを返します。 元のターゲット文字列は変更されません。

>>>

>>> s = 'foobar'
>>> t = s.upper()
>>> print(s, t)
foobar FOOBAR

リストメソッドは異なります。 リストは変更可能であるため、ここに示すリストメソッドはターゲットリストを変更します。

+ a.append(<obj>)+

_ リストにオブジェクトを追加します。 _

`+ a.append(<obj>)`はオブジェクト ` <obj> `をリスト ` a +`の最後に追加します:

>>>

>>> a = ['a', 'b']
>>> a.append(123)
>>> a
['a', 'b', 123]

リストメソッドは、ターゲットリストを適切に変更することを忘れないでください。 新しいリストは返されません。

>>>

>>> a = ['a', 'b']
>>> x = a.append(123)
>>> print(x)
None
>>> a
['a', 'b', 123]

リストに連結するために `+`演算子が使用される場合、ターゲットオペランドが反復可能な場合、その要素が分割されて個別にリストに追加されることに注意してください。

>>>

>>> a = ['a', 'b']
>>> a + [1, 2, 3]
['a', 'b', 1, 2, 3]

`+ .append()`メソッドはそのようには機能しません! iterableが ` .append()+`でリストに追加される場合、単一のオブジェクトとして追加されます:

>>>

>>> a = ['a', 'b']
>>> a.append([1, 2, 3])
>>> a
['a', 'b', [1, 2, 3]]

したがって、 `+ .append()+`を使用すると、文字列を単一のエンティティとして追加できます。

>>>

>>> a = ['a', 'b']
>>> a.append('foo')
>>> a
['a', 'b', 'foo']

+ a.extend(<iterable>)+

_ 反復可能オブジェクトのリストを拡張します。 _

はい、これはおそらくあなたが考えていることです。 `+ .extend()`もリストの最後に追加しますが、引数は反復可能と想定されています。 ` <iterable> +`のアイテムは個別に追加されます:

>>>

>>> a = ['a', 'b']
>>> a.extend([1, 2, 3])
>>> a
['a', 'b', 1, 2, 3]

つまり、 `+ .extend()+`は `+`演算子のように動作します。 より正確には、リストを適切に変更するため、「 = +」演算子のように動作します。

>>>

>>> a = ['a', 'b']
>>> a += [1, 2, 3]
>>> a
['a', 'b', 1, 2, 3]

+ a.insert(<インデックス>、<obj>)+

_ リストにオブジェクトを挿入します。 _

`+ a.insert(<index>、<obj>)`は、オブジェクト ` <obj> `をリスト ` a `の指定された ` <index> `に挿入します。 メソッド呼び出しの後、 ` a [<index>] `は ` <obj> +`であり、残りのリスト要素は右にプッシュされます。

>>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a.insert(3, 3.14159)
>>> a[3]
3.14159
>>> a
['foo', 'bar', 'baz', 3.14159, 'qux', 'quux', 'corge']

+ a.remove(<obj>)+

_ リストからオブジェクトを削除します。 _

`+ a.remove(<obj>)`はオブジェクト ` <obj> `をリスト ` a `から削除します。 ` <obj> `が ` a +`にない場合、例外が発生します:

>>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a.remove('baz')
>>> a
['foo', 'bar', 'qux', 'quux', 'corge']

>>> a.remove('Bark!')
Traceback (most recent call last):
  File "<pyshell#13>", line 1, in <module>
    a.remove('Bark!')
ValueError: list.remove(x): x not in list

+ a.pop(index = -1)+

_ リストから要素を削除します。 _

このメソッドは、2つの点で `+ .remove()+`と異なります。

  1. オブジェクト自体ではなく、削除するアイテムのインデックスを指定します。

  2. メソッドは値を返します:削除されたアイテム。

`+ a.pop()+`はリストの最後のアイテムを削除するだけです:

>>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> a.pop()
'corge'
>>> a
['foo', 'bar', 'baz', 'qux', 'quux']

>>> a.pop()
'quux'
>>> a
['foo', 'bar', 'baz', 'qux']

オプションの `+ <index> `パラメータが指定されている場合、そのインデックスのアイテムが削除されて返されます。 ` <index> +`は、文字列とリストのインデックス付けのように、負になる場合があります。

>>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> a.pop(1)
'bar'
>>> a
['foo', 'baz', 'qux', 'quux', 'corge']

>>> a.pop(-3)
'qux'
>>> a
['foo', 'baz', 'quux', 'corge']

`+ <index> `のデフォルトは ` -1 `であるため、 ` a.pop(-1)`は ` a.pop()+`と同等です。

リストは動的です

このチュートリアルは、Pythonリストの特徴を定義する6つのリストから始まりました。 最後の1つは、リストが動的であることです。 上記のセクションでこれの多くの例を見てきました。 アイテムがリストに追加されると、必要に応じて大きくなります。

>>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> a[2:2] = [1, 2, 3]
>>> a += [3.14159]
>>> a
['foo', 'bar', 1, 2, 3, 'baz', 'qux', 'quux', 'corge', 3.14159]

同様に、リストはアイテムの削除に合わせて縮小されます:

>>>

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a[2:3] = []
>>> del a[0]
>>> a
['bar', 'qux', 'quux', 'corge']

Pythonタプル

Pythonは、タプルと呼ばれるオブジェクトの順序付けられたコレクションである別のタイプを提供します。

発音は、尋ねる人によって異なります。 「too-ple」(「Mott the Hoople」と発音)と綴られているように発音する人もいれば、「tup-ple」(「supple」と発音)と綴られているように発音する人もいます。 私の傾向は後者であり、おそらく「五重奏」、「六重奏」、「八重奏」などと同じ起源に由来し、私が知っている人は皆、後者を「しなやか」と韻を踏むように発音します。

タプルの定義と使用

タプルは、次のプロパティを除き、すべての点でリストと同じです。

  • タプルは、角括弧( + [] +)ではなく括弧( ())で要素を囲むことで定義されます。

  • タプルは不変です。

タプルの定義、インデックス付け、およびスライスを示す短い例を次に示します。

>>>

>>> t = ('foo', 'bar', 'baz', 'qux', 'quux', 'corge')
>>> t
('foo', 'bar', 'baz', 'qux', 'quux', 'corge')

>>> t[0]
'foo'
>>> t[-1]
'corge'
>>> t[1::2]
('bar', 'qux', 'corge')

決して恐れるな! 私たちのお気に入りの文字列とリストの反転メカニズムはタプルでも機能します:

>>>

>>> t[::-1]
('corge', 'quux', 'qux', 'baz', 'bar', 'foo')

*注意:*括弧を使用してタプルが定義されていても、文字列とリストの場合と同様に、角括弧を使用してタプルをインデックス付けおよびスライスします。

リストについて学んだことはすべて、それらは順序付けられていて、任意のオブジェクトを含むことができ、インデックスを付けたりスライスしたり、ネストしたりできます。タプルについても同様です。 ただし、変更することはできません。

>>>

>>> t = ('foo', 'bar', 'baz', 'qux', 'quux', 'corge')
>>> t[2] = 'Bark!'
Traceback (most recent call last):
  File "<pyshell#65>", line 1, in <module>
    t[2] = 'Bark!'
TypeError: 'tuple' object does not support item assignment

リストの代わりにタプルを使用する理由

  • タプルを操作するときのプログラム実行は、同等のリストの場合よりも高速です。 (リストまたはタプルが小さい場合、これはおそらく目立たないでしょう。)

  • データを変更したくない場合があります。 コレクション内の値がプログラムの存続期間中一定である場合、リストの代わりにタプルを使用すると、偶発的な変更を防ぐことができます。 *辞書と呼ばれるもう1つのPythonデータ型があります。これは、そのコンポーネントの1つとして不変型の値を必要とします。 タプルはこの目的に使用できますが、リストは使用できません。

Python REPLセッションでは、複数のオブジェクトの値をコンマで区切って `+ >>> +`プロンプトに直接入力することにより、同時に表示できます。

>>>

>>> a = 'foo'
>>> b = 42
>>> a, 3.14159, b
('foo', 3.14159, 42)

Pythonは、入力を暗黙的にタプルとして解釈しているため、括弧内に応答を表示します。

タプルの定義に関して、注意する必要のある特徴が1つあります。 空のタプルを定義するとき、または2つ以上の要素を持つタプルを定義するとき、あいまいさはありません。 Pythonは、タプルを定義していることを知っています。

>>>

>>> t = ()
>>> type(t)
<class 'tuple'>

>>>

>>> t = (1, 2)
>>> type(t)
<class 'tuple'>
>>> t = (1, 2, 3, 4, 5)
>>> type(t)
<class 'tuple'>

しかし、1つのアイテムでタプルを定義しようとするとどうなりますか:

>>>

>>> t = (2)
>>> type(t)
<class 'int'>

_Doh!_式で演算子の優先順位を定義するためにも括弧が使用されるため、Pythonは式 (2)+`を単なる整数 `+ 2 +`として評価し、 `+ int +`オブジェクトを作成します。 Pythonにシングルトンのタプルを本当に定義したいことを伝えるには、閉じ括弧の直前に末尾のコンマ( `+、)を含めます。

>>>

>>> t = (2,)
>>> type(t)
<class 'tuple'>
>>> t[0]
2
>>> t[-1]
2

おそらくシングルトンのタプルを頻繁に定義する必要はありませんが、方法が必要です。

シングルトンのタプルを表示すると、Pythonにはコンマが含まれ、タプルであることを思い出させます。

>>>

>>> print(t)
(2,)

タプルの割り当て、パッキング、およびアンパッキング

すでに上で見たように、複数のアイテムを含むリテラルタプルを単一のオブジェクトに割り当てることができます。

>>>

>>> t = ('foo', 'bar', 'baz', 'qux')

これが発生すると、タプル内のアイテムがオブジェクトに「パック」されたようになります。

>>>

>>> t
('foo', 'bar', 'baz', 'qux')
>>> t[0]
'foo'
>>> t[-1]
'qux'

その「パック済み」オブジェクトがその後新しいタプルに割り当てられると、個々のアイテムはタプル内のオブジェクトに「アンパック」されます。

>>>

>>> (s1, s2, s3, s4) = t
>>> s1
'foo'
>>> s2
'bar'
>>> s3
'baz'
>>> s4
'qux'

展開するとき、左側の変数の数はタプルの値の数と一致する必要があります。

>>>

>>> (s1, s2, s3) = t
Traceback (most recent call last):
  File "<pyshell#16>", line 1, in <module>
    (s1, s2, s3) = t
ValueError: too many values to unpack (expected 3)

>>> (s1, s2, s3, s4, s5) = t
Traceback (most recent call last):
  File "<pyshell#17>", line 1, in <module>
    (s1, s2, s3, s4, s5) = t
ValueError: not enough values to unpack (expected 5, got 4)

パッキングとアンパッキングを1つのステートメントに結合して、複合割り当てを行うことができます。

>>>

>>> (s1, s2, s3, s4) = ('foo', 'bar', 'baz', 'qux')
>>> s1
'foo'
>>> s2
'bar'
>>> s3
'baz'
>>> s4
'qux'

繰り返しますが、割り当ての左側のタプル内の要素の数は、右側の数と等しくなければなりません。

>>>

>>> (s1, s2, s3, s4, s5) = ('foo', 'bar', 'baz', 'qux')
Traceback (most recent call last):
  File "<pyshell#63>", line 1, in <module>
    (s1, s2, s3, s4, s5) = ('foo', 'bar', 'baz', 'qux')
ValueError: not enough values to unpack (expected 5, got 4)

このような割り当てや、その他の少数の状況では、Pythonでは、タプルを示すために通常使用される括弧を除外できます。

>>>

>>> t = 1, 2, 3
>>> t
(1, 2, 3)

>>> x1, x2, x3 = t
>>> x1, x2, x3
(1, 2, 3)

>>> x1, x2, x3 = 4, 5, 6
>>> x1, x2, x3
(4, 5, 6)

>>> t = 2,
>>> t
(2,)

括弧が含まれていても含まれていなくても同じように機能するため、括弧が必要かどうか疑問がある場合は、括弧を含めてください。

タプルの割り当てにより、奇妙なちょっとした慣用的なPythonが可能になります。 多くの場合、プログラミング時には、値を交換する必要がある2つの変数があります。 ほとんどのプログラミング言語では、次のようにスワップが発生している間、一時変数に値の1つを保存する必要があります。

>>>

>>> a = 'foo'
>>> b = 'bar'
>>> a, b
('foo', 'bar')

>>># We need to define a temp variable to accomplish the swap.
>>> temp = a
>>> a = b
>>> b = temp

>>> a, b
('bar', 'foo')

Pythonでは、1つのタプル割り当てでスワップを実行できます。

>>>

>>> a = 'foo'
>>> b = 'bar'
>>> a, b
('foo', 'bar')

>>># Magic time!
>>> a, b = b, a

>>> a, b
('bar', 'foo')

一時変数を使用して値を交換する必要があった人なら誰でも知っているように、Pythonでこの方法で交換できることは、最新の技術的成果の頂点です。 これよりも良くなることはありません。

結論

このチュートリアルでは、Python* lists および *tuples の基本的なプロパティと、それらの操作方法について説明しました。 Pythonプログラミングでこれらを広範囲に使用します。

リストの主な特徴の1つは、リストが順序付けられていることです。 リスト内の要素の順序はそのリストの固有のプロパティであり、リスト自体が変更されない限り変更されません。 (タプルについても同様ですが、もちろん変更できません。)

次のチュートリアルでは、Python * dictionary:*を順不同の複合データ型として紹介します。 読む!

  • __クイズに挑戦:*インタラクティブな「Pythonリストとタプル」クイズで知識をテストします。 完了すると、学習の進捗状況を経時的に追跡できるようにスコアを受け取ります。

link:/quizzes/python-lists-tuples/[クイズに挑戦»]