पायथन में हैश मैप

Question

मैं पायथन में एक हाशपॉप लागू करना चाहता हूं। मैं एक इनपुट के लिए एक उपयोगकर्ता से पूछना चाहता हूं। उनके इनपुट के आधार पर मैं हाशपैप की कुछ जानकारी प्राप्त कर रहा हूं। यदि उपयोगकर्ता HashMap की एक कुंजी में प्रवेश करता है, तो मैं इसी मूल्य को पुनः प्राप्त करना चाहूंगा।

मैं पायथन में इस कार्यक्षमता को कैसे लागू करूं?

HashMap<String,String> streetno=new HashMap<String,String>();
   streetno.put("1", "Sachin Tendulkar");
   streetno.put("2", "Dravid");
   streetno.put("3","Sehwag");
   streetno.put("4","Laxman");
   streetno.put("5","Kohli")

Comments

meta.stackexchange.com/questions/15650/…

— एलन

Answer 1

पायथन डिक्शनरी एक बिल्ट-इन टाइप है जो की-वैल्यू पेयर को सपोर्ट करता है।

streetno = {"1": "Sachin Tendulkar", "2": "Dravid", "3": "Sehwag", "4": "Laxman", "5": "Kohli"}

साथ ही तानाशाह कीवर्ड का उपयोग करना:

streetno = dict({"1": "Sachin Tendulkar", "2": "Dravid"}) 

या:

streetno = {}
streetno["1"] = "Sachin Tendulkar" 

Comments

दूसरा उदाहरण सिर्फ पहले की तरह ही एक तानाशाही का निर्माण करता है और फिर उसे कॉपी करता है। अन्य उपयोग dict, जो इस संदर्भ में अधिक उपयुक्त होगा, dict(key1=value1, key2=value2, ...)लेकिन इसके लिए स्ट्रिंग्स की कुंजी की आवश्यकता होती है जो कि पायथन पहचानकर्ता (और आंतरिक रूप से, यह एक शब्दकोश भी बनाता है)।

दिलचस्प है, मुझे महसूस नहीं हुआ कि नग्न तार वैध पहचानकर्ता थे।

— एलन

मुझे यकीन नहीं है कि अगर मैं आपको सही तरीके से समझता हूं ("नग्न स्ट्रिंग्स" क्या हैं?), लेकिन मेरा मानना ​​है कि आप इसे पीछे की ओर मिला है। आपका अपडेट किया गया दूसरा उदाहरण अमान्य है और मुझे कभी भी उस काम के बारे में बताने का इरादा नहीं है। कीवर्ड तर्क वाक्य रचना है, जो स्वीकार करता है केवल नग्न पहचानकर्ता, आंतरिक रूप से एक शब्दकोश का उपयोग करता है। dictनिर्माता का समर्थन करता है कीवर्ड तर्कों और की तरह काम करता है def dict(**kwds): return kwds, तो कीवर्ड तर्क दिया।

दूसरा उदाहरण एक सिंटैक्स त्रुटि उठाता है। चर नाम एक नंबर से शुरू नहीं हो सकता

— सिमोन बर्गोट

हाँ, यह एक "मानचित्र" जैसा दिखता है और यह "मानचित्र" की तरह कार्य करता है। लेकिन सवाल "पायथन में मानचित्र" नहीं है, लेकिन "पायथन में हैश मैप": क्या एक हैश (!) मानचित्र हैं?

— 309963d8521805330a44bdc3387873

Answer 2

आप जो चाहते थे (उस समय मूल प्रश्न पूछा गया था) एक संकेत था। यहाँ एक संकेत है: पायथन में, आप शब्दकोशों का उपयोग कर सकते हैं ।

Answer 3

यह पाइथन के लिए बनाया गया है। शब्दकोश देखें ।

आपके उदाहरण के आधार पर:

streetno = {"1": "Sachine Tendulkar",
            "2": "Dravid",
            "3": "Sehwag",
            "4": "Laxman",
            "5": "Kohli" }

फिर आप इसे इस तरह एक्सेस कर सकते हैं:

sachine = streetno["1"]

इसके अलावा उल्लेख के लायक: यह एक कुंजी के रूप में किसी भी गैर-परस्पर डेटा प्रकार का उपयोग कर सकता है। यही है, यह एक कुंजी के रूप में एक टपल, बूलियन या स्ट्रिंग का उपयोग कर सकता है।

Answer 4

streetno = { 1 : "Sachin Tendulkar",
            2 : "Dravid",
            3 : "Sehwag",
            4 : "Laxman",
            5 : "Kohli" }

और मूल्यों को पुनः प्राप्त करने के लिए:

name = streetno.get(3, "default value")

या

name = streetno[3]

यह कुंजी के रूप में संख्या का उपयोग कर रहा है, कुंजी के रूप में तार का उपयोग करने के लिए संख्याओं के आसपास उद्धरण डालें।

Answer 5

हैश मैप्स पायथन में निर्मित होते हैं, उन्हें शब्दकोष कहा जाता है :

streetno = {}                        #create a dictionary called streetno
streetno["1"] = "Sachin Tendulkar"   #assign value to key "1"

उपयोग:

"1" in streetno                      #check if key "1" is in streetno
streetno["1"]                        #get the value from key "1"

अधिक जानकारी के लिए दस्तावेज़ीकरण देखें, जैसे अंतर्निहित तरीके और इतने पर। वे पायथन कार्यक्रमों में बहुत अच्छे हैं, और बहुत ही आम हैं (बिना सोचे समझे)।

Answer 6

यहाँ अजगर के उपयोग से हैश मैप का कार्यान्वयन सादगी के लिए हैश मानचित्र 16 निश्चित आकार का है। इसे आसानी से बदला जा सकता है। रिहाशिंग इस कोड के दायरे से बाहर है।

class Node:
    def __init__(self, key, value):
        self.key = key
        self.value = value
        self.next = None

class HashMap:
    def __init__(self):
        self.store = [None for _ in range(16)]
    def get(self, key):
        index = hash(key) & 15
        if self.store[index] is None:
            return None
        n = self.store[index]
        while True:
            if n.key == key:
                return n.value
            else:
                if n.next:
                    n = n.next
                else:
                    return None
    def put(self, key, value):
        nd = Node(key, value)
        index = hash(key) & 15
        n = self.store[index]
        if n is None:
            self.store[index] = nd
        else:
            if n.key == key:
                n.value = value
            else:
                while n.next:
                    if n.key == key:
                        n.value = value
                        return
                    else:
                        n = n.next
                n.next = nd

hm = HashMap()
hm.put("1", "sachin")
hm.put("2", "sehwag")
hm.put("3", "ganguly")
hm.put("4", "srinath")
hm.put("5", "kumble")
hm.put("6", "dhoni")
hm.put("7", "kohli")
hm.put("8", "pandya")
hm.put("9", "rohit")
hm.put("10", "dhawan")
hm.put("11", "shastri")
hm.put("12", "manjarekar")
hm.put("13", "gupta")
hm.put("14", "agarkar")
hm.put("15", "nehra")
hm.put("16", "gawaskar")
hm.put("17", "vengsarkar")
print(hm.get("1"))
print(hm.get("2"))
print(hm.get("3"))
print(hm.get("4"))
print(hm.get("5"))
print(hm.get("6"))
print(hm.get("7"))
print(hm.get("8"))
print(hm.get("9"))
print(hm.get("10"))
print(hm.get("11"))
print(hm.get("12"))
print(hm.get("13"))
print(hm.get("14"))
print(hm.get("15"))
print(hm.get("16"))
print(hm.get("17"))

आउटपुट:

sachin
sehwag
ganguly
srinath
kumble
dhoni
kohli
pandya
rohit
dhawan
shastri
manjarekar
gupta
agarkar
nehra
gawaskar
vengsarkar

Comments

मुझे लगता है कि आपका तर्क आंशिक रूप से सही है! hash(key) & 15, 73%15= 13लेकिन यह समतुल्य है: 1001001 & 0001111 = 0001111यानी 9नहीं 13, मुझे लगता है कि मॉड का उपयोग करना सही ऑपरेशन है। अगर मैं ग़लत हूं तो मेरी गलती सुझाएं!

— अनु

हालांकि आप सूची के माध्यम से पुनरावृति कैसे करते हैं?

— पेट्रो

Answer 7

class HashMap:
    def __init__(self):
        self.size = 64
        self.map = [None] * self.size

    def _get_hash(self, key):
        hash = 0

        for char in str(key):
            hash += ord(char)
        return hash % self.size

    def add(self, key, value):
        key_hash = self._get_hash(key)
        key_value = [key, value]

        if self.map[key_hash] is None:
            self.map[key_hash] = list([key_value])
            return True
        else:
            for pair in self.map[key_hash]:
                if pair[0] == key:
                    pair[1] = value
                    return True
                else:
                    self.map[key_hash].append(list([key_value]))
                    return True

    def get(self, key):
        key_hash = self._get_hash(key)
        if self.map[key_hash] is not None:
            for pair in self.map[key_hash]: 
                if pair[0] == key:
                    return pair[1]
        return None

    def delete(self, key):
        key_hash = self._get_hash(key)

        if self.map[key_hash] is None :
            return False
        for i in range(0, len(self.map[key_hash])):
            if self.map[key_hash][i][0] == key:
                self.map[key_hash].pop(i)
                return True

    def print(self):

        print('---Phonebook---')
        for item in self.map:
            if item is not None:
                print(str(item))

h = HashMap()

Answer 8

इस मामले में पायथन काउंटर भी एक अच्छा विकल्प है:

from collections import Counter

counter = Counter(["Sachin Tendulkar", "Sachin Tendulkar", "other things"])

print(counter)

यह सूची में प्रत्येक तत्व की गिनती के साथ एक तानाशाही देता है:

Counter({'Sachin Tendulkar': 2, 'other things': 1})

Answer 9

अजगर में आप एक शब्दकोश का उपयोग करेंगे।

यह अजगर में एक बहुत ही महत्वपूर्ण प्रकार है और अक्सर उपयोग किया जाता है।

आप आसानी से एक बना सकते हैं

name = {}

शब्दकोशों में कई विधियाँ हैं:

# add entries:
>>> name['first'] = 'John'
>>> name['second'] = 'Doe'
>>> name
{'first': 'John', 'second': 'Doe'}

# you can store all objects and datatypes as value in a dictionary
# as key you can use all objects and datatypes that are hashable
>>> name['list'] = ['list', 'inside', 'dict']
>>> name[1] = 1
>>> name
{'first': 'John', 'second': 'Doe', 1: 1, 'list': ['list', 'inside', 'dict']}

आप एक हुक्म के आदेश को प्रभावित नहीं कर सकते।