Python 如何度量哈希表的最大负载因子

因此，我需要最大负载因子为.8，当这种情况发生时，我需要重新刷新表（基本上使映射的容量加倍）

但是我如何准确地测量负载系数呢？是当前桶的长度吗？因为如果查看set（）方法，在添加之后，如果负载因子>=80%，我需要将映射重新灰化为当前容量的两倍。但是，如何准确测量负载系数

---

任何帮助都将不胜感激。我只需要知道如何测量负载系数

我想这就是你想要的：

类哈希映射：
“”“哈希映射类”“”
定义初始长度（自身，最大长度=8）：
self.max\u length=最大长度
自最大荷载系数=0.8
self.length=0
self.map=[None]*self.max_长度
self.keyslist=[]
def_get_散列（self，key）：
散列=0
对于str（键）中的字符：
散列+=ord（字符）
返回哈希%self.max\u长度
def get（自身、密钥、默认值=无）：
key\u hash=self.\u get\u hash（key）
如果self.map[key_hash]不是None：
对于self.map[key\u hash]中的pair：
如果对[0]==密钥：
返回对[1]
如果self.map[key_hash]为无：
一无所获
如果需要，定义再灰化（自身）：
如果self.length>=self.max\u负载系数*self.capacity（）：
自我容量（自我容量（）*2）
def设置（自身、键、值）：
key\u hash=self.\u get\u hash（key）
键\值=[键，值]
self.keyslist.append（键）
如果self.map[key_hash]为无：
自我长度+=1
self.map[key\u hash]=列表（[key\u value]）
自我。如果需要的话，重新洗牌
返回真值
其他：
对于self.map[key\u hash]中的pair：
自我长度+=1
如果对[0]==密钥：
对[1]=值
返回真值
self.map[key\u hash].append（key\u值）
自我。如果需要的话，重新洗牌
返回真值
def容量（自身）：
返回self.max_长度
def再灰分（自身、新容量）：
#创建具有新容量的新hashmap
new_hashmap=hashmap（新_容量）
#在新hashmap中插入所有键
对于键入self.keyslist：
value=self.get（键）
新建\u hashmap.put（键，值）
#将新hashmap的所有字段复制到此hashmap
self.max\u length=新的\u hashmap.max\u length
self.max\u load\u factor=新的\u hashmap.max\u load\u factor
self.length=new_hashmap.length
self.map=new_hashmap.map
self.keyslist=new_hashmap.keyslist

class HashMap:
    """ hashmap class """
    def __init__(self):
        self.max_length = 8
        self.max_load_factor = 0.8
        self.length = 0
        self.map = [None] * self.max_length
        self.keyslist = []

    def _get_hash(self, key):
        hash = 0
        for char in str(key):
            hash += ord(char)
        return hash % self.max_length

    def get(self, key, default=None):
        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]
        if self.map[key_hash] is None:
            return None

    def set(self, key, value):
        key_hash = self._get_hash(key)
        key_value = [key, value]
        self.keyslist.append(key)
        if self.map[key_hash] is None:
            self.length += 1
            self.map[key_hash] = list([key_value])
            if self.max_load_factor >= .8:
                self.rehash(self.capacity * 2)
            return True
        else:
            for pair in self.map[key_hash]:
                self.length += 1
                if pair[0] == key:
                    pair[1] = value
                    return True
            if self.max_load_factor >= .8:
                self.rehash(self.capacity * 2)
            self.map[key_hash].append(key_value)
            return True


    def capacity(self):
        return self.max_length  # return the current capacity --number of buckets-- in the map

    def rehash(self):
        self.map = [None] * (self.max_length * 2)
        return self.map