Aprendiendo Python: SECUENCIAS: Tuplas, listas, diccionarios y conjuntos

En Python, se puede trabajar con conjuntos de datos ordenados o no, éstos son asignados a (), [] o a {} y de esta manera Python entiende de qué se trata.

Las Listas: []

Son conjuntos de datos separados por comas de cualquier naturaleza entre corchetes.

a = 8

b = ['Pedro', 1, 0.25, ['seis; 'numero'], a]

En nuestro caso la variable b es una lista que contiene texto, números, otra lista llamada diccionario y otra variable

a = 8
b = ['Pedro', 1, 0.25, {'seis': 'numero'}, a]
print(f"La lista es : {b}")
print(f"La lista tiene {len(b)} elementos")
c = 1
for x in b:
    print(f"Este es el elemento {c} = {x}")
    c += 1

En este ejemplo, da la salida, que se explica por sí misma:

La lista es : ['Pedro', 1, 0.25, {'seis': 'numero'}, 8]

La lista tiene 5 elementos

Este es el elemento 1 = Pedro

Este es el elemento 2 = 1

Este es el elemento 3 = 0.25

Este es el elemento 4 = {'seis': 'numero'}

Este es el elemento 5 = 8

Se puede consultar cada elemento por separado mediante :

lista[orden] de manera que empezando por el 0, el de número 1 sería el segundo = 1

print(b[1]) ---> 1

Se utilizan métodos para actuar con ellas, como append, count, extend, index, insert, pop, remove, reverse, sohort.

Se puede añadir o quitar elementos a cualquier lista.

Para añadir: append(), extend() e insert()

append(lo que se quiera añadir) y lo añadirá donde quiera, OJO --> no siempre al final.

a = 8
b = ['Pedro', 1, 0.25, {'seis': 'numero'}, a]
print(f"La lista es : {b}")
print(f"La lista tiene {len(b)} elementos")
c = 1
for x in b:
    print(f"Este es el elemento {c} = {x}")
    c += 1
print(b[1])
s = b
print('Voy a añadir la palabra añadido')
s.append('añadido')
print("Esto es la lista anterior")
print(f"pero con el elemento nuevo al final de la misma\n {s}")

La lista es : ['Pedro', 1, 0.25, {'seis': 'numero'}, 8]

La lista tiene 5 elementos

Este es el elemento 1 = Pedro

Este es el elemento 2 = 1

Este es el elemento 3 = 0.25

Este es el elemento 4 = {'seis': 'numero'}

Este es el elemento 5 = 8

Voy a añadir la palabra añadido

Esto es la lista anterior

pero con el elemento nuevo al final de la misma, en este caso si es al final.

['Pedro', 1, 0.25, {'seis': 'numero'}, 8, 'añadido']

El ejemplo anterior con el método extend():

extend extiende la lista con lo que se le pase

s.extend(range(9,12))
print(f"pero con el elemento nuevo al final de la misma\n {s}")

Con esta línea añadida. se añade a la lista tres elementos con el comando range más al final (ahora si es al final) del 9 al 11

Quedando así la lista del ejemplo:

['Pedro', 1, 0.25, {'seis': 'numero'}, 8, 'añadido', 9, 10, 11]

Con insert metemos en la posición que se le pase el elemento que se quiere.

si se quisiera meter en la posición 1 (que ya vimos que había un 1) otro valor:

r = {'animal':'elefante'}
s.insert(1,r)
print(f'Ahora queda la lista así')
print(s)

Ahora queda la lista así

['Pedro', {'animal': 'elefante'}, 1, 0.25, {'seis': 'numero'}, 8, 'añadido', 9, 10, 11]

Hemos añadido a la lista un diccionario en la posición 2ª de la misma.

Método buscar: index()

Mediante el método index podemos buscar en qué índice se encuentra determinado valor, pero nos da el primer valor

versiones = [1,2,3,4,4.2,4.8,5,9]

print(versiones.index(4.2)) ---> da 4 (Que es la 5ª posición)

Recorte o slicing:

Podemos seleccionar un segmento de la lista mediante:

lista[índice primero:indice final]

Teniendo en cuenta que el índice final será el anterior al que pongamos

por ejemplo sobre la lista versiones, queremos quedarnos de la posición 2 (índice 1) a la posición 8 (índice 8)

versiones = [1,2,3,4,4.2,4.8,5,9]
print(f"Esta es la posición 2 de versiones = {versiones[1]}")
print(f"Esta es la posición 8 de versiones = {versiones[7]}")
tt = versiones[1:8]
print(f"Este es el segmento 1:8 = {tt}")

Esta es la posición 2 de versiones = 2
Esta es la posición 8 de versiones = 9
Este es el segmento 1:8 = [2, 3, 4, 4.2, 4.8, 5, 9]

Operación	Resultado
`x in s`	Indica si la variable `x` se encuentra en `s`
`s + t`	Concantena las secuencias `s` y `t`
`s * n`	Concatena `n` copias de `s`
`s[i]`	Elemento `i` de `s`, empezando por `0`
`s[i:j]`	Porción de la secuencia `s` desde `i` hasta `j` (no inclusive)
`s[i:j:k]`	Porción de la secuencia `s` desde `i` hasta `j` (no inclusive), con paso `k`
`len(s)`	Cantidad de elementos de la secuencia `s`
`min(s)`	Mínimo elemento de la secuencia `s`
`max(s)`	Máximo elemento de la secuencia `s`

Cuadro sacado de: https://uniwebsidad.com/libros/algoritmos-python/capitulo-7/listas

Diccionarios: {a:b}

Conjuntos: {a,b...,n}

Son secuencias de pares de elementos separados por :

Se distingue por estar dentro de {}

Los conjuntos son diccionarios sin definiciones. Muy poco usados

Operaciones más habituales en conjuntos

A | B: Unión entre el conjunto A y B (Los elementos del conjunta A y los elementos del conjunto B)
A & B: Intersección entre el conjunto A y B (los elementos que están en ambos conjuntos)
A – B: Diferencia entre el conjunto A y B (los elementos que están en A pero no están en B)
A ^B: Diferencia simétrica entre el conjunto A y B (los elementos que están en A o en B pero no en los dos)

dicc = {'Nombre':'Palabra asociada a una persona que lo identifica', 'Edad': 55, 'País': 'España'}
f = 0
for x in dicc:
print(f"Término {f} .- {x} = {dicc[x]}")
f += 1

Da como resultado:

Término 0 .- Nombre = Palabra asociada a una persona que lo identifica

Término 1 .- Edad = 55

Término 2 .- País = España

Hemos terminado

Métodos aplicables a secuencias:

Ya se ha visto algunos como .insert(), .extend(), .append(), .index(),

También operaciones como slicing[a:b], len()

Para elimiar elementos:

remove(): Elimina el primer elemento que encuentre con el parámetro pasado.

Por ejemplo:

lista = [1,2,3,4,5,6]
print(f"Esta es la lista de partida {lista}")
pregunta =int(input("Qué número quieres quitar: "))
lista.remove(pregunta)
print(f"Esta es la lista de partida {lista}")

Esta es la lista de partida [1, 2, 2, 4, 5, 6]
Qué número quieres quitar: 2
Esta es la lista de partida [1, 2, 4, 5, 6]

Como se ve sólo quita el primer elemento que coincide lo que se le pide.

Si quisiéramos quitar todos los elementos que cumplan una condición habría que hacer un bucle o condicionante, o anidar ambos, donde nos quedáramos sólo con lo que nos interese:

lista = [2, 2, 2, 2, 5, 6]
posicion = []
print(f"Esta es la lista de partida {lista}")
pregunta =int(input("Qué número quieres quitar: "))
p = 0
for x in lista:
    if x != pregunta:
        posicion.append(x)
    print(f"Esto es x = {x} y pregunta {pregunta} en la posición {p}")
    p +=1
print(f"Así queda la lista posicion = {posicion}")
lista = posicion
print(f"Esta es la lista final: {lista}")

Esta es la lista de partida [2, 2, 2, 2, 5, 6]
Qué número quieres quitar: 2
Esto es x = 2 y pregunta 2 en la posición 0
Esto es x = 2 y pregunta 2 en la posición 1
Esto es x = 2 y pregunta 2 en la posición 2
Esto es x = 2 y pregunta 2 en la posición 3
Esto es x = 5 y pregunta 2 en la posición 4
Esto es x = 6 y pregunta 2 en la posición 5
Así queda la lista posicion = [5, 6]
Esta es la lista final [5, 6]

Como se ve, se hace uso de otra lista donde metemos los que nos interesa y luego renombramos las listas.

Como se ve, también, una forma de quitar es quedarse con lo que quieres, no necesariamente eliminar con del o con remove, es cuestión de darle la vuelta a lo que es realmente lo que quieres que quede.

Otra forma de eliminar es con del(lista[indice])

En la lista:

listado = [5, 'a', 9, 'ahora']

podemos eliminar el que queramos mediante su índice:

listado = [5, 'a', 9, 'ahora']
respaldo = []
for d in listado:
    respaldo.append(str(d))
r = 0
for a in respaldo:
    print(f"La posición {r} tiene el elemento {a}")
    r +=1
eliminar = input(f"Escribe el elemento quieres eliminar: ")
print(f"Has escrito {eliminar} que es del tipo {type(eliminar)}")
buscar = respaldo.index(eliminar)
print(f"Está en la posición {buscar} que es del tipo {type(buscar)}")
respaldo.pop(buscar)
listado = respaldo
print(f"El listado de respaldo es: {respaldo}\ny listado queda así {listado}")

La posición 0 tiene el elemento 5
La posición 1 tiene el elemento a
La posición 2 tiene el elemento 9
La posición 3 tiene el elemento ahora
Escribe el elemento quieres eliminar: 9
Has escrito 9 que es del tipo <class 'str'>
Está en la posición 2 que es del tipo <class 'int'>
El listado de respaldo es: ['5', 'a', 'ahora']
y listado queda así ['5', 'a', 'ahora']

En esta ocasión mediante el método pop(índice) hemos podido eliminar el elemento.

El método pop(i) lo que hace es identificar el índice y eliminarlo.

https://www.tutorialpython.com/?s=pop

Las TUPLAS()

Son una forma de secuencias inmutables, como si fueran constantes que no se pueden modificar, ni siquiera añadir o eliminar nada de ellas, pero si se pueden consultar, usando los métodos;

count() para saber cuántos valores hay del parámetro que se le pasa.

index() para saber en qué posición se encuentra determinado parámetro

tupla1 = ('hola, 1, 'feo, 26, {'nombre': 'Pedro', 'edad':56})

print('TUPLAS')
tupla1 = ('hola', 1, 1, "feo", 26, {"Nombre":'Pedro'})
tupla2 = []
tupla3 = []
print(f"Esto es la tupla = {tupla1}")
print("Los elementos de la tupla son:")
e = 0
for x in tupla1:
    print(f"elemento {e} = {x} que es del tipo {type(x)}")
    tupla2.append(str(x))
    e +=1
print(f"Esto es tupla2: {tupla2}")
m = 0
for y in tupla2:
    print(f"elemento {m} = {y} que es del tipo {type(y)}")
    m +=1
print("Ahora la tupla es str en su totalidad")
print("Ahora podemos comparar más fácilmente lo que queramos")
r = input(f"¿Qué elemento quieres buscar: ")
print(f"Aparence {tupla2.count(r)} vez/ces lo que buscabas = {r}")

if tupla2.count(r)>1:
    o = 0
    for t in tupla2:
        #print(f"Este es el índice {o} = {t}")
        if t == r:
            tupla3.append(o)
        o +=1
    print(f"Los índices son {tupla3}")
    for u in tupla3:
        print(f"El índice {u} tiene el valor {tupla1[u]}")

else:
    print(f"Y está en el índice {tupla2.index(r)}")
    print(f"El índice {tupla2.index(r)} tiene el valor {tupla1[tupla2.index(r)]}")
print(f"de la tupla inicial {tupla1}")

TUPLAS
Esto es la tupla = ('hola', 1, 1, 'feo', 26, {'Nombre': 'Pedro'})
Los elementos de la tupla son:
elemento 0 = hola que es del tipo <class 'str'>
elemento 1 = 1 que es del tipo <class 'int'>
elemento 2 = 1 que es del tipo <class 'int'>
elemento 3 = feo que es del tipo <class 'str'>
elemento 4 = 26 que es del tipo <class 'int'>
elemento 5 = {'Nombre': 'Pedro'} que es del tipo <class 'dict'>
Esto es tupla2: ['hola', '1', '1', 'feo', '26', "{'Nombre': 'Pedro'}"]
elemento 0 = hola que es del tipo <class 'str'>
elemento 1 = 1 que es del tipo <class 'str'>
elemento 2 = 1 que es del tipo <class 'str'>
elemento 3 = feo que es del tipo <class 'str'>
elemento 4 = 26 que es del tipo <class 'str'>
elemento 5 = {'Nombre': 'Pedro'} que es del tipo <class 'str'>
Ahora la tupla es str en su totalidad
Ahora podemos comparar más fácilmente lo que queramos
¿Qué elemento quieres buscar: feo
Aparence 1 vez/ces lo que buscabas = feo
Y está en el índice 3
El índice 3 tiene el valor feo
de la tupla inicial ('hola', 1, 1, 'feo', 26, {'Nombre': 'Pedro'})

Aprendiendo Python

SECUENCIAS: Tuplas, listas, diccionarios y conjuntos

Operaciones más habituales en conjuntos

No hay comentarios:

Publicar un comentario