Discussion :

[Avi.Py]

Bonjour ! J'aurai besoin de votre aide sur quelques programmes . L'entièreté de mon TP porte sur les fonctions polynomiales et me demande de créer des fonctions visant à "exploiter" des données de ces fonctions comme par exemple créer une fonction qui permet de déterminer le degré d'une équation etc.

J'ai donc déjà créer une fonction python : poly_simple permettant de supprimer tous les coefficients nuls situés avant le premier coefficient non nul. En d'autres termes, la fonction supprime les coefficients nuls inutiles.

Examples
--------
>>> poly_simple([0, 1])
[1]
>>> poly_simple([0, 0])
[]
>>> poly_simple([1, 0, 1, 0])
[1, 0, 1, 0]
"""

Voice le code de cette fonction :

Code :

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

1
2
3
4
5
6
7
 
def poly_simple(poly):
 
    i = 0
    while i < len(poly) and poly[i] == 0:
        i += 1
    return poly[i:]

J'aurai donc besoin de votre aide pour élaborer tout d'abord un code permettant de retourner le degré d'une fonction polynomiale.

Par exemple:


Le polynôme de degré 2, P(X) = 2*X^2 - 1 est représenté par la liste [2, 0, -1] de longueur 3.

>>> poly_degre([3, 1])
1
>>> poly_degre([1, 2, 3, 2, 0, -1])
5
>>> poly_degre([0, 1])
0
>>> poly_degre([0, 1, 0])
1
>>> poly_degre([1])
0
>>> poly_degre([])
-1

Merci de votre aide !

[BufferBob]

salut,

ce que tu pourrais faire c'est virer de la liste tous les zéros qui sont à gauche tant qu'/si il y en a, après quoi vu que tu vires déjà les zéros à gauche dans la liste, le degré de ton polynôme c'est juste len(poly)-1 finalement

[Avi.Py]

salut,

ce que tu pourrais faire c'est virer de la liste tous les zéros qui sont à gauche tant qu'/si il y en a, après quoi vu que tu vires déjà les zéros à gauche dans la liste, le degré de ton polynôme c'est juste len(poly)-1 finalement

Merci beaucoup de ton aide cela fonctionne !

Je vais essayer de continuer le TP je vous enverrai mon code pour vérification.

Merci pour votre réponse.

[Avi.Py]

salut,

ce que tu pourrais faire c'est virer de la liste tous les zéros qui sont à gauche tant qu'/si il y en a, après quoi vu que tu vires déjà les zéros à gauche dans la liste, le degré de ton polynôme c'est juste len(poly)-1 finalement

J'ai donc continué le Tp de mon côté pour obtenir plusieurs fonctions.

La fonction permettant de renvoyer le degré de la fonction :

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
# %%
import doctest
from math import sqrt, isclose
def poly_simple(poly):
    i = 0
    while i < len(poly) and poly[i] == 0:
        i += 1
    return poly[i:]
 
## EX 1
 
def poly_degre(poly):
    a=poly_simple(poly)
    degré=len(a)-1
    return degré
 
 
 
if  poly_degre([3, 1])!=1:
    print ('La fonction poly_degre([3, 1])!=1 ne renvoie pas le bon degré')
 
if  poly_degre([1, 2, 3, 2, 0, -1])!=5:
    print ('La fonction poly_degre([1, 2, 3, 2, 0, -1])!=5 ne renvoie pas le bon degré')
 
if  poly_degre([0, 1])!=0:
    print ('La fonction poly_degre([0, 1])!=0 ne renvoie pas le bon degré')
 
if  poly_degre([0, 1, 0])!=1:
    print ('La fonction poly_degre([0, 1, 0])!=1 ne renvoie pas le bon degré')
 
if  poly_degre([1])!=0:
    print ('La fonction poly_degre([1])!=0 ne renvoie pas le bon degré')
 
if  poly_degre([])!=-1:
    print ('La fonction poly_degre([])!=-1 ne renvoie pas le bon degré')

La fonction permettant d'évaluer le polynome au point x0 :

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
def poly_eval(poly,x0):
 
    res=0
    poly_puissance=len(poly)-1
 
    for Mv in range (len(poly)):
 
        res+= poly[Mv]*x0**(poly_puissance-Mv)
 
    return res
 
 
if not isclose( poly_eval([2, 0, -1], sqrt(2)), 3.0 ):
    print ('L appel de la fonction isclose( poly_eval([2, 0, -1], sqrt(2)), 3.0 ) est fausse')
 
if not isclose( poly_eval([2, 0, -1], -sqrt(2)), 3.0):
    print ('L appel de la fonction isclose( poly_eval([2, 0, -1], -sqrt(2)), 3.0 ) est fausse')
 
if not isclose( poly_eval([2, 0, -1], -1.0), 1.0):
    print ('L appel de la fonction isclose( poly_eval(poly_eval([2, 0, -1], -1.0), 1.0 ) est fausse')
 
if not isclose(poly_eval([2, 0, -1], -1.0), 1.0):
    print ('L appel de la fonction isclose(poly_eval([2, 0, -1], -1.0), 1.0) est fausse')

Et enfin une fonction permettant de résoudre une équation du 2nd degré :

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
38
39
40
41
42
43
44
45
46
47
48
49
def poly_quadratique(poly):
 
    solutions=[]
 
    if poly_degre(poly)!=2:
        return 'None'
 
    A=poly[0]
    B=poly[1]
    C=poly[2]
 
 
 
    delta=B*B-4*A*C # On calcule delta, le discriminant, en fonction de A,B et C
 
 
    if delta <0:
        return (solutions) # Lorsque delta est négatif, il n'y a pas de solutions
    if delta==0:
        x=-B/2*A # Calcul de X
        solutions+=[x]
        return (solutions)
    if delta >0:
        racine_carre_delta=sqrt(delta) # On calcul la racine carré de delta
        k=-B-racine_carre_delta # Variable qui va intervenir dans le calcul de X1
        l=-B+racine_carre_delta # Variable qui va intervenir dans le calcul de x2
        m=2*A # Variable qui va intervenir dans le calcul de X1 et X2
        x1=k/m # Calcul de X1
        x2=l/m # Calcul de X2
        solutions+=[x1,x2]
        return (solutions)
 
if not isclose(  poly_quadratique([1, 0, -2])[0], -sqrt(2)  ):
    print ('L appel de la fonction isclose(  poly_quadratique([1, 0, -2])[0], -sqrt(2)  ) est fausse')
 
if not isclose(  poly_quadratique([1, 0, -2])[1], sqrt(2)  ):
    print ('L appel de la fonction isclose(  poly_quadratique([1, 0, -2])[1], sqrt(2)  ) est fausse')
 
if  poly_quadratique([1, 0, 1])!=[]:
    print ('La fonction poly_quadratique([1, 0, 1])!=[] n a pas de solutions')
 
if  poly_quadratique([1, 0, 0])!=[0.0]:
    print ('La fonction poly_quadratique([1, 0, 0])!=[0.0] ne renvoie pas les bonnes racines')
 
if  poly_quadratique([1, 0])!='None':
    print ('La fonction poly_quadratique([1, 0])!=[None] n est pas une fonction du 2nd degré')
 
if  poly_quadratique([1,0,0,0])!='None':
    print ('La fonction poly_quadratique([1,0,0,0])!=None n est pas une fonction du 2nd degré')

J'aurai donc besoin d'aide pour l'élaboration de plusieurs fonctions.

Tout d'abord, il faudrait que j'obtienne une fonction poly_complete(poly,n) qui complète une représentation avec des 0 jusqu'à n.

Exemples :

• poly_complete([2, 0, -1], 1) → [2, 0, -1]
• poly_complete([2, 0, -1], 2) → [2, 0, -1]
• poly_complete([2, 0, -1], 3) → [0, 2, 0, -1]
• poly_complete([1], 0) → [1]
• poly_complete([1], 1) → [0, 1]
• poly_complete([], 0) → [0]
• poly_complete([], 1) → [0, 0]
• poly_complete([], 2) → [0, 0, 0]

[Sve@r]

Bonjour

Code :

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

1
2
3
4
def poly_degre(poly):
    a=poly_simple(poly)
    degré=len(a)-1
    return degré

Code python :

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

1
2
def poly_degre(poly):
	return len(poly_simple(poly))-1

Et enfin une fonction permettant de résoudre une équation du 2nd degré :

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
def poly_quadratique(poly):
 
    solutions=[]
 
    if poly_degre(poly)!=2:
        return 'None'
 
    A=poly[0]
    B=poly[1]
    C=poly[2]
 
 
 
    delta=B*B-4*A*C # On calcule delta, le discriminant, en fonction de A,B et C
 
 
    if delta <0:
        return (solutions) # Lorsque delta est négatif, il n'y a pas de solutions
    if delta==0:
        x=-B/2*A # Calcul de X
        solutions+=[x]
        return (solutions)
    if delta >0:
        racine_carre_delta=sqrt(delta) # On calcul la racine carré de delta
        k=-B-racine_carre_delta # Variable qui va intervenir dans le calcul de X1
        l=-B+racine_carre_delta # Variable qui va intervenir dans le calcul de x2
        m=2*A # Variable qui va intervenir dans le calcul de X1 et X2
        x1=k/m # Calcul de X1
        x2=l/m # Calcul de X2
        solutions+=[x1,x2]
        return (solutions)

T'es sûr pour la string None retournée au début? Il y a tant d'objets Python permettant de retourner un état (True, False, None) que retourner une string pour indiquer ledit état est assez mal vu. Une string implique une notion de langage qui dépend aussi du lecteur. Et au retour, comparer deux strings est plus long que comparer deux états. En plus retourner une string "None" est tellement tompeur par rapport à l'état None...
Ensuite pas de parenthèses au return. Et enfin au lieu de créer le tableau "solutions" à partir des solutions puis retourner le tableau, autant retourner directement les solutions...

Code python :

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

1
2
3
4
5
6
7
8
9
	if delta <0: return [] # Lorsque delta est négatif, il n'y a pas de solutions
 
	A*=2 # Ben oui, le A initial ne sert plus à rien...
	B=-B/A
	if delta==0: return [B,]
 
	# Evident que ici delta >0 !!!
	r=sqrt(delta)/A
	return [B-r, B+r]

J'aurai donc besoin d'aide pour l'élaboration de plusieurs fonctions.

Tout d'abord, il faudrait que j'obtienne une fonction poly_complete(poly,n) qui complète une représentation avec des 0 jusqu'à n.

Exemples :

• poly_complete([2, 0, -1], 1) → [2, 0, -1]
• poly_complete([2, 0, -1], 2) → [2, 0, -1]
• poly_complete([2, 0, -1], 3) → [0, 2, 0, -1]
• poly_complete([1], 0) → [1]
• poly_complete([1], 1) → [0, 1]
• poly_complete([], 0) → [0]
• poly_complete([], 1) → [0, 0]
• poly_complete([], 2) → [0, 0, 0]

Code python :

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

1
2
3
def poly_complete(poly, n):
	if len(poly) > n: return poly
	return [0,] * (n - len(poly) + 1) + poly

[Avi.Py]

Bonjour

Code python :

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

1
2
def poly_degre(poly):
	return len(poly_simple(poly))-1

T'es sûr pour la string None retournée au début? Il y a tant d'objets Python permettant de retourner un état (True, False, None) que retourner une string pour indiquer ledit état est assez mal vu. Une string implique une notion de langage qui dépend aussi du lecteur. Et au retour, comparer deux strings est plus long que comparer deux états. En plus retourner une string "None" est tellement tompeur par rapport à l'état None...
Ensuite pas de parenthèses au return. Et enfin au lieu de créer le tableau "solutions" à partir des solutions puis retourner le tableau, autant retourner directement les solutions...

Code python :

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

1
2
3
4
5
6
7
8
9
	if delta <0: return [] # Lorsque delta est négatif, il n'y a pas de solutions
 
	A*=2 # Ben oui, le A initial ne sert plus à rien...
	B=-B/A
	if delta==0: return [B,]
 
	# Evident que ici delta >0 !!!
	r=sqrt(delta)/A
	return [B-r, B+r]

Merci pour toute ton aide!
Pour ce qui est du 'None' je suis contraint d'utiliser un str puisque j'ai comme consigne de renvoyer l'information "None" a l'utilisateur. Si j'utilise directement le caractère None tel quel le résultat de l'appel de la fonction renverra "rien" à l'utilisateur pour l'informer que la fonction saisie n'est pas une fonction du 2nd degré.

J'aurai donc besoin d'aide pour l'élaboration de plusieurs fonctions.

Code python :

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

1
2
3
def poly_complete(poly, n):
	if len(poly) > n: return poly
	return [0,] * (n - len(poly) + 1) + poly

Pourrais tu m'expliquer cette ligne en particulier je n'arrive pas a bien l'interpréter :

Code :

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

return [0,] * (n - len(poly) + 1) + poly

J'aurai donc besoins de plusieurs autres fonctions me permettant d'effectuer plusieurs types d'opérations ( additionner, dériver, multiplier ):

L'addition tel que poly_addition(poly_1, poly_2)

• poly_addition([], [2, 0, 1]) → [2, 0, 1]
• poly_addition([2, 0, 1], []) → [2, 0, 1]
• poly_addition([3, 1, 1], [3, 0, 2, 2]) → [3, 3, 3, 3]
• poly_addition([2, 0, 1], [-2, 0, 1]) → [2]

La dérivation tel que poly_derive(poly)

• poly_derive([2, 0, 1])→ [4, 0]
• poly_derive([3, 0, 2, 2]) → [9, 0, 2]

et la multiplication poly_produit(poly_1, poly_2)

• poly_produit([5, 3, 2], [1]) → [5, 3, 2]
• poly_produit([5, 3, 2], []) → []
• poly_produit([5, 3, 2], [11, 7]) → [55, 68, 43, 14]
• poly_produit([11, 7], [5, 3, 2]) → [55, 68, 43, 14]
• poly_produit([1, 1], [1, 1]) → [1, 2, 1]

Je n'arrive pas a manipuler correctement les listes pour effectuer toutes ces opérations, si vous pouvez m'éclairez la dessus cela m'aiderait grandement merci encore !

[wiztricks]

Je n'arrive pas a manipuler correctement les listes pour effectuer toutes ces opérations, si vous pouvez m'éclairez la dessus cela m'aiderait grandement merci encore !

Profitez en pour revoir votre cours sur les listes ou ouvrir un tuto... et essayez de faire quelque chose avec ce que vous avez compris plutôt que d'attendre qu'on écrive le code pour vous.

- W

[Sve@r]

Pour ce qui est du 'None' je suis contraint d'utiliser un str puisque j'ai comme consigne de renvoyer l'information "None" a l'utilisateur.

Je pense que le créateur parle bel et bien de l'état "None" qu'il nomme ici "information".

Si j'utilise directement le caractère None tel quel le résultat de l'appel de la fonction renverra "rien" à l'utilisateur pour l'informer que la fonction saisie n'est pas une fonction du 2nd degré.

Ne confond pas "rien" et "None". None c'est "quelque chose de concret signifiant rien" mais ça reste quelque chose. De plus, toute fonction Python renvoie toujours quelque chose et si le programmeur ne met pas de return explicite alors elle retourne None

Code python :

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

1
2
3
4
5
6
7
8
9
>>> def fct(): pass
...
>>> a=fct()
>>> print(a)
None
>>> print(a is None)
True
>>> print("la fonction a marché" if a is None else "")
la fonction a marché

Pourrais tu m'expliquer cette ligne en particulier je n'arrive pas a bien l'interpréter :

Code :

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

return [0,] * (n - len(poly) + 1) + poly

Un code d'exemple n'est pas fait pour rester passif devant en attendant qu'une lumière s'allume au plafond. Tu as aussi le droit de t'en inspirer pour faire tes propres tests...

Code :

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

1
2
3
4
>>> ["toto",]*10
['toto', 'toto', 'toto', 'toto', 'toto', 'toto', 'toto', 'toto', 'toto', 'toto']
>>> >>> ["toto",]*5 + ["titi",]*2
['toto', 'toto', 'toto', 'toto', 'toto', 'titi', 'titi']

Je n'arrive pas a manipuler correctement les listes pour effectuer toutes ces opérations, si vous pouvez m'éclairer la dessus cela m'aiderait grandement merci encore !

Ben l'addition donnera un nouveau polynome contenant l'addition de chaque coefficient de son rang (0 pour un rang non écrit). Exemple [3, 1, 1] + [3, 0, 2, 2] = [0, 3, 1, 1] + [3, 0, 2, 2] = [0+3, 3+0, 1+2, 1+2]
Pour la dérivée c'est pas non plus super compliqué. La dérivée de x^n c'est nx^(n-1). Et (kf)' ("k" coefficient multiplicateur, "f" fonction à dériver) = k(f'). Ainsi la dérivée de x^3 c'est 3x² donc la dérivée de 4x^3 c'est 4*3x² soit 12x². Donc la dérivée de [3, 0, 2, 2] (sous-entendu 3x^3 + 0x² + 2x + 2 c'est 3*(3x²) + 0x + 2 soit [9, 0, 2]. Bref juste un décalage dans la liste

Et pour la multiplication de polynomes, suffit d'appliquer (5x² + 3x + 2) * (11x + 7) => (5x² * 11x) + (5x²*7+3x*11x) + (3x*7 + 11x*2) + (7*2) = 55x^3 + (33+35)x² + (21+22)x + 14 = 55x^3 + 68x² + 43x + 14. Là à mon avis le moins compliqué sera de toujours positionner le polynöme de degré le plus haut soit toujours à gauche soit toujours à droite de l'autre.

[Avi.Py]

Merci énormément pour tout vos commentaires ! Je vais essayer de continuer et je reviendrai vers vous quand j'aurai mes fonctions

[marco056]

Un code d'exemple n'est pas fait pour rester passif devant en attendant qu'une lumière s'allume au plafond. Tu as aussi le droit de t'en inspirer pour faire tes propres tests...

Code :

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

1
2
3
4
>>> ["toto",]*10
['toto', 'toto', 'toto', 'toto', 'toto', 'toto', 'toto', 'toto', 'toto', 'toto']
>>> >>> ["toto",]*5 + ["titi",]*2
['toto', 'toto', 'toto', 'toto', 'toto', 'titi', 'titi']

Désolé de perturber votre discussion mais j'ai une question : à quoi sert la virgule ? C'est une vraie question et non de la provoc à 2 balles.

Code :

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

1
2
3
4
5
6
>>> ["toto",]*5 + ["titi",]*2
['toto', 'toto', 'toto', 'toto', 'toto', 'titi', 'titi']
>>> ["toto"]*5 + ["titi"]*2
['toto', 'toto', 'toto', 'toto', 'toto', 'titi', 'titi']
>>> ["toto"]*10
['toto', 'toto', 'toto', 'toto', 'toto', 'toto', 'toto', 'toto', 'toto', 'toto']

[Avi.Py]

J'ai donc réussi à avancer sur les fonctions addition et multiplication mais sans grand résultat.

Pour l'addition j'ai commencé avec le code suivant :

Code :

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

1
2
3
4
5
6
7
def poly_addition(poly_1,poly_2):
 
    res=[]
 
    res=[x+y for x, y in zip(poly_1,poly_2)]
 
    return res

Mais le résultat n'est pas bon :

Code :

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

1
2
3
4
>> poly_addition([], [2, 0, 1])
[]
>>poly_addition([3, 1, 1], [3, 0, 2, 2])
[6, 1, 3]

J'ai donc essayer avec un code différent :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 poly_1=len(poly_1)
  poly_2=len(poly_2)
 
  if poly_1<poly_2:
    POLY_1=[0]*(poly_2-poly_1)+POLY_1
  else:
    POLY_2=[0]*(poly_1-poly_2)+POLY_2
 
  S=[sum(C) for C in zip(poly_1,poly_2)]
 
  return S

Mais la aussi ça ne fonctionne pas.

EDIT: J'ai continué a travailler sur la fonction et j'ai obtenue une fonction addition qui fonctionne. Le problème est que je n'arrive pas paramétrer le sens de lecture de la liste dans le sens demandé:

Code :

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

1
2
3
4
5
6
7
8
9
10
def poly_addition(poly_1,poly_2):
 
    poly_11=poly_1[::-1]
    poly_22=poly_2[::-1]
 
    if len(poly_11)>len(poly_22) : new = [0]*len(poly_11) 
    else : new = [0]*len(poly_22) 
    for i in range(len(poly_11)): new[i]+= poly_11[i] 
    for i in range(len(poly_22)): new[i]+= poly_22[i] 
    return new

Par exemple pour l'appel de la fonction >>• poly_addition([3, 1, 1], [3, 0, 2, 2]) → [3, 3, 3, 3]
Mais pour le reste je n'arrive pas y arriver.

Pour la multiplication :

Code :

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

1
2
3
4
5
6
7
8
9
10
def poly_produit(poly_1,poly_2):
 
    poly_1=poly_1[:]
    poly_2=poly_2[:]
    R=[0]*(len(poly_1)+len(poly_2))
 
    for (i,a) in enumerate(poly_1):
      for (j,b) in enumerate(poly_2):
        R[i+j]+=a*b
      return R

Je n'y arrive également pas.

Et pour la dérivé je n'arrive pas a comprendre comment je dois m'y prendre.

[marco056]

Il suffirait peut-être de prendre une feuille de papier et un crayon pour le faire à la main puis de le programmer.
De là où je suis, cela semble quand même assez trivial.

[Sve@r]

Désolé de perturber votre discussion mais j'ai une question : à quoi sert la virgule ? C'est une vraie question et non de la provoc à 2 balles.

Pas de souci. C'est une habitude issue des tuples. Dans un tuple, la virgule est obligatoire. C'est même elle qui fait le tuple et non les parenthèses

Code python :

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

1
2
3
4
5
6
>>> a=1,
>>> type(a)
<class 'tuple'>
>>> a=(1)
>>> type(a)
<class 'int'>

Les parenthèses étant toutefois très souvent nécessaire, j'ai pris l'habitiude de les mettre tout le temps pour mes tuples (a=(1,)). Et par souci d'homogénéité, j'ai donc pris l'habitude de mettre aussi la virgule pour les listes bien que ce ne soit pas nécessaire (mais pas non plus interdit) => a=[1,]. Ainsi, remplacer si besoin une liste par un tuple (et inversement) se fait très rapidement.

Pour l'addition j'ai commencé avec le code suivant :

Code :

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

1
2
3
4
5
6
7
def poly_addition(poly_1,poly_2):
 
    res=[]
 
    res=[x+y for x, y in zip(poly_1,poly_2)]
 
    return res

Mais le résultat n'est pas bon :

Code :

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

1
2
3
4
>> poly_addition([], [2, 0, 1])
[]
>>poly_addition([3, 1, 1], [3, 0, 2, 2])
[6, 1, 3]

J'ai donc essayé avec un code différent :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 poly_1=len(poly_1)
  poly_2=len(poly_2)
 
  if poly_1<poly_2:
    POLY_1=[0]*(poly_2-poly_1)+POLY_1
  else:
    POLY_2=[0]*(poly_1-poly_2)+POLY_2
 
  S=[sum(C) for C in zip(poly_1,poly_2)]
 
  return S

Mais la aussi ça ne fonctionne pas.

C'est parce que zip() ne zippe que les éléments présents. Si t'as 2 listes de tailles différentes, il s'arrête à la plus courte des deux (c'est quand-même bien aussi de regarder ce que font les choses qu'on veut utiliser => print(tuple(zip(range(3), range(8))))). Et c'est peut-être aussi pas pour rien qu'on t'a fait écrire une fonction "poly_complete()" que je t'ai écrite et que t'as donc pas besoin de refaire si maladroitement !!!
Et attention aux participes passés (2 fois que je corrige). L'orthographe sert à indiquer le sens d'un mot (peau/pot) et la grammaire sert à indiquer le sens de la phrase (a essayé/à essayer).

J'ai continué a travailler sur la fonction et j'ai obtenue une fonction addition qui fonctionne. Le problème est que je n'arrive pas paramétrer le sens de lecture de la liste dans le sens demandé:

Code :

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

1
2
3
4
5
6
7
8
9
10
def poly_addition(poly_1,poly_2):
 
    poly_11=poly_1[::-1]
    poly_22=poly_2[::-1]
 
    if len(poly_11)>len(poly_22) : new = [0]*len(poly_11) 
    else : new = [0]*len(poly_22) 
    for i in range(len(poly_11)): new[i]+= poly_11[i] 
    for i in range(len(poly_22)): new[i]+= poly_22[i] 
    return new

Bah, tu remplaces return new par return list(reversed(new)) comme ça ton code tout branquignole qu'il est fonctionnera quand-même. Sans déconner, ton premier code était super, t'avais juste qu'à commencer par compléter la plus courte des deux listes et c'était fini et tu es parti dans des trucs à 2 ronds...

Pour la multiplication Je n'y arrive également pas.

La multiplication ce n'est pas "chaque item par chaque item" comme tu l'as fait, c'est pour chaque item1 de rang n1 (n1 comptés à partir de la droite), pour chaque item2 de rang n2 (même comptage), res[n1+n2]+=item1*item2
Exemple [4, 5, 6] * [7, 8, 9] c'est [4 (rang 2), 5 (rang 1), 6 (rang 0)] * [7 (rang 2), 8 (rang 1), 9 (rang 0)] ce qui donnera

• 4 (rang 2) * 7 (rang 2) = 28 (rang 4)
• 4 (rang 2) * 8 (rang 1) + 5 (rang 1) * 7 (rang 2) = 32 + 35 (rang 3)
• 4 (rang 2) * 9 (rang 0) + 5 (rang 1) * 8 (rang 1) + 6 (rang 0) * 7 (rang 2) = 36 + 40 + 42 (rang 2)
• 5 (rang 1) * 9 (rang 0) + 6 (rang 0) * 8 (rang 1) = 45 + 48 (rang 1)
• 6 (rang 0) * 9 (rang 0) = 54 (rang 0)

soit [28, 67, 118, 93, 54]

Le détail ici : http://www.afkw.org/pythagore/concep...iplication.pdf

Et pour la dérivé je n'arrive pas a comprendre comment je dois m'y prendre.

Chaque item de rang n (n commençant à 0 et compté à partir de la droite) devient lui-même multiplié par n mais est placé au rang n-1. Exemple [7 (rang 3), 8 (rang 2), 4 (rang 1), 12 (rang 0)] devient [7*3 (rang 2), 8*2 (rang 1), 4*1 (rang 0)] et le [12] disparait.

[marco056]

Merci Sve@r

[Avi.Py]

C'est parce que zip() ne zippe que les éléments présents. Si t'as 2 listes de tailles différentes, il s'arrête à la plus courte des deux (c'est quand-même bien aussi de regarder ce que font les choses qu'on veut utiliser => print(tuple(zip(range(3), range(8))))). Et c'est peut-être aussi pas pour rien qu'on t'a fait écrire une fonction "poly_complete()" que je t'ai écrite et que t'as donc pas besoin de refaire si maladroitement !!!
Et attention aux participes passés (2 fois que je corrige). L'orthographe sert à indiquer le sens d'un mot (peau/pot) et la grammaire sert à indiquer le sens de la phrase (a essayé/à essayer).


Bah, tu remplaces return new par return list(reversed(new)) comme ça ton code tout branquignole qu'il est fonctionnera quand-même. Sans déconner, ton premier code était super, t'avais juste qu'à commencer par compléter la plus courte des deux listes et c'était fini et tu es parti dans des trucs à 2 ronds...

A force de faire et refaire y a bien un moment ou je vais réussir a comprendre J'ai donc obtenu le code suivant pour que chaque liste soit de la même longueur :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
def poly_addition(poly_1,poly_2):
 
    res=[]
    degre_1=poly_degre(poly_1)
    degre_2=poly_degre(poly_2)
    if poly_1<poly_2:
      poly_1=poly_complete(poly_1,degre_2)
      res=[x+y for x, y in zip(poly_1,poly_2)]
    else:
      poly_2=poly_complete(poly_2,degre_1)
      res=[x+y for x, y in zip(poly_1,poly_2)]
 
    return res

Tous mes appels de fonctions sont donc juste, j'ai quand même un petit soucis au niveau des 0, par exemple l'appel de la fonction poly_addition([2, 0, 1], [-2, 0, 1]) renvoie [0,0,2] et pas [2]
J'essayerai de plus faire des fonctions bancales pour les prochaines promis

Je vais donc attaquer la fonction multiplication maintenant.

[Sve@r]

A force de faire et refaire y a bien un moment ou je vais réussir a comprendre

Exact. C'est comme ça que ça rentre.

J'ai donc obtenu le code suivant pour que chaque liste soit de la même longueur :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
def poly_addition(poly_1,poly_2):
 
    res=[]
    degre_1=poly_degre(poly_1)
    degre_2=poly_degre(poly_2)
    if poly_1<poly_2:
      poly_1=poly_complete(poly_1,degre_2)
      res=[x+y for x, y in zip(poly_1,poly_2)]
    else:
      poly_2=poly_complete(poly_2,degre_1)
      res=[x+y for x, y in zip(poly_1,poly_2)]
 
    return res

Pas besoin de répéter res=.... Tu le sors du bloc if/else. Et (si tu réfléchis bien) tu n'avais même pas besoin de tester lequel des deux compléter...

Code python :

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

1
2
3
def poly_addition(poly_1,poly_2):
	m=max(len(poly_1), len(poly_2))
	return [x+y for (x, y) in zip(poly_complete(poly_1, m), poly_complete(poly_2, m))]

Tous mes appels de fonctions sont donc juste, j'ai quand même un petit soucis au niveau des 0, par exemple l'appel de la fonction poly_addition([2, 0, 1], [-2, 0, 1]) renvoie [0,0,2] et pas [2]

Tu te souviens de poly_simple() que tu as fait au début???

Je vais donc attaquer la fonction multiplication maintenant.

Courage !!! Pense au début à créer un polynome rempli de 0 et ayant pour longueur la somme des longueurs des 2 polynomes à multiplier - 1. Ensuite pense aussi à renverser tes polynomes via reversed() avant de partir dans les boucles. Ca te permettra d'utiliser enumerate() avec le rang dans le bon sens. Suffira au final de renvoyer un list(reversed(res)) pour avoir ton résultat dans le bon sens...

[Avi.Py]

=Sve@r;11729886]Exact. C'est comme ça que ça rentre.


Pas besoin de répéter res=.... Tu le sors du bloc if/else. Et (si tu réfléchis bien) tu n'avais même pas besoin de tester lequel des deux compléter...

Code python :

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

1
2
3
def poly_addition(poly_1,poly_2):
	m=max(len(poly_1), len(poly_2))
	return [x+y for (x, y) in zip(poly_complete(poly_1, m), poly_complete(poly_2, m))]

Tu te souviens de poly_simple() que tu as fait au début???

Ma fonction addition est complète et optimale, merci pour toute ton aide.

Courage !!! Pense au début à créer un polynome rempli de 0 et ayant pour longueur la somme des longueurs des 2 polynomes à multiplier - 1. Ensuite pense aussi à renverser tes polynomes via reversed() avant de partir dans les boucles. Ca te permettra d'utiliser enumerate() avec le rang dans le bon sens. Suffira au final de renvoyer un list(reversed(res)) pour avoir ton résultat dans le bon sens...

J'ai un peu peur de décevoir parceque je crois bien que je vais vous présenter une fonction à "2 ronds"

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 poly_produit(poly_1,poly_2):
 
   res_produit=[len(poly_1)+len(poly_2)]-1
   i=0
   poly_1_produit=reversed(poly_1)
   poly_2_produit=reversed(poly_2)
   if poly_1>poly_2:
     for i in range(len(poly_1_produit)):
      res_produit=poly_1_produit[i]*poly_2_produit[i]
   else:
    for i in range(len(poly_2_produit)):
      res_produit=poly_1_produit[i]*poly_2_produit[i]
 
   return list(reversed(res_produit))

[marco056]

Le "i = 0" semble ne pas servir à grand chose

[Sve@r]

Ma fonction addition est complète et optimaleTa fonction addition est bien mieux que la mienne, merci pour toute ton aide.

De rien.

J'ai un peu peur de décevoir parceque je crois bien que je vais vous présenter une fonction à "2 ronds"

Ce n'est pas la manière qui compte (enfin pas trop) mais la matière. Pour l'addition, la matière y était donc je t'ai montré comment faire pareil en mieux. Mais là, la matière n'y est pas.
Tout ce que tu faits, c'est l'équivalent d'une addition => tu multiplies les termes de même rang. Pour [4, 5, 6] * [7, 8, 9] tu faits [4*7, 5*8, 6*9], ce qui n'a rien à voir avec la multiplication que j'ai expliquée, qui est expliquée dans le PDF dont je t'ai donné le lien ou avec les exemples de multiplications de ton TP. [4, 5, 6] * [7, 8, 9] ne fait pas [28, 40, 54] mais [28, 67, 118, 93, 54]. Remarque avec ta méthode tu obtiens quand-même les premier et dernier termes corrects.
Et en plus tu retombes dans tes travers du début avec ton if poly_1>poly_2. Que va faire cette instruction? Comment te représentes-tu un polynome 1 plus petit (ou plus grand) qu'un polynome 2??? Et en plus ça sert à rien car [2, 3] * [4, 5, 6] = [4, 5, 6] * [2, 3] (tu peux prendre l'algo sur le polynome le plus petit qui multiplie le plus grand, ou sur le plus grand qui multiplie le plus petit, il fonctionne pareil car il traite la totalité des deux polynomes)

Le "i = 0" semble ne pas servir à grand chose

T'as remarqué qu'il écrase son res_produit à chaque itération ?

[Avi.Py]

Ce n'est pas la manière qui compte (enfin pas trop) mais la matière. Pour l'addition, la matière y était donc je t'ai montré comment faire pareil en mieux. Mais là, la matière n'y est pas.
Tout ce que tu faits, c'est l'équivalent d'une addition => tu multiplies les termes de même rang. Pour [4, 5, 6] * [7, 8, 9] tu faits [4*7, 5*8, 6*9], ce qui n'a rien à voir avec la multiplication que j'ai expliquée, qui est expliquée dans le PDF dont je t'ai donné le lien ou avec les exemples de multiplications de ton TP. [4, 5, 6] * [7, 8, 9] ne fait pas [28, 40, 54] mais [28, 67, 118, 93, 54]. Remarque avec ta méthode tu obtiens quand-même les premier et dernier termes corrects.
Et en plus tu retombes dans tes travers du début avec ton if poly_1>poly_2. Que va faire cette instruction? Comment te représentes-tu un polynome 1 plus petit (ou plus grand) qu'un polynome 2??? Et en plus ça sert à rien car [2, 3] * [4, 5, 6] = [4, 5, 6] * [2, 3] (tu peux prendre l'algo sur le polynome le plus petit qui multiplie le plus grand, ou sur le plus grand qui multiplie le plus petit, il fonctionne pareil car il traite la totalité des deux polynomes)

Je crois comprendre ne croyez pas que je fais rien vu les erreurs bêtes qu'il y a dans mon code

T'as remarqué qu'il écrase son res_produit à chaque itération ?

Code :

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

1
2
3
4
5
6
7
8
9
def poly_produit(poly_1,poly_2):
 
    Poly_produit_1 = poly_simple(poly_1[:])
    Poly_produit_2 = poly_simple(poly_2[:])
    Produit = [0] * (len(Poly_produit_1)+len(Poly_produit_2)+1)
    for (i,a) in enumerate(Poly_produit_1):
     for (j,b) in enumerate(Poly_produit_2):
      Produit[i+j] += a * b
    return poly_simple((Produit))

Qui fonctionne malgré un petit soucis. J'utilise donc poly_simple pour enlever tous les 0 inutiles mais la fonction renvoie quand même des 0 inutiles.

Par exemple pour l'appel de la fonction poly_produit([1, 3, 3, 1], [1, 1]) -> [1, 4, 6, 4, 1, 0, 0] au lieu de [1, 4, 6, 4, 1]