Besoin d'aide pour creer une liste à partir d'une chaine de caracteres

Version imprimable

Bonjour à tous,
J'essaye de créer un programme qui me permettra à partir d'une chaine de caractères représentant un polynome (ex : '1-4X**3+3X**2' ) d'obtenir une liste des coefficients du polynome (ici [1,0,3,-4]).

Pour commencer, j'essaye d'ecrire un petit programme qui me permettrait de récupérer les monomes (séparés par des + ou des - ) sous forme d'une liste.
Et après j'analyserais cette liste et en fonction du degré et du coefficient associé je créerai ma liste finale.

Le probleme réside pour l'instant dans mon premier programme, j'ai essayé celui ci mais il ne semble pas fonctionner :
Code:

1 2 3 4 5 6 7 def monome(l): M=[] for i in l : if i in "+-": M.append(l[0:i]) l.replace(l[0:i],"") return M
Code:

1 2 3 4 5 6 7 8 >>> l='1+4*X-X**2' >>> monome(l) Traceback (most recent call last): File "<pyshell#21>", line 1, in <module> monome(l) File "<pyshell#15>", line 5, in monome M.append(l[0:i]) TypeError: slice indices must be integers or None or have an __index__ method
Merci d'avance!
Bonne journée

Salut,

Dans ton code le nom i représente la lettre courante et non son index.

Tu peux directement avoir l'index et la lettre avec enumerate()
Code:

1 2 3 4 5 6 7 8 9 10 a = '1-4X**3+3X**2' d = 0 m = [] for i, l in enumerate(a): if l in ['+', '-']: m.append(a[d:i]) d = i + 1 m.append(a[d:]) print m
Ce qui donne:
Code:

1 2 ['1', '4X**3', '3X**2']

Salut,
Je pense que tu voulais faire:

Code:

1
2
3
4
5
6
7
8
9
10
def monome(l):
    M=[]
    i_ref = 0
    for idx, i in enumerate(l) :
        if i in "+-":
            M.append(l[i_ref:idx])
            i_ref = idx
    else:
        M.append(l[i_ref:])
    return M

Sinon les regex marchent bien :

Code:

1
2
import re
print( re.split('(\+|-)',l) )

Code:

['1', '-', '4X**3', '+', '3X**2']

10/05/2013, 15h19
cvicto

Merci beaucoup pour vos réponses,
la premiere solution de dardanos correspond exactement avec ce que je voulais car j'ai besoin du signe du monome dans ma liste et de plus cela tient compte du fait qu'il peut y avoir des polynomes constants.
J'ai juste une petite question sur la fonction enumerate pour etre sure d'avoir bien compris.

Lorsqu'on ecrit : for idx, i in enumerate(l),
est ce que le idx correspond bien à l'indice de l'element i de la chaine l en sous entendant que l'indexation commence à zéro ?

Merci beaucoup pour vos reponses aussi rapides, je vais essayer de finir mon programme d'ici ce soir, je vous tiens au courant.

ps : je ne connaissais pas les regex mais je pense que mon prof ne prefere pas qu'on les utilise.
10/05/2013, 15h24
VinsS

Citation:

Envoyé par cvicto

Lorsqu'on ecrit : for idx, i in enumerate(l),
est ce que le idx correspond bien à l'indice de l'element i de la chaine l en sous entendant que l'indexation commence à zéro ?

C'est exactement cela.

Rebonjour,
je pensais avoir reussi un programme qui me permettait d'obtenir une liste de couples correspondant aux monomes de la forme (coeff, degré) mais ca ne marche pas.
En dessous le programme et un test montrant ce que j'obtiens :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 def couples_cd(M): C=[] for i in M : c=0 d=0 for j,k in enumerate(i): if k in 'X': c=(i[0:j]) for p,q in enumerate (i): if q in '*': d=(i[(p+1):]) else : d==1 else: c=i d==0 C.append((c,d)) return C
Code:

1 2 couples_cd(['3', '+4X', '-5X**2']) [('3', 0), ('+4X', 0), ('-5X**2', '2')]
ici j'aimerais obtenir [('3',0), ('+4',1), ('-5',2)] voire meme [(3,0), (4,1), (-5,2)] mais enlever les guillemets et le signe + ne sera pas trop dur à faire après je pense.

Si quelqu'un pouvait m'eclairer ce serait tres gentil.

10/05/2013, 18h22
VinsS

Est-ce ton copier-coller qui à foiré ? Le else n'est pas indenté avec le if auquel il fait suite.

Ensuite, d==0 et d==1 devraient être d = 0 et d = 1.

Voici ma proposition :

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
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
def monome(l):
    M=[]
    i_ref = 0
    for idx, i in enumerate(l) :
        if i in "+-":
            M.append(l[i_ref:idx])
            i_ref = idx
    else:
        M.append(l[i_ref:])
    return M
 
def decomposition(l):
    decompo = []
    for mono in monome(l):
        if not 'X' in mono:     # degré 0
            coeff, expo = mono, 0
        elif 'X**' in mono:     # degré > 1
            coeff, expo = mono.split('X**')
        elif 'X' in mono:       # degré 1
            coeff, expo = mono[-2], 1
        else:                   # erreur donnée
            print('Problème monome : {0}'.format(mono))
            continue
        decompo.append( ( float(coeff), int(expo) ) )
    # Tri par exposant croissant
    return sorted(decompo, key=lambda e: e[-1])
 
if __name__ == '__main__':
    print(decomposition('1-4X**3+3X**2'))
    print(decomposition('3+4X-5X**2'))

Code:

1
2
[(1.0, 0), (3.0, 2), (-4.0, 3)]
[(3.0, 0), (4.0, 1), (-5.0, 2)]

10/05/2013, 20h06
cvicto

Pour repondre à VinsS, en fait je ne savais pas trop ou le mettre car je voulais que le else soit pris en compte seulement à la fin de la boucle et non pas a chaque iteration et merci je n'etais plus sure pour les == ou =.

Et merci dardanos ta solution correspond a ce que je voulais faire, il faut juste que je rajoute le cas ou le coefficient d'un degré non nul puisse etre 1 car a ce moment la le 1 est implicite et il faut mettre dans le programme que s'il n'y a pas de caractere entre le signe et le X, cela sous entend un 1.

J'ai une petite question aussi sur le programme.

La difference entre float et integer c'est que un integer est forcement entier alors qu'un float peut etre decimal ?

Pour finir, quand on ecrit "mono[-2]", on affiche le deuxieme caractere en partant de la gauche mais cela pose donc probleme quand les coefficients sont composés de plusieurs chiffres.
J'essaye de rectifier ces petits details et je vous envoie le nouveau programme.

Merci encore !

Voila ce que j'ai reussi à faire, je pense qu'il y avait des facons plus "jolies" de le faire mais bon ca marche !

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
def couples_cd(l):
	couples = []
	for mono in monome(l):
		if not 'X' in mono:     # degré 0
			c,d = mono,0
		elif 'X**' in mono:     # degré > 1
			c,d = mono.split('X**')
			if c=='':
				c='1'
			if c=='+':
				c='1'
			if c=='-':
				c='-1'
		elif 'X' in mono:       # degré 1
			i=len(mono)
			c,d = mono[:(i-1)],1
			if c=='':
				c='1'
			if c=='+':
				c='1'
			if c=='-':
				c='-1'
		couples.append((float(c), int(d)))
	return sorted(couples, key=lambda e: e[-1])

Code:

1
2
couples_cd('1-X**2+354X-456X**3+X**5')
[(1.0, 0), (354.0, 1), (-1.0, 2), (-456.0, 3), (1.0, 5)]

Merci pour votre aide.

Ok, c'est bien alors. Ceci fait la même chose :

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
38
39
40
41
42
43
44
45
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
def monome(l):
    M=[]
    i_ref = 0
    for idx, i in enumerate(l) :
        if i in "+-":
            M.append(l[i_ref:idx])
            i_ref = idx
    else:
        M.append(l[i_ref:])
    return M
 
def decoupe(chaine,motif):
    idx = chaine.index(motif)
    nbc = len(motif)
    c, e = chaine[:idx], chaine[idx+nbc:]
    if not c or c=='+':
        c = '1'
    elif c=='-':
        c = '-1'
    if not e:
        e = '1'
    return c, e
 
def couples_cd(l):
    decompo = []
    for m in monome(l):
        if not 'X' in m:     # degré 0
            coeff, expo = m, 0
        elif 'X**' in m:     # degré > 1
            coeff, expo = decoupe(m,'X**')
        elif 'X' in m:       # degré 1
            coeff, expo = decoupe(m,'X')
        else:                # erreur donnée
            print('Problème monome : {0}'.format(m))
            continue
        decompo.append( ( float(coeff), int(expo) ) )
    # Tri par exposant croissant
    return sorted(decompo, key=lambda e: e[-1])
 
if __name__ == '__main__':
    print(couples_cd('1-4X**3+3X**2'))
    print(couples_cd('3+74X-5X**2'))
    print(couples_cd('1-X**2+354X-456X**3+X**5'))

13/05/2013, 16h59
cvicto

Oui c'est vrai ca marche aussi bien.

Merci encore pour votre aide a tout les deux.