affecter valeurs tableau

Version imprimable

12/03/2011, 12h56
space_56

affecter valeurs tableau
Bonjour,

Pour mettre des valeurs dans un tableau avec python, je fais :
Code:

1 2 3 4 5 6 gh = 0 t = [] for i in xrange(15): t[i] = gh gh = gh + 1
mais cela affiche une erreur, est-ce qu'il faut faut nécessairement utiliser le append ?
Sans utiliser append, comment faudrait-il l'écrire ?

Pour xrange, si on écrit :
Code:

1 2 for i in xrange(2, 16, 0.01)
pourquoi ne peut-il pas avancer par pas de 0.01 ?

Merci de votre aide.

Bonjour,

Comment utiliser l'index avec une liste dont l'index est à zéro ? Comme ceci peut etre

Code:

1
2
3
4
5
6
7
8
9
10
>>> t = range(15)
>>> type(t)
<type 'list'>
>>> print t
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
>>> t = list(xrange(15))
>>> print type(t)
<type 'list'>
>>> print t
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

Sinon pour xrange :

Citation:

step must not be zero (or else ValueError is raised)

Code:

1
2
3
>>> a = 0.1
>>> print int(a)
0

Code:

1
2
3
4
5
6
7
8
9
10
11
12
def Xrange(start=0, stop=0, step=1):
    if step < 0:
        while start > stop:
            yield start
            start = start + step
    else:
        while start < stop:
            yield start
            start = start + step
 
for elems in Xrange(1.0, 10.0, 0.1):
    print(elems)

@+

Edit: Par contre list(Xrange(15)) ne fonctionne pas très bien. Cela viens sans doute de mon code...

12/03/2011, 16h14
PauseKawa
Bon,

Après test les solutions les plus stables pour xrange et 0.1 sembles etre une fonction dans le style Xrange pour ce qui d'une utilisation
Code:

1 2 for elems in Xrange(0.0, 15.0, 0.1): print(elems)
Mais cela n'est pas utilisable pour créer directement une liste avec list.
Pour générer une liste numpy s'en sort très bien
Code:

1 2 import numpy as np t = np.arange(0, 15, 0.1)
Mais je suis étonné des résultats de mes différents tests (cela viens de list ?)... Je vais y regarder de plus pres.

@+

Bonjour,

Citation:

Envoyé par space_56

Sans utiliser append, comment faudrait-il l'écrire ?

On peut initialiser le tableau avec range ou comme ça:

Code:

1
2
3
4
5
6
7
8
 
gh = 0
t = [0 for i in xrange(15)]
for i in xrange(15):
      t[i] = gh
      gh = gh + 1
print t
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

Citation:

Envoyé par space_56

pourquoi ne peut-il pas avancer par pas de 0.01 ?

Parce que xrange ne supporte que les entiers. Et seulement le type int et pas le type long.

Voilà un code qui simule le comportement de xrange pour les flottants et les long:

Code:

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
 
def xplage(*arg):
    lga = len(arg)
    if lga == 1:
        xmin, xmax, xpas = 0, arg[0], 1
    elif lga == 2:
        xmin, xmax, xpas = arg[0], arg[1], 1
    elif lga == 3:
        xmin, xmax, xpas = arg[0], arg[1], arg[2]
    else:
        raise ValueError ("Erreur xplage: nombre d'arguments doit être 1,2,ou 3")
    if xpas == 0:
        raise ValueError ("Erreur xplage: le pas ne peut être nul")
    x = xmin
    if isinstance(xpas, float):
        eps = xpas/10.0
    else:
        eps = 0
    if xpas>0:
        if xmax<xmin:
            raise ValueError ("Erreur xplage: bouclage infini")
        while x+eps<xmax:
            yield x
            x += xpas
    else:
        if xmax>xmin:
            raise ValueError ("Erreur xplage: bouclage infini")
        while x+eps>xmax:
            yield x
            x += xpas

Avec ce code:

Code:

1
2
3
4
5
6
7
8
9
10
for i in xplage(2, 16, 0.01):
    print i
2
2.01
2.02
2.03
...
15.97
15.98
15.99

NB: conformément au xrange, on n'a jamais la dernière valeur.

Ce code fonctionne aussi pour:

Code:

1
2
3
4
xplage(2)
xplage(2, 16)
xplage(2, -16, -0.01)
xplage(9999999999999999999999999999999999999999L, 9999999999999999999999999999999999999999L+10L):

Et détecte les données anormales => exception.

Tyrtamos

Bonjour tyrtamos,

Je me retrouve avec dans ton code dans le même cas de figure que dans mes essais, soit:
Code:

1 2 3 4 5 6 7 t1 = [] for i in xplage(2, 3, 0.1): print i t1.append(i) t = list(xplage(2, 3, 0.1)) print t print t1
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 2 2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 2.9 [2, 2.1000000000000001, 2.2000000000000002, 2.3000000000000003, 2.40000000000000 04, 2.5000000000000004, 2.6000000000000005, 2.7000000000000006, 2.80000000000000 07, 2.9000000000000008] [2, 2.1000000000000001, 2.2000000000000002, 2.3000000000000003, 2.40000000000000 04, 2.5000000000000004, 2.6000000000000005, 2.7000000000000006, 2.80000000000000 07, 2.9000000000000008]
Dès que j'utilise les données (map etc) je me retrouve avec un résultat 'différent' Aurais tu une explication ? J'ai bien vu des avertissements sur la virgule, hors modules spécifiques, à droite et gauche mais je n'arrive pas à comprendre.
Le seul qui me donne le bon résultat c'est arange de numpy mais pour lire les sources... (chez moi c'est un .so)...

@+

Bonjour PauseKawa,

Il s'agit seulement d'un problème d'affichage bien connu:
Code:

1 2 3 print 2.3000000000000003, [2.3000000000000003] 2.3 [2.3000000000000003]
En effet, les vrais résultats de la boucle sont les suivants (on utilise repr() pour avoir tous les chiffres):
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 t1 = [] for i in xplage(2, 3, 0.1): print repr(i) t1.append(i) 2 2.1 2.2 2.3000000000000003 2.4000000000000004 2.5000000000000004 2.6000000000000005 2.7000000000000006 2.8000000000000007 2.900000000000001
Et l'intégration des ces valeurs à l'intérieur d'une liste ne les change pas, mais les affiche complètement.

Pour échapper à cela, qui ne concerne que l'affichage, il faut utiliser un code d'affichage qui transforme la liste en chaine, et qui force l'utilisation de str au lieu de repr. Comme:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 def formatliste(L): """création d'une chaine à partir d'une liste de nombres pour affichage """ ch = '[' if len(L)>0: for x in L: ch += "%s, " % x ch = ch[:-2] # on retire la dernière virgule en trop ch += ']' return ch print formatliste(t1) [2, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9]
Bien sûr, pour afficher un arbre de profondeur quelconque (liste de listes de listes...) avec des données quelconques, des instructions d'affichage des flottants et des problèmes d'encodage des chaines, c'est un peu plus compliqué. Un exemple sur mon site: http://python.jpvweb.com/mesrecettes....php?id=printx

Tyrtamos

13/03/2011, 10h30
PauseKawa
Désolé tyrtamos, j'ai du mal...
Code:

1 2 3 4 5 6 7 8 9 t1 = [] for item in xplage(1, 2, 0.5): t1.append(item) t2 = [] for item in xplage(1, 2, 0.1): t2.append(item) print(t1[1]) print(t2[5]) print(t1[1] == t2[5])
Code:

1 2 3 1.5 1.5 False
C'est moi ou c'est plus qu'un problème d'affichage ?
Un lien vers une explication sur le sujet (j'ai bien vu des warning sur le sujet mais ma logique ne suit pas...) ?

Merci d'avance
13/03/2011, 11h46
tyrtamos
Il faut distinguer le fait que 'print x' arrange l'affichage de x en 'oubliant' les tous derniers chiffres derrière la virgule et en arrondissant en conséquence. Ce qui nous convient la plupart du temps. Mais ça ne change pas le vrai nombre en mémoire qui comporte tous ses chiffres.

Dans ton dernier exemple:

print(t1[1]) affiche 1.5, et c'est bien 1.5 (print repr(t1[1])) affiche 1.5)

mais:
print(t2[5]) affiche 1.5, mais c'est en réalité 1.5000000000000004 (c'est ce que donne print repr(t2[5])))

Ce qui fait que 1.5==1.5000000000000004 donne False, et c'est très bien ainsi.

Autre essai:
Code:

1 2 3 4 print str(1.5000000000000004) 1.5 print repr(1.5000000000000004) 1.5000000000000004
Ok?

Tyrtamos
13/03/2011, 12h04
PauseKawa

Bonjour,

J'avais bien compris mais pour moi 1 + 0.5 == 1 + (0.1 * 5) et 1 + (0.1 * 5) != 1.5000000000000004. Pour moi c'est une erreur de calcul (d'où viens le 4 ?) et non d'affichage.
Mais je ne vais pas polluer plus le sujet de space_56. Je vais regarder cela et je reviendrais avec un autre sujet si besoin.

Merci

Tu n'as pas tort sur un point: en plus des pb d'affichage, il y a effectivement des pb de calcul pour la raison suivante: les nombres sont stockés sous forme binaire, et il est impossible de représenter exactement 0.1 (par exemple) sous forme binaire: il y a donc une erreur dû, non au calcul lui-même, mais au stockage du nombre en mémoire:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 x = 1 while x<2: print repr(x) x += 0.1 1 1.1 1.2000000000000002 1.3000000000000003 1.4000000000000004 1.5000000000000004 1.6000000000000005 1.7000000000000006 1.8000000000000007 1.9000000000000008
Python ne fait qu'utiliser la bibliothèque du C qui fait donc la même chose.

Pour échapper complètement à ça, il faut choisir un autre mode de stockage en mémoire comme le module décimal en Python. En contrepartie, c'est moins rapide.

Tyrtamos

13/03/2011, 17h46
PauseKawa

Bonjour,

Je viens de relire 14.1. Representation Error et c'est enfin rentrer... (il était temps).
Du coup j'ai honte alors pour me rattraper : t = [0 for _ in xrange(15)]

@+
13/03/2011, 19h13
wiztricks
Désolé mais ce n'est pas qu'un problème d'affichage, dans la suite:
Code:

1 2 3 4 5 6 7 8 9 1.1 1.2000000000000002 1.3000000000000003 1.4000000000000004 1.5000000000000004 1.6000000000000005 1.7000000000000006 1.8000000000000007 1.9000000000000008
"On voit" qu'une déviation s'accumule à chaque itération.
Techniquement, pour éviter cela, il est raisonnable de faire qqc. comme:
Code:

1 2 3 def frange(min, max, step): for c in range (int((max - min) / step)): yield min + c * step
i.e. les imprécisions se compensent à chaque étape.

Bien sûr il y aura toujours de l'imprécision (à traiter), mais moins d'erreurs:
Code:

1 2 3 4 5 6 7 8 9 10 1.0 1.1 1.2 1.3 1.4 1.5 1.6 1.7000000000000002 1.8 1.9
- W
13/03/2011, 20h47
PauseKawa

Bonsoir wiztricks,

C'est bien ce que dit tyrtamos et la doc.
D'où, sans doute, le fait que les résultats d'un arange (ce n'est pas du Python) de numpy donne des résultats plus justes (d'après mes 'petits' tests).
En résumé il est préférable d'utiliser les modules de calcul pour les float.

@+
14/03/2011, 10h03
wiztricks

Salut PauseKawa,

La doc dit qu'on ne sait pas faire une bijection entre les représentations base 10 et binaires mais cela nous le savions.
Mon propos est d'essayer d'expliquer pourquoi arange travaille mieux car in fine, dans les deux cas, nous avons la même bibliothèque C, même CPU
- W
14/03/2011, 20h39
PauseKawa

Et je t'en remercie wiztricks.
Tout ce que je voulais dire c'est que la déviation en question prend du temps de calcul pour la correction, d'où un avantage à utiliser arange (optimisé) plutôt que de revoir le monde.