スマホ版は別ページ→

≪いっしょにPython≫　プログラマーの実験ノート

　このページは，プログラム言語Pythonをこれから学ぼうと考えている筆者の備忘録です．
　そこそこ調べて書いていますが，仕様を精密に調べたものではありません．どちらかと言えば，実装されたPython 3を使ってみてどうなったかということを中心に書いたものです．いわば，実験ノートの記録です．（最終更新年月日：2019.5.3 / by Python 3.7.3）

Pythonの練習には，
の３通りが使えるが，以下は(2)のNew Fileから，テキストエディタを使って，プログラムを書く場合を考える．

• Pythonでは，よく使われる関数が組み込み関数（ビルドイン関数）になっており，何らかの外部モジュールをインポートしなくても，どの場面でも使えるようになっている．

【書式】
• リストを作成するには，角括弧（ブラケット）を使って直接定義する方法
の他に，タプル，文字列，集合，辞書などの他のデータ型で定義されているものをリスト型に直す方法もある．
• list()関数を使えば，他のデータ型で定義されているものをリスト型に直せる．
• リスト型で定義されているものにlist()関数を適用してもエラーにはならず，元のリストのコピーが返される（値のコピーなので，元のリストを変更しても変換後のリストは影響を受けない）．

タプル→リスト
【例 10.1】

tp1 = ('a','b','c','d')
L1 = list(tp1)
print(L1)
print(tp1)

→
['a', 'b', 'c', 'd']
('a', 'b', 'c', 'd')
• タプル型からリスト型が作られるが,元のタプルはなくならない．

文字列→リスト
【例 10.2】

str1 = 'abcd'
str2 = 'ABC','XY'
L1 = list(str1)
L2 = list(str2)
print(L1)
print(str1)
print(L2)
print(str2)

→
['a', 'b', 'c', 'd']
abcd
['ABC', 'XY']
('ABC', 'XY')
• str1は文字列で，list()により1文字ずつを要素とするリストになる．
• str2は，カンマで区切られているから，元のデータは文字列のタプル，すなわち，str2 = ('ABC','XY')であり，list()によって1文字ずつにはならず，2つの単語になる．

集合→リスト
【例 10.3】

set1 = {'x','yz','uvw'}
L1 = list(set1)
print(L1)
print(set1)

→
['uvw', 'x', 'yz']
{'uvw', 'x', 'yz'}
• 集合の要素は，並び方が決まっていないという特徴があり，list()で変換した瞬間の並び方を反映したリストになる．もう一度変換すると，別の並び方のリストができる（ことが多い）

辞書→リスト
【例 10.4】

d1 = {'3':'boy','2':'am', '1':'I'}
L1 = list(d1)
print(L1)
print(d1)

→
['3', '2', '1']
{'3': 'boy', '2': 'am', '1': 'I'}
• 辞書をリストに変換すると，キーだけのリストになり，値は付いて来ない．

リスト→リスト
【例 10.5】

L1 = [4,5,6]
L2 = list(L1)
L3 = L1
print(L1,L2)
print(id(L1),id(L2), id(L3))
L1[1] = 7
print(L1,L2, L3)

→
[4, 5, 6] [4, 5, 6]
45660120 47506256 45660120
[4, 7, 6] [4, 5, 6] [4, 7, 6]
• L1→L2のようにlist()を使って変換すると，値のコピーとなって別のメモリアドレス（上記のid()はメモリアドレスの10進表示）にリストが作られる．したがって，L1[1] = 7のように，元のリストの一部を書き換えても，変換でできたリストL2は影響を受けない．
• これに対して，L3 = L1のようにリストを代入すると，参照渡しになり同じメモリアドレスを持つ．このため，L1[1] = 7のように，元のリストの一部を書き換えると，L3も書き換わる．

【書式】
• タプルを作成するには，丸括弧（パーレン）を使って直接定義する方法
の他に，リスト，文字列，集合，辞書などの他のデータ型で定義されているものをタプル型に直す方法もある．
• tuple()関数を使えば，他のデータ型で定義されているものをタプル型に直せる．
• タプル型で定義されているものにtuple()関数を適用してもエラーにはならず，元のタプルの参照が返される（同じメモリアドレスを指し示す）．

リスト→タプル
【例 11.1】

L1 = [4,5,6]
t2 = tuple(L1)
print(t2)
print(L1)

→
(4, 5, 6)
[4, 5, 6]
• リスト型からタプル型が作られるが,元のリストはなくならない．

文字列→タプル
【例 11.2】

str1 = 'My pen.'
t1 = tuple(str1)
print(t1)
print(str1)

→
('M', 'y', ' ', 'p', 'e', 'n', '.')
My pen.
• 文字列をタプルに変換すると，半角スペースやピリオドも1文字ごとの要素になる．

集合→タプル
【例 11.3】

s1 = {'ab','c','def'}
t1 = tuple(s1)
print(t1)
print(s1)

→
('def', 'ab', 'c')
{'def', 'ab', 'c'}
• 集合の要素は，並び方が決まっていないという特徴があり，list()で変換した場合と同様に，その瞬間の並び方を反映したタプルになる．もう一度変換すると，別の並び方のタプルができる（ことが多い）

辞書→タプル
【例 11.4】

d1 = {'2':'ab','1':'c','3':'def'}
t1 = tuple(d1)
print(t1)
print(d1)

→
('2', '1', '3')
{'2': 'ab', '1': 'c', '3': 'def'}
• 辞書をタプルに変換すると，キーだけのタプルになり，値は付いて来ない．

タプル→タプル
【例 11.5】

t1 = ('xy','a','stu')#1
t2 = tuple(t1)#2
t3 = t1#3
print(t1,t2, t3)
print(id(t1),id(t2),id(t3))
t3 = ('b','yz','pqr')#4
print(t1,t2, t3)
print(id(t1),id(t2),id(t3))

→
('xy', 'a', 'stu') ('xy', 'a', 'stu') ('xy', 'a', 'stu')
41882648 41882648 41882648
('xy', 'a', 'stu') ('xy', 'a', 'stu') ('b', 'yz', 'pqr')
51551848 51551848 46273600
• タプルをtuple()を使ってタプルに変換すると，同じタプルの参照になる．t3 = t1のように代入したときも同様になる．
• タプルはイミュータブル（一部書き換えや追加ができない）であるが，t3 = ('b','yz','pqr')のように，代入によって全部書き換えすることはできる．この場合，t3だけが書き換わり，t1, t2は影響を受けない．
• #1によってt1は('xy','a','stu')のデータのあるメモリアドレスを参照するようになる．次に，#2によって､t2も同じメモリアドレスを参照するようになり，#3により，t3も同じメモリアドレスを参照するようになる．ここで，#4の代入を行うと，t3は('b','yz','pqr')のデータのあるメモリアドレスを参照するようになるが，t1,t2の参照先は変わらない．

【書式】
• 辞書型は，１つの要素が，キーと値の２つのものから成り立っている．
• ２つの要素が組になっているデータをdict()関数で取り込むと，辞書が作れる．３つ，４つの要素になっているとエラーになる．

2文字ずつの文字列からなるリスト→辞書
【例 12.1】

L1 = ['1a','2b','3c','2d']
d1 = dict(L1)
print(d1)

→
{'1': 'a', '2': 'd', '3': 'c'}
• 辞書型では，同じキーの要素は存在できないので，'2':'b', '2':'d'のように初めのもの'2'が同じ場合，後の要素'2':'d'は辞書に入れない．
• L1 = ['1ax','2byz','3c','4d']の場合，'1ax','2byz'の文字列の長さが3,4となっているから，dict()で辞書型にすることはできない．

2要素ずつのリストからなるリスト→辞書
【例 12.2】

L1 = [['b','boy'],['c','cat'],['d','door']]
d1 = dict(L1)
print(d1)

→
{'b': 'boy', 'c': 'cat', 'd': 'door'}

2要素ずつのタプルからなるリスト→辞書
【例 12.3】

L1 = [(1,'a'),(2,'xy'),(3,'pqr')]
d1 = dict(L1)
print(d1)

→
{1: 'a', 2: 'xy', 3: 'pqr'}

辞書→辞書
【例 12.4】

d1 = {1:'ab',2:'xy',3:'pq'}
d2 = dict(d1)#1
print(d1, id(d1),d2,id(d2))
d2[2] = 'STU'
print(d1, id(d1),d2,id(d2))

→
{1: 'ab', 2: 'xy', 3: 'pq'} 47570640 {1: 'ab', 2: 'xy', 3: 'pq'} 46745520
{1: 'ab', 2: 'xy', 3: 'pq'} 47570640 {1: 'ab', 2: 'STU', 3: 'pq'} 46745520
• 辞書型のデータをdict()に渡してもエラーにならずに，値をコピーした別の辞書ができる．
• 別の辞書なので，一方を書き換えても他方は影響されない．
• #1の箇所を，d2 = d1という形で代入で行うと，参照のコピーになり，一方を書き換えると他方も変わる．

【書式】
• str()関数は，int型，float型のような数値型のデータを文字列型に変換したり，バイナリデータを文字列に変換するのが本来の使い方だと考えられるが，リスト型，辞書型などにも使える．

【例 13.1】

n1 = 12
L1 = ['a',3,5]
t1 = ('b',4)
s1 = {'x','y','z'}
d1 = {4:'A', 5:'B'}
str1 = str(n1)
str2 = str(L1)
str3 = str(t1)
str4 = str(s1)
str5 = str(d1)
print(str1,str2,str3,str4,str5)
print(len(str1),len(str2),len(str3),len(str4),len(str5))

→
12 ['a', 3, 5] ('b', 4) {'y', 'x', 'z'} {4: 'A', 5: 'B'}
2 11 8 15 16
• print()だけでは何も変わっていないように見えるが，int型のn1は'12'という文字列に変わる．
• リスト型の['a',3,5]は，リストという意味ではなくて，ブラケットという文字（[），引用符という文字（'），aという文字（a），...のように各々の記号が単なる文字データとして扱われる．例えば，['a', 3, 5]の文字列長が11になるのは，3の前のスペースを1文字と数え，5の前のスペースも1文字と数える．
• 他のデータもlen()関数の出力と照らしてみると分かる．

文字列→文字列の場合
【例 13.2】

str1 = 'abcd'
str2 = str(str1)#1
str3 = str1#2
print(str1, id(str1),str2,id(str2))
print(str3,id(str3))
str1 = 'AB'#3
print(str1, id(str1),str2,id(str2))
print(str3,id(str3))

→
abcd 51853984 abcd 51853984
abcd 51853984
AB 51853888 abcd 51853984
abcd 51853984
• #1のように文字列をstr()で変換すると，＃2のように代入した場合と同様に，メモリアドレスの参照のコピーになる．
• str1,str2,str3の参照しているメモリアドレスが同じ場合に，#3のようにstr1に別の文字列を代入すると，str1の参照先だけが変わる．

【書式】
• リスト，タプル，文字列，辞書，集合はset()関数で集合を作成する． • フローズンセットは，照合に対応するイミュータブルなオブジェクトで，作成後に一部書き換えや追加はできない．

リスト，タプル，文字列，辞書，集合→集合，フローズンセットの場合
【例 14.1】

L1 =[1,2,3]
s1 = set(L1)
print(L1,s1)#1
t1 = (4,5,6)
s2 = set(t1)
print(t1,s2)#2
str1 = 'abc'
s3 = set(str1)
print(str1,s3)#3
d1 = {1:'a',2:'b'}
s4 = set(d1)
print(d1,s4)#4
set1 = {7,8,9}
s5 = set(set1)
print(set1, s5)#5

→
[1, 2, 3] {1, 2, 3}
(4, 5, 6) {4, 5, 6}
abc {'a', 'b', 'c'}
{1: 'a', 2: 'b'} {1, 2}
{8, 9, 7} {8, 9, 7}
※集合には，同じ要素は入らない（以下に共通）
• #1 1次元のリストは，各要素を並べた集合になる
• #2 1次元のタプルは，各要素を並べた集合になる
• #3 文字列は，1文字ずつの集合になる
• #4 辞書は，キーだけの集合になる
• #5 集合は，集合になる（並び方は決まらない）

各々frozenset()としても同様の結果が得られる

元のデータがネスト（入れ子）になっている場合
【例 14.2】

L1 =[[1,2],[3,4]]
s1 = set(L1)#1
print(L1,s1)
t1 = ((4,5),(6,7))
s2 = set(t1)#2
print(t1,s2)
str1 = ['abc','def']
s3 = set(str1)#3
print(str1,s3)

→
#1 エラー
#2 ((4, 5), (6, 7)) {(4, 5), (6, 7)}
#3 ['abc', 'def'] {'abc', 'def'}
• 元のデータがネスト（入れ子）になっていても集合に変換できるが，#1のようにリストのリストを集合に変換するとエラーになる．
• 詳しく言えば，小さい区切りがリスト，辞書，集合のようなミュータブルなデータになっているものは，集合になってからその要素が書き換えられることになり，同一要素がある集合は存在できないという条件を満たさなくなる恐れがある．このようなものは集合に変換できない．逆に，小さい方の区切りが，タプル，文字列のようなイミュータブルなデータであるものは，入れ子になっていても構わない．

集合→集合の場合
【例 14.3】

s1 = {1,2,3}
s2 = set(s1)#1
print(s1,id(s1),s2,id(s2))
s1.discard(2)#2
s1.add(4)#3
print(s1,id(s1),s2,id(s2))

s3 = s1#4
print(s1,id(s1),s3,id(s3))
s1.discard(1)#5
s1.add(5)#6
print(s1,id(s1),s3,id(s3))

→
{1, 2, 3} 46417360 {1, 2, 3} 46417240
{1, 3, 4} 46417360 {1, 2, 3} 46417240
{1, 3, 4} 46417360 {1, 3, 4} 46417360
{3, 4, 5} 46417360 {3, 4, 5} 46417360
• #1のようにs2 = set(s1)で集合s2を作成すると，s1の値をコピーした別の集合ができるので，#2,#3のようにs1の要素の一部を変更してもs2には影響はない．（集合の要素はs1[offset]のような番号では参照できない．集合s1の要素nを削除するには，s1.discard(n)，集合s1に要素mを追加するには，s1.add(m)とする）
• #4のように，s3 = s1という形で，変数を代入する形で集合s3を作成すると，参照のコピー（メモリアドレスのコピー）になり，s1の要素を書き換えると，s3の要素も書き換わる．
• これに対して，s3 = {1,2,3}という形で新たに集合のリテラルを代入して，集合s3を作成すると，見かけの値はs1と同じに見えても，s3は新たな集合リテラルのメモリアドレスを指すので，s1を書き換えてもs3は影響を受けない．

≪値のコピー，参照コピー≫まとめ

以下において，リテラルとは，文字列'abc'や数値の3, 3.14のように直接書き込まれた生のデータのことをいう．

• 以下において，イテラブルとは，リスト，タプル，文字列，辞書，集合のように，要素を１つずつ取り出すことができるオブジェクトのこととする．
• イテラブルなオブジェクトに対しては，
• リスト，タプル，文字列，辞書，集合は，そのままではイテレータではないが，イテレータにすれば

【書式】
• イテレータは，それぞれの要素に対して「次」の要素を取り出せる仕組みになっているオブジェクトです．
• イテレータに対しては，for文が利用できる．
• イテレータを作成するには， がある．

（参考）イテラブルなオブジェクトの要素はfor文で取り出せる
【例 15.1】

L1 = ['Sun','Mon','Tue']
for x in L1:
    print(x, end=' ')
T1 = ('Jan','Feb','Mar')
for y in T1:
    print(y, end=' ')
str1 = 'Sunday'
for s in str1:
    print(s, end=' ')
d1 = {3:'Wed', 4:'Thu', 5:'Fri'}
for z in d1:#1
    print(z, end=' ')
for v in d1.values():#2
    print(v, end=' ')
for k,v in d1.items():#3
    print(k,v, sep=':', end=' ')
S1 = {'Apr','May','Jun'}
for m in S1:
    print(m, end=' ')

→
Sun Mon Tue
Jan Feb Mar
S u n d a y
Wed Thu Fri
3:Wed 4:Thu 5:Fri
Jun Apr May
• forの後にはイテラブルなオブジェクトの１つの要素を仮引数として書く．
• 文字列では，この形で1文字ずつ取り出される．
• #1 辞書では，この形でキーだけが取り出される．これは，for z in d1.keys():とした場合と同じになる．
• #2 辞書の値をとりだすには，for v in d1.values():とする．
• #3 辞書のキーと値の２つとも取り出すには，２つの仮引数を用いて，for k,v in d1.items():とする．
• 集合では，取り出される順序は固定していない．
※上記いずれも場合も，next()関数［Python 2では，イテラブル.next()メソッド］は対応していない．

iter()関数にイテラブルなオブジェクトを渡すとイテレータができる
【例 15.2】

L1 = ['Sun','Mon','Tue']
I1 = iter(L1)
print(next(I1))

T1 = ('Jan','Feb','Mar')
I2 = iter(T1)
next(I2)
print(next(I2))#1

str1 = 'Sunday'
I3 = iter(str1)
next(I3)

d1 = {3:'Wed', 4:'Thu', 5:'Fri'}
I4 = iter(d1)
x1 = next(I4)
print(x1)#2

S1 = {'Apr','May','Jun'}
I5 = iter(S1)
y1 = next(I5)
print(y1)

→
Sun
Feb
3
May
• #1 next()を2回使うと，２つ進んでFebを指す．
• #2 辞書型をイテレータにすると，単純に使えばキーを返す．

• for文をリスト，タプル，文字列，辞書，集合に対して使うときは，初めから終わりまで何回でも回せる．
• for文をイテレータに対して使った後は，現在地が終端になり，2回目からは何も表示されない．
【例 15.3】

L1 = ['Sun','Mon','Tue']
I1 = iter(L1)
    
for z in L1:
    print('1:'+z)
for w in L1:
    print('2:'+w)
   
for x in I1:
    print('3:'+x)
for y in I1:
    print('4:'+y)

→
1:Sun
1:Mon
1:Tue
2:Sun
2:Mon
2:Tue
3:Sun
3:Mon
3:Tue
• リストで行うfor文，'1:'と'2:'は何度でも，初めから終わりまで回す．
• イテレータで行うfor文は，'3:'を行うと'4:'は何も行われない．

• 初めイテレータは先頭の要素を指していて，next()を呼ぶたびに，１つずつ要素が進む．
• イテレータの終端でnext()を呼ぶと，StopIterationエラーになる．
• for文は，現在地から終端までを取り出し，現在地を終端にする．終端でfor文を呼び出しても，エラーにならず何も起こらない．
• イテレータの中では，for文もnext()も要素を「ほぼ自動的に」進めるので，手動で戻したり，何度も読み出すことには向かない．むしろ，「もれなく」「重複なく」1回ずつ読み出す作業に適している．
【例 15.4】

s1 = 'Sunday'
I1 = iter(s1)
x = next(I1)#1
print(x)
for y in I1:#2
    print(y, end=' ')
print('\n')
for y in I1:#3
    print(y, end=' ')

→
S
u n d a y
• #1 で1つ進むから，#2のfor文は2つ目の要素から終端まで読み出す．
• #3になるまでに終端にいるから，#3は何も読み出さない．

• range()関数は，0からn−1までの整数のリストを作る．そのままでリストとして使えるが，iter()でイテレータにすることもできる．
• 例15.4と同様に，リストとして使う場合とイテレータとして使う場合とでは，結果が異なる．
【例 15.5】

R1 = range(5)#リスト
I1 = iter(R1)#イテレータ
print('\n1->')
for n in R1:
    print(n, end=' ')
print('\n2->')
for m in R1:
    print(m, end=' ')
    
print('\n3->')
print(next(I1))
print(next(I1))
for x in I1:
    print(x, end=' ')
print('\n4->')
for y in I1:
    print(y, end=' ')

→
1->
0 1 2 3 4
2->
0 1 2 3 4
3->
0
1
2 3 4
4->
• R1はリストで，for文を何回まわしても，先頭から終端まで読める．
• I1はイテレータで，next()を１回使うと１要素進む．next()を２回使ってから，for文を使うと残りの要素だけを読む．
• 1回終端まで読んでしまうと，2回目のfor文は何も読み出さない．

• イテレータを作成するために，(B)ジェネレータを使う方法もある．
• ジェネレータは，関数の戻り値をyield文で書いたもので，その値がイテレータの要素になる．
（英語のyield［動詞］を直訳すると，「産出する」という意味になる）

【例 15.6】

def gen1():
    yield 'dog'
    yield 'cat'
    yield 'bird'
for x in gen1():
    print(x)

→
dog
cat
bird

【例 15.7】

pi8 = '3.141592'
def gen2():
    for w in pi8:
        yield w
I2 = gen2()
print(next(I2),next(I2),next(I2))
for x in I2:
    print(x)

→
3 . 1
4
1
5
9
2
• 文字列pi8（πの８桁分）から１文字ずつ取り出して，イテレータにする．
• next()を３回呼ぶと，forは残りのものを示す．

• 数学で集合を表すために{1, 3, 5}のように要素を書き並べて表す方法を「外延的表記」，
{ n | 0<n<9, n∈N }のように要素が満たすべき性質（条件）で示す方法を「内包的表記」という．
• Pythonで次のようにブラケット（角括弧）で囲んだものは，リスト内包表記になる．
　次のようにパーレン（丸括弧）で囲んだものは，ジェネレータ内包表記になる．

【例 15.8】

L1 = [x**2 for x in range(5)] #1
print(L1)

str1 = 'My pen.'
L2 = [c for c in str1 if c != ' '] #2
print(L2)

G1 = (x**2 for x in range(5)) #3
for y in G1:
    print(y)
G2 = (c for c in str1 if c != ' ') #4
for z in G2:
    print(z)

→
[0, 1, 4, 9, 16]
['M', 'y', 'p', 'e', 'n', '.']
0
1
4
9
16
M
y
p
e
n
.
#1は0〜4までの整数の2乗から成るリスト
#2は文字列My pen.のうちで半角スペース以外の文字を要素とするリスト
#3, #4は各々に対応するジェネレータによって作られるイテレータ

• リスト，タプル，文字列などの要素を逆順に並べたイテレータを作る．
• 逆順とは，元の並びを単純に逆にしたもののことで，50音逆順ソートのような内容に踏み込んだもののことではない．

【書式】

【例 16.1】

L1 = ['こぶた','たぬき','きつね','ねこ']
G1 = reversed(L1)
print(next(G1))
print(next(G1))
print(next(G1))
print(next(G1))

→
ねこ
きつね
たぬき
こぶた
• next()は元のオブジェクトの要素を逆順に並べたイテレータの中でのnext()を示す．［元のオブジェクトの後から順］
• これは，
L1.reverse()
G2 = iter(L1)
と書いた場合と同じ結果になる．（ただし，この場合は元のL1自体が並び替わる）