Continuando con el artículo REVIT ARCHITECTURE (946) – PYTHON – Funciones (30) – Tuplas y diccionarios (2) Utilización de una Tupla (1) se indican a continuación otras acciones que se pueden realizar con Tuplas:
La función len() acepta tuplas y devuelve el número de elementos contenidos dentro de ellas.
El operador + puede unir tuplas.
El operador * puede multiplicar tuplas, al igual que las listas.
Los operadores in y not in funcionan de la misma manera que en las listas.
Tenemos la siguiente Tupla en la que se van a utilizar las acciones comentadas en el párrafo anterior:
Se crea una tupla llamada my_tuple que contiene tres elementos: 1, 10, y 100.
Recordamos una vez más que las tuplas son estructuras de datos inmutables, es decir, una vez que se han creado, no se pueden modificar.
En esta línea, se está creando una nueva tupla llamada t1.
La operación my_tuple + (1000, 10000) concatena dos tuplas: my_tuple (que contiene (1, 10, 100)) y la tupla (1000, 10000).
El resultado de esta operación es una nueva tupla: (1, 10, 100, 1000, 10000).
Es importante notar que la tupla original my_tuple no se modifica; se crea una nueva tupla que se almacena en t1.
Aquí se crea otra nueva tupla llamada t2.
La operación my_tuple * 3 multiplica la tupla my_tuple por 3.
Esto significa que los elementos de my_tuple se repiten tres veces seguidas en la nueva tupla.
El resultado es la tupla (1, 10, 100, 1, 10, 100, 1, 10, 100).
Esta línea imprime la longitud (número de elementos) de la tupla t2 utilizando la función len().
t2 contiene 9 elementos, por lo que se imprime 9.
Aquí se imprime la tupla t1, que es (1, 10, 100, 1000, 10000).
Esta línea imprime la tupla t2, que es (1, 10, 100, 1, 10, 100, 1, 10, 100).
Este comando evalúa si el número 10 está presente en la tupla my_tuple.
Dado que 10 es un elemento de my_tuple, la expresión 10 in my_tuple es True, por lo que se imprime True.
Finalmente, esta línea evalúa si el número -10 no está presente en my_tuple.
Como -10 no es un elemento de my_tuple, la expresión -10 not in my_tuple es True, por lo que se imprime True.
Resumen de la salida:
len(t2): 9, ya que t2 contiene 9 elementos.
t1: (1, 10, 100, 1000, 10000), que es la tupla resultante de concatenar my_tuple con (1000, 10000).
t2: (1, 10, 100, 1, 10, 100, 1, 10, 100), que es my_tuple repetida 3 veces.
10 in my_tuple: True, porque el valor 10 está en my_tuple.
-10 not in my_tuple: True, porque el valor -10 no está en my_tuple.
Una de las propiedades más útiles de las tuplas es su capacidad para aparecer en el lado izquierdo del operador de asignación.
En el siguiente fragmento de código:
Es un ejemplo de tres tuplas interactuando; es decir, los valores almacenados en ellas «circulan» – t1 se convierte en t2, t2 se convierte en t3, y t3 se convierte en t1.
Los elementos de una tupla pueden ser variables, no solo literales. Además, pueden ser expresiones si están en el lado derecho del operador de asignación.
Este código ilustra cómo se pueden usar tuplas para realizar una asignación múltiple en Python.
Inicialización de la variable var
Se crea una variable var y se le asigna el valor 123.
Este valor se utilizará más adelante para construir una de las tuplas.
Creación de las tuplas t1, t2, y t3
t1 = (1, ):
Se crea una tupla t1 que contiene un solo elemento: el número 1.
La coma , es necesaria para que Python entienda que se está creando una tupla con un solo elemento, de lo contrario, sería simplemente un número entre paréntesis.
t2 = (2, ):
Similarmente, se crea la tupla t2 que contiene un solo elemento: el número 2.
t3 = (3, var):
Aquí se crea la tupla t3 que contiene dos elementos: el número 3 y el valor de la variable var, que es 123.
Por lo tanto, t3 es (3, 123).
Asignación múltiple: intercambio de valores
Esta línea realiza una asignación múltiple, intercambiando los valores entre las tuplas t1, t2, y t3.
La operación ocurre en un solo paso y de forma simultánea, lo que significa que los valores de t1, t2, y t3 se reasignan a nuevas variables sin interferencias entre ellos.
Desglosemos lo que sucede:
t1 recibe el valor actual de t2, que es (2, ).
t2 recibe el valor actual de t3, que es (3, 123).
t3 recibe el valor actual de t1, que es (1, ).
Estado final de las tuplas:
t1 ahora es (2, ).
t2 ahora es (3, 123).
t3 ahora es (1, ).
Este código muestra cómo se pueden intercambiar los valores entre varias tuplas utilizando asignación múltiple. Las tuplas originales t1, t2, y t3 han «circulado» entre sí: t1 toma el valor de t2, t2 toma el valor de t3, y t3 toma el valor de t1, logrando un intercambio elegante y eficiente de valores.
Contenido Web de Yolanda Muriel está sujeto bajo Licencia Creative Commons Atribución-NoComercial-SinDerivadas 3.0 Unported.
yolandamuriel.com 