Discussion :

[The0y]

bonjour,

je suis débutant en python et je suis face à un problème dans l'écriture de mon code, et comme je ne sais pas nommer ce que j'essai de faire je n'arrive pas a m'auto-documenter sur le sujet.

bref un exemple sera plus parlant qu'un long discours :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
x = 1
y = 5
 
def mod(elem):
    global elem
    elem += 2
    print(f'dep. mod : {elem} = ', elem)
 
#choix de la variable de travail
var = x
mod(var)
 
print('dep. main : x = ', x)
print('dep. main : y = ', y)

bien sûr la ligne 5 provoque une erreur que je comprends parfaitement...

mais je suppose que chacun a très bien compris se que j'essai de faire :
je veux que la variable qui sera utilisé en global soit définit en amont dans l'attribu de la fonction.
sauf que je ne sais pas comment pointer la variable elle-meme et pas le contenu.

quel syntaxe utiliser pour ce genre d'application ? comment se nome se type de syntaxe ?

merci, d'avance et désolé je ne connais pas la catérorie de ma question qui est plutôt d'ordre général ou syntaxique je pense...

[wiztricks]

Salut
On peut écrire ça ainsi:

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
x = 1
y = 5
 
def mod(elem):
    # global elem
    globals()[elem] += 2
    v = globals()[elem]
    print(f'dep. mod : {v= }')
 
#choix de la variable de travail
var = 'x'
mod(var)
 
print('dep. main : x = ', x)
print('dep. main : y = ', y)

Mais sauf à expliquer le pourquoi de ce que vous voulez faire, il sera toujours préférable d'utiliser une fonction pour ce qu'est une fonction:

Code :

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

1
2
3
4
5
6
7
8
9
x = 1
y = 5
 
def mod(v):
    return v+2
 
x = mod(x)
print('dep. main : x = ', x)
print('dep. main : y = ', y)

Un langage de programmation est un langage: vous devez apprendre à jouer avec les concepts qu'il définit plutôt que débarquer avec des idées préconçues sur ce que vous voulez faire et tordre le truc pour y arriver.

- W

[The0y]

super merci, je vais pouvoir avancer...

oui je comprend, je détourne un peu l'utilisation de la fonction,
dans mon cas une Class serai peu être plus aproprié, mais n'ai pas encore LE niveau pour les Class ; je débute et mon code ne sera peut être pas un model d'utilisation, mais pour une utilisation personnel... ça suffira

en tout cas merci pour ta réponse cela m'a permis de mieux comprendre la mécanique : en faite l'utilisation d'un string puis de crochet c'est très malin !

[papajoker]

oui je comprend, je détourne un peu l'utilisation de la fonction

Mais quel but ? détourner pour faire une chose que l'on ne devrait pas faire ?

dans mon cas une Class serai peu être plus aproprié

certainement pas

mieux comprendre la mécanique : en faite l'utilisation d'un string puis de crochet c'est très malin !

J'ai rien compris !
string avec crochet c'est pour accéder a un caractère de cette chaine. Pas vu dans le code que l'on t'a donné.
globals()[elem] c'est juste l'utilisation d'un dictionnaire

La bonne pratique, c'est simplement de retourner une valeur via ta fonction (code no 2 de wiztricks), point final.

[wiztricks]

en tout cas merci pour ta réponse cela m'a permis de mieux comprendre la mécanique : en faite l'utilisation d'un string puis de crochet c'est très malin !

Ca n'a rien de malin, globals() est un dictionnaire, structure essentielle du langage et les crochets racontent qu'on y accède comme si c'était une sorte de tableau. Les index étant dans ce cas les clefs. Pour les sequences ce seront des positions/nombres.

Avec les class, on pourra faire la même chose via des mécanismes d'introspection:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
class A:
    x = 1
    y = 5
 
def mod(obj, s):
    if not hasattr(obj, s):
        return
    setattr(obj, s, getattr(obj, s) + 1)
 
a = A()
print (f'{a.x=}')
mod(a, 'x')
print(f'{a.x=}')

Un module (et ses variables globales) est un objet comme un autre:

Code :

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

1
2
3
4
5
6
import sys
m = sys.modules[__name__]  # je récupère l'objet module, les variables peuvent être accédées via le chemin m...:
 
print (f'{m.x=}')
mod(m, 'x')
print(f'{m.x=}')

note: m et a sont mutables alors que a.x et m.x ne le sont pas.


- W

[Sve@r]

Bonjour

dans mon cas une Class serai peu être plus aproprié

Peut-être donner plus de détails sur ce que sera ton cas, car contrairement à ce que tu imagines, je n'ai absolument pas compris ce que tu voulais faire. Pourquoi utiliser un paramètre pour obtenir une valeur à laquelle tu accèdes déjà de par sa mise en globale ? Un nouveau cas de problème XY ???

en faite l'utilisation d'un string puis de crochet c'est très malin !

Non, c'est juste l'utilisation d'un outil que tu ne connais pas encore mais qui n'est pas compliqué : toutes les variables de ton code se trouvent dans un dictionnaire récupérable par la fonction "globals()". Et chaque variable "xxx" est référencée comme clef de ce dictionnaire.
De là, on peut soit modifier la variable directement (xxx=123) soit modifier cette même variable en passant par le dictionnaire (globals()["xxx"]=123). Ou même créer une fonction qui pourra mettre n'importe quelle valeur dans n'importe quelle variable...

Code python :

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

1
2
3
4
5
6
7
8
def modif(v, x): globals()[v]=x
 
xxx=123
yyy=456
modif("xxx", 777)
modif("yyy", 888)
print(xxx)        # 777
print(yyy)        # 888

... mais de là à comprendre l'utilité ou le besoin d'une telle fonction...

[fred1599]

Hello,

Le titre "Problème syntaxe pointeur ?" change à mon sens l'interprétation !

Dans ce cas, le PO cherchait probablement à comprendre comment simuler ou utiliser des concepts similaires aux pointeurs dans Python.

Puisque Python n'a pas de pointeurs directs, la façon la plus proche de simuler leur comportement est d'utiliser des objets mutables (comme les listes ou les dictionnaires).
Lorsqu'on passe un objet mutable à une fonction, on passe en réalité une référence à cet objet. Les modifications apportées à l'objet à l'intérieur de la fonction se reflètent donc à l'extérieur.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
def modifier_liste(data):
    print(f'dep. mod : data (avant modification) = {data}')
    data[0] += 2
    print(f'dep. mod : data (après modification) = {data}')
 
 
ma_liste = [1, 5]
print(f'dep. main : ma_liste (avant appel) = {ma_liste}')
modifier_liste(ma_liste)
print(f'dep. main : ma_liste (après appel) = {ma_liste}')

C'est le comportement le plus proche de ce qu'on ferait avec un pointeur en C pour modifier la valeur pointée.