Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » Python » Error anidado en llamada reiteradas a funcion.

Python - Error anidado en llamada reiteradas a funcion.

Volver
Nuevo Tema
<<>>
 
Vista:

Error anidado en llamada reiteradas a funcion.

Publicado por jac (14 intervenciones) el 04/11/2022 23:58:21
Hola amig@s:

Llevo varios dias lidiando con esta situacion, y no se si estoy tonto, no entiendo de nada, o Python tiene alguna caracteristica oculta a mi entendimiento que no soy capaz de ver.

Por que cuando llamo a la funcion analisis, la lista_uno no varia nunca y la lista_dos si?


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
#!/usr/bin/python3
 
def analisis(lista_uno,lista_dos):
 
	resultado_uno=[]
	for linea in lista_uno:
		linea="B"+linea
		resultado_uno.append(linea)
 
	resultado_dos=[]
	for linea in lista_dos:
		linea[0]="B"+linea[0]
		linea[1]="B"+linea[1]
		resultado_dos.append(linea)
 
	return resultado_uno,resultado_dos
 
#funcion de inicio
def inicio():
 
	lista_uno=["A","B","C","D","E"]
	lista_dos=[["0","1"],["1","2"],["2","3"]]
	print ("Original.: ")
	print ("---------- ")
	print ("Lista uno: ",lista_uno)			#Tiene que ser: ["A","B","C","D","E"]
	print ("Lista dos: ",lista_dos)			#Tiene que ser:	[["0","1"],["1","2"],["2","3"]]
	print ("\n")
 
 
	resultado=analisis(lista_uno,lista_dos)
	print ("Despues de la primera llamada: ")
	print ("------------------------------ ")
	print ("Lista uno: ",lista_uno)			#Tiene que ser: ["A","B","C","D","E"]
	print ("Lista dos: ",lista_dos)			#Tiene que ser:	[["0","1"],["1","2"],["2","3"]]
	print ("\n")
	print ("Resultado uno: ",resultado[0])		#Tiene que ser: ['BA', 'BB', 'BC', 'BD', 'BE']
	print ("Resultado dos: ",resultado[1])		#Tiene que ser: [['B0', 'B1'], ['B1', 'B2'], ['B2', 'B3']]
	print ("\n")
 
 
	resultado=analisis(lista_uno,lista_dos)
	print ("Despues de la Segunda llamada: ")
	print ("------------------------------ ")
	print ("Lista uno: ",lista_uno)			#Tiene que ser: ["A","B","C","D","E"]
	print ("Lista dos: ",lista_dos)			#Tiene que ser:	[["0","1"],["1","2"],["2","3"]]
	print ("\n")
	print ("Resultado uno: ",resultado[0])		#Tiene que ser: ['BA', 'BB', 'BC', 'BD', 'BE']
	print ("Resultado dos: ",resultado[1])		#Tiene que ser: [['B0', 'B1'], ['B1', 'B2'], ['B2', 'B3']]
 
	return
 
#inicio de programa
inicio()
 
 
""" SALIDA...
Original.:
----------
Lista uno:  ['A', 'B', 'C', 'D', 'E']
Lista dos:  [['0', '1'], ['1', '2'], ['2', '3']]
Despues de la primera llamada:
------------------------------
Lista uno:  ['A', 'B', 'C', 'D', 'E']
Lista dos:  [['B0', 'B1'], ['B1', 'B2'], ['B2', 'B3']]
Resultado uno:  ['BA', 'BB', 'BC', 'BD', 'BE']
Resultado dos:  [['B0', 'B1'], ['B1', 'B2'], ['B2', 'B3']]
Despues de la Segunda llamada:
------------------------------
Lista uno:  ['A', 'B', 'C', 'D', 'E']
Lista dos:  [['BB0', 'BB1'], ['BB1', 'BB2'], ['BB2', 'BB3']]
Resultado uno:  ['BA', 'BB', 'BC', 'BD', 'BE']
Resultado dos:  [['BB0', 'BB1'], ['BB1', 'BB2'], ['BB2', 'BB3']]
"""

Lista_uno y lista_dos no deberian variar nunca puesto que no se hace ningun cambio en ellas.

Cual es el motivo por el que lista_dos varia conforme se va llamando a la funcion analisis.

Gracias por leerme y un saludo a tod@s!
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
sin imagen de perfil
Val: 2.808
Oro
Ha mantenido su posición en Python (en relación al último mes)
Gráfica de Python

Error anidado en llamada reiteradas a funcion.

Publicado por tincopasan (1082 intervenciones) el 05/11/2022 03:35:41
1) en realidad si la estás modificando con:
1
2
3
for linea in lista_dos:
		linea[0]="B"+linea[0]
		linea[1]="B"+linea[1]
en donde para cada iteración le das un nuevo valor con el signo =

2) te recomendaría que no uses la misma variable en distintos bucles y que no le asignes un valor a esa variable, tampoco es necesario y es recomendable no usar los mismos nombres en los parámetros.

3 ) una forma sería:

1
2
3
4
5
6
7
8
9
10
11
12
13
def analisis(lista_uno,lista_dos):
 
    resultado_uno=[]
    for x  in lista_uno:
        linea="B"+ x
        resultado_uno.append(linea)
 
    resultado_dos=[]
    for i in lista_dos:
        linea2=["B"+i[0],"B"+i[1]]
        resultado_dos.append(linea2)
 
    return resultado_uno,resultado_dos

4) y todo eso se puede resumir a:
1
2
def analisis(lista1,lista2):
    return ["B"+x for x in lista1] ,[["B"+i[0],"B"+i[1]] for i in lista2]
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

Error anidado en llamada reiteradas a funcion.

Publicado por jac (14 intervenciones) el 05/11/2022 12:38:18
Buenos dias tincopasan!

Y lo primero esta antes... Gracias por responder!

El ejemplo que pongo es un ejemplo tosco.
Lo pongo asi para que se pueda entender de la manera mas facil posible.



Cuando dices:
1) en realidad si la estás modificando con: ...

No, en realidad no estoy pidiendo que lista_dos se modifique.
Estoy pidiendo que linea tome los valores de lista_dos.

Si fuera como dices, tambien estaria pidiendo que lista_uno se modificase.
Sin embargo lista_uno no se modifica...

Mirandolo con detenimiento, el codigo es el mismo.
Solo que lista_uno es una lista sencilla, y lista_dos es una lista de listas.

Cuando se ejecuta la instruccion for para lista_uno, solo estoy pidiendo que pase sus valores a la variable linea.
Al igual que cuando se ejecuta el for para lista_dos.

Siempre he entendido que al iniciarse el for este borra, barre, limpia o crear un nuevo espacio de memoria donde se van almacenando los nuevos datos de la iteracion (en este caso en la variable linea).

Y cuando dices: en donde para cada iteración le das un nuevo valor con el signo =

Lo que entiendo es que mi problema es debido la herencia de clases de la programacion orientada a objetos.
No obstante, en ese codigo no hay clases, solo hay instrucciones y funciones.



Tambien cuando dices:
2) te recomendaría que no uses la misma variable en distintos bucles y que no le asignes un valor a esa variable, tampoco es necesario y es recomendable no usar los mismos nombres en los parámetros.

Efectivamente, es solo codigo de ejemplo.
Lo hago asi para que se pueda ver de la manera mas facil posible el arrastre de los valores de una funcion a otra.

Como python reserva un espacio de memoria unico para cada uno de los nombres de variable de cada funcion, no debe haber colision, sobreposicion, error o mal entendimiento alguno.

La variable lista_uno de la funcion inicio, es distinta (ocupa distinta direccion de memoria) que la variable lista_uno de la funcion analisis, y asi las demas.



Disculpar por la parrafada que acabo de dar, pero en mi cerebro sigo sin verlo.

Saludos a tod@s!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
sin imagen de perfil
Val: 2.808
Oro
Ha mantenido su posición en Python (en relación al último mes)
Gráfica de Python

Error anidado en llamada reiteradas a funcion.

Publicado por tincopasan (1082 intervenciones) el 05/11/2022 16:51:20
1
Mirandolo con detenimiento, el codigo es el mismo.

vaya que no miras con detenimiento.

1
linea="B"+linea
y
1
linea[0]="B"+linea[0]

¿de verdad te parecen lo mismo? si tu respuesta es si, ya no puedo ayudarte, pero uno tiene índices y el otro no.

Reemplazar elementos en una lista es muy sencillo. Simplemente rebana la lista y asigna nuevos valores a esa selección.
Puedes seleccionar un elemento o modificar pedazos enteros de la lista de una sola vez.

1
lista_uno[0]="B"+lista_uno[0]

for en el primer caso devuelve el valor y el segundo un slice

eso sería más parecido al segundo caso, usando índices, que en el primer caso no lo estás haciendo.

No tengo ganas de mostrarte como funciona ni el for ni el slice, búscalo, pero sin el for le paso el indice:

1
2
3
lista_uno=["A","B","C","D","E"]
lista_uno[0]="B"+lista_uno[0]
print(lista_uno)

ahora le pasé indices, que insisto , no están!


el segundo for es basicamente como si:

1
2
lista_dos[0][0]="B"+ lista_dos[0][0]
print(lista_dos)
donde le estás pasando lo índices

sino te das cuento de esto, te recomiendo que releas lo básico de listas, slices y for
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

Error anidado en llamada reiteradas a funcion.

Publicado por jac (14 intervenciones) el 06/11/2022 11:22:12
Bueno dias de nuevo tincopasan!

Y de nuevo gracias por responder.

Tienes razon, todo lo que dices es correcto.

Y para entender o saber cual son los valores de retorno de una instruccion solo hay que hacer un type() de ese valor.

Pero creo que no has entendido el origen de mi problema, de mi duda, y del por que de esta consulta.

Mi problema no es con las instrucciones (for... etc), ni con las variables (str, list... etc.).

Mi problema es con las funciones:

Por que ocurre que sin pedir un cambio expecifico en las variables del espacio de memoria de la primera funcion, otra segunda funcion es capaz de cambiar los valores del espacio de memoria de la primera?

Quizad esta, llana y sencillamente, deberia haber sido mi pregunta.
Pero claro, siempre tengo que liarla escribiendo codigo y yendome por las ramas...

Eso es lo que no me entra en la cabeza...

Por que las variables de la funcion inicio, se ven alteradas desde la funcion analisis?

Si python reserva un espacio de memoria unico para cada una de las variables de cada funcion, los nombre de las variables de cada funcion serian (internamente para python) algo como esto:

inicio.lista_uno
inicio.lista_dos

analisis.lista_uno
analisis.lista_dos

Y cada una tendria o deberia tener su propio espacio de memoria, unico, e inviolable.

Por eso decia en el primer post que no se si estoy tonto, no entiendo de nada, o Python tiene alguna caracteristica oculta a mi entendimiento que no soy capaz de ver.

Y por eso cuando te decia "mirandolo con detenimiento", no me estaba refiriendo a ti, a que hubieses leido el codigo mas detenidamente o menos... eso es cosa de cada uno.

Me estaba refiriendo a que la situacion del for es la misma para lista_uno y lista_dos.
Un for es un for y hace lo que hace en cualquier funcion...

Pero los valores de lista_dos en la funcion inicio se ven modificados, a mi entendimiento, sin venir a cuento...

No se si me acabo de explicar correctamente, o la acabo de liar mas todavia...


Venga, un saludo!

Y muchas gracias por aguantarme la chapa que os estoy dando.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
sin imagen de perfil
Val: 2.808
Oro
Ha mantenido su posición en Python (en relación al último mes)
Gráfica de Python

Error anidado en llamada reiteradas a funcion.

Publicado por tincopasan (1082 intervenciones) el 06/11/2022 20:52:44
Soy muy malo explicando pero te faltan conceptos, así que pondré un ejemplo pero, como dije no sé si explicaré de forma entendible:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#-*- coding: utf  -8 -*-
def cambiar_lista(L):
    L[0] = 4
    #está modificando, no creando
 
    print("\nfunción cambiar")
    print("conjunto de variables: ",locals())
    print("espacio de memoria de la lista: ",id(L))
    #acá es el mismo espacio de memoria
 
    L = [3,2,1]
 
    print("conjunto de variables: ",locals())
    #Ahora si es una lista nueva en esta función
    print("espacio de memoria de la nueva lista: ",id(L))
 
    #este  es un nuevo espacio de memoria
    #este espacio de memoria si corresponde solo al ámbito de está función
    #y después del call se elimina
 
    print("alias: " ,L)
    #fue una nueva lista, otro espacio de memoria y si va a desaparecer
 
def otro_espacio():
    L = [1,2,3]
    print("\notro espacio")
    print("conjunto de variables: ",locals())
    print("espacio de memoria de la lista: ",id(L))
 
    cambiar_lista(L)
    #al llamar a la función la lista L ocupa el mismo lugar de memoria
 
    print("después de la función:  ",L) #[4, 2, 3]
    #y solo fue modificada
 
otro_espacio()

Hay cientos de tutoriales sobre la memoria, el ámbito y alcance de las variables, te recomiendo que leas varios y hagas distintas pruebas, por mi parte no puedo explicar mejor.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

Error anidado en llamada reiteradas a funcion.

Publicado por jac (14 intervenciones) el 10/12/2022 20:34:06
Pues nada amig@s, con este script podeis ver lo que hace Python al respecto:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
#!/usr/bin/python3
 
def analisis_reasignar(n,a,b,c,l,t,d,ll,tt,dd):
 
	#reasignacion
	n=n		#numerico
	analisis_id_n=id(n)
 
	a=a		#cadena
	analisis_id_a=id(a)
 
	b=b		#boleano
	analisis_id_b=id(b)
 
	c=c		#conjunto
	analisis_id_c=id(c)
 
	l=l		#lista
	analisis_id_l=id(l)
 
	t=t		#tupla
	analisis_id_t=id(t)
 
	d=d		#diccionario
	analisis_id_d=id(d)
 
	ll=ll		#lista de listas
	analisis_id_ll=id(ll)
 
	tt=tt		#tupla de tuplas
	analisis_id_tt=id(tt)
 
	dd=dd		#diccionario de diccionarios
	analisis_id_dd=id(dd)
 
	print ("VALORES DESPUES DE REASIGNAR:")
	print ("+--------------------+--------------------+------------------------------+")
	print ("| Tipo de objeto     | Posicion memoria   | Valor contenido              |")
	print ("+--------------------+--------------------+------------------------------+")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(n)), analisis_id_n, n), end=" ")
	if inicio_id_n==analisis_id_n:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(a)), analisis_id_a, a), end=" ")
	if inicio_id_a==analisis_id_a:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(b)), analisis_id_b, b), end=" ")
	if inicio_id_b==analisis_id_b:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(c)), analisis_id_c, str(c)), end=" ")
	if inicio_id_c==analisis_id_c:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(l)), analisis_id_l, str(l)), end=" ")
	if inicio_id_l==analisis_id_l:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(t)), analisis_id_t, str(t)), end=" ")
	if inicio_id_t==analisis_id_t:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(d)), analisis_id_d, str(d)), end=" ")
	if inicio_id_d==analisis_id_d:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(ll)), analisis_id_ll, str(ll)), end=" ")
	if inicio_id_ll==analisis_id_ll:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(tt)), analisis_id_tt, str(tt)), end=" ")
	if inicio_id_tt==analisis_id_tt:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(dd)), analisis_id_dd, str(dd)), end=" ")
	if inicio_id_dd==analisis_id_dd:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("+--------------------+--------------------+------------------------------+")
	print ("\n")
	return
 
def analisis_modifica(n,a,b,c,l,t,d,ll,tt,dd):
 
	#modificacion
	n+=1		#numerico
	analisis_id_n=id(n)
 
	a+="1"		#cadena
	analisis_id_a=id(a)
 
	b+=True		#boleano
	analisis_id_b=id(b)
 
	c.add(1)	#conjunto
	analisis_id_c=id(c)
 
	l+=[1]		#lista
	analisis_id_l=id(l)
 
	t+=tuple("1")	#tupla
	analisis_id_t=id(t)
 
	d["1"]=1	#diccionario
	analisis_id_d=id(d)
 
	ll+=[[1],[1]]	#lista de listas
	analisis_id_ll=id(ll)
 
	tt+=((1),(1))	#tupla de tuplas
	analisis_id_tt=id(tt)
 
	dd["1"]={"1": 1}	#diccionario de diccionarios
	analisis_id_dd=id(dd)
 
	print ("VALORES DESPUES DE MODIFICAR:")
	print ("+--------------------+--------------------+------------------------------+")
	print ("| Tipo de objeto     | Posicion memoria   | Valor contenido              |")
	print ("+--------------------+--------------------+------------------------------+")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(n)), analisis_id_n, n), end=" ")
	if inicio_id_n==analisis_id_n:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(a)), analisis_id_a, a), end=" ")
	if inicio_id_a==analisis_id_a:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(b)), analisis_id_b, b), end=" ")
	if inicio_id_b==analisis_id_b:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(c)), analisis_id_c, str(c)), end=" ")
	if inicio_id_c==analisis_id_c:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(l)), analisis_id_l, str(l)), end=" ")
	if inicio_id_l==analisis_id_l:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(t)), analisis_id_t, str(t)), end=" ")
	if inicio_id_t==analisis_id_t:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(d)), analisis_id_d, str(d)), end=" ")
	if inicio_id_d==analisis_id_d:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(ll)), analisis_id_ll, str(ll)), end=" ")
	if inicio_id_ll==analisis_id_ll:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(tt)), analisis_id_tt, str(tt)), end=" ")
	if inicio_id_tt==analisis_id_tt:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(dd)), analisis_id_dd, str(dd)), end=" ")
	if inicio_id_dd==analisis_id_dd:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("+--------------------+--------------------+------------------------------+")
	print ("\n")
	return
 
def analisis_nuevos_valores(n,a,b,c,l,t,d,ll,tt,dd):
 
	n=2		#numerico
	analisis_id_n=id(n)
 
	a="2"		#cadena
	analisis_id_a=id(a)
 
	b=True		#boleano
	analisis_id_b=id(b)
 
	c={2}		#conjunto
	analisis_id_c=id(c)
 
	l=[2]		#lista
	analisis_id_l=id(l)
 
	t=tuple("2")	#tupla
	analisis_id_t=id(t)
 
	d={"2":2}	#diccionario
	analisis_id_d=id(d)
 
	ll=[[2],[2]]	#lista de listas
	analisis_id_ll=id(ll)
 
	tt=((2),(2))	#tupla de tuplas
	analisis_id_tt=id(tt)
 
	dd={"2": {"2": 2}}	#diccionario de diccionarios
	analisis_id_dd=id(dd)
 
	print ("VALORES DESPUES DE ASIGNAR NUEVOS VALORES:")
	print ("+--------------------+--------------------+------------------------------+")
	print ("| Tipo de objeto     | Posicion memoria   | Valor contenido              |")
	print ("+--------------------+--------------------+------------------------------+")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(n)), analisis_id_n, n), end=" ")
	if inicio_id_n==analisis_id_n:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(a)), analisis_id_a, a), end=" ")
	if inicio_id_a==analisis_id_a:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(b)), analisis_id_b, b), end=" ")
	if inicio_id_b==analisis_id_b:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(c)), analisis_id_c, str(c)), end=" ")
	if inicio_id_c==analisis_id_c:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(l)), analisis_id_l, str(l)), end=" ")
	if inicio_id_l==analisis_id_l:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(t)), analisis_id_t, str(t)), end=" ")
	if inicio_id_t==analisis_id_t:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(d)), analisis_id_d, str(d)), end=" ")
	if inicio_id_d==analisis_id_d:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(ll)), analisis_id_ll, str(ll)), end=" ")
	if inicio_id_ll==analisis_id_ll:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(tt)), analisis_id_tt, str(tt)), end=" ")
	if inicio_id_tt==analisis_id_tt:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(dd)), analisis_id_dd, str(dd)), end=" ")
	if inicio_id_dd==analisis_id_dd:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("+--------------------+--------------------+------------------------------+")
	print ("\n")
	return
 
def analisis_for(n,a,b,c,l,t,d,ll,tt,dd):
 
	#numerico
	analisis_id_n=id(n)
 
	#cadena
	analisis_id_a=id(a)
	for bucle_a in a:
		bucle_a+="1"
	analisis_id_a=id(a)
 
	#boleano
	analisis_id_b=id(b)
 
	#conjunto
	analisis_id_c=id(c)
	for bucle_c in c:
		bucle_c+=1
	analisis_id_c=id(c)
 
	#lista
	analisis_id_l=id(l)
	for bucle_l in l:
		bucle_l+=1
	analisis_id_l=id(l)
 
	#tupla
	analisis_id_t=id(t)
	for bucle_t in t:
		bucle_t+="1"
	analisis_id_t=id(t)
 
	#diccionario
	analisis_id_d=id(d)
	for bucle_d in d:
		bucle_d+=1
	analisis_id_d=id(d)
 
	#lista de listas
	analisis_id_ll=id(ll)
	for bucle_ll in ll:
		bucle_ll+=[1]
	analisis_id_ll=id(ll)
 
	#tupla de tuplas
	analisis_id_tt=id(tt)
	for bucle_tt in tt:
		if type(bucle_tt) is str:
			bucle_tt+="1"
		else:
			bucle_tt+=tuple("1")
	analisis_id_tt=id(tt)
 
	#diccionario de diccionarios
	analisis_id_dd=id(dd)
	for bucle_dd in dd:
		bucle_dd+=1
	analisis_id_dd=id(dd)
 
	print ("VALORES DESPUES DE EJECUTAR BUCLE FOR:")
	print ("+--------------------+--------------------+------------------------------+")
	print ("| Tipo de objeto     | Posicion memoria   | Valor contenido              |")
	print ("+--------------------+--------------------+------------------------------+")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(n)), analisis_id_n, n), end=" ")
	if inicio_id_n==analisis_id_n:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(a)), analisis_id_a, a), end=" ")
	if inicio_id_a==analisis_id_a:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(b)), analisis_id_b, b), end=" ")
	if inicio_id_b==analisis_id_b:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(c)), analisis_id_c, str(c)), end=" ")
	if inicio_id_c==analisis_id_c:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(l)), analisis_id_l, str(l)), end=" ")
	if inicio_id_l==analisis_id_l:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(t)), analisis_id_t, str(t)), end=" ")
	if inicio_id_t==analisis_id_t:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(d)), analisis_id_d, str(d)), end=" ")
	if inicio_id_d==analisis_id_d:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(ll)), analisis_id_ll, str(ll)), end=" ")
	if inicio_id_ll==analisis_id_ll:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(tt)), analisis_id_tt, str(tt)), end=" ")
	if inicio_id_tt==analisis_id_tt:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(dd)), analisis_id_dd, str(dd)), end=" ")
	if inicio_id_dd==analisis_id_dd:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("+--------------------+--------------------+------------------------------+")
	print ("\n")
	return
 
def analisis_visitar(n,a,b,c,l,t,d,ll,tt,dd):
 
	#numerico
	analisis_id_n=id(n)
 
	#cadena
	analisis_id_a=id(a)
 
	#boleano
	analisis_id_b=id(b)
 
	#conjunto
	analisis_id_c=id(c)
 
	#lista
	analisis_id_l=id(l)
 
	#tupla
	analisis_id_t=id(t)
 
	#diccionario
	analisis_id_d=id(d)
 
	#lista de listas
	analisis_id_ll=id(ll)
 
	#tupla de tuplas
	analisis_id_tt=id(tt)
 
	#diccionario de diccionarios
	analisis_id_dd=id(dd)
 
 
	print ("VALORES DESPUES DE VISITAR:")
	print ("+--------------------+--------------------+------------------------------+")
	print ("| Tipo de objeto     | Posicion memoria   | Valor contenido              |")
	print ("+--------------------+--------------------+------------------------------+")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(n)), analisis_id_n, n), end=" ")
	if inicio_id_n==analisis_id_n:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(a)), analisis_id_a, a), end=" ")
	if inicio_id_a==analisis_id_a:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(b)), analisis_id_b, b), end=" ")
	if inicio_id_b==analisis_id_b:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(c)), analisis_id_c, str(c)), end=" ")
	if inicio_id_c==analisis_id_c:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(l)), analisis_id_l, str(l)), end=" ")
	if inicio_id_l==analisis_id_l:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(t)), analisis_id_t, str(t)), end=" ")
	if inicio_id_t==analisis_id_t:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(d)), analisis_id_d, str(d)), end=" ")
	if inicio_id_d==analisis_id_d:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(ll)), analisis_id_ll, str(ll)), end=" ")
	if inicio_id_ll==analisis_id_ll:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(tt)), analisis_id_tt, str(tt)), end=" ")
	if inicio_id_tt==analisis_id_tt:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(dd)), analisis_id_dd, str(dd)), end=" ")
	if inicio_id_dd==analisis_id_dd:
		print ("REUTILIZACION")
	else:
		print ("")
 
	print ("+--------------------+--------------------+------------------------------+")
	print ("\n")
	return
 
def inicio(hacer):
 
	n=0		#numerico
	global inicio_id_n
	inicio_id_n=id(n)
 
	a="0"		#cadena
	global inicio_id_a
	inicio_id_a=id(a)
 
	b=False		#boleano
	global inicio_id_b
	inicio_id_b=id(b)
 
	c={0}		#conjunto
	global inicio_id_c
	inicio_id_c=id(c)
 
	l=[0]		#lista
	global inicio_id_l
	inicio_id_l=id(l)
 
	t=tuple("0")	#tupla
	global inicio_id_t
	inicio_id_t=id(t)
 
	d={0:0}		#diccionario
	global inicio_id_d
	inicio_id_d=id(d)
 
	ll=[[0],[0]]	#lista de listas
	global inicio_id_ll
	inicio_id_ll=id(ll)
 
	tt=tuple(("0", tuple("0")))	#tupla de tuplas
	global inicio_id_tt
	inicio_id_tt=id(tt)
 
	dd={0: {0: 0}}	#diccionario de diccionarios
	global inicio_id_dd
	inicio_id_dd=id(dd)
 
	print ("ASIGNACION DE VALORES AL INICIO:")
	print ("+--------------------+--------------------+------------------------------+")
	print ("| Tipo de objeto     | Posicion memoria   | Valor contenido              |")
	print ("+--------------------+--------------------+------------------------------+")
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(n)), inicio_id_n, n))
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(a)), inicio_id_a, a))
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(b)), inicio_id_b, b))
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(c)), inicio_id_c, str(c)))
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(l)), inicio_id_l, str(l)))
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(t)), inicio_id_t, str(t)))
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(d)), inicio_id_d, str(d)))
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(ll)), inicio_id_ll, str(ll)))
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(tt)), inicio_id_tt, str(tt)))
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(dd)), inicio_id_dd, str(dd)))
	print ("+--------------------+--------------------+------------------------------+")
	print ("\n")
 
	if hacer=="r":
		analisis_reasignar(n,a,b,c,l,t,d,ll,tt,dd)         #reasignacion
 
	if hacer=="m":
		analisis_modifica(n,a,b,c,l,t,d,ll,tt,dd)         #modificacion
 
	if hacer=="n":
		analisis_nuevos_valores(n,a,b,c,l,t,d,ll,tt,dd)   #nuevos valores
 
	if hacer=="f":
		analisis_for(n,a,b,c,l,t,d,ll,tt,dd)              #bucle for
 
	if hacer=="v":
		analisis_visitar(n,a,b,c,l,t,d,ll,tt,dd)          #visitar
 
	print ("VALORES AL FINALIZAR INICIO:")
	print ("+--------------------+--------------------+------------------------------+")
	print ("| Tipo de objeto     | Posicion memoria   | Valor contenido              |")
	print ("+--------------------+--------------------+------------------------------+")
 
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(n)), str(id(n)), n))
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(a)), str(id(a)), a))
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(b)), str(id(b)), b))
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(c)), str(id(c)), str(c)))
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(l)), str(id(l)), str(l)))
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(t)), str(id(t)), str(t)))
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(d)), str(id(d)), str(d)))
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(ll)), str(id(ll)), str(ll)))
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(tt)), str(id(tt)), str(tt)))
	print ("|{:<20}|{:<20}|{:<30}|".format(str(type(dd)), str(id(dd)), str(dd)))
	print ("+--------------------+--------------------+------------------------------+")
	print ("\n"*15)
 
	return
 
inicio("r")	#reasignacion
inicio("m")	#modificacion
inicio("n")	#nuevos valores
inicio("f")	#bucle for
inicio("v")	#visitar





Y despues de ejecutar, la salida que proporciona Python en mi maquina es esta:
Por cierto, en la version 3.9.2... en otras versiones no he tenido tiempo probar.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
ASIGNACION DE VALORES AL INICIO:
+--------------------+--------------------+------------------------------+
| Tipo de objeto     | Posicion memoria   | Valor contenido              |
+--------------------+--------------------+------------------------------+
|<class 'int'>       |140484368070928     |0                             |
|<class 'str'>       |140484366394608     |0                             |
|<class 'bool'>      |9394144             |0                             |
|<class 'set'>       |140484367245088     |{0}                           |
|<class 'list'>      |140484366999104     |[0]                           |
|<class 'tuple'>     |140484366088368     |('0',)                        |
|<class 'dict'>      |140484367449216     |{0: 0}                        |
|<class 'list'>      |140484366397376     |[[0], [0]]                    |
|<class 'tuple'>     |140484366843008     |('0', ('0',))                 |
|<class 'dict'>      |140484366585024     |{0: {0: 0}}                   |
+--------------------+--------------------+------------------------------+
 
 
VALORES DESPUES DE REASIGNAR:
+--------------------+--------------------+------------------------------+
| Tipo de objeto     | Posicion memoria   | Valor contenido              |
+--------------------+--------------------+------------------------------+
|<class 'int'>       |140484368070928     |0                             | REUTILIZACION
|<class 'str'>       |140484366394608     |0                             | REUTILIZACION
|<class 'bool'>      |9394144             |0                             | REUTILIZACION
|<class 'set'>       |140484367245088     |{0}                           | REUTILIZACION
|<class 'list'>      |140484366999104     |[0]                           | REUTILIZACION
|<class 'tuple'>     |140484366088368     |('0',)                        | REUTILIZACION
|<class 'dict'>      |140484367449216     |{0: 0}                        | REUTILIZACION
|<class 'list'>      |140484366397376     |[[0], [0]]                    | REUTILIZACION
|<class 'tuple'>     |140484366843008     |('0', ('0',))                 | REUTILIZACION
|<class 'dict'>      |140484366585024     |{0: {0: 0}}                   | REUTILIZACION
+--------------------+--------------------+------------------------------+
 
 
VALORES AL FINALIZAR INICIO:
+--------------------+--------------------+------------------------------+
| Tipo de objeto     | Posicion memoria   | Valor contenido              |
+--------------------+--------------------+------------------------------+
|<class 'int'>       |140484368070928     |0                             |
|<class 'str'>       |140484366394608     |0                             |
|<class 'bool'>      |9394144             |0                             |
|<class 'set'>       |140484367245088     |{0}                           |
|<class 'list'>      |140484366999104     |[0]                           |
|<class 'tuple'>     |140484366088368     |('0',)                        |
|<class 'dict'>      |140484367449216     |{0: 0}                        |
|<class 'list'>      |140484366397376     |[[0], [0]]                    |
|<class 'tuple'>     |140484366843008     |('0', ('0',))                 |
|<class 'dict'>      |140484366585024     |{0: {0: 0}}                   |
+--------------------+--------------------+------------------------------+
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ASIGNACION DE VALORES AL INICIO:
+--------------------+--------------------+------------------------------+
| Tipo de objeto     | Posicion memoria   | Valor contenido              |
+--------------------+--------------------+------------------------------+
|<class 'int'>       |140484368070928     |0                             |
|<class 'str'>       |140484366394608     |0                             |
|<class 'bool'>      |9394144             |0                             |
|<class 'set'>       |140484367245088     |{0}                           |
|<class 'list'>      |140484366397376     |[0]                           |
|<class 'tuple'>     |140484366627504     |('0',)                        |
|<class 'dict'>      |140484366585024     |{0: 0}                        |
|<class 'list'>      |140484366999104     |[[0], [0]]                    |
|<class 'tuple'>     |140484366843008     |('0', ('0',))                 |
|<class 'dict'>      |140484367449216     |{0: {0: 0}}                   |
+--------------------+--------------------+------------------------------+
 
 
VALORES DESPUES DE MODIFICAR:
+--------------------+--------------------+------------------------------+
| Tipo de objeto     | Posicion memoria   | Valor contenido              |
+--------------------+--------------------+------------------------------+
|<class 'int'>       |140484368070960     |1                             |
|<class 'str'>       |140484366843056     |01                            |
|<class 'int'>       |140484368070960     |1                             |
|<class 'set'>       |140484367245088     |{0, 1}                        | REUTILIZACION
|<class 'list'>      |140484366397376     |[0, 1]                        | REUTILIZACION
|<class 'tuple'>     |140484366842944     |('0', '1')                    |
|<class 'dict'>      |140484366585024     |{0: 0, '1': 1}                | REUTILIZACION
|<class 'list'>      |140484366999104     |[[0], [0], [1], [1]]          | REUTILIZACION
|<class 'tuple'>     |140484366403440     |('0', ('0',), 1, 1)           |
|<class 'dict'>      |140484367449216     |{0: {0: 0}, '1': {'1': 1}}    | REUTILIZACION
+--------------------+--------------------+------------------------------+
 
 
VALORES AL FINALIZAR INICIO:
+--------------------+--------------------+------------------------------+
| Tipo de objeto     | Posicion memoria   | Valor contenido              |
+--------------------+--------------------+------------------------------+
|<class 'int'>       |140484368070928     |0                             |
|<class 'str'>       |140484366394608     |0                             |
|<class 'bool'>      |9394144             |0                             |
|<class 'set'>       |140484367245088     |{0, 1}                        |
|<class 'list'>      |140484366397376     |[0, 1]                        |
|<class 'tuple'>     |140484366627504     |('0',)                        |
|<class 'dict'>      |140484366585024     |{0: 0, '1': 1}                |
|<class 'list'>      |140484366999104     |[[0], [0], [1], [1]]          |
|<class 'tuple'>     |140484366843008     |('0', ('0',))                 |
|<class 'dict'>      |140484367449216     |{0: {0: 0}, '1': {'1': 1}}    |
+--------------------+--------------------+------------------------------+
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ASIGNACION DE VALORES AL INICIO:
+--------------------+--------------------+------------------------------+
| Tipo de objeto     | Posicion memoria   | Valor contenido              |
+--------------------+--------------------+------------------------------+
|<class 'int'>       |140484368070928     |0                             |
|<class 'str'>       |140484366394608     |0                             |
|<class 'bool'>      |9394144             |0                             |
|<class 'set'>       |140484367245088     |{0}                           |
|<class 'list'>      |140484366999104     |[0]                           |
|<class 'tuple'>     |140484366088368     |('0',)                        |
|<class 'dict'>      |140484367449216     |{0: 0}                        |
|<class 'list'>      |140484366397184     |[[0], [0]]                    |
|<class 'tuple'>     |140484366843008     |('0', ('0',))                 |
|<class 'dict'>      |140484367449408     |{0: {0: 0}}                   |
+--------------------+--------------------+------------------------------+
 
 
VALORES DESPUES DE ASIGNAR NUEVOS VALORES:
+--------------------+--------------------+------------------------------+
| Tipo de objeto     | Posicion memoria   | Valor contenido              |
+--------------------+--------------------+------------------------------+
|<class 'int'>       |140484368070992     |2                             |
|<class 'str'>       |140484366774576     |2                             |
|<class 'bool'>      |9394176             |1                             |
|<class 'set'>       |140484366635072     |{2}                           |
|<class 'list'>      |140484366397120     |[2]                           |
|<class 'tuple'>     |140484366627408     |('2',)                        |
|<class 'dict'>      |140484366585024     |{'2': 2}                      |
|<class 'list'>      |140484366396992     |[[2], [2]]                    |
|<class 'tuple'>     |140484366583168     |(2, 2)                        |
|<class 'dict'>      |140484367507584     |{'2': {'2': 2}}               |
+--------------------+--------------------+------------------------------+
 
 
VALORES AL FINALIZAR INICIO:
+--------------------+--------------------+------------------------------+
| Tipo de objeto     | Posicion memoria   | Valor contenido              |
+--------------------+--------------------+------------------------------+
|<class 'int'>       |140484368070928     |0                             |
|<class 'str'>       |140484366394608     |0                             |
|<class 'bool'>      |9394144             |0                             |
|<class 'set'>       |140484367245088     |{0}                           |
|<class 'list'>      |140484366999104     |[0]                           |
|<class 'tuple'>     |140484366088368     |('0',)                        |
|<class 'dict'>      |140484367449216     |{0: 0}                        |
|<class 'list'>      |140484366397184     |[[0], [0]]                    |
|<class 'tuple'>     |140484366843008     |('0', ('0',))                 |
|<class 'dict'>      |140484367449408     |{0: {0: 0}}                   |
+--------------------+--------------------+------------------------------+
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ASIGNACION DE VALORES AL INICIO:
+--------------------+--------------------+------------------------------+
| Tipo de objeto     | Posicion memoria   | Valor contenido              |
+--------------------+--------------------+------------------------------+
|<class 'int'>       |140484368070928     |0                             |
|<class 'str'>       |140484366394608     |0                             |
|<class 'bool'>      |9394144             |0                             |
|<class 'set'>       |140484367245088     |{0}                           |
|<class 'list'>      |140484366397184     |[0]                           |
|<class 'tuple'>     |140484366627504     |('0',)                        |
|<class 'dict'>      |140484367449408     |{0: 0}                        |
|<class 'list'>      |140484366999104     |[[0], [0]]                    |
|<class 'tuple'>     |140484366843008     |('0', ('0',))                 |
|<class 'dict'>      |140484367449216     |{0: {0: 0}}                   |
+--------------------+--------------------+------------------------------+
 
 
VALORES DESPUES DE EJECUTAR BUCLE FOR:
+--------------------+--------------------+------------------------------+
| Tipo de objeto     | Posicion memoria   | Valor contenido              |
+--------------------+--------------------+------------------------------+
|<class 'int'>       |140484368070928     |0                             | REUTILIZACION
|<class 'str'>       |140484366394608     |0                             | REUTILIZACION
|<class 'bool'>      |9394144             |0                             | REUTILIZACION
|<class 'set'>       |140484367245088     |{0}                           | REUTILIZACION
|<class 'list'>      |140484366397184     |[0]                           | REUTILIZACION
|<class 'tuple'>     |140484366627504     |('0',)                        | REUTILIZACION
|<class 'dict'>      |140484367449408     |{0: 0}                        | REUTILIZACION
|<class 'list'>      |140484366999104     |[[0, 1], [0, 1]]              | REUTILIZACION
|<class 'tuple'>     |140484366843008     |('0', ('0',))                 | REUTILIZACION
|<class 'dict'>      |140484367449216     |{0: {0: 0}}                   | REUTILIZACION
+--------------------+--------------------+------------------------------+
 
 
VALORES AL FINALIZAR INICIO:
+--------------------+--------------------+------------------------------+
| Tipo de objeto     | Posicion memoria   | Valor contenido              |
+--------------------+--------------------+------------------------------+
|<class 'int'>       |140484368070928     |0                             |
|<class 'str'>       |140484366394608     |0                             |
|<class 'bool'>      |9394144             |0                             |
|<class 'set'>       |140484367245088     |{0}                           |
|<class 'list'>      |140484366397184     |[0]                           |
|<class 'tuple'>     |140484366627504     |('0',)                        |
|<class 'dict'>      |140484367449408     |{0: 0}                        |
|<class 'list'>      |140484366999104     |[[0, 1], [0, 1]]              |
|<class 'tuple'>     |140484366843008     |('0', ('0',))                 |
|<class 'dict'>      |140484367449216     |{0: {0: 0}}                   |
+--------------------+--------------------+------------------------------+
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ASIGNACION DE VALORES AL INICIO:
+--------------------+--------------------+------------------------------+
| Tipo de objeto     | Posicion memoria   | Valor contenido              |
+--------------------+--------------------+------------------------------+
|<class 'int'>       |140484368070928     |0                             |
|<class 'str'>       |140484366394608     |0                             |
|<class 'bool'>      |9394144             |0                             |
|<class 'set'>       |140484367245088     |{0}                           |
|<class 'list'>      |140484366999104     |[0]                           |
|<class 'tuple'>     |140484366088368     |('0',)                        |
|<class 'dict'>      |140484367449216     |{0: 0}                        |
|<class 'list'>      |140484366397184     |[[0], [0]]                    |
|<class 'tuple'>     |140484366843008     |('0', ('0',))                 |
|<class 'dict'>      |140484367449408     |{0: {0: 0}}                   |
+--------------------+--------------------+------------------------------+
 
 
VALORES DESPUES DE VISITAR:
+--------------------+--------------------+------------------------------+
| Tipo de objeto     | Posicion memoria   | Valor contenido              |
+--------------------+--------------------+------------------------------+
|<class 'int'>       |140484368070928     |0                             | REUTILIZACION
|<class 'str'>       |140484366394608     |0                             | REUTILIZACION
|<class 'bool'>      |9394144             |0                             | REUTILIZACION
|<class 'set'>       |140484367245088     |{0}                           | REUTILIZACION
|<class 'list'>      |140484366999104     |[0]                           | REUTILIZACION
|<class 'tuple'>     |140484366088368     |('0',)                        | REUTILIZACION
|<class 'dict'>      |140484367449216     |{0: 0}                        | REUTILIZACION
|<class 'list'>      |140484366397184     |[[0], [0]]                    | REUTILIZACION
|<class 'tuple'>     |140484366843008     |('0', ('0',))                 | REUTILIZACION
|<class 'dict'>      |140484367449408     |{0: {0: 0}}                   | REUTILIZACION
+--------------------+--------------------+------------------------------+
 
 
VALORES AL FINALIZAR INICIO:
+--------------------+--------------------+------------------------------+
| Tipo de objeto     | Posicion memoria   | Valor contenido              |
+--------------------+--------------------+------------------------------+
|<class 'int'>       |140484368070928     |0                             |
|<class 'str'>       |140484366394608     |0                             |
|<class 'bool'>      |9394144             |0                             |
|<class 'set'>       |140484367245088     |{0}                           |
|<class 'list'>      |140484366999104     |[0]                           |
|<class 'tuple'>     |140484366088368     |('0',)                        |
|<class 'dict'>      |140484367449216     |{0: 0}                        |
|<class 'list'>      |140484366397184     |[[0], [0]]                    |
|<class 'tuple'>     |140484366843008     |('0', ('0',))                 |
|<class 'dict'>      |140484367449408     |{0: {0: 0}}                   |
+--------------------+--------------------+------------------------------+





A mi entender mal, muy mal el reutilizar los mismos espacios de memoria para o en distintas funciones.
Y dependiendo del tipo de la variable, unas veces si y otras veces no...

Donde ha quedado la definicion de variables u objetos locales y globales!

Un saludo!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar