Comment ça se passe ? Concaténation de chaînes

Version imprimable

03/04/2021, 00h11
apt

1 pièce(s) jointe(s)

Comment ça se passe ? Concaténation de chaînes
Bonjour,

Exemple :
Code:

1 2 S = "Hello" S +=" World!"
=>

Code:

S = "Hello World!"

Pièce jointe 594846

Dans une concaténation de chaînes, comment se déroule le processus d'allocation de la nouvelle valeur en mémoire, sans effacer ni perdre le nom de la variable?

La création de la nouvelle chaîne sera-t-elle enregistrée dans une variable temporaire avant de mettre à jour la valeur de S ?

Merci d'avance.

Salut,

Vous ne devez pas essayer de mélanger les différents niveaux d'abstractions, sinon vous allez juste vous perdre!

Après si vous voulez voir ce qu'il se passe sous le capot, çà commence par:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
>>> import dis
>>> def f():
...     S = 'hello'
...     S += ' world'
...
>>> dis.dis(f)
  2           0 LOAD_CONST               1 ('hello')
              2 STORE_FAST               0 (S)
 
  3           4 LOAD_FAST                0 (S)
              6 LOAD_CONST               2 (' world')
              8 INPLACE_ADD
             10 STORE_FAST               0 (S)
             12 LOAD_CONST               0 (None)
             14 RETURN_VALUE
>>>

et vous voyez que dans ce monde là, les choses du dessus se traduisent de façon bizarre.

- W

03/04/2021, 20h55
Sve@r

Bonjour

Citation:

Envoyé par apt

Dans une concaténation de chaînes, comment se déroule le processus d'allocation de la nouvelle valeur en mémoire, sans effacer ni perdre le nom de la variable?
La création de la nouvelle chaîne sera-t-elle enregistrée dans une variable temporaire avant de mettre à jour la valeur de S ?

Déjà il faut éclater les opérateurs qui mixent opération et affectation( typiquement +=, -= etc) car ils se décomposent ("+=" devient "=" puis "+").
Ainsi s+="World" se traduit par s=s + "World". Donc Python commence par calculer s + "World" (méthode "__add__" de l'objet "str") puis place le résultat de cette opération dans "s".
Ne te reste qu'à regarder le source de Python, chercher l'objet "str" puis décortiquer sa méthode "__add__".
21/04/2021, 18h59
apt

Bonjour wiztricks, Sve@r,

@wiztricks : pas compris cette liste ?

@Sve@r : Est-ce que l'adresse mémoire du premier s (s = "Hello") et la même pour le deuxième s (s = "Hello World!") ?

Merci.

Citation:

Envoyé par apt

@Sve@r : Est-ce que l'adresse mémoire du premier s (s = "Hello") et la même pour le deuxième s (s = "Hello World!") ?

Non. Lors de la nouvelle affectation, la mémoire précédente qui était dans le "s" est alors libérée. La nouvelle chaine est créée en mémoire puis affectée dans "s". Te suffit d'afficher hex(id(s)) à chaque étape et tu verras que les valeurs changent.

Ensuite on peut mieux le voir si on crée son propre objet string qui montre ses étapes de création et de suppression...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#!/usr/bin/env python3
# coding: utf-8
 
class myStr(object):
	def __init__(self, s):
		print("__init__", repr(self), s)
		self.__chaine=s
	# __init__()
 
	def __del__(self): print("__del__", repr(self), self.__chaine)
 
	def __str__(self): return self.__chaine
 
	def __add__(self, s): return myStr(self.__chaine+str(s))
# class myStr
 
s=myStr("Hello")
print(s)
s+=myStr("World")
print(s)

Déjà tu te rends compte que pour créer l'addition, je suis obligé de retourner un nouvel objet (sinon je ne pourrais pas écrire des expressions comme truc=myStr("a") + myStr("b")).

Et donc au résultat

Code:

1
2
3
4
5
6
7
8
__init__ <__main__.myStr object at 0x7f20c73a5860> Hello		# Première création
Hello									# Affichage de la chaine "s"
__init__ <__main__.myStr object at 0x7f20c73a54a8> World		# Seconde création
__init__ <__main__.myStr object at 0x7f20c73a5470> HelloWorld		# Création du résultat de l'addition qui ira dans "s"
__del__ <__main__.myStr object at 0x7f20c73a54a8> World			# Suppression de la seconde création devenue inutile
__del__ <__main__.myStr object at 0x7f20c73a5860> Hello			# Suppression de la première création devenue inutile (puisque "s" est libérée)
HelloWorld								# Affichage de la nouvelle chaine "s"
__del__ <__main__.myStr object at 0x7f20c73a5470> HelloWorld		# Suppression du résultat de l'addition devenu inutile (puisque "s" est de nouveau libérée)

Si on change juste s+=myStr("World") par ss=s+myStr("World") (donc on ne perd plus le premier "s"), le résultat...

Code:

1
2
3
4
5
6
7
8
__init__ <__main__.myStr object at 0x7f5b4ec8a828> Hello		# Première création
Hello									# Affichage de la chaine "s"
__init__ <__main__.myStr object at 0x7f5b4ec8a470> World		# Seconde création
__init__ <__main__.myStr object at 0x7f5b4ec8a400> HelloWorld		# Création du résultat de l'addition qui ira cettte fois dans "ss"
__del__ <__main__.myStr object at 0x7f5b4ec8a470> World			# Suppression de la seconde création devenue inutile
HelloWorld								# Affichage de la nouvelle chaine "ss"
__del__ <__main__.myStr object at 0x7f5b4ec8a828> Hello			# Suppression de la première création devenue inutile (puisque "s" est libérée)
__del__ <__main__.myStr object at 0x7f5b4ec8a400> HelloWorld		# Suppression du résultat de l'addition devenu inutile (puisque "ss" est libérée)

... et on voit que le premier "s" n'est supprimé qu'à la fin du programme. Maintenant... est-ce vraiment utile???

Sinon un truc que là je pense bien plus important: les valeurs par défaut des paramètres d'une fonction qui sont crées non pas quand la fonction est appelée, mais quand la fonction est implémentée.

Un exemple

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#!/usr/bin/env python3
# coding: utf-8
 
class myObject(object):
	def __init__(self): print("__init__", repr(self))
	def __del__(self): print("__del__", repr(self))
# class myObject
 
def fct(n=myObject()):
	print("entrée dans fct ", n)
 
print(1)
fct(123)
print(2)
fct()
print(3)

Et le résultat

Code:

1
2
3
4
5
6
7
__init__ <__main__.myObject object at 0x7fae6ae55828>		# L'objet est créé avant même que la fonction soit appelée
1								# Affichage témoin
entrée dans fct  123						# La fonction a été appelée avec un vrai paramètre, elle l'affiche
2								# Affichage témoin
entrée dans fct  <__main__.myObject object at 0x7fae6ae55828>	# La fonction a été appelée sans paramètre, elle affiche alors le paramètre par défaut créé au début du programme
3								# Affichage témoin
__del__ <__main__.myObject object at 0x7fae6ae55828>		# L'objet est supprimé avec la fonction quand le programme se termine

C'est pour cela que ce genre de fonction...

Code:

1
2
3
4
5
6
7
8
def f(n, tab=[]):
	tab.append(n)
	return tab
# f()
 
print(f(1))
print(f(2))
print(f(3))

... peut causer des surprises...

Code:

1
2
3
[1]
[1, 2]
[1, 2, 3]

!!!

21/04/2021, 22h14
wiztricks

Citation:

Envoyé par apt

@wiztricks : pas compris cette liste ?

Quelle liste?

On n'arrivera pas à vous expliquer quoi que ce soit si vous n'avez pas le minimum de bases pour comprendre.

Il serait plus simple d'essayer d'expliquer quel problème vous cherchez à résoudre ou pourquoi vous posez cette question.

- W

Citation:

Envoyé par wiztricks

Quelle liste?

Celle-ci :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 >>> import dis >>> def f(): ... S = 'hello' ... S += ' world' ... >>> dis.dis(f) 2 0 LOAD_CONST 1 ('hello') 2 STORE_FAST 0 (S) 3 4 LOAD_FAST 0 (S) 6 LOAD_CONST 2 (' world') 8 INPLACE_ADD 10 STORE_FAST 0 (S) 12 LOAD_CONST 0 (None) 14 RETURN_VALUE >>>
Citation:

Envoyé par wiztricks

pourquoi vous posez cette question.

j'aimerais savoir comment python traite une concaténation (les étapes).

Par exemple, utilise-t-il une nouvelle variable pour construire la nouvelle chaîne, avant de retourner la chaîne finale?

La variable s pour cette chaine finale, est-ce la même que la chaîne de départ ou une nouvelle variable s ?

La case mémoire allouée en premier temps pour la chaine "Hello", est-elle la même case mémoire pour la chaine "Hello World!"

Sve@r

Merci pour la démonstration, je vais essayer de comprendre tout ça !

22/04/2021, 11h00
VinsS

Salut,

Règle numéro 1: Il n'y a pas de variable en Python.

Lorsque tu fais s = "Hello" Python construit un objet str avec la valeur "Hello". Ensuite, si l'opération n'a pas échoué, il colle une étiquette avec la mention "s" sur cet objet.

Donc l'objet c'est la str et non pas l'étiquette.

La variable en tant que "boîte dont le contenu peut varier" est une notion totalement fausse en Python et tes questionnements reposent semble-t-il sur cette erreur.

Si tu ajoutes s = "Bonjour" Python construit un objet str avec la valeur "Bonjour". Ensuite se souvient avoir déjà fait une étiquette avec un "s", l'enlève de l'objet str("Hello") et la colle sur le nouvel objet. Et lorsque tu fais une concaténation c'est pareil, tu construis un nouvel objet, dans une nouvelle zone mémoire mais c'est l'ancienne étiquette qui est réutilisée.

Un même objet peut recevoir autant d'étiquettes que l'on veut. L'objet lui-même possède un compteur de référence pour gérer cela, lorsque ce compteur arrive à zéro il est effacé par un mécanisme appelé "Garbage collector". La mémoire libérée n'est pas nécessairement restituée au système, ça c'est de la cuisine interne.

Ceci dit, ça ne dérange pas d'utiliser le terme variable, on comprend ce que tu veux dire, l'erreur est de voir ce "s" comme un objet ou une case mémoire.
22/04/2021, 11h23
wiztricks
Salut,

Pour compléter ce qu'a raconté VinsS.
C'est quoi une variable en Python l'association d'une chaîne de caractères (le nom de la variable) avec un objet.
Et Python réalise cette association via des dictionnaires (au moins pour les variables globales):

Je définis la clef X dans le dictionnaire globals()

Code:

>>> globals()['X'] = 123

Et si j'accède à X "normalement", je retrouve mes petits:
Code:

1 2 >>> X 123
Et la réciproque est vraie...
J'assigne à X un autre objet:

Code:

>>> X = 'abc'

Et si je regarde le côté dictionnaire de la chose, je retrouve l'objet:
Code:

1 2 3 >>> globals()['X'] 'abc' >>>
Voilà comment fonctionne Python... Et vou voyez que comprenant cela, vos questions n'ont pas trop de sens.

- W
22/04/2021, 14h24
Sve@r
Ce qu'il est intéressant de noter, c'est que toute copie d'un objet se contente en fait de copier juste l'étiquette...
Code:

1 2 3 4 5 6 >>> a=12345 >>> id(a) 140561597757136 >>> b=a >>> id(b) 140561597757136
... jusqu'à ce qu'il y ait nouvelle affectation dans l'étiquette...
Code:

1 2 3 >>> b=12345 >>> id(b) 140561597757168
Et dans ce cas, la valeur de la nouvelle affectation (ici identique à l'ancienne) n'entre même pas en ligne de compte (sinon cela voudrait dire que Python va "chercher" si "par hasard" la valeur "12345" n'a pas déjà été stockée quelque part ce qui n'apporterait aucune plus-value à l'opération).

Et ce comportement (à l'économie) fait que la copie d'un objet (même super gros) ou son envoi à une fonction est super rapide
Code:

1 2 3 4 5 6 >> a=list(range(10000*5000)) # Ca ça prendra un peu de temps >>> id(a) 140561597454280 >>> b=a # Ca ce sera instantané >>> id(b) 140561597454280
L'inconvénient c'est que comme il n'y a en réalité qu'un seul objet, modifier l'original se répercute dans la copie
Code:

1 2 3 4 5 >>> a=[1, 2, 3] >>> b=a >>> a.append("xxx") >>> b [1, 2, 3, 'xxx']
Toutefois il s'agit là d'un inconvénient assez minime car d'une part cela convient dans 99% des cas (il est assez rare de travailler sur deux objets similaires en parallèle). Mais si cela arrive, alors il est tout à fait possible de "forcer" la copie
Code:

1 2 3 4 5 >>> a=[1, 2, 3] >>> b=list(a) >>> a.append("xxx") >>> b [1, 2, 3]
Après, les concaténations de chaines ne sont qu'un cas particulier de ce comportement général.