Python définir une fonction logarithme

Bonjour,

Je suis nouveau sur le forum,

Je vous poste ce message car j’ai besoin d’aide pour un exercice de mathématiques dans lequel il y a de la programmation.

Je dois défini dans le langage Python, la fonction f(x)=ln(1+x) qui pour tout x donné teste si x appartient à I=]-1;+infini[ avant de renvoyer la valeur de la fonction f. Le programme devra afficher un message d’erreur si x n’appartient pas à I.

Bonjour,

Qu’as-tu déjà tenté ? Qu’est-ce qui te bloque exactement ?

Connais-tu la fonction logarithme fournit de base par Python ? Est-ce que tu sais définir une fonction en Python ?

Bonjour Aabu,

Ce qui me bloque le plus c’est la liste, sinon j’ai déjà avancé comme je pouvais :

from math import*
x=50 "par exemple"
I=[-1,inf] "sauf que -1 doit être exclu et je ne crois pas que inf existe sur Python"
def f(x):
  if x in I:
    return log(1+x)
    print(log(1+x))
  else:
    print("x n'appartient pas à I")

D’accord, je comprends ton problème. Tu es confus sur la notation des listes en Python et la notation mathématiques des intervalles.

En Python, la notation [a, b, ...] sert à créer une liste. Une liste n’est rien d’autre qu’une séquence d’éléments. Un élément appartient à la liste s’il y apparaît au moins une fois, ce que teste l’opérateur in. Tu ne peux pas représenter un intervalle de réels avec une liste, parce qu’un intervalle contient une infinité (indénombrable qui plus est) de valeurs.

En mathématiques, on note $[a, b[$ tous les réels compris entre a (inclus) et b (exclus). Il n’y a pas de notation spéciale en Python pour noter un intervalle, et il n’y a pas non plus d’opérateur pour l’appartenance.

Cela veut dire que pour savoir si un nombre est dans un intervalle en Python (dont on connaît les bornes a et b), il faut tester qu’il est plus grand ou égal à a et plus petit strictement que b. On peut le faire à l’aide des opérateurs de comparaison.

À noter que inf existe en Python, mais il n’est pas prévu de s’en servir dans ces cas normaux (et donc tu ne peux pas juste écrire inf).

Merci de ta réponse Aabu, mais comment je dois créer une liste qui décrit l’intervalle I=]-1;+infini[ où -1 est exclu ? Car si je tape : I=[-1,10^9[ (je prends 10^9 car je ne peux pas écrire inf) -1 n’est pas exclu de mon intervalle.

Justement, tu ne peux pas écrire une liste qui décrit un intervalle. Par contre, tu peux traduire la définition de l’intervalle en terme de comparaisons.

Par exemple mathématiquement :

$e \in ]a, b[ \Leftrightarrow a < e~\mathrm{et}~e < b$

La partie droite se traduit très facilement en Python ; je te laisse quand même adapter à ton cas à toi.

Cela donnerai donc :

from math import*
def f(x):
  if x>-1:
    return log(1+x)
    print(log(1+x))
  else:
    print("x n'appartient pas à I")

Et ça fonctionne!!

Merci beaucoup Aabu

Salut,

La condition x > -1 est bonne. En revanche, ton code ne vas pas s’exécuter en l’état. Les commentaires se marquent avec #. Du texte entre guillemets est une chaîne, donc la ligne x=50 "par exemple" n’est pas valide en Python. EDIT : tu l’as enlevé entre temps.

Ensuite, le print après le return ne sera jamais exécuté, vois-tu pourquoi ?

Enfin, le code que tu as écrit se contente de définir une fonction, mais ne l’appelle pas. Donc même après avoir corrigé les points que je soulève, il ne se passera rien lorsque tu vas exécuter ton script.

Bonjour adr1,

Merci j’avais oublié qu’il fallait mettre # pour les commentaires

Mais je viens de tester le programme suivant :

from math import*
def f(x):
  if x>-1:
    return log(1+x)
  else:
    print("x n'appartient pas à I")

Et ce programme fonctionne très bien

Dans mon commentaire, je parlais du print(log(x+1)) après le return, qui ne pouvait jamais être atteint puisque return te fait sortir de la fonction.

Par ailleurs, je suppose que tu exécutes ton script dans un IDE qui te permet d’appeler f par la suite, mais le programme que tu as posté ici ne fait rien à part définir une fonction. Si c’est ce qu’on vous demande, c’est très bien, mais c’est un peu étrange…

Oui c’est ce qu’on nous demande, enfin c’est le début.

J’avais une autre question à poser d’ailleurs. Notre professeur nous demande de construire une fonction représentation qui ne prend pas d’argument (pas de 'x’), mais qui affiche les courbes associées aux fonction f(x)=ln(1+x), g(x)=x-x²/2 et h(x)=x sur l’ensemble de définition qui est [0;+infini[.

J’ai commencé à faire ça:

from math import*
from matplotlib.pyplot import*
x=arange(-10,10,0.01)
y_1=log(1+x)
y_2=x-x²/2
y_3=x
plot(x,y_1)
plot(x,y_2)
plot(x,y_3)

Notre professeur nous demande de construire une fonction représentation qui ne prend pas d’argument (pas de 'x’), mais qui affiche les courbes associées aux fonction f(x)=ln(1+x), g(x)=x-x²/2 et h(x)=x sur l’ensemble de définition qui est [0;+infini[.

Même questions que dans la première réponse. Qu’est-ce que tu as essayé et qu’est-ce qui te bloque ?

J’étais en train de modifier mon message, j’ai fait ça :

from math import*
from matplotlib.pyplot import*
x=arange(-10,10,0.01)
y_1=log(1+x)
y_2=x-x²/2
y_3=x
plot(x,y_1)
plot(x,y_2)
plot(x,y_3)
show()

’étais en train de modifier mon message

Prends le temps d’écrire tes messages, il n’y a pas le feu. C’est plus simple si tu postes directement un message "fini" plutôt que si on se mélange entre les réponses et les éditions.

Ton code est pas mal, mais arange est défini dans numpy qu’il te faut donc importer.

Par ailleurs, tu définis x comme $[-10,10]$ alors qu’on te donne un ensemble de définition de $[0,+\infty[$. Bien évidemment, tu ne peux pas faire un graphique qui va jusqu’à l’infini, donc il va falloir une borne supérieure plus raisonable (et tu n’as pas besoin d’aller très haut de toute façon, 10 par exemple convient vu que le comportement intéressant de ces fonctions se passe relativement près de $0$).

J’obtiens donc :

import numpy as np
from math import*
from matplotlib.pyplot import*
x=arange(0,10,0.01)
y_1=log(1+x)
y_2=x-x²/2
y_3=x
plot(x,y_1)
plot(x,y_2)
plot(x,y_3)
show()

Mais je n’ai pas de fonction représentation comme mon professeur me le demande

Attention, import numpy as np n’importe pas le contenu du module dans le contexte courant, donc arange n’est pas accessible directement. Il faut taper np.arange pour y accéder.

Par ailleurs, il te faudra utiliser la fonction np.log pour pouvoir calculer le log élément par élément de ton tableau (et tu n’as alors plus besoin de from math import *).

Mais je n’ai pas de fonction représentation comme mon professeur me le demande

Ben il te suffit de mettre le code que tu as écrit dans un bloc def representation():.

Au final j’ai fait autrement mais ça fonctionne :

from math import*
from pylab import*
def representation():
  x=arange(0,10,0.01)
  y_1=log(1+x)
  y_2=x-(x**2/2)
  y_3=x
  plot(x,y_1)
  plot(x,y_2)
  plot(x,y_3)
  show()

En fait tu as fait exactement pareil sans le savoir. pylab importe plein de chose, notamment from numpy import * et from matplotlib.pyplot import *. Note que le log que tu utilises est donc celui de numpy, et donc que ton from math import * est inutile. Cette collision des noms est la raison pour laquelle utiliser des from <package> import * est une mauvaise pratique (mais malheureusement sûrement celle qui est enseignée en lycée…) et que pylab est une horreur pour gérer proprement ses dépendances…

D’accord, comment aurait tu fais donc ? Pour connaître la bonne méthode

Quelque chose comme ça pour se débarrasser des imports implicites :

import numpy as np
import matplotlib.pyplot as plt

def representation():
    x = np.arange(0, 10, 0.01)
    plt.plot(x, np.log(1 + x))
    plt.plot(x, x - x**2 / 2)
    plt.plot(x, x)
    plt.show()

Merci beaucoup adri1