インデックス

spamという名前の変数に['cat', 'bat', 'rat', 'elephant']というリストが格納されているとします。Pythonのspam[0]というコードは'cat'に評価され、spam[1]は'bat'に評価されます。リストに続く角かっこ内の整数はインデックスと呼ばれます。リストの最初の値はインデックス0で、2番目の値がインデックス1、3番目の値がインデックス2です。図6-1はspamに代入されたリスト値をインデックスとともに示しています。インデックスは0から始まりますから、最後のインデックスはリストのサイズより1小さくなります。4つの要素のリストの最後のインデックスは3です。

インデックスを試してみるために、次の式を対話型シェルに入力してください。変数spamにリストを代入するところから始めます。

>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam[0]
'cat'
>>> spam[1]
'bat'
>>> spam[2]
'rat'
>>> spam[3]
'elephant'
>>> ['cat', 'bat', 'rat', 'elephant'][3]
'elephant'
❶ >>> 'Hello, ' + spam[0]
❷ 'Hello, cat'
>>> 'The ' + spam[1] + ' ate the ' + spam[0] + '.'
'The bat ate the cat.'

式'Hello, ' + spam[0](❶)が'Hello, ' + 'cat'に評価されます。spam[0]が'cat'に評価されるからです。この式はさらに文字列'Hello, cat'に評価されます(❷)。

リストに入っている要素の個数を超えるインデックスを使うと、PythonはIndexError というエラーメッセージを表示します。

>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam[10000]
Traceback (most recent call last):
  File "<python-input-0>", line 1, in <module>
    spam[10000]
IndexError: list index out of range

リストの中にリストを入れることもできます。次のように、インデックスを複数書けば、リストの中のリストにアクセスできます。

>>> spam = [['cat', 'bat'], [10, 20, 30, 40, 50]]
>>> spam[0]
['cat', 'bat']
>>> spam[0][1]
'bat'
>>> spam[1][4]
50

最初のインデックスがどのリスト値かを指定し、2つ目のインデックスがそのリスト値の中の値を指し示します。例えば、spam[0][1]は'bat'になります。最初のリスト値の中の2番目の値です。

負の数のインデックス

インデックスは0から始まって増えていきますが、負の整数をインデックスに使うこともできます。対話型シェルで次のように入力してみてください。

>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam[-1]  # 最後のインデックス
'elephant'
>>> spam[-3]  # 最後から3番目のインデックス
'bat'
>>> 'The ' + spam[-1] + ' is afraid of the ' + spam[-3] + '.'
'The elephant is afraid of the bat.'

-1という整数はリストの最後のインデックスで、-2は最後から2番目のインデックスです。

スライス

インデックスでリストから1つの値を取り出せるように、スライスでリストから複数の値を新しいリストの形式で取り出せます。スライスは、インデックスと同じように、角カッコの中で指定しますが、コロンの前後に2つの数値が入ります。インデックスとスライスの違いは次のとおりです。

• spam[2]はリストのインデックスです（角かっこの中に整数が1つ）
• spam[1:4]はリストのスライスです（角かっこの中に整数が2つ）

スライスでは、最初の整数がスライスを開始するインデックスで、2つ目の整数がスライスを終了するインデックスです。スライスにより作られたリストは、2つ目の整数のインデックスが指す値まで元のリストを切り取りますが、その値は含みません。対話型シェルで次のように入力してみてください。

>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam[0:4]
['cat', 'bat', 'rat', 'elephant']
>>> spam[1:3]
['bat', 'rat']
>>> spam[0:-1]
['cat', 'bat', 'rat']

短縮記法として、コロンの片側あるいは両側のインデックスを省略できます。

>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam[:2]
['cat', 'bat']
>>> spam[1:]
['bat', 'rat', 'elephant']
>>> spam[:]
['cat', 'bat', 'rat', 'elephant']

最初のインデックス（コロンの左側）を省略すると、0を指定したのと同じになり、リストの最初からになります。2つ目のインデックス（コロンの右側）を省略すると、リストの長さを指定したのと同じになり、リストの最後までになります。

len()関数

len()関数にリスト値を渡すと、そのリストに入っている値の個数を返します。対話型シェルで次のように入力してみてください。

>>> spam = ['cat', 'dog', 'moose']
>>> len(spam)
3

これはこの関数が文字列値の文字数をカウントするのに似ています。

値の更新

通常、spam = 42のように、代入文の左側には変数名が来ます。リストのインデックスを使って、そのインデックスの値を変更することもできます。

>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam[1] = 'aardvark'
>>> spam
['cat', 'aardvark', 'rat', 'elephant']
>>> spam[2] = spam[1]
>>> spam
['cat', 'aardvark', 'aardvark', 'elephant']
>>> spam[-1] = 12345
>>> spam
['cat', 'aardvark', 'aardvark', 12345]

この例で、spam[1] = 'aardvark'は「リストspamのインデックス1の値に文字列'aardvark'を代入する」という意味になります。-1のような負の数をインデックスに指定して値を更新することもできます。

結合と繰り返し

+演算子と*演算子でリストの結合と繰り返しをできます。

>>> [1, 2, 3] + ['A', 'B', 'C']
[1, 2, 3, 'A', 'B', 'C']
>>> ['X', 'Y', 'Z'] * 3
['X', 'Y', 'Z', 'X', 'Y', 'Z', 'X', 'Y', 'Z']
>>> spam = [1, 2, 3]
>>> spam = spam + ['A', 'B', 'C']
>>> spam
[1, 2, 3, 'A', 'B', 'C']

+演算子は2つのリストを結合して新しいリスト値を作ります。*演算子はリストを整数回繰り返して結合します。

del文

del文はリストのインデックスを指定してその値を削除します。削除された値よりあとにある値はすべてインデックスが1つ繰り上がります。対話型シェルで次のように入力してみてください。

>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> del spam[2]
>>> spam
['cat', 'bat', 'elephant']
>>> del spam[2]
>>> spam
['cat', 'bat']

del文は「非代入」文のように変数自体を削除するのにも使えます。変数を削除してから使おうとすると、もうその変数は存在しなくなっているので、NameErrorエラーが発生します。実務的には、変数自体を削除する必要はまずありませんが、リストから値を削除するのにdel文は使えます。

forループとリスト

第3章では、forループを使ってコードのブロックを指定した回数だけ実行する方法を学習しました。技術的には、forループはコードブロックをリスト中の要素の個数回だけ繰り返し実行します。例えば、次のコードを実行してください。

for i in range(4):
    print(i)

このプログラムの出力は次のようになります。

0
1
2
3

range(4)が返す値は、[0, 1, 2, 3]と似たシーケンス値（連続値）です。以下のプログラムは上のプログラムと同じ出力になります。

for i in [0, 1, 2, 3]:
    print(i)

このforループは、変数iにリスト[0, 1, 2, 3]の値を順番に設定して節を実行します。

Pythonでは、forループでrange(len(some_list))を使ってリストのインデックスを反復処理することがよくあります。対話型シェルで次のように入力してみてください。

>>> supplies = ['pens', 'staplers', 'flamethrowers', 'binders']
>>> for i in range(len(supplies)):
...     print('Index ' + str(i) + ' in supplies is: ' + supplies[i])
...
Index 0 in supplies is: pens
Index 1 in supplies is: staplers
Index 2 in supplies is: flamethrowers
Index 3 in supplies is: binders

for ループでrange(len(supplies))を使うと、ループ中のコードでインデックス（i）とそのインデックスに対応する値（supplies[i]）の両方にアクセスできるので便利です。何と言っても、range(len(supplies))はリストsuppliesの中に入っている要素の個数に関わらずすべてのインデックスを反復処理できます。

in演算子とnot in演算子

in演算子とnot in演算子を使うと、ある値がリストの中に入っているかどうかを判定できます。他の演算子と同様に、inとnot inは式中の2つの値の間で使います。探す値と探すリストの間で使います。その式はブール値に評価されます。対話型シェルに以下のコードを入力して確かめてみましょう。

>>> 'howdy' in ['hello', 'hi', 'howdy', 'heyas']
True
>>> spam = ['hello', 'hi', 'howdy', 'heyas']
>>> 'cat' in spam
False
>>> 'howdy' not in spam
False
>>> 'cat' not in spam
True

以下のプログラムは、ユーザーが入力したペットの名前がリストの中にあるかどうかを判定します。新しいファイルエディタウィンドウを開いて、以下のコードをmyPets.pyという名前で保存してください。

my_pets = ['Zophie', 'Pooka', 'Fat-tail']
print('Enter a pet name:')
name = input()
if name not in my_pets:
    print('I do not have a pet named ' + name)
else:
    print(name + ' is my pet.')

出力は次のようになります。

Enter a pet name:
Footfoot
I do not have a pet named Footfoot

not in演算子はnotブール演算子と別物であることに注意してください。

多重代入

多重代入は、技術的にはタプルアンパックと呼ばれますが、複数の変数にリストの値を1行で代入する短縮記法です。次のようにする代わりに

>>> cat = ['fat', 'gray', 'loud']
>>> size = cat[0]
>>> color = cat[1]
>>> disposition = cat[2]

次のようにできるということです。

>>> cat = ['fat', 'gray', 'loud']
>>> size, color, disposition = cat

変数の個数とリストの要素数は一致しなければなりません。一致しなければValueErrorエラーが発生します。

>>> cat = ['fat', 'gray', 'loud']
>>> size, color, disposition, name = cat
Traceback (most recent call last):
  File "<python-input-0>", line 1, in <module>
    size, color, disposition, name = cat
ValueError: not enough values to unpack (expected 4, got 3)

多重代入を使うと複数行で代入するよりもコードが短く読みやすくなります。

リストの要素の数え上げ

forループでリストの要素のインデックスを取得するのに、range(len(some_list))の代わりに、enumerate()関数を呼び出すこともできます。ループの反復ごとに、enumerate()は、リストの要素のインデックスと要素そのものの2つの値を返します。例えば、このコードは「forループとリスト」で紹介したコードと同じ動きをします。

>>> supplies = ['pens', 'staplers', 'flamethrowers', 'binders']
>>> for index, item in enumerate(supplies):
...     print('Index ' + str(index) + ' in supplies is: ' + item)
...
Index 0 in supplies is: pens
Index 1 in supplies is: staplers
Index 2 in supplies is: flamethrowers
Index 3 in supplies is: binders

ループで要素と要素のインデックスの両方が必要な場合に、enumerate()関数が役立ちます。

ランダム選択と順序

randomモジュールにはリストを引数に取る関数がいくつかあります。random.choice()関数はリストから要素をランダムに選んで返します。以下の式を対話型シェルに入力してみてください。

>>> import random
>>> pets = ['Dog', 'Cat', 'Moose']
>>> random.choice(pets)
'Cat'
>>> random.choice(pets)
'Cat'
>>> random.choice(pets)
'Dog'

random.choice(some_list)はsome_list[random.randint(0, len(some_list) – 1]を簡単に書いたものだと考えられます。

random.shuffle()関数はリストの要素の順番をその場でシャッフルします。以下の式を対話型シェルに入力してみてください。

>>> import random
>>> people = ['Alice', 'Bob', 'Carol', 'David']
>>> random.shuffle(people)
>>> people
['Carol', 'David', 'Alice', 'Bob']
>>> random.shuffle(people)
>>> people
['Alice', 'David', 'Bob', 'Carol']

この関数は、新しいリストを返すのではなく、リストをその場で変更します。

値の検索

リスト値には値を渡せるindex()メソッドがあります。その値がリストの中に存在すれば、その値のインデックスを返します。その値がリストの中に存在しなければ、ValueErrorエラーが発生します。以下の式を対話型シェルに入力してみてください。

>>> spam = ['hello', 'hi', 'howdy', 'heyas']
>>> spam.index('hello')
0
>>> spam.index('heyas')
3
>>> spam.index('howdy howdy howdy')
Traceback (most recent call last):
  File "<python-input-0>", line 1, in <module>
    spam.index('howdy howdy howdy')
ValueError: 'howdy howdy howdy' is not in list

その値がリストの中に複数存在すれば、最初に見つかった値のインデックスを返します。

>>> spam = ['Zophie', 'Pooka', 'Fat-tail', 'Pooka']
>>> spam.index('Pooka')
1

index()は3ではなく1を返します。

値の追加

リストに新しい値を追加するには、append()メソッドとinsert()メソッドを使います。append()メソッドはリストの最後に値を追加します。

>>> spam = ['cat', 'dog', 'bat']
>>> spam.append('moose')
>>> spam
['cat', 'dog', 'bat', 'moose']

insert()メソッドは、リストのどこにでも値を追加することができます。insert()の第一引数は値を挿入するインデックスで、第二引数は挿入する値です。以下の式を対話型シェルに入力してみてください。

>>> spam = ['cat', 'dog', 'bat']
>>> spam.insert(1, 'chicken')
>>> spam
['cat', 'chicken', 'dog', 'bat']

これは、spam = spam.append('moose')やspam = spam.insert(1, 'chicken')のような代入文ではないことに注意してください。append()とinsert()の返り値はNoneですので、それを新しい変数の値として格納することはないでしょう。これらのメソッドはリストをその場で変更します。「ミュータブルとイミュータブル」で詳しく説明します。

データ型ごとにメソッドがあります。append()とinsert()はリストメソッドで、リスト値についてのみ呼び出せます。文字列値や整数値について呼び出すことはできません。そのようなことをしようとするとどうなるか、対話型シェルで以下のコードを入力して確かめてみます。

>>> eggs = 'hello'
>>> eggs.append('world')
Traceback (most recent call last):
  File "<python-input-0>", line 1, in <module>
    eggs.append('world')
AttributeError: 'str' object has no attribute 'append'
>>> bacon = 42
>>> bacon.insert(1, 'world')
Traceback (most recent call last):
  File "<python-input-0>", line 1, in <module>
    bacon.insert(1, 'world')
AttributeError: 'int' object has no attribute 'insert'

AttributeErrorエラーメッセージが表示されます。

値の削除

remove()メソッドはリストから削除したい値を引数に取ります。

>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam.remove('bat')
>>> spam
['cat', 'rat', 'elephant']

リストの中に存在しない値を削除しようとすると、ValueErrorエラーが発生します。例えば、対話型シェルで次のように入力して、エラーメッセージが表示されるのを確認してください。

>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam.remove('chicken')
Traceback (most recent call last):
  File "<python-input-0>", line 1, in <module>
    spam.remove('chicken')
ValueError: list.remove(x): x not in list

リストの中に複数回登場する値については、最初の値のみが削除されます。

>>> spam = ['cat', 'bat', 'rat', 'cat', 'hat', 'cat']
>>> spam.remove('cat')
>>> spam
['bat', 'rat', 'cat', 'hat', 'cat']

リストから削除したい値のインデックスがわかっている場合はdel文を使い、値をもとに削除したい場合はremove()メソッドを使います。

値の並べ替え

数値のリストまたは文字列のリストについては、sort()メソッドで並べ替えできます。対話型シェルで次のように入力してみてください。

>>> spam = [2, 5, 3.14, 1, -7]
>>> spam.sort()
>>> spam
[-7, 1, 2, 3.14, 5]
>>> spam = ['Ants', 'Cats', 'Dogs', 'Badgers', 'Elephants']
>>> spam.sort()
>>> spam
['Ants', 'Badgers', 'Cats', 'Dogs', 'Elephants']

数値については小さい順、文字列についてはアルファベット順に並べ替えます。reverseキーワード引数（名前付きパラメータ）にTrueを渡すと、値を逆順に並べ替えられます。

>>> spam.sort(reverse=True)
>>> spam
['Elephants', 'Dogs', 'Cats', 'Badgers', 'Ants']

sort()メソッドについては次の3点に注意してください。第一に、リストをその場で並べ替えますので、spam = spam.sort()のように返り値を変数に格納しないでください。

第二に、数値と文字列値が混在しているリストを並べ替えることはできません。どのように並べ替えたらよいかわからないからです。以下のコードを対話型シェルに入力すると、 TypeErrorエラーが発生します。

>>> spam = [1, 3, 2, 4, 'Alice', 'Bob']
>>> spam.sort()
Traceback (most recent call last):
  File "<python-input-0>", line 1, in <module>
    spam.sort()
TypeError: '<' not supported between instances of 'str' and 'int'

第三に、文字列については、正確に言うと、アルファベット順ではなくASCII順に並べ替えます。大文字は小文字の後に来るので、小文字のaは大文字のZの後に来ます。例えば、次のように対話型シェルに入力してください。

>>> spam = ['Alice', 'ants', 'Bob', 'badgers', 'Carol', 'cats']
>>> spam.sort()
>>> spam
['Alice', 'Bob', 'Carol', 'ants', 'badgers', 'cats']

アルファベット順に値を並べ替えたければ、sort()メソッドを呼び出すときに、キーワード引数keyにstr.lowerを渡してください。

>>> spam = ['a', 'z', 'A', 'Z']
>>> spam.sort(key=str.lower)
>>> spam
['a', 'A', 'z', 'Z']

この引数は、リストの中に入っている値を変更しませんが、あたかもすべて小文字であるかのように扱います。

値を逆の順番にする

リストの中に入っている要素の順番を逆にする必要があれば、reverse()リストメソッドを呼び出します。以下の式を対話型シェルに入力してみてください。

>>> spam = ['cat', 'dog', 'moose']
>>> spam.reverse()
>>> spam
['moose', 'dog', 'cat']

sort()リストメソットと同様に、reverse()はリストを返しません。ですので、spam = spam.reverse()ではなくspam.reverse()と書きます。

ミュータブルとイミュータブル

リストと文字列には大きな違いが一つあります。リスト値はミュータブルです。つまり、値の追加、削除、更新ができます。これに対し、文字列はイミュータブルで、変更できません。文字列に文字を再代入しようとしたら、TypeErrorエラーが発生します。以下の対話型シェルで確認してください。

>>> name = 'Zophie a cat'
>>> name[7] = 'the'
Traceback (most recent call last):
  File "<python-input-0>", line 1, in <module>
    name[7] = 'the'
TypeError: 'str' object does not support item assignment

文字列を「変化」させる正しいやり方は、スライスと結合を用いて新しい文字列を組み立てるというやり方です。

>>> name = 'Zophie a cat'
>>> new_name = name[0:7] + 'the' + name[8:12]
>>> name
'Zophie a cat'
>>> new_name
'Zophie the cat'

[0:7]と[8:12]で変化させない文字を取得しています。元の'Zophie a cat'という文字列に手を加えていないことに注意してください。文字列はイミュータブルです。

リスト値はミュータブルで変更できるのですが、次のコードの2行目はリストeggsを変更していません。

>>> eggs = ['A', 'B', 'C']
>>> eggs = ['x', 'y', 'z']
>>> eggs
['x', 'y', 'z']

eggsの中に入っている値は変更されていません。そうではなく、全く新しい別のリスト値（['x', 'y', 'z']）が古いリスト値（['A', 'B', 'C']）に置き換わっています。

元のリストeggsの中に入っている値を['x', 'y', 'z']に変更する場合は、del文とappend()メソッドを使い、このように行います。

>>> eggs = ['A', 'B', 'C']
>>> del eggs[2]
>>> del eggs[1]
>>> del eggs[0]
>>> eggs.append('x')
>>> eggs.append('y')
>>> eggs.append('z')
>>> eggs
['x', 'y', 'z']

この例では、変数eggsが同じリスト値のままです。上書きされたのではなく変更されました。リストのその場での変更です。

ミュータブルとイミュータブルを区別することに意義が感じられないかもしれませんが、「参照」で関数の引数に取ったときの違いを説明します。 その前にイミュータブルなリストであるタプル型を紹介します。

タプル型

タプル型とリスト型には2つの違いしかありません。1つ目の違いは、タプルは角かっこではなく丸かっこで作成するという点です。対話型シェルで次のように入力してみてください。

>>> eggs = ('hello', 42, 0.5)
>>> eggs[0]
'hello'
>>> eggs[1:3]
(42, 0.5)
>>> len(eggs)
3

2つ目の違いは、リストはミュータブルであるのに対し、タプルは文字列と同じようにイミュータブルだという点です。値の変更、追加、削除はできません。　以下のコードを対話型シェルに入力すると、TypeErrorエラーが発生します。

>>> eggs = ('hello', 42, 0.5)
>>> eggs[1] = 99
Traceback (most recent call last):
  File "<python-input-0>", line 1, in <module>
    eggs[1] = 99
TypeError: 'tuple' object does not support item assignment

要素を1つだけ持つタプルを作成する場合は、丸かっこ内の値のあとにカンマを入れてください。そうしないと、Pythonは値に丸かっこを付けたものだと解釈します（Pythonでは、他のプログラミング言語とは異なり、リストやタプルの最後の要素のあとにカンマを入れることができます）。type()関数を呼び出している、以下の対話型シェルの実行で確認してください。

>>> type(('hello',))
<class 'tuple'>
>>> type(('hello'))
<class 'str'>

タプルを使うと、そのシーケンス型では値の変更を意図していないことをコードの読み手に伝えられます。決して変更されないシーケンス型の値が必要な場合はタプルを使いましょう。リストではなくタプルを使えば、イミュータブルで変更されないために最適化されており、リストよりも少し速く実行できるという利点もあります。

リストとタプルの変換

str(42)が整数42の文字列表現である'42'を返すのと同じように、list()とtuple()はそれぞれ渡された値のリストとタプルを返します。以下のコードを対話型シェルに入力すると、返り値のデータ型が渡された値のデータ型と違っていることがわかります。

>>> tuple(['cat', 'dog', 5])
('cat', 'dog', 5)
>>> list(('cat', 'dog', 5))
['cat', 'dog', 5]
>>> list('hello')
['h', 'e', 'l', 'l', 'o']

タプルをミュータブルにしたければリストに変換します。

引数

引数がどのようにして関数に渡されるかを理解するのに、参照という概念は特に重要です。関数が呼び出されると、Pythonは引数への参照をパラメータ変数にコピーします。（第7章で説明する辞書や）リストのようなミュータブルな値であれば、関数内のコードが元の値をその場で変更することを意味します。この事実の帰結を確認するために、新しいファイルエディタウィンドウを開いて以下のコードをpassingReference.pyという名前で保存してください。

def eggs(some_parameter):
    some_parameter.append('Hello')

spam = [1, 2, 3]
eggs(spam)
print(spam)  # [1, 2, 3, 'Hello']を表示

eggs()を呼び出したときに、返り値にspamの新しい値を代入していないことに注意してください。そうではなく、直接リストをその場で変更しています。このプログラムを実行すると、[1, 2, 3, 'Hello']と表示します。

spamとsome_parameterは別々の参照ではありますが、同じリストを参照しています。そのため、関数呼び出しが終わっても、関数内でのappend('Hello')メソッドの呼び出しがリストに影響します。

この振る舞いを覚えておいてください。Pythonがリストや辞書をこのように扱うという事実を忘れると、予期せぬ振る舞いや混乱させられるようなバグにつながりかねません。

copy()関数とdeepcopy()関数

リストと辞書に関して参照を関数に渡すのが簡便ではありますが、渡されたリストや辞書が関数内で変更される場合に、その変更が元のリストや辞書に反映されてほしくないこともあるでしょう。この振る舞いに対処するために、Pythonにはcopy()関数とdeepcopy()関数を提供するcopyモジュールがあります。前者のcopy.copy()はリストや辞書のようなミュータブルな値のコピーを作成します。参照のコピーではありません。以下の式を対話型シェルに入力してみてください。

>>> import copy
>>> spam = ['A', 'B', 'C']
>>> cheese = copy.copy(spam)  # リスト自体の複製を作成する
>>> cheese[1] = 42  # cheeseを変更
>>> spam  # 変数spamは変更されていない
['A', 'B', 'C']
>>> cheese  # 変数cheeseは変更されている
['A', 42, 'C']

変数spamとcheeseは別々のリストを参照しています。よって、cheeseのインデックス1に42を代入しても、その変数の中にある値しか変更されません。

変数が値を格納するのではなく値を参照するのと同じように、リストは値そのものではなく値への参照を保持します。図6-4をご覧ください。

コピーしたいリストがその中にリストを保持しているときは（入れ子のリストになっているときは）、copy.copy()ではなくcopy.deepcopy()を使ってください。copy.deepcopy()関数は内側のリストもコピーします。

カンマコード

次のようなリスト値があるとします。

spam = ['apples', 'bananas', 'tofu', 'cats']

リスト値を引数に取り、すべての要素をカンマで区切って、最後の区切りにはandを加える関数を作成してください。例えば、上記のspamリストをその関数に渡すと'apples, bananas, tofu, and cats'が返されます。このリストに限らず、どのリストを渡しても動作する関数を書いてください。空リスト[]を渡した場合も考慮してください。

連続コイン投げ

連続したコイン投げの実験をします。100回コインを投げて、表が出たらHを、裏が出たらT を記入します。T T T T H H H H T Tのような結果を得ます。100回のランダムなコイン投げの結果を書いてくださいと人間に頼むと、H T H T H H T H T Tのような表と裏の入れ替わりの多い結果を書きがちです。これは（人間にとっては）ランダムに見えますが、数学的にはランダムではありません。人間は6連続の表または裏をめったに書きませんが、本当にランダムなコイン投げだとそれが十分に起こり得ます。人間はランダムが苦手です。

ランダムに生成された100回分の表または裏の結果について、6連続の表または裏がどれくらいの頻度で出現するかを確かめるプログラムを書いてください。プログラムは2つの部分に分けられます。100個のランダムに選んだ'H'または'T'の値のリストを生成する部分と、6連続の表または裏があるかどうかを確かめる部分です。実験を10,000回行うループの中にその2つの部分のコードを入れてください。そうすれば、どれくらいのパーセンテージで6連続の表または裏を含むかを算出できます。ヒントとして、random.randint(0, 1)関数を呼び出すと、半々の確率で0または1を返します。

以下のテンプレートをご活用ください。

import random
number_of_streaks = 0
for experiment_number in range(10000):  # 合計10,000回の実験を実行
    # 100個の表または裏の値のリストを作成するコード

    # 6連続の表または裏があるかどうかをチェックするコード

print('Chance of streak: %s%%' % (number_of_streaks / 100))

もちろん、これは推計に過ぎませんが、10,000回実験すればサンプルサイズとしては十分でしょう。数学の知識があればプログラムを書かずに正確な答えを出せるかもしれません（プログラマには数学が得意ではない人が多いです）。

forループでランダムに選んだ'H'または'T'を100回リストに追加してください。6連続の表または裏があるかどうかを判定するには、some_list[i:i + 6]のようなスライス（インデックスiから始まる6つの要素を含むリスト）を作成し、['H', 'H', 'H', 'H', 'H', 'H']または['T', 'T', 'T', 'T', 'T', 'T']と比較します。