10
votes

Trouver des listes vides dans la liste imbriquée des listes

Compte tenu d'une liste arbitraire imbriquée, comment puis-je trouver si une liste contient des listes vides? Considérez l'exemple suivant:

myList <- liste (liste ("foo", "bar", "baz", liste (liste ())))

J'ai essayé Rapply , mais qui passe à travers des listes. Bien que je puisse utiliser nul , je devrais connaître le niveau de nidification à l'avance. Pour cet exercice, je n'ai pas besoin de savoir où se trouve la liste (bien que ce soit un bonus), j'ai juste besoin d'un moyen de détecter s'il y en a un.


                        
                        
                            
                                                                    r
                                                                    nested-lists
                                                            
                        
                                                    
                            
                            
                                1 commentaires
                                
                                                                            @Mrflick Oui, c'est ce que je suis après



                                    
                    3 Réponses :
                    
                                            
                            
                                
                                    9
 votes
                                
                            
                            
                                
                                     Qu'en est-il d'une fonction comme celle-ci  xxx  
 essentiellement, nous créons une fonction récursive pour rechercher des listes de longueur 0.   xxx  
 et Voici une modification pour trouver l'index de la liste vide   xxx  
 ceci doit renvoyer un vecteur de l'index que vous pouvez utiliser pour trouver la liste vide. Par exemple   xxx  
 si le premier paramètre lui-même est une liste vide, il retournera 0   xxx  
 et s'il y a Pas de liste vide, il devrait renvoyer un vecteur vide   xxx                                  

                                                                    
                                    
                                    
                                        7 commentaires
                                        
                                                                                            
                                                    J'ai pensé que la récursion serait un bon moyen de le résoudre. Une légère modification - j'utiliserais  vapply (x, has_empty_list, logique (1)) .                                                

                                                
                                                                                            
                                                    @ Sebastian-C a ajouté une autre fonction pour trouver la liste manquante aussi                                                
                                                
                                                                                            
                                                    Merci @mrflick. Celui à trouver des listes vides est génial, mais celui de trouver des listes vides est un peu plus délicieux. Il semble avoir des problèmes avec plusieurs listes vides (il semble que la plus imbriquée).                                                
                                                
                                                                                            
                                                    Vrai. Si vous voulez que cela fasse autre chose, vous devez décrire le comportement attendu.                                                
                                                
                                                                                            
                                                    Une question, pourquoi  is.vector (x) &! Est.atomic (x)  au lieu de  is.list (x) ?                                                

                                                
                                                                                            
                                                     est.Liste  fonctionnerait probablement aussi bien. C'est plutôt curieusement la première chose qui me vint à l'esprit.                                                

                                                
                                                                                            
                                                    Juste un commentaire mineur, je suppose que vous pouvez remplacer  sapply (m, longueur)  avec  longueurs (m)  (pour les versions R récentes)                                                

                                                
                                                                                    

                                    

                                                            

                        

                        
                                            
                            
                                
                                    5
 votes
                                
                            
                            
                                
                                     Une autre option pratique à utiliser avec la liste imbriquée consiste à utiliser  data.tree  package:  xxx                                  


                                                                    
                                    
                                    
                                        1 commentaires
                                        
                                                                                            
                                                    semble être assez lent.                                                
                                                
                                                                                    
                                    
                                                            

                        

                        
                                            
                            
                                
                                    0
 votes
                                
                            
                            
                                
                                     Une autre approche consiste à utiliser  rrrapply  code> dans le  rrrapply  code> -Package (une extension de la base-  rrrapply  code>):  xxx  Pré> 
 Il est simple de mettre à jour l'appel ci-dessus pour renvoyer les vecteurs d'index de toutes les listes vides:  p>  xxx  pré> 
 ici, nous utilisons le  .xpos  code> argument qui évalue à la position de l'élément de liste actuelle sous évaluation.  p> 
  Notez que cela renvoie automatiquement toutes les positions de liste de vide à la place d'un seul:  P> 
mylist2 <- list(list("foo", list(), "baz", list(list())))

rrapply(mylist2,
        classes = "list",
        condition = function(x) length(x) < 1,
        f = function(x, .xpos) .xpos, 
        how = "flatten"
)
#> [[1]]
#> [1] 1 2
#> 
#> [[2]]
#> [1] 1 4 1

## using MrFlick's find_empty_list function
find_empty_list(mylist2)
#> [1] 1 4 1

                                

                                                                    
                                    
                                    
                                        0 commentaires