Cordiales Saludos
Tuplas
La tupla es una estructura de dato interna de python que nos sirve para tener una colección de datos indexados. La principal característica de las tuplas es que son inmutables, es decir, no podemos modificar/eliminar los valores internos y tampoco podemos agregar nuevos elementos. Son de gran utilidad si deseamos que su estructura no cambie dentro de nuestro programa.
De manera generalizada crearemos las tuplas encerrando los elementos que la componen dentro de paréntesis. Aunque la podemos crear sin los paréntesis, por regla general recomiendo el uso de los éstos.
>>> tupla = (1, 2, 3)
>>> type(tupla)
<class 'tuple'>
>>> tupla2 = 4, 5, 6
>>> type(tupla2)
<class 'tuple'>
>>>
>>>
Las tuplas están indexadas, por tal motivo podemos acceder a sus elementos:
>>> tupla = (1, 2, 3)
>>> tupla[0]
1
>>>
>>> tupla[-1]
3
>>>
A continuación veremos los métodos y características de las tuplas y de las listas. Es común comparar las listas y las tuplas por su parecido.
# Una Comparación de los métodos y caracteristicas de las LIstas y Tuplas
>>> lista = [ 1, 2, 3 ]
>>> dir(lista)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
>>> tupla = (1, 2, 3)
>>> dir(tupla)
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
>>>
La función type() es de mucha ayuda para aclarar con que tipo de datos estamos trabajando.
>>> type(lista)
<class 'list'>
>>> type(tupla)
<class 'tuple'>
>>>
Método count()
Nos permite saber cuantas veces aparece un número dentro de la tupla. En el siguiente ejercicio deseamos determinar cuantas veces aparece el 2. La respuesta es 2 veces.
>>> elementos = (10, 9, 10, 10, 3, 2, 2)
>>> elementos.count(2)
2
>>>
Método index()
Nos permite obtener el índice de un número dentro de la tupla. En el siguiente ejercicio nos muestra que el número 9 está en la posición 1.
>>> elementos = (10, 9, 10, 10, 3, 2, 2)
>>> elementos.index(9)
1
>>>
Podemos transformar una lista en tupla con la función interna tuple():
>>> numeros = [100, 200, 300]
>>> tuple_numeros = tuple(numeros)
>>> type(tuple_numeros)
<class 'tuple'>
Podemos transformar un tupla en lista con la función interna list():
>>> letras = ('a', 'b', 'c')
lista_letras = list(letras)
>>> type(lista_letras)
<class 'list'>
Algo importante es que las tuplas ocupan menos espacios de memoria, veamos:
>>> lista.__sizeof__()
64
>>> tupla.__sizeof__()
48
>>>
Longitud de tuplas
>>> len(tupla)
3
Tuplas de un solo valor
>>> tupla2 = ("Unico",)
>>> type(tupla2)
<class 'tuple'>
>>>
Iteración de Tuplas
Desempaquetado de Tuplas
Cuando creamos la tupla, lo que hacemos es empaquetar valores dentro de la tupla creada,
tupla = (1, 2, 3)
Para el desempaquetado colocamos variables donde se asignarán los valores de la tupla.
# Desempaquetado de Tuplas
>>> uno, dos, tres = tupla
>>> uno
1
>>> dos
2
>>> tres
3
>>>
Profundizando en Python
1.- dir()
La función dir() nos mustra todas las caracteristicas y métodos de un objeto.
2.- Type()
La función type() nos muestra el tipo de dato.
3.- Limpiando la Consola
Linux
# Para sistemas Linux
>>> from os import system
>>> system("clear")
Windows
#Para sistema Window
>>> from os import system
>>> system("cls")
4.- Zen de Python
Tipea en la consola de python: import this y nos mostrará el Zen de Python
>>> import this
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
>>>
Para finalizar, recuerda siempre practicar, practicar, practicar.