valeur des indices d'une liste [0 for y in range(1,6)]

Version imprimable

26/01/2022, 17h12
amitoum

valeur des indices d'une liste [0 for y in range(1,6)]

Bonjour,

lorsque je définis une liste avec l'instruction

Code:

ex =[0 for y in range(1,6)]

j'obtiens une erreur lorsque je cherche à me servir de ex[5] mais ex[0] ne pose pas de problème.

Faut-il en déduire que le début et la fin de range ne servent à rien et que seule leur différence est prise en compte avec un index qui commence toujours à 0?

Ou y a-t-il un autre moyen d'obtenir qu'un index prenne les valeurs de 1 à 9?

Salut !

Code:

1
2
>>> [0 for y in range(1,6)]
[0, 0, 0, 0, 0]

Code:

1
2
3
4
5
6
7
8
9
10
>>> for y in range(1,6):
	ex.append(0)
	print(y, ex)
 
 
1 [0]
2 [0, 0]
3 [0, 0, 0]
4 [0, 0, 0, 0]
5 [0, 0, 0, 0, 0]

Code:

1
2
3
4
5
6
7
>>> ex[5]
Traceback (most recent call last):
  File "<pyshell#21>", line 1, in <module>
    ex[5]
IndexError: list index out of range
>>> ex[4]
0

Autre exemple :

Code:

1
2
3
4
5
6
7
8
9
10
11
>>> for y in range(12,0,-2):
	ex.append(0)
	print(y,ex)
 
 
12 [0]
10 [0, 0]
8 [0, 0, 0]
6 [0, 0, 0, 0]
4 [0, 0, 0, 0, 0]
2 [0, 0, 0, 0, 0, 0]

Ou encore :

Code:

1
2
3
4
5
6
7
8
9
10
11
>>> for y in "azerty":
	ex.append(0)
	print(y,ex)
 
 
a [0]
z [0, 0]
e [0, 0, 0]
r [0, 0, 0, 0]
t [0, 0, 0, 0, 0]
y [0, 0, 0, 0, 0, 0]

Vous ne faites que parcourir un itérable et demander de rajouter 0 pour chaque élément de cet itérable, ces éléments sont indépendants de votre liste ex, comme vous pouvez le voir dans ce dernier exemple.

26/01/2022, 18h20
wiztricks

Salut,

Les indices d'une séquence (comme les listes) commencent toujours à 0.
[0 for y in range(1,6)] fabrique une liste de 5 éléments tous nuls et les indices valides iront de 0 à 4.

- W
26/01/2022, 18h53
amitoum

Citation:

Envoyé par wiztricks

Salut,

Les indices d'une séquence (comme les listes) commencent toujours à 0.
[0 for y in range(1,6)] fabrique une liste de 5 éléments tous nuls et les indices valides iront de 0 à 4.

- W

Mais à quoi servent alors le début et la fin de l'intervalle range?
26/01/2022, 18h56
MPython Alaplancha

Bonsoir,

Citation:

Envoyé par amitoum

Mais à quoi servent alors le début et la fin de l'intervalle range?

Dans ce cas rien .
C'est strictement identique à:

Code:

[0 for y in range(5)]
26/01/2022, 19h23
Sve@r

Bonjour

Citation:

Envoyé par amitoum

Mais à quoi servent alors le début et la fin de l'intervalle range?

Si par exemple tu as un tableau de 20 éléments et que tu veux traiter les éléments de 12 à 17, plus facile et plus lisible d'écrire for i in range(12, 18) pour traiter l'élément [i] que d'écrire for i in range(6) pour traiter l'élément [i+12].
26/01/2022, 19h42
amitoum

Merci à tous.

Mais je trouve quand même surprenant d'avoir ajouté des formulations comme range [1,6] ou range[2,7] si elles sont toutes rigoureusement identiques à range [5].

Je parasite un peu le sujet, c'est amusant de voir que range() semble un peu moins efficace qu'un string dans ce cas de figure :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
>>> def test1():
	st = time.time()
	x = "_"*123456789
	ex = []
	for _ in x:
		ex.append(0)
	print(len(ex),time.time()-st)
 
 
>>> def test2():
	st = time.time()
	ex = []
	for _ in range(123456789):
		ex.append(0)
	print(len(ex),time.time()-st)
 
 
>>> test1()
123456789 5.945485591888428
>>> test2()
123456789 6.174558401107788

A+

26/01/2022, 22h39
Sve@r

Citation:

Envoyé par amitoum

Mais je trouve quand même surprenant d'avoir ajouté des formulations comme range [1,6] ou range[2,7] si elles sont toutes rigoureusement identiques à range [5].

Tu n'as pas pigé.
Le but de range() est de générer une liste de nombres entre x et y. Donc range(1, 6) n'est pas rigoureusement identique à range(5). Dans le premier cas ça donne [1, 2, 3, 4, 5] et dans l'autre ça donne [0, 1, 2, 3, 4].
Ce qui est identique c'est juste le nombre de chiffre générés (5 dans les deux cas).

Dans ta formulation [0 for y in range(1,6)] tu n'utilises pas "y", il est juste là pour créer la boucle. Donc dans ce cas précis, avoir [1, 2, 3, 4, 5] ou [0, 1, 2, 3, 4] n'a aucune importance puisque ces valeurs ne sont pas utilisées. Mais ce n'est pas parce que toi tu ne les utilises pas que d'autres n'en auront pas besoin.

Citation:

Envoyé par LeNarvalo

Je parasite un peu le sujet, c'est amusant de voir que range() semble un peu moins efficace qu'un string dans ce cas de figure

Mouais. Peut-être parce que l'objet "range()" est un poil plus long à renvoyer ses valeurs que l'opération de multiplication de string. Si certains ont une idée plus précise...
26/01/2022, 22h47
wiztricks
Citation:

Envoyé par amitoum

Mais je trouve quand même surprenant d'avoir ajouté des formulations comme range [1,6] ou range[2,7] si elles sont toutes rigoureusement identiques à range [5].

Si vous ne comprenez pas que [0 for y in range(5)] est équivalent à:
Code:

1 2 3 liste = [] for _ in range(5): liste.append(0)
Le range dans ce cas ne sert qu'a savoir combien de fois on répète l'instruction liste.append(0)... et il y a plein de façons de dire 5 fois avec range. Ce qui devrait vous faire tiquer, c'est que l'indice qu'on récupère de range (ici _) n'est pas utilisé dans la boucle.
On aurait pu écrire for _ in 'aaaaa': ou for _ in 'a'*5:....

Ouvrez un tuto. apprenez les bases et surtout à relire le code que vous écrivez.

- W

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
31
32
33
34
35
36
37
class FortranList(list):
    def __init__(self, *args, first_index=1):
        super().__init__(*args)
        self.first_index = first_index
 
    def get_py_idx(self,i):
        if isinstance(i, slice):
            return slice( i.start-self.first_index,i.stop-self.first_index,i.step)            
        else :
            return i-self.first_index
 
    @property
    def last_index(self):
        return self.first_index + len(self) - 1
 
    def __getitem__(self, i):
        return super().__getitem__(self.get_py_idx(i))
 
    def __setitem__(self, i,val):
        super().__setitem__(self.get_py_idx(i),val)
 
    # def __delitem__(self, i):
    #     raise NotImplementedError
    #     ### See here to do that : https://stackoverflow.com/questions/20247841/using-delitem-with-a-class-object-rather-than-an-instance-in-python
 
x=FortranList([5,6,7])
print(x)
print(x[2])
print(x.first_index, x.last_index)
print(len(x))
x.append(8)
x.append(9)
print(x)
print(x[4])
print(x[3:5])
x[2:4]=[12,13]
print(x)

Ci dessus voici une manière de faire des liste avec des indices qui démarre à autre chose que 0. Mais bon, si vous n'êtes pas au point sur range, j'ai bien peur que ce code soit difficile à comprendre pour vous, et donc à adapter à vos besoins.

28/01/2022, 13h26
Sve@r

Citation:

Envoyé par lg_53

j'ai bien peur que ce code soit difficile à comprendre pour vous

Il l'est déjà pour moi :aie: (mais peut-être est-ce parce que je ne connais pas Fortran et ne sait donc pas comment il gère ses listes). Apparemment les indices Fortran commencent à 1 c'est ça?
PS: à mon avis le PO a décroché...:mrgreen:
28/01/2022, 15h05
lg_53
Citation:

Envoyé par Sve@r

Il l'est déjà pour moi :aie: (mais peut-être est-ce parce que je ne connais pas Fortran et ne sait donc pas comment il gère ses listes). Apparemment les indices Fortran commencent à 1 c'est ça?
PS: à mon avis le PO a décroché...:mrgreen:

Je peux expliquer le code plus en détail si tu veux, aucune connaissance de Fortran n'est requise.

Les indices Fortran commence par défaut à 1, mais en fait tu peux ajuster comme tu veux, lorsque tu déclares ton tableau, tu as 2 possibilité de paramètres : soit tu en donne la taille, soit tu donne le premier indice et le dernier indice.
Code:

1 2 3 INTEGER, DIMENSION(3) :: v INTEGER, DIMENSION(0:2) :: w INTEGER, DIMENSION(12:17) :: x
Mais bon, là on s'écarte du sujet initial. J'ai nommé ma classe ainsi car ça me faisait penser justement au Fortran (de mes souvenirs de master), mais là ce qu'il faut juste comprendre c'est que l'on peut customiser à souhait l'indice de début que l'on souhaite donner à notre conteneur.

Dans mon exemple, j'aurais très bien pu écrire aussi
Code:

1 2 y=FortranList([5,6,7], first_index=7) z=FortranList([5,6,7], first_index=-3)
et même avec les négatifs ça marche (on adapte les indice auquel on veut accéder derrière). Après ici, au PO de voir dans ce cas s'il autorise l'accès à l'élément -4, qui serait le dernier élément de la liste, puisque -3 est le premier élément, ou bien s'il souhaite interdire ce comportement, via un test et une erreur dans le __getitem__.
28/01/2022, 22h41
Invité

Citation:

Envoyé par Sve@r

Peut-être parce que l'objet "range()" est un poil plus long à renvoyer ses valeurs que l'opération de multiplication de string*.

* et de parcours du string généré !
30/01/2022, 08h35
MPython Alaplancha
Citation:

Envoyé par amitoum

Ou y a-t-il un autre moyen d'obtenir qu'un index prenne les valeurs de 1 à 9?

Comme dit précédemment une liste commence toujours par l'index 0.
Ceci étant dit, lorque tu parcours une liste tu peux très bien compter les index à partir de 1:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 >>> l = [1, 2, 3] >>> for index,nbr in enumerate(l, 1): print(nbr, end=" ") if index == 3: print("soleil!") print() 1 2 3 soleil! >>>
30/01/2022, 08h58
VinsS

Salut,

Et pour ceux qui, arrivés ici, ont toujours du mal avec la fonction range il y a cet article:

https://aroberge.blogspot.com/2017/0...not-exist.html

Fuseau horaire GMT +2. Il est actuellement 14h56.