←PC版は別ページ

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

 このページは,プログラム言語Pythonをこれから学ぼうと考えている筆者の備忘録です.
 そこそこ調べて書いていますが,仕様を精密に調べたものではありません.どちらかと言えば,実装されたPython 3を使ってみてどうなったかということを中心に書いたものです.いわば,実験ノートの記録です.(最終更新年月日:2019.5.3 / by Python 3.7.3)
Pythonの練習には,
(1) IDLEというメニューから入って,>>>というプロンプトが表示される状態で使う場合
• 画面の上端がPython 3.7.x Shellとなっていて,2行目がFile, Edit, Shell, Debug, ...となっている
• 1行入力するたびに,エラーを確かめながら処理を進める,対話型インタプリタの形になっている
(2) IDLEというメニューから入って,左上端のFileをクリック→New Fileと進む場合
• 画面の上端がファイル名(初めはUntitled)となっていて,2行目がFile, Edit, format, Run, ...となっている
(3) Python 3.7.x という真っ黒なコマンドプロンプトの画面(ターミナルウィンドウ)から入るもの
の3通りが使えるが,以下は(2)のNew Fileから,テキストエディタを使って,プログラムを書く場合を考える.

Pythonの組み込み関数(ビルドイン関数)

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

10. list()関数

【書式】
リスト = list(タプルなど)
• リストを作成するには,角括弧(ブラケット)を使って直接定義する方法
L1 = [3, 4, 5] など
の他に,タプル,文字列,集合,辞書などの他のデータ型で定義されているものをリスト型に直す方法もある.
• list()関数を使えば,他のデータ型で定義されているものをリスト型に直せる.
• リスト型で定義されているものにlist()関数を適用してもエラーにはならず,元のリストのコピーが返される(値のコピーなので,元のリストを変更しても変換後のリストは影響を受けない).
タプル→リスト
【例 10.1】
IDLE → New File → Save as .. → Run
tp1 = ('a','b','c','d')
L1 = list(tp1)
print(L1)
print(tp1)

['a', 'b', 'c', 'd']
('a', 'b', 'c', 'd')
• タプル型からリスト型が作られるが,元のタプルはなくならない.
文字列→リスト
【例 10.2】
IDLE → New File → Save as .. → Run
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】
IDLE → New File → Save as .. → Run
set1 = {'x','yz','uvw'}
L1 = list(set1)
print(L1)
print(set1)

['uvw', 'x', 'yz']
{'uvw', 'x', 'yz'}
• 集合の要素は,並び方が決まっていないという特徴があり,list()で変換した瞬間の並び方を反映したリストになる.もう一度変換すると,別の並び方のリストができる(ことが多い)
辞書→リスト
【例 10.4】
IDLE → New File → Save as .. → Run
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】
IDLE → New File → Save as .. → Run
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も書き換わる.


11. tuple()関数

【書式】
タプル = list(リストなど)
• タプルを作成するには,丸括弧(パーレン)を使って直接定義する方法
t1 = (5,6,7) など
t1 = 5,6,7 のように丸括弧を省略してもタプルになる
の他に,リスト,文字列,集合,辞書などの他のデータ型で定義されているものをタプル型に直す方法もある.
• tuple()関数を使えば,他のデータ型で定義されているものをタプル型に直せる.
• タプル型で定義されているものにtuple()関数を適用してもエラーにはならず,元のタプルの参照が返される(同じメモリアドレスを指し示す).
リスト→タプル
【例 11.1】
IDLE → New File → Save as .. → Run
L1 = [4,5,6]
t2 = tuple(L1)
print(t2)
print(L1)

(4, 5, 6)
[4, 5, 6]
• リスト型からタプル型が作られるが,元のリストはなくならない.
文字列→タプル
【例 11.2】
IDLE → New File → Save as .. → Run
str1 = 'My pen.'
t1 = tuple(str1)
print(t1)
print(str1)

('M', 'y', ' ', 'p', 'e', 'n', '.')
My pen.
• 文字列をタプルに変換すると,半角スペースやピリオドも1文字ごとの要素になる.
集合→タプル
【例 11.3】
IDLE → New File → Save as .. → Run
s1 = {'ab','c','def'}
t1 = tuple(s1)
print(t1)
print(s1)

('def', 'ab', 'c')
{'def', 'ab', 'c'}
• 集合の要素は,並び方が決まっていないという特徴があり,list()で変換した場合と同様に,その瞬間の並び方を反映したタプルになる.もう一度変換すると,別の並び方のタプルができる(ことが多い)
辞書→タプル
【例 11.4】
IDLE → New File → Save as .. → Run
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】
IDLE → New File → Save as .. → Run
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の参照先は変わらない.


12. dict()関数

【書式】
辞書 = dict(リストなど)
• 辞書型は,1つの要素が,キーと値の2つのものから成り立っている.
• 2つの要素が組になっているデータをdict()関数で取り込むと,辞書が作れる.3つ,4つの要素になっているとエラーになる.
2文字ずつの文字列からなるリスト→辞書
【例 12.1】
IDLE → New File → Save as .. → Run
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】
IDLE → New File → Save as .. → Run
L1 = [['b','boy'],['c','cat'],['d','door']]
d1 = dict(L1)
print(d1)

{'b': 'boy', 'c': 'cat', 'd': 'door'}
2要素ずつのタプルからなるリスト→辞書
【例 12.3】
IDLE → New File → Save as .. → Run
L1 = [(1,'a'),(2,'xy'),(3,'pqr')]
d1 = dict(L1)
print(d1)

{1: 'a', 2: 'xy', 3: 'pqr'}
辞書→辞書
【例 12.4】
IDLE → New File → Save as .. → Run
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という形で代入で行うと,参照のコピーになり,一方を書き換えると他方も変わる.


13. str()関数

【書式】
文字列 = str(オブジェクト)
• str()関数は,int型,float型のような数値型のデータを文字列型に変換したり,バイナリデータを文字列に変換するのが本来の使い方だと考えられるが,リスト型,辞書型などにも使える.
【例 13.1】
IDLE → New File → Save as .. → Run
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】
IDLE → New File → Save as .. → Run
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の参照先だけが変わる.


14. set(), frozenset()関数

【書式】
集合 = set(イテラブル)
フローズンセット = frozenset(イテラブル)
• リスト,タプル,文字列,辞書,集合はset()関数で集合を作成する. • フローズンセットは,照合に対応するイミュータブルなオブジェクトで,作成後に一部書き換えや追加はできない.
リスト,タプル,文字列,辞書,集合→集合,フローズンセットの場合
【例 14.1】
IDLE → New File → Save as .. → Run
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】
IDLE → New File → Save as .. → Run
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】
IDLE → New File → Save as .. → Run
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のように直接書き込まれた生のデータのことをいう.
X1を一部変更した場合X1に,X1='abc', X1=('a','b')のように別のリテラルを代入して,
全部書き換えした場合
@文字列,タプル
イミュータブル:一部変更や追加は不可
≪次の(A)(B)は同じ結果になる.≫
(A) X2 = str(X1), X2 = tuple(X1)とした場合
(B) X2 = X1とした場合
参照のコピーになり,同じ文字列,タプルを指す
イミュータブルだから,一部書き換えや追加はできない.X1にX1='ab',X1=('a','b')のように新たにリテラルを代入して,全部書き換えした場合は,X1だけが書き換わり,X2は影響を受けない.
X1の参照先だけが別のリテラルに変化する
Aリスト,辞書,集合
ミュータブル:一部変更や追加が可能
(A) X2 = list(X1),X2 = dict(X1),X2 = set(X1)とした場合
値のコピーになり,別のリスト,辞書,集合が作られる.X2=X1.copy()と同じ結果になる
(B) X2 = X1とした場合
参照のコピーになり,同じリスト,辞書,集合を指し示す.
(A)
X1の一部変更はできる
→X2は別のリスト,辞書,集合であるから,影響を受けない.
X1だけが変わり,X2は影響を受けない.
(B)
X1の一部変更はできる
→X1とX2は同じものを指し示しているから,X2も連動して変化する.

15. iter()関数

• 以下において,イテラブルとは,リスト,タプル,文字列,辞書,集合のように,要素を1つずつ取り出すことができるオブジェクトのこととする.
• イテラブルなオブジェクトに対しては,
(1) for文が使える
(2) iter()関数やジェネレータを使って,イテレータにすることができる
• リスト,タプル,文字列,辞書,集合は,そのままではイテレータではないが,イテレータにすれば
(1) for文も使える
(2) next()関数[Python 3から]によって次の要素を取得できる
【書式】
イテレータ = iter(オブジェクト)
要素 = next(イテレータ)
• イテレータは,それぞれの要素に対して「次」の要素を取り出せる仕組みになっているオブジェクトです.
• イテレータに対しては,for文が利用できる.
• イテレータを作成するには,
(A) iter()関数を使う方法
(B) ジェネレータを使う方法
がある.
(参考)イテラブルなオブジェクトの要素はfor文で取り出せる
【例 15.1】
IDLE → New File → Save as .. → Run
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文字ずつ取り出される.
• #1 辞書では,この形でキーだけが取り出される.これは,for z in d1.keys():とした場合と同じになる.
• #2 辞書の値をとりだすには,for v in d1.values():とする.
• #3 辞書のキーと値の2つとも取り出すには,2つの仮引数を用いて,for k,v in d1.items():とする.
• 集合では,取り出される順序は固定していない.
※上記いずれも場合も,next()関数[Python 2では,イテラブル.next()メソッド]は対応していない.
iter()関数にイテラブルなオブジェクトを渡すとイテレータができる
【例 15.2】
IDLE → New File → Save as .. → Run
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回使うと,2つ進んでFebを指す.
• #2 辞書型をイテレータにすると,単純に使えばキーを返す.
• for文をリスト,タプル,文字列,辞書,集合に対して使うときは,初めから終わりまで何回でも回せる.
• for文をイテレータに対して使った後は,現在地が終端になり,2回目からは何も表示されない.
【例 15.3】
IDLE → New File → Save as .. → Run
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()を呼ぶたびに,1つずつ要素が進む.
• イテレータの終端でnext()を呼ぶと,StopIterationエラーになる.
• for文は,現在地から終端までを取り出し,現在地を終端にする.終端でfor文を呼び出しても,エラーにならず何も起こらない.
• イテレータの中では,for文もnext()も要素を「ほぼ自動的に」進めるので,手動で戻したり,何度も読み出すことには向かない.むしろ,「もれなく」「重複なく」1回ずつ読み出す作業に適している.
【例 15.4】
IDLE → New File → Save as .. → Run
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】
IDLE → New File → Save as .. → Run
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()を1回使うと1要素進む.next()を2回使ってから,for文を使うと残りの要素だけを読む.
• 1回終端まで読んでしまうと,2回目のfor文は何も読み出さない.

ジェネレータ

• イテレータを作成するために,(B)ジェネレータを使う方法もある.
• ジェネレータは,関数の戻り値をyield文で書いたもので,その値がイテレータの要素になる.
(英語のyield[動詞]を直訳すると,「産出する」という意味になる)
【例 15.6】
IDLE → New File → Save as .. → Run
def gen1():
    yield 'dog'
    yield 'cat'
    yield 'bird'
for x in gen1():
    print(x)

dog
cat
bird
【例 15.7】
IDLE → New File → Save as .. → Run
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(πの8桁分)から1文字ずつ取り出して,イテレータにする.
• next()を3回呼ぶと,forは残りのものを示す.

ジェネレータ式(ジェネレータ内包表記)

• 数学で集合を表すために{1, 3, 5}のように要素を書き並べて表す方法を「外延的表記」,
{ n | 0<n<9, n∈N }のように要素が満たすべき性質(条件)で示す方法を「内包的表記」という.
• Pythonで次のようにブラケット(角括弧)で囲んだものは,リスト内包表記になる.
[式 for 変数名 in イテラブルオブジェクト]
[式 for 変数名 in イテラブルオブジェクト if 条件式]
 次のようにパーレン(丸括弧)で囲んだものは,ジェネレータ内包表記になる.
(式 for 変数名 in イテラブルオブジェクト)
(式 for 変数名 in イテラブルオブジェクト if 条件式)
【例 15.8】
IDLE → New File → Save as .. → Run
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は各々に対応するジェネレータによって作られるイテレータ

16. reversed()関数

• リスト,タプル,文字列などの要素を逆順に並べたイテレータを作る.
• 逆順とは,元の並びを単純に逆にしたもののことで,50音逆順ソートのような内容に踏み込んだもののことではない.
【書式】
イテレータ = reversed(オブジェクト)
【例 16.1】
IDLE → New File → Save as .. → Run
L1 = ['こぶた','たぬき','きつね','ねこ']
G1 = reversed(L1)
print(next(G1))
print(next(G1))
print(next(G1))
print(next(G1))

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