table d'une fonction

Bonjour

Comment créer une table de valeurs d’une fonction.

#Tableau de valeurs d'une fonction
def f(expr,liste):
    tabl=[]
    for i in range(len(liste)):
        x=liste[i]
        tabl.append(expr) 
    return(tabl)

>>> f(2*x-1,[0,1,2,3])
Traceback (most recent call last):
  File "<pyshell#16>", line 1, in <module>
    f(2*x-1,[0,1,2,3])
NameError: name 'x' is not defined

Je ne vois pas pourquoi x n’est pas défini ?

Salut,

De ce que je comprends, tu veux une liste de tous les 2*x - 1 pour xvariant dans [0, 1, 2, 3], c’est-à-dire obtenir en retour [-1, 1, 3, 5] ?

Alors il faut savoir qu’hors du contexte de ta fonction f, la variable x n’existe pas, Python ne la connaît pas. Quand tu donnes en argument à ta fonction 2*x-1, Python tente d’avaluer directement la valeur de cette expression, donc il échoue (x n’existe pas dans le contexte).

Tu ne peux donc pas passer en argument une expression qui serait évaluée plus tard. Par contre, ce que tu peux faire c’est envoyer une fonction utilisant cette expression, et donc qui calculerait le résultat à chaque appel. Les lambdas se prêtent très bien à ça.

L’appel à ta fonction ressemblerait donc à f(lambda x: 2*x-1, [0, 1, 2, 3]). Je te laisse modifier le contenu de la fonction f en conséquence, pour appeler f avec la valeur courante de x à chaque itération.

PS : Tu pourrais aussi remplacer [0, 1, 2, 3] par range(4), ça reviendrait au même.

Bonjour @kadpython

Quand tu appelle la fonction f en faisnt f(2*x-1,[0,1,2,3]) tu ne passe pas à f un expression mais une valeur calculée de 2*x-1, donc si la variable x n’existe pas avant l’appel de la fonction cela provoque l’erreur NameError: name 'x' is not defined

De plus si tu envoie dans tabl expr donc aurras une liste de fonctions, il faut utliser expr(x).

#Tableau de valeurs d'une fonction
def f(expr,liste):
    tabl=[]
    for i in range(len(liste)):
        x=liste[i]
        tabl.append(expr(x)) 
    return(tabl)
 
def fonc(x) :
    return 2 * x - 1
 
>>> f(fonc,[0,1,2,3])
[-1, 1, 3, 5]

Dans ta fonction f, tu appelle for i in range(len(liste)): x=liste[i] ce qui n’est pas utile en python, on replacera ce code par:for x in liste:

ton code devient alors :

#Tableau de valeurs d'une fonction
def f(expr,liste):
    tabl=[]
    for x in liste:
        tabl.append(expr(x)) 
    return tabl
 
def fonc(x) :
    return 2 * x - 1

Une autre methode pour obtenir ce genre de resultat est l’utilisation des Listes en intention ce qui donne pour f :

def f(expr,liste):
  return [expr(x) for x in liste]

Il ya beaucoup de tutos python sur zds : https://zestedesavoir.com/bibliotheque/?tag=python , et en paticulier https://zestedesavoir.com/articles/1079/les-secrets-dun-code-pythonique/ qui donne des infos sur les bonnes pratiques de python.

Sache que la fonction que tu cherches à implémenter existe déjà dans Python sous le nom de map:

map(lambda x: 2*x-1, [0, 1, 2, 3])

(Attention, en Python 3 c´est un itérateur)

Mais c’est une bonne chose de s’entraîner écrire ce genre de petite fonction soi-même pour bien comprendre comment ça marche. Tu connaîtras la magie derrière.

Bonjour J’ai essayé d’appeler la fonction map mais je n’y arrive pas! Le message: <class 'map’> A vrai dire je ne vois pas du tout comment appeler cette fonction.

Je n’arrive plus à coller le message d’erreur.

Si tu as comme résultat un <class 'map’> c’est que tu ne l’as pas appelée, tu as juste tapé map dans l’interpréteur. Normalement tu devrais avoir un <map object>.

Mais comme le disait sgble juste au-dessus, en Python 3 map ne renvoie pas une liste mais un autre type d’itérateur, qu’il est toujours possible de convertir en liste :

>>> map(lambda x: 2*x-1, range(4))
<map object at 0x7faaf28749d0>
>>> list(map(lambda x: 2*x-1, range(4)))
[-1, 1, 3, 5]

Pour le lecteur inaverti, attention tout de même. Un itérateur n’est pas toujours convertible en liste. On peut facilement créer des itérateurs qui continuent à l’infini.

Par exemple,

def counter():
    """Same as itertools.count(0)."""
    i = -1
    while True:
        i += 1
        yield i

def take_n(iterator, n):
    """Make a list with the n first elements of any iterator."""
    return [elt for _, elt in zip(range(n), iterator)]

# iterator over all natural integers
all_integers = counter()
# map has no issue with an infinite iterator
table_of_three = map(lambda x: 3 * x, all_integers)
# doing this would blow up your memory!
# list(table_of_three)
# but we can still manipulate it with other tools
print(take_n(table_of_three, 5))