ฉันจะแลกเปลี่ยนคีย์กับค่าในพจนานุกรมได้อย่างไร

ฉันได้รับพจนานุกรมเป็นอินพุตและต้องการส่งคืนพจนานุกรมซึ่งคีย์จะเป็นค่าของอินพุตและค่าของใครจะเป็นคีย์อินพุตที่เกี่ยวข้อง ค่าเป็นเอกลักษณ์

ตัวอย่างเช่นสมมติว่าข้อมูลที่ฉันป้อนคือ:

a = dict()
a['one']=1
a['two']=2

ฉันต้องการให้ผลลัพธ์ของฉันเป็น:

{1: 'one', 2: 'two'}

เพื่อชี้แจงฉันต้องการให้ผลลัพธ์ของฉันเทียบเท่ากับสิ่งต่อไปนี้:

res = dict()
res[1] = 'one'
res[2] = 'two'

วิธี Pythonic ที่เรียบร้อยเพื่อให้บรรลุสิ่งนี้?

Python 2:

res = dict((v,k) for k,v in a.iteritems())

Python 3 (ขอบคุณ @erik):

res = dict((v,k) for k,v in a.items())

new_dict = dict(zip(my_dict.values(), my_dict.keys()))

ตั้งแต่ Python 2.7 เป็นต้นไปรวมถึง 3.0+ มีเนื้อหาที่สั้นกว่าและอ่านง่ายกว่า:

>>> my_dict = {'x':1, 'y':2, 'z':3}
>>> {v: k for k, v in my_dict.items()}
{1: 'x', 2: 'y', 3: 'z'}

In [1]: my_dict = {'x':1, 'y':2, 'z':3}

In [2]: dict((value, key) for key, value in my_dict.iteritems())
Out[2]: {1: 'x', 2: 'y', 3: 'z'}

คุณสามารถใช้ประโยชน์จากการเข้าใจตามคำสั่ง :

res = {v: k for k, v in a.iteritems()}

แก้ไข: สำหรับ Python 3 ให้ใช้a.items()แทนa.iteritems()ไฟล์. การสนทนาเกี่ยวกับความแตกต่างระหว่างพวกเขาสามารถพบได้ในiteritems ใน Pythonบน SO

คุณสามารถลอง:

d={'one':1,'two':2}
d2=dict((value,key) for key,value in d.iteritems())
d2
  {'two': 2, 'one': 1}

ระวังว่าคุณไม่สามารถ 'ย้อนกลับ' พจนานุกรมได้ถ้า

1. คีย์มากกว่าหนึ่งคีย์ใช้ค่าเดียวกัน ตัวอย่างเช่น{'one':1,'two':1}. 1พจนานุกรมใหม่เท่านั้นสามารถมีหนึ่งรายการที่มีคีย์
2. ค่าอย่างน้อยหนึ่งค่าไม่สามารถเข้าถึงได้ ตัวอย่างเช่น{'one':[1]}. [1]เป็นค่าที่ถูกต้อง แต่ไม่ใช่คีย์ที่ถูกต้อง

ดูหัวข้อนี้ในรายชื่อผู้รับจดหมาย python สำหรับการสนทนาในหัวข้อนี้

คำตอบนำหน้าปัจจุบันถือว่าค่าไม่ซ้ำกันซึ่งไม่ได้เป็นเช่นนั้นเสมอไป จะเกิดอะไรขึ้นถ้าค่าไม่ซ้ำกัน? คุณจะหลวมข้อมูล! ตัวอย่างเช่น:

d = {'a':3, 'b': 2, 'c': 2} 
{v:k for k,v in d.iteritems()} 

ผลตอบแทน {2: 'b', 3: 'a'}ผลตอบแทน

ข้อมูลเกี่ยวกับ'c'ถูกละเว้นโดยสิ้นเชิง ตามหลักการแล้วควรมีลักษณะเช่นนี้{2: ['b','c'], 3: ['a']}นี้ นี่คือสิ่งที่การใช้งานด้านล่างทำ

Python 2.x

def reverse_non_unique_mapping(d):
    dinv = {}
    for k, v in d.iteritems():
        if v in dinv:
            dinv[v].append(k)
        else:
            dinv[v] = [k]
    return dinv

Python 3.x

def reverse_non_unique_mapping(d):
    dinv = {}
    for k, v in d.items():
        if v in dinv:
            dinv[v].append(k)
        else:
            dinv[v] = [k]
    return dinv

res = dict(zip(a.values(), a.keys()))

new_dict = dict( (my_dict[k], k) for k in my_dict)

หรือดีกว่า แต่ใช้ได้เฉพาะใน Python 3:

new_dict = { my_dict[k]: k for k in my_dict}

อีกวิธีหนึ่งในการขยายการตอบสนองของIlya Prokinคือการใช้reversedฟังก์ชันนี้จริงๆ

dict(map(reversed, my_dict.items()))

โดยพื้นฐานแล้วพจนานุกรมของคุณจะวนซ้ำผ่าน (โดยใช้.items()) โดยที่แต่ละรายการเป็นคู่คีย์ / ค่าและรายการเหล่านั้นจะสลับกับreversedฟังก์ชัน เมื่อสิ่งนี้ถูกส่งไปยังตัวdictสร้างมันจะเปลี่ยนเป็นคู่ค่า / คีย์ซึ่งเป็นสิ่งที่คุณต้องการ

คำแนะนำสำหรับการปรับปรุงสำหรับคำตอบของ Javier:

dict(zip(d.values(),d))

แทนที่จะd.keys()เขียนเฉยๆdเพราะถ้าคุณใช้พจนานุกรมด้วยตัววนซ้ำมันจะส่งคืนคีย์ของพจนานุกรมที่เกี่ยวข้อง

เช่น สำหรับพฤติกรรมนี้:

d = {'a':1,'b':2}
for k in d:
 k
'a'
'b'

สามารถทำได้อย่างง่ายดายด้วยความเข้าใจในพจนานุกรม:

{d[i]:i for i in d}

dict(map(lambda x: x[::-1], YourDict.items()))

.items()(key, value)กลับรายการของสิ่งอันดับของ map()ผ่านองค์ประกอบของรายการและใช้lambda x:[::-1]กับแต่ละองค์ประกอบ (ทูเปิล) เพื่อย้อนกลับดังนั้นแต่ละทูเปิลจะ(value, key)อยู่ในรายการใหม่ที่พ่นออกมาจากแผนที่ สุดท้ายdict()สร้างคำสั่งจากรายการใหม่

ใช้ลูป : -

newdict = {} #Will contain reversed key:value pairs.

for key, value in zip(my_dict.keys(), my_dict.values()):
    # Operations on key/value can also be performed.
    newdict[value] = key

หากคุณใช้ Python3 จะแตกต่างกันเล็กน้อย:

res = dict((v,k) for k,v in a.items())

การเพิ่มโซลูชันในสถานที่:

>>> d = {1: 'one', 2: 'two', 3: 'three', 4: 'four'}
>>> for k in list(d.keys()):
...     d[d.pop(k)] = k
... 
>>> d
{'two': 2, 'one': 1, 'four': 4, 'three': 3}

ใน Python3 เป็นสิ่งสำคัญที่คุณต้องใช้list(d.keys())เนื่องจากdict.keysส่งคืนมุมมองของคีย์ หากคุณใช้ Python2 d.keys()ก็เพียงพอแล้ว

คำตอบของ Hanan เป็นคำตอบที่ถูกต้องเนื่องจากครอบคลุมกรณีทั่วไปมากกว่า (คำตอบอื่น ๆ เป็นคำตอบที่ทำให้เข้าใจผิดสำหรับผู้ที่ไม่ทราบสถานการณ์ที่ซ้ำกัน) การปรับปรุงคำตอบของ Hanan คือการใช้ setdefault:

mydict = {1:a, 2:a, 3:b}   
result = {}
for i in mydict:  
   result.setdefault(mydict[i],[]).append(i)
print(result)
>>> result = {a:[1,2], b:[3]}