小编Aso*_*cia的帖子

我这里有 2 个列表：

list1 = [happy, sad, grumpy, mad]
list2 = [2, 5, 6, 9]

我想让数字分配给情绪？（happy 等于 2，sad 等于 5，以此类推）。理想情况下，我想这样做，以便您可以比较 list1 中的项目，例如：

if happy > sad:
    print ("you are happy")

我想让这段代码尽可能高效，所以我不想分别为 list1 中的每个变量分配一个数字。

我有一个如下所示的数据列表结构：

[('a', 1),('a', 2),('b', 0),('b', 1),('c', 0)]

如果第一项相同，我正在尝试组合元组的第二个值。（并删除重复项）

最终结果应该是：

[('a', 3),('b', 1),('c', 0)]

我的方法是创建第二个空列表并检查列表中是否存在第一个元素，如果不存在则追加。否则循环遍历第二个列表，并将迭代中 [1] 项的值从第一个列表添加到第二个列表中的 [1] 项。我无法让我的概念发挥作用。如果有人有更有效的解决方案，我也愿意接受建议。

secondList = []
for item in firstList:
    if (secondList.count(item[0]]):
      secondList.append(item)
    else:
      for item_j in secondList:
        if (item_j[0] == item[0]):
          item_j[1] = item_j[1]+item[1]

我正在编写一个程序来解析这样的列表。

['ecl:gry', 'pid:860033327', 'eyr:2020', 'hcl:#fffffd', 'byr:1937', 'iyr:2017', 'cid:147', 'hgt:183cm']

我想把这个列表变成我在这里完成的键值对的字典：

keys = []
values = []

for string in data:
    pair = string.split(':')
    keys.append(pair[0])
    values.append(pair[1])

zipped = zip(keys, values)
self.dic = dict(zipped)
print(self.dic)

我知道我可以使用列表理解在这样的时间制作列表之一

keys = [s.split(':')[0] for s in data]
values = [s.split(':')[1] for s in data]

这需要两个循环，所以第一个代码示例会更好，但是有没有办法使用一个生成器生成两个列表并解包，然后将两者压缩在一起？

我的关注涉及我的一个变量，它在列表中包含元组，如下所示。

test = [(['a','b','c'],[3,2,5]),(['d','e','f'],[1,5,6]),(['g','h','j'],[1,2,4])]

例如，我正在尝试获取列表的第二个元组元素的总和，[3,2,5]并根据该总和对它们进行排序。所以求和的结果应该是。

result1 = [(['a','b','c'],[10]),(['d','e','f'],[12]),(['g','h','j'],[7])]

那么我预期的最终结果应该按降序排序。

result = [['d','e','f'],['a','b','c'],['g','h','j']]

文本文件：

Animals
  Tiger
  Lion
    Cat
      Mice
Birds
  Parrot
  Peacock
    Hen
      chicken
Reptiles
Mammals

我想根据缩进动态分离单词并将其存储在不同的列表中

预期输出：

a=['Animals','Birds','Reptiles','Mammals']
b=['Tiger','Lion','Parrot','Peacock']
c=['Cat','Hen']
d=['Mice','Chicken']

这是我的代码：

a=[]
b=[]
c=[]
d=[]
for i in text:
  indent = len(i)-len(i.lstrip())
  if indent == 0:
    a.append(i)
  if indent == 2:
    b.append(i)
  if indent == 4:
    c.append(i)
  if indent == 6:
    d.append(i)        

它提供了预期的输出，但我希望它采用动态方法。

我正在做一个项目，并且有多个字典，这些字典都由相同的长度组成，也用相同的键填充，每个值都是不同的灰度图片，所以是一个数组。

d1 = {'1' : 'a1' , '2' : 'a2' , '3' : 'a3'} 
d2 = {'1' : 'b1' , '2' : 'b2' , '3' : 'b3'} 
d3 = {'1' : 'c1' , '2' : 'c2' , '3' : 'c3'}

你知道如何使用这些字典来构建一个包含所有图片的大字典，但键从 1 开始到 n 结束，n 是图片的数量吗？图片的顺序无关紧要。

像这样：

d_new = { ' 1 ' : ' a1 ' , ' 2 ' : ' a2 ' , ' 3 ' : ' a3 ' , ' 4 ' : ' b1 …

实现这一目标的最佳方法是什么：

user_input = ">"

if 2 user_input 3:
    print("yes")

我想避免写另一个if声明：

if user_input == ">":
    if 2 > 3:
        print("yes")

我正在尝试获取数组中出现频率最高的两个元素的数量。例如，在列表['aa','bb','cc','dd','bb','bb','cc','ff']中，最频繁的应该是3（'bb' 在数组中出现的次数）和第二个最频繁的2（'cc' 在数组中出现的次数）。

我试过这个：

max = 0
snd_max = 0
for i in x:
 aux=x.count(i)
 if aux > max
   snd_max=max
   max=aux

print(max, snd_max)

但我怀疑是否有更简单的方法？

我想知道是否可以从 Haskell 中的可迭代事物中创建变量。我在搜索时发现了这个，但我无法适应我的情况。也许这是不可能的，或者我错过了一些东西，因为我是初学者。基本上，我想知道在 Haskell 中是否有可能发生这样的事情：

>>> list_of_lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> a, b, c = list_of_lists
>>> print(a)
[1, 2, 3]

我有一系列嵌套循环，循环遍历多个 excel 文件，并根据对内容的检查，将内容添加到数据框列表中。

在某种情况下，我需要跳出当前循环，而不是添加到数据框列表中，并继续解析下一个 excel。不幸的是，我无法弄清楚如何设置循环以完成我想要的行为。

目前代码如下。我添加了解释我正在寻找什么行为的评论。

for name in folder_names:
path = rf'I:\PATH\{name}'
file_list = [f for f in glob.glob(path+"/*.xlsx")]
df_list = []
for f in file_list: #if a break event is triggered, I need to return here.
    xl = pd.ExcelFile(f)
    if len(xl.sheet_names) == 1:
        wb = load_workbook(f, data_only = True)
        sh = wb.worksheets[0]
        ColNames = {}
        Current  = 0
        for COL in sh.iter_cols(1, sh.max_column):
            ColNames[COL[0].value] = Current
            Current += 1
        for row_cells in sh.iter_rows(min_row=2, max_row=len(sh['D'])):
            if row_cells[ColNames['XXXX ID']].fill.start_color.index != …