1.2.2. 基本的な型

1.2.2.1. 数値型

ちなみに

Python は以下の数値型、スカラー型をサポートしています:

Integer:
>>> 1 + 1

2

>>> a = 4

>>> type(a)   

<type 'int'>
Floats:
>>> c = 2.1

>>> type(c)   

<type 'float'>
Complex:
>>> a = 1.5 + 0.5j

>>> a.real

1.5

>>> a.imag

0.5

>>> type(1. + 0j)   

<type 'complex'>
Booleans:
>>> 3 > 4

False

>>> test = (3 > 4)

>>> test

False

>>> type(test)      

<type 'bool'>

ちなみに

Python シェルは基本的な算術演算 +, -, *, /, % (剰余)がそのまま使えるため電卓代わりに使うこともできます

>>> 7 * 3.

21.0

>>> 2**10

1024

>>> 8 % 3

2

型変換(キャスト):

>>> float(1)

1.0

警告

整数の除算

Python 2 では:

>>> 3 / 2   

1

Python 3 では:

>>> 3 / 2   

1.5

安全のために: 浮動小数点数を使いましょう:

>>> 3 / 2.

1.5



>>> a = 3

>>> b = 2

>>> a / b # In Python 2  

1

>>> a / float(b)

1.5

将来的なふるまい: 常に Python3 の場合と同様にふるまいます

>>> from __future__ import division  

>>> 3 / 2  

1.5

ちなみに

明示的に整数での除算を利用したい場合は // を使います:

>>> 3.0 // 2

1.0

注釈

除算演算子の挙動は Python 3 で変化しました。 Python 3.

1.2.2.2. コンテナ

ちなみに

Python はたくさんの効率よいコンテナ型を提供していて、これらはオブジェクトの集まりを記録できます。

1.2.2.2.1. リスト

ちなみに

リストは順序つきのオブジェクトの集まりです、要素となるオブジェクトは異なる型を取ることができます。例:

>>> l = ['red', 'blue', 'green', 'black', 'white']

>>> type(l)     

<type 'list'>

インデクス指定: リストが含む個々のオブジェクトにアクセス:

>>> l[2]

'green'

負のインデクスは末尾から数えます:

>>> l[-1]

'white'

>>> l[-2]

'black'

警告

インデクスは 0 から始まります (C のように) 1 から (Fortran や Matlab のように) ではありません!

スライス: 規則正しく並んだ要素からなる部分リストを得る:

>>> l

['red', 'blue', 'green', 'black', 'white']

>>> l[2:4]

['green', 'black']

警告

l[start:stop] はインデクス start<= i <stop を満す i (i は start から stop-1 までの値をとる) の要素を含むことに注意しましょう. したがって l[start:stop] は (stop-start) 個の要素を持ちます.

スライス構文: l[start:stop:stride]

ちなみに

全てのスライスの引数は必須ではありません:

>>> l

['red', 'blue', 'green', 'black', 'white']

>>> l[3:]

['black', 'white']

>>> l[:3]

['red', 'blue', 'green']

>>> l[::2]

['red', 'green', 'white']

リストは 変更可能 なオブジェクトなので変更できます:

>>> l[0] = 'yellow'

>>> l

['yellow', 'blue', 'green', 'black', 'white']

>>> l[2:4] = ['gray', 'purple']

>>> l

['yellow', 'blue', 'gray', 'purple', 'white']

注釈

リストの要素は異なる型でも構いません:

>>> l = [3, -200, 'hello']

>>> l

[3, -200, 'hello']

>>> l[1], l[2]

(-200, 'hello')

ちなみに

同じ型を持つ数値データの集まりを扱うには、numpy モジュールが提供する array 型を使うことがしばしば より効率的 です。NumPy の配列は固定サイズのメモリ上のかたまりです。Numpy の配列を使うと, 要素が規則正しく並んでいることと、Python のループでは無く配列操作用の C 関数によって操作されるため, 要素に対する演算を速く行なうことができます。

ちなみに

Python はリストを変更、照会するための多くの関数を提供します. ここでは少数の例を挙げますが、詳しくは https://docs.python.org/tutorial/datastructures.html#more-on-lists を見てください.

要素の追加と削除:

>>> L = ['red', 'blue', 'green', 'black', 'white']

>>> L.append('pink')

>>> L

['red', 'blue', 'green', 'black', 'white', 'pink']

>>> L.pop() # removes and returns the last item

'pink'

>>> L

['red', 'blue', 'green', 'black', 'white']

>>> L.extend(['pink', 'purple']) # extend L, in-place

>>> L

['red', 'blue', 'green', 'black', 'white', 'pink', 'purple']

>>> L = L[:-2]

>>> L

['red', 'blue', 'green', 'black', 'white']

逆順:

>>> r = L[::-1]

>>> r

['white', 'black', 'green', 'blue', 'red']

>>> r2 = list(L)

>>> r2

['red', 'blue', 'green', 'black', 'white']

>>> r2.reverse() # in-place

>>> r2

['white', 'black', 'green', 'blue', 'red']

リストの結合と繰り返し:

>>> r + L

['white', 'black', 'green', 'blue', 'red', 'red', 'blue', 'green', 'black', 'white']

>>> r * 2

['white', 'black', 'green', 'blue', 'red', 'white', 'black', 'green', 'blue', 'red']

ちなみに

ソート:

>>> sorted(r) # new object

['black', 'blue', 'green', 'red', 'white']

>>> r

['white', 'black', 'green', 'blue', 'red']

>>> r.sort()  # in-place

>>> r

['black', 'blue', 'green', 'red', 'white']

メソッドとオブジェクト指向プログラミング

ここで r.method() という表記法 (例 r.append(3) や L.pop()) はオブジェクト指向プログラミング(OOP)のはじめての例です. オブジェクト r は list なので . の表記で使える method 関数 を所持しています. このチュートリアルでは . の表記以上の OOP の知識は不要です.

メソッドを見つける:

助言: IPython を起動した上で：tab-補完 (tab を押す)

In [28]: r.<TAB>

r.__add__           r.__iadd__          r.__setattr__

r.__class__         r.__imul__          r.__setitem__

r.__contains__      r.__init__          r.__setslice__

r.__delattr__       r.__iter__          r.__sizeof__

r.__delitem__       r.__le__            r.__str__

r.__delslice__      r.__len__           r.__subclasshook__

r.__doc__           r.__lt__            r.append

r.__eq__            r.__mul__           r.count

r.__format__        r.__ne__            r.extend

r.__ge__            r.__new__           r.index

r.__getattribute__  r.__reduce__        r.insert

r.__getitem__       r.__reduce_ex__     r.pop

r.__getslice__      r.__repr__          r.remove

r.__gt__            r.__reversed__      r.reverse

r.__hash__          r.__rmul__          r.sort

1.2.2.2.2. 文字列

異なる文字列構文(シングルクォート, ダブルクォート, 3重クォート):

s = 'Hello, how are you?'

s = "Hi, what's up"

s = '''Hello,                 # tripling the quotes allows the

       how are you'''         # the string to span more than one line

s = """Hi,

what's up?"""

In [1]: 'Hi, what's up?'

------------------------------------------------------------

   File "<ipython console>", line 1

    'Hi, what's up?'

           ^

SyntaxError: invalid syntax

改行文字は n で tab 文字は t です。

ちなみに

文字列はリストのように要素が集まったものです. そのためインデクスやスライスを同じ構文や規則で使うことができます.

インデクス指定:

>>> a = "hello"

>>> a[0]

'h'

>>> a[1]

'e'

>>> a[-1]

'o'

ちなみに

(負のインデクスは右端から数えることに対応することを忘れないように.)

スライス:

>>> a = "hello, world!"

>>> a[3:6] # 3rd to 6th (excluded) elements: elements 3, 4, 5

'lo,'

>>> a[2:10:2] # Syntax: a[start:stop:step]

'lo o'

>>> a[::3] # every three characters, from beginning to end

'hl r!'

ちなみに

アクセントや特殊記号は Unicode 文字列で扱うことができます( https://docs.python.org/tutorial/introduction.html#unicode-strings を見ましょう)。

文字列は 変化不可能なオブジェクト なので内容を変更することはできません. とはいえ, 元の文字列から新しい文字列を作ることはできます.

In [53]: a = "hello, world!"

In [54]: a[2] = 'z'

---------------------------------------------------------------------------

Traceback (most recent call last):

   File "<stdin>", line 1, in <module>

TypeError: 'str' object does not support item assignment



In [55]: a.replace('l', 'z', 1)

Out[55]: 'hezlo, world!'

In [56]: a.replace('l', 'z')

Out[56]: 'hezzo, worzd!'

ちなみに

文字列は上で見た a.relace のような多くの便利なメソッドを持っています. a. がオブジェクト指向の表記法であることと新しいメソッドを探すのに tab 補完や help(str) が使えることは覚えておきましょう.

参考

Python はパターンを探したり, フォーマットするといった進んだ文字列操作の方法を提供しています. 時間的制限にためにその話題はここでは述べませんが,興味のある読者は https://docs.python.org/library/stdtypes.html#string-methods と https://docs.python.org/library/string.html#new-string-formatting を参照して下さい.

文字列の置換:

>>> 'An integer: %i; a float: %f; another string: %s' % (1, 0.1, 'string')

'An integer: 1; a float: 0.100000; another string: string'



>>> i = 102

>>> filename = 'processing_of_dataset_%d.txt' % i

>>> filename

'processing_of_dataset_102.txt'

1.2.2.2.3. 辞書

ちなみに

辞書とは キーを値に対応づけ する効率よいテーブルです. これは 順序づけられていない コンテナです:

>>> tel = {'emmanuelle': 5752, 'sebastian': 5578}

>>> tel['francis'] = 5915

>>> tel     

{'sebastian': 5578, 'francis': 5915, 'emmanuelle': 5752}

>>> tel['sebastian']

5578

>>> tel.keys()   

['sebastian', 'francis', 'emmanuelle']

>>> tel.values()   

[5578, 5915, 5752]

>>> 'francis' in tel

True

ちなみに

値を名前と関連づけて値を記録し取得する (文字列に対して名前や時刻等) のに便利に使うことができます. より詳しくは https://docs.python.org/tutorial/datastructures.html#dictionaries を見ましょう.

辞書のキー、(あるいは値) は各々異なる型を取ることができます:

>>> d = {'a':1, 'b':2, 3:'hello'}

>>> d       

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

1.2.2.2.4. 他のコンテナ型

タブル

タプルとは変化不可能なリストです. タプルの要素は丸括弧に囲われて書かれるか、単にカンマで区切られ書かれます:

>>> t = 12345, 54321, 'hello!'

>>> t[0]

12345

>>> t

(12345, 54321, 'hello!')

>>> u = (0, 2)

集合: 順序つきでない, 一意な要素の集まり:

>>> s = set(('a', 'b', 'c', 'a'))

>>> s    

set(['a', 'c', 'b'])

>>> s.difference(('a', 'b'))    

set(['c'])

1.2.2.3. 代入演算子

ちなみに

Python library reference によると:

代入文は名前を値に(再)束縛したり, 変更可能なオブジェクトの属性や要素を変更したりするために使われます。

簡単にいえば, 以下のように動作します(単純代入):

  1. 右辺の式が評価され, 対応する値が得られる

  2. 右辺のオブジェクトが左辺の 名前 に代入あるいは束縛される

注意すべきこと:

  • 単一のオブジェクトは束縛される名前をいくつも持ち得る:

    In [1]: a = [1, 2, 3]

    In [2]: b = a

    In [3]: a

    Out[3]: [1, 2, 3]

    In [4]: b

    Out[4]: [1, 2, 3]

    In [5]: a is b

    Out[5]: True

    In [6]: b[1] = 'hi!'

    In [7]: a

    Out[7]: [1, 'hi!', 3]

  • リストを インプレース に変更するには, インデクス指定かスライスを使う:

    In [1]: a = [1, 2, 3]

    In [3]: a

    Out[3]: [1, 2, 3]

    In [4]: a = ['a', 'b', 'c'] # Creates another object.

    In [5]: a

    Out[5]: ['a', 'b', 'c']

    In [6]: id(a)

    Out[6]: 138641676

    In [7]: a[:] = [1, 2, 3] # Modifies object in place.

    In [8]: a

    Out[8]: [1, 2, 3]

    In [9]: id(a)

    Out[9]: 138641676 # Same as in Out[6], yours will differ...

  • ここでの重要な概念は 変更可能か変化不可能か です

    • 変更可能なオブジェクトはインプレースに変更されます

    • 変化不可能なオブジェクトは一旦作られたら変更できません

参考

David M. Beazley による記事 Types and Objects in Python に上の話題についてのとても優れた詳しい解説があります。