Python 使用字典计算列表变量

我必须做一个程序，可以计算出一个给定列表中水果的数量

我尝试了一个for循环，但没有成功。我也试过一个计数器，但这会删除第二个“香蕉”，只识别一个

c = { 'banana': 'fruit', 'apple': 'fruit', 'pizza': 'fastfood', 'fries': 'fastfood' }
v = [ 'fries', 'banana', 'banana', 'apple', 'pizza' ]

r = len([v for v in c if c.items() == 'fruit' in c.value()])

print(r)

---

我希望这会给我水果的数量，但我的输出是0。

首先尝试这个数字类型，然后查找dictual c键的出现情况

c={‘香蕉’：‘水果’、‘苹果’：‘水果’、‘比萨饼’：‘快餐’、‘薯条’：‘快餐’}

v=['薯条'、'香蕉'、'香蕉'、'苹果'、'比萨饼']

result=[c[i]for i in v]这将迭代并给出元素的类型

输出={}

对于c.Value中的键： 输出[键]=strresult.countkey

---

printoutput

尝试第一种数字输出类型，然后查找出现的DICTOR c键

c={‘香蕉’：‘水果’、‘苹果’：‘水果’、‘比萨饼’：‘快餐’、‘薯条’：‘快餐’}

v=['薯条'、'香蕉'、'香蕉'、'苹果'、'比萨饼']

result=[c[i]for i in v]这将迭代并给出元素的类型

输出={}

对于c.Value中的键： 输出[键]=strresult.countkey

---

printoutput

您可以从所有水果中构建一个集合，并使用该集合：

c = { 'banana': 'fruit', 'apple': 'fruit', 'pizza': 'fastfood', 'fries': 'fastfood' }

# collect all fruits into a set that only contains fruit
fixed = set(k for k,v in c.items() if v=="fruit")  # cheating by creating the set in setup ;)

v = [ 'fries', 'banana', 'banana', 'apple', 'pizza' ]

r = sum(f in fixed for f in v)

print(r)

返回3-因为O1集合查找的结果为True，而False为0

在大多数情况下，该解决方案的性能较差，而在其他情况下，该解决方案的性能稍快：

要创建集合，它将访问dict的每个值一次以构建集合，然后使用创建的集合来确定某个对象是否是水果： 考虑：

c = {'banana':'fruit'}
v = ['banana' * 100000]
fixed = set(k for k,v in c.items() if v=="fruit")

口述理解必须直接获得c['banana']100000次的值，并执行100000次c[val]=='fruit'检查它是否是水果。这比在构造的集合上检查100000次固定的“香蕉”要慢

对于手头的例子来说，dict comp很好

大多数情况下，dict comp速度更快：

setup_code = """
c = { 'banana': 'fruit', 'apple': 'fruit', 'pizza': 'fastfood', 'fries': 'fastfood' }
v = [ 'fries', 'banana', 'banana', 'apple', 'pizza' ]
fixed = set(k for k,v in c.items() if v=="fruit")
"""

setup_code2 = """
c = { 'banana': 'fruit', 'apple': 'fruit', 'pizza': 'fastfood', 'fries': 'fastfood' }
v = ['banana']*1000  
fixed = set(k for k,v in c.items() if v=="fruit")
"""

using_set = """
# collect all fruits into a set that only contains fruit

r = sum(1 if f in fixed else 0 for f in v)
"""

using_dict_comp = """
r = sum(1 for val in v if c[val] == 'fruit')
"""

import timeit

print("set:", timeit.timeit(using_set,setup=setup_code,number=10000))
print("dict:", timeit.timeit(using_dict_comp,setup=setup_code,number=1000))
print("set:", timeit.timeit(using_set,setup=setup_code2,number=10000))
print("dict:", timeit.timeit(using_dict_comp,setup=setup_code2,number=10000))

输出：

'set:', 0.0069959163665771484 
'dict:', 0.0006661415100097656

'set:', 0.6653687953948975  # this "fasteness" goes away as soon as more items are in the set
'dict:', 0.7533159255981445 

---

您可以从所有水果中构建一个集合，并使用：

c = { 'banana': 'fruit', 'apple': 'fruit', 'pizza': 'fastfood', 'fries': 'fastfood' }

# collect all fruits into a set that only contains fruit
fixed = set(k for k,v in c.items() if v=="fruit")  # cheating by creating the set in setup ;)

v = [ 'fries', 'banana', 'banana', 'apple', 'pizza' ]

r = sum(f in fixed for f in v)

print(r)

返回3-因为O1集合查找的结果为True，而False为0

在大多数情况下，该解决方案的性能较差，而在其他情况下，该解决方案的性能稍快：

要创建集合，它将访问dict的每个值一次以构建集合，然后使用创建的集合来确定某个对象是否是水果： 考虑：

c = {'banana':'fruit'}
v = ['banana' * 100000]
fixed = set(k for k,v in c.items() if v=="fruit")

口述理解必须直接获得c['banana']100000次的值，并执行100000次c[val]=='fruit'检查它是否是水果。这比在构造的集合上检查100000次固定的“香蕉”要慢

对于手头的例子来说，dict comp很好

大多数情况下，dict comp速度更快：

setup_code = """
c = { 'banana': 'fruit', 'apple': 'fruit', 'pizza': 'fastfood', 'fries': 'fastfood' }
v = [ 'fries', 'banana', 'banana', 'apple', 'pizza' ]
fixed = set(k for k,v in c.items() if v=="fruit")
"""

setup_code2 = """
c = { 'banana': 'fruit', 'apple': 'fruit', 'pizza': 'fastfood', 'fries': 'fastfood' }
v = ['banana']*1000  
fixed = set(k for k,v in c.items() if v=="fruit")
"""

using_set = """
# collect all fruits into a set that only contains fruit

r = sum(1 if f in fixed else 0 for f in v)
"""

using_dict_comp = """
r = sum(1 for val in v if c[val] == 'fruit')
"""

import timeit

print("set:", timeit.timeit(using_set,setup=setup_code,number=10000))
print("dict:", timeit.timeit(using_dict_comp,setup=setup_code,number=1000))
print("set:", timeit.timeit(using_set,setup=setup_code2,number=10000))
print("dict:", timeit.timeit(using_dict_comp,setup=setup_code2,number=10000))

输出：

'set:', 0.0069959163665771484 
'dict:', 0.0006661415100097656

'set:', 0.6653687953948975  # this "fasteness" goes away as soon as more items are in the set
'dict:', 0.7533159255981445 

试试看：

r = sum(1 for val in v if c[val] == 'fruit')

或者，像@jpp建议的稍微短一点：

r = sum(c[val] == 'fruit' for val in v)

或者，如果你需要速度，比如@Patrick Artner：

ctag = { k: v for k, v in c.items() if v == 'fruit' }
r = sum(1 for val in v if val in ctag)

说明：每次访问值并进行比较是非常昂贵的。创建一个所有键都是结果的新字典，然后忽略这些值，这样更便宜。这比使用集合要好，因为集合是使用搜索复杂度为OlogN的平衡树实现的，而DICT是使用搜索复杂度为O1的hashmaps实现的，只要映射中的项目数不超过内部容量太多…

请尝试：

r = sum(1 for val in v if c[val] == 'fruit')

或者，像@jpp建议的稍微短一点：

r = sum(c[val] == 'fruit' for val in v)

或者，如果你需要速度，比如@Patrick Artner：

ctag = { k: v for k, v in c.items() if v == 'fruit' }
r = sum(1 for val in v if val in ctag)

说明：每次访问值并进行比较是非常昂贵的。创建一个所有键都是结果的新字典，然后忽略这些值，这样更便宜。这比使用集合要好，因为集合是使用搜索复杂度为OlogN的平衡树实现的，而DICT是使用搜索复杂度为O1的哈希映射实现的，只要映射中的项数不超过内部容量太多…

这里有一个解决方案：

res = sum(c[value] == 'fruit' for value in v)

这是因为bool被视为int的一个子类，即布尔真/假等价于整数1/0。

这里有一个解决方案：

res = sum(c[value] == 'fruit' for value in v)

---

这是因为bool被视为int的一个子类，即布尔真/假等价于整数1/0。

类似于@Daniel Trugman的答案，但稍微简单一些：

r = sum(1 for value in c.values() if value == 'fruit')

---

类似于@Daniel Trugman的回答，但稍微简单一点：

r = sum(1 for value in c.values() if value == 'fruit')

---

为什么会有5个输出？为什么会有5个输出？在dict中查找比在集合中查找更快。因此，您的解决方案似乎比原来的解决方案效率低。@DanielTrugman通过只将属于水果的键收集到集合中，查找不需要计算字典值-dict中的每个项都被触摸一次，setlookup为O1-如果使用dict，则需要访问香蕉：水果两次。为什么您认为集合查找比dict查找慢？dict.keys是一个集合。据我所知，dict访问是使用hashmap实现的，而set是I

---

使用平衡树实现。第一个是O1，第二个是Ologn。对于这些数据集来说，这是胡说八道，但对于较大的数据集来说，这是相关的。dict.keys返回一个集合这一事实只是表示dict中所有键集合的一种方便方式，它与底层实现无关。@DanielTrugman是的，你是对的-你的性能更好-添加measurements@PatrickArtner，首先，我想说我很喜欢这条线，多亏了你：第二，因为你是对的，而且缓慢的部分是访问值，所以我为像你这样的面向性能的程序员改进了我的实现！再次感谢：在dict中查找比在集合中查找更快。因此，您的解决方案似乎比原来的解决方案效率低。@DanielTrugman通过只将属于水果的键收集到集合中，查找不需要计算字典值-dict中的每个项都被触摸一次，setlookup为O1-如果使用dict，则需要访问香蕉：水果两次。为什么您认为集合查找比dict查找慢？keys是一个集合。据我所知，dict访问是使用hashmap实现的，而set是使用平衡树实现的。第一个是O1，第二个是Ologn。对于这些数据集来说，这是胡说八道，但对于较大的数据集来说，这是相关的。dict.keys返回一个集合这一事实只是表示dict中所有键集合的一种方便方式，它与底层实现无关。@DanielTrugman是的，你是对的-你的性能更好-添加measurements@PatrickArtner，首先，我想说我很喜欢这条线，多亏了你：第二，因为你是对的，而且缓慢的部分是访问值，所以我为像你这样的面向性能的程序员改进了我的实现！再次感谢：