Discussion :

[Bescu]

Bonjour,

le titre ne devant pas être très explicite je précise mon problème du début :

le script sur lequel je suis en train de travailler a pour but :

- de faire une requête dans une base de données (sqlite)
- d'écrire une "fiche" en html avec les éléments récupérés par la requête.

Rien de bien compliqué donc sauf que dans ma base de données il y a des attributs qui ne sont parfois pas renseignés et j'aimerais que ma fiche html ne contienne que les champs pour lesquels des attributs sont renseignés.

exemple :

liste_exemple=[["attribut0","attribut1","","attribut3","",""],["attribut0","attribut1","","attribut3","","attribut5"],["","attribut1","","attribut3","","attribut5"]]

dans cette liste de liste, seuls attribut2 et attribut4 ne sont jamais renseignés.

je cherche à écrire une fonction qui me retournerait les index de ces attributs vides. Ex : a_supprimer=[2,4]

j'y suis parvenu d'une façon pas très propre (voir le code ci-dessous) mais j'aimerais faire une fonction qui marcherait avec n'importe qu'elle liste de liste. Je n'arrive pas à voir comme cela est faisable. avez-vous une idée??

Voici le code actuel :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
liste_exemple=[["attribut0","attribut1","","attribut3","",""],["attribut0","attribut1","","attribut3","","attribut5"],["","attribut1","","attribut3","","attribut5"]]
attrib_list=[]
attribut0,attribut1,attribut2,attribut3,attribut4,attribut5=[],[],[],[],[],[]
for elem in liste_exemple:
    attribut0.append(elem[0])
    attribut1.append(elem[1])
    attribut2.append(elem[2])
    attribut3.append(elem[3])
    attribut4.append(elem[4])
    attribut5.append(elem[5])
attrib_list.append(attribut0)
attrib_list.append(attribut1)
attrib_list.append(attribut2)
attrib_list.append(attribut3)
attrib_list.append(attribut4)
attrib_list.append(attribut5)
 
a_garder=[]
a_supprimer=[]
 
n=0
for list_ind in attrib_list:
    test=''
    for elem in list_ind:
        test=test+elem
    if test != "":
        a_garder.append(n) # colonnes non vides
    else:
        a_supprimer.append(n) # colonnes vides
    n+=1
 
print a_garder,a_supprimer

Merci d'avance!

Bonne après-midi!

[tyrtamos]

Bonjour,

Une solution possible:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
a_supprimer = lambda L: [i for i, elem in enumerate(L) if elem==""]
 
L = ["attribut0","attribut1","","attribut3","",""]
print a_supprimer(L)
[2, 4, 5]

[Bescu]

Merci pour ton aide.

Cependant mon problème est que en "entrée" je n'ai pas une liste "simple" mais une liste de listes d'éléments de type string (comme dans mon exemple).

Et je veux que ma fonction ne me retourne les index pour lesquel chaque liste de ma liste sont vide (2 et 4 dans mon exemple). Je ne sais pas si c'est plus clair?

Merci d'avance,

Maxime

[tyrtamos]

Eh non, je n'ai pas compris.

Le mieux, c'est de donner un exemple:
1- j'ai: [...]
2- je veux: [...]

Et on trouvera!

[Bescu]

Ok ;-)

Donc j'ai une liste (liste_exemple) comprenant plusieurs listes (ici 3 listes), comprenant chacunes 6 éléments de type string :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

liste_exemple=[["attribut0","attribut1","","attribut3","",""],["attribut0","attribut1","","attribut3","","attribut5"],["","attribut1","","attribut3","","attribut5"]]

je veux :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
print a_supprimer
[2,4]

car pour chacune de mes 3 listes qui composent liste_exemple, les index 2 et 4 renvoient à un élément string vide "".

Le code que j'ai mis dans mon premier poste fonctionne, tu peux le lancer tel quel. Le problème est que j'ai besoin d'une fonction qui s'adapte à n'importe qu'elle "liste de listes".

[tyrtamos]

Ok, pour qu'un indice sorte, il faut que la chaine correspondante soit vide dans toutes les sous-listes.

Dans ce cas essaie ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
def indicesvides(L):
    a_supprimer = lambda L: [i for i, elem in enumerate(L) if elem==""]
    sup0 = set(a_supprimer(L[0]))
    for liste in L[1:]:
        sup0 = sup0 & set(a_supprimer(liste))
    return list(sup0)
 
liste_exemple = [["attribut0","attribut1","","attribut3","",""],["attribut0","attribut1","","attribut3","","attribut5"],["","attribut1","","attribut3","","attribut5"]]
 
print indicesvides(liste_exemple)
[2, 4]

J'utilise le type "set" qui donne accès aux fonctions d'ensemble, et l'opérateur '&' (intersection) ne laisse passer que les éléments présents dans les listes.

[plxpy]

Salut

Le problème est que j'ai besoin d'une fonction qui s'adapte à n'importe qu'elle "liste de listes"

Qu'entends-tu par là ?

Ce n'est pas plutôt "une liste de listes de n'importe quel type d'éléments" que tu veux traiter ?

(je dis ça parce que géomaticien => attributs d'objets géographiques => pas les mêmes types)

[Bescu]

Merci tyrtamos ça m'a tout l'air d'être ça mais je n'ai pas le temps d'essayer et de comprendre le code utilisé ce soir, je ferai le retour demain!

Ce n'est pas plutôt "une liste de listes de n'importe quel type d'éléments" que tu veux traiter ?
(je dis ça parce que géomaticien => attributs d'objets géographiques => pas les mêmes types)

Non non la je ne vais traiter que des éléments de type string (ou unicode) ou int donc j'arriverai à adapter le code je pense. Je n'aurais pas d'éléments de type géographique

[plxpy]

alors, qu'entends-tu par "n'importe quelle liste de listes" ?! je ne comprends pas le sens.

D'ailleurs, tu dis bien que tu as des chaines ET des int ! Ce ne sont pas des attributs d'objets que tu traites dans tes listes ?

Ou alors, ton type d'élément est unique dans chaque cas mais tu as des cas où ce sont des int, des cas où ce sont des strings, etc ... et c'est ce que tu appelles "n'importe quel liste de listes". Comme formulation ...

[dividee]

Il y a une fonction parfois très pratique sur les listes de listes, c'est la fonction zip. Elle permet de "transposer" une "matrice", c'est à dire d'inverser les "lignes" et les "colonnes":

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
>>> list_ex = [['a0','a1','','a3','',  ''],
...            ['a0','a1','','a3','','a5'],
...            [  '','a1','','a3','','a5']]
>>> zip(*list_ex)
[('a0', 'a0',   ''),
 ('a1', 'a1', 'a1'),
 (  '',   '',   ''),
 ('a3', 'a3', 'a3'),
 (  '',   '',   ''),
 (  '', 'a5', 'a5')]

(J'ai reformaté la sortie ci-dessus pour clarifier le résultat)

Comme on le voit, le problème revient dès lors à trouver la position des sous-listes qui ne contiennent que des chaînes vides.
En une ligne:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
>>> [i for i,e in enumerate(zip(*list_ex)) if all([x=='' for x in e])]
[2, 4]

[plxpy]

Zut - je vois la réponse de dividee à l'instant. Comme j'en ai écrit une tartine, je poste quand même (et puis, de toute façon, j'aborde d'autres choses

Je reprends.

Je fais l'hypothèse que les sous-listes ont le même nombre d'éléments : dans l'exemple donné c'est le cas et comme ce sont, apparemment, des résultats de requêtes dans une base SQlite, ils correspondent aux mêmes "colonnes" de différents enregistrements.

Si, dans chaque cas, tous les éléments "unitaires" (les éléments des sous-listes de la liste) ont le même type (dans ton exemple, chaine de caractères) il faut, dans la fonction "indicesvides" du code de Tyrtamos, passer un autre paramètre qui est la valeur "vide" pour le type traité (ça tombe bien, en Python, on peut passer tantôt une chaine, tantôt un entier, tantôt un ...)

Ca te permet de changer

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
def indicesvides(L):
    a_supprimer = lambda L: [i for i, elem in enumerate(L) if elem==""]
    ....

en

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
def indicesvides(L,valeur_vide):
    a_supprimer = lambda L: [i for i, elem in enumerate(L) if elem==valeur_vide]
    ....

et de l'appeler de cette façon :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
res_entier = indicesvides(L_entier, 0)  # éléments entiers, 0 == valeur non renseignée (bof)
res_string = indicesvides(L_string, '') # éléments chaines de caractères, '' == valeur non renseignée (re-bof)

nb : pourquoi la récupération/requête dans SQlite ne retourne-t-elle pas quelque chose qui, in fine, t'arriverait sous la forme d'un None python, sans équivoque, dans tes sous-listes ? d'autant que la notion de valeur NULL (non remplie/non renseignée) existe dans certains SGBD. Autre débat ... Mais, dans ce cas, il n'y aurait même pas à paramétrer indicesvides avec une valeur typée : le test pourrait être fait avec None, quelque soit le type des éléments traités.


Si tu ne peux réduire, pour un type donné, la notion de "valeur vide" à une seule et même valeur, tu peux passer par des fonctions (une par type) qui tiendront lieu de deuxième paramètre à indicesvides.

Exemple : pour des valeurs réelles, NaN est un bon candidat comme valeur vide. Sauf que :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
>>> nan1 = float('nan')
>>> nan2 = float('nan')
>>> nan1 == nan2
False

il faudra utiliser math.isnan :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
>>> nan1 = float('nan')
>>> math.isnan(nan1)
True

Le début de indicesvides devient alors :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
def indicesvides(L,is_valeur_vide):
    a_supprimer = lambda L: [i for i, elem in enumerate(L) if is_valeur_vide(elem)]
    ....

On passe une fonction qui prend comme seul paramètre un élément et retourne True ou False

Ca donne (j'utilise des fonctions lambda ici) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
>>> est_entier_vide = lambda i: i == 0
>>> est_chaine_vide = lambda s: s == ''
>>>
>>> res_entier = indicesvides(L_entiers, est_entier_vide)
>>> res_string = indicesvides(L_strings, est_chaine_vide)
>>> res_reels  = indicesvides(L_reels, math.isnan)

Je teste tout ça sur des exemples concrets, en modifiant aussi le code de Tyrtamos. Je prodite du fait que les sous-listes ont le même nombres d'éléments et qu'ils se correspondent.

J'utilise alors zip qui fait ça (c'est exactement ce qu'on veut) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
>>> L = [['a0','a1','a2'],['b0','b1','b2'],['c0','c1','c2']]
>>> zip(*L)
[('a0', 'b0', 'c0'), ('a1', 'b1', 'c1'), ('a2', 'b2', 'c2')]
>>>

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
>>> def indicesvides(L, est_vide):
...     a_supprimer = list()
...     for i, valeurs in enumerate(zip(*L)):
...             # si liste des valeurs non nulles vide
...             if not filter(lambda v: not est_vide(v), valeurs):
...                     a_supprimer.append(i)
...     return a_supprimer
... 
>>> 
>>> est_vide_entier = lambda i: i == 0
>>> L_entiers = [[1,2,0,3,0],[0,4,0,5,0],[6,7,0,8,0]]
>>> indicesvides(L_entiers, est_vide_entier)
[2, 4]
>>>
>>> est_vide_chaine = lambda s: s == ''
>>> L_chaines = [['1','2','','3',''],['','4','','5',''],['6','7','','8','']]
>>> indicesvides(L_chaines, est_vide_chaine)
[2, 4]
>>>
>>> from math import isnan
>>> nan = float('nan')
>>> L_reels = [[1.0, 2.0, nan, 3.0, nan], [nan, 4.0, nan, 5.0, nan], [6.0, 7.0, nan, 8.0, nan]]
>>> indicesvides(L_reels, isnan)
[2, 4]
>>>

Et si, comme je le supposais (à tort), les types variaient dans les sous-listes (mais qu'ils se correspondaient d'une sous-liste à l'autre), il y a aussi moyen de s'en sortir. Mais ça commence à faire beaucoup ...

[wiztricks]

Salut,
Très joli coup de zip!
Juste pour rappeler que '' is False et aussi 0, donc:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

[ i for i,e in enumerate(zip(*list_ex)) if all([x=='' for x in e])]

s'écrit aussi:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

[ i for i,e in enumerate(zip(*list_ex)) if not any(e) ]

Et c'est fou le nombre de lignes de commentaire à écrire pour expliquer cela.

- W

[alexdevl]

Bonjour,
Sinon il est possible de faire une version qui limite les commentaires :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
liste_exemple=[["attribut0","attribut1","","attribut3","",""],["attribut0","attribut1","","attribut3","","attribut5"],["","attribut1","","attribut3","","attribut5"]]
 
n_attributs=len(liste_exemple[0])
 
a_supprimer=[]
for i in range(n_attributs):
    s=""
    for elem in liste_exemple:
        s+=elem[i]
    if s=="":
        a_supprimer.append(i)
print a_supprimer

[plxpy]

Ici, rater le zip qui nous tend les bras en criant :

Moi, m'sieur, moi m'sieur ! Je sais, je sais !

est vraiment dommage.

S"il ne sert pas ici, il ne servira jamais et on écrira en python comme on le fait en C, en ... Après, on peut ne pas aller "trop" loin dans la programmation fonctionnelle, mais rater le zip, quand même ...

[alexdevl]

Bonjour plxpy,
Vu le code de départ, il me semble important de proposer à Bescu une version plus décomposée voir plus adaptable.

Je l'ai fait dans cette optique, il ne s'agit pas de ''rater'' le zip mais de proposer des alternatives.

Alex

[Bescu]

alors, qu'entends-tu par "n'importe quelle liste de listes" ?! je ne comprends pas le sens.

D'ailleurs, tu dis bien que tu as des chaines ET des int ! Ce ne sont pas des attributs d'objets que tu traites dans tes listes ?

Ou alors, ton type d'élément est unique dans chaque cas mais tu as des cas où ce sont des int, des cas où ce sont des strings, etc ... et c'est ce que tu appelles "n'importe quel liste de listes". Comme formulation ...

Désolé de ne pas avoir été assez clair. C'est vrai que cela prête à confusion. Quand je disais "n'importe quelle type de liste" je pensais au nombre d'attributs et de sous-listes. Mais effectivement j'aurai à traiter des sous-listes composées d'attributs en chaine de caractère et d'autres chiffres (int, float) mais je pense qu'avec tous ces éléments de réponses je vais réussir à me débrouiller!

Merci à tous pour toutes ces réponses et explications! Je ne connaissais pas la fonction zip (je suis un grand débutant en programmation et en python) par exemple qui peut être très pratique quand on bosse sur des résultats de requêtes!

Bon week-end à tous et merci encore!

Maxime