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.

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.

"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"
        }
    ]
]



#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

Recommended Posts

Type de valeur d'un dictionnaire avec une structure compliquée (tri par structure de clé par valeur profonde)
Trier par valeur de valeur de type dict
Le tri du tableau de tuple peut être accéléré en spécifiant une clé (Python)
Extension du dictionnaire python par argument
Remplacez la valeur du dictionnaire par Python> update ()
Essayez l'apprentissage profond de la génomique avec Kipoi
Erreur de clé de dictionnaire → Résoudre avec la clé dans le dictionnaire
Analyse émotionnelle des tweets avec apprentissage en profondeur
Rechercher une clé de dictionnaire pythondict par expression régulière
[proxy https avec squid] Résolvez l'erreur qui s'est produite avec une clé dh trop petite