1+ """
2+ EJERCICIO:
3+ - Muestra ejemplos de asignación de variables "por valor" y "por
4+ referencia", según su tipo de dato.
5+ - Muestra ejemplos de funciones con variables que se les pasan "por
6+ valor" y "por referencia", y cómo se comportan en cada caso en el
7+ momento de ser modificadas.
8+ (Entender estos conceptos es algo esencial en la gran mayoría de
9+ lenguajes)
10+
11+ DIFICULTAD EXTRA (opcional):
12+ Crea dos programas que reciban dos parámetros (cada uno) definidos
13+ como variables anteriormente.
14+
15+ - Cada programa recibe, en un caso, dos parámetros por valor, y en
16+ otro caso, por referencia.
17+
18+ Estos parámetros los intercambia entre ellos en su interior, los
19+ retorna, y su retorno se asigna a dos variables diferentes a las
20+ originales.
21+
22+ A continuación, imprime el valor de las variables originales y las
23+ nuevas, comprobando que se ha invertido su valor en las segundas.
24+
25+ Comprueba también que se ha conservado el valor original en las primeras.
26+
27+ by adra-dev.
28+ """
29+
30+
31+ """
32+ En un lenguaje de programaicon, una variable es un termnio que
33+ representa un espacio en la memoria del ordenador.
34+ """
35+
36+ # Paso por valor
37+
38+ a = int (10 )
39+ b = float (5 )
40+ c = complex (2 + 5j )
41+ d = str ("Hola mundo!" )
42+ e = list ([1 , 2 , 3 ])
43+ f = dict (zip (['a' ,'b' ,'c' ],[1 , 2 , 3 ]))
44+ g = set ([1 , 2 , 3 ])
45+
46+ print (a , b , c , d , e , f , g ,)
47+ print (a is b )
48+ print (e is f )
49+ print (f is g )
50+ print (g is e )
51+
52+ # Paso por referencia
53+
54+ a = 10
55+ b = a
56+
57+ c = 5.5
58+ d = c
59+
60+ e = 2 + 5j
61+ f = e
62+
63+ g = "Hola mundo!"
64+ h = g
65+
66+ i = list ([1 , 2 , 3 ])
67+ j = i
68+
69+ k = dict (zip (['a' ,'b' ,'c' ],[1 , 2 , 3 ]))
70+ l = k
71+
72+ m = set ([1 , 2 , 3 ])
73+ n = m
74+
75+ print (a , b , c , d , e , f , g ,)
76+ print (a is b )
77+ print (g is h )
78+ print (i is j )
79+ print (k is l )
80+
81+ """
82+ En python, los argumentos siempre se pasan por referencia, es decir,
83+ los identificadores definidos en la cabecera de la funcion quedan
84+ refernciados a las posiciones de memoria de los valores indicados en
85+ llamada a la funcion. Pero resulta que el objeto pasado como
86+ argumento puede ser mutable o inmutable. Si es inmutable, los
87+ parametors crean, como ya sabemos, un nuevo espacio en memoria, lo
88+ cual seria equivalente a un paso por valor. Por tanto, cuando los
89+ argumentos son objetos inmutables su contenido no se ve alterado por
90+ la llamada a la funcion, pues los parametros guardan su propia copia
91+ del argumento.
92+ """
93+
94+ # paso por valor
95+ def appellidar (nombre ):
96+ nombre += ' Martinez'
97+ print (nombre )
98+
99+ nombre = 'Rosa'
100+ appellidar (nombre )
101+ print (nombre )
102+
103+ """
104+ En cambio, cuando pasamos como argumentos tipos mutables, la tabla
105+ de simbolos de la funcion tambien contiene sus propios
106+ identificadores, pero estos parametros apuntan a las posiciones de
107+ memoria donde se alojan los datos pasados como argumento.
108+ """
109+
110+ def ampliar (lista ):
111+ lista += [4 , 5 , 6 ]
112+
113+ l = [1 , 2 , 3 ]
114+ print (l )
115+ ampliar (l )
116+ print (l )
117+
118+
119+ """
120+ Extra
121+ """
122+ # Por valor
123+
124+ def value (value_1 , value_2 ):
125+ temp = value_1
126+ value_1 = value_2
127+ value_2 = temp
128+
129+ return value_1 , value_2
130+
131+ value_1 = 'Hello'
132+ value_2 = 'Python'
133+ value_3 , value_4 = value (value_1 , value_2 )
134+ print (f"{ value_1 } { value_2 } )
135+ print (f"{ value_3 } { value_4 } )
136+
137+
138+
139+ # Por referencia
140+ def ref (value_1 : list , value_2 : list ) -> tuple :
141+ temp = value_1
142+ value_1 = value_2
143+ value_2 = temp
144+
145+ return value_1 , value_2
146+
147+
148+ my_list_a = [10 ,20 ]
149+ my_list_b = [30 ,40 ]
150+ my_list_c , my_list_d = ref (my_list_a , my_list_b )
151+ print (f"{ my_list_a } { my_list_b } )
152+ print (f"{ my_list_c } { my_list_d } )
0 commit comments