Pythonデータ型入門
この記事では、Pythonの基本的なデータ型に潜入します。
これらはデータを表現する基本的な方法のいくつかを形成しています。
これらの基本的なデータ型を分類する1つの方法として、4つのグループのうちの1つに分類されます。
- 数値型：
int,floatと、あまり見かけないcomplexです。 - シーケンス。文字列:
str(文字列)、list、tuple(タプル) - ブール演算子: (
TrueまたはFalse) - 辞書:
dict(辞書) データ型、(key, value)ペアから構成されます。
ここで重要なのは、Pythonは通常どのようなデータ型を使用するかを指定する必要はなく、あなたが何を意味していると考えるかに基づいて変数にデータ型を割り当てるということです。
同様に重要なことは、Pythonは「緩く/弱く型付けされた」プログラミング言語であるということです。
これは、変数がプログラムの実行中にその型を変えることができるということで、（JavaやC++などの）「強く型付けされた」プログラミング言語の場合とは異なります。
つまり、int型であったものが、文字列を代入すると、簡単にstr型になってしまうのです。
この例では、 type(variable) という関数を使って、渡した変数の型を返すことがあります。
また、Pythonのシェルを使うので、表示したいものをすべて表示するような面倒なコードは必要ありません。
数値データ型
これらのデータ型は非常に単純なもので、数値を表します。
これらは10進数、浮動小数点数、あるいは複素数であることがあります。
Integer データ型 – int
int` データ型は、整数の値を扱います。
つまり、0, 1, -2, -15 のような値で、0.5, 1.01, -10.8 などのような数値ではありません。
Pythonに次のようなコードを与えると、Pythonは a が整数であると判断し、 int データ型を割り当てます。
>>> x = 5
>>> type(x)
<class 'int'=""
Pythonが 5 を整数として理解するように、もっと具体的にこのようなことを言うこともできますが、ボンネットの中で自動的にこれと全く同じことをします。
>>> x = int(5)
>>> type(x)
<class 'int'=""
Pythonは（接頭辞のない）どんな数列も10進数として扱うことは注目に値します。
この数列は、実は制約を受けません。
つまり、Java のような他の言語とは異なり、 int の値には最大値がありません – それは無制限です。
sys.maxsize` は整数の最大値を意味するので、直感に反するように聞こえるかもしれませんが、そうではありません。
>>> x = sys.maxsize
>>> x
2147483647
これは32ビットの符号付きバイナリ整数の値のように見えますが、xにもっと大きな数値を代入するとどうなるかを見てみましょう。
>>> x = sys.maxsize
>>> x+1
2147483648
実は、次のようにすることもできる。
>>> y = sys.maxsize + sys.maxsize
>>> y
4294967294
整数の大きさの唯一の制限は、Pythonを実行しているマシンのメモリです。
整数の接頭辞
数値を別の形式でパックしたいときはどうすればよいでしょうか。
一連の数値に接頭辞を付けて、Pythonに異なるシステムで扱うように指示することができます。
具体的には、以下のような接頭辞があります。
- 0b
または0B` – 整数を 2 進数に変換します。 - 0o
または0O` – 整数を 8 進数に変換します。 - 0x
または0X` – 整数を 16 進数に変換します。
では、これらを試してみましょう。
# Decimal value of 5
>>> x = 5
>>> x
5
# Binary value of 1
>>> x = 0b001
>>> x
1
# Octal value of 5
>>> x = 0o5
>>> x
5
# Hexadecimal value of 10
>>> x = 0x10
>>> x
16
浮動小数点データ型 – float
float` データ型は、小数点以下15桁までの浮動小数点数を表現することができます。
つまり、0.3, -2.8, 5.542315467 などの数値だけでなく、整数も扱えるということです。
ドットの後に15個以上の数字がある数値は切り捨てられます。
例えば、Pythonは次のようなものを float として正しく理解することは困難ではありません。
>>> y = 2.3
>>> type(y)
<class 'float'=""
>>> y = 5/4
>>> type(y)
<class 'float'=""
しかし、前に述べたように、もし 5 とだけ言った場合、Python はそれを int データ型とみなします。
もし、何らかの理由で float という変数に 5 という値を持たせたい場合は、Python に明示的に知らせる必要があります。
>>> y = 5.0
>>> type(y)
<class 'float'=""
>>> y = float(5)
>>> type(y)
<class 'float'=""
このデータ型は、 NaN (“Not a Number”) や +/-∞、指数などの特別な「数」を表現するために使用することができます。
>>> y = float('-infinity')
>>> y
-inf
>>> y = float(5e-3)
>>> y
0.005
>>> y = float('nan')
>>> y
nan
ここで、一つ興味深い余談があります。
それは、NaNがどのように振る舞うかということです。
つまり、 y == float('nan') を実行すると、 y はまあ、数字ではないのに、 False を返します。
実際、値と参照を比較することで、この挙動はおかしいとわかる。
>>> x = float('nan')
>>> x == float('nan')
False
>>> x == x
False
>>> x is x
True
もちろん、これは NaN がこのように動作するように意図されているから起こることですが、それでも興味深いことです。
もし、 == と is 演算子の違いに馴染みがなければ、 Python のオブジェクト比較 – == vs is をご覧ください!
複素数 – 複素数
最後に扱うべき数値型は complex 型です。
これはめったに使われないデータ型で、その仕事は虚数を複素数のペアで表現することです。
数学でよく使われる i とは異なり、 j という文字を使って数値の虚数部を表現します。
これは、Pythonが、複素数の虚数部分を名付ける数学的な慣習ではなく、電気工学的な慣習に従っているためです。
それでは、Pythonで複素数をどのように宣言するか見てみましょう。
# Assigning a value of 0r and 1j to `com`
>>> com = 1j
# Printing `com`s value
>>> com
1j
# Multiplying complex numbers
>>> com*com
(-1+0j)
# Assigning a value to a new `com` number
>>> com2 = 3 + 1j
# Adding two complex numbers
>>> com+com2
(3+2j)
# Assigning a new value to `com`
>>> com = complex(1 + 2j)
# Printing `com`
>>> com
(1+2j)
シーケンスデータ型
Sequence データ型は、ある種のコレクションを表現するために使用されます。
これらの要素の集まりは、同じ型の要素で構成されることも、全く異なる型の要素で構成されることもあります。
スト
文字列とは、一重引用符または二重引用符で表される文字の並びのことです。
これには空文字列 (引用符の間に文字がない) も含まれる。
整数と同じように、文字列にも長さの制限はありません。
コンピュータのメモリが許す限り、文字列を作成することができます。
文字列は、一連の文字、つまり言葉を表現する最も基本的な方法なので、非常によく使われます。
>>> my_string = 'some sequence of characters'
>>> my_string
'some sequence of characters'
>>> type(my_string)
<class 'str'=""
文字列には特殊な値を含めることもできます。
たとえば、文字列を印刷するときに改行したい場合は n を、や `'`、`"` などの特殊文字を使用する場合は などのように前にバックスラッシュを追加する必要があります。
バックスラッシュを付加することは、特殊文字をエスケープすることと同じです。
>>> my_string = "adding a new line
and some double quotes " to the string"
>>> print(my_string)
adding a new line
and some double quotes " to the string
すべての ' や " の前にバックスラッシュを追加することを気にしない別の方法は、代わりに ''' (トリプルクォート) を使うことで、Pythonが必要なところにバックスラッシュを追加してくれます。
>>> my_string = '''No need to worry about any ' or " we might have'''
>>> my_string
'No need to worry about any ' or " we might have'
フロートをストリングに変換して、Pythonの “弱い型付け “の性質を示すことができます。
# Assigning float value to `z`
>>> z = 5.2
# Checking for the type of `z`
>>> type(z)
<class 'float'=""
# Printing the value of `z`
>>> z
5.2
# Changing `z` into a string
>>> z = str(z)
# Checking the type of `z`
>>> type(z)
<class 'str'=""
# Printing the value of `z`
>>> z
'5.2'
z` が大した問題なく型変換されたことがわかります。
リスト
文字列とは異なり、リストは任意のデータ型の順序付きシーケンスを含むことができ、同じリスト内に複数の異なるデータ型を含むこともできます。
リストは、[element1, element2] のように [] の間にリストの要素を与えるか、単に [] と記述して後で要素を追加することで作成されます。
リストの反転、ソート、クリア、拡張のほか、アペンド（末尾への挿入）、特定の位置への要素の挿入・削除などのメソッドが組み込まれている。
要素にはリスト内のインデックスでアクセスすることができ、インデックスは 0 から始まります。
例えば、 some_list という名前のリストに対して、リストの最初の要素（空でない場合）を見るには、 some_list[0] を使用することができ、リストの他のすべての要素に対しても同じことが言えます。
また、これらの要素は some_list[i] = new_value と記述することで、インデックス i で変更することができます。
それでは、リストを作って、それに対していくつかの操作を行ってみましょう。
# Making an empty list
>>> some_list = []
# Printing the value of the list
>>> some_list
[]
# Checking the type of the list
>>> type(some_list)
<class 'list'=""
# Appending an integer to the list
>>> some_list.append(5)
# Printing the value of the list
>>> some_list
[5]
# Inserting an element at the `0`th index
>>> some_list.insert(0, 'some string')
# Printing the value of the list
>>> some_list
['some string', 5]
# Printing the value of the element on the `1`st index
>>> some_list[1]
5
# Appending another element ot the list
>>> some_list.append(123)
# Printing the value of the list
>>> some_list
['some string', 5, 123]
# Assigning the second element, an already existing value, to a new value
>>> some_list[2] = 'a'
# Printing the value of the list
>>> some_list
['some string', 5, 'a']
しかし、型が不一致のリストをソートしてみようとすると
>>> some_list.sort()
Traceback (most recent call last):
File "<stdin", line 1, in <module
TypeError: '<' not supported between instances of 'int' and 'str'
intは<演算子でstr` と比較することができないので、エラーが発生します。
>>> some_list = [1, 6, 4, 2, 8, 7]
>>> some_list
[1, 6, 4, 2, 8, 7]
>>> some_list.sort()
>>> some_list
[1, 2, 4, 6, 7, 8]
ソートすることができました。
タプル
タプルデータタイプはリストと非常に似ていますが、唯一の違いはイミュータブルであることと、 [] の代わりに () を用いて作成されることです。
つまり、一度 tuple を作成すると、その中に含まれる値を変更することはできない。
ほとんどの場合、リストよりもわずかに高速で、データを変更されないように保護するために使用されます。
# Creating a tuple
>>> some_tuple = ("some string", 5, True, float('nan'))
# Printing the value of a tuple
>>> some_tuple
('some string', 5, True, nan)
# Accessing an element of a tuple
>>> some_tuple[0]
'some string'
# Accessing elements from given index to the end of the tuple
>>> some_tuple[1:]
(5, True, nan)
# Accessing elements from given index to another given index
>>> some_tuple[1:3]
(5, True)
# Trying to assign a new value to the element at the `0`th index
>>> some_tuple[0] = 'some other string' # Causes an error
ブール型 – bool
boolデータ型は、ブーリアン値 -TrueまたはFalse` を表すために使用されます。
このデータ型は他の値を含むことはできません。
しかし、Pythonはほとんどのものをそれほど問題なく bool に変換します。
例えば、 bool(5) と言った場合、Python は True と判断し、 bool(0) と言った場合は False と判断します。
基本的には、 0 が false で、 1 が true となる。
1以降は同様にTrueとして扱われる。
文字列についても同様で、空の文字列を代入した場合はFalse` として扱われます。
この真偽判定(Pythonでは真偽判定とも呼ばれる)は、Pythonが bool 値を期待するすべてのコンテキストで暗黙のうちに行われます。
例えば、 if(5) と言えば、 if(bool(5)) と同じ効果、つまり if(True) と同じ効果を持ちます。
それでは、どのようにブール値を宣言し、使用するかを見てみましょう。
# Declaring a boolean
>>> some_bool = True
# Printing a boolean's value
>>> some_bool
True
# Checking a boolean's type
>>> type(some_bool)
<class 'bool'=""
# Assigning an empty string to a boolean
>>> some_bool = bool('')
# Checking the boolean's value
>>> some_bool
False
TrueとFalseはキーワードであり、trueやfalse` とは言えないことに注意してください。
>>> some_bool = false
# Throws an error
辞書タイプ – dict
Sequence データ型グループとは異なり、dict (辞書) は順序付けされないコレクションです。
具体的には、「(キー, 値)`」のペアのコレクションを、順番に並べないようにします。
これは、例えばリストとは異なり、値はキーに関連づけられ、整数のインデックスには関連づけられないことを意味します。
辞書は以下のような構造をしている。
{
key1 : value1,
key2 : value2,
....
keyN : valueN
}
キーは一意でなければならないが、値はそうでないことに注意することが重要である。
ある値を調べたいときは、キーを渡してそのペアを取り出す。
辞書は {} の間に (key, value) ペアを追加することで作成できます（[] はリスト、() はタプルを表すことを覚えておいてください）、あるいは単に空の {} を書き、後でペアを追加します。
キーと値は様々なデータ型にすることができる。
# Checking the value of a dict
>>> type({})
<class 'dict'=""
# Assigning keys and values to a dict
>>> some_dict = { 5 : 'five', 4 : 'four'}
# Printing the value of a dict
>>> some_dict
{5: 'five', 4: 'four'}
# Accessing a dict element via its key
>>> some_dict[5]
'five'
# Assigning a new value to a key
>>> some_dict[6] = 'six'
# Printing the value of the dict
>>> some_dict
{5: 'five', 4: 'four', 6: 'six'}
# Removing the (key, value) pair that has the key 5 (this also returns the value)
>>> some_dict.pop(5)
'five'
# Trying to access an element with the key 5
>>> some_dict[5] # Raises an error since the key 5 no longer exists
結論
Pythonは、コードを曖昧にしすぎず、できるだけコードを書きやすくするように書かれています。
しかし、その書きやすく弱い型付けは、他の人があなたのコードを見たとき、またはあなたがコードを書いてからしばらくしてそれを再検討するときに、混乱につながる可能性があります。
曖昧になる可能性がある場合は、正確な型を書き、異なる型の変数名を再利用しないようにするのがよい習慣です。
</module