Python에서 중첩된 딕트를 어떻게 생성합니까?

Python에서 중첩된 딕트를 어떻게 생성합니까?

2개의 CSV 파일이 있습니다. '데이터' 및 '매핑':

• 열로 되어 있습니다: ' 핑는개' 4개의 열이 있습니다.Device_Name,GDN,Device_Type,그리고.Device_OS네 개의 열이 모두 채워집니다.
• ' 은 'Data'와 열을 .Device_Name열은 채워지고 나머지 세 개의 열은 비워집니다.
• 는 제 가 각각의 을 모두 .Device_Name파일에 합니다.GDN,Device_Type,그리고.Device_OS값을 입력합니다.

2개의 열만 있을 때 dict를 사용하는 방법은 알고 있지만(1개는 매핑해야 함) 3개의 열을 매핑해야 할 때 이를 수행하는 방법은 모르겠습니다.

다음은 제가 매핑을 수행하기 위해 사용한 코드입니다.Device_Type:

x = dict([])
with open("Pricing Mapping_2013-04-22.csv", "rb") as in_file1:
    file_map = csv.reader(in_file1, delimiter=',')
    for row in file_map:
       typemap = [row[0],row[2]]
       x.append(typemap)

with open("Pricing_Updated_Cleaned.csv", "rb") as in_file2, open("Data Scraper_GDN.csv", "wb") as out_file:
    writer = csv.writer(out_file, delimiter=',')
    for row in csv.reader(in_file2, delimiter=','):
         try:
              row[27] = x[row[11]]
         except KeyError:
              row[27] = ""
         writer.writerow(row)

를 합니다.Attribute Error.

좀 조사해 본 결과, 중첩된 딕트를 만들어야 할 것 같은데, 어떻게 해야 할지 전혀 모르겠어요.

중첩 딕트는 사전 내의 사전입니다.아주 간단한 것.

>>> d = {}
>>> d['dict1'] = {}
>>> d['dict1']['innerkey'] = 'value'
>>> d['dict1']['innerkey2'] = 'value2'
>>> d
{'dict1': {'innerkey': 'value', 'innerkey2': 'value2'}}

패키지의 를 사용하여 중첩된 사전을 쉽게 만들 수도 있습니다.

>>> import collections
>>> d = collections.defaultdict(dict)
>>> d['dict1']['innerkey'] = 'value'
>>> d  # currently a defaultdict type
defaultdict(<type 'dict'>, {'dict1': {'innerkey': 'value'}})
>>> dict(d)  # but is exactly like a normal dictionary.
{'dict1': {'innerkey': 'value'}}

---

원하는 대로 채울 수 있습니다.

코드에서 다음과 같은 것을 권장합니다.

d = {}  # can use defaultdict(dict) instead

for row in file_map:
    # derive row key from something 
    # when using defaultdict, we can skip the next step creating a dictionary on row_key
    d[row_key] = {} 
    for idx, col in enumerate(row):
        d[row_key][idx] = col

---

귀하의 의견에 따르면:

코드가 위에 있을 수 있습니다. 질문을 혼동하고 있습니다.간단히 말해서, 제 문제는 a.csv b.csv 파일이 2개 있고, a.csv는 4개의 열 i jkl, b.csv도 이러한 열이 있습니다.i는 이러한 csvs'의 키 열입니다. jkl 열은 a.csv에서는 비어 있지만 b.csv에서는 채워집니다.'i'를 키 열로 사용하여 jkl 열의 값을 b.csv 파일에서 a.csv 파일로 매핑하고 싶습니다.

제 제안은 (기본 명령어를 사용하지 않고) 다음과 같은 것입니다.

a_file = "path/to/a.csv"
b_file = "path/to/b.csv"

# read from file a.csv
with open(a_file) as f:
    # skip headers
    f.next()
    # get first colum as keys
    keys = (line.split(',')[0] for line in f) 

# create empty dictionary:
d = {}

# read from file b.csv
with open(b_file) as f:
    # gather headers except first key header
    headers = f.next().split(',')[1:]
    # iterate lines
    for line in f:
        # gather the colums
        cols = line.strip().split(',')
        # check to make sure this key should be mapped.
        if cols[0] not in keys:
            continue
        # add key to dict
        d[cols[0]] = dict(
            # inner keys are the header names, values are columns
            (headers[idx], v) for idx, v in enumerate(cols[1:]))

그러나 csv 파일을 구문 분석하는 데는 csv 모듈이 있습니다.

업데이트: 중첩된 사전의 임의 길이를 보려면 다음 답변으로 이동하십시오.

컬렉션의 기본 dict 함수를 사용합니다.

고성능: 데이터 세트가 크면 "키가 입력되지 않은 경우"가 매우 비쌉니다.

낮은 유지보수: 코드를 더 읽기 쉽게 만들고 쉽게 확장할 수 있습니다.

from collections import defaultdict

target_dict = defaultdict(dict)
target_dict[key1][key2] = val

내포된 임의 수준의 경우:

In [2]: def nested_dict():
   ...:     return collections.defaultdict(nested_dict)
   ...:

In [3]: a = nested_dict()

In [4]: a
Out[4]: defaultdict(<function __main__.nested_dict>, {})

In [5]: a['a']['b']['c'] = 1

In [6]: a
Out[6]:
defaultdict(<function __main__.nested_dict>,
            {'a': defaultdict(<function __main__.nested_dict>,
                         {'b': defaultdict(<function __main__.nested_dict>,
                                      {'c': 1})})})

을 사용할 는 dict와 같은 합니다.nested_dict존재하지 않는 키를 조회하면 딕트에 새 키 항목이 생성되어 많은 혼란을 일으킬 수 있습니다.

다음은 Python3의 예입니다.nested_dict모듈:

import nested_dict as nd
nest = nd.nested_dict()
nest['outer1']['inner1'] = 'v11'
nest['outer1']['inner2'] = 'v12'
print('original nested dict: \n', nest)
try:
    nest['outer1']['wrong_key1']
except KeyError as e:
    print('exception missing key', e)
print('nested dict after lookup with missing key.  no exception raised:\n', nest)

# Instead, convert back to normal dict...
nest_d = nest.to_dict(nest)
try:
    print('converted to normal dict. Trying to lookup Wrong_key2')
    nest_d['outer1']['wrong_key2']
except KeyError as e:
    print('exception missing key', e)
else:
    print(' no exception raised:\n')

# ...or use dict.keys to check if key in nested dict
print('checking with dict.keys')
print(list(nest['outer1'].keys()))
if 'wrong_key3' in list(nest.keys()):

    print('found wrong_key3')
else:
    print(' did not find wrong_key3')

출력:

original nested dict:   {"outer1": {"inner2": "v12", "inner1": "v11"}}

nested dict after lookup with missing key.  no exception raised:  
{"outer1": {"wrong_key1": {}, "inner2": "v12", "inner1": "v11"}} 

converted to normal dict. 
Trying to lookup Wrong_key2 

exception missing key 'wrong_key2' 

checking with dict.keys 

['wrong_key1', 'inner2', 'inner1']  
did not find wrong_key3

pip install addict

from addict import Dict

mapping = Dict()
mapping.a.b.c.d.e = 2
print(mapping)  # {'a': {'b': {'c': {'d': {'e': 2}}}}}

참조:

1. 이지딕트 깃허브
2. 중독자 깃허브

경로에 대한 목록(임의 길이)이 지정된 중첩 사전을 만들고 경로 끝에 존재할 수 있는 항목에 대해 함수를 수행하려면 다음과 같은 유용한 작은 재귀 함수가 매우 유용합니다.

def ensure_path(data, path, default=None, default_func=lambda x: x):
    """
    Function:

    - Ensures a path exists within a nested dictionary

    Requires:

    - `data`:
        - Type: dict
        - What: A dictionary to check if the path exists
    - `path`:
        - Type: list of strs
        - What: The path to check

    Optional:

    - `default`:
        - Type: any
        - What: The default item to add to a path that does not yet exist
        - Default: None

    - `default_func`:
        - Type: function
        - What: A single input function that takes in the current path item (or default) and adjusts it
        - Default: `lambda x: x` # Returns the value in the dict or the default value if none was present
    """
    if len(path)>1:
        if path[0] not in data:
            data[path[0]]={}
        data[path[0]]=ensure_path(data=data[path[0]], path=path[1:], default=default, default_func=default_func)
    else:
        if path[0] not in data:
            data[path[0]]=default
        data[path[0]]=default_func(data[path[0]])
    return data

예:

data={'a':{'b':1}}
ensure_path(data=data, path=['a','c'], default=[1])
print(data) #=> {'a':{'b':1, 'c':[1]}}
ensure_path(data=data, path=['a','c'], default=[1], default_func=lambda x:x+[2])
print(data) #=> {'a': {'b': 1, 'c': [1, 2]}}

빈 딕트에 데이터를 추가할 빈 중첩 목록입니다.

ls = [['a','a1','a2','a3'],['b','b1','b2','b3'],['c','c1','c2','c3'], 
['d','d1','d2','d3']]

즉, data_message 내부에 4개의 빈 dict를 생성합니다.

data_dict = {f'dict{i}':{} for i in range(4)}
for i in range(4):
    upd_dict = {'val' : ls[i][0], 'val1' : ls[i][1],'val2' : ls[i][2],'val3' : ls[i][3]}

    data_dict[f'dict{i}'].update(upd_dict)

print(data_dict)

산출물

{'val0': {'val': 'a', 'val1': 'a1', 'val2': 'a2', 'val3': 'a3': 'val1': 'b1', 'val2': 'b2', 'val3': 'val3': 'val3': 'val3', 'val3': 'val2', 'val2', 'val2': 'val3', 'val2'

#in jupyter
import sys
!conda install -c conda-forge --yes --prefix {sys.prefix} nested_dict 
import nested_dict as nd
d = nd.nested_dict()

이제 'd'를 사용하여 중첩된 키 값 쌍을 저장할 수 있습니다.

dict 및 구현에서만 상속된 단순 클래스를 만들 수 있습니다.__missing__방법:

class NestedDict(dict):
    def __missing__(self, x):
        self[x] = NestedDict()
        return self[x]

d = NestedDict()
d[1][2] = 3
print(d)
# {1: {2: 3}}

빈 항목을 초기화할 수 있습니다.NestedDict새 키에 값을 할당합니다.

from ndicts import NestedDict

nd = NestedDict()
nd["level1", "level2", "level3"] = 0

>>> nd
NestedDict({'level1': {'level2': {'level3': 0}}})

칙령은 파이피에 있습니다.

pip install ndicts

언급URL : https://stackoverflow.com/questions/16333296/how-do-you-create-nested-dict-in-python