Definiciones de algoritmo
Algoritmo: Conjunto ordenado de operaciones sistemáticas que permite hacer un cálculo y hallar
la solución de un tipo de problema.
Algoritmo: Se denomina algoritmo a un grupo finito de operaciones organizadas de manera lógica
y ordenada que permite solucionar un determinado problema.
Algoritmo: una serie de instrucciones o reglas establecidas que, por medio de una sucesión de
pasos, permiten arribar a un resultado o solución.
Algoritmo: una secuencia de instrucciones que representan un modelo de solución para
determinado tipo de problemas. O bien como un conjunto de instrucciones que realizadas en
orden conducen a obtener la solución de un problema.
¿Cómo se Diseña un Algoritmo?
En programación, un algoritmo establece, de manera genérica e informal, la secuencia de pasos o
acciones que resuelve un determinado problema y, para representarlo, se utiliza,
fundamentalmente, dos tipos de notación: pseudocódigo y diagramas de flujo.
Partes de un Algoritmo
Todo algoritmo debe obedecer a la estructura básica de un sistema, es decir: entrada, proceso y
salida.
Características de los Algoritmos
Las características fundamentales que debe cumplir todo algoritmo son:
Un algoritmo debe ser preciso e indicar el orden de realización de cada paso.
Un algoritmo debe estar definido. Si se sigue un algoritmo dos veces, se debe obtener el mismo
resultado cada vez.
Un algoritmo debe ser finito. el algoritmo se debe terminar en algún momento; o sea, debe tener
un número finito de pasos.
Un algoritmo debe ser legible: El texto que lo describe debe ser claro, tal que permita entenderlo y
leerlo fácilmente.
Comandos básicos para usar en la consola:
Ctrl + L = Limpiar pantalla
CD = Change Directory
… = Carpeta padre
CD… = Cambiar de directorio a la carpeta padre
Alt + 92 =
ls = list
mkdir = Make directory
touch = para crear archivos
ls -la Listar y ver archivos ocultos
pwd Ver en que directorio estoy
cd Cambiar directorio
rm Borrar
mv Mover archivo
rmdir Borrar directorio
ls -t Ordena los archivos por fecha de modificación
ls -x Ordena elementos por nombre y extensión
ls -X Ordenar elementos por extensión y nombre
ls -S Ordena los archivos por tamaño de archivo
cat Muestra el contenido completo de un archivo
head Muestra las primeras líneas de un archivo
tail Muestra las ultimas líneas de un archivo
touch crea archivos
Primero, para iniciar la consola interactiva de Python debemos escribir el comando **py **en
Windows, pero en otros sistemas el comando es python3.
Ahora, podemos comenzar.
En la consola nos permite escribir operaciones matemáticas como 5 + 5 sin escribir nada más, pero
en el editor de código debemos “imprimir” el resultado, de la siguiente manera:
print(5 + 5). Con esto obtendremos el resultado.
Ahora veamos como se realiza cada operación aritmética:
Operadores aritméticos en Python
Suma: 5 + 5
Resta: 5 - 5
Multiplicación: 5 * 5
División (con decimales): 5 / 5
División (sin decimales): 21 // 5
Resto de la división: 21 % 5
Potencia: 2 ** 2
Raíz cuadrada: 9 **(1/2)
Asignación de variables
En Python, creamos las variables asignándoles un valor de la siguiente manera:
<identificador> = <valor>
en este caso el signo = se lee como “asignar”
Reasignación de variables
Podemos en cualquier momento cambiar el valor de nuestra variable volviendo a asignar un valor
al mismo identificador:
<identificador> = <nuevo valor>
Reglas en el uso de identificadores de variable
No pueden empezar con un número.
Deben estar en minúsculas
Para separar las palabras usamos el guion bajo: _
Estas reglas son aplicadas al lenguaje Python, en otros lenguajes puede haber otras reglas.
Tipos de variables en Python
a = 28 → int (entero)
b = 1.5 → float (decimales)
c = “Hello” → str (string o cadena de texto)
d = True → boolean (verdadero o falso)
e = None → NoneType (Sin valor)
f = “5” → str (5 y “5” no son lo mismo. La primera es un entero y la segunda una cadena de texto)
Un objeto es una forma de modelar el mundo en programación. En los lenguajes de programación
se caracterizan por tener métodos y atributos. En Python todo es un objeto.
Podemos encontrar cuatro tipos de datos que vienen definidos por defecto en Python, a estos
tipos de datos los conocemos como primitivos.
Tipos de datos primitivos en Python
Integers: números Enteros
Floats: números de punto flotante (decimales)
Strings: cadena de caracteres (texto)
Boolean: boolenaos (Verdadero o Falso)
Algunos operadores aritméticos pueden funcionar para operar con otros tipos de datos. Por
ejemplo: podemos sumar strings, lo que concatena el texto o multiplicar un entero por un string,
lo que repetirá el _string _las veces que indique el entero.
Tipos de dato adicionales
Datos en texto: str
Datos numéricos: int, float, complex
Datos en secuencia: list, tuple, range
Datos de mapeo: dict
Set Types: set, frozenset
Datos booleanos: bool
Datos binarios: bytes, bytearray, memoryview
¿Cómo saber el tipo de dato que estoy usando?
Usamos el comando type()
Ejemplo:
x=5
print(type(x))
Operadores lógicos
and ( y ): compara dos valores, y si ambos son verdaderos, devuelve True.
or ( ó ): si al comparar dos valores y uno de los dos se cumple, devuelve True. Solo devuelve falso
cuando los dos valores no se cumplen.
not ( no): invierte el valor de una variable, dando el valor contrario al de la variable evaluada.
Operadores de comparación
== ( igual qué ): determina si dos valores son iguales o no.
!= (diferente de): determina si dos valores son distintos o no. Si los valores son diferentes devuelve
True, si son iguales devuelve False.
> (mayor que): compara dos valores, y determina si es mayor que el otro.
< (menor que): compara dos valores y determina si es menor que el otro.
>= (mayor o igual): compara dos valores y determinas si es mayor o igual que el otro.
<= (menor o igual): compara dos valores y determinas si es menor o igual que el otro.
Los condicionales son decisiones que se establecen desacuerdo a los parámetros que indiquemos,
para obtener un tipo de resultado deseado.
Ejemplo: si un número es mayor o igual que otro, los números deberán sumarse, de lo contrario
deberán restarse. Debe cumplirse una condición para saber cuál será el camino a seguir.
A continuación veremos cómo funcionan los condicionales en Python.
if
(Si) se usa para la condición principal.
elif
(Si no) en caso de que la condición principal o anterior no se cumpla, se puede utilizar para agregar
otra condición.
else
(Sino) en caso de que la(s) condición(es) anterior(es) no se cumplan, se ejecuta como alternativa
sin condicional.
En lenguaje natural (español)
‘Si’ introduce una oración en la que se indica una condición real o hipotética que se ha de cumplir
necesariamente para que sea cierto o se produzca lo que se expresa: Si corres, lo alcanzarás.
‘Sino’ es una conjunción adversativa que se escribe en una sola palabra y se usa, principalmente,
para contraponer un concepto a otro: No estudia, sino que trabaja.
‘Si no’** introduce una oración condicional: Si no estudias, no aprobarás.
Las funciones ayudan a optimizar el código. Es decir, utilizar la menor cantidad de líneas dentro del
código y evitar escribir acciones repetitivas.
Esto nos sirve para entregar un código más limpio y con buenas prácticas, que no desperdicia
recursos innecesariamente. En Python, para definir funciones empleamos def.
Gracias a def, podemos “definir” funciones que emplearemos más tarde. Una función, en
programación, es un grupo de instrucciones con un objetivo en particular y que se ejecuta cuando
es “invocada”.
Cuando la definimos, estamos dándole un conjunto de instrucciones o un algoritmo. Al ahorrar
líneas de código con funciones logramos también que la legibilidad de este sea más fácil.
Para trabajar con cadenas de texto en Python, vamos a aplicar una serie de métodos a las variables
que hayamos creado anteriormente.
Método: es una función especial, que existe para un tipo de dato en particular. Por ejemplo, si
queremos que el texto ingresado se transforme en mayúsculas.
Métodos para trabajar con texto en Python
[Link](): El método strip eliminará todos los caracteres vacíos que pueda contener la
variable
[Link](): El método lower convertirá a las letras en minúsculas.
[Link](): El método upper convertirá a las letras en mayúsculas.
[Link](): El método capitalize convertirá a la primera letra de la cadena de caracteres
en mayúscula.
[Link] (‘o’, ‘a’): El método replace remplazará un caracterer por otro. En este caso
remplazará todas las ‘o’ por el caracter ‘a’.
len(variable): Te indica la longitud de la cadena de texto dentro de la variable en ese momento.
Índices:
Se escriben entre corchetes al lado de la variable y son apuntadores numéricos a cada caracter.
Por ejemplo, para el nombre Facundo, cuando utilizamos la variable nombre[1], aparece la letra
‘a’, dado que dicha variable tiene almacenada en ese momento la cadena de caracteres ‘Facundo’
donde la ‘a’ es el segundo caracterer.
Aclaración: se comienza a contar caracteres desde el 0 (que es el primer número en informática).
Siguiendo el ejemplo, la letra ‘F’ de ‘Facundo’ es el carácter número 0. Por ende, nombre[0], nos
devolvería una F.
En Python, los slices, traducidos al español como “rebanadas”, nos permiten dividir los caracteres
de un string de múltiples formas. A continuación, realizaremos un ejemplo cómo utilizarlos:
Cómo usar slices en Python
nombre = "Francisco"
nombre
"Francisco"
nombre[0 : 3)
Arranca desde el primer índice hasta llegar antes del 3° índice.
El resultado sería
"Fra"
nombre[:3]
Va desde el principio hasta antes de llegar del 3° índice. Como no hay ningún parámetro en el
primer lugar, se interpreta que arranca desde el principio. Recordemos que empezamos a contar
desde cero como primer dígito.
El resultado sería
"Fra"
nombre[1:7]
Arranca desde el índice 1 hasta llegar antes del 7.
El resultado sería
"rancis"
nombre[1:7:2]
Arranca desde el índice 1 hasta llegar antes del 7, pero pasos de 2 en 2, ya que eso es lo que nos
indica el 3er parámetro, el cual es 2.
El resultado sería
"rni"
nombre[1::3]
Arranca desde el índice 1 hasta el final del string (al no haber ningún 2° parámetro, significa que va
hasta el final), pero en pasos de 3 en 3.
El resultado sería
"rcc"
nombre[::-1]
Al no haber parámetro en las 2 primeras posiciones, se interpreta que se arranca desde el inicio
hasta el final, pero en pasos de 1 en 1 con la palabra al revés, porque es -1.
El resultado sería
"ocsicnarF"
Un bucle es un ciclo continuo en todos los lenguajes de programación que nos permite iterar sobre
nuestros pasos: magina un contador cíclico (1,2,3,4,5,6…) donde puedes agregar un paso más
sobre tu programa principal.
Ejemplo de bucle en Python
Para este ejemplo, utilizaremos las potencias hasta llegar a un número determinado:
def potencia(numero):
potencia = 1
while (potencia <= 10):
result = numero ** potencia
print('Potencia de {} elevado a la {} es {}'.format(numero, potencia, result))
potencia += 1
def run():
numero = int(input('Escribe el numero al cual quieres averiguarle la potencia: '))
potencia(numero)
if __name__ == "__main__":
run()
Ejemplo de bucle en la vida real
Despertar
Estudiar en Platzi
Comer
Dormir
Cuando repetimos estas acciones en ese orden, durante un tiempo determinado o infinito
estamos hablando de un bucle.
En este ejemplo, aprenderemos a detectar si una palabra es palíndromo en Python. Para el
ejemplo utilizaremos “Luz azul”.
Vamos a definir la función utilizando def:
def esPalindromo(palabra):
palabra = str(palabra).strip().lower()
palabra and print(palabra == palabra[::-1])
esPalindromo(luzazul) # va a imprimir True.
¿Qué acaba de ocurrir?
En la primera línea de la función, convertimos el valor recibido a string, eliminamos los espacios
indeseados aplicando strip y formateamos a minúscula con lower.
¿Por qué? Porque si ejecutamos esPalindromo(True) nuestro programa mostraría un error, ya que
no se pueden ejecutar métodos strip y lower sobre datos de tipo booleano.
En la segunda línea, ejecutando palabra and, lo que le decimos al programa es que si la variable
palabra es Truty, ejecute el código después del and.
Esta es una forma mucho más corta de correr el siguiente código:
if palabra == True:
ejecutar.....
Pero, ¿qué es un valor truty?
En programación, un valor truty es cualquier valor que, sin ser explícitamente un booleano True, la
computadora lo interpreta como un true. Por ejemplo: cualquier número mayor a 0 o cualquier
string que no este vacío.
Luego, dentro del print() no es necesario hacer un if que retorne true o false, al hacer la
comparación.
# if palabra == palabra[::-1]:
# return True
# else:
# return False
palabra == palabra[::-1]
Si la comparación es correcta, va a imprimir True, de lo contrario devolvera False.
Un bucle while permite repetir la ejecución de un grupo de instrucciones mientras se cumpla una
condición (es decir, mientras la condición tenga el valor True).
La sintaxis del bucle while es la siguiente:
while condicion:
cuerpo del bucle
Python evalúa la condición:
Si el resultado es True, se ejecuta el cuerpo del bucle. Una vez ejecutado el cuerpo del bucle, se
repite el proceso (se evalúa de nuevo la condición y, si es cierta, se ejecuta de nuevo el cuerpo del
bucle) una y otra vez mientras la condición sea cierta.
Si el resultado es False, el cuerpo del bucle no se ejecuta y continúa la ejecución del resto del
programa.
Ejemplo de while en Python
def run():
LIMITE = 1000000
contador = 0
potencia_2 = 2**contador
while potencia_2 < LIMITE:
print('2 elevado a ' + str(contador) +
' es igual a: ' + str(potencia_2))
contador = contador + 1
potencia_2 = 2**contador
if __name__ == "__main__":
run()
Consejo: se puede cancelar un ciclo infinito si presionas Ctrl + c.
El ciclo for es un tipo de bucle usado cuando se conozcan la cantidad de veces a iterar.
Un contador es una variable que se encarga de contener valores que irán incrementando o
decrementando cada vez que se ejecuta una acción que lo contenga. El incremento o decremento
es llamado paso del contador y es siempre constante.
Ejemplo: El marcador de un partido de fútbol, cada vez que un equipo anote un gol, aumenta su
marcador en una unidad.
Ejemplo 2: En las carreras de autos, cuando un vehículo pasa por la línea de meta, se incrementa
en una unidad el número de vueltas dadas al circuito, o bien se decrementa el número de vueltas
que faltan por realizar.
Entonces, el incremento es siempre constante, el paso del contador no necesariamente puede ser
una unidad, también puede incrementarse o decrementarse de a dos, tres, cuatro, hasta n. Es
decir, puede ser cualquier número que conserve siempre el mismo valor durante todo el
programa.
Su sintaxis es:
variable = variable + constante(al incrementar)
variable = variable - constante(al decrementar)
o de manera resumida:
variable += constante
variable -= constante
Ejemplo:
gol_local = 0 #si anotan gol: gol_local = gol_local +1
Consejo: Es importante inicializar en cero a la variable cuando aparezca a ambos lados del símbolo
de asignación
Ejemplo del bucle for en Python
def imprimir_numero(inicio, fin):
for inicio in range(fin+1):
print(f'Numero: {inicio}')
def imprimir_numero_while(inicio, fin):
while inicio <= fin:
print(f'Numero: {inicio}')
inicio += 1
def run():
while True:
print('')
print('*********************************************************')
print('*******************N U M E R O S**********************')
print('')
inicio = int(input('Digite el número inicial para la secuencial: '))
print('')
fin = int(input('Digite el número final para la secuencial: '))
print('')
if inicio < fin:
imprimir_numero(inicio,fin)
else:
print(f'El numero inicial {inicio} debe ser ser menor al numero final {fin}.')
if __name__ == "__main__":
run()
Recorrer un string con el ciclo For es tomar la cadena de caracteres y separarlas una a una. De este
modo, quedaría el comando:
def run():
frase = input("Escribe una frase: ")
for caracter in frase:
print([Link]())
if __name__ == "__main__":
run()
Donde usaremos la variable frase para recorrer la frase que se escriba en el input. Cuando se
escriba una frase, se recorrerá cambiando todas las letras a mayúsculas.
Ejemplo del ciclo For para recorrer strings en Python
Ejemplo 1
def run():
## Este ejemplo imprime cada caracter de tu nombre
nombre = input("Escribe tu nombre :")
for letra in nombre:
print(letra)
if __name__ == "__main__":
run()
Ejemplo 2
def run():
frase = input("Escribe una frase: ")
for caracter in frase:
print([Link]())
if __name__ == "__main__":
run()
La instrucción continue en Python devuelve el control al comienzo del ciclo while o ciclo for. Esta
instrucción rechaza todas las declaraciones restantes en la iteración actual del ciclo y mueve el
control de regreso a la parte superior del mismo.
La instrucción break en Python termina el ciclo actual y reanuda la ejecución en la siguiente
instrucción. En otras palabras, break rompe el ciclo entero mientras que continue solo rompe la
vuelta actual.
Ejemplos de interrupción de ciclos con break y continue en Python
Ejemplo1
def run():
for i in range(10000):
print(i)
if i == 5678:
break
if __name__ == '__main__':
run()
Ejemplo 2
def run():
for contador in range(1000):
if contador % 2 != 0:
continue
print(contador)
if __name__ == '__main__':
run()
Ejemplo 3
def run():
texto= input('Escribe un texto: ')
for letra in texto:
if letra == 'o':
break
print(letra)
if __name__ == '__main__':
run()
*La instrucción continue en Python devuelve el control al comienzo del ciclo while o ciclo for. Esta
instrucción rechaza todas las declaraciones restantes en la iteración actual del ciclo y mueve el
control de regreso a la parte superior del mismo.
*La instrucción break en Python termina el ciclo actual y reanuda la ejecución en la siguiente
instrucción. En otras palabras, break rompe el ciclo entero mientras que continue solo rompe la
vuelta actual.
*En este ejemplo, aprenderemos cómo detectar si un número es primo en Python. Esto se conoce
como prueba de primalidad. Un número primo es todo número que puede dividirse únicamente
por sí mismo y por 1. Todos los números primos, excepto el 2, son impares.
En la matemática aplicada, los números primos son utilizados para generar códigos criptográficos
seguros. Esto se logra empleando los números primos de Mersenne (números muy grandes).
*En este ejemplo, aprenderemos cómo detectar si un número es primo en Python. Esto se conoce
como prueba de primalidad. Un número primo es todo número que puede dividirse únicamente
por sí mismo y por 1. Todos los números primos, excepto el 2, son impares.
En la matemática aplicada, los números primos son utilizados para generar códigos criptográficos
seguros. Esto se logra empleando los números primos de Mersenne (números muy grandes).
Las listas nos permiten guardar múltiples valores en una sola variable. Estas listas en Python nos
permiten guardar elementos del mismo tipo o diferentes, por lo que podemos tener strings,
números enteros y decimales juntos en una misma variable. Las listas también son conocidas
como arrays en otros lenguajes programación.
Cómo trabajar con listas en Python
Declarar lista
my_lista = []
my_lista = list()
Unir listas
my_lista = [1]
my_lista2 = [2,3,4]
my_lista3 = my_lista + my_lista2
my_lista3 # [1,2,3,4]
Partir listas como slices
my_lista = [1,2,3]
my_lista[1:] = [2,3]
Extender una lista
my_lista = [1]
my_lista2 = [2,3,4]
my_lista.extend(my_lista2) # [1,2,3,4]
Multiplicar listas
my_lista = ['a']
my_lista2 = my_lista * 5
my_lista2 # ['a','a','a','a','a']
Eliminar el último elemento de la lista
my_lista = [1,2,3,4,5]
my_lista = my_lista.pop()
my_lista # [1,2,3,4]
Ordenar lista
my_lista = [2,1,5,4,3]
my_lista = my_lista.sort()
my_lista # [1,2,3,4,5]
Eliminar un elemento
my_lista = [1,2,3,4,5]
del my_lista[0]
my_lista # [2,3,4,5]
Eliminar si conocemos su valor
my_lista = [1,2,3,4,5]
my_lista.remove(3)
my_lista #[1,2,4,5]
saber qué métodos hay dentro de un elemento
my_lista = [1,2,3,4,5]
dir(my_lista) # ['__add__', '__class__', '__contains__', ...
Modificar un elemento
my_lista = [1,2,3,4,5]
my_lista[0] = 100
my_lista # [100,2,3,4,5]
Añadir un elemento al final
my_lista = [1,2,3,4,5]
my_lista.append(6)
my_lista # [1,2,3,4,5,6]
Organizar una lista
my_lista = [2,5,1,3,4]
my_lista.sort() #[1,2,3,4,5]
Métodos adicionales para listas
.sorted()
También ordena como sort() pero modifica la lista inicial
.clear()
Vacía la lista
.count()
Cuenta las veces que esta un elemento en lista
.index()
Indica la posición donde esta un elemento de la lista
.insert()
Inserta un elemento en una posición dada ej: [Link](posición,item)
.reverse()
Le da la vuelta a una lista
**Suma **(+) Concatena dos o más listas:
a=[1,2]
b=[3,4]
a + b --> [1,2,3,4]
**Multiplicación **(*) Repite la misma lista:
a=[1,2]
a * 2 —> [1,2,1,2]
Añadir elemento al final de la lista:
a=[1]
[Link](2)=[1,2]
Eliminar elemento al final de la lista:
a=[1,2]
b=[Link]()
a=[1]
**Eliminar elemento **dado un indice:
a=[1,2]
b=[Link](1)
a=[2]
Ordenar lista de menor a mayor, esto modifica la lista inicial
a=[3,8,1]
[Link]() —> [1,3,8]
Ordenar lista de menor a mayor, esto NO modifica la lista inicial
a=[3,8,1]
[Link]() —> [1,3,8]
Eliminar elementos de lista Elimina el elemento de la lista dado su indice
a=[1,2,3]
del a[0] —> a[2,3]
Eliminar elementos de lista Elimina el elemento de la lista dado su valor
a=[0, 2, 4, 6, 8]
[Link](6)
a=[0, 2, 4, 8]
**Range **creacion de listas en un rango determinado
a=(list(range(0,10,2))) -->crea un conteo desde 0 hasta 10 en pasos de 2 en 2.
a=[0,2,4,6,8]
Tamaño lista len Devuelve el valor del tamaño de la lista:
a=[0,2,4,6,8]
len(a)=5
append()
Añade un ítem al final de la lista:
lista = [1,2,3,4,5]
[Link](6)
print(lista)
# [1, 2, 3, 4, 5, 6]
clear()
Vacía todos los ítems de una lista:
lista = [1,2,3,4,5]
[Link]()
#[]
extend()
Une una lista a otra:
l1 = [1,2,3]
l2 = [4,5,6]
[Link](l2)
#[1, 2, 3, 4, 5, 6]
count()
Cuenta el número de veces que aparece un ítem:
["Hola", "mundo", "mundo"].count("Hola")
#1
index()
Devuelve el índice en el que aparece un ítem (error si no aparece):
["Hola", "mundo", "mundo"].count("Hola")
#0
insert()
Agrega un ítem a la lista en un índice específico:
l = [1,2,3]
[Link](0,0) #(index , element) first position 0, second last position -1
#last position len
# [ 0, 1 , 2 , 3 ]
pop()
Extrae un ítem de la lista y lo borra:
l = [10,20,30,40,50]
print([Link]())
print(l)
#50
#[10, 20, 30, 40]
Podemos indicarle un índice con el elemento a sacar (0 es el primer ítem):
print([Link](0))
print(l)
#10
#[20, 30, 40]
remove()
Borra el primer ítem de la lista cuyo valor concuerde con el que indicamos:
l = [20,30,30,30,40]
[Link](30)
print(l)
#[20, 30, 30, 40]
reverse()
Le da la vuelta a la lista actual:
[Link]()
print(l)
#[40, 30, 30, 20]
Las cadenas no tienen el método .reverse() pero podemos simularlo haciendo unas conversiones:
lista = list("Hola mundo")
[Link]()
cadena = "".join(lista)
cadena
#'odnum aloH'
sort()
Ordena automáticamente los ítems de una lista por su valor de menor a mayor:
lista = [5,-10,35,0,-65,100]
[Link]()
lista
#[-65, -10, 0, 5, 35, 100]
Podemos utilizar el argumento reverse=True para indicar que la ordene del revés:
[Link](reverse=True)
lista
#[100, 35, 5, 0, -10, -65]
Para los que no lo sabían, los strings (cadenas de caracteres) al igual que las tuplas, también son
considerados por python como inmutables.
La única manera de modificar el contenido de una variable de tipo string, es reasignando
completamente su valor. No es posible realizar cambios individuales en un índice particular.
Los diccionarios en Python son una estructura de datos mutable las cuales almacenan diferentes
tipos de valores sin darle importancia a su orden. Identifican a cada elemento por una clave (Key).
Se escriben entre {}.
Operaciones en diccionarios
.keys():Retorna la clave de nuestro elemento.
.values(): Retorna una lista de elementos (valores del diccionario).
.items(): Devuelve lista de tuplas (primero la clave y luego el valor).
.clear(): Elimina todos los items del diccionario.
.pop(“n”): Elimina el elemento ingresado.
Diccionarios: Son una estructura de datos mutable las cuales almacenan diferentes tipos de
valores sin darle importancia a su orden. Identifican a cada elemento por una clave (Key). Se
escriben entre {}.
Operaciones:
.keys() —> Retorna la clave de nuestro elemento
.values()—> Retorna una lista de elementos (valores del diccionario)
.items() —> Devuelve lista de tuplas (primero la clave y luego el valor)
.clear() —> Elimina todos los items del diccionario
.pop(“n”) —> Elimina el elemento ingresado
Tipos de datos en Python
Inmutables:
Strings (Texto)
Int (Número entero)
Float (Número de coma flotante)
Decimal (Número decimal)
Complex (Complejo)
Bool (Booleano)
Tuple (Tupla)
Frozenset (Conjunto congelado)
Bytes (8 bits)
Range (Rango)
None (Nulo)
Mutables:
List (Listado)
Dict (Diccionario)
Set (Conjunto)
Bytearray (array de bits)
MemoryView (Vista de la memoria)