-1
votes

Extraire des valeurs uniques de Pandas Cadre par ligne et ajoutez-les à une nouvelle colonne

J'ai le problème suivant que je veux résoudre:

Disons que j'ai un Datafram qui ressemble à ce xxx

Je cherche un moyen de trouver un moyen de trouver Les valeurs uniques dans chaque ligne et les ajoutent à une autre colonne tout en laissant tomber toutes les nans.

La sortie doit ressembler à ce qui suit: xxx

Toute suggestion sur Comment résoudre ceci?


3 commentaires

Quel est le problème, exactement? Avez-vous essayé quelque chose, effectué des recherches? Overflow de pile n'est pas un service de rédaction de code gratuit. Voir: Tour , Comment demander < / a>, centre d'aide , meta.stactverflow.com/questions/261592/... . Vous n'avez même pas partagé les données dans un format qui est quelque peu pratique à utiliser. Où est-ce que ce Dataframe vient en premier lieu? N'y a-t-il aucun moyen de le créer correctement / le changer à l'avance?


J'ai fait de nombreuses recherches, mais je n'ai trouvé aucun résultat prometteur pour ce type de problème d'OS, j'ai décidé de poser cette question. Bien sûr, la question pourrait être approuvée, mais par la quantité de réponses donnée, le problème semblait être entièrement compréhensible sans inclure des informations inutiles


n'a trouvé aucun résultat prometteur pour ce type de problème Stackoverflow.com/Questtions/19377969/... , Stackoverflow.com/questions/33158417/... .


4 Réponses :


0
votes

Utilisation: xxx

Nous pouvons également utiliser: xxx


0 commentaires

2
votes
# Convert each column dtype to str: x.astype(str)
# Null dtype became 'nan' so remove it: replace('nan', "")
# Concatenate each row entry: sum()
# Convert it to set to delete duplicate entries 
# Convert it to list to concatenate with "," as a string

df_new = df.apply(lambda x: ",".join(list(set(((x.astype(str)).sum()).replace('nan', "")))), axis=1)



1 commentaires

J'ai testé votre réponse et la modifiait à df_new = df.apply (lambda x: "," .join (liste (défini (x.dropna (). Astype (str)))), axis = 1) pour obtenir les résultats souhaités



2
votes

Voici une tentative combinant définir et dans un lambda : xxx

sortie: < / p> xxx


0 commentaires

0
votes

Un long chemin à faire

dee = dict(tuple(df.groupby('Match')))
tmp = []
tmp2 = []
for k,v in dee.items():

    tmp.append(k)

    for i in v.columns.tolist():
        tmp3 = []
        #print(i)
        tmp3.append(str(v[i]))
    tmp2.append(tmp3)
new = pd.DataFrame({'Match':tmp,'List':tmp2})


8 commentaires

Je pense que vous ne voulez certainement pas de boucles imbriquées!


J'entends cela souvent, et je suppose que cela en raison de la mémoire et du temps? Les développeurs n'utilisent pas souvent des boucles imbriquées? J'ai fait un chèque de temps sur cette version du code à l'aide d'une ligne 27000 par 26 jumelles de colonne. A pris 1,34 seconde. Comparera à l'une des autres méthodes postées.


Ce n'est pas que ce soit le mal en soi et c'est une réponse parfaitement valide à la question. Il est plus que cela devrait être évité s'il y a une meilleure solution disponible. Surtout sur un site comme Stackoverflow, qui est censé être un référentiel de connaissances plus qu'un service d'aide de code. Considérez un cas où quelqu'un rencontre une situation similaire l'année prochaine et trouve cette question. Seul leur jeu de données est de 27 000 000 rangées et 500 colonnes et il existe des exigences de temps de traitement pour leur entreprise. Maintenant une approche vectorisée qui prend 2 ms vs 50ms sur des données plus petites est de plus en plus préférable.


@ G.anderson j'ai essayé la réponse postée par l'utilisateur Isabella. Sur ma machine, j'ai eu un temps plus rapide avec ma méthode, existe-t-il une gamme où une méthode fonctionne mieux que l'autre? Pourrait faire pour une page de blog intéressante `1.17 S ± 182 ms par boucle (moyenne ± STD. DEV. DEV. DE 7 RUNS, 1 boucle chacune) 4,69 s ± 174 ms par boucle (moyenne ± STD. Dev. De 7 roues, 1 boucle chacun) `


Le temps d'exécution réel va fortement dépendre de la machine et de l'environnement, mais le meilleur test est généralement de créer des jeux de données plus gros et plus gros (et plus diversifiés) et de voir si une méthode échelle mieux qu'un autre. Je dirai que fonctionnant sur un dict comme vous l'avez fait est probablement mieux que la même itération sur le Dataframe avec, par exemple, iTerrows . Pour ma machine, votre solution exécute 50,1 ms ± 12,9 ms et df.iloc [:, 1:]. Appliquer (Lambda x: Set ([i car i pour i STR ( i)! = 'nan']), axis = 1) exécute dans 2.38 ms ± 134 μs


Un autre point à mentionner: Appliquer (Axis = 1) couplé avec [i pour i in ...] est en fait une boucle imbriquée , il est simplement optimisé sous le capot utilisant des méthodes intégrées pour fonctionner plus rapidement sur les structures de données sous-jacentes. Une bonne ressource dans une pile débordement question: sont Pour les boucles dans les pandas vraiment mauvais? Quand devrais-je m'occuper?


@ G.anderson intéressant, merci pour l'aperçu, il y a beaucoup de choses à en apprendre de ce genre de python


Toujours plus à apprendre! C'est la beauté de ce site. à votre santé!