Нужно взять список значений из словаря и вычесть это значение из общего количества значений

Question

Я понимаю, что название может вводить в заблуждение, поэтому позвольте мне объяснить.

Я беру информацию из списка, который выглядит как L = [21.123, 22.123, 23.123, 21.123] Я удаляю десятичные дроби и сортирую список по возрастанию. Я также изменить его на словарь с вхождениями, который выглядит как newlist = {23: 1, 22: 1, 21: 2}

Что мне нужно сделать, это составить список ключей и значений, которые я могу сделать. Это дает мне два списка, [23, 22, 21] и [1, 1, 2] один для значений и один для вхождений. Мне нужно превратить мой список вхождений в число вхождений, которые равны или меньше соответствующего ключа.

Я бы хотел, чтобы мой список выглядел как [23, 22, 21] (что легко сделать) и [4, 3, 2], потому что 4 раза составляют 23 секунды или меньше, 3 раза - 22 секунды или меньше, а 2 - время составляет 21 секунду или меньше.

Я почти уверен, что мне нужен цикл for для перебора всех значений частоты, изменения этого значения на общее количество раз, введенных в список, и вычитания любого значения больше, чем оно. Я не знаю, как это сделать, поэтому любая помощь будет принята с благодарностью.

Answer 1

Я нашел свое собственное решение, которое кажется относительно простым.Код выглядит как

counter = 0
print(valuelist)
for i in valuelist:
    print(int(solves - counter))
    counter = counter + i
    redonevalues.append(solves - counter + 1)

Он принимает мои значения, переходит к первому, добавляет вхождения в счетчик, вычитает счетчик из решений и добавляет 1 для выравнивания

Answer 2

Вам нужен словарь, в котором для каждого элемента в ваших данных ключом является округленное значение (int(item)), а значением является количество элементов, которые меньше или равны этому округленному значению.

A словарное понимание (в сочетании с списком ) может сделать это:

data = [21.123, 22.123, 23.123, 21.123]

aggregate = {
    item: len([n for n in data if int(n) <= item])
    for item in set(map(int, data))
}

print(aggregate)  # -> {21: 2, 22: 3, 23: 4}

, которая представляет собой форму единственного оператора для написания такого цикла:

aggregate = {}
for item in set(map(int, data)):
    aggregate[item] = len([n for n in data if int(n) <= item])
}

Использование set() делает список уникальным. Таким образом, цикл выполняется только так часто, как это необходимо.

Answer 3

При условии, что вы правильно рассчитываете от [21.123, 22.123, 23.123, 21.123], простой вложенный цикл с промежуточной суммой может сделать все остальное:

from collections import Counter

newlist = {23: 1, 22: 1, 21: 2}

counts = Counter()
for k in newlist:
    for v in newlist:
        if v <= k:
            counts[k] += newlist[v]

print(counts)
# Counter({23: 4, 22: 3, 21: 2})

Вы также можете использовать itertools.product() для сжатия двойных петель в одну:

from itertools import product
from collections import Counter

newlist = {23: 1, 22: 1, 21: 2}

counts = Counter()
for k, v in product(newlist, repeat=2):
    if v <= k:
        counts[k] += newlist[v]

print(counts)
# Counter({23: 4, 22: 3, 21: 2})

Вышеуказанные значения хранятся в collections.Counter(), вы можете получить [4, 3, 2], позвонив по номеру list(counts.values()).

Answer 4

Вот функциональное решение. Незначительно сложная часть представляет собой кумулятивную сумму в обратном направлении, которая возможна при подаче обратного кортежа к itertools.accumulate и последующем обращении результата.

from collections import Counter
from itertools import accumulate
from operator import itemgetter

L = [21.123, 22.123, 23.123, 21.123]

c = Counter(map(int, L))                       # Counter({21: 2, 22: 1, 23: 1})
counter = sorted(c.items(), reverse=True)      # [(23, 1), (22, 1), (21, 2)]
keys, counts = zip(*counter)                   # ((23, 22, 21), (1, 1, 2))

cumsum = list(accumulate(counts[::-1]))[::-1]  # [4, 3, 2]

Ваш желаемый результат сохраняется в keys и cumsum:

print(keys)

(23, 22, 21)

print(cumsum)

[4, 3, 2]