문제

주어진 사전 다음과 같이

my_map = { 'a': 1, 'b':2 }

할 수 있는 방법 하나의 반전이 지도하여 얻을:

inv_map = { 1: 'a', 2: 'b' }
도움이 되었습니까?

해결책

Python 2.7.x의 경우

inv_map = {v: k for k, v in my_map.iteritems()}

Python 3+ :

inv_map = {v: k for k, v in my_map.items()}

다른 팁

DICT의 값이 독특하다고 가정합니다.

dict((v, k) for k, v in my_map.iteritems())

값이 my_map 독특하지 않습니다 :

inv_map = {}
for k, v in my_map.iteritems():
    inv_map[v] = inv_map.get(v, [])
    inv_map[v].append(k)

매핑의 유형을 보존하는 동안이 작업을 수행합니다 (그것이 dict 또는 a dict 아강):

def inverse_mapping(f):
    return f.__class__(map(reversed, f.items()))

이 시도:

inv_map = dict(zip(my_map.values(), my_map.keys()))

(그 점에 유의하십시오 사전보기에 대한 파이썬 문서 명시 적으로 그것을 보장합니다 .keys() 그리고 .values() 동일한 순서로 요소를 갖추어 위의 접근 방식이 작동 할 수 있습니다.)

대안으로 :

inv_map = dict((my_map[k], k) for k in my_map)

또는 Python 3.0의 DICT 이해를 사용합니다

inv_map = {my_map[k] : k for k in my_map}

더 기능적인 방법 :

my_map = { 'a': 1, 'b':2 }
dict(map(reversed, my_map.items()))

이것은 대답을 확장합니다 https://stackoverflow.com/questions/483666/python-reverse inverse-a-mapping/485368#485368, DITT의 값이 독특하지 않은시기에 적용됩니다.

class ReversibleDict(dict):

    def reversed(self):
        """
        Return a reversed dict, with common values in the original dict
        grouped into a list in the returned dict.

        Example:
        >>> d = ReversibleDict({'a': 3, 'c': 2, 'b': 2, 'e': 3, 'd': 1, 'f': 2})
        >>> d.reversed()
        {1: ['d'], 2: ['c', 'b', 'f'], 3: ['a', 'e']}
        """

        revdict = {}
        for k, v in self.iteritems():
            revdict.setdefault(v, []).append(k)
        return revdict

구현은 사용할 수 없다는 점에서 제한됩니다 reversed 두 번, 원래를 되 찾으십시오. 그렇게 대칭이 아닙니다. Python 2.6으로 테스트됩니다. 여기 결과적인 DITT를 인쇄하는 데 사용하는 방법의 사용 사례입니다.

오히려 사용한다면 a set A보다 list, 그리고 이것이 의미가있는 응용 프로그램이 있습니다. setdefault(v, []).append(k), 사용 setdefault(v, set()).add(k).

우리는 또한 중복 키로 사전을 반대로 사용하여 defaultdict:

from collections import Counter, defaultdict

def invert_dict(d):
    d_inv = defaultdict(list)
    for k, v in c.items():
        d_inv[v].append(k)
    return d_inv

text = 'aaa bbb ccc ddd aaa bbb ccc aaa' 
c = Counter(text.split()) # Counter({'aaa': 3, 'bbb': 2, 'ccc': 2, 'ddd': 1})
dict(invert_dict(c)) # {1: ['ddd'], 2: ['bbb', 'ccc'], 3: ['aaa']}

보다 여기:

이 기술은 사용하는 동등한 기술보다 간단하고 빠릅니다. dict.setdefault().

의 조합 목록과 사전을 이해합니다.을 처리할 수 있 복제 열쇠

{v:[i for i in d.keys() if d[i] == v ] for k,v in d.items()}

2 센트의 Pythonic Way 추가 :

inv_map = dict(map(reversed, my_map.items()))

예시:

In [7]: my_map
Out[7]: {1: 'one', 2: 'two', 3: 'three'}

In [8]: inv_map = dict(map(reversed, my_map.items()))

In [9]: inv_map
Out[9]: {'one': 1, 'three': 3, 'two': 2}

값이 고유하지 않고 약간의 하드 코어라면 :

inv_map = dict(
    (v, [k for (k, xx) in filter(lambda (key, value): value == v, my_map.items())]) 
    for v in set(my_map.values())
)

특히 큰 독점의 경우이 솔루션은 답보다 훨씬 덜 효율적입니다. 파이썬 리버스 / 매핑을 반전시킵니다 루프가 끝나기 때문입니다 items() 여러 번.

람다를 좋아한다면 위에서 제안한 다른 기능 외에도 :

invert = lambda mydict: {v:k for k, v in mydict.items()}

또는 이런 식으로도 할 수 있습니다.

invert = lambda mydict: dict( zip(mydict.values(), mydict.keys()) )

이것을하는 가장 좋은 방법은 클래스를 정의하는 것입니다. 다음은 "대칭 사전"의 구현입니다.

class SymDict:
    def __init__(self):
        self.aToB = {}
        self.bToA = {}

    def assocAB(self, a, b):
        # Stores and returns a tuple (a,b) of overwritten bindings
        currB = None
        if a in self.aToB: currB = self.bToA[a]
        currA = None
        if b in self.bToA: currA = self.aToB[b]

        self.aToB[a] = b
        self.bToA[b] = a
        return (currA, currB)

    def lookupA(self, a):
        if a in self.aToB:
            return self.aToB[a]
        return None

    def lookupB(self, b):
        if b in self.bToA:
            return self.bToA[b]
        return None

삭제 및 반복 방법은 필요한 경우 구현하기에 쉽습니다.

이 구현은 전체 사전을 반전시키는 것보다 훨씬 효율적입니다 (이 페이지에서 가장 인기있는 솔루션 인 것 같습니다). 말할 것도없이, 당신은 원하는만큼 당신의 교활함에서 값을 추가하거나 제거 할 수 있으며, 역 사자는 항상 유효성을 유지합니다.

사용 지퍼

inv_map = dict(zip(my_map.values(), my_map.keys()))

이것은 비 유니크 값을 처리하고 고유 한 경우의 많은 모양을 유지합니다. 

inv_map = {v:[k for k in my_map if my_map[k] == v] for v in my_map.itervalues()}

Python 3.x의 경우 교체하십시오 Itervalues ~와 함께 가치. 나는 이것에 대한 신용을받을 수 없다 ... 그것은 아이콘 잭이 제안했다.

Python 2.7/3.x에서는 시도해보십시오

inv_map={};
for i in my_map:
    inv_map[my_map[i]]=i    
print inv_map

예를 들어 다음 사전이 있습니다.

dict = {'a': 'fire', 'b': 'ice', 'c': 'fire', 'd': 'water'}

그리고 당신은 그런 거꾸로 된 형태로 그것을 얻고 싶습니다.

inverted_dict = {'fire': ['a', 'c'], 'ice': ['b'], 'water': ['d']}

첫 번째 솔루션. 반전 핵심 가치 사전 쌍 a for-루프 접근 :

# Use this code to invert dictionaries that have non-unique values

inverted_dict = dictio()
for key, value in dict.items():
    inverted_dict.setdefault(value, list()).append(key)

두 번째 솔루션. a 사전 이해력 역전을위한 접근 :

# Use this code to invert dictionaries that have unique values

inverted_dict = {value: key for key, value in dict.items()}

세 번째 솔루션. 사용 반전을 되돌리기 접근하다:

# Use this code to invert dictionaries that have lists of values

dict = {value: key for key in inverted_dict for value in my_map[key]}

함수는 유형 목록의 값에 대해 대칭입니다. reverse_dict (reverse_dict (사전))를 수행 할 때 튜플이 목록에 덮여 있습니다.

def reverse_dict(dictionary):
    reverse_dict = {}
    for key, value in dictionary.iteritems():
        if not isinstance(value, (list, tuple)):
            value = [value]
        for val in value:
            reverse_dict[val] = reverse_dict.get(val, [])
            reverse_dict[val].append(key)
    for key, value in reverse_dict.iteritems():
        if len(value) == 1:
            reverse_dict[key] = value[0]
    return reverse_dict

사전은 값과 달리 사전 내에서 하나의 고유 한 키가 필요하기 때문에, 반전 된 값을 새로운 특정 키에 포함 할 종류의 목록에 추가해야합니다. 

def r_maping(dictionary):
    List_z=[]
    Map= {}
    for z, x in dictionary.iteritems(): #iterate through the keys and values
        Map.setdefault(x,List_z).append(z) #Setdefault is the same as dict[key]=default."The method returns the key value available in the dictionary and if given key is not available then it will return provided default value. Afterward, we will append into the default list our new values for the specific key.
    return Map

나는 Python 2에서 그렇게 할 것입니다.

inv_map = {my_map[x] : x for x in my_map}

def invertDictionary(d):
    myDict = {}
  for i in d:
     value = d.get(i)
     myDict.setdefault(value,[]).append(i)   
 return myDict
 print invertDictionary({'a':1, 'b':2, 'c':3 , 'd' : 1})

이것은 다음과 같이 출력을 제공합니다. {1 : [ 'a', 'd'], 2 : [ 'b'], 3 : [ 'c']}

  def reverse_dictionary(input_dict):
      out = {}
      for v in input_dict.values():  
          for value in v:
              if value not in out:
                  out[value.lower()] = []

      for i in input_dict:
          for j in out:
              if j in map (lambda x : x.lower(),input_dict[i]):
                  out[j].append(i.lower())
                  out[j].sort()
      return out

이 코드는 다음과 같습니다.

r = reverse_dictionary({'Accurate': ['exact', 'precise'], 'exact': ['precise'], 'astute': ['Smart', 'clever'], 'smart': ['clever', 'bright', 'talented']})

print(r)

{'precise': ['accurate', 'exact'], 'clever': ['astute', 'smart'], 'talented': ['smart'], 'bright': ['smart'], 'exact': ['accurate'], 'smart': ['astute']}

비 지체 맵에 대한 빠른 기능 솔루션 (고유 한 값) :

from itertools import imap, groupby

def fst(s):
    return s[0]

def snd(s):
    return s[1]

def inverseDict(d):
    """
    input d: a -> b
    output : b -> set(a)
    """
    return {
        v : set(imap(fst, kv_iter))
        for (v, kv_iter) in groupby(
            sorted(d.iteritems(),
                   key=snd),
            key=snd
        )
    }

이론적으로 이것은 세트에 추가 (또는 목록에 추가)를 추가하는 것보다 더 빠릅니다. 명령적인 해결책.

불행히도 값은 정렬 가능해야하며, 분류는 Groupby에 의해 요구됩니다.

완전히 다른 것이 아니라 요리 책에서 약간 다시 작성한 레시피입니다. 보유함으로써 최적화되어 있습니다 setdefault 인스턴스를 통해 얻을 때마다 메소드가 있습니다.

def inverse(mapping):
    '''
    A function to inverse mapping, collecting keys with simillar values
    in list. Careful to retain original type and to be fast.
    >> d = dict(a=1, b=2, c=1, d=3, e=2, f=1, g=5, h=2)
    >> inverse(d)
    {1: ['f', 'c', 'a'], 2: ['h', 'b', 'e'], 3: ['d'], 5: ['g']}
    '''
    res = {}
    setdef = res.setdefault
    for key, value in mapping.items():
        setdef(value, []).append(key)
    return res if mapping.__class__==dict else mapping.__class__(res)

CPYTHON 3.X에서 실행하도록 설계, 2.X 교체 용. mapping.items() ~와 함께 mapping.iteritems()

내 컴퓨터에서 다른 예보다 조금 더 빨리 실행됩니다.

값이 고유하지 않고 해시 (1 차원) 일 수있는 경우 :

for k, v in myDict.items():
    if len(v) > 1:
        for item in v:
            invDict[item] = invDict.get(item, [])
            invDict[item].append(k)
    else:
        invDict[v] = invDict.get(v, [])
        invDict[v].append(k)

그리고 더 깊이 파고 들어야한다면 재귀로 단 한 번의 차원 :

def digList(lst):
    temp = []
    for item in lst:
        if type(item) is list:
            temp.append(digList(item))
        else:
            temp.append(item)
    return set(temp)

for k, v in myDict.items():
    if type(v) is list:
        items = digList(v)
        for item in items:
            invDict[item] = invDict.get(item, [])
            invDict[item].append(k)
    else:
        invDict[v] = invDict.get(v, [])
        invDict[v].append(k)

사전을 반대시킵니다 :

dict_ = {"k0":"v0", "k1":"v1", "k2":"v1"}
inversed_dict_ = {val: key for key, val in dict_.items()}

print(inversed_dict_["v1"])

나는 '맵'이 함수이기 때문에 사이클 '및 method'.get () '의 도움으로 이것을 썼고 사전의'map '을'map1 '으로 변경했습니다.

def dict_invert(map1):
    inv_map = {} # new dictionary
    for key in map1.keys():
        inv_map[map1.get(key)] = key
    return inv_map

모든 종류의 사전의 경우 키로 사용할 고유 한 값이 없어도 각 값에 대한 키 목록을 만들 수 있습니다.

inv_map = {v: inv_map.get(v, []) + [k] for k,v in my_map.items()}

이것은 최상의 솔루션은 아니지만 작동합니다. 우리가 되돌려 줄 사전은 다음과 같이 가정 해 봅시다.

사전 = { 'a': 1, 'b': 2, 'c': 3}, 다음 :

dictionary = {'a': 1, 'b': 2, 'c': 3}
reverse_dictionary = {}
for index, val in enumerate(list(dictionary.values())):
    reverse_dictionary[val] = list(dictionary.keys())[index]

reverse_dictionary의 출력은 {1 : 'a', 2 : 'b', 3 : 'c'}이어야합니다.

라이센스 : CC-BY-SA ~와 함께 속성
제휴하지 않습니다 StackOverflow
scroll top