Carte de hachage dans Python
Je veux implémenter un HashMap en Python. Je veux demander à un utilisateur pour une entrée. en fonction de sa contribution, je récupère des informations du HashMap. Si l'utilisateur entre une clé du HashMap, j'aimerais récupérer la valeur correspondante.
Comment implémenter cette fonctionnalité en Python?
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")
dictionnaire Python est un type intégré qui prend en charge les paires clé-valeur.
streetno = {"1":"Sachine Tendulkar", "2":"Dravid", "3":"Sehwag", "4":"Laxman","5":"Kohli"}
ainsi que l'utilisation du mot clé dict:
streetno = dict({"1":"Sachine Tendulkar", "2":"Dravid"})
ou:
streetno = {}
streetno["1"] = "Sachine Tendulkar"
Tout ce que vous vouliez (au moment où la question a été posée à l'origine) était un indice. Voici un indice: En Python, vous pouvez utiliser dictionnaires .
C'est intégré pour Python. Voir dictionnaires .
Sur la base de votre exemple:
streetno = {"1": "Sachine Tendulkar",
"2": "Dravid",
"3": "Sehwag",
"4": "Laxman",
"5": "Kohli" }
Vous pouvez alors y accéder comme ceci:
sachine = streetno["1"]
Il convient également de mentionner: il peut utiliser n'importe quel type de données non mutable comme clé. C'est-à-dire qu'il peut utiliser un tuple, un booléen ou une chaîne comme clé.
streetno = { 1 : "Sachin Tendulkar",
2 : "Dravid",
3 : "Sehwag",
4 : "Laxman",
5 : "Kohli" }
Et pour récupérer des valeurs:
name = streetno.get(3, "default value")
Ou
name = streetno[3]
Pour utiliser un nombre en tant que clés, mettez des guillemets autour des chiffres pour utiliser des chaînes en tant que clés.
Les cartes de hachage sont intégrées à Python, elles s'appellent dictionnaires :
streetno = {} #create a dictionary called streetno
streetno["1"] = "Sachin Tendulkar" #assign value to key "1"
Usage:
"1" in streetno #check if key "1" is in streetno
streetno["1"] #get the value from key "1"
Voir la documentation pour plus d'informations, par exemple. méthodes intégrées et ainsi de suite. Ils sont excellents et très courants dans les programmes Python (sans surprise).
Voici la mise en oeuvre de la carte de hachage en utilisant python Pour des raisons de simplicité, la carte de hachage est de taille fixe 16. Cela peut être modifié facilement. Rehase est hors de portée de ce code.
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"))
Sortie:
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 est également une bonne option dans ce cas:
from collections import Counter
counter = Counter(["Sachin Tendulkar", "Sachin Tendulkar", "other things"])
print(counter)
Ceci retourne un dict avec le nombre de chaque élément de la liste:
Counter({'Sachin Tendulkar': 2, 'other things': 1})