నిఘంటువుకు మూలకాలను జోడించి పైథాన్‌లో నిఘంటువులలో చేరడం

ఈ విభాగం డిక్షనరీకి కొత్త అంశాలను ఎలా జోడించాలో వివరిస్తుంది (డిక్ట్ టైప్ ఆబ్జెక్ట్) లేదా పైథాన్‌లో ఉన్న మూలకం యొక్క విలువను నవీకరించండి. బహుళ నిఘంటువులను కలపడం (చేరడం, విలీనం చేయడం) కూడా సాధ్యమే.

• బహుళ నిఘంటువుల సంయోగం (విలీనం): నవీకరణ (), | ఆపరేటర్, | = ఆపరేటర్
• బహుళ అంశాలను జోడించండి లేదా నవీకరించండి: నవీకరణ (), | = ఆపరేటర్

కీలను పేర్కొనడం ద్వారా నిఘంటువుకు అంశాలను జోడించండి మరియు నవీకరించండి.

మీరు ఈ క్రింది విధంగా నిఘంటువు అంశాలను జోడించవచ్చు / నవీకరించవచ్చు.

నిఘంటువు వస్తువు [కీ] = విలువ

ఉనికిలో లేని కీ పేర్కొనబడినప్పుడు, క్రొత్త మూలకం జతచేయబడుతుంది మరియు ఇప్పటికే ఉన్న కీ పేర్కొనబడినప్పుడు, ఉన్న విలువ నవీకరించబడుతుంది (ఓవర్రైట్ చేయబడింది).

d = {'k1': 1, 'k2': 2}

d['k3'] = 3
print(d)
# {'k1': 1, 'k2': 2, 'k3': 3}

d['k1'] = 100
print(d)
# {'k1': 100, 'k2': 2, 'k3': 3}

మీరు ఉన్న కీ విలువను నవీకరించకూడదనుకుంటే, setdefault () పద్ధతిని ఉపయోగించండి.

బహుళ నిఘంటువులను కలపండి (విలీనం చేయండి): నవీకరణ (), | ఆపరేటర్, | = ఆపరేటర్

update()

మరొక నిఘంటువు వస్తువు నిఘంటువు వస్తువు యొక్క పద్ధతి నవీకరణ () కు వాదనగా పేర్కొనబడితే, దానిలోని అన్ని అంశాలు జోడించబడతాయి.

ఇప్పటికే ఉన్న కీతో కీ అతివ్యాప్తి చెందితే, అది వాదనలో పేర్కొన్న నిఘంటువు విలువతో భర్తీ చేయబడుతుంది.

d1 = {'k1': 1, 'k2': 2}
d2 = {'k1': 100, 'k3': 3, 'k4': 4}

d1.update(d2)
print(d1)
# {'k1': 100, 'k2': 2, 'k3': 3, 'k4': 4}

నవీకరణ () వాదనలో బహుళ నిఘంటువులను పేర్కొనడం లోపం.

d1 = {'k1': 1, 'k2': 2}
d2 = {'k3': 3, 'k4': 4}
d3 = {'k5': 5, 'k6': 6}

# d1.update(d2, d3)
# TypeError: update expected at most 1 arguments, got 2

తరువాత వివరించినట్లుగా, నవీకరణ () క్రొత్త అంశాలను కీవర్డ్ ఆర్గ్యుమెంట్స్ (కీ = విలువ) గా జోడించగలదు, కాబట్టి నిఘంటువుకు ** ని జోడించి, ప్రతి మూలకాన్ని కీవర్డ్ ఆర్గ్యుమెంట్‌గా విస్తరించి, దానిని పాస్ చేయండి.

d1.update(**d2, **d3)
print(d1)
# {'k1': 1, 'k2': 2, 'k3': 3, 'k4': 4, 'k5': 5, 'k6': 6}

మునుపటి ఉదాహరణలలో మాదిరిగా, నవీకరణ () ను ఉపయోగించడం వలన అసలు నిఘంటువు వస్తువు అప్‌డేట్ అవుతుంది.

మీరు బహుళ నిఘంటువులను విలీనం చేయడం ద్వారా కొత్త నిఘంటువును సృష్టించాలనుకుంటే, {** d1, ** d2} (పైథాన్ 3.5 నుండి) లేదా డిక్ట్ (** d1, ** d2) ఉపయోగించండి.

పైథాన్ 3.9 మరియు తరువాత, | ఉపయోగించి కొత్త నిఘంటువును సృష్టించడం కూడా సాధ్యమే ఆపరేటర్ తరువాత వివరించబడింది.

| ఆపరేటర్, | = ఆపరేటర్ (పైథాన్ 3.9 మరియు తరువాత)

పైథాన్ 3.9 నుండి, | ని ఉపయోగించి రెండు నిఘంటువులను విలీనం చేయడం సాధ్యపడుతుంది ఆపరేటర్. రెండు నిఘంటువులకు ఒకే కీ ఉన్నప్పుడు, కుడి వైపున ఉన్న విలువకు ప్రాధాన్యత ఉంటుంది.

d1 = {'k1': 1, 'k2': 2}
d2 = {'k1': 100, 'k3': 3, 'k4': 4}

print(d1 | d2)
# {'k1': 100, 'k2': 2, 'k3': 3, 'k4': 4}

print(d2 | d1)
# {'k1': 1, 'k3': 3, 'k4': 4, 'k2': 2}

| ఆపరేటర్ల శ్రేణిని ఉపయోగించడం ద్వారా బహుళ నిఘంటువులను కలపడం కూడా సాధ్యమే.

d1 = {'k1': 1, 'k2': 2}
d2 = {'k3': 3, 'k4': 4}
d3 = {'k5': 5, 'k6': 6}

print(d1 | d2 | d3)
# {'k1': 1, 'k2': 2, 'k3': 3, 'k4': 4, 'k5': 5, 'k6': 6}

+ నవీకరణ () మాదిరిగా, ఎడమ వైపున ఉన్న వస్తువు నవీకరించబడుతుంది.

d1 = {'k1': 1, 'k2': 2}
d2 = {'k1': 100, 'k3': 3, 'k4': 4}

d1 |= d2
print(d1)
# {'k1': 100, 'k2': 2, 'k3': 3, 'k4': 4}

బహుళ అంశాలను జోడించండి లేదా నవీకరించండి: నవీకరణ (), | = ఆపరేటర్

update()

కీవర్డ్ ఆర్గ్యుమెంట్ కీ = విలువ నవీకరణ () పద్ధతిలో పేర్కొనబడినప్పుడు, కీ కీ మరియు విలువ విలువ జోడించబడతాయి. ఇప్పటికే ఉన్న కీతో కీ అతివ్యాప్తి చెందితే, అది వాదనలో పేర్కొన్న విలువతో భర్తీ చేయబడుతుంది.

d = {'k1': 1, 'k2': 2}

d.update(k1=100, k3=3, k4=4)
print(d)
# {'k1': 100, 'k2': 2, 'k3': 3, 'k4': 4}

నవీకరణ () పద్ధతికి వాదనగా (కీ, విలువ) జాబితాను పేర్కొనడం కూడా సాధ్యమే. ఇప్పటికే ఉన్న కీతో కీ అతివ్యాప్తి చెందితే, అది ఆర్గ్యుమెంట్‌గా పేర్కొన్న విలువతో భర్తీ చేయబడుతుంది.

d = {'k1': 1, 'k2': 2}

d.update([('k1', 100), ('k3', 3), ('k4', 4)])
print(d)
# {'k1': 100, 'k2': 2, 'k3': 3, 'k4': 4}

జిప్ () ఫంక్షన్‌తో కలిపి, కీల జాబితా మరియు విలువల జాబితా నుండి మూలకాలను జోడించవచ్చు.

d = {'k1': 1, 'k2': 2}

keys = ['k1', 'k3', 'k4']
values = [100, 3, 4]

d.update(zip(keys, values))
print(d)
# {'k1': 100, 'k2': 2, 'k3': 3, 'k4': 4}

| = ఆపరేటర్ (పైథాన్ 3.9 మరియు తరువాత)

| = ఆపరేటర్‌తో, కుడి వైపున (కీ, విలువ) జాబితాను పేర్కొనవచ్చు.

d = {'k1': 1, 'k2': 2}

d |= [('k1', 100), ('k3', 3), ('k4', 4)]
print(d)
# {'k1': 100, 'k2': 2, 'k3': 3, 'k4': 4}

| తో జాబితాను పేర్కొనడం గమనించండి ఆపరేటర్ లోపం ఏర్పడుతుంది. నిఘంటువు నుండి నిఘంటువు కార్యకలాపాలకు మాత్రమే మద్దతు ఉంది.

# print(d | [('k1', 100), ('k3', 3), ('k4', 4)])
# TypeError: unsupported operand type(s) for |: 'dict' and 'list'