tail -f /dev/null

If you haven't had any obstacles lately, you're not challenging. be the worst.

トップ > python > Python data collectionとbuilt-in

Python data collectionとbuilt-in

python

Pythonのおべんきょう。

Python String object

format() method (formatter)

  • 値を文字列へformatする。
  • replacement field (置換フィールド) はformat() methodに渡す引数を示すindexである。
  • format文字列を使用する場合、 波括弧をplaceholderの指定に使用する。
  • {} はpositional argument specifiersや、 replacement field (置換フィールド)と呼ぶ(※1)。
>>> test_string = 'xxx'
>>> test_string_2 = 'yyy'

>>> "{1} and {0}".format(test_string, test_string_2)
'yyy and xxx'

>>> if x > 5:
...     raise Exception('x should low 5. x is: {}'.format(x))
...
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
Exception: x should low 5. x is: 10

docs.python.org Formatter

string concatenation (文字列結合)

  • Stringはimmutableの為、 string concatenation を行う場合、 新しいstring objectを生成しそれにmemoryを割り当てて変数へ代入を行う。
  • join method (str.join(s)) でstring literalを連結すれば新しくobjectを生成すること無く、 memoryも割り当てない。
s = ""
for x in y:
    s += x # 結合+代入 (concatenation + substitution)

compound field (合成フィールド)

  • compound filed (合成フィールド) と呼ばれるアクセス修飾子で、 Pythonと同じような構文で要素へアクセスする。
  • 次のようなアクセス方法でcompound fieldを利用出来る。
    • indexを指定してlistの要素へアクセスする。
    • dictのkeyで要素へアクセスする。
    • moduleの変数、 関数名でアクセスする。
    • instanceを渡し、 property、 method名でアクセスする。
# `{0[0]}` and `{0[3]}` called compound field (合成フィールド).
>>> TEST_LIST = [1, 2, 3, [1, 2, 3, 4, 5], 4]
>>> "{0[0]} and {0[3]}".format(TEST_LIST)

1 and [1, 2, 3, 4, 5]

format specifiers (フォーマット指定子)

“Format specifications” are used within replacement fields contained within a format string to define how individual values are presented... They can also be passed directly to the built-in format() function. Each formattable type may define how the format specification is to be interpreted.

docs.python.org

>>> "{0:.1f} {1}".format(10.123, ' .')
'10.1  .'
  • :.<桁数>f のコロン以降は、 format specifiers (フォーマット指定子) と呼ばれ、 置換する変数のフォーマット方法を決める指定子である。
    • 0、 空白、 文字列を追加したり、 進数を変換したり出来る。
  • argument specifiers (引数指定子) とも呼ばれる。
  • 例は公式を参照。
  • 古い % の記法もある。 ※2

URI parameterから、 dictを作る

URL末尾のパラメータから urllib libraryを利用してdictionaryを作ることも出来るが

import urllib.parse as urlparse

url = "https://www.example.org/index.html?country=japan&state=tokyo&city=shibuya"
print(dict(urlparse.parse_qsl(urlparse.urlsplit(url).query)))
{'country': 'japan', 'state': 'tokyo', 'city': 'shibuya'}

list comprehension(リスト内包表記)でsplit(sep=None, maxsplit=-1)が、 [x,y] のlistを返し、 dictに変換する.

uri = 'country=japan&state=tokyo&city=shibuya'

param_list = uri.split('&') # ['country=japan', 'state=tokyo', 'city=shibuya']
param_list_comp = [li.split('=', 1) for li in param_list if '=' in li] # [['country', 'japan'], ['state', 'tokyo'], ['city', 'shibuya']]
param_dict = dict(param_list_comp) # {'country': 'japan', 'state': 'tokyo', 'city': 'shibuya'}

前後x番目のstring以降を抽出する

>>> test_str = '123 ABC DEF'

>>> test_str[2:]
'3 ABC DEF'
>>> test_str[3:]
' ABC DEF'
>>> test_str[:-2]
'123 ABC D'
>>> test_str[-3:]
'DEF'

>>> test_str[:-3] + test_str[-3:]
'123 ABC DEF

注釈

※1. version3.1から {} 内のpositional argument specifier(replacement field)は省略可能となった。

>>> '{}, {}, {}'.format('a', 'b', 'c')
'a, b, c'

Changed in version 3.1: The positional argument specifiers can be omitted for str.format(), so '{} {}'.format(a, b) is equivalent to '{0} {1}'.format(a, b).
Changed in version 3.4: The positional argument specifiers can be omitted for Formatter.

※2. format % values の形式。

  • formatの文字列にある変数をvaluesの0以上の要素で置換するprintfのようなもの。
  • strftime() 等では %a, %w, %d 等directiveがある。
  • 例:
    • %s: String
    • %d: Integers
    • %f: Floating point numbers (浮動小数点数)
    • %.<桁数>f: Floating point numbers with fix number (固定桁数の浮動小数点数)
>>> test_format = "xxx"
>>> "xxx is %s" % test_format
'xxx is xxx'

Python Int object (native data type)

数値型には 3 種類あります: 整数 、 浮動小数点数 、 複素数 です。さらに、ブール型は整数のサブタイプです。整数には精度の制限がありません。浮動小数点型はたいていは C の double を使って実装されています; あなたのプログラムが動作するマシンでの浮動小数点型の精度と内部表現は、 sys.float_info から利用できます。複素数は実部と虚部を持ち、それぞれ浮動小数点数です。複素数 z から実部および虚部を取り出すには、 z.real および z.imag を使ってください。 (標準ライブラリには、その他の数値型、分数を保持する fractions や、ユーザ定義の精度の浮動小数点数を保持する decimal があります。)

docs.python.org

Int object

  • built-in object.
  • 整数(8進数, 16進数, 短整数, 長整数), 浮動小数, 複素数に分かれる.
  • 演算子 +, -, *, % は他言語と似たように利用可能.
    • 他 **: 冪乗, <<, >>: bit shift, &, |, ^: and, or, xor 等がある.
  • Pythonは数値に小数点が存在した場合は, typeがfloatになる.
  • int()でfloat値を指定した場合は, 型強制で小数点以下切り捨てすることが可能.
    • 例えば int(1.5) は 1 に型強制される.
  • math moduleで数学計算が可能.
>>> type(1)
<class 'int'>

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

# isinnstance: 値や変数の型を確認
>>> isinstance(1,int)
True

演算

  • /演算子 : 浮動小数点の除算
  • //演算子 : 整数除算
  • ** : 冪乗(累乗)
  • % : 整数除算余り
>>> 1.5/2
0.75

>>> 2.5//2
1.0

# 5の2乗
>>> 5**2
25

>>> 5%2
1

Intでbool

bool値として0,0.0はfalse, それ以外はtrueとして利用したりも出来る。

>>> def x(y):
...     if y:
...         print("true")
...     else:
...         print("false")
...
>>> x(1)
true
>>> x(0)
false
>>> x(0.1)

分数

>>> import fractions
>>> x = fractions.Fraction(1,5)
>>> x*5
Fraction(1, 1)
>>> x*10
Fraction(2, 1)
>>> x
Fraction(1, 5)

Data collection: List object

リストはミュータブルなシーケンスで、一般的に同種の項目の集まりを格納するために使われます (厳密な類似の度合いはアプリケーションによって異なる場合があります)。
class list([iterable])
リストの構成にはいくつかの方法があります:
角括弧の対を使い、空のリストを表す:
角括弧を使い、項目をカンマで区切る: [a]、[a, b, c]
リスト内包表記を使う: [x for x in iterable]
型コンストラクタを使う: list() または list(iterable)
コンストラクタは、 iterable の項目と同じ項目で同じ順のリストを構築します。 iterable は、シーケンス、イテレートをサポートするコンテナ、またはイテレータオブジェクトです。
iterable が既にリストなら、 iterable[:] と同様にコピーが作られて返されます。例えば、 list('abc') は ['a', 'b', 'c'] を、 list( (1, 2, 3) ) は [1, 2, 3] を返します。引数が与えられなければ、このコンストラクタは新しい空のリスト を作成します。

docs.python.org

List object (リストについて)

  • sequence type (複数の要素をまとめて扱える).
    • 他にString, List, Tuple, Range等がある.
  • 動的であり作成後に変更可能.
  • 要素は順序づけされる.
  • 全要素をメモリにコピーする.
    • 取り扱いに注意.
  • iterable にするには, iter() を呼び出す.
  • string(文字列)と比較すると同じsequence typeのobjectだが次の点が異なる.
    • stringは1つのindexに1文字ずつ格納していたが, listは1つのindexに1つのobjectを格納すること.
      • objectであれば何でも保存可能.
        • listをlistに格納する2次元配列等.
    • objectがmutableであり, object自身を変更することが可能であること. (※1)
  • stringと同様, slicingや結合が可能.
>>> li = ['a', 'b', 'c']
>>> li
['a', 'b', 'c']
>>> li[0]
'a'
>>> li[1]
'b'
>>> li[-1]
'c'

>>> li_1 = [1,2,3]
>>> li_2 = [4,5]

>>> li_3 = [li_1,li_2]
>>> li_3
[[1, 2, 3], [4, 5]]

>>> li_3[1][0]
4

# ex. stdin 1 2 3 -> [1, 2, 3]
test_list=list(map(int,input().split()))
print(test_list)

# same as below
test_list=[int(i) for i in input().split()]

Slice (スライス)

>>> li = ['a', 'bb', 'ccc', 'dddd']
>>> li[0:1] #0~1の直前迄slice
['a']
>>> li[1:2] #1~2の直前迄slice
['bb']
>>> li[3:4] #3~4の直前迄slice
['dddd']
>>> li[:2] #前から2要素目まで返す
['a', 'bb']
>>> li[2:] #後ろから2要素目まで返す
['ccc', 'dddd']

List結合

>>> li
['a', 'bb', 'ccc', 'dddd']

# Listの要素は型の制約が無い
>>> li = li + ['eeeee', 5]
>>> li
['a', 'bb', 'ccc', 'dddd', 'eeeee', 5]

# 末尾に要素を追加
>>> li.append(False)
>>> li
['a', 'bb', 'ccc', 'dddd', 'eeeee', 5, False]

# listにlistを入れることも可能
>>> li.append(['append_1', 'append_2'])
>>> li
['a', 'bb', 'ccc', 'insert_1', 'dddd', 'eeeee', 5, False, ['append_1', 'append_2']]

# 引数のlistを追加する. appendと異なり, listにlistを追加することは出来ない(筈).
>>> li.extend(['extend_1', 'extend_2'])
['a', 'bb', 'ccc', 'dddd', 'eeeee', 5, False, False, 'extend_1', 'extend_2']

# 指定したindexへ挿入
>>> li.insert(3, 'insert_1')
>>> li
['a', 'bb', 'ccc', 'insert_1', 'dddd', 'eeeee', 5, False, False, 'extend_1', 'extend_2']
  • +演算子 でlist結合が可能.
  • Listはclassである(classとして実装されている)為, listの生成はclassのinstance化である.
    • methodを利用可能.
      • extend()
      • insert()
  • List結合により, 追加でmemory上に新しいlistが作成される.
    • 新しいlistは既存変数へ代入される.
  • 結合+代入の2処理が走る為, 巨大なsizeのlistは時に大量のmemoryを必要とする .

List検索

>>> li
['a', 'bb', 'ccc', 'insert_1', 'dddd', 'eeeee', 5, False, False, 'extend_1', 'extend_2']

>>> li.count(False)
2
>>> 'dddd' in li
True
>>> li.index('eeeee')
5

Listから要素を削除

>>> li
['a', 'bb', 'ccc', 'insert_1', 'dddd', 'eeeee', 5, False, False, 'extend_1', 'extend_2', ['append_1', 'append_2']]

>>> del li[7]
>>> li
['a', 'bb', 'ccc', 'insert_1', 'dddd', 'eeeee', 5, False, 'extend_1', 'extend_2', ['append_1', 'append_2']]

>>> li.remove('extend_2')
>>> li
['a', 'bb', 'ccc', 'insert_1', 'dddd', 'eeeee', 5, False, 'extend_1', ['append_1', 'append_2']]

# 要素の最後を削除
>>> li.pop()
['append_1', 'append_2']
>>> li
['a', 'bb', 'ccc', 'insert_1', 'dddd', 'eeeee', 5, False, 'extend_1']

>>> li.pop(3)
'insert_1'
>>> li
['a', 'bb', 'ccc', 'dddd', 'eeeee', 5, False, 'extend_1']

boolでlistを利用する

>>> def x(y):
...     if y:
...         print("true")
...     else:
...         print("false")
...
>>> x([])
false

# 要素が1つ以上あれば、True。
>>> x(['a'])
true

list comprehension (リスト内包表記)

>>> test_list = [1,3,5,7]
>>> [li * 2 for li in test_list]
[2, 6, 10, 14]

>>> [li * 3 for li in test_list if li < 5]
[3, 9]
  • forのネストでif条件式を行う書き方は, for loop毎に, また条件毎にinterpreter上で処理を行う為遅くなる。
  • リスト内包表記を利用することで、 interpreter内部で処理が走る為処理が早くなる。
  • 可読性も向上する。
  • list内包表記は新しくlistを作成する為, 元のlistには影響が無い。
  • listのresize(結合+代入)は内包表記でも発生する(再割り当て)。
    • 例えば以下の場合, loopでinterpreter上の処理とcounterが走り, appendでlookup関数の処理が追加で走る。
  • 処理の流れは右から左へ見ると把握しやすい。
    • test_listの要素を1度に1つずつ取り出し, 一時変数liへ代入. li * 2 を適用し結果を戻り値のlistへ追加する。
x = []
for i in y:
    if ...:
        x.append(i)

enumerate()

loop内でsequenceを使う場合, 要素のindexを取れる関数。

for i, element in enumerate(['a','b','c']):
    print(i, enumerate)
0 a
1 b
2 c

zip()

複数listから要素の取り出し, 組み合わせを行う関数。

for i in zip ([1,2,3],[4,5,6]):
    print(i)
(1,4)
(2,5)
(3,6)

sequenceのunpack

  • 等号の左右にある要素数が同じ場合, sequenceの要素を変数に格納可能。
  • *による複数要素のキャプチャも可能。
one,two,three,four = 'a',2,'c',3,'d'
one,two,three,*four = 'a',2,'c',3,'d'
print(four)
[3, d]

注釈

※1 string(文字列)はimmutableである、の追記。

>>> a = 'xxx'
>>> b = 'yyy'
>>> print(a)
xxx
>>> a = a + b
>>> print(a)
xxxyyy

上記はaが xxxyyy に変化したように見える。しかしa自体は xxx のままである。最初に変数aのpointerはxxxを見ていたが、 xxx+yyy を見るようにpointer (references先, 向き先) を変更された為。 stringは不変だが、変数はpointerを変更することが出来る。

Data collection: Tuple object

  • 要素は順序づけされる。
  • 要素はimmutableであり, 作成後の変更は不可。
    • hashableである。
    • listにはあったappend, remove()等操作出来るmethodが無い。
    • sliceは変更では無く、新しいtupleを作るので, 可能。
  • objectの割り当て、取り出しが高速に行える。
    • 変更の予定が無いdataをiterateするだけなら、tupleが良い。
    • 書き込む予定が無いという宣言にもなる。
  • 組み合わせが固定な要素の格納に適す。
    • 座標等
  • listより高速。
    • 変更予定のない集合をiterateするだけであれば、listではなくtupleが良い。
    • 高速でimmutableなので。
  • listと異なり、 []では無く()で要素を囲む。
  • listと同様、順序付けが行われる。
  • 辞書のkeyとして使える。
    • listはmutableなので使えない。
  • tupleはlistへ変換可能(list())。
    • 逆も可能(tuple())。

多値代入

  • 関数から複数の戻り値を返す処理.
  • tupleで複数の要素を代入することが可能.
>>> path = '/path/to/python_test.py'
>>> import os
>>> (dir, file) = os.path.split(path)
>>> dir
'/path/to/'
>>> file
'python_test.py'

# rangeが返したiterate値を代入
>>>  (jan, feb, mar, apr, may, jun, jul, aug, sep, oct, nov, dec) =  range(12)
>>> jan
0
>>> feb
1

Data collection: Set (集合) object

set オブジェクトは、固有の hashable オブジェクトの順序なしコレクションです。通常の用途には、帰属テスト、シーケンスからの重複除去、積集合、和集合、差集合、対称差 (排他的論理和) のような数学的演算の計算が含まれます。(他のコンテナについては組み込みの dict, list, tuple クラスや collections モジュールを参照してください。)
集合は、他のコレクションと同様、 x in set, len(set), for x in set をサポートします。コレクションには順序がないので、集合は挿入の順序や要素の位置を記録しません。従って、集合はインデクシング、スライシング、その他のシーケンス的な振舞いをサポートしません。
set および frozenset という、2つの組み込みの集合型があります。 set はミュータブルで、add() や remove() のようなメソッドを使って内容を変更できます。ミュータブルなため、ハッシュ値を持たず、また辞書のキーや他の集合の要素として用いることができません。一方、frozenset 型はイミュータブルで、ハッシュ可能 です。作成後に内容を改変できないため、辞書のキーや他の集合の要素として用いることができます。
空でない set (frozenset ではない) は、set コンストラクタに加え、要素を波括弧中にカンマで区切って列挙することでも生成できます。例: {'jack', 'sjoerd'}。

docs.python.org/ja/3/library/stdtypes.html#set-types-set-frozenset

Set (集合)

  • built-in object.
  • 値の集合.
  • 要素の特徴
    • 一意
      • 要素の一意性を重視するデータ構造.
    • 順序を保持しない.
    • hashable
  • 組み込み型の set(),frozenset() がある.
    • setとfrozensetの違いとしては, frozensetの場合は要素を変更する事が出来ない(immutable).
  • listは if num in x: の処理を行う際に要素の全探索を行うが, set()はhash tableで実装されており要素とindexが貼られた整数がペアとなっている.
    • hash値を元に要素の検索を行う為, list検索よりも何倍も速い.
    • dictも同様hash tableなので, 速い.

set()

  • stringからset型を生成することも可能.
  • tupleからset型を生成することも可能.
  • listからset型を生成することも可能.
  • dictionaryから, set型を生成することも可能.
    • dictionaryの場合, keyがsetに格納される.
>>> set_test = set()
>>> set_test
set()

# set関数の呼び出しではなく, set classのinstance化である.
>>> type(set_test)
<class 'set'>

>>> set_from_str = set("test unique xxx")
>>> set_from_str
{'e', 'u', ' ', 'x', 'q', 't', 'i', 's', 'n'}

>>> set_from_tuple = set((1,2,3))
>>> set_from_tuple
{1, 2, 3}

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

>>> set_from_dict = set({"key_1":"val_1","key_2":"val_2"})
>>> set_from_dict
{'key_2', 'key_1'}

>>> set = {1,2,3}
>>> type(set)
<class 'set'>
>>> set
{1, 2, 3}

Setへの追加、除外

  • add method
    • 単一の引数のみ指定可.
  • update method
    • 引数として集合をとり, 全要素を集合に追加する.
    • 集合は一意の為, 重複した値を含むことができない.
    • 引数は複数可.
  • discard method
    • 単一の引数のみ指定可.
    • 存在しない要素を引数として呼び出した場合, エラーが発生しない.
  • remove method
    • 単一の引数のみ指定可.
    • 存在しない要素を引数として呼び出した場合, KeyError exceptionとなる.
  • clear method
    • 全要素を削除する.
  • pop method
    • 集合は順序が無い為, どこがpopされるのか制御不可. (※1)
>>> set_test = {1,2,3}

# args support all type.
>>> set_test.add(5)
>>> set_test
{1, 2, 3, 5}

>>> set_test.update({4,6})
>>> set_test
{1, 2, 3, 4, 5, 6}

>>> set_test.update({3,7},{4,8})
>>> set_test
{1, 2, 3, 4, 5, 6, 7, 8}

>>> set_test.discard(8)
>>> set_test
{1, 2, 3, 4, 5, 6, 7}

# only 1 arg can be set.
>>> set_test.discard(6,7)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: discard() takes exactly one argument (2 given)

# nothing happen when arg set nonexistent val.
>>> set_test.discard(100)

>>> set_test.remove(7)
>>> set_test
{1, 2, 3, 4, 5, 6}

# remove throw KeyError when arg is nonexistent val.
>>> set_test.remove(100)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 100

# throw TypeError when pop takes no args.
>>> set_test.pop(6)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: pop() takes no arguments (1 given)

# clear all values.
>>> set_test.clear()

# throw KeyError when pop takes empty set.
>>> set_test.pop()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'pop from an empty set'

集合演算 (Set operation)

  • union method
    • 引数のsetをまとめて返す
  • intersection method
    • 引数のsetと同じ要素を返す
  • difference method
    • 引数のsetと比較し, 自身に存在しない要素を返す.
  • symmetric_difference
    • 引数のsetと比較し, 対称な値を返す.
  • issubset
    • 引数のsetに含まれる場合は, Trueを返す.
>>> set_test = {1,2,3}
>>> set_test_2 = {3,4,5}

>>> set_test.union(set_test_2)
{1, 2, 3, 4, 5}

>>> set_test.intersection(set_test_2)
{3}

>>> set_test.difference(set_test_2)
{1, 2}

>>> set_test_2.difference(set_test)
{4, 5}

>>> set_test.symmetric_difference(set_test_2)
{1, 2, 4, 5}

>>> set_test = {1,2,3}
>>> set_test_2 = {2,3}

>>> set_test.issubset(set_test_2)
False

>>> set_test_2.issubset(set_test)
True

Set comprehension (集合内包表記)

>>> test_list = [1,2,3,4,5,6,7]

>>> test_set_comp = {x * 3 for x in test_list if x < 5}
>>> type(test_set_comp)
<class 'set'>

>>> test_set_comp
{9, 3, 12, 6}

注釈

※1. 順序が無いsetに対しpopを利用すると何処から削除されるかだが, 試したところ追加されたreference(変数には値そのものが格納される訳ではなく, 変数の場所を指し示すreference値が格納される)の最後からpopされているのではないか, と思った.

>>> set_test
{20}
>>> set_test.update({1,2,3,4,5,33})
>>> set_test
{4, 3, 2, 1, 5, 33, 20}
>>> set_test.pop()
20
>>> set_test
{4, 3, 2, 1, 5, 33}
>>> set_test.pop()
4
>>> set_test.pop()
3

Data collection: Dict object

Dict object

  • 汎用性が高いdata structureである.
  • built-in type (組み込み型), 且つmapping typeである.
  • key, value (キーと値) の unique なペアを要素として持つ.
    • keyをindexとして利用してobjectへアクセスする.
    • valueはtype(型)に制限されない. どのようなtypeでも問題無い.
    • keyはstring, int, その他幾つかのtypeを利用可能.
  • iterableである.
  • 順序の観点では, 次の通り.
    • version 3.6までは一定順序で保存するsequenceとは異なり, dictの要素は順序が無かった.
    • version 3.7から順序が保持(保証)されるようになった.
>>> test_dict = {"key_1":"val_1","key_2":"val_2"}

>>> test_dict["key_3"] = "val_3"
>>> test_dict
{'key_1': 'val_1', 'key_2': 'val_2', 'key_3': 'val_3'}

>>> test_dict["key_1"] = "val_1_1"
>>> test_dict
{'key_1': 'val_1_1', 'key_2': 'val_2', 'key_3': 'val_3'}

>>> bool(test_dict)
True
>>> test_dict_2 = {}
>>> bool(test_dict_2)

view object

  • 次のmethodは、view objectを返す (python3).

    • view objectはdictの内容を展開するobject.
    • listと異なり, 全要素をmemoryにコピーしない.

  • keys() method

    • dict_keys objectを返す.
    • key:valを同じ順序で返す.
  • values() method
    • dict_values objectを返す.
    • key:valを同じ順序で返す.
  • items() method
    • dict_items objectを返す.

dict comprehension (辞書内包表記)

>>> a = {num: num*2 for num in range(10)}
>>> a
{0: 0, 1: 2, 2: 4, 3: 6, 4: 8, 5: 10, 6: 12, 7: 14, 8: 16, 9: 18}

>>> import os, glob
>>> test_dict = {py:os.stat(py) for py in glob.glob('*.py')}

>>> type(test_dict)
<class 'dict'>

>>> test_dict
{'zero.py': os.stat_result(st_mode=33188, st_ino=8626644617, st_dev=16777220, st_nlink=1, st_uid=800756132, st_gid=610996163, st_size=0, st_atime=1563162123, st_mtime=1563162123, st_ctime=1563162123), 'python_test.py': os.stat_result(st_mode=33188, st_ino=8626469773, st_dev=16777220, st_nlink=1, st_uid=800756132, st_gid=610996163, st_size=61, st_atime=1563006896, st_mtime=1562993542, st_ctime=1563006894)}

>>> test_dict.items()
dict_items([('zero.py', os.stat_result(st_mode=33188, st_ino=8626644617, st_dev=16777220, st_nlink=1, st_uid=800756132, st_gid=610996163, st_size=0, st_atime=1563162123, st_mtime=1563162123, st_ctime=1563162123)), ('python_test.py', os.stat_result(st_mode=33188, st_ino=8626469773, st_dev=16777220, st_nlink=1, st_uid=800756132, st_gid=610996163, st_size=61, st_atime=1563006896, st_mtime=1562993542, st_ctime=1563006894))])

# key: `glob.glob('*.py')` 関数で返されたfile.
>>> list(test_dict.keys())
['zero.py', 'python_test.py']

# value: `os.stat(py)` 関数で返されたmetadata.
>>> list(test_dict.values())
[os.stat_result(st_mode=33188, st_ino=8626644617, st_dev=16777220, st_nlink=1, st_uid=800756132, st_gid=610996163, st_size=0, st_atime=1563162123, st_mtime=1563162123, st_ctime=1563162123), os.stat_result(st_mode=33188, st_ino=8626469773, st_dev=16777220, st_nlink=1, st_uid=800756132, st_gid=610996163, st_size=61, st_atime=1563006896, st_mtime=1562993542, st_ctime=1563006894)]

>>> test_dict['zero.py'].st_uid
800756132

key, valueの置換.

>>> test_dict = {1:'a', 2:'b', 3:'c'}
>>> test_dict
{1: 'a', 2: 'b', 3: 'c'}
>>> {val:key for key, val in test_dict.items()}
{'a': 1, 'b': 2, 'c': 3}

その他

  • OrderedDict
    • 辞書のsub class.
    • 要素が追加された順序を保持する.
  • defaultdict
    • 辞書のsub class.
    • 要素が見つからなかった場合, 指定された関数を呼び出して初期値を生成する.