基本データ型と変数

基本データ型と変数#

in English or the language of your choice. 

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

最初の注意点#

半角と全角#

半角を基本としてコード（スペースも含めて）を書くこと。

次の２つケース以外で全角を使うとエラーが発生する。

  • 以下で説明する文字列型のデータ型の場合は全角を使っても構わない。

  • 半角の#の後であれば全角を使っても構わない（Pythonは#の後に続くコードを無視するためであり，よくコメントを書くのに使われる）。

例えば，次のコード・セルには半角の10の後に全角のスペースが紛れ込んでいるためエラーが発生している。

10　

  Cell In[2], line 1
    10
      ^
SyntaxError: invalid non-printable character U+3000

「全角スペース忍者」には要注意！

しかし、#を使うと#の後は無視され実行されない。

# 10　

不明瞭さをなくすために次の表現を使う。

  • #を付けてコードを実行できないようにすることを「コメントアウトする」（comment out）するいう。「コメント」して実行されないように（「アウト」）する、という意味。

  • #を取り除きコードを実行できるようにすることを「アンコメント」（uncomment）するという。「アン」は「コメント」の否定形。

左詰め#

Pythonではインデントが重要な役割を果たします。原則，コード・セルの中で左詰めでコードを書くようにすること。一方で，以下で説明するようにインデントが必須な場合（例えば，forループや関数を定義する場合）もあり，その様な場合は半角スペース4つを入れるのが慣例となっている。Jupyter NotebookではTabを押すことにより半角スペース4つが自動で挿入されるので覚えておこう。

括弧#

コードでは括弧が多用されるが，次の呼称とする。

  • ()：丸括弧（parentheses）

  • []：角括弧（brackets）

  • {}：波括弧（braces, curly braces, curly brackets）

２つのデータ型と算術演算#

２つのデータ型#

Pythonには無数のデータ型があるが，まず基本となる2つを考える。

  • 整数型（intと表される; integerの略）

  • 浮動小数点型（floatと表される）

整数型とは文字通り1や100などの整数のことであり，浮動小数点型とは0.2や11.666などの小数を指す。Pythonでは整数と小数を異なるデータ型として区別して扱うので，1と1.0はデータ型が異なることになる。

Note

なぜ浮動小数点型を「少数」と呼ばないのか。数字の3.14を考えよう。表示方法によって次のように分けることができる。

  • 固定小数点型

    \[ 3.14 \]

    この場合，小数点は3と1の間に固定されている。

  • 浮動小数点型

    \[ 3.14\times 10^0,\quad 31.4\times 10^{-1},\quad 314.0\times 10^{-10} \]

    10の指数によって小数点が移動していることがわかる。

コンピュータは後者を利用しデータを2進法で表しているためである。

整数型の1を実行すると，1が返され表示されることになる。

1 

1

同様に不動小数点型の1.0を実行すると1.0が返される。

1.0

1.0

データ型を確認するためにtype()という関数が用意されているので，それを使ってみよう（関数に関しては後述する）。

type(1)

int

type(1.0)

float

整数型はint（integerの略），浮動小数点型はfloat（floating point numberの略）と表示されている。

Tip

1,000,000,000.0（10億）のような大きな数字は３桁ごとにコンマを入れると読みやすくなるが，Pythonでは,の代わりに_を使うことができる。例えば，35億をxに割り当てる場合は次の様に書くことができる。

x = 3_500_000_000.0

計算機としてのPython#

基本的な算術演算子として以下を挙げることができる。

  • +（加算）

  • -（減算）

  • *（乗算）

  • /（除算）

  • **（累乗）

a/bを計算すると，整数部分である商と余り（0の場合もある）に分けることができる。

  • //（切り捨て除算）：整数部分を返す

  • %（剰余演算）：余り返す

a÷bを考えよう。除算，切り捨て除算，剰余演算の関係は次の式で与えられる。

a = b X q + r

  • a：割られる数

  • b：割る数

  • q：商（quotient）

  • r：剰余（余り, remainder）

qを求めるには//を使い，rを求めるには%を使う。

例を挙げて考えよう。まず整数型の四則演算と累乗を考えてみよう。

100 + 2

102

100 - 2

98

100 * 2

200

100 / 2

50.0

100 ** 2

10000

ここで気づくのは，商のみが浮動小数点型が返されている。更に，式の数値に不動小数点型が１つでも入ると，浮動小数点型が返されることになる。例えば，上のコードの2を2.0に変えて計算してみると，全て浮動小数点型が返ってくる（試してみよう。）

数学では()の中が先に計算されるが，Pythonでも同じである。

(100 - 50) / 2

25.0

次に切り捨て演算を考えよう。a/bを計算すると，結果は整数部分である商と余り（0の場合もある）に分けることができるが，整数部分を返すのが切り捨て演算となる。次の例では整数型7を不動小数点型で割り，計算結果の整数部分を不動小数点型で返している（2.0ではなく2で割ると整数型3が返される。試してみよう）。

7 // 2.0

3.0

切り捨て演算と関係が深いのが剰余演算%である。x/yの例を使うと，余り返すのが剰余演算となる。上と同じ例を使うと次の値が返される。

7 % 2.0

1.0

この例では7➗２.0=2.0余り1.0となるため，7 % 2.0は1.0を返し，5 // 2は2.0を返すことになる。

Note

切り捨て演算と剰余演算には次の関係が成立する。

a　== (a//b)*(b) + (a%b)

ここで==は両辺が等しいことを確認するための演算子でありTrueを返すことになるが，詳細は後に説明するので両辺は等しいとだけ理解すれば良いだろう。a,b>0の場合は問題なく理解できると思う。しかし，aもしくはbもしくは両方が負の値を取るとエキゾチックな値になるので注意する必要がある。基本的に//は「床関数」と同義と考え，上の関係が満たされるように%の値が決まることになる。このサイトではa,b>0のみを考える。

=による変数の割り当て#

=の役割#

数学では=は等号であり，両辺が等しいことを示すが，Pythonでは別の意味で使われる。変数にデータを割り当てる場合にのみ使われる。即ち，「等号」ではなく「割り当て演算子」である。次の例では値10を変数xに割り当てている。

x = 10

ここで注意して欲しいのは，右辺の10が左辺のxに割り当てられている。10 = xとするとエラーが発生する。

xの値を返す（表示する）には，xを書いたセルを実行するだけである。

x

10

もちろん変数を使って算術演算を行うことも可能である。

x = 100
y = 10
z = x / y
z

10.0

このコードセルを実行すると，上から順番に１行目から評価されることになる。

  • １行目：100がxに割り当てられる。注意してほしい点は，上でx = 10が実行されており，10がxに割り当てられていいた。x = 100が実行されると同時に，x = 10の割り当ては無効になり，100がxに新たに割り当てられることになる。

  • ２行目：10がyに割り当てられる。

  • ３行目：x / yが評価され，その値がzに割り当てられる。

  • ４行目：zが評価され，値10.0が返される。

上の説明では「代入する」ではなく「割り当てる」という表現を使ったが，その理由を解説しよう。簡単にいうと，xと100は全く別物であるためである。この点を理解するために、多くの品物が保管されている大きな倉庫を考えてみよう。倉庫の管理者はどの品物がどこに保管されているかを記録する在庫リストを作成し、そこに品物が保管されている棚を示す記号を記入するとしよう。この例を使うと、

  • 100　→　倉庫の棚に保管されている品物

  • x　→　在庫リストに記載されている棚の記号

となる。品物と棚の記号は別物である。Pythonでは、品物である10がコンピューター内のメモリーの所定の場所に保存され、その場所を示すのが変数xとなる。即ち、xは品物10の実態とは異なる単なる「参照記号」なのである。

  • 100　→　PCのメモリーに保存されているデータ

  • x　→　参照記号

この点を明確にするために、上のコードは「100を変数xに割り当てる」と考える。ここで=の右辺を先に読み，その次に左辺を読んでいることに注意しよう。=を右から左に読む（考える）ことを習慣づけることが、今後Pythonを勉強する上で重要となる。この点を示すために次のコードを考えてみよう。

x = x + 1

「？」と思うかもしれない。暗に方程式として考えるためであろう（私がそうだった）。これを右から左に読むとスッキリする。

  1. 上で100をxに割り当てたが、問題のコードの右辺のxがその100である。100に1を加えたものが101であり、それが右辺である。

  2. =を使い右辺の101を左辺のxに割り当てている。この時点で、100の参照記号であったxは101の参照記号に変更される。

実際にxを表示してみよう。

x

101

このように=を使う度に，右辺のデータが左辺の参照記号に割り当てられたり，割り当てが変更されたりすることになる。「品物と参照記号の関係」は今の段階ではそれ程重要ではないが，先に進むにつれて重要性が増してくるので，今のうちにこのようなイメージを持つと良いだろう。

Note

x = 101を考えてみよう。Pythonの公式ドキュメントでは，このように=が使われるコードを assignment statement と呼んでいる。一方，日本語版は assignment statement を「代入文」と訳し，=を「代入演算子」と呼んでいる。しかし英語では assignment（割り当て）と substitution（代入）は異なる意味を持ち，前者が参照記号と実態の関係をより正確に反映していると考えられる。このサイトでは参照記号と実態の違いを強調するために，「代入する」ではなく「割り当てる（assign）」という表現を使っている。

複数の変数の同時割り当て#

=を使い１つの変数への割り当てを考えたが、同時に複数の変数への割り当ても可能である。次の例を考えよう。（=の右辺から読む！）

a, b, c = 3.14, 10_000, 999

左から順番に次のように割り当てをおこなっている。

  • 3.14　→　a

  • 10_000　→　b

  • 999　→　c

それぞれの変数を,で区切っていることにも留意しよう。同様に，,で区切って変数を並べて実行すると全てを丸括弧で挟んで返すことになる。ここでの()は，後に説明するタプルと呼ばれるデータ型を表している。

a, b, c

(3.14, 10000, 999)

また同時複数割り当ては，変数の値を入れ替える場合に便利である。次の例ではaとbの値を入れ替えている。（右辺から読む！）

a, b = b, a

a, b, c

(10000, 3.14, 999)

Note

「複数の変数同時割り当て」と表現したが，ここで説明するタプルのアンパッキングと呼ばれる特徴を指している。

累算割り当て演算子#

上でx = x + 1が出てきたが、これを短縮してx += 1と書くことができる。次のコードを考えようてみよう。

x = 10
x += 1
x += 1
x += 1
x += 1
x += 1
x

15

コードセルの上から１行ずつ実行される。１行目で10がxに割り当てられる。２行目のx += 1はx = x + 1と同じなので，xは11になる。同様に，３行目でxは12になり同じ計算が６行目まで続くことになる。最後のxは割り当てられた値を表示するためのものであり，最終的に15になっていることがわかる。

同様に他の算術演算子についても次の様に書くことができる。

  • x = x - 1 \(\Rightarrow\) x -= 1

  • x = x * 10 \(\Rightarrow\) x *= 10

  • x = x / 10 \(\Rightarrow\) x /= 10

  • x = x ** 2 \(\Rightarrow\) x **= 2

  • x = x // 3 \(\Rightarrow\) x //= 10

  • x = x % 2 \(\Rightarrow\) x %= 2

x=2
x **= 2
x **= 2
x

16

x=201
x //= 2
x //= 2
x

50

予約語#

変数に値を割り当てることができるが，２つ注意点がある。

  1. 変数名をアルファベットで分かりやすい変数名にするのが可読性が高いコードを書くコツである。自分が書いたコードを数ヶ月後に読むとxやyが何の値を意味するのか分からない，という場合を避けるためである。

  2. 変数名を作る上で守らなくてはならないルールがある。

    • (a-z, A-Z)もしくは_（アンダースコア）で始める。

    • 最初の文字以外であれば(a-z, A-Z)と_に加え数字も可。

    • 長さに制限はない。

    • 小文字と大文字は異なる記号として認識される。

    • 次の単語は特定の目的のために事前に定義されている「予約語」なため，変数名としては使えない（使うとエラーが発生する）。

import keyword
keyword.kwlist

['False',
 'None',
 'True',
 'and',
 'as',
 'assert',
 'async',
 'await',
 'break',
 'class',
 'continue',
 'def',
 'del',
 'elif',
 'else',
 'except',
 'finally',
 'for',
 'from',
 'global',
 'if',
 'import',
 'in',
 'is',
 'lambda',
 'nonlocal',
 'not',
 'or',
 'pass',
 'raise',
 'return',
 'try',
 'while',
 'with',
 'yield']

これらに加え，

  • 変数の頭文字は小文字とする

というのが慣例（エラーにはならない）であり，大文字で始まる変数は通常classと呼ばれるオブジェクトに使う。

文字列型#

説明#

３つ目の基本データ型として文字列型を説明する。文字列は

'国内総生産'

'国内総生産'

のように'（シングル・クォーテーション）もしくは"（ダブル・クォーテーション）で挟まれて定義される。どちらを使っても同じだが，クォートの中でクォートを使う必要がある場合は，それぞれ違ったものを使う。例えば，

'He said "Python is very useful!" to me.'

'He said "Python is very useful!" to me.'

この例では，外側は'と'を使っており，内側は"と"を使っている。データ型を確認してみよう。

type('神戸大学')

str

strはstringの略である。次も文字列型となることには注意しよう。

'0.1'

'0.1'

  type('0.1')

str

後述する数字の加算や除算などはできない0.1である。一方で文字列型専用の「加算」と「乗算」があるので，そちらも後述する。

従って，0.1を使って算術演算をすることエラーが発生する。

1 + '1.0'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[34], line 1
----> 1 1 + '1.0'

TypeError: unsupported operand type(s) for +: 'int' and 'str'

+と*#

+は文字列型と他のデータ型とは一緒に使えないが，文字列同士であれば使うことができる。+は文字列を結合することになる。

'一人当たり' + 'GDP'

'一人当たりGDP'

'1.0' + '1.00'

'1.01.00'

一方で+がなくても同じように文字列を結合して返すことになる。

'一人当たり' 'GDP'

'一人当たりGDP'

+は文字列の結合を明示的にする目印と考えれば良いだろう。

また*を使うと文字列をリピートすることができる。

'(^o^)/   '*3

'(^o^)/   (^o^)/   (^o^)/   '

'-★'*20

'-★-★-★-★-★-★-★-★-★-★-★-★-★-★-★-★-★-★-★-★'

'😎🚀'*10

'😎🚀😎🚀😎🚀😎🚀😎🚀😎🚀😎🚀😎🚀😎🚀😎🚀'

ブール型#

説明#

次にブール型（boolでありbooleanの略）と呼ばれるデータ型を考える。ブール型には次の２つの値しかない。

  • True（真）

  • False（偽）

名前が示すように「真偽」を示すのがブール型であり，TrueとFalseをブール値（真偽値, truth value）と呼ぶ。

True

True

False

False

２つの値しかないが活躍の幅は広く，至る所で使うことになる。特に，ある条件が満たされる場合（True）と満たされない場合（False）を使い分けることで，様々な計算が可能となる。この点を説明するためには，比較演算子を説明するが，演算の結果としてTrueもしくはFalseが返されることになる。

比較演算#

次の演算子を使うことにより，変数の真偽を確認することができる。

  • ==（等号）

  • !=（等号不成立）

  • <（小なり）

  • >（大なり）

  • <=（小なりイコール，\(\leq\)と同じ）

  • >=（大なりイコール，\(\geq\)と同じ）

最初の==は「等号」が２つ並んでいるが，Pythonではこれが正しく「等号」を意味する。即ち，両辺が同値かどうかを確認することができるのである。例を考えよう。

10 == 10.0

True

データ型は異なるが，10という数値は同じなのでTrueが返されている。次の例でFalseが返されるのも簡単に理解できる。

10.1 == 10.0

False

一方，!=は==と逆の結果を返すことになる

10 != 10.0

False

10.1 != 10.0

True

残り４つの比較演算子は数学の不等号と同じように解釈すれば良いので問題ないだろう。

1 <= 10

True

1 >= 10

False

Note

=が含まれる比較演算子は必ず２つの記号（==，!=，>=，<=）から構成されているので覚えておこう。

ブール値（真偽値）#

10+5は何？もちろん15である。では10はTrueとFalseのどっち？「えっ？どういうこと？」と考えるかもしれないが，答えはTrueである。「Pythonでは全てがオブジェクトである」と言われるが（「オブジェクト」については後述する），全てのオブジェクトにはブール値がある。それを確かめる関数がbool()である。10のブール値を確認してみよう。

bool(10)

True

では何がTrueで何がFalseなのだろうか。

＜Falseと評価される値＞

  • False（当たり前だがブール値のFalse）

  • None

  • 0（整数型）

  • 0.0（浮動小数点型）

  • ''（空の文字列）

  • []（空のリスト）

  • ()（空のタプル）

  • {}（空の辞書）

  • range(0)

  • 等々

Noneは「無」の状態を表す値である。データ型を調べると次のようになる。

type(None)

NoneType

上のリストには説明していないものも含まれるが，Falseと評価されるのは「無」，「空」に対応する値と覚えておけば良いだろう。

bool(0)

False

bool("")

False

スペースも含めて，それら以外は全てTrueと評価される。

bool(' ')

True

ついでに「経済学はおもしろい！」という意見についてPythonが同意するか尋ねてみよう😎

bool('経済学はおもしろい！')

True

ブール演算#

関連する演算としてブール演算がある。次の演算子となる。

  • not：でない（反転もしくは否定）

  • and：且つ

  • or：又は

英語の意味のままなので，分かり易いのではないだろうか。注意する点は、ブール演算子が複数同時に使われる場合の計算の優先順位であり、次の順番となる。

  1. not

  2. and

  3. or

notが一番優先され、orの優先順位が一番低い。この順番を忘れると意図せぬ間違いにつながるので、()を使うことを推奨する。

例を考えるために，まず次の変数を設定しよう。

a = 1
b = -1

not#

まずnotから考えよう。「否定」なので次の様な挙動となる。

  • Trueの前に置くとFalseを返す。

  • Flaseの前に置くとTrueを返す。

not True

False

not (a > 1)

True

この結果は次のように解釈できる。まず()の中が優先的に評価されFalseが返される。更に，notで否定されるので結果はTrueとなる。（(not a) > 1は異なる結果となるので注意しよう。）次の結果も同様に解釈することができる。

not False

True

not (a < 1)

True

and#

次にandを考えよう。

True and True

True

「True且つTrue」なので全体ではTrueとなる。簡単に理解できるはずである。次も基本的には同じである。

(a > 0) and (b < 0)

True

次の例にはFalseが入っている。

False and True

False

(a < 0) and (b < 0)

False

or#

簡単なので解説は不要であろう。

True or False

True

(a > 0) and (b > 0)

False

andとorは何を返しているのか#

上の例を見るとandとorはTrueもしくはFalseのみを返しているような印象を持つかも知れないが，実はそうではない。次の条件に従って，andは左の変数もしくは右の変数を返している。orも同様である。

演算

結果

x or y

x がFalseなら y, そうでなければ x を返す

x and y

x がFalseなら x , そうでなければ y を返す

ここでTrueかFalseは，上で説明したブール値が使われる。次の例を考えよう。

'' or 5

5

空の文字列''のブール値はFalseになるため，上の表に従って5が返されている。上の表に従うと，次の例も理解できるだろう。

'' and 5

''

ブール値と数値#

全てのオブジェクトにはブール値があることを説明した。一方で，ブール値は次の数値と同値して扱われる。

  • True　→　1もしくは1.0

  • False　→　0

コードで確かめてみよう。

True == 1 # Trueは１なのでTrueを返す

True

False == 0 # Falseは0なのでTrueを返す

True

True + True + True

3

True * 10

10

今の段階でこの用途は明確ではないと思うが，データを扱う際は非常に便利に感じることだろう。

精度#

「コンピューターは非常に正確だ」というイメージを持っていないだろうか（私がそうだった）。実は，全くその逆である。次の計算をしてみよう。

0.3 == 0.1 + 0.1 + 0.1

False

「えっ！」と思うかもしれない。Falseということは，Pythonは左辺と右辺の値は異なると判断している。明らかに「おかしな」結果である。

なぜこうなるかを説明するために\(1/3\)を考えよう。

\(\dfrac{1}{3}=0.333333333333333333\cdots\cdots\cdots\)

永遠に3が続く。コンピュータのメモリの容量は有限であるため、無限に続く3をメモリに保存しすることは不可能である。従って、どこかで切断して\(1/3\)の近似値を保存する必要がある。これと同じようなことをPythonは行っている。10進法の数字を2進法に変換し，計算結果を10進法に変換し表示する。その際、多くの数字は\(1/3\)と同じように近似値となる。即ち，0.1と表示されていても，Pythonは実際には近似値を使っているため，誰でもおかしいと思う結果が発生することになる。

では0.1と0.3の近似値を表示してみよう。

Hide code cell source 
print('0.1の近似値\n','-'*9,'\n',format(0.1, '.55f'),sep='')
print('\n\n0.3の近似値\n','-'*9,'\n',format(0.3, '.55f'),sep='')

0.1の近似値
---------
0.1000000000000000055511151231257827021181583404541015625


0.3の近似値
---------
0.2999999999999999888977697537484345957636833190917968750

format(0.9, '.55f')

'0.9000000000000000222044604925031308084726333618164062500'

近似値と0.1もしくは0.3との差は非常に小さく，殆どの計算には支障がない程度になっている。これで0.3 == 0.1 + 0.1 + 0.1がFalseを返す理由が分かったが，この事から次のことが言える。

浮動小数点型に==を使い真偽を確かめるのは危険である。使わないように！

Note

では２つの浮動小数点型の真偽をどのように確かめれば良いのだろうか。２つの方法を紹介する。

  1. このセクションで説明するmathモジュールにあるisclose関数を使うことができる。この関数は２つの値が十分に近い場合はTrueを返す。例えば，次のコードはTrueを返すことになる。

import math
math.isclose(0.3, 0.1+0.1+0.1)

  1. この章で説明するNumPyと呼ばれる外部パッケージに含まれるisclose()関数を使うことができる。この関数も２つの値が十分に近い場合はTrueを返す。次のコードはTrueを返すことになる。

import numpy as np
np.isclose(0.3, 0.1+0.1+0.1)

上の例では小さな値を考えたが，大きい値の場合にも類似する問題が存在する。次を計算してみよう。

2.0**52

4503599627370496.0

2.0**52 == 2.0**52 + 1

False

この結果は期待どおりであるが，次の例はそうではない。

2.0**53

9007199254740992.0

2.0**53 == 2.0**53 + 1.0

True

これは浮動小数点型で正確に表示できる最大の数（有効桁数）に制限があるために発生する。2.0**53の例は有効桁数を超えているため対応不可能になり間違った結果を返している。一方，整数型には有効桁数に制限はないため，このような問題は発生しない。

2**53 == 2**53 + 1

False

コンテナデータ型#

上では基本となるデータ型を説明したが，そのような（それらだけではないが）データ型の集合となるデータ型も存在する。それがコンテナデータ型（Container Datatypes）と呼ばれるものであり，次の３種類について説明する

  • リスト（list）

  • タプル（tuple，「チュープル」とも呼ばれる）

  • 辞書（dict，dictionaryの略）

リスト#

説明#

リストは最も基本となるコンテナデータ型であり，次の特徴を持っている。

  • []を使って作成する。

  • 要素は,で区切る。

  • 要素を変更することが可能（mutable）。

例としてショッピング・リストを考えよう。

['bread', 'egg', 'ham']

['bread', 'egg', 'ham']

もちろん日本語でも構わない。

['パン', '玉子', 'ハム']

['パン', '玉子', 'ハム']

その価格を表すリストも作成しよう。

[100, 300, 250]

[100, 300, 250]

もちろん変数に割り当てることも可能である。

price_list = [100, 300 , 250]
price_list

[100, 300, 250]

type()関数を使ってデータ型を確認してみよう。

type(price_list)

list

リストのデータ型はlistと表示されることがわかる。また異なるデータ型が要素として入ることも可能である。

['egg', 100, True]

['egg', 100, True]

これもショッピングに関する情報だと考えることもできる。商品はeggは，価格は100，購入するかどうかはTrueといった具合である。

要素が１つのリストの生成も可能である（玉子の価格のみ）。

[100]

[100]

空のリストも作成可能であり，白紙ショッピング・リストと考えれば良いだろう。後々活躍することになる。

[]

[]

またリストの中にリストや他のデータ型（以下で説明するタプルや辞書など）を入れることも可能だ。ショッピング・リストの例から離れるが次の様に書くことできる。

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

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

整数型の0，空のリスト，そして要素の数が異なるリストが入っている。

次の例は行列のように要素が並んでいる。

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

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

+と*#

リストにも+を使うことができる。文字列と同じように，複数のリストを結合することができる。

[100,300,250] + ['egg','ham','bread']

[100, 300, 250, 'egg', 'ham', 'bread']

また*は整数型の値を使うことにより，要素をリピートして一つのリストとして返すことになる。

['egg', 100] * 3

['egg', 100, 'egg', 100, 'egg', 100]

[['egg']+[100], ['ham']*2, 'bread']

[['egg', 100], ['ham', 'ham'], 'bread']

タプル#

説明#

主な特徴：

  • 基本的には()を使って作成する。

    • 実はコンマ,によってタプルは定義されるため(と)は必須ではない。

  • 要素は,で区切る。

  • 要素を変更すること不可能（immutable）。

まずリストで使ったショッピング・リストの例を考えよう。

('egg', 'ham', 'bread')

('egg', 'ham', 'bread')

変数に割り当てて，データ型を確認してみよう。

price_tuple = (100, 300 , 250)

type(price_tuple)

tuple

タプルのデータ型はtupleと表示される。次の例では異なるデータ型が要素として入っている。

('egg', 100, True)

('egg', 100, True)

上でも触れたが，タプルは(と)が無くても作成できる。例えば、次のコードでもタプルとなる。

'egg', 100, True

('egg', 100, True)

タプルは，コンマ,によってタプルは定義されるためであり，()はタプルを明確にするためと考えて良いだろう。

上の例が示すように，コードセルで,を使いコードを書き実行するとタプルが変えることがわかる。例えば，次のコードもタプルを返し，個々の要素がそれぞれのコードの実行結果となっている。

x = 10
y = 3

True * 3 == y, x/y, type(y)

(True, 3.3333333333333335, int)

また要素が１つのタプルも生成可能だが，その場合も必ず,を付ける事を忘れないように。

('1',)

('1',)

例えば，次のコードは整数型の10になる。type()関数を使って確認してみよう。

(10), type((10))

(10, int)

２つの実行結果がタプルとして返されている。

タプルの中にタプルや他のデータ型を入れることも可能だ。例えば，

(0, ['egg', 100], (3,4,5))

(0, ['egg', 100], (3, 4, 5))

ここで['egg', 100]はリストである。

+と*#

リストと同じように，+は結合に使うことができる。

(100, 300, 250) + ('egg','ham','bread')

(100, 300, 250, 'egg', 'ham', 'bread')

また*を使うと要素を整数回リピートしたタプルを作成することができる。

('egg', 100) * 3

('egg', 100, 'egg', 100, 'egg', 100)

辞書#

説明#

主な特徴：

  • {}を使って作成する。

  • 辞書（dictionary）はキー（key）と値（value）のペアが１つの要素となる。

  • １つの要素は:を挟んで左側にキーがあり，右側に値がくる。全てを{}で囲み辞書を定義する。

  • キーは変更不可（immutable）だが，値は変更可能（mutable）

ショッピング・リストの例を考えよう。

{'egg':100, 'ham':300, 'bread':250}

{'egg': 100, 'ham': 300, 'bread': 250}

各要素は商品と価格のペアになっている。１つ目の要素は'egg':100であり，'egg'がキーとなり，100が値である。２つ目の要素のキーは'ham'，値は300となっている。今の段階では辞書を使う目的が不明確でしっくりこないと思うが，勉強を進めるととてもパワフルなツールだと気づくだろう。

変数に割り当てて，データ型を調べてみよう。

dic = {'失業率':0.05, 'インフレ率':0.01}

type(dic)

dict

辞書のデータ型はdictであることがわかる。

値は様々なデータ型を設定できる。リストやタプル，辞書も値として指定できる。

{'a':(1,2), 'b':[3,4], 'c':True, 'd':{'県':'兵庫', '市':'神戸'}}

{'a': (1, 2), 'b': [3, 4], 'c': True, 'd': {'県': '兵庫', '市': '神戸'}}

この特性を利用して，学生の成績を格納しておくことも考えられる。

mark = {'1234567e':{'経済学':95, '統計学':83, 'ゼミ':100},
        '7654321e':{'経済学':65, '統計学':73, 'ゼミ':85},
        '1234321e':{'経済学':60, '統計学':99, 'ゼミ':65}}
mark

{'1234567e': {'経済学': 95, '統計学': 83, 'ゼミ': 100},
 '7654321e': {'経済学': 65, '統計学': 73, 'ゼミ': 85},
 '1234321e': {'経済学': 60, '統計学': 99, 'ゼミ': 65}}

キーは変更不可能な次のデータ型が使える。

  • 文字列型

  • 整数型

  • 不動小数点型

  • タプル

{'egg':100, 5:100, 1.001: False, (1,2):'B'}

{'egg': 100, 5: 100, 1.001: False, (1, 2): 'B'}

辞書の結合#

リストとタプルの結合には+を使うことができたが，辞書では使えない。その代わりに，Python3.9以降であれば|（「パイプ」と読む）が使える。

x = {'egg':100, 'ham':100}
y = {'ham':300, 'bread':250} 

x | y

{'egg': 100, 'ham': 300, 'bread': 250}

xには'ham':100があり，yには'ham':300がある。結合すると，|の右側にあるxの'b'が上書きされていることに注意しよう。

Python3.8以前であれば次の構文となる。

{**x, **y}

{'egg': 100, 'ham': 300, 'bread': 250}

所属検査演算#

次の演算子を使うと所属関係を確認することができる。

  • in：あるデータがコンテナデータの要素であればTrue，そうでなければFalseを返す。

  • not in：inの結果を反転させたブール値を返す。

例を考えよう。

lst = [['egg', 'ham'], 100, 300]

tpl = (('egg', 'ham'), 100, 300)

dic = {'egg':100, 'ham':300}

100がlstに含まれるかは次のコードで確認できる。

100 in lst

True

not inの場合は次のようになる。

100 not in lst

False

入れ子の場合は，次のような挙動となる。

'egg' in lst

False

['egg','ham'] in lst

True

タプルの場合も同じである。

100 in tpl, 100 not in tpl, 'egg' in tpl, ('egg','ham') in tpl

(True, False, False, True)

辞書の場合は，キーの確認に対応している。

'egg' in dic, 'egg' not in dic

(True, False)

in演算子は文字列にも使うことができる。

'egg' in 'breadeggham'

True

まとめ#

＜基本データ型＞

データ型

例

整数型（int）

10

不動小数点型（float）

10.0

文字列型（str）

'10.0' もしくは "10.0"

ブール型（bool）

True もしくは False

＜算術演算＞

算術演算子

例

動作・戻り値

+

10+2　→　12

加算

-

10-2　→　8

減算

*

10*2　→　20

乗算

/

10/2　→　5.0

除算

**

10**2　→　100

累乗

//

11//2　→　5

剰余演算

%

11%2　→　1

切り捨て除算

＜文字列＞

文字列型に使う

例

動作・戻り値

+

'神戸' + '大学'　→　'神戸大学'

結合

+がなくても

'神戸' '大学'　→　'神戸大学'

結合

*

'★'*5　→　'★★★★★'

文字列を整数個返す

＜比較演算＞

比較演算子

例

意味

==

10 == 10　→　True

等号

!=

11 != 10　→　True

等号不成立

<

5 < 10　→　True

小なり

>

10 > 5　→　True

大なり

<=

5 <= 10　→　True

小なりイコール

>=

10 >= 5　→　True

大なりイコール

＜ブール演算＞

ブール演算子

例

意味

not

not True　→　False

否定

and

True and False　→　False

且つ

or

False or True　→　True

又は

＜コンテナデータ型＞

データ型

例

リスト

[0,1,3]

タプル

(0,1,3)

辞書

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

＜コンテナデータ型の結合＞

データ型

例

結合方法

リスト

x = [0,10]
y = [30]

x + y　→　[0,10,30]

タプル

x = (0,10)
y = (30,)

x + y　→　(0,10,30)

辞書

x = {'a':0}
y = {'b':10}

x | y 又は {**y,**x}　→　{'a':0,'b':10}

＜所属確認演算＞

ブール演算子

例

演算

in

x = [1,2]

2 in x　→　True

not in

x = [1,2]

2 not in x　→　False
Contents