Hash Map w Pythonie

144

Chcę zaimplementować HashMap w Pythonie. Chcę poprosić użytkownika o wprowadzenie danych. w zależności od jego wkładu pobieram informacje z HashMap. Jeśli użytkownik wprowadzi klucz z HashMap, chciałbym pobrać odpowiednią wartość.

Jak zaimplementować tę funkcjonalność w Pythonie?

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")
Kiran Bhat
źródło

Odpowiedzi:

246

Słownik Pythona to typ wbudowany, który obsługuje pary klucz-wartość.

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

a także używając słowa kluczowego dict:

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

lub:

streetno = {}
streetno["1"] = "Sachin Tendulkar" 
Alan
źródło
11
Drugi przykład po prostu buduje dyktando w taki sam sposób jak poprzednio, a następnie go kopiuje. Innym zastosowaniem dict, które byłoby bardziej odpowiednie w tym kontekście, jest to, dict(key1=value1, key2=value2, ...)że wymaga to kluczy do łańcuchów, które są również prawidłowymi identyfikatorami Pythona (i wewnętrznie tworzy to również słownik).
Ach, ciekawe, nie zdawałem sobie sprawy, że nagie struny są prawidłowymi identyfikatorami.
Alan
Nie jestem pewien, czy dobrze Cię rozumiem (czym są „nagie struny”?), Ale wydaje mi się, że zrozumiałeś to wstecz. Twój zaktualizowany drugi przykład jest nieważny i nigdy nie zamierzałem podawać czegoś takiego jak ta praca. Argumenty słów kluczowych składnia, który akceptuje tylko nagie identyfikatory, wewnętrznie używa słownika. Przez dictkonstruktor obsługuje słowa kluczowego na argumenty i działa jak def dict(**kwds): return kwdsgdyby podane argumenty słowa kluczowego.
Drugi przykład wywołuje błąd składniowy. nazwy zmiennych nie mogą zaczynać się od liczby
Simon Bergot
Tak, wygląda jak „mapa” i zachowuje się jak „mapa”. Ale pytanie nie brzmi „Mapa w Pythonie”, ale „Mapa mieszająca w Pythonie”: Czy słowniki są mapą z krzyżykiem (!)?
309963d8521805330a44bdcb3d87f3
27

Wszystko, czego chciałeś (w czasie, gdy pierwotnie zadawano pytanie), to podpowiedź. Oto wskazówka: w Pythonie możesz używać słowników .

Christian Neverdal
źródło
24

Jest wbudowany w Python. Zobacz słowniki .

Na podstawie twojego przykładu:

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

Możesz wtedy uzyskać do niego dostęp w następujący sposób:

sachine = streetno["1"]

Warto również wspomnieć: może używać dowolnego niezmiennego typu danych jako klucza. Oznacza to, że może używać krotki, wartości logicznej lub ciągu znaków jako klucza.

Edwin
źródło
16
streetno = { 1 : "Sachin Tendulkar",
            2 : "Dravid",
            3 : "Sehwag",
            4 : "Laxman",
            5 : "Kohli" }

Aby pobrać wartości:

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

Lub

name = streetno[3]

Oznacza to użycie liczby jako kluczy, umieść liczby w cudzysłowie, aby użyć łańcuchów jako kluczy.

totaam
źródło
14

Mapy skrótów są wbudowane w Pythonie i nazywane są słownikami :

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

Stosowanie:

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

Zobacz dokumentację, aby uzyskać więcej informacji, np. Wbudowane metody i tak dalej. Są świetne i bardzo powszechne w programach Pythona (nic dziwnego).

rozwijać
źródło
12

Oto implementacja Hash Map przy użyciu Pythona. Dla uproszczenia, mapa skrótów ma stały rozmiar 16. Można to łatwo zmienić. Ponowne haszowanie jest poza zakresem tego kodu.

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

Wynik:

sachin
sehwag
ganguly
srinath
kumble
dhoni
kohli
pandya
rohit
dhawan
shastri
manjarekar
gupta
agarkar
nehra
gawaskar
vengsarkar
Vishwas Abhyankar
źródło
Myślę, że twoja logika jest częściowo poprawna! hash(key) & 15,, 73%15= 13ale to jest równoważne: 1001001 & 0001111 = 0001111tj. 9i nie 13, myślę, że użycie mod jest poprawną operacją. Popraw mnie, jeśli się mylę!
Anu
Jak jednak przeglądasz tę listę?
Petro
8
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()
krezaeim
źródło
7

Python Counter to również dobra opcja w tym przypadku:

from collections import Counter

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

print(counter)

Zwraca dykt z liczbą każdego elementu na liście:

Counter({'Sachin Tendulkar': 2, 'other things': 1})
Shadowtrooper
źródło
1

W Pythonie użyłbyś słownika.

Jest to bardzo ważny typ w Pythonie i często używany.

Możesz je łatwo utworzyć, korzystając z

name = {}

Słowniki mają wiele metod:

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

Nie możesz wpływać na kolejność dyktowania.

Szczery
źródło