Type de valeur d'un dictionnaire avec une structure compliquée (tri par structure de clé par valeur profonde)

Il est également appelé tri par valeur complexe (de quel type s'agit-il?)

--Cas où la valeur du dictionnaire spécifié a une structure --Trier la structure sous la clé par une valeur dans la valeur du dictionnaire complexe. --Clé Trier en conservant la structure ci-dessous.

• Faites attention si la valeur spécifiée est une chaîne de caractères ou une valeur numérique. (Jouez "" et Aucun à l'avance ou réglez-le sur 0)

Par exemple, il existe une telle structure de dictionnaire

Adic = {
↓ Ici ou ↓ Je veux trier ici
            'C134':{"price":30,"sales":"1000","profit":200 ,"alist":[110,20,30 ,50]}, 
            'C623':{"price":80,"sales":"100" ,"profit":6   ,"alist":[100,10,30 ,50]},
            'C430':{"price":70,"sales":"5000","profit":1000,"alist":[160,11,120,6]},
            'C115':{"price":10,"sales":"2400","profit":40  ,"alist":[80 , 1,10 ,6]}
        }

Le point est l'expression de la valeur de retour de l'expression lambda

Spécifiez la valeur que vous souhaitez trier dans la structure Value avec sorted () (dans ce cas, x [1] est le type de dictionnaire interne). 　key = lambda x: x[1]['profit']

Doit suivre si la valeur que vous souhaitez spécifier est plus profonde (x [1] ['alist'] correspond à la liste, spécifiez la seconde) 　key = lambda x: x[1]['alist'][1]

Fondamentalement, cela

dic = {'A':10000, 'B':2010, 'C':5, 'D':500} res = sorted (dic.items (), key = lambda x: x [1]) #value spécification res = sorted (pathD.items (), key = lambda x: int (x [0])) # Au fait, trier par clé lorsque key est str

Lambda peut être lu si vous le considérez comme une abréviation pour une fonction.

def lambda(x): return 2x --> lambda x:2x

Dans le type dict, le taple (clé, valeur) saute dans x, donc 0 ou 1 est spécifié.

import collections
from prettyprint import pp, pp_str #pp est votre préféré alors veuillez en avoir un officiel récemment
from collections import OrderedDict

Adic = {
            #Trier ces 4 colonnes par valeur valeur quelque part dans valeur
            'C134':{"price":30,"sales":"1000","profit":200 ,"alist":[110,20,30,50]}, 
            'C623':{"price":80,"sales":"100" ,"profit":6   ,"alist":[100,10,30,50]},
            'C430':{"price":70,"sales":"5000","profit":1000,"alist":[160,11,120,6]},
            'C115':{"price":10,"sales":"2400","profit":40  ,"alist":[80,1,10,6]}
        }

#On a l'impression que x est un taple du dictionnaire. Spécifiez la valeur en traçant à travers le taple
#Notez qu'il sera retourné dans la liste
#Toutes les désignations par ordre décroissant:reverse=True
pp('Trier par profit')
res1 = sorted(Adic.items(), key=lambda x: x[1]['profit'],reverse=True)
pp(res1)

pp('Trier par ventes (chaîne de caractères convertie en int)')
res2 = sorted(Adic.items(), key=lambda x: int(x[1]['sales']),reverse=True)
pp(res2)

pp('Trier par la deuxième liste')
res3 = sorted(Adic.items(), key=lambda x: x[1]['alist'][1],reverse=True)
pp(res3)

pp('tri par clé (tirez le numéro avec 3 de l'arrière. Lorsque 3 chiffres ou fixe)')
res4 = sorted(Adic.items(), key=lambda x: int (x[0][-3]) ,reverse=True)#En quelque sorte même sans int
pp(res4)

pp('tri par clé (premier caractère"C"Couper)')
res5 = sorted(Adic.items(), key=lambda x: int(x[0].lstrip('C')) ,reverse=True)
pp(res5)

pp('Trier par profit 2')
res6 = OrderedDict(sorted(Adic.items(), key=lambda x: x[1]['profit'],reverse=True))
print(res6)#S'il s'agit de pp, la commande sera rompue.
pp(type(res6))

résultat

Je ne collerai que le cas de profit pour le moment. Les valeurs de profit, 1000, 200, 40, 6 peuvent être triées par structure dans l'ordre décroissant! En termes de clé, l'ordre structurel est c430, c134, c115, c623.

• OrderedDict est incompatible avec l'ancienne technologie pp. *

"Trier par profit"
[
    [
        "C430", 
        {
            "alist": [
                160, 
                11, 
                120, 
                6
            ], 
            "price": 70, 
            "profit": 1000, 
            "sales": "5000"
        }
    ], 
    [
        "C134", 
        {
            "alist": [
                110, 
                20, 
                30, 
                50
            ], 
            "price": 30, 
            "profit": 200, 
            "sales": "1000"
        }
    ], 
    [
        "C115", 
        {
            "alist": [
                80, 
                1, 
                10, 
                6
            ], 
            "price": 10, 
            "profit": 40, 
            "sales": "2400"
        }
    ], 
    [
        "C623", 
        {
            "alist": [
                100, 
                10, 
                30, 
                50
            ], 
            "price": 80, 
            "profit": 6, 
            "sales": "100"
        }
    ]
]

• Au début, je l'ai fait avec python3.5, mais lors de la vérification, python2.7
• Je suis désolé de ne pas avoir unifié les citations.

#Remarques
#Relation entre les expressions lambda et les fonctions
def func(x):
    return x ** 2

func = lambda x: x ** 2
func(2) #4

#traitement de chaîne
string.strip()#Supprimer tous les sauts de ligne vides
string.strip("\n\r")#Supprimer les appels aux deux extrémités
string.rstrip("\n\r")#Supprimer ce qui frappe avec un ketsu