Discussion :

[amitoum]

Bonjour,

lorsque je définis une liste avec l'instruction

Code :

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

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?

[Invité]

Salut !

Code :

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

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

Code :

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

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 :

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

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 :

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

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 :

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

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.

[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

[amitoum]

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?

[MPython Alaplancha]

Bonsoir,

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

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

Code :

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

[0 for y in range(5)]

[Sve@r]

Bonjour

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].

[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].

[Invité]

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 :

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
>>> 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+

[Sve@r]

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.

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...

[wiztricks]

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 :

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

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

[lg_53]

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
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.

[Sve@r]

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

Il l'est déjà pour moi (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é...

[lg_53]

Il l'est déjà pour moi (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é...

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 :

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

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 :

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

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__.

[Invité]

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é !

[MPython Alaplancha]

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 :

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

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!
 
>>>

[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