Discussion :

[Juilien]

Pouvez vous m'aider j'arrive pas à trouver ce que fait le programme suivant, surtout avec l'utilisation de try et except (je ne comprends pas leur fonction), voici le code:

Code :

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

1
2
3
4
5
6
7
8
9
def Sim(P):
    try:
        R=[]
        i=len(P)-1
        while P[i]==0:
            i-=1
        P=P[:i+1]
        return P
        except: return [0]

[Invité]

Ca c'est du titre !
Ce code est comment dire... nul à chier ?
Mention spécial pour le i-=1 suivi du i+1 en indice

PS : Tu as choppé où ce code ? C'est n'importe quoi... Sinon utilises la balise # la prochaine fois ! Bordel ça fait de la programmation et c'est pas fichu de mettre une balise sur un forum, je comprendrais jamais...

[Juilien]

Ca c'est du titre !
Ce code est comment dire... nul à chier ?
Mention spécial pour le i-=1 suivi du i+1 en indice

PS : Tu as choppé où ce code ? C'est n'importe quoi... Sinon utilises la balise # la prochaine fois ! Bordel ça fait de la programmation et c'est pas fichu de mettre une balise sur un forum, je comprendrais jamais...

C'est un exercice, et ce qui est demandé c'est de trouver ce que fait le programme

[wiztricks]

Pouvez vous m'aider j'arrive pas à trouver ce que fait le programme

Ce n'est pas un programme mais une fonction qui prend en paramètre un P qui est une séquence (puisqu'on peut lui appliquer len et accéder à ses éléments via un indice).

Puis on voit qu'il y a une boucle "tant que" où la condition est P[i]==0 qui commence à la fin (voir l'initialisation de i) pour parcourir P en décroissant. Dit autrement, on décrémente tant qu'on trouve des 0 à partir de la fin.

A la sortie de la boucle, l'indice i sera le premier non 0 trouvé... et on retourne le début de P sans les 0 de la fin.

Après, il faut confirmer tout ça en testant pour vérifier que ça fait bien ce qu'on pense.

- W

[Invité]

Pour commencer le R=[] ne sert à rien.
i = len(p)-1 ben ça sert uniquement à trouver le dernier indice de l'itérable
while P[i]==0: tant que la valeur sélectionné de l'itérable vaut 0 ...
i-=1 soustraire l'indice de 1, donc on part du dernier élément de l'itérable et on revient vers le début tant que c'est un 0
...

Bref je te laisse déduire le reste ! Pour le try except ici il ne sert à rien probablement... Sinon ça permet de capturer une exception : https://docs.python.org/fr/3.5/tutorial/errors.html

Je propose une alternative carrément moins performante mais je trouve ça beau, une ligne et paf :

Code :

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

>>> list(int(y) for y in str(P)[1:-1].rstrip(', 0').split(", "))

PS pour les pros : C'est amusant spliter avec ", " semble plus performant qu'avec ",", j'imagine que ça fait moins de boulot pour int(y) ?

[Pyramidev]

Bonjour,

Code :

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

1
2
3
4
5
6
7
8
9
def Sim(P):
    try:
        R=[]
        i=len(P)-1
        while P[i]==0:
            i-=1
        P=P[:i+1]
        return P
        except: return [0]

Indenté ainsi, l'interpréteur rejette le code. Tu devrais voir une erreur SyntaxError. Pour que l'interpréteur accepte ce code, il faut décaler except vers la gauche, au même niveau que try :

Code :

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

1
2
3
4
5
6
7
8
9
def Sim(P):
    try:
        R=[]
        i=len(P)-1
        while P[i]==0:
            i-=1
        P=P[:i+1]
        return P
    except: return [0]

Pour visualiser comment la fonction se comporte, on peut ajouter des print :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def Sim(P):
    try:
        R=[]
        i=len(P)-1
        print("Before while: i ==", i)
        while P[i]==0:
            i-=1
            print("In while: i ==", i)
        P=P[:i+1]
        print("P ==", P)
        return P
    except Exception as e:
        print(f"Error ({type(e)}): {e}")
        return [0]

Dans un cas normal, tu peux voir que ça se comporte comme le décrit wiztricks :

Code :

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

1
2
3
4
5
6
7
>>> Sim([0, 42, 0, 55, 0, 0, 0])
Before while: i == 6
In while: i == 5
In while: i == 4
In while: i == 3
P == [0, 42, 0, 55]
[0, 42, 0, 55]

En plus des listes, ça marche aussi avec les autres types de séquence, comme les tuples :

Code :

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

1
2
3
4
5
6
7
>>> Sim((0, 42, 0, 55, 0, 0, 0))
Before while: i == 6
In while: i == 5
In while: i == 4
In while: i == 3
P == (0, 42, 0, 55)
(0, 42, 0, 55)

Par contre, si l'argument de la fonction est une séquence qui n'a que des 0, alors ça part en sucette :

Code :

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

1
2
3
4
5
6
7
8
9
10
Sim([0, 0, 0])
Before while: i == 2
In while: i == 1
In while: i == 0
In while: i == -1
In while: i == -2
In while: i == -3
In while: i == -4
Error (<class 'IndexError'>): list index out of range
[0]

Cela inclut le cas où la séquence est vide :

Code :

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

1
2
3
4
>>> Sim([])
Before while: i == -1
Error (<class 'IndexError'>): list index out of range
[0]

Concrètement, quand i devient strictement plus petit que -len(P) l'évaluation de P[i] lève une exception de type IndexError et on saute dans le except.

Si l'argument de la fonction n'est pas une séquence, ça part aussi en sucette :

Code :

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

1
2
3
>>> Sim(42)
Error (<class 'TypeError'>): object of type 'int' has no len()
[0]

Dans ce cas, l'évaluation de len(42) lève une exception de type TypeError et on saute dans le except.

À part ça, dans un vrai programme, pour gérer les erreurs, il ne faudrait JAMAIS écrire quelque chose de la forme except: return [0] qui intercepte toutes les erreurs possibles et imaginables sans afficher de message d'erreur, mais c'est un autre sujet. Là, c'est juste pour l'exercice.

[VinsS]

Salut,

Pour ne pas se fourvoyer avec cet index, il y a pop() qui fait les choses plus simplement.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
>>> l = [5, 9, 0, 15, 0, 0, 0, 0]
>>> while l and l[-1] == 0:
...     l.pop(-1)
... 
0
0
0
0
>>> l
[5, 9, 0, 15]

[Sve@r]

Bonjour

Pouvez vous m'aider j'arrive pas à trouver ce que fait le programme suivant

Dans ce cas, on prend un papier et un crayon et on reproduit les opérations. Ou (au pis aller) on ouvre Python et on lance le job.
Ca commence par chercher le dernier indice de P, qui pour un tableau de (par exemple) 20 éléments vaut 19 puisque le premier commence à 0. Donc len(P)-1.
Tant que l'élément "i" vaut 0, i est décrémenté.
Ensuite, quand l'élément "i" ne vaut plus 0 on sort de la boucle. L'indice est donc positionné sur le dernier élément du tableau à ne pas valoir 0. Le tableau tout entier est alors remplacé par sa partie commençant à 0 et se terminant à cet indice et il est retourné.
Bref cette fonction, écrite visiblement avec deux pieds gauches tellement elle est bancale, supprime tous les 0 consécutifs situés à droite d'un tableau. Pour [1, 3, 5, 0, 7, 4, 0, 0, 0] ça renvoie [1, 3, 5, 0, 7, 4]

Code python :

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

1
2
3
def Sim(P):
	while P[-1] == 0: P.pop()
	return P

surtout avec l'utilisation de try et except (je ne comprends pas leur fonction)

Et t'as pas eu l'idée d'aller ouvrir un tutoriel qui en parle? Effectivement c'est bien plus pratique de se laisser porter à aller demander des explications et à attendre que le travail des autres t'arrive tout cuit.
try/except c'est littéralement "essaye et gère le cas si ça plante". C'est pour gérer le cas où tout le tableau est à 0. Dans ce cas i continue à descendre et quand il est trop bas, l'accès à P[i] n'est plus possible donc plantage donc renvoi d'un tableau neutre [0]
A ce sujet, deux remarques

• un bon programmeur (enfin un programmeur qui se respecte et qui n'a pas une touffe de poils aux mains) ciblera précisément l'exception attendue au lieu de râtisser large et toutes les récupérer y compris celles qui n'auraient rien à voir et qui pourraient provenir d'une erreur de logique. Donc ici c'est except IndexError. Ca évitera à la fonction de retourner [0] quand on lui passe par exemple un nombre ou une chaine
• étant donné que Python accepte les indices négatifs (cf mon exemple), il faudra descendre jusqu'à deux fois la taille du tableau avant d'avoir le except. Pour un tableau de 20, le code parcourera toutes les valeurs de 19 jusqu'à -20 avant de sortir donc fera deux fois le même travail

Comme l'a dit Le Narvalo, c'est vraiment un code de merde.

Code python :

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

1
2
3
4
5
def Sim(P):
	try:
		while P[-1] == 0: P.pop()
	except IndexError: return [0]
	else: return P

[Pyramidev]

Admettons que l'argument soit toujours une liste.

Code python :

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

1
2
3
4
5
def Sim(P):
	try:
		while P[-1] == 0: P.pop()
	except IndexError: return [0]
	else: return P

Attention que ta fonction a un effet de bord : elle modifie la liste passée en paramètre, contrairement au code d'origine qui retournait une nouvelle liste sans modifier la liste de départ.

Voici une version qui copie la liste en paramètre avant d'éditer la copie et qui, au passage, évite les tours de passe-passe avec IndexError :

Code :

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

1
2
3
4
5
def Sim(P):
    result = list(P)
    while result and result[-1] == 0:
        result.pop()
    return result if result else [0]

[Sve@r]

Admettons que l'argument soit toujours une liste.

C'était un petit peu implicite dans mon esprit vu que la fonction retourne une liste [0]. On a du mal à penser qu'elle pourrait retourner une liste quand elle reçoit un tuple. Enfin oui pourquoi pas (sait-on jamais à quoi a pensé le codeur originel?). Là fatalement avec mes pop() ça foire.

Attention que ta fonction a un effet de bord : elle modifie la liste passée en paramètre, contrairement au code d'origine qui retournait une nouvelle liste sans modifier la liste de départ.

Ah oui, bien vu

et qui, au passage, évite les tours de passe-passe avec IndexError

Hum... là je ne suis pas certain que le jeu en vaille la chandelle. Deux tests à chaque itération, et de nouveau encore un test identique à la fin...
except IndexError n'est pas un tour de passe-passe. Il fait partie d'une méthode de programmation assez plébiscitée dans Python faite pour éviter le toctou bug.

[wiztricks]

Pour le try except ici il ne sert à rien probablement... Sinon ça permet de capturer une exception : https://docs.python.org/fr/3.5/tutorial/errors.html

Il sert à traiter le cas où la séquence ne contient que des 0.
On voit bien le débutant qui se prend l'exception dans la gueule après avoir écrit un premier code, et qui, au lieu de réfléchir au pourquoi la pousse sous le tapis.
Débutant qui partage son code avec un collègue qui demande de nous expliquer le code au cas où...

Avec un Python basique, il aurait été plus raisonnable d'écrire:

Code :

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

1
2
3
4
5
6
     i = len(p)-1
     while i > 0:
           if p[i] != 0:
              break
           i -= 1
     return p[:i+1]

note: for ... in range(...) est plus concis mais aussi bien plus abstrait.

- W

[Invité]

Il sert à traiter le cas où la séquence ne contient que des 0.

Effectivement ! =)

Et mon code farfelue ne gère pas ça non plus... ValueError: invalid literal for int() with base 10: ''. Comme quoi pas si simple ! =(

Alternative :

Code :

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

1
2
3
4
5
6
7
def toto():
	P = [0,1,0,0]
	i = -1
	nb = -len(P)
	while P[i] == 0 and i != nb:
		i-=1
	return P[:i+1]

[Sve@r]

Mention spécial pour le i-=1 suivi du i+1 en indice

Alternative :

Code :

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

1
2
3
4
5
6
7
def toto():
	P = [0,1,0,0]
	i = -1
	nb = -len(P)
	while P[i] == 0 and i != nb:
		i-=1
	return P[:i+1]

Ah??? Vas-tu te donner aussi une mention spéciale ???

[Pyramidev]

except IndexError n'est pas un tour de passe-passe.

Dans l'algo présent, balayer les indices négatifs n'a pas vraiment de sens.

On voit bien le débutant qui se prend l'exception dans la gueule après avoir écrit un premier code, et qui, au lieu de réfléchir au pourquoi la pousse sous le tapis.
Débutant qui partage son code avec un collègue qui demande de nous expliquer le code au cas où...

En effet, c'est une hypothèse possible, surtout quand on voit la ligne R=[] qui ne sert à rien. Je parie que R servait à stocker le résultat de la fonction, puis a été abandonné en court de route puis oublié.
D'ailleurs, je me suis demandé quel était le sens de l'algo. Pourquoi retourner [0] si la liste est vide après avoir viré tous les 0 les plus à droite ?

Juilien, est-ce que P représente les coefficients d'un polynôme du plus petit degré au plus grand ?
Par exemple, [3, 2, 1] représenterait X^2 + 2X + 3 et [0] représenterait le polynôme nul.
Est-ce que la fonction Sim sert à simplifier un polynôme en supprimant les 0 en trop ?

Si oui, alors l'argument en entrée ne peut pas être une liste vide et on peut utiliser le code de wiztricks (je fais des renommages) :

Code :

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

1
2
3
4
5
6
7
def simplify(polynom):
    i = len(polynom) - 1
    while i > 0:
        if polynom[i] != 0:
            break
        i -= 1
    return polynom[:i+1]

qui peut se simplifier en :

Code :

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

1
2
3
4
5
def simplify(polynom):
    i = len(polynom) - 1
    while i > 0 and polynom[i] == 0:
        i -= 1
    return polynom[:i+1]

La variante qui appelle pop peut aussi se simplifier :

Code :

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

1
2
3
4
5
def simplify(polynom):
    result = list(polynom)
    while len(result) > 1 and result[-1] == 0:
        result.pop()
    return result

Concernant les 3 codes ci-dessus, la différence de comportement par rapport au code de départ est que, si l'argument est une liste vide, alors la fonction retourne une liste vide au lieu de [0]. Mais, si mon interprétation est juste, l'argument sera toujours une liste non vide.

[Sve@r]

Dans l'algo présent, balayer les indices négatifs n'a pas vraiment de sens.

L'algo d'origine balaye les indices du +max jusqu'à -max et donc la partie [-1:-max] fait effectivement double travail (comme je l'ai précisé dans mon premier post).
Dans mon algo (parce que quand tu parles de "passe-passe" tu m'as cité donc je présume que tu parles de celui-là) , je m'arrête quand la liste est vide. C'est là que except IndexError (que j'ai rajouté dans ma V2) prend son utilité. Et la liste n'est balayée qu'une seule fois. Je ne dis pas que ici il est primordial (peu de chances de voir un toctou dans le cas présent) mais il ne peut pas non plus être qualifié de "passe-passe" comme un arnaqueur de bonneteau...

D'ailleurs, je me suis demandé quel était le sens de l'algo. Pourquoi retourner [0] si la liste est vide après avoir viré tous les 0 les plus à droite ?

Pour avoir une liste existante. En math, le nombre "0000" c'est "0". De même dans l'esprit du codeur de ce truc, la liste [0, 0, 0, 0] ça doit donner [0].

[MPython Alaplancha]

@Sve@r:
J'ai effacé mon message car je me suis apperçu de mon erreur, mais tu as eu le temps de la noter

[Invité]

Ah??? Vas-tu te donner aussi une mention spéciale ???

A la base il n'y avait pas d'indentation =)

[Sve@r]

A la base il n'y avait pas d'indentation =)

Je comprends mieux. Le code n'était pas entre balises et on voyait tout au même niveau c'est ça?

[Invité]

Je comprends mieux. Le code n'était pas entre balises et on voyait tout au même niveau c'est ça?

Si Señor Tintin !♪ ♫

Des bonus sont +/- cachés dans ce message