データの操作

データの操作#

in English or the language of your choice.

# 警告メッセージを非表示
import warnings
warnings.filterwarnings("ignore")

基本データ型の変換#

次の４つの基本データ型を考えよう。

整数型
浮動小数点型
文字列型
ブール型

ここでは，それぞれのデータ型を他のデータ系に変換する次の関数を紹介する。

int()：整数型への変換
float()：浮動小数点型への変換
str()：文字列型への変換
bool()：ブール型への変換（真偽値の確認）

整数型・浮動小数点型　→　浮動小数点型・整数型#

f0 = 10.0
i0 = 10

f0を整数型へ，i1を浮動小数点型に変換してみよう。

int(f0), type( int(f0) )

(10, int)

float(i0), type( float(i0) )

(10.0, float)

文字列型　→　整数型・浮動小数点型#

次に文字列を考えよう。

s0 = '10'

int()を使うと整数に変換できる。またfloat()関数を適用すると浮動小数点型に変換できる。

int(s0), type( int(s0) )

(10, int)

float(s0), type( type(s0) )

(10.0, type)

これを利用して次の演算が可能となる。

2 + int(s0), 2 + float(s0)

(12, 12.0)

次に以下の文字列を考えよう。

s1 = '10.0'

まずfloat()を使って浮動小数点型に変換してみよう。

float(s1), type( float(s1) )

(10.0, float)

これにより算術演算が可能となる。

float(s1) // 3

3.0

一方でint()を使うとエラーが発生する。

int(s1)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[12], line 1
----> 1 int(s1)

ValueError: invalid literal for int() with base 10: '10.0'

直感的には，s1の小数点以下の0があるからである。この場合，整数型に変換するには次の２ステップ必要となる。

s1　→　浮動小数点型　→　整数型

int( float(s1) )

int( float(s1) ) ** 5

整数型・浮動小数点型　→　文字列型#

文字列型への変換は簡単で，元の値をそのままクォテーション''に入れて返すことになる。

str(f0), str(i0)

('10.0', '10')

整数型・浮動小数点型・文字列型　→　ブール型#

この変換は既出のbool()を使い，対象となるデータのブール値（真偽値）の確認となる。即ち，対象となるオブジェクトが「空・無」かどうかを確かめるの使われる。

bool(100)

True

bool(0)

False

bool('神戸大学'), bool('')

(True, False)

コンテナデータ型の操作#

ここではコンテナデータ型の次の操作について説明する。

要素の抽出（アクセス）
要素の入れ替え
要素の削除
他のデータ型からリストへの変換
基本的なメソッド

リスト#

１つの要素の抽出#

要素のインデックス（位置）を考える場合，次の図のように左から0，1，2…，右からは-1，-2，-3と数える。

   0   1   2   3   4   5  （左から数える） 
 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
  -6  -5  -4  -3  -2  -1　（右から数える）

例えば，次のリストを考えよう。

my_list = ['A', 'B', 'C', 'D', 'E', 'F']

'A'は０番目，'B'１番目，'C'は２番目と数える。Aを抽出したい場合は[]を使いAのインデックス番号0を指定する。

my_list[0]

'A'

Eにアクセスしたい場合は，インデックス番号は4なので次のようになる。

my_list[4]

'E'

または右から数えたインデックス番号-2を使っても同じ結果となる。

my_list[-2]

'E'

複数要素の抽出（その１）#

次に複数の連続する要素を抽出したいとしよう。この場合はスライシングと呼ばれ，:（コロン）を使う。:の左右にインデックス番号を置き要素を選択するが，次のルールに従う。

[＜start＞:＜end＞]

start：最初のインデックス
end：最後の次のインデックス

即ち，:の右側にあるインデックスの要素は抽出されない。例えば，my_listの１番目から３番目の要素を抽出したい場合は1:4となる。

my_list[1:4]

['B', 'C', 'D']

次のように書くとより直感的になるのではないだろうか。

my_list[1:3+1]

['B', 'C', 'D']

次のルールも覚えておこう。

:の左側の番号を省略すると「0番目から」と解釈される。
:右側を省略すると「最後まで」と解釈される。

次のコードは最初からスライスしている。

my_list[:3+1]

['A', 'B', 'C', 'D']

最後までスライスする場合は次のコードとなる。

my_list[3:]

['D', 'E', 'F']

では:の左右の番号を省略するとどうなるのだろう。「最初から最後まで」，即ち，全てとなり，リストのコピーを作成することと同じである。

your_list = my_list[:]
your_list

['A', 'B', 'C', 'D', 'E', 'F']

Note

my_listのA，C，Eのように連続していない要素を同時に抽出したい場合はどうすれば良いだろうか。残念ながら，簡単な方法は用意されていない。しかし１つの方法として次のコードで要素のインデックス番号を指定してアクセスすることが可能である。

my_idx = [0,2,4]
[my_list[i] for i in my_idx]

１行目はA，C，Eのインデックス番号のリストであり，２行目は後に説明する内包表記を使っている。

複数要素の抽出（その２）#

上の説明でのスライシングのインデックス番号は，1,2,3,4の様に増分は1となっている。実は，この増分も次のように設定することができる。

[＜start＞:＜end＞|＜step＞]

start：最初のインデックス
end：最後の次のインデックス
step：増分（デフォルトは1）

stepのデフォルトは1なので，設定しなければ増分は1となり，上で説明したスライシングとなる。ここではstepを指定した場合について触れる。次の例を考えよう。

lst = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

stepを2にすると，インデックス番号が一つおきとなり偶数だけが抽出される。

lst[::2]

[0, 2, 4, 6, 8]

ここではstartとendは指定されていないので，全てのインデックス番号が抽出の対象となっている。もちろんstepを3にすると２つおきのインデックス番号の要素が抽出される。

lst[::3]

[0, 3, 6, 9]

またstepに負の整数を使うと，要素を逆に並べて結果を返すことになる。次の例は，全ての要素を逆に並べている。

lst[::-1]

[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

もちろん-2にすると，逆順で一つおきの要素が抽出される。

lst[::-2]

[9, 7, 5, 3, 1]

２次元リストの要素抽出#

次の例は入れ子のケースである。

my_list2 = ['A', ['B', 'C'], ['D', 'E', 'F', 'G', 'H']]

この場合でも考え方は変わらない。例えば，['B','C']を抽出したいとしよう。['B','C']は1番目の要素として入っているので次のコードでアクセスできる。

element1 = my_list2[1]
element1

['B', 'C']

更に，element1のBを抽出したいとしよう。その場合も同じ考えで次のコードとなる。

element1[0]

'B'

また別々に書いたコードを続けて書いても同じ結果となる。

my_list[1][0]

'B'

もちろんスライシングも使える。D，E，Fを抽出したい場合は次のコードとなる。

my_list2[-1][:2+1]

['D', 'E', 'F']

要素の入れ替え#

要素の入れ替え方法を説明するために，次のリストlst0を作成しよう。

lst0 = [0, 1, 2 ,3, 4, 5]
lst0

[0, 1, 2, 3, 4, 5]

0番目の要素は0だが，これを文字列'Kobe'に入れ替えてみよう。方法は簡単で，入れ替えたい要素を選び=の左辺に置き，右辺には新しい要素を配置し実行するだけである。次のコードとなる。

lst0[0] = 'Kobe'
lst0

['Kobe', 1, 2, 3, 4, 5]

右辺から読めば理解できる。「Kobeをlst0[1]に割り当てる」となり，これで「入れ替え」となる。この例の右辺は文字列だが，他のデータ型でも可能である。例えば，

lst0[1] = {'a':100}
lst0

['Kobe', {'a': 100}, 2, 3, 4, 5]

スライシングを使い要素入れ替えも可能である。

lst0[-2:] = (40, 60)
lst0

['Kobe', {'a': 100}, 2, 3, 40, 60]

この場合，左辺の要素数と右辺の要素数が同じになる必要がある。また右辺に辞書を置くとキーの値が割り当てられることになる。試してみよう。

lst0[-2:] = {'A':40, 'B':60}
lst0

['Kobe', {'a': 100}, 2, 3, 'A', 'B']

要素の削除#

要素を削除するには色々な方法が用意されているが，最も簡単なのはdel（deleteの略）を使うことだろう。delの後に削除したい要素を書き実行するだけである。例えば，

del lst0[0]
lst0

[{'a': 100}, 2, 3, 'A', 'B']

Kobeが削除されている。次の例はスライシングを使いAとBを削除している。

del lst0[-2:]
lst0

[{'a': 100}, 2, 3]

他のコンテナデータ型からリストへの変換#

関数list()を使う。

次のタプルを考えよう。

tpl = (1, 3.14, 'A')
tpl

(1, 3.14, 'A')

list()を使うとリストに変換される。

list(tpl)

[1, 3.14, 'A']

次に辞書を考えてみよう。

dic = {'a':1,'b':2,'c':3}
dic

{'a': 1, 'b': 2, 'c': 3}

この場合は，キーだけが抽出されリストが作成される。

list(dic)

['a', 'b', 'c']

Note

次のコードでも辞書のキーからリストを作成することができる。

list(dic.keys())

また辞書の値からリストを作成するには次のコードを使うことができる。

list(dic.values())

ここで.keys()と.values()はdicのメソッドと呼ばれるものであり，下でより詳しく説明する。

メソッド#

全てのリストにはリスト自体に働きかける関数が備わっており，それをメソッドと呼ぶ。より詳細な説明は後に回すとして，ここではリストの最後に要素を追加するappend()というメソッドを紹介する。空のリストを考えよう。

lst = []

次の構文となる。

lst.append(＜追加する要素＞)

ここで.はメソッドにアクセスするための記号であり，その後にメソッドappend()を置く。では100をlstに追加してみよう。

lst.append(100)

何も表示されないが，lstは変更されている。lstを実行すると100が追加されていることが確認できる。

lst

[100]

次は50を追加しよう。

lst.append(50)

lst

[100, 50]

append()以外にも色々なメソッドが備わっている。

タプル#

説明#

まず次の様にtpl1とtpl2を定義しよう。

tpl1 = (10, 20, 30, 40, ('a', 'b'))

tpl2 = ((1,2,3),
        (4,5,6),
        (7,8,9))

タプルのリストとの違いは，要素を変更できないということである。その他は殆ど同じなので，次のことが言える。

１つの要素の抽出：リストと同じ
- 例えば，tpl1[0]は10を返す。
複数要素の抽出（スライシング）：リストと同じ
- 例えば，tpl1[1:3+1]は(20, 30, 40)を返す。
２次元タプルの要素抽出：リストと同じ
- 例えば，tpl[1][0]は4を返す。
要素の入れ替え：不可
- 例えば，tpl[1] = 0を実行するとエラーが発生する。
要素の削除：不可
- 例えば，del tpl[1]を実行するとエラーが発生する。

他のコンテナデータ型からリストへの変換#

関数tuple()を使う。

この関数もlist()と非常に似ている。次のリストを考えよう。

lst = [1, 3.14, 'A']
lst

[1, 3.14, 'A']

tuple(lst)

(1, 3.14, 'A')

辞書の場合はキーのタプルとなる。

dic = {'a':1,'b':2,'c':3}
tuple(dic)

('a', 'b', 'c')

Note

次のコードでも辞書のキーからタプルを作成することができる。

tuple(dic.keys())

また辞書の値からタプルを作成するには次のコードを使うことができる。

tuple(dic.values())

ここで.keys()と.values()はdicのメソッドと呼ばれるものであり，下でより詳しく説明する。

辞書#

要素の抽出#

次の例を考えよう。

macro = {'inflation':2, 'unemployment':5, 'interest_rate': 3}

0番目の要素はinflation（インフレ）と2（％）には２つのペアであり，1番目の要素はunemployment（失業）と5（％）のペアとなっている。辞書の場合，要素にアクセスするには0や1のインデックス番号を使わずに，キーを指定しペアとなる値を抽出する。その際，リストとタプルと同じように[]を使う。inflationの2にアクセスしてみよう。

macro['inflation']

同様にunemploymentの値にアクセスするには次の様にする。

macro['unemployment']

辞書にスライシングはない。

入れ子の場合の抽出#

次の例を考えよう。

dic2 = {'AB':{'a':1, 'b':2,}, 'C':[10, 20]}

次のコードでABの値を抽出できることは理解できるだろう。

dic3 = dic2['AB']
dic3

{'a': 1, 'b': 2}

更に，bの値2にアクセスしたいとしよう。その場合は，

dic3['b']

とすれば良い。２つのコードを一緒に書くと次の様になる。

dic2['AB']['b']

同じ要領で，20にアクセスしてみよう。

dic2['C'][1]

どれだけ入れ子になっていても[]を連続させることによって目的の要素にアクセスできることが分かると思う。

値の入れ替え#

辞書はキーと値のペアとなっているが，変更できるのは値だけである。方法はリストと同じで，=の左辺に変更したいキーを選び，右辺に変更後の値を配置し実行するだけである。例えば，macroにあるunemploymentの値を10.5に入れ替えてみよう。

macro['unemployment'] = 10.5
macro

{'inflation': 2, 'unemployment': 10.5, 'interest_rate': 3}

要素の削除#

どうしてもキーを変更したい場合は，キー・値のペアを削除し，新たに追加することになる。例えば，'unemployment':10.5を'失業率':10.5に「変更」するには次のコードとなる。

del macro['unemployment']  # 1

macro['失業率'] = 10.5      # 2

macro                      # 3

{'inflation': 2, 'interest_rate': 3, '失業率': 10.5}

１行目で'unemployment':10.5を削除している，ここでのdelはリストの要素を削除した際に使った同じdelである。
２行目で'失業率':10.5を追加している。
３行目はmacroを実行して内容を表示している。

メソッド#

リスト同様，全ての辞書には様々なメソッドが備わっている。ここでは２つを紹介する。

keys()：キーを抽出するメソッド
values()：値を抽出するメソッド

まずmacroを使ってkeys()から考えよう。

mkey = macro.keys()
mkey

dict_keys(['inflation', 'interest_rate', '失業率'])

３つのキーが並んでいるのが確認できる。一方で表示の最初にdict_keysと書かれており，リストやタプルと異なる様である。データ型を確認してみよう。

type(mkey)

dict_keys

dict_keysというデータ型であり，やはりリストやタプルとは異なる。リストに変換するには関数list()を使えば良い。

list(mkey)

['inflation', 'interest_rate', '失業率']

同様にタプルに変換するにはtuple()を使う。

次にメソッドvalues()を考えよう。

mval = macro.values()

mval, type(mval)

(dict_values([2, 3, 10.5]), dict_values)

dict_valuesというデータ型となっている。リストに変換するには次のコードとなる。

list(mval)

[2, 3, 10.5]

文字列の操作#

文字の抽出#

ここでは文字列型の次の操作について説明する。

要素の抽出（アクセス）
基本的なメソッド

Pythonの文字列には6つのアルファベット文字が，それぞれを

次の文字列を考えよう。

s = 'It is fun to learn Python!'

sにはアルファベットと半角スペースが使われているが，それぞれが要素となる文字列である。従って，リスト同様[]を使って文字を抽出することができる。0番目と最後の文字は次のコードでアクセスできる。

s[0], s[-1]

('I', '!')

スライシングも使える。

s[3:10+1]

'is fun t'

文字列は変更不可#

タプル同様，文字列は変更不可となるため次の操作はできない。

要素の入れ替え
要素の削除

sのPythonをeconomicsに変更するには，新しい文字列をsに再割り当てすることになる。

s = 'It is fun to learn economics!'

`list()`と`tuple()`を使う#

文字列にlist()やtuple()を使うと，１つの文字が要素となるリストもしくはタプルを返すことになる。

list('Python')

['P', 'y', 't', 'h', 'o', 'n']

tuple('Python')

('P', 'y', 't', 'h', 'o', 'n')

メソッド#

全ての文字列には色々なメソッドが準備されている。ここでは３つ紹介する。

split()：デフォルトでは半角スペースで分割しリストを返す。
join()：文字列を結合する。
replace()：文字列を入れ替える。

sにsplit()を使ってみよう。

s.split()

['It', 'is', 'fun', 'to', 'learn', 'economics!']

デフォルトでは区切りに半角スペースが使われ，単語がリストの構成要素となっている。()に分割に使う文字列を指定することもできる。例えば，isで分割してみよう。

s.split('is')

['It ', ' fun to learn economics!']

この場合isが区切りとなり，sは２つに分かれている。

次にjoin()を説明しよう。次の構文となる。

'＜結合に使う文字列＞'.join(＜文字列が含まれるリスト・タプル＞)

まずリストを作成して説明しよう。

s_new = ['P','y','t','h','o','n']

'-'.join(s_new)

'P-y-t-h-o-n'

それぞれの文字が-で結合されているのがわかる。次も同じ結果を返す。

'-'.join('Python')

'P-y-t-h-o-n'

これは

'-'.join( list('Python') )

と同じことであり，list()が自動的に適応されていることが分かる。

'-'.join(s_new)のs_newの代わりにsを使ってみよう。

'-'.join(s)

'I-t- -i-s- -f-u-n- -t-o- -l-e-a-r-n- -e-c-o-n-o-m-i-c-s-!'

半角スペースを含めて全ての文字の間に-が入っている。単語の間にだけ-が入るようにするには次のコードで可能である。

'-'.join( s.split() )

'It-is-fun-to-learn-economics!'

s.split()で単語からなるリストを作成した後にjoin()で結合している。

メソッドreplace()を使っても同じ結果を得ることができる。

s.replace(' ', '-')

'It-is-fun-to-learn-economics!'

第１引数' '：入れ替える対象の文字列
第２引数'-'：入れ替える文字列

s.replace(' ', '😁').replace('!', '‼️')

'It😁is😁fun😁to😁learn😁economics‼️'

まとめ#

＜基本データ型の変換＞

関数	動作
`list()`	リストへ変換
`tuple()`	タプルへ変換
`str()`	文字列へ変換
`bool()`	真偽値の確認

＜要素アクセス＞

データ型	例	抽出方法
リスト	`x = [0,10,30]`	`x[1]`　→　`10`
タプル	`y = (0,10,30)`	`y[1]`　→　`10`
辞書	`z = {'a':0, 'b':10}`	`z['b']`　→　`10`

＜スライシング＞

データ型	例	抽出方法
リスト	`x = [0,10,20,30]`	`x[:2+1]`　→　`[0,10,20]`
リスト	`x = [0,10,20,30]`	`x[1:]`　→　`[10,20,30]`
リスト	`x = [0,10,20,30]`	`x[:]`　→　`[0,10,20,30]`
リスト	`x = [0,10,20,30]`	`x[::-1]`　→　`[30,20,10,0]`

基本的にタプルも同じ

＜値の入れ替え＞

データ型	例	方法
リスト	`x = [0,10,30]`	`x[1]=100`
タプル	`y = (0,10,30)`	不可
辞書	`z = {'a':0, 'b':10}`	`z['b']=100`

＜要素の削除＞

データ型	例	削除方法
リスト	`x = [0,10,30]`	`del x[1]`　→　`[0,30]`
タプル	`y = (0,10,30)`	不可
辞書	`z = {'a':0,'b':10}`	`del z['a']`　→　`{'b':10}`

＜メソッド＞

データ型	例	メソッド
リスト	`x = [10]`	`x.append(20)`　→　`[10,20]`
辞書	`x = {'a':0,'b':10}`	`list( x.keys() )`　→　`['a','b']`
辞書	`x = {'a':0,'b':10}`	`list( x.values() )`　→　`[0,10]`
文字列	`x = 'It is me!'`	`x.split() )`　→　`['It','is','me!']`
文字列	`x = ['It','is','me!']`	`'-'.join(x) )`　→　`'It-is-me.'`
文字列	`x = 'It is me!'`	`x.replace(' ','-') )`　→　`'It-is-me.'`

データの操作

Contents

データの操作#

基本データ型の変換#

整数型・浮動小数点型 → 浮動小数点型・整数型#

文字列型 → 整数型・浮動小数点型#

整数型・浮動小数点型 → 文字列型#

整数型・浮動小数点型・文字列型 → ブール型#

コンテナデータ型の操作#

リスト#

１つの要素の抽出#

複数要素の抽出（その１）#

複数要素の抽出（その２）#

２次元リストの要素抽出#

要素の入れ替え#

要素の削除#

他のコンテナデータ型からリストへの変換#

メソッド#

タプル#

説明#

他のコンテナデータ型からリストへの変換#

辞書#

要素の抽出#

入れ子の場合の抽出#

値の入れ替え#

要素の削除#

メソッド#

文字列の操作#

文字の抽出#

文字列は変更不可#

list()とtuple()を使う#

メソッド#

まとめ#

整数型・浮動小数点型　→　浮動小数点型・整数型#

文字列型　→　整数型・浮動小数点型#

整数型・浮動小数点型　→　文字列型#

整数型・浮動小数点型・文字列型　→　ブール型#

`list()`と`tuple()`を使う#