Discussion :

[ypcman]

Bonjour.

C'est purement théorique mais je voudrais que ma fct f2() puisse modifier la valeur de b, paramètre fourni par la fct f1() ...
b n'est pas une variable globale mais seulement le 2° paramètre de ma fct f1 et je ne trouve pas comment faire pour que b soit considérée comme globale par f2, ou au moins modifiable par f2, sans lui passer b en paramètre

Code :

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

1
2
3
4
5
6
def f1(a, b):
    def f2(a):
        b += 1
        return a + b
 
    return f2(a)

[lg_53]

De la manière dont c'est écrit, vous ne pouvez pas vous servir de f2 depuis l'extérieur. Vous ne pouvez vous en servir qu'à l'intérieur de f1. Donc l'instruction b+=1 peut très bien faire partie intégrante de f1.

Code :

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

1
2
3
4
5
6
def f1(a, b):
    b += 1
    def f2(a):
        return a + b
 
    return f2(a)

Idéalement je ferais comme ca ceci dit :

Code :

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

1
2
3
4
5
def f1(a, b):
    return f2(a, b+1)
 
def f2(a,b):
    return a + b

Ca ne répond peut être pas forcément à votre besoin, mais j'ai du mal à imaginer votre application qui vous limite dans le passage de b (ou b+1) en paramètre. Et sinon après pour ca, il y a les objets, dans lesquels, justement par définition, l'ensemble des attributs de l'objet est accessible (et modifiable) par l'ensemble des méthodes de celui-ci.

[wiztricks]

Salut,

mais je voudrais que ma fct f2() puisse modifier la valeur de b, paramètre fourni par la fct f1() ...

Il suffit de déclarer b nonlocal:

Code :

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

1
2
3
4
5
6
def f1(a, b):
    def f2(a):
        nonlocal b
        b += 1
        return a + b
    return f2(a)

- W

[Sve@r]

Bonjour

et je ne trouve pas comment faire pour que b soit considérée comme globale par f2, ou au moins modifiable par f2, sans lui passer b en paramètre

Code python :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#!/usr/bin/env python3
# coding: utf-8
 
def f1(a, b):
	def f2(a):
		nonlocal b
		b += 1
		return a + b
 
	print("avant: b=%d" % b)
	x=f2(a)
	print("après: b=%d" % b)
	return x
 
f1(5, 7)

L'instruction "nonlocal" dans une sous-fonction fait référence à la variable de même nom située dans la fonction de plus haut niveau. C'est une évolution de P3.

Sous P2, il aurait fallu créer une variable directement comme attribut de f1 (car f1, fonction, étant aussi un objet, peut donc avoir des attributs)

Code python2 :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#!/usr/bin/env python2
# coding: utf-8
 
def f1(a, b):
	def f2(a):
		f1.bb += 1
		return a + f1.bb
 
	f1.bb=b 
	print("avant: bb=%d" % f1.bb)
	x=f2(a)
	print("après: bb=%d" % f1.bb)
	return x
 
f1(5, 7)

(ça marche aussi avec P3 évidemment)

C'est purement théorique

Fort heureusement. On peut toutefois s'en servir si on veut attacher un "êtat" à une fonction.
Imaginons l’étal d’un marchand. Celui-ci va devoir établir et afficher le prix de ses fruits.
Une première solution pourra être de passer par des classes et créer un objet. Mais c'est un peu lourd pour un truc aussi simple.
Une seconde solution permet d’obtenir le même résultat mais en passant simplement par des fonctions au lieu de classes.

Code python :

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
>>> def etal(fruit):
...	def maj(modif):
...		nonlocal prix
...		prix+=modif
...		print("Le prix des %s est de %d€" % (fruit, prix))
...	prix=0
...	return maj
 
>>> orange=etal("oranges")
>>> pomme=etal("pommes")
>>> orange(5)
Le prix des oranges est de 5€
>>> pomme(2)
Le prix des pommes est de 2€
>>> orange(-1)
Le prix des oranges est de 4€
>>> pomme(4)
Le prix des pommes est de 6€

[ypcman]

Merci lg_53 pour votre réponse. En fait, je m'amuse à faire les épreuves du bac en NSI et je cherche à résoudre la question 6 de l'épreuve 2022 de Polynésie :

La fonction fabrique ci-dessous a pour but de répondre au problème posé. Pour cela,
la fonction annexe utilise la valeur de n, qu'elle peut modifier, et renvoie un arbre
binaire de hauteur hauteur_max dont le nombre de nœuds est égal à la valeur de n au
moment de son appel.

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 fabrique(h, n):
    def annexe(hauteur_max):
        if n == 0:
            return get_arbre_vide()
        elif hauteur_max == 0:
            n = n - 1
            # ... => return get_arbre_vide()
        else:
            n = n - 1
            gauche = annexe(hauteur_max - 1)
            # ...    => droite = annexe(hauteur_max - 1)
            return arbre(gauche, droite, n + 1)
 
    return annexe(h)

6. Recopier sur la copie les lignes 7 et 11 en complétant les points de suspension.

Je ne comprend pas comment coder que la fonction annexe() peut modifier n, comme pourtant annoncé dans l'énoncé


Sve@r vient de répondre à ma question ! Merci

[Sve@r]

Je ne comprend pas comment coder que la fonction annexe() peut modifier n, comme pourtant annoncé dans l'énoncé

Ah oui, tu ne me répondais pas à moi (désolé)
Donc il suffit de rajouter nonlocal n entre le def annexe(...) et if n == 0.

Sve@r vient de répondre à ma question ! Merci

Non, wiztricks m'a devancé pendant que je testais avant de répondre. Toujours plus rapide que moi pfff...

[ypcman]

Merci donc aussi à Wiztricks dont je n'avais pas vu la réponse synthétique, le post de Sve@r, nettement plus long, s'étant affiché en haut de la pile de la discussion