i_yamasakiさんの投稿

結論：
lambda式の参照は呼び出されたタイミングで決まる

本題：
またミュータブル、イミュータブル関連で躓いたのでメモ
リスト内辞書にラムダ式を持たせて比較を行おうとした。

l = ["a", "b", "c", "d", "e"]

funcL = [
    {
        "str": s,
        "func": lambda x: x == s
    } for s in l
]

checkStr = "a"

for func in funcL:
    print(checkStr, func["str"], func["func"](checkStr))

# >> std out
# >> a a False
# >> a b False
# >> a c False
# >> a d False
# >> a e False

なんでaとaがFalseになってるの！？となったところで確認してみるとfunc["func"]で比較しているsがすべてeになっている。

l = ["a", "b", "c", "d", "e"]

funcL = [
    {
        "str": s,
        "func": lambda _x: print(s)
    } for s in l
]

for func in funcL:
    func["func"](None)

# >> std out
# >> e
# >> e
# >> e
# >> e
# >> e

いろいろ試したところラムダ式の中身が確定されるのはラムダ式が呼び出されたタイミングで参照されている値であり、今回の例ではそれぞれのラムダ式が呼び出された時点でのsの参照先が"e"のためすべてのラムダ式で"e"と比較されていたらしい。

解決策：
おとなしくラムダ式を使わずに比較する。

l = ["a", "b", "c", "d", "e"]

checkStr = "a"

for s in l:
    print(checkStr, s, checkStr == s)

# >> std out
# >> a a True
# >> a b False
# >> a c False
# >> a d False
# >> a e False

集合型にはミュータブル型（変更不可）しか入れられないのが原因らしい。

辞書はイミュータブル型（変更可能）だから入らなかったので一度文字列（ミュータブル型）に変換して入れた後にリストに入れれば疑似的に重複を削除できた。

import json

dlist = [
    {"a": 1},
    {"a": 1}, # 同じ値
    {"b": 2},
]

dlist_new = [json.loads(d_str) for d_str in {json.dumps(d_dict) for d_dict in dlist}]
# dlist_new = [{"a": 1}, {"b": 2}]
# dlist_newの中身は順不同

ミュータブル型に変換するのであれば辞書のキーにしてしまい値だけ取り出す方法でもできることに気が付いた。こちらのほうがすっきりしていて見やすい気がする。また、愚直に集合型を使用しないので中身が元のリストの出現順になる。

import json

dlist = [
    {"a": 1},
    {"a": 1}, # 同じ値
    {"b": 2},
]

dlist_new = list({json.dumps(d): d for d in dlist}.values())

print(dlist_new)
# dlist_new = [{"a": 1}, {"b": 2}]

辞書の要素の順がすべて同じであると保証されている場合はこれでも良いが、よく考えると要素の出現順が違うとこの方法だとうまくいかないことに気が付いてしまった。

import json

dlist = [
    {"c": 3, "a": 1},
    {"a": 1, "c": 3}, # 同じ値、ただし順番は違う
    {"b": 2, "c": 3},
]

dlist_new1 = [json.loads(d_str) for d_str in  {json.dumps(d_dict) for d_dict in dlist}]
# [{'c': 3, 'a': 1}, {'a': 1, 'c': 3}, {'b': 2, 'c': 3}]
# 重複削除失敗

dlist_new2 = list({json.dumps(d): d for d in dlist}.values())
# [{'c': 3, 'a': 1}, {'a': 1, 'c': 3}, {'b': 2, 'c': 3}]
# 重複削除失敗

辞書の順をソートしても良いが、ネストが深い場合にどうにもならないので比較するしかなさそう。すでに出てきた辞書を追加するリストを使う方法が最初に浮かんだ。

dlist = [
    {"c": 3, "a": 1},
    {"a": 1, "c": 3}, # 同じ値、ただし順番は違う
    {"b": 2, "c": 3},
]

dlist_new = []

for d in dlist:
    if d not in dlist_new:
        dlist_new.append(d)

# dlist_new = [{'c': 3, 'a': 1}, {'b': 2, 'c': 3}]

ただどうしてもワンライナーで書きたかったので考えていたところ、dlist内の比較結果が同じもので作成したリストを文字列に変換し、それをキーにしてリスト内の比較結果が同じものを紐づける方法を思いついた。

import json

dlist = [
    {"c": 3, "a": 1},
    {"a": 1, "c": 3}, # 同じ値、ただし順番は違う
    {"b": 2, "c": 3},
]

dlist_new = list({json.dumps([_d for _d in dlist if d == _d]): d for d in dlist}.values())
# [{'a': 1, 'c': 3}, {'b': 2, 'c': 3}]
# 同じ内容の場合後に出てきたものが入る

あまり賢い方法には思えないがこれが一番スッキリしていると思う。

myset = {
    {"a": 1},
    {"b": 2}
}
# TypeError: unhashable type: 'dict'

辞書型どうしで比較できるんだから集合に入れたときも頑張ってくれたっていいじゃん…

結論

jmespathライブラリを使うと良い

やりたいこと

今まで深いネストをした辞書から値を取り出す際には

d = {"hoge": {"fuga": {"piyo": 1}}}

v = d.get("hoge", {}).get("fuga", {}).get("piyo")
# v = 1

としていたが、非常に長ったらしいのでやめたかった。
ネストをピリオドでつないで取得できるのが理想。

調べたところ、ライブラリでの解決策としては「辞書型を拡張したクラスを使う」パターンと、「関数を通して辞書から指定の値を取り出す」パターンがあるらしい。

「辞書型を拡張したサブクラスを使う」パターン

pip install python-box

from box import Box

d = {"hoge": {"fuga": {"piyo": 1}}}

mybox = Box(d, box_dots=True, default_box=True)
v = mybox["hoge.fuga.piyo"]
# v = <Box: 1>

default_box=Trueでパスが存在しないときにも空のBoxオブジェクトが帰ってくる。
想像していたものに近いがサブクラスの宣言がいちいち必要なのが面倒。

「関数を通して辞書から指定の値を取り出す」パターン

pip install jmespath

import jmespath

d = {"hoge": {"fuga": {"piyo": 1}}}

v = jmespath.search("hoge.fuga.piyo", d)
# v = 1

これでよさそう。

参考ページ
https://qtatsu.hatenablog.com/entry/2021/05/08/165510

投稿テストを兼ねて
Pythonサブカテゴリ作成

Python