The Japanese translation of "A Whirlwind Tour of Python" - Built-In Types: Simple Values

http://nbviewer.jupyter.org/github/jakevdp/WhirlwindTourOfPython/blob/master/05-Built-in-Scalar-Types.ipynb

# 組み込みの型：単純な値
Pythonの変数とオブジェクトについて話すとき、すべてのPythonのオブジェクトは付属された型情報をもつという事実を述べました。ここで、Pythonで提供される組み込みの型を簡単にみてみましょう。いくつかの複合的な型と対照的に単純な型というのは、次の節で話されます。
Pythonのシンプルな型は次の表でまとめられます。

```
**Python Scalar Types**
Type	Example	Description
int	x = 1	integers (i.e., whole numbers)
float	x = 1.0	floating-point numbers (i.e., real numbers)
complex	x = 1 + 2j	Complex numbers (i.e., numbers with real and imaginary part)
bool	x = True	Boolean: True/False values
str	x = 'abc'	String: characters or text
NoneType	x = None	Special object indicating nulls
```
順にこれらのそれぞれで手早くみていきましょう。

## 整数
たいていの基本的な数値型は整数型です。小数点を除き、いかなる数も整数です。

```
In [1]:
x = 1
type(x)
Out[1]:
int
```
Pythonの整数は実際、Cのような言語の整数よりもかなり洗練されています。Cの整数は、固定精度で、たいていいくつかの値がオーバーフローします（しばしば 231231 または 263263 のそば、環境に依存します）。Pythonの整数は変動精度で、他の言語でオーバーフローする計算ができます。

```
In [2]:
2 ** 200
Out[2]:
1606938044258990275541962092341162602522202993782792835301376
```
Pythonの整数の他の便利な機能はデフォルトで、浮動小数点型に型をこえて除算することです。

```
In [3]:
5 / 2
Out[3]:
2.5
```
この超過はPython3の機能です、Python2ではCのような多くの静的型付け言語のように、整数の除算はいかなり少数も切り捨てて、いつも整数を返します。

```
# Python 2 behavior
>>> 5 / 2
2
```
Python3でのふるまいをおさえるために、切り捨て除算演算子を使いましょう：

```
In [4]:
5 // 2
Out[4]:
2
```
最後に、Python2.xではintとlong型両方とももっていたけども、Python3はこれら二つを一つのint型のふるまいに結合したことに留意しましょう。

## 浮動小数点数
浮動小数点型は、少数をためることができます。それらは標準的な少数表記か指数表記のどちらかで定義されることができます。

```
In [5]:
x = 0.000005
y = 5e-6
print(x == y)
True
In [6]:
x = 1400000.00
y = 1.4e6
print(x == y)
True
```
指数表記では、eまたはEが "...を...に10かける"と読めますので、1.4e6は 1.4x10^6のように解釈されます。
整数は明示的にfloatのコンストラクタでfloatに変換されます。

```
In [7]:
float(1)
Out[7]:
1.0
```

## 余談： 浮動小数点精度
浮動小数点の算出に気づくことは、その精度が限定されているということです、つまり等価のテストが不安定になります。例えば、

```
In [8]:
0.1 + 0.2 == 0.3
Out[8]:
False
```
なぜこんな場合が？それはPythonで固有のふるまいとならないからですが、科学的計算のプラットフォームとか全部ではないが、たいてい使われる二進の浮動小数点の容量が固定精度形式のためです。浮動小数点数を使うすべてのプログラミング言語はビットの固定数の中にためて、ほぼ表現するためだけのいくつかの数となります。高精度に三つの値を表示してみてましょう。：

```
In [9]:
print("0.1 = {0:.17f}".format(0.1))
print("0.2 = {0:.17f}".format(0.2))
print("0.3 = {0:.17f}".format(0.3))
0.1 = 0.10000000000000001
0.2 = 0.20000000000000001
0.3 = 0.29999999999999999
```
私たちは10をベースにした10進数表記について考えるのがなれているので、各々の端数は10の累乗の合計として表現されます。
1/8 = 1*10^-1 + 2*10^-2 + 5*10^^3
10進を基本とした標記に近いもので、より親しみやすい10進標記でこれを 0.125 と表現します。

たいていのコンピュータは二進表記で値をためますので、各々の数は2の累乗の総計として表現されます。
1/8=0*2^-1+0*2^-2+1*2^-3
2ベースの表現で、こうやって書きます、

```math
0.001_2
```

補完部の2は二進数であることを示しています。

```math
0.125=0.001_2
```
は、値が一方の数になってます、その数は二進十進の両方の表記が数値が有限の数で現れることができるということです。

似たような10をベースにした数の表現では、たぶん数の有限の数値であらわせない数値とわかるでしょう。例えば、11を33で割ることは標準的な数値表現では

```
1/3=0.333333333⋯
```
連続した3は永遠に続きます、すなわち、本当にこの商を表現するために、求められる桁数は無限です！

同様に、無限の桁数を求める二進表記についての数があります、例えば

```math
1/10=0.00011001100110011⋯_2
```
ちょうど10進表記は完全に、1/3を表現するための無限の桁数を求めて、二進表記は1/10の表現をするための無限の桁数を求めます。Pythonは内部的に、たいていのシステムで最初の非ゼロのbitからはるかの超えて52bitで、これらの表現を捨てます。

この浮動小数点の値についての丸め誤差は、浮動小数点数で動作する必要悪です。それを扱う最高の方法は、いつも浮動小数の算術がおおよそであることを気にかけることです。そして、浮動小数点の値で等価のテストを確かめることに決して頼らないことです。

## 複素数
複素数は実と虚（浮動小数点数）部を伴う数です。整数と前の実数を見つけてきました。つまり複素数を作るために、これらを使うことができます。

```
In [10]:
complex(1, 2)
Out[10]:
(1+2j)
```
または、虚数部を示すために表現としてj接尾辞を使うことができます：

```
In [11]:
1 + 2j
Out[11]:
(1+2j)
```
複素数は、多様な興味深い属性とメソッドをもっています、それは簡単にはこう示せます：

```
In [12]:
c = 3 + 4j
In [13]:
c.real  # real part
Out[13]:
3.0
In [14]:
c.imag  # imaginary part
Out[14]:
4.0
In [15]:
c.conjugate()  # complex conjugate
Out[15]:
(3-4j)
In [16]:
abs(c)  # magnitude, i.e. sqrt(c.real ** 2 + c.imag ** 2)
Out[16]:
5.0
```

## String Type
Pythonの文字列はシングルまたはダブルクォートで作られます。

```
In [17]:
message = "what do you like?"
response = 'spam'
```
Pythonは多くの極度に使いやすい文字列関数とメソッドをもってます。ここではそれらのいくつかを紹介します：

```
In [18]:
# length of string
len(response)
Out[18]:
4
In [19]:
# Make upper-case. See also str.lower()
response.upper()
Out[19]:
'SPAM'
In [20]:
# Capitalize. See also str.title()
message.capitalize()
Out[20]:
'What do you like?'
In [21]:
# concatenation with +
message + response
Out[21]:
'what do you like?spam'
In [22]:
# multiplication is multiple concatenation
5 * response
Out[22]:
'spamspamspamspamspam'
In [23]:
# Access individual characters (zero-based indexing)
message[0]
Out[23]:
'w'
```
Pythonに搭載されているよりおおくの話は、"Lists"を見てください。

## None型
PythonはNonTypeという特別な型を含んでいます、これは唯一単純な値をもっているだけです、Noneです、たとえば：

```
In [24]:
type(None)
Out[24]:
NoneType
```
あなたは多くの場所でNoneが使われるのをみるでしょうが、たぶんたいていは一般的に関数のデフォルトの戻り値として使われます。例えば、Python3のprint()関数は何も返しませんが、それでもその値をとらえることができます：

```
In [25]:
return_value = print('abc')
abc
In [26]:
print(return_value)
None
```
同様に、値を返さないPythonのどの関数も、現実には、Noneを返します。

## ブール型
ブール型は二つの値をもつ可能性のある単純な型です。TrueとFalseで、それは前に話した比較演算子によって返されます：

```
In [27]:
result = (4 < 5)
result
Out[27]:
True
In [28]:
type(result)
Out[28]:
bool
```
ブール値は大文字と小文字を区別することに留意してください。いくつかの他の言語とちがって、TrueとFalseは大文字ではじめないといけないです。

```
In [29]:
print(True, False)
True False
```
ブールはまたbool()オブジェクトコンストラクタを使って作れます、任意の他の型の値は、予想されうるルールによって、ブールに変換されます。例えば、任意の数値型は0と等しい場合Falseになります、そしてさもなければTrueですね：

```
In [30]:
bool(2014)
Out[30]:
True
In [31]:
bool(0)
Out[31]:
False
In [32]:
bool(3.1415)
Out[32]:
True
```
Noneのブール変換はいつもFalseです：

```
In [33]:
bool(None)
Out[33]:
False
```
文字列について、空の文字列ではbool(s)はFalseです、そしてさもなければTrue：

```
In [34]:
bool("")
Out[34]:
False
In [35]:
bool("abc")
Out[35]:
True
```
シーケンス型について、次の節で見るんですが、ブールの表現は空のシーケンスでFalseで、他のどんなシーケンスでTrueです。

```
In [36]:
bool([1, 2, 3])
Out[36]:
True
In [37]:
bool([])
Out[37]:
False
```