Aunque ya se han tocado la listas de forma superficial y más tarde para mostrar como se hace un array bidimensional, ahora vamos a aprender mucho más sobre como funcionan y su control, sobre todo por que puede resultar extremadamente interesante.
El cual nos da como resultado:
2 1
[2, 56.78, 3, 33.44, 1, 2]
[2, 56.78, 3, 33.44, 1, 2, 102]
4
[56.78, 3, 33.44, 1, 2, 102]
[102, 2, 1, 33.44, 3, 56.78]
[1, 2, 3, 33.44, 56.78, 102]
[1, 2, 3, 33.44, 56.78]
Para llevarlas a cabo utilizamos los siguientes métodos:
Y su resultado es:
[1, 5, 67, 4, 2, 89, 23]
[1, 5, 4, 2, 89, 23]
[1, 5, 4, 23]
[]
Una tupla consiste en un número de valores separados por comas:
Que nos da como resultado:
('hola', 'mundo', 'desde', 'phyton')
(('hola', 'mundo', 'desde', 'phyton'), (1, 2, 3, 4))
Las tuplas son inmutables, aunque pueden contener objetos mutables.
Al representarse siempre aparecen entre paréntesis.
Puede parecer que las tuplas son parecidas a las listas, pero son distintas, las tuplas son inmutables y suelen contener elementos heterogeneos a los que se accede al desempaquetar o indexar. Las listas por su lado son mutables y sus elementos generalmente son homogeneos, accediendose a ellos por iteración.
Cuando hacemos
Estamos empaquetando las tuplas, pero también se puede desempaquetar de la siguiente forma:
Para hacer un desempaquetado de secuencias, se debe de tener en el lado izquierdo tantas variables como elementos tiene la tupla que se encuentra en el lado izquierdo. De este modo se tiene acceso a las variables de forma normal.
El resultado de este pequeño script es:
{'FORD', 'Mercedes', 'Fiat', 'SEAT'}
True
False
{'t', 's', 'm', 'o', 'u', 'i', 'q'}
{'a', 'm', 'l', 'o', 'r', 'u', 'e', 'i', 'c', 'g'}
{'s', 't', 'q'}
{'a', 'm', 'l', 'e', 'i', 'g', 'q', 't', 's', 'o', 'r', 'u', 'c'}
{'i', 'u', 'm', 'o'}
{'t', 'a', 's', 'l', 'r', 'e', 'c', 'g', 'q'}
Métodos
Empezaremos analizando algunos de sus metodos:- list.append (i) Agrega un elemento al final de la lista
- list.extend (l) Agrega a la lista todos los elementos de una lista dada
- list.insert (x, i) Inserta un elemento i delante de la posición x, por lo que list.insert (3, 'Pi') insertará Pi delante de la posicion 3.
- list.remove (i) Elimina el primer elemento de la lista que coincida con i, pero si no hay ninguno nos dará un error
- list.pop (x) Elimina el elemento de la posición solicitada y lo devuelve, en caso de no añadir la posición lo hará de la última.
- list.clear() Elimina todos los elementos de una lista
- list.index(i) Devuelve el número de veces que i aparece en la lista
- list.sort(key=none reverse=false) Sirve para ordenar una lista, los argumentos se pueden utilizar para definir un orden especifico
- list.reverse() Invierte los elementos de la lista
- list.copy() Devuelve la mayoría de lo elementos de una lista.
a = [2, 56.78, 33.44, 1, 2] print(a.count(2), a.count(1)) a.insert(2, 3) print(a) a.append(102) print(a) print(a.index(1)) a.remove(2) print(a) a.reverse() print(a) a.sort() print(a) a.pop() print(a)
El cual nos da como resultado:
2 1
[2, 56.78, 3, 33.44, 1, 2]
[2, 56.78, 3, 33.44, 1, 2, 102]
4
[56.78, 3, 33.44, 1, 2, 102]
[102, 2, 1, 33.44, 3, 56.78]
[1, 2, 3, 33.44, 56.78, 102]
[1, 2, 3, 33.44, 56.78]
Pilas
El concepto de pila es muy sencillo, imagina una pila de libros, donde para poner uno libro siempre tienes que ponerlo encima y para quitarlo siempre retiras el de lo alto. Es decir el último que llega antes se va.
Para utilizar esta estructura es tan sencillo como utilizar los métodos:
- list.append() que coloca al final
- list.pop() que quita el último elemento de la lista
Colas
Si el concepto de pila es sencillo, el de cola lo es más todavía, tan solo tenemos que imaginar una cola para entrar al cine, concierto, del paro... donde los nuevos elementos que llegan se colocan al final de la cola, pero los que salen son los que están al principio.
- list.append() que añade al final de la lista
- list.pop(0) que retira el primer elemento de la lista
del
Existe otra forma de eliminar un elemento de una lista, usando la instrucción del, que puede usarse también para eliminar secciones o la lista completa como vemos en el siguiente ejemplo:
b = [1, 5, 67, 4, 2, 89, 23] print(b) del b[2] print(b) del b[3:5] print(b) del b[:] print(b)
Y su resultado es:
[1, 5, 67, 4, 2, 89, 23]
[1, 5, 4, 2, 89, 23]
[1, 5, 4, 23]
[]
Tuplas y secuencias
t = 'hola', 'mundo', 'desde', 'phyton' print(t) u = t, (1, 2, 3, 4) print(u)
Que nos da como resultado:
('hola', 'mundo', 'desde', 'phyton')
(('hola', 'mundo', 'desde', 'phyton'), (1, 2, 3, 4))
Las tuplas son inmutables, aunque pueden contener objetos mutables.
Al representarse siempre aparecen entre paréntesis.
Puede parecer que las tuplas son parecidas a las listas, pero son distintas, las tuplas son inmutables y suelen contener elementos heterogeneos a los que se accede al desempaquetar o indexar. Las listas por su lado son mutables y sus elementos generalmente son homogeneos, accediendose a ellos por iteración.
Cuando hacemos
t = 'hola', 'mundo', 'desde', 'phyton'
Estamos empaquetando las tuplas, pero también se puede desempaquetar de la siguiente forma:
v, x, y, z = t
Para hacer un desempaquetado de secuencias, se debe de tener en el lado izquierdo tantas variables como elementos tiene la tupla que se encuentra en el lado izquierdo. De este modo se tiene acceso a las variables de forma normal.
Conjuntos
Los conjuntos son colecciones no ordenadas de elementos sin repetir.
Sus usos básicos son:
- Verificación de pertenencia y eliminación de entradas duplicadas
- Funciones matemáticas típicas de los conjuntos como unión, intersección, diferencia...
- Para crear conjuntos se utilizan las llaves {elementos} lo la función set(elementos)
- Para crear un conjuntos vacío se utiliza set() sin nada dentro
#Declaración e impresión de un conjunto
coches = {'SEAT', 'Mercedes', 'Fiat', 'FORD'}
print(coches)
#comprobación de elementos en un conjunto
condicion = 'SEAT' in coches
print(condicion)
condicion2 = 'Mitshubishi' in coches
print(condicion2)
#Operaciones con conjunto
a = set ('mosquito')
b = set ('murcielago')
print(a)
print(b)
print(a - b) #conjunto a - b
print(a | b) #letras que estan en a o en b
print(a & b) #intersección entre a y b
print(a ^ b) #letras en a o b pero no en ambos
El resultado de este pequeño script es:
{'FORD', 'Mercedes', 'Fiat', 'SEAT'}
True
False
{'t', 's', 'm', 'o', 'u', 'i', 'q'}
{'a', 'm', 'l', 'o', 'r', 'u', 'e', 'i', 'c', 'g'}
{'s', 't', 'q'}
{'a', 'm', 'l', 'e', 'i', 'g', 'q', 't', 's', 'o', 'r', 'u', 'c'}
{'i', 'u', 'm', 'o'}
{'t', 'a', 's', 'l', 'r', 'e', 'c', 'g', 'q'}
Diccionarios
En otros lenguajes de programación se suelen conocer como arrays asociativos.
Se indexan por claves, que debe de ser de tipo inmutables (cadenas y números siempre pueden ser claves)
Para entender los diccionarios, lo mejor es pensar en un conjunto no ordenado de pares clave: valor, con el requirimiento de que las claves han de ser únicas.
Para crear un diccionario es necesario hacerlo entre llaves {}, de hecho dentro debemos de poner la lista de pares clave: valor separados por comas para declararlo.
Las operaciones principales que se pueden hacer con los conjuntos es guardar un valor con un a clave (la clave no debe existir, o de lo contrario se borrará el valor que había antes), extraer un valor a través de un clave, y borrar un valor a través de del.
Se puede listar un diccionario por medio de list(d.keys()) pero esto dará el diccionario ordenado de forma arbitraria, por lo que puede resultar más interesante mostrarlo de forma ordenada por medio de sorted(d.keys())
Para consultar si una clave esta en el diccionario, lo ideal es usar in.
A continuación vemos un ejemplo de todo esto para entenderlo facilmente:
#declaración y salida de un diccionario
telefonos = {'Miguel':123456789, 'Antonio':987654321, 'María':543216789}
print(telefonos)
#añadiendo un elemento nuevo
telefonos['Lorenzo']=918273465
print(telefonos)
#imprimiendo un elemento dado, solo imprime el valor, no la clave
print(telefonos['Miguel'])
print(list(telefonos.keys()))
print(sorted(telefonos.keys()))
Aquí podemos ver claramente como funciona todo lo que hemos explicado, resultando más sencillo de lo que en realidad podría parecer, y a continuación el resultado que muestra por pantalla.
{'Miguel': 123456789, 'María': 543216789, 'Antonio': 987654321}
{'Miguel': 123456789, 'María': 543216789, 'Lorenzo': 918273465, 'Antonio': 987654321}
123456789
['Miguel', 'María', 'Lorenzo', 'Antonio']
['Antonio', 'Lorenzo', 'María', 'Miguel']
Dando como resultado:
Miguel 123456789
Antonio 987654321
María 543216789
Pero puede ocurrir que queramos que el mismo for nos enumere los elementos conforme los va mostrando y para ello se puede utilizar el método enumerate() como vemos en el siguiente ejemplo:
Con el cual se obtiene el siguente resultado:
0 ('Antonio', 987654321)
1 ('Miguel', 123456789)
2 ('María', 543216789)
Pero también podemos hacer una iteración entre dos secuencias al mismo tiempo, emparejando los valores por medio de zip().
y su resultado:
¿Cual es tu nombre? Lancelot
¿Cual es tu objetivo? la busqueda del santo grial
¿Cual es tu color favorito? azul
Podemos iterar a través de una lista de forma inversa con reversed() y ordenada con sorted():
Que obtiene:
------LISTA INVERSA---------
color favorito
objetivo
nombre
------LISTA OORDENADA---------
Lancelot
azul
la busqueda del santo grial
{'Miguel': 123456789, 'María': 543216789, 'Antonio': 987654321}
{'Miguel': 123456789, 'María': 543216789, 'Lorenzo': 918273465, 'Antonio': 987654321}
123456789
['Miguel', 'María', 'Lorenzo', 'Antonio']
['Antonio', 'Lorenzo', 'María', 'Miguel']
Técnicas de iteración
Aunque ya conocemos varias formas de iterar, tan solo tenemos que ver la entrada sobre las estructuras de control de flujo, ahora vamos a ver algunas formas específicas de iterar por listas, seguro que le sacas partido....
Cuando queremos iterar en un diccionario, podemos obtener la clave y el valor si utilizamos el método items():
telefonos = {'Antonio': 987654321, 'María': 543216789, 'Miguel': 123456789}
for k, v in telefonos.items():
print(k, v)
Dando como resultado:
Miguel 123456789
Antonio 987654321
María 543216789
Pero puede ocurrir que queramos que el mismo for nos enumere los elementos conforme los va mostrando y para ello se puede utilizar el método enumerate() como vemos en el siguiente ejemplo:
telefonos = {'Antonio': 987654321, 'María': 543216789, 'Miguel': 123456789}
for k, v in enumerate(telefonos.items()):
print(k, v)
Con el cual se obtiene el siguente resultado:
0 ('Antonio', 987654321)
1 ('Miguel', 123456789)
2 ('María', 543216789)
Pero también podemos hacer una iteración entre dos secuencias al mismo tiempo, emparejando los valores por medio de zip().
preguntas = ['nombre', 'objetivo', 'color favorito']
respuestas = ['Lancelot', 'la busqueda del santo grial', 'azul']
for p, r in zip(preguntas, respuestas):
print('¿Cual es tu {0}? {1}'.format(p, r))
y su resultado:
¿Cual es tu nombre? Lancelot
¿Cual es tu objetivo? la busqueda del santo grial
¿Cual es tu color favorito? azul
Podemos iterar a través de una lista de forma inversa con reversed() y ordenada con sorted():
print('------LISTA INVERSA---------')
for i in reversed(preguntas):
print(i)
print('------LISTA OORDENADA---------')
for f in sorted(respuestas):
print(f)
Que obtiene:
------LISTA INVERSA---------
color favorito
objetivo
nombre
------LISTA OORDENADA---------
Lancelot
azul
la busqueda del santo grial
No hay comentarios:
Publicar un comentario