value - sort dictionary list python




Como posso classificar um dicionário por chave? (17)

Acho que a coisa mais fácil é classificar o dict por key e salvar a chave classificada: par de valores em um novo dict.

dict1 = {'renault': 3, 'ford':4, 'volvo': 1, 'toyota': 2} 
dict2 = {}                  # create an empty dict to store the sorted values
for key in sorted(dict1.keys()):
    if not key in dict2:    # Depending on the goal, this line may not be neccessary
        dict2[key] = dict1[key]

Para tornar mais claro:

dict1 = {'renault': 3, 'ford':4, 'volvo': 1, 'toyota': 2} 
dict2 = {}                  # create an empty dict to store the sorted     values
for key in sorted(dict1.keys()):
    if not key in dict2:    # Depending on the goal, this line may not be  neccessary
        value = dict1[key]
        dict2[key] = value

Qual seria uma boa maneira de ir de {2:3, 1:89, 4:5, 3:0} para {1:89, 2:3, 3:0, 4:5} ?
Eu verifiquei algumas mensagens, mas todas usam o operador "classificado" que retorna as tuplas.


Aqui encontrei uma solução mais simples para ordenar o python dict por key usando pprint . por exemplo.

>>> x = {'a': 10, 'cd': 20, 'b': 30, 'az': 99} 
>>> print x
{'a': 10, 'b': 30, 'az': 99, 'cd': 20}

mas enquanto estiver usando pprint, ele retornará o dict ordenado

>>> import pprint 
>>> pprint.pprint(x)
{'a': 10, 'az': 99, 'b': 30, 'cd': 20}

Da documentação da biblioteca de collections do Python :

>>> from collections import OrderedDict

>>> # regular unsorted dictionary
>>> d = {'banana': 3, 'apple':4, 'pear': 1, 'orange': 2}

>>> # dictionary sorted by key -- OrderedDict(sorted(d.items()) also works
>>> OrderedDict(sorted(d.items(), key=lambda t: t[0]))
OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)])

>>> # dictionary sorted by value
>>> OrderedDict(sorted(d.items(), key=lambda t: t[1]))
OrderedDict([('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)])

>>> # dictionary sorted by length of the key string
>>> OrderedDict(sorted(d.items(), key=lambda t: len(t[0])))
OrderedDict([('pear', 1), ('apple', 4), ('orange', 2), ('banana', 3)])

Em Python 3.

>>> D1 = {2:3, 1:89, 4:5, 3:0}
>>> for key in sorted(D1):
    print (key, D1[key])

1 89
2 3
3 0
4 5

Eu venho com a ordenação por ordem de linha única.

>> a = {2:3, 1:89, 4:5, 3:0}
>> c = {i:a[i] for i in dict.fromkeys(sorted([i for i in a]))}
>> print(c)
{1: 89, 2: 3, 3: 0, 4: 5}
[Finished in 0.4s]

Espero que isso seja útil.


Existe uma maneira fácil de classificar um dicionário.

De acordo com sua pergunta

A solução é :

c={2:3, 1:89, 4:5, 3:0}
y=sorted(c.items())
print y

(Onde c, é o nome do seu dicionário.)

Este programa fornece a seguinte saída:

[(1, 89), (2, 3), (3, 0), (4, 5)]

como você queria.

Outro exemplo é:

d={"John":36,"Lucy":24,"Albert":32,"Peter":18,"Bill":41}
x=sorted(d.keys())
print x

Dá a saída: ['Albert', 'Bill', 'John', 'Lucy', 'Peter']

y=sorted(d.values())
print y

Dá a saída: [18, 24, 32, 36, 41]

z=sorted(d.items())
print z

Dá a saída:

[('Albert', 32), ('Bill', 41), ('John', 36), ('Lucy', 24), ('Peter', 18)]

Assim, alterando-o em chaves, valores e itens, você pode imprimir como o que você queria.Espero que isso ajude!


Há vários módulos Python que fornecem implementações de dicionário que mantêm automaticamente as chaves em ordem de classificação. Considere o módulo sortedcontainers , que é sortedcontainers do sortedcontainers puro-Python e fast-as-C. Há também uma comparação de desempenho com outras opções populares comparadas entre si.

Usar um dict ordenado é uma solução inadequada se você precisar constantemente adicionar e remover pares chave / valor enquanto também itera.

>>> from sortedcontainers import SortedDict
>>> d = {2:3, 1:89, 4:5, 3:0}
>>> s = SortedDict(d)
>>> s.items()
[(1, 89), (2, 3), (3, 0), (4, 5)]

O tipo SortedDict também suporta pesquisas de localização indexadas e exclusão que não é possível com o tipo de dict interno.

>>> s.iloc[-1]
4
>>> del s.iloc[2]
>>> s.keys()
SortedSet([1, 2, 4])

O dicionário Python não foi ordenado antes do Python 3.6. Na implementação do CPython do Python 3.6, o dicionário mantém a ordem de inserção. Do Python 3.7, isso se tornará um recurso de idioma.

Se você quiser classificar um ditado aninhado, incluindo o sub-dit dentro, você pode fazer:

test_dict = {'a': 1, 'c': 3, 'b': {'b2': 2, 'b1': 1}}

def dict_reorder(item):
    return {k: sort_dict(v) if isinstance(v, dict) else v for k, v in sorted(item.items())}

reordered_dict = dict_reorder(test_dict)

https://gist.github.com/ligyxy/f60f0374defc383aa098d44cfbd318eb


Os dicionários padrão do Python não são ordenados. Mesmo se você classificasse os pares (chave, valor), você não seria capaz de armazená-los em um dict maneira a preservar a ordem.

A maneira mais fácil é usar OrderedDict , que lembra a ordem em que os elementos foram inseridos:

In [1]: import collections

In [2]: d = {2:3, 1:89, 4:5, 3:0}

In [3]: od = collections.OrderedDict(sorted(d.items()))

In [4]: od
Out[4]: OrderedDict([(1, 89), (2, 3), (3, 0), (4, 5)])

Não importa a maneira como od é impresso; vai funcionar como esperado:

In [11]: od[1]
Out[11]: 89

In [12]: od[3]
Out[12]: 0

In [13]: for k, v in od.iteritems(): print k, v
   ....: 
1 89
2 3
3 0
4 5

Python 3

Para usuários do Python 3, é necessário usar o .items() vez de .iteritems() :

In [13]: for k, v in od.items(): print(k, v)
   ....: 
1 89
2 3
3 0
4 5

Os ditos de Python são não ordenados. Geralmente, isso não é um problema, já que o caso de uso mais comum é fazer uma pesquisa.

A maneira mais simples de fazer o que você quer seria criar um collections.OrderedDict inserindo os elementos na ordem de classificação.

ordered_dict = collections.OrderedDict([(k, d[k]) for k in sorted(d.keys())])

Se você precisar iterar, como os outros acima sugeriram, a maneira mais simples seria iterar as chaves classificadas. Exemplos-

Imprimir valores classificados por chaves:

# create the dict
d = {k1:v1, k2:v2,...}
# iterate by keys in sorted order
for k in sorted(d.keys()):
    value = d[k]
    # do something with k, value like print
    print k, value

Obter lista de valores classificados por chaves:

values = [d[k] for k in sorted(d.keys())]

Para python3.6 +, isso é feito facilmente com:

>>> d = {2:3, 1:89, 4:5, 3:0}
>>> dict(sorted(d.items()))
{1: 89, 2: 3, 3: 0, 4: 5}

Se você tem um dict, por exemplo:

not_ordered_dict = {5 : "5555", 9 : "9999", 1 : "1111"}

ordered_dict = {}

for key in sorted(not_ordered_dict):
    ordered_dict[key] = not_ordered_dict[key]   

Solução mais simples é que você deve obter uma lista de chave dict é ordem classificada e, em seguida, iterar sobre dict. Por exemplo

a1 = {'a':1, 'b':13, 'd':4, 'c':2, 'e':30}
a1_sorted_keys = sorted(a1, key=a1.get, reverse=True)
for r in a1_sorted_keys:
    print r, a1[r]

A seguir será a saída (ordem decrescente)

e 30
b 13
d 4
c 2
a 1

Uma comparação de tempo entre os dois métodos em 2.7 mostra que eles são virtualmente idênticos:

>>> setup_string = "a = sorted(dict({2:3, 1:89, 4:5, 3:0}).items())"
>>> timeit.timeit(stmt="[(k, val) for k, val in a]", setup=setup_string, number=10000)
0.003599141953657181

>>> setup_string = "from collections import OrderedDict\n"
>>> setup_string += "a = OrderedDict({1:89, 2:3, 3:0, 4:5})\n"
>>> setup_string += "b = a.items()"
>>> timeit.timeit(stmt="[(k, val) for k, val in b]", setup=setup_string, number=10000)
0.003581275490432745 

Vocês estão fazendo coisas complicadas ... é muito simples

from pprint import pprint
Dict={'B':1,'A':2,'C':3}
pprint(Dict)

A saída é:

{'A':2,'B':1,'C':3}

from operator import itemgetter
# if you would like to play with multiple dictionaries then here you go:
# Three dictionaries that are composed of first name and last name.
user = [
    {'fname': 'Mo', 'lname': 'Mahjoub'},
    {'fname': 'Abdo', 'lname': 'Al-hebashi'},
    {'fname': 'Ali', 'lname': 'Muhammad'}
]
#  This loop will sort by the first and the last names.
# notice that in a dictionary order doesn't matter. So it could put the first name first or the last name first. 
for k in sorted (user, key=itemgetter ('fname', 'lname')):
    print (k)

# This one will sort by the first name only.
for x in sorted (user, key=itemgetter ('fname')):
    print (x)

l = dict.keys()
l2 = l
l2.append(0)
l3 = []
for repeater in range(0, len(l)):
    smallnum = float("inf")
    for listitem in l2:
        if listitem < smallnum:
            smallnum = listitem
    l2.remove(smallnum)
    l3.append(smallnum)
l3.remove(0)
l = l3

for listitem in l:
    print(listitem)




dictionary