파이썬 해시 맵

파이썬에서 HashMap을 구현하고 싶습니다. 사용자에게 입력을 요청하고 싶습니다. 그의 입력에 따라 HashMap에서 일부 정보를 검색합니다. 사용자가 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")

Python 사전 은 키-값 쌍을 지원하는 내장 유형입니다.

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

dict 키워드를 사용하는 것 외에도

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

또는:

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

당신이 원하는 것은 (질문이 처음 요청되었을 때) 힌트였습니다. 힌트는 다음과 같습니다. Python에서는 사전 을 사용할 수 있습니다 .

파이썬 용으로 내장되어 있습니다. 사전을 참조하십시오 .

귀하의 예를 기반으로 :

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

그런 다음 다음과 같이 액세스 할 수 있습니다.

sachine = streetno["1"]

또한 언급 할 가치가 있습니다 : 변경 불가능한 데이터 유형을 키로 사용할 수 있습니다. 즉, 튜플, 부울 또는 문자열을 키로 사용할 수 있습니다.

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

그리고 값을 검색하려면 다음을 수행하십시오.

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

또는

name = streetno[3]

숫자를 키로 사용하고 문자열을 키로 사용하려면 숫자를 따옴표로 묶습니다.

해시 맵은 Python에 내장되어 있으며 사전 이라고 합니다 .

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"

기본 제공 방법 등과 같은 자세한 내용은 설명서를 참조하십시오. 그들은 훌륭하고 파이썬 프로그램에서 매우 일반적입니다.

다음은 파이썬을 사용한 해시 맵의 구현입니다. 단순 해시 맵의 크기는 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

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()

이 경우 Python Counter 도 좋은 옵션입니다.

from collections import Counter

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

print(counter)

목록의 각 요소 개수와 함께 dict를 반환합니다.

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

파이썬에서는 사전을 사용합니다.

파이썬에서 매우 중요한 유형이며 자주 사용됩니다.

당신은 쉽게 하나를 만들 수 있습니다

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']}

당신은 dict의 순서에 영향을 줄 수 없습니다.