Python 型

2025-11-142025
87.1% (317.9/365)
November
46.6% (13.9/30)
Week 46
71.2% (4.9/7)
Day 14 Fri
98.6% (23.6/24)

訪問者

total: 17125
today: 1
yesterday: 1
now: 1

↑

更新

MenuBar

Python の型 †

a graph image

↑

動的型付け †

Python は、動的型付け

明示的型付けもできる

>>> val1=int(123)
>>> type(val1)
<class 'int'>

>>> val2=str(123)
>>> type(val2)
<class 'str'>

↑

id()、is、== †

Python では、データは全てオブジェクト。オブジェクトには固有の id が振られる。id は、id(obj) で知ることができる
== は、 obj1.__eq__(obj2) を呼び出している。値が違っても True が返ってくることがある
```
>>> 1 is True
False
>>> 1 == True
True
```

"is" は、同じオブジェクトかどうかを検査する

数値・文字列は、同じ値は同じオブジェクトになる (Lisp とおなじ)

>>> str1="123"
>>> str2="123"

>>> id(str1)
4369725008
>>> id(str2)
4369725008

>>> str1 == str2
True
>>> str1 is str2
True

list は、内容が同じでも別のオブジェクトになる

>>> list1=[1,2,3]
>>> list2=[1,2,3]

>>> id(list1)
4369290088
>>> id(list2)
4369341832

>>> list1 == list2
True
>>> list1 is list2
False

None との比較は is / is not を使わなければいけない
- Python3 だと、== でも上手く比較できるっぽい・・・。まぁ is / is not を使うのが無難でしょうが
→ 値の比較は is / is not にすればよい ?

↑

None †

>>> type(None)
<class 'NoneType'>

↑

数値 †

↑

bool †

>>> type(True)
<class 'bool'>
>>> type(False)
<class 'bool'>

↑

int †

>>> type(1)
<class 'int'>

↑

float †

>>> type(1.0)
<class 'float'>

float に関する情報

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308,
min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15,
mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)
>>> sys.float_info.max
1.7976931348623157e+308

↑

complex †

>>> type(1+1j)
<class 'complex'>

↑

long は、Python3 で廃止された †

int の桁数制限はなし

Python2 まであった sys.maxint は廃止された

>>> import sys
>>> sys.maxint
AttributeError: 'module' object has no attribute 'maxint'

↑

list †

↑

作成 †

[] か list(iterator) でリストを作成できる
```
>>> list1=[1,2,3]
>>> list1
[1, 2, 3]
```
int だけではなく文字や list などなんでも詰め込める
```
>>> list2=[list1,4,5]
>>> list2
[[1, 2, 3], 4, 5]
```

文字列を list にする

>>> list3=list('abcd')
>>> list3
['a', 'b', 'c', 'd']

tuple を list にする

>>> list4=list((3,5,4))
>>> list4
[3, 5, 4]

range を list にする
```
>>> list5=list(range(6))
>>> list5
[0, 1, 2, 3, 4, 5]
```
range() 関数は range(開始,終了,ステップ) というようにも指定できる
```
>>> list6=list(range(3,9,2))
>>> list6
[3, 5, 7]
```
Pytyon2 では、range() は list を返していたが、Python3 では range 型を返す。range 型は、要素を列挙するイテレータ機能を持っているので、list() 関数で list にすることができる。
```
>>> whoareyou=range(6)
>>> type(whoareyou)
<class 'range'>
```

リスト内包表記

[追加する要素 for 取り出した要素 in リスト if 追加条件]

>>> ['OSX10.' + str(i) for i in range(9)]
['OSX10.0', 'OSX10.1', 'OSX10.2', 'OSX10.3', 'OSX10.4', 'OSX10.5', 'OSX10.6', 'OSX10.7', 'OSX10.8']
>>> [lang for lang in ['python','perl','ruby','plsql','java','c'] if lang.startswith('p')]
['python', 'perl', 'plsql']

↑

要素の取得 †

>>> lst=[1,2,3,4,5,6]

配列風
```
>>> lst[0]
1
>>> lst[1]
2
```
サブリストの取得
- [開始:終了]
```
>>> lst[0:4]
[1, 2, 3, 4]
```
- [開始:終了:ステップ]
```
>>> lst[0:4:2]
[1, 3]
```
- [開始:] (開始以降)
```
>>> lst[3:]
[4, 5, 6]
```
- [:終了] (終了まで)
```
>>> lst[:3]
[1, 2, 3]
```
- ステップに負の数を指定することもできる
```
>>> lst[::-1]
[6, 5, 4, 3, 2, 1]
>>> lst[5:2:-1]
[6, 5, 4]
```

↑

要素の検索 †

>>> lst=[1,2,3,4,5,6,5,4,3,2,1]

3があるかどうか
```
>> 3 in lst
True
```
最初にでてきた 3 の index
```
>>> lst.index(3)
2
```
index 5 以降で、最初にでてきた 3 の index
```
>>> lst.index(3,5)
8
```
index 0～5 までで、最初にでてきた 3 の index
```
>>> lst.index(3,0,5)
2
```
index 5～10 までで、最初にでてきた 3 の index
```
>>> lst.index(3,5,10)
8
```
存在しない要素の index を調べようとすると ValueError? が発生する
```
>>> lst.index(99)
ValueError: 99 is not in list
```

↑

要素の集計 †

リストの要素数

>>> lst=[1,2,3,4,5,6,5,4,3,2,1]
>>> len(lst)
11

指定した要素の個数を数える

>>> lst=[1,2,3,4,5,6,5,4,3,2,1]
>>> lst.count(3)
2
>>> lst.count(6)
1
>>> lst.count(99)
0

最大の要素と最小の要素を見つける
```
>>> lst=[1,2,3,4,5,6,5,4,3,2,1]
>>> max(lst)
6
>>> min(lst)
1
```
要素の "値" を返す関数を第二引数に指定できる。(下の例は 3 で割ったあまりを返す無名関数)
```
>>> max(lst,key=(lambda p : p % 3))
2
>>> min(lst,key=(lambda p : p % 3))
3
```

要素を合計する

>>> lst=[1,2,3,4,5,6,5,4,3,2,1]
>>> sum(lst)
36

bool の配列を集計する

>>> any([False,False,False])
False
>>> any([False,False,True])
True
>>> any([True,True,True])
True

>>> all([False,False,False])
False
>>> all([False,False,True])
False
>>> all([True,True,True])
True
>>>

↑

要素の更新 †

代入

>>> lst
[1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1]
>>> lst[1]=99
>>> lst
[1, 99, 3, 4, 5, 6, 5, 4, 3, 2, 1]

範囲を指定して置き換える (1:3 で、lst[1]とlst[2] のあった部分にリストを代入)

>>> lst[1:3] = ['a','b','c','d']
>>> lst
[1, 'a', 'b', 'c', 'd', 4, 5, 6, 5, 4, 3, 2, 1]

list.append(obj) obj をリストに追加する

>>> lst=[1,2,3]
>>> lst.append('a')
>>> lst
[1, 2, 3, 'a']
>>> lst.append(['x','y'])
>>> lst
[1, 2, 3, 'a', ['x', 'y']]

list.extend(list) list の内容をリストに追加する
```
>>> lst=[1,2,3]
>>> lst.extend('a')
>>> lst
[1, 2, 3, 'a']
>>> lst.extend(['x','y'])
>>> lst
[1, 2, 3, 'a', 'x', 'y']
```
+演算子でも追加できるが extend のほうが速い

list.insert(idx, obj) objをidxの直前に挿入する

>>> lst=[1,2,3]
>>> lst.insert(2,'a')
>>> lst
[1, 2, 'a', 3]

↑

要素の削除 †

最初にでてきた 3 を削除

>>> lst=[1,2,3,4,5,6,5,4,3,2,1]
>>> lst.remove(3)
>>> lst
[1, 2, 4, 5, 6, 5, 4, 3, 2, 1]
>>> lst.remove(99)
ValueError: list.remove(x): x not in list

インデックスを指定して削除

>>> lst=[1,2,3,4,5,6,5,4,3,2,1]
>>> del lst[1]
>>> lst
[1, 3, 4, 5, 6, 5, 4, 3, 2, 1]

範囲指定 (インデックス 3 と 4 を削除)

>>> lst=[1,2,3,4,5,6,5,4,3,2,1]
>>> del lst[3:5]
>>> lst
[1, 2, 3, 6, 5, 4, 3, 2, 1]

範囲指定 (インデックス 3(4),4(5),5(6),6(5),7(4) からステップ2 で削除 → インデックス 3(4),5(6),7(4) を削除)

>>> lst=[1,2,3,4,5,6,5,4,3,2,1]
>>> del lst[3:8:2]
>>> lst
[1, 2, 3, 5, 5, 3, 2, 1]

↑

ソート †

list.sort(key=関数, reverse=真偽値)
```
>>> lst=['a','ab','abc','abcd']
>>> lst.sort(key=(lambda p : 1.0 / len(p)))
>>> lst
['abcd', 'abc', 'ab', 'a']
```
key 関数の値が小さい順に並ぶ。key 関数を省略した場合には値の自然順序にならぶ (整数の場合値の大きさ、文字列の場合辞書順)。
Python3 で、引数の cmp=比較関数が廃止された(遅いから)。

sorted(list, key=関数, reverse=真偽値) : list

>>> lst=['a','ab','abc','abcd']
>>> lst2=sorted(lst, key=(lambda p : 1.0 / len(p)))
>>> lst
['a', 'ab', 'abc', 'abcd']
>>> lst2
['abcd', 'abc', 'ab', 'a']

ソートしたリストをあたらに作って返す。元のリストは変更されない。

list.reverse()

>>> lst=['a','ab','abc','abcd']
>>> lst.reverse()
>>> lst
['abcd', 'abc', 'ab', 'a']

reversed(list) : iterator

>>> lst=['a','ab','abc','abcd']
>>> it=reversed(lst)
>>> type(it)
<class 'list_reverseiterator'>
>>> list(it)
['abcd', 'abc', 'ab', 'a']

引数の list の順番が反対に返ってくるイテレータを返す。

↑

コピー †

参照を代入

>>> lst=[1,2,3,4]
>>> cpy=lst
>>> id(lst)
30364536
>>> id(cpy)
30364536
>>> cpy[1]=99
>>> cpy
[1, 99, 3, 4]
>>> lst
[1, 99, 3, 4]

lst と cpy は、同じリストをさす

shallow copy (リストは別のもの。要素は同じもの)

>>> lst=[1,2,3,['x','y']]
>>> cpy=lst[:]
>>> id(lst)
30364736
>>> id(cpy)
30367496
>>> id(lst[3])
30674696
>>> id(cpy[3])
30674696
>>> cpy[3].append('z')
>>> cpy
[1, 2, 3, ['x', 'y', 'z']]
>>> lst
[1, 2, 3, ['x', 'y', 'z']]

※ cpy=lst[:] と cpy=list(lst) は同じ

deep copy (リストも要素も別になる)

>>> import copy
>>> lst=[1,2,3,['x','y']]
>>> cpy=copy.deepcopy(lst)
>>> id(lst)
30364536
>>> id(cpy)
30375248
>>> id(lst[3])
30670360
>>> id(cpy[3])
30670200
>>> cpy[3].append('z')
>>> cpy
[1, 2, 3, ['x', 'y', 'z']]
>>> lst
[1, 2, 3, ['x', 'y']]

↑

比較 †

要素が同一か比較

>>> [1,2,3] == [1,2,3]
True
>>> [1,2,3] != [1,2,3]
False

大小比較は、要素を左から見ていって、初めて見つかった違う要素で比較。片方に要素が無い場合は、あるほうが大きい(>,<,>=,<=)
```
>>> [1,2,3] > [1,3,4]
False
>>> [1,2,3] < [1,3,4]
True
>>> [1,2,3] > [1,2]
True
```

is は、オブジェクトが同じか比較

>>> [1,2,3] is [1,2,3]
False
>>> lst=[1,2,3]
>>> cpy=lst
>>> lst is cpy
True

↑

tuple †

変更不可であることを除いて list と同じ。読み出し操作が list の 10 倍以上速い。

作成方法

>>> tpl=(1,2,3)
>>> tpl
(1, 2, 3)

>>> tpl=tuple([4,5,6])
>>> tpl
(4, 5, 6)

要素の変更不可

>>> tpl=(1,2,3)
>>> tpl[1] = 99
TypeError: 'tuple' object does not support item assignment

要素の削除不可

>>> tpl=(1,2,3)
>>> del tpl[1]
TypeError: 'tuple' object doesn't support item deletion

tuple自体は消せる

>>> tpl=(1,2,3)
>>> del tpl
>>> tpl
NameError: name 'tpl' is not defined

copyできる
tuple.sort() , tuple.reverse() はできない

sorted(tuple) は list を返す。reverse(tuple) は iterator を返す

>>> tpl=(9,5,6,2,7)
>>> sorted(tpl)
[2, 5, 6, 7, 9]
>>> it=reversed(tpl)
>>> type(it)
<class 'reversed'>
>>> list(it)
[7, 2, 6, 5, 9]

比較は list と同じ

↑

set †

↑

作成 †

>>> set1=set([1,2,3,2,1])
>>> set1
{1, 2, 3}

可変オブジェクトを set の要素に指定することはできない

>>> set3=set([1,2,3,['x','y']])
TypeError: unhashable type: 'list'

Python3 から {} で set を作れるようになった

>>> set2={1,2,3,2,1}
>>> set2
{1, 2, 3}

Python3 からセット内包表記が可能になった

>>> {py + 'thon' for py in ['py','mara','row','py','suxame'] if len(py) < 4}
{'python', 'rowthon'}

↑

set同士の演算 †

set同士は、集合演算子 (|&-^) を使って演算できる
set.xxxxx(iteratble) で、iteratable と自分自身の集合演算をした結果の 新しいset を作ることができる

和

>>> {1,2,3} | {2,3,4}
{1, 2, 3, 4}

>>> {1,2,3}.union([2,3,4])
{1, 2, 3, 4}

積(共通集合)

>>> {1,2,3} & {2,3,4}
{2, 3}

>>> {1,2,3}.intersection([2,3,4])
{2, 3}

差

>>> {1,2,3} - {2,3,4}
{1}

>>> {1,2,3}.difference([2,3,4])
{1}

対象差

>>> {1,2,3} ^ {2,3,4}
{1, 4}

>>> {1,2,3}.symmetric_difference([2,3,4])
{1, 4}

↑

要素の取得 †

for文で取り出す。順番が不定なことに注意
```
>>> for v in {4,8,7,9,2}:
...     print(v)
...
8
9
2
4
7
```

↑

要素の検索 †

3があるかどうか
```
>> 3 in {1,2,3}
True
```

↑

要素の集計 †

setの要素数

>>> set1={1,2,3,4,5,6,5,4,3,2,1}
>>> set1
{1, 2, 3, 4, 5, 6}
>>> len(set1)
6

↑

要素の更新 †

set.add(obj) obj を追加する
```
>>> set1={1,2,3}
>>> set1.add(4)
>>> set1
{1, 2, 3, 4}
```
setは重複が無い集合なので、既にある要素を add() しても元のまま
```
>>> set1.add(1)
>>> set1
{1, 2, 3, 4}
```

和

>>> set1={1,2,3}
>>> set1 |= {2,3,4}
>>> set1
{1, 2, 3, 4}

>>> set1={1,2,3}
>>> set1.update([2,3,4])
>>> set1
{1, 2, 3, 4}

積(共通集合)

>>> set1={1,2,3}
>>> set1 &= {2,3,4}
>>> set1
{2, 3}

>>> set1={1,2,3}
>>> set1.intersection_update([2,3,4])
>>> set1
{2, 3}

差

>>> set1={1,2,3}
>>> set1 -= {2,3,4}
>>> set1
{1}

>>> set1={1,2,3}
>>> set1.difference_update([2,3,4])
>>> set1
{1}

対象差

>>> set1={1,2,3}
>>> set1 ^= {2,3,4}
>>> set1
{1, 4}

>>> set1={1,2,3}
>>> set1.symmetric_difference_update([2,3,4])
>>> set1
{1, 4}

↑

要素の削除 †

set.remove(obj)

>>> set1={1,2,3}
>>> set1.remove(3)
>>> set1
{1, 2}
>>> set1.remove(3)
KeyError: 3

削除対象が無いとエラーが発生する

set.discard(obj)

>>> set1={1,2,3}
>>> set1.discard(3)
>>> set1
{1, 2}
>>> set1.discard(3)
>>> set1
{1, 2}

削除対象が無くてもエラーが発生しない

set.pop()

>>> set1={1,2,3}
>>> entity=set1.pop()
>>> set1
{2, 3}
>>> entity
1

どれか一つをとりだす。どれが取り出されるかは不定。取り出すものが無いと KeyError?

>>> set1={1,2,3}
>>> set1.pop()
1
>>> set1.pop()
2
>>> set1.pop()
3
>>> set1.pop()
KeyError: 'pop from an empty set'

set.clear()

>>> set1={1,2,3}
>>> set1.clear()
>>> set1
set()

↑

コピー †

参照を代入

>>> set1={1,2,3}
>>> id(set1)
30341040

>>> set2=set1
>>> id(set2)
30341040

shallow copy
```
>>> id(set1.copy())
29750136
>>> id(set(set1))
29750136
```
shallow copy は、元と違うものができる。しかし、shallow copy は一つしか作られないらしい。

deep copy

>>> import copy
>>> id(copy.deepcopy(set1))
30341160
>>> id(copy.deepcopy(set1))
29750016

deep copy は、毎回違うものが作られる

↑

比較 †

要素が同一か比較

>>> {1,2,3} == {1,2,3}
True
>>> {1,2,3} != {1,2,3}
False

真にサブセットか？(同じ場合はダメ)

>>> {1,2,3} < {1,2,3}
False
>>> {1,2,3} < {1,2}
False
>>> {1,2,3} < {1,2,3,4}
True

真にスーパーセットか？(同じ場合はダメ)

>>> {1,2,3} > {1,2,3}
False
>>> {1,2,3} > {1,2}
True
>>> {1,2,3} > {1,2,3,4}
False

サブセットか？

>>> {1,2,3} <= {1,2,3}
True
>>> {1,2,3} <= {1,2}
False
>>> {1,2,3} <= {1,2,3,4}
True

>>> {1,2,3}.issubset([1,2,3])
True
>>> {1,2,3}.issubset([1,2])
False
>>> {1,2,3}.issubset([1,2,3,4])
True

スーパーセットか？

>>> {1,2,3} >= {1,2,3}
True
>>> {1,2,3} >= {1,2}
True
>>> {1,2,3} >= {1,2,3,4}
False

>>> {1,2,3}.issuperset([1,2,3])
True
>>> {1,2,3}.issuperset([1,2])
True
>>> {1,2,3}.issuperset([1,2,3,4])
False

is は、オブジェクトが同じか比較

>>> {1,2,3} is {1,2,3}
False
>>> set1={1,2,3}
>>> cpy=set1
>>> set1 is cpy
True

↑

frozen set †

変更不可のset

>>> set1=set([1,2,3])
>>> set1.add(4)
>>> set1
{1, 2, 3, 4}

>>> set2=frozenset([1,2,3])
>>> set2.add(4)
AttributeError: 'frozenset' object has no attribute 'add'

↑

dictionary †

↑

作成 †

{key:value, key:value, … }

>>> osx = {'siam' : 'beta',
       'cheetah' : 10.0,
       'puma' : 10.1,
       'jaguar' : 10.2,
       'panther' : 10.3,
       'tiger' : 10.4,
       'leopard' : 10.5,
       'snow leopard' : 10.6,
       'lion' : 10.7,
       'mountain lion' : 10.8}
>>> osx
{'tiger': 10.4, 'lion': 10.7, 'puma': 10.1, 'jaguar': 10.2, 'mountain lion': 10.8,
'panther': 10.3, 'cheetah': 10.0, 'siam': 'beta', 'leopard': 10.5, 'snow leopard': 10.6}

dict()

>>> dict(key1='val1', key2='val2')
{'key2': 'val2', 'key1': 'val1'}
>>> dict([('key3','val3'),('key4','val4')])
{'key3': 'val3', 'key4': 'val4'}
>>> dict({'key5':'val5', 'key6':'val6'})
{'key6': 'val6', 'key5': 'val5'}

dict.fromKeys(sequence)

>>> dict.fromkeys(range(6))
{0: None, 1: None, 2: None, 3: None, 4: None, 5: None}
>>> dict.fromkeys(range(6), 'default')
{0: 'default', 1: 'default', 2: 'default', 3: 'default', 4: 'default', 5: 'default'}

Python3 から辞書内包表記が使える

>>> keys=['k1','k2','k3','kk']
>>> vals=['v1','v2','v3','vv']
>>> {key:val for key,val in zip(keys,vals) if key[1:] == val[1:]}
{'k3': 'v3', 'k2': 'v2', 'k1': 'v1'}

↑

要素の取得 †

>>> osx
{'tiger': 10.4, 'lion': 10.7, 'puma': 10.1, 'jaguar': 10.2, 'mountain lion': 10.8,
'panther': 10.3, 'cheetah': 10.0, 'siam': 'beta', 'leopard': 10.5, 'snow leopard': 10.6}

dict[key]

>>> osx['lion']
10.7
>>> osx.get('siam')
'beta'

dict.get(key) / dict.get(key, default value)

>>> osx.get('tama') is None
True
>>> osx.get('tama', '10.9')
'10.9'

dict.keys()

>>> osx.keys()
dict_keys(['tiger', 'lion', 'puma', 'jaguar', 'mountain lion', 'panther', 'cheetah', 'siam',
'leopard', 'snow leopard'])

dict.values()

>>> osx.values()
dict_values([10.4, 10.7, 10.1, 10.2, 10.8, 10.3, 10.0, 'beta', 10.5, 10.6])

dict.items()

>>> osx.items()
dict_items([('tiger', 10.4), ('lion', 10.7), ('puma', 10.1), ('jaguar', 10.2), 
('mountain lion', 10.8), ('panther', 10.3), ('cheetah', 10.0), ('siam', 'beta'), 
('leopard', 10.5), ('snow leopard', 10.6)])

for文では key が取り出せる。順番が不定なことに注意

>>> for key in osx:
	print(key + "= OSX" + str(osx.get(key)))
	
tiger= OSX10.4
lion= OSX10.7
puma= OSX10.1
jaguar= OSX10.2
mountain lion= OSX10.8
panther= OSX10.3
cheetah= OSX10.0
siam= OSXbeta
leopard= OSX10.5
snow leopard= OSX10.6

↑

要素の検索 †

>>> osx
{'tiger': 10.4, 'lion': 10.7, 'puma': 10.1, 'jaguar': 10.2, 'mountain lion': 10.8,
'panther': 10.3, 'cheetah': 10.0, 'siam': 'beta', 'leopard': 10.5, 'snow leopard': 10.6}
>>> 'leopard' in osx
True
>>> 'tama' in osx
False

↑

要素の集計 †

>>> osx
{'tiger': 10.4, 'lion': 10.7, 'puma': 10.1, 'jaguar': 10.2, 'mountain lion': 10.8,
'panther': 10.3, 'cheetah': 10.0, 'siam': 'beta', 'leopard': 10.5, 'snow leopard': 10.6}
>>> len(osx)
10

↑

要素の更新 †

代入

>>> osx
{'tiger': 10.4, 'lion': 10.7, 'puma': 10.1, 'jaguar': 10.2, 'mountain lion': 10.8,
'panther': 10.3, 'cheetah': 10.0, 'siam': 'beta', 'leopard': 10.5, 'snow leopard': 10.6}
>>> osx['siam'] = 'public beta'
>>> osx
{'tiger': 10.4, 'lion': 10.7, 'puma': 10.1, 'jaguar': 10.2, 'mountain lion': 10.8,
'panther': 10.3, 'cheetah': 10.0, 'siam': 'public beta', 'leopard': 10.5, 'snow leopard': 10.6}

dict.setdefault(key, val)

>>> osx.setdefault('tama', '10.9')
'10.9'
>>> osx
{'leopard': 10.5, 'tiger': 10.4, 'lion': 10.7, 'puma': 10.1, 'jaguar': 10.2, 'panther': 10.3,
'tama': '10.9', 'snow leopard': 10.6, 'cheetah': 10.0, 'siam': 'public beta', 'mountain lion': 10.8}

dict.update(dict)

>>> dict1={'k1':'v1','k2':'v2', 'k3':'v3'}
>>> dict2={'k3':'vA','k4':'vB', 'k5':'vC'}
>>> dict1.update(dict2)
>>> dict1
{'k3': 'vA', 'k2': 'v2', 'k1': 'v1', 'k5': 'vC', 'k4': 'vB'}

dict.update(key1=val1, key2=val2, …)
dict.update([(key1, val1), (key2, val2), …)
dict.update({key1: val1, key2: val2, …})

↑

要素の削除 †

del

>>> dict1={'k1':'v1','k2':'v2', 'k3':'v3'}
>>> del dict1['k1']
>>> dict1
{'k3': 'v3', 'k2': 'v2'}

dict.pop(key) / dict.pop(key, default value)

>>> dict1={'k1':'v1','k2':'v2', 'k3':'v3', 'k4':'v4', 'k5':'v5'}
>>> dict1.pop('k1')
'v1'
>>> dict1
{'k3': 'v3', 'k2': 'v2', 'k5': 'v5', 'k4': 'v4'}

keyが無い場合 KeyError? が発生する。default value を設定すると key が無い場合に dafault value が返却される

>>> dict1.pop('k2')
v2
>>> dict1.pop('k2')
KeyError: 'k2'
>>> dict1.pop('k2','I dont have k2')
'I dont have k2'

dict.popitem()

>>> dict1
{'k3': 'v3', 'k5': 'v5', 'k4': 'v4'}
>>> dict1.popitem()
('k3', 'v3')
>>> dict1.popitem()
('k5', 'v5')
>>> dict1.popitem()
('k4', 'v4')
>>> dict1.popitem()
KeyError: 'popitem(): dictionary is empty'

↑

コピー †

参照を代入

>>> dict1 = {'k1':[1,2,3], 'k2':[4,5,6]}
>>> dict2 = dict1
>>> id(dict1)
140733378109328
>>> id(dict2)
140733378109328

shallow copy

>>> dict3 = dict1.copy()
>>> id (dict1)
140733378109328
>>> id (dict3)
140733367902720
>>> id (dict1['k1'])
4562201128
>>> id (dict3['k1'])
4562201128

>>> dict4 = dict(dict1)
>>> id (dict1)
140733378109328
>>> id (dict4)
140733378119056
>>> id (dict1['k1'])
4562201128
>>> id (dict4['k1'])
4562201128

deep copy

>>> import copy
>>> dict5 = copy.deepcopy(dict1)
>>> id (dict1)
140733378109328
>>> id (dict5)
140733378122624
>>> id (dict1['k1'])
4562201128
>>> id (dict5['k1'])
4562201416

↑

比較 †

要素が同じか

>>> dict1 = {'k1':'v1','k2':'v2'}
>>> dict2 = {'k1':'v1','k2':'v2'}
>>> dict1 == dict2
True
>>> dict1 != dict2
False

=>,>,<,<= は Python3 では使えないようだ

>>> dict3 = {'k3':'v3','k4':'v4'}
>>> dict4 = {'k5':'v5','k6':'v6','k7':'v7'}
>>> dict3 <= dict4
TypeError: unorderable types: dict() <= dict()

is はオブジェクトが同じか ?

>>> dict1 = {'k1':'v1','k2':'v2'}
>>> dict2 = {'k1':'v1','k2':'v2'}
>>> dict3 = dict1
>>> dict1 == dict2
>>> dict1 is dict2
False
>>> dict1 is dict3
True

↑

順序付き辞書 †

>>> dict([('k1','v1'),('k2','v2')])
{'k2': 'v2', 'k1': 'v1'}

>>> from collections import OrderedDict
>>> OrderedDict([('k1','v1'),('k2','v2')])
OrderedDict([('k1', 'v1'), ('k2', 'v2')])

↑

文字列 †

↑

作成 †

StrExam1.py

#!/usr/bin/env python
# config : UTF-8

strs=list()

#######################################################################
# '...' も "..." も同じ
strs.append('Single Quotation')
strs.append("Double Quotation")

#######################################################################
# """...""" で囲むと 改行や引用符 がそのまま出力
strs.append("""3 Double Quotation
	"123"
	"456"
""")

#######################################################################
# エスケープシーケンス
strs.append("abc\n\tdef")

#######################################################################
# r"..." でエスケープシーケンス無効化
strs.append(r"abc\n\tdef")

#######################################################################
# 日本語
strs.append("あいう")

#######################################################################
# メッセージ (Python3 からの書き方)
strs.append("{0} が {1} ました".format("ふとん","ふっとび"))
strs.append("{a} が {b} ました".format(a="アリス",b="走り"))

#######################################################################
# メッセージ (Object)
class City(object):
   def __init__(self, name, population):
     self.name = name
     self.population = population

tokyo = City("東京",1200)
strs.append("{0.name} の人口は {0.population} 万人です".format(tokyo))

#######################################################################
# メッセージ (辞書)
name = {'osaka':'大阪'}
population = {'osaka':886}
strs.append("{0[osaka]} の人口は {1[osaka]} 万人です".format(name, population))

for str in strs:
   print(str)
   print("--------------------")

実行結果

$ ./StrExam1.py 
Single Quotation
--------------------
Double Quotation
--------------------
3 Double Quotation
        "123"
        "456"

--------------------
abc
        def
--------------------
abc\n\tdef
--------------------
あいう
--------------------
ふとん が ふっとび ました
--------------------
アリス が 走り ました
--------------------
東京 の人口は 1200 万人です
--------------------
大阪 の人口は 886 万人です
--------------------

↑

要素の取得 †

StrExam2.py

#!/usr/bin/env python
# config : UTF-8

txt = "1234567890壱弐参四五六七八九〇1234567890壱弐参四五六七八九〇"

print(txt)
print("文字数 : " + str(len(txt)))

print("3文字目 =" + txt[2])
print("13文字目 =" + txt[12])

print("前5文字以降 =" + txt[5:])
print("後5文字以全 =" + txt[:-5])
print("前5文字～後5文字" + txt[5:-5])
print("5～15文字 =" + txt[5:15])

print("5～15文字 3文字間隔 =" + txt[5:-5:3])

実行結果

$ ./StrExam2.py 
1234567890壱弐参四五六七八九〇1234567890壱弐参四五六七八九〇
文字数 : 40
3文字目 =3
13文字目 =参
前5文字以降 =67890壱弐参四五六七八九〇1234567890壱弐参四五六七八九〇
後5文字以全 =1234567890壱弐参四五六七八九〇1234567890壱弐参四五
前5文字～後5文字67890壱弐参四五六七八九〇1234567890壱弐参四五
5～15文字 =67890壱弐参四五
5～15文字 3文字間隔 =69弐五八1470参

Python3 からは、マルチバイト文字であることを意識する必要は無い

↑

要素の検索 †

str.find(検索文字列, [開始位置], [終了位置]) / str.index(検索文字列, [開始位置], [終了位置])

>>> txt
'12345ABCDEF12345ABCDEF'

find(), index() は、左から検索。rfind(), rindex() は右から検索

>>> txt.find("345")
2
>>> txt.rfind("345")
13
>>> txt.index("345")
2
>>> txt.rindex("345")
13

find() は、検索文字列が見つからないと -1 を返す

>>> idx = 0
>>> while idx > -1 :
...     idx = txt.find("345", idx+1)
...     print(idx)
...
2
13
-1

index は ValueError? が発生する

>>> idx = 0
>>> while idx > -1 :
...     idx = txt.index("345", idx+1)
...     print(idx)
... 
2
13
ValueError: substring not found

↑

要素の集計 †

len(str)

>>> txt
'12345ABCDEF12345ABCDEF'
>>> len(txt)
22

マルチバイト文字であることを意識する必要は無い

>>> len("1234567890壱弐参四五六七八九〇1234567890壱弐参四五六七八九〇")
40

str.count(検索文字列, [開始位置], [終了位置])
```
'12345ABCDEF12345ABCDEF'
>>> txt.count('345')
2
```

↑

要素の判定 †

str.startswith(検索文字列, [開始位置], [終了位置])
str.endswith(検索文字列, [開始位置], [終了位置])
str.isalpha()
str.isalnum()

str.isdigit() ([0-9]+)

>>> "123".isdigit()
True
>>> "-123".isdigit()
False
>>> "百二十三".isdigit()
False

str.isnumeric() (ローマ数字、漢数字が TRUE になる)

>>> "123".isnumeric()
True
>>> "-123".isnumeric()
False
>>> "百二十三".isnumeric()
True

str.islower()
str.isupper()
str.istitle() (先頭とスペースの後が大文字になっているか)
str.isspace() ([ \t\r\n]+)
str.isidentifier() (Python3～ .変数名として使える文字列か)
str.isprintable() (Python3～ .エスケープ文字が入っていないか)

↑

要素の加工 †

文字列の連結

>>> "123" + "ABC"
'123ABC'

文字列型以外を連結しようとすると TypeError?

>>> "123" + 456
TypeError: Can't convert 'int' object to str implicitly
>>> "123" + str(456)
'123456'

"区切り文字".join(シーケンス) : 文字列
```
>>> ",".join(["123","ABC","!@#"])
'123,ABC,!@#'
```
str.split("区切り文字",[分割数]) 左から分割した list にする
str.rsplit("区切り文字",[分割数]) 右から分割した list にする
```
>>> '123,ABC,!@#'.split(",")
['123', 'ABC', '!@#']
>>> '123,ABC,!@#'.rsplit(",")
['123', 'ABC', '!@#']
```
区切り文字を省略すると、スペース区切り (※両端がトリムされる)
```
>>> ' 123  ABC   !@#  '.rsplit()
['123', 'ABC', '!@#']
```

str.splitline() 改行で分割

>>> '1st line\n2nd line'.splitlines()
['1st line', '2nd line']

第一引数に True を指定すると改行文字が残される

>>> '1st line\n2nd line'.splitlines(True)
['1st line\n', '2nd line']

str.partition(区切り文字) 左から分割した tuple にする

str.rpartition(区切り文字) 右から分割した tuple にする

>>> '123abc123abc'.partition('b')
('123a', 'b', 'c123abc')
>>> '123abc123abc'.rpartition('b')
('123abc123a', 'b', 'c')

str.replace(置換対象の文字列, 置き換え文字列,[最大置換回数])

>>> '123abc123abc123abc'.replace('abc','xyz')
'123xyz123xyz123xyz'
>>> '123abc123abc123abc'.replace('abc','xyz',2)
'123xyz123xyz123abc'

str.expandtabs([タブ幅]) tabをスペースに置き換える。タブ幅省略時は 1 tab = 8 spc

>>> 'TYPE\tRMX11\t$9,250'
'TYPE\tRMX11\t$9,250'
>>> 'TYPE\tRMX11\t$9,250'.expandtabs()
'TYPE    RMX11   $9,250'

str.translate(変換テーブル)
{りんご→apple, みかん→orange, ぶどう→grape, ... } という変換辞書で文字列を変換するわけではない 1文字→1文字の変換
```
>>> table = str.maketrans('abc','xyz','3')
>>> "abcde12345a1b2c3d4e5".translate(table)
'xyzde1245x1y2zd4e5'
```
table は dict
```
>>> type(table)
<class 'dict'>
>>> table
{97: 120, 98: 121, 99: 122, 51: None}
>>> chr(97)
'a'
>>> chr(120)
'x'
```
辞書は str クラスの static メソッドである str.maketrans() を使う (Python2 までは string モジュールの一部だったが Python3 から str クラスの static メソッド)
- str.maketrans(置換対象の文字列, 置き換え文字列,[削除文字列])
- str.maketrans(辞書)
```
>>> dicTrans={'%FROM%':'manager@acme.co.tk','%TO%':'customer@gmail.com','%SUBJECT%':'Shipping Date'}
>>> table = str.maketrans(dicTrans)
ValueError: string keys in translate table must be of length 1
```
  ぱっと見、誰でもこういう使い方を予想するよねぇ。1文字→1文字の変換辞書を作るので、str.maketrans(辞書) の辞書は要素数が1 でなければならない。
str.lower()
str.upper()
str.title() (先頭とスペースの後を大文字にする)
str.capitalize() (先頭を大文字にする)
str.ljust(文字列の長さ,[埋字]) (左寄せ。埋字省略時はスペースで埋字)
str.center(文字列の長さ,[埋字]) (中寄せ。埋字省略時はスペースで埋字)

str.rjust(文字列の長さ,[埋字]) (右寄せ。埋字省略時はスペースで埋字)

>>> "abc".ljust(10)
'abc       '
>>> "abc".center(10)
'   abc    '
>>> "abc".rjust(10)
'       abc'
>>> "123456".rjust(10,'*')
'****123456'

str.zfill(文字列の長さ)
```
>>> "123456".zfill(10)
'0000123456'
```
str.strip([除去文字列]) (両端から除去文字列を削除。除去文字列省略時は空白を削除)
str.rstrip([除去文字列]) (右だけ)

str.lstrip([除去文字列]) (左だけ)

>>> 'aaabbbcccbbbaaa'.strip('a')
'bbbcccbbb'
>>> 'aaabbbcccbbbaaa'.rstrip('a')
'aaabbbcccbbb'
>>> 'aaabbbcccbbbaaa'.lstrip('a')
'bbbcccbbbaaa'
>>> '    <tag>value</tag>    '.strip()
'<tag>value</tag>'

↑

Iterator / Generator †

Iterator は、next() 関数で、要素を順番に取り出せるオブジェクト
```
>>> plants = iter(['梅','蘭','菊','竹'])
>>> plants
<list_iterator object at 0x102b7e050>
>>> next(plants)
'梅'
>>> next(plants)
'蘭'
>>> next(plants)
'菊'
>>> next(plants)
'竹'
>>> next(plants)
Traceback (most recent call last):
  File "<pyshell#77>", line 1, in <module>
    next(plants)
StopIteration
```
- iter( iteratable ) で iteratable の内容を順に返す iterator を作成する
  - iter( dictionary ) は、key の iterator (dict_Keyiterator) が作られる
  - iter( set ) は、set_iterator が作られる
- next(iterator) で要素を取得する (→ 内部的には iterator.__next__() が呼ばれている)
- 要素がなくなると StopIteration? 例外が発生する
- ※ Python2 までは、iterator.next() で要素を取得していた

Generator は、計算によって値を生成する Iterator

#!/usr/bin/env python
# coding: utf-8

def fibonacci_generator() :
  yield 0
  yield 1
  
  i = 0
  j = 1
  while True :
    k = i + j
    i = j
    j = k
    yield k

fibonacci = fibonacci_generator()

print([next(fibonacci) for i in range(10)])

$ python fibonnacci.py 
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

Generator は、無限ループする関数オブジェクト
値は yield で生成する。yield で値を返すと処理が止まる。次に next(generator) が呼ばれたら、次の yield まで処理を進める。

Python

目次

訪問者

更新

最新の10件

人気の10件

MenuBar

Python の型 †

動的型付け †

id()、is、== †

None †

数値 †

bool †

int †

float †

complex †

long は、Python3 で廃止された †

list †

作成 †

要素の取得 †

要素の検索 †

要素の集計 †

要素の更新 †

要素の削除 †

ソート †

コピー †

比較 †

tuple †

set †

作成 †

set同士の演算 †

要素の取得 †

要素の検索 †

要素の集計 †

要素の更新 †

要素の削除 †

コピー †

比較 †

frozen set †

dictionary †

作成 †

要素の取得 †

要素の検索 †

要素の集計 †

要素の更新 †

要素の削除 †

コピー †

比較 †

順序付き辞書 †

文字列 †

作成 †

要素の取得 †

要素の検索 †

要素の集計 †

要素の判定 †

要素の加工 †

Iterator / Generator †