目录

介绍

概念化这个混乱

编码此混乱

警告

使用其他容器

有时有必要将集合用作字典键，但是这可能会导致性能下降并且不安全。以下是使它更快更安全的方法。

下载源4.9 KB
介绍

使用C＃进行功能样式编程时，您最终可能会遇到需要按项目的有序列表来键入字典的情况。有好的方法，但不是非常好的方法。本文旨在为您提供一种将列表用作字典键的有效且相对安全的方法。

概念化这个混乱

字典键必须具有可比性，以确保相等性，必须提供适当的哈希码，并且必须不可变。这些要求使使用列表作为字典键有点麻烦，因为列表通常不提供值语义——在这种情况下，是逐项比较和适当的哈希码。也许更糟的是，列表允许您随时修改它们。

总之，这里有两个主要问题，一个是逐项比较列表不是很有效，并且使用标准IList<T>实现作为字典键从根本上是不安全的，因为可以随时对其进行修改。

我们可以通过要求使用IReadOnlyList<T>来或多或少地解决后者，后者提供类似列表的访问，而不需要修改列表的方法。不过，当我们声明KeyList<T>类时，我们将在其中添加一个Add()方法。这样做的原因是允许您首先填写列表。如果我们想更加安全，则可以取消该Add()方法，并强制您将这些项作为数组传递给KeyList<T>的构造函数。未执行此操作的原因是为了提高性能。KeyList<T>的主要目的是性能，将数据传递给构造函数将需要一个副本。副本不一定很慢，但我们不需要它——我们在这里没事，因为任何采用IReadOnlyList<T>的操作都不会看到Add() 方法，这样，我们就避免了虚假的副本。

前者需要做更多的工作。我们必须在KeyList<T>上实现值相等语义。但是，在这里，我们提出了一个重要的技巧：在将每个项目添加到列表时，我们都会重新计算哈希码，这样我们就不必在以后进行计算。然后，我们将该哈希码用作相等性检查的一部分，以在它们不相等时短路。接下来，让我们看一下该KeyList<T>类的代码。

编码此混乱


sealed class KeyList<T> : IReadOnlyList<T>, IEquatable<KeyList<T>>
{
    int _hashCode;
    List<T> _items;
    public KeyList()
    {
        _items = new List<T>();
        _hashCode = 0;
    }
    public KeyList(int capacity)
    {
        _items = new List<T>(capacity);
        _hashCode = 0;
    }
    public T this[int index] => _items[index];

    public int Count => _items.Count;

    public IEnumerator<T> GetEnumerator()
    {
        return _items.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
    public void Add(T item)
    {
        _items.Add(item);
        if (null != item)
            _hashCode ^= item.GetHashCode();
    }
    public override int GetHashCode()
    {
        return _hashCode;
    }
    public bool Equals(KeyList<T> rhs)
    {
        if (ReferenceEquals(this, rhs))
            return true;
        if (ReferenceEquals(rhs, null))
            return false;
        if (rhs._hashCode != _hashCode)
            return false;
        var ic = _items.Count;
        if (ic != rhs._items.Count)
            return false;
        for(var i = 0;i<ic;++i)
            if (!Equals(_items[i], rhs._items[i]))
                return false;
        return true;
    }
    public override bool Equals(object obj)
    {
        return Equals(obj as KeyList<T>);
    }
}

这里的重要方法Add()和主要Equals()方法。您可以在Add()中看到我们正在为添加的每个项目修改_hashCode字段。您可以在Equals()方法中看到，如果哈希代码不相等，我们会在最后进行逐项比较之前短路。这样可以大大提高性能。另一个性能提升在于无需计算任何内容的GetHashCode()方法。由于这些方法通常是由IDictionary<TKey,TValue>实现调用的，因此我们希望它们尽可能快，尤其是GetHashCode()方法，Dictionary<TKey, TValue>经常调用它。


如果在发布模式下运行代码，则将获得准确的性能指标。在Debug中没有那么多，因此如果您在Debug中运行，该程序将向您发出警告。您可以看到我们使用的字典，一个是标准列表，另一个是特殊KeyList<T>实例。与使用List<T>相比，使用KeyList<T>应该可以提高5x+的性能， 而且由于它只实现了列表访问的IReadOnlyList<T>，所以也更安全。现在我们两个最初的问题都解决了。

警告

已经指出，如果T类型是可变的，则这是不正确的。这是真的。然而，Dictionary<TKey, TValue>和HashSet<T>也是如此，所以这里也适用同样的警告-不要更改添加到这些列表的项的值，就像不应该更改添加到Dictionary和HashSet的键值一样。

使用其他容器

如果需要，可以将该技术应用于其他集合。如果需要（相对地）高效的无序比较，可以将其调整为HashSet<T> 。我已经在一些项目中做到了这一点。只需确保在Equals()方法中使用SetEquals()进行逐项比较，因为它更快。

本文翻译自：How to return dictionary keys as a list in Python?
 In Python 2.7 , I could get dictionary keys , values , or items as a list: 在Python 2.7中 ，我可以将字典键 ， 值或项作为列表获取： 
>>> newdict = {1:0, 2:0, 3:0}
>>> newdict.keys()
[1, 2, 3]

 Now, in Python >= 3.3 , I get something like this: 现在，在Python> = 3.3中 ，我得到如下信息： 
>>> newdict.keys()
dict_keys([1, 2, 3])

 So, I have to do this to get a list: 因此，我必须这样做以获得列表： 
newlist = list()
for i in newdict.keys():
    newlist.append(i)

 I'm wondering, is there a better way to return a list in Python 3 ? 我想知道，是否有更好的方法在Python 3中返回列表？ 
#1楼
参考：https://stackoom.com/question/18ZRm/如何在Python中将字典键作为列表返回
#2楼
 Try list(newdict.keys()) . 尝试list(newdict.keys()) 。 
 This will convert the dict_keys object to a list. 这会将dict_keys对象转换为列表。 
 On the other hand, you should ask yourself whether or not it matters. 另一方面，您应该问自己是否重要。 The Pythonic way to code is to assume duck typing ( if it looks like a duck and it quacks like a duck, it's a duck ). Python的编码方式是假设鸭子输入（ 如果看起来像鸭子，而像鸭子一样嘎嘎叫，那就是鸭子 ）。 The dict_keys object will act like a list for most purposes. 在dict_keys对象的作用类似于列表。 For instance: 例如： 
for key in newdict.keys():
  print(key)

 Obviously, insertion operators may not work, but that doesn't make much sense for a list of dictionary keys anyway. 显然，插入运算符可能不起作用，但是对于字典关键字列表而言，这并没有多大意义。 
#3楼
 A bit off on the "duck typing" definition -- dict.keys() returns an iterable object, not a list-like object. 在“鸭子类型”定义上dict.keys()偏离dict.keys()返回一个可迭代的对象，而不是类似列表的对象。 It will work anywhere an iterable will work -- not any place a list will. 它可以在任何可迭代的地方都可以使用-列表不能在任何地方使用。 a list is also an iterable, but an iterable is NOT a list (or sequence...) 列表也是可迭代的，但可迭代的不是列表（或序列...） 
 In real use-cases, the most common thing to do with the keys in a dict is to iterate through them, so this makes sense. 在实际的用例中，与字典中的键有关的最常见的事情是遍历它们，因此这很有意义。 And if you do need them as a list you can call list() . 如果确实需要它们作为列表，则可以调用list() 。 
 Very similarly for zip() -- in the vast majority of cases, it is iterated through -- why create an entire new list of tuples just to iterate through it and then throw it away again? 与zip()非常相似-在大多数情况下，它都是经过迭代的-为什么要创建整个元组的新列表只是为了对其进行迭代，然后又将其丢弃？ 
 This is part of a large trend in python to use more iterators (and generators), rather than copies of lists all over the place. 这是python中使用更多迭代器（和生成器）而不是在各处使用列表副本的一种大趋势的一部分。 
 dict.keys() should work with comprehensions, though -- check carefully for typos or something... it works fine for me: dict.keys()应该可以理解-仔细检查是否有错别字...对我来说很好用： 
>>> d = dict(zip(['Sounder V Depth, F', 'Vessel Latitude, Degrees-Minutes'], [None, None]))
>>> [key.split(", ") for key in d.keys()]
[['Sounder V Depth', 'F'], ['Vessel Latitude', 'Degrees-Minutes']]
#4楼
 list(newdict) works in both Python 2 and Python 3, providing a simple list of the keys in newdict . list(newdict)在Python 2和Python 3中均可使用，提供了newdict中的键的简单列表。 keys() isn't necessary. keys()不是必需的。 (: （： 
#5楼
 You can also use a list comprehension : 您还可以使用列表推导 ： 
>>> newdict = {1:0, 2:0, 3:0}
>>> [k  for  k in  newdict.keys()]
[1, 2, 3]

 Or, shorter, 或更短一点 
>>> [k  for  k in  newdict]
[1, 2, 3]

 Note: Order is not guaranteed on versions under 3.7 (ordering is still only an implementation detail with CPython 3.6). 注意：在3.7版以下的版本中，不能保证订购（订购仍然只是CPython 3.6的实现细节）。 
#6楼
 Converting to a list without using the keys method makes it more readable: 在不使用keys方法的情况下转换为列表使其更具可读性： 
list(newdict)

 and, when looping through dictionaries, there's no need for keys() : 并且，当遍历字典时，不需要keys() ： 
for key in newdict:
    print key

 unless you are modifying it within the loop which would require a list of keys created beforehand: 除非您要在循环中进行修改，否则将需要预先创建的键列表： 
for key in list(newdict):
    del newdict[key]

 On Python 2 there is a marginal performance gain using keys() . 在Python 2上，使用keys()获得少量性能提升 。 

1、列表可以作为集合的元素吗？
2、集合可以作为列表的元素吗？
3、元组可以作为集合的元素吗？
4、集合可以作为元组的元素吗？
5、字典可以作为集合的元素吗？
对于上面这五个问题，是不是不太懂呢？接下来我会一一解答。
一、第一个问题：
首先我们需要知道什么可以作为集合的元素。集合对象是一组无序排列***可哈希***的值，集合成员可以做字典中的键。那么可哈希与不可哈希是什么意思呢？
简要的说可哈希的数据类型，即不可变的数据结构(字符串str、元组tuple、对象集objects)；同理，不可哈希的数据类型，即可变的数据结构 (集合set，列表list，字典dict)
>>> set1={[1,2,3,4],4,5,6}c
Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    set1={[1,2,3,4],4,5,6}
TypeError: unhashable type: 'list'

注：unhashable是“不可哈希的”的意思
可见，报错了。所以列表不可以作为集合的元素.
二、第二个问题：
那么列表的元素可以有哪些呢？列表没有长度限制，元素类型可以不同，使用非常灵活。看例子：
>>> list1=[{1,2,3,4},4,5,6]
>>> list1
[{1, 2, 3, 4}, 4, 5, 6]
>>>

说明集合可以作为列表的元素。
三、第三个问题：
在第一个小问中说到，元组（tuple）是不可变的数据结构（可哈希的数据类型），因此，是可以作为集合元素的。
>>> set2={(1,2,3,4,5),6,7,8}
>>> set2
{8, (1, 2, 3, 4, 5), 6, 7}
>>> 

四、第四个问题：
元组与列表类似，不同之处在于元组的元素不能修改具体用法我这里不在赘述。
>>> tuple1=({1,2,3,4,5},89,5)
>>> tuple1
({1, 2, 3, 4, 5}, 89, 5)
>>> 

所以集合可以作为元组的元素。
五、第五个问题：
因为字典是可变的数据结构（不可哈希），所以自然也不能作为集合的元素。
>>> set1={{'Name': 'Runoob', 'Age': 7, 'Class': 'First'},4,5,6}
Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    set1={{'Name': 'Runoob', 'Age': 7, 'Class': 'First'},4,5,6}
TypeError: unhashable type: 'dict'
>>> 

附上一张表：


观看顺序：ex：字符串可以作为列表的元素  列表可以作为列表的元素…
如果有错误的地方，还请指正，大家一起学习。

print(dict.fromkeys(['a','b','c']))
>>>{'a': None, 'b': None, 'c': None}