Liste d'arguments sans les crochets

Version imprimable

Bonjour.
J'ai créé une calculatrice, et j'aimerais passer une liste d'arguments dans l'invocation d'une fonction sans mettre de crochets : que la fonction pgcd(l) s'invoque par pgcd(argument1,argument2,argument3...) au lieu de pgcd([argument1,argument2,argument3...]).

Code :

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
 
from Tkinter import *
def pgcd(l):
    for e in l:
        while l[0]<>e:
            if l[0]<e:l[0],e=e,l[0]
            l[0]=l[0]-e
    return l[0]
 
def add(arg):entree.insert(INSERT,arg)
 
def evaluate():resultat.set(str(eval(entree.get())))
 
def calc():
    global f1,f2,f,entree,resultat
    f1,f2=Frame(f),Frame(f)
    f1.grid();f2.grid()
    resultat=StringVar()
 
    entree=Entry(f1,textvariable=resultat)
    entree.grid()
    Button(f2,text="PGCD",command=lambda:add('pgcd([])')).grid()
    Button(f2,text="=",command=evaluate).grid()
 
f=Tk()
calc()
f.mainloop()

Merci.

22/03/2010, 15h38
tyrtamos

Bonjour,

En ajoutant un astérisque comme ça: def pgcd(*l):, les arguments simplement listés à l'appel seront attribués au tuple l. Par contre, tu devras modifier ton code, parce que l[0]=... déclenche une erreur puisque l est un tuple...

Tyrtamos
22/03/2010, 16h09
Spitfire 95

Bonjour.
J'y ai pensé... mais je n'ai pas réussi à adapter le code pour un tuple.
Comment sont indexés les tuples et comment les appelle-t-on par leur index ?

Merci.

Ce qui est interdit est de vouloir affecter une autre valeur à un argument en l'appelant avec son indice. Mais on peut récupérer sa valeur avec cette même notation pour l'utiliser dans les calculs.

Voilà un petit exemple sur le calcul du PGCD de n valeurs:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 def pgcd(a, b): """Calcul du PGCD de 2 nombres entiers a et b (Euclide)""" while b<>0: a, b = b, a%b return a def pgcdn(*n): """Calcul du PGCD de n nombres entiers (Euclide)""" p = pgcd(n[0], n[1]) for x in n[2:]: p = pgcd(p, x) return p print pgcdn(70, 154, 210, 66) 2
Si tu es intéressé par les calculs et les calculatrices, tu devrais trouver de nombreuses sources d'inspirations sur mon site: http://python.jpvweb.com/mesrecettespython/.

Tyrtamos

22/03/2010, 19h42
josmiley
Citation:

Envoyé par Spitfire 95

Bonjour.
J'y ai pensé... mais je n'ai pas réussi à adapter le code pour un tuple.
Merci.
Code:

1 2 3 def pgcdn(*n): n = list(n)
22/03/2010, 19h56
Spitfire 95

Merci, mais ça, je l'avait déjà trouvé entre temps. Mais les tuples prennent moins de place en mémoire, donc je préférerais qu'on me dise comment l'adapter pour des tuples.
Merci quand même.
22/03/2010, 20h41
valAa

Salut,

Citation:

Envoyé par Spitfire 95

Merci, mais ça, je l'avait déjà trouvé entre temps. Mais les tuples prennent moins de place en mémoire, donc je préférerais qu'on me dise comment l'adapter pour des tuples.
Merci quand même.

La différence entre un tuple et une liste, c'est essentiellement que la liste est un objet mutable, et pas le tuple. Il faut donc voir le tuple comme une liste constante, non modifiable. Le problème dans ton code est que ta fonction récupère une liste la modifie puis la renvoie. Tu auras compris que le problème se situe là où j'ai écris en italique. Comment modifier un objet non mutable ? Par définition on ne peux pas, il faut donc construire un second tuple (ou une liste) à partir des valeurs modifiées.

Donc si tu veux que ta fonction prenne un tuple en argument, il faut qu'elle renvoie (1) soit un autre tuple, (2) soit une liste, construit à partir des valeurs modifiées du tuple d'origine.
(1) si tu peux renvoyer un objet non mutable
(2) si tu dois renvoyer un objet mutable
22/03/2010, 20h46
Spitfire 95

Merci pour cette réponse claire.
Je vais donc garder le système du l=list(l).

Et encore merci à tous ceux qui m'ont aidé.

Au revoir.