将列表转换为字典的最快方法，列表值作为键，列表索引作为值

Question

We can convert a list to dict, setting the list values as the keys, and setting the list indexes as the values thusly:

classes = ['car', 'bus', 'van']

reverse_classes = dict.fromkeys(classes)
for i, key in enumerate(reverse_classes):
    reverse_classes[key] = i

print(reverse_classes)

{'car': 0, 'bus': 1, 'van': 2}

The question is: Is this the fastest way?

Context:

This is used to quickly get the index of the class in a __getitem__ implementation of a custom torch.utils.data.Dataset while training:

from torch.utils.data import Dataset

## Load all training data from https://github.com/PKU-IMRE/VERI-Wild, and set all images minus 1 per class for training, and keep the last one for testing
class VeRIWild(Dataset):
    def __init__(self, main_dir, transform, train=True, debug=False):
        self.root_dir = main_dir
        self.transform = transform
        self.train = train
        self.classes = natsort.natsorted(os.listdir(os.path.join(self.root_dir, 'images')))
        self.total_imgs = []
        for car in self.classes:
            imgs = natsort.natsorted(os.listdir(os.path.join(self.root_dir, 'images', car)))
            if train:
                for im in imgs[:-1]: # keep the last image for test
                    self.total_imgs.append(os.path.join(car, im))
            else:
                self.total_imgs.append(os.path.join(car, imgs[-1]))

        self.reverse_classes = dict.fromkeys(self.classes)
        for i, key in enumerate(self.reverse_classes):
            self.reverse_classes[key] = i
            

    def __len__(self):
        return len(self.total_imgs)

    ## Returns: Tuple (image, target) where target is the index of the target category.
    def __getitem__(self, idx):
        img_loc = os.path.join(self.root_dir, 'images', self.total_imgs[idx])
        image = Image.open(img_loc).convert("RGB")
        tensor_image = self.transform(image)
        car_name = os.path.dirname(self.total_imgs[idx])
        return (tensor_image, self.reverse_classes[car_name])

Answer 1

Maybe you can try

out = dict(zip(data, range(len(data))))

Simple benchmark (try it on larger dataset):

from timeit import timeit
from itertools import count

# classes = ['car', 'bus', 'van']
classes = set('''Est voluptatum fuga natus ea officiis eveniet facere aut. Nihil eaque quia dolor officia. Et dolorem et aut laborum impedit accusantium consequatur. Atque tempora facilis iusto. Sit neque eligendi et accusantium et. Ut veritatis in voluptatum'''.split())

def f1(data):
    reverse_classes = {c: i for i, c in enumerate(data)}
    return reverse_classes

def f2(data):
    reverse_classes = dict.fromkeys(data)
    for i, key in enumerate(reverse_classes):
        reverse_classes[key] = i
    return reverse_classes

def f3(data):
    return dict(zip(data, range(len(data))))

def f4(data):
    return dict(zip(data, count()))


t1 = timeit(lambda: f1(classes), number=1000)
t2 = timeit(lambda: f2(classes), number=1000)
t3 = timeit(lambda: f3(classes), number=1000)
t4 = timeit(lambda: f4(classes), number=1000)

print(t1)
print(t2)
print(t3)
print(t4)

Prints:

0.006092605064623058
0.007285483996383846
0.004913415992632508
0.0048480971017852426

---

EDIT: Added version with itertools.count (Thanks @HeapOverflow)

Answer 2

Define fastest ?

The simplest, and probably most pythonic way, would be to use a dict-comprehension:

classes = [...]
reverse_classes = {item : idx for idx, item in enumerate(classes)}

Note that this will keep the last item only:

>>> classes = ['car', 'bus', 'van', 'car']
>>> {item: idx for idx, item in enumerate(classes)}
{'car': 3, 'bus': 1, 'van': 2}