python - 存储一组四个(或更多)值的最佳数据结构是什么？

说我有以下variables及其代表values的相应record。

name = 'abc'
age = 23
weight = 60
height = 174

请注意，value可以是不同的types(string，integer，float，对任何其他对象的引用等)。

将会有许多records(至少> 100,000)。当所有这四个record(实际上是其unique)放在一起时，每个variables都将是values。换句话说，不存在record，所有4个values都相同。

我正在尝试在Python中找到一种有效的数据结构，该结构将允许我基于records时间复杂度中的任何variables来(存储和)检索log(n)。

例如:

def retrieve(name=None,age=None,weight=None,height=None)
    if name is not None and age is None and weight is None and height is None:
        /* get all records with the given name */
    if name is None and age is not None and weight is None and height is None:
        /* get all records with the given age */
    ....
    return records

retrieve的调用方式如下:

retrieve(name='abc')

上面应该返回[{name:'abc', age:23, wight:50, height=175}, {name:'abc', age:28, wight:55, height=170}, etc]

retrieve(age=23)

上面应该返回[{name:'abc', age:23, wight:50, height=175}, {name:'def', age:23, wight:65, height=180}, etc]
而且，将来我可能需要在此记录中再添加一个或两个variables。例如，sex = 'm'。因此，retrieve函数必须是可伸缩的。

简而言之:Python中是否存在数据结构，该数据结构将允许storing a record包含n数目的columns(名称，年龄，性别，体重，高度等)和retrieving records，并基于column(或理想情况下为logarithmic)中的constant - O(1)中的任意(一个)查找时间)复杂度？

最佳答案

Python内置了一个单一的数据结构，可以满足您的所有需求，但是要实现目标并相当有效地做到这一点，可以很容易地结合使用它们。

例如，假设您的输入是名为employees.csv的逗号分隔值文件中的以下数据，其字段名称定义如第一行所示:

name,age,weight,height
Bob Barker,25,175,6ft 2in
Ted Kingston,28,163,5ft 10in
Mary Manson,27,140,5ft 6in
Sue Sommers,27,132,5ft 8in
Alice Toklas,24,124,5ft 6in

下面的工作代码说明了如何将这些数据读取和存储到记录列表中，并自动创建单独的查找表以查找与每个记录中的字段所包含的值相关联的记录。

记录是由namedtuple创建的类的实例，这是一种非常有效的内存存储方法，因为每个记录都缺少类实例通常包含的__dict__属性。使用它们将使使用点语法(如record.fieldname)按名称访问每个字段成为可能。

查找表是defaultdict(list)实例，它们平均提供类似于字典的 O (1)查找时间，并且还允许将多个值与每个值相关联。因此，查找关键字是要查找的字段值的值，并且与之相关的数据将是存储在Person列表中的具有该值的employees记录的整数索引的列表-因此它们都将相对小的。

请注意，该类的代码完全是数据驱动的，因为它不包含任何硬编码的字段名，这些字段名全部在读取时从csv数据输入文件的第一行获取。当然，在使用实例时，所有retrieve()方法调用必须提供有效的字段名称。

更新

修改为在首次读取数据文件时不为每个字段的每个唯一值创建查找表。现在，retrieve()方法仅在需要时才“懒惰地”创建它们(并保存/缓存结果以备将来使用)。也已修改为可在Python 2.7+(包括3.x)中使用。

from collections import defaultdict, namedtuple
import csv

class DataBase(object):
    def __init__(self, csv_filename, recordname):
        # Read data from csv format file into a list of namedtuples.
        with open(csv_filename, 'r') as inputfile:
            csv_reader = csv.reader(inputfile, delimiter=',')
            self.fields = next(csv_reader)  # Read header row.
            self.Record = namedtuple(recordname, self.fields)
            self.records = [self.Record(*row) for row in csv_reader]
            self.valid_fieldnames = set(self.fields)

        # Create an empty table of lookup tables for each field name that maps
        # each unique field value to a list of record-list indices of the ones
        # that contain it.
        self.lookup_tables = {}

    def retrieve(self, **kwargs):
        """ Fetch a list of records with a field name with the value supplied
            as a keyword arg (or return None if there aren't any).
        """
        if len(kwargs) != 1: raise ValueError(
            'Exactly one fieldname keyword argument required for retrieve function '
            '(%s specified)' % ', '.join([repr(k) for k in kwargs.keys()]))
        field, value = kwargs.popitem()  # Keyword arg's name and value.
        if field not in self.valid_fieldnames:
            raise ValueError('keyword arg "%s" isn\'t a valid field name' % field)
        if field not in self.lookup_tables:  # Need to create a lookup table?
            lookup_table = self.lookup_tables[field] = defaultdict(list)
            for index, record in enumerate(self.records):
                field_value = getattr(record, field)
                lookup_table[field_value].append(index)
        # Return (possibly empty) sequence of matching records.
        return tuple(self.records[index]
                        for index in self.lookup_tables[field].get(value, []))

if __name__ == '__main__':
    empdb = DataBase('employees.csv', 'Person')

    print("retrieve(name='Ted Kingston'): {}".format(empdb.retrieve(name='Ted Kingston')))
    print("retrieve(age='27'): {}".format(empdb.retrieve(age='27')))
    print("retrieve(weight='150'): {}".format(empdb.retrieve(weight='150')))
    try:
        print("retrieve(hight='5ft 6in'):".format(empdb.retrieve(hight='5ft 6in')))
    except ValueError as e:
        print("ValueError('{}') raised as expected".format(e))
    else:
        raise type('NoExceptionError', (Exception,), {})(
            'No exception raised from "retrieve(hight=\'5ft\')" call.')

输出:

retrieve(name='Ted Kingston'): [Person(name='Ted Kingston', age='28', weight='163', height='5ft 10in')]
retrieve(age='27'): [Person(name='Mary Manson', age='27', weight='140', height='5ft 6in'),
                     Person(name='Sue Sommers', age='27', weight='132', height='5ft 8in')]
retrieve(weight='150'): None
retrieve(hight='5ft 6in'): ValueError('keyword arg "hight" is an invalid fieldname')
                           raised as expected

关于python - 存储一组四个(或更多)值的最佳数据结构是什么？，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/15418386/