Tipos de datos en Python

Maricela Carrera (Haly-en)

2024-04-13

¡Bienvenidos al taller de PyLadies!

Síguenos en nuestras redes sociales :

@PyLadies_Cuerna

@PyLadies-Cuernavaca

@haly-en

@HalyHalymary

@Maricela Carrera

Agenda

• Variables
• Tipos de datos
  • Cadenas
  • Listas
  • Diccionarios
  • Tuplas

• Operadores
  • Aritmeticos, lógicos, comparativos… etc
• Anidación de sentencias condicionales
  • if, elif, else,
  • bucles: For, while, break…
  • continue…

Listxs ¿?

¡Abróchense los cinturones!

Variables

En Python los tipos de nombres para variables deben de ser:

• Válidas
• No válidas

nombre_estudiante = "María"
calificacion_examen = 10
_numero_articulos = 78 
suma_total = 1500
proteínas = ["Arg","Ala","Trp"] #se recomienda que las variables tengan nombres informativos
#mi_variable
#algo
# p

1er_nombre = "María" # Comienza con un número.
precio$ = 23 #Contiene un símbolo no válido ($).
espacio en_medio = "algo" #Contiene un espacio en blanco.
-variable= "hola" #No comienza con una letra o guion bajo.

Palabras Reservadas

[Evitar palabras reservadas:
Python tiene palabras reservadas que tienen un significado especial en el lenguaje. No se pueden usar estas palabras como nombres de variables.

Ejemplos de palabras reservadas incluyen: if, for, while, def, class, True, False,** etc.]{.medium}

Tipos de datos

Tipos de datos Numéricos

• Numéricos
• Ejercicio en colab
• Resultado

a = int(200) # interos 
print("El tipo de dato de la variable tiene un valor:", a, type(a))
b = float(2.3)
print("El tipo de dato de la variable tiene un valor:", b, type(b))
hex(a) #Convierte el número entero a una cadena de caracteres con representación hexadecimal.
#Los números enteros también tienen los operadores aritméticos, de comparación etc... 
a+b
str(a)
a

El tipo de dato de la variable tiene un valor: 200 <class 'int'>
El tipo de dato de la variable tiene un valor: 2.3 <class 'float'>

200

vamos al COLAB

Escriban un código sencillo para calcular el área de un rectángulo

base = 10  # Tipo int (número entero)
altura = 5.2  # Tipo float (número decimal)

area = base * altura
perimetro = 2 * (base + altura)

print(f"Área del rectángulo: {area}")
print(f"Perímetro del rectángulo: {perimetro}")

Área del rectángulo: 52.0
Perímetro del rectángulo: 30.4

En Python, existen diversos tipos de variables que permiten almacenar y manipular información de distintas maneras. Cada tipo de dato posee características y funcionalidades específicas que los hacen adecuados para diferentes propósitos. A continuación, se presentan algunos ejemplos de tipos de variables válidas junto con ejemplos de nombres válidos e inválidos para cada tipo.

Tipos de datos Cadenas

• ¿qué son?
• Ejercicios en Colab
• Ejercicio Resuelto

nombre = "Juan"  # Cadena simple
mensaje = 'Hola, mundo!'  # Cadena simple con comillas simples
frase_larga = """Este es un ejemplo de una cadena de varias líneas
que se puede escribir utilizando tres comillas dobles."""  # Cadena multilínea

edad = 30  # Variable entera
# Para saber qué tipo de dato es
type(nombre)
# Acceso a caracteres individuales
primer_caracter = nombre[0]  # 'J'
ultimo_caracter = nombre[-1]  # 'z'
tercer_caracter = nombre[2]  # 'u'

# Concatenación de cadenas
apellido = "perez"
nombre_completo = nombre + " " + apellido
frase_completa = mensaje + " " + "Estoy aprendiendo Python."

# Replicación de cadenas
repetir_tres_veces = frase_larga * 3

# Longitud de cadena
longitud_nombre = len(nombre)

# Mayúsculas y minúsculas
nombre_mayusculas = nombre.upper()
nombre_minusculas = nombre.lower()

# Búsqueda de subcadenas
esta_en_mensaje = mensaje.find("mundo")  # Devuelve la posición del primer carácter coincidente

# Reemplazo de subcadenas
mensaje_modificado = mensaje.replace("mundo", "universo")

# Formateo de cadenas
datos_formateados = f"Nombre: {nombre}, Edad: {edad}"

frase = "Esta es una frase de ejemplo para mostrar el uso de split."

palabras = frase.split()  # Dividir la frase en palabras

# Define a string variable
nombre = "María Gutierrez"

# Check if the name starts with "María"
if nombre.startswith("María"):
  print("El nombre empieza con 'María'")
else:
  print("El nombre no empieza con 'María'")



# Impresión de resultados
# print(f"Nombre: {nombre}")
# print(f"Mensaje: {mensaje}")
# print(f"Frase larga:\n{frase_larga}")
# print(f"Primer caracter: {primer_caracter}")
# print(f"Tercer caracter: {tercer_caracter}")
# print(f"Nombre completo: {nombre_completo}")
# print(f"Frase completa: {frase_completa}")
# print(f"Repetir tres veces: {repetir_tres_veces}")
# print(f"Longitud del nombre: {longitud_nombre}")
# print(f"Nombre en mayúsculas: {nombre_mayusculas}")
# print(f"Nombre en minúsculas: {nombre_minusculas}")
# print(f"¿'mundo' está en el mensaje?: {esta_en_mensaje}")
# print(f"Mensaje modificado: {mensaje_modificado}")
# print(f"Datos formateados: {datos_formateados}")

Figure 1:

Palabras separadas por comas: Esta, es, una, frase, de, ejemplo, para, mostrar, el, uso, de, split.

Este ejercicio práctico demuestra el uso del método split para dividir cadenas de texto en Python y procesar las palabras individuales de manera eficiente.

Tipos de datos: listas

• Listas
• Ejercicios en Colab
• Métodos en listas

compuestos_organicos = ["etanol", "metano", "ácido propiónico"]  # Lista de compuestos orgánicos
secuencia_adn = ["A", "T", "G", "C", "C", "A", "G", "T"]  # Secuencia de ADN
datos_experimentales = [[1, 2.5, 3.1], [4, 5.2, 6.4], [7, 8.3, 9.6]]  # Conjunto de datos experimentales
compuestos_organicos = ["etanol", "metano", "ácido propiónico"]

# Acceder al primer elemento
primer_compuesto = compuestos_organicos[0]
print(primer_compuesto)  # Output: etanol
#Reemplazar
secuencia_adn[2] = "U"  # Reemplaza G con U en el indice2
print(secuencia_adn)  # salida: ['A', 'T', 'U', 'C', 'C', 'A', 'G', 'T']
# agregar un elemento
secuencia_adn.append("G")  # Agrega G al final de la lista
print(secuencia_adn)  # salida: ['A', 'T', 'U', 'C', 'C', 'A', 'G', 'T', 'G']

# Elimina un elemento
secuencia_adn.remove("C")  # Elimina la primera vez que encuentra C
print(secuencia_adn)  # Salida: ['A', 'T', 'U', 'C', 'A', 'G', 'T', 'G']

longitud_lista = len(compuestos_organicos)
print(f"Longitud de la lista: {longitud_lista}")  # Salida: 3

# Check if the list is empty
if not compuestos_organicos:
  print("La lista está vacía")
else:
  print("La lista no está vacía")
secuencia_adn = ["A", "T", "G", "C", "C", "A", "G", "T"]
#slicing en listas
# genera una sublista dado un  index desde el elemento 1
subsecuencia1 = secuencia_adn[:4]  # Regresa los primeros 4 elementos
print(subsecuencia1)  # Output: ['A', 'T', 'G', 'C']

#  genera una sublista dado un  index y los úlimos elementos
subsecuencia2 = secuencia_adn[3:]  # del index 3 en adelante
print(subsecuencia2)  # Output: ['C', 'C', 'A', 'G', 'T']

# y por intervalos, toma elementos desde el elemento1  con un salto 
subsecuencia3 = secuencia_adn[::2]  
print(subsecuencia3)  # Output: ['A', 'G', 'A', 'G']

etanol
['A', 'T', 'U', 'C', 'C', 'A', 'G', 'T']
['A', 'T', 'U', 'C', 'C', 'A', 'G', 'T', 'G']
['A', 'T', 'U', 'C', 'A', 'G', 'T', 'G']
Longitud de la lista: 3
La lista no está vacía
['A', 'T', 'G', 'C']
['C', 'C', 'A', 'G', 'T']
['A', 'G', 'C', 'G']

imagen de Dmitry kolpanov

Tiempo de una pausa o seguimos?…

Tipos de datos Diccionarios

• Diccionarios
• Ejemplos
• Explorar en colab

El Diccionario Python es una secuencia desordenada de datos en forma de par clave-valor (key:value). Es muy útil para recuperar datos de forma optimizada entre una gran cantidad de datos. Los diccionarios son herramientas poderosas para manejar información compleja de manera eficiente y son ampliamente utilizados en diversas aplicaciones de programación.

• 
  

Important

Dictionary values can be of any data type, including mutable types like lists.

# Diccionario vacío
diccionario_vacio = {}

# Diccionario con pares clave-valor
estudiante = {"nombre": "Juan Pérez", 
                "edad": 25, "carrera":
                  "Ingeniería Informática"}
                  
# Acceder a un valor por clave
valor_nombre = estudiante["nombre"]
print(f"Nombre: {valor_nombre}")  # Output: Nombre: Juan Pérez

# Acceder a un valor usando la notación alternativa (índice)
valor_edad = estudiante["edad"]
print(f"Edad: {valor_edad}")  # Output: Edad: 25

# Modificar un valor existente
estudiante["carrera"] = "Ciencia de la Computación"
print(estudiante["carrera"])  # Output: Ciencia de la Computación

# Agregar un nuevo par clave-valor
estudiante["materia_favorita"] = "Programación"
print(estudiante)  # Output: {'nombre': 'Juan Pérez', 'edad': 25, 'carrera': 'Ciencia de la Computación', 'materia_favorita': 'Programación'}

# Eliminar un par clave-valor
del estudiante["edad"]
print(estudiante)  # Output: {'nombre': 'Juan Pérez', 'carrera': 'Ciencia de la Computación', 'materia_favorita': 'Programación'}

# Recorrer las claves del diccionario
for clave in estudiante:
  print(clave)  # Output: nombre, carrera, materia_favorita

# Recorrer las claves y valores del diccionario (usando `items()`)
for clave, valor in estudiante.items():
  print(f"{clave}: {valor}")  # Output: nombre: Juan Pérez, carrera: Ciencia de la Computación, materia_favorita: Programación

# Comprobar si una clave existe
if "nombre" in estudiante:
  print("La clave 'nombre' está presente")
else:
  print("La clave 'nombre' no está presente")  # Output: La clave 'nombre' está presente
# Comprobar el valor de una clave si existe (usando `get()`)
valor_telefono = estudiante.get("telefono", None)
if valor_telefono:
  print(f"Teléfono: {valor_telefono}")
else:
  print("La clave 'telefono' no está presente o su valor es None")

Nombre: Juan Pérez
Edad: 25
Ciencia de la Computación
{'nombre': 'Juan Pérez', 'edad': 25, 'carrera': 'Ciencia de la Computación', 'materia_favorita': 'Programación'}
{'nombre': 'Juan Pérez', 'carrera': 'Ciencia de la Computación', 'materia_favorita': 'Programación'}
nombre
carrera
materia_favorita
nombre: Juan Pérez
carrera: Ciencia de la Computación
materia_favorita: Programación
La clave 'nombre' está presente
La clave 'telefono' no está presente o su valor es None

# valid dictionary
# integer as a key
#my_dict = {1: "one", 2: "two", 3: "three"}

# valid dictionary
# tuple as a key
#my_dict = {(1, 2): "one two", 3: "three"}

# invalid dictionary
# Error: using a list as a key is not allowed
#my_dict = {1: "Hello", [1, 2]: "Hello Hi"}

# valid dictionary
# string as a key, list as a value
#my_dict = {"USA": ["Chicago", "California", "New York"]}

Tipos de datos

un extra Es posible crear diccionarios a partir de dos listas.

nombres = ["Juan", "María", "Pedro"]
apellidos = ["Pérez", "Gómez", "López"]

# Crear un diccionario utilizando zip() y dict()
diccionario_alumnos = dict(zip(nombres, apellidos))
print(diccionario_alumnos)  # Output: {'Juan': 'Pérez', 'María': 'Gómez', 'Pedro': 'López'}

nombres = ["Juan", "María", "Pedro"]
apellidos = ["Pérez", "Gómez", "López"]

# Crear un diccionario utilizando zip() y dict()
diccionario_alumnos = dict(zip(nombres, apellidos))
print(diccionario_alumnos)  # Output: {'Juan': 'Pérez', 'María': 'Gómez', 'Pedro': 'López'}

{'Juan': 'Pérez', 'María': 'Gómez', 'Pedro': 'López'}
{'Juan': 'Pérez', 'María': 'Gómez', 'Pedro': 'López'}

La función zip() crea un objeto iterable que combina elementos de las dos listas de forma paralela. La estructura dict() convierte el objeto iterable zip() en un diccionario, utilizando las primeras listas como claves y las segundas como valores correspondientes.

El ciclo for recorre la lista nombres y obtiene cada nombre en cada iteración. El índice i del ciclo se utiliza para acceder al elemento correspondiente en la lista apellidos. Se crea una entrada en el diccionario diccionario_alumnos utilizando el nombre actual como clave y el apellido correspondiente como valor.

Tipos de datos Tuplas

• ?
• Creación de tuplas
• Manipular tuplas

Las tuplas en Python son estructuras de datos ordenadas e inmutables que almacenan colecciones de elementos. A diferencia de las listas, las tuplas no se pueden modificar una vez creadas. Son útiles para representar datos que no cambian con el tiempo, como coordenadas, información de contacto o configuraciones.

Important

Inmutabilidad: Garantiza que los datos no se modifiquen accidentalmente.

# Tupla vacía
tupla_vacia = ()

# Tupla con un elemento
tupla_un_elemento = (5,)  # Las comas son opcionales para un solo elemento

# Tupla con varios elementos
tupla_varios = (10, "Hola", True)

tupla_varios = (10, "Hola", True)

# Acceder al primer elemento
primer_elemento = tupla_varios[0]
print(primer_elemento)  # Output: 10

# Acceder al último elemento
ultimo_elemento = tupla_varios[-1]
print(ultimo_elemento)  # Output: True

# Acceder a un elemento por su índice
segundo_elemento = tupla_varios[1]
print(segundo_elemento)  # Output: Hola

tupla_varios = (10, "Hola", True)

# Intento de modificar un elemento
#tupla_varios[0] = 20  # Error: no se puede asignar a una tupla

# Las tuplas son inmutables, no se pueden modificar después de crearse

tupla1 = (1, 2, 3)
tupla2 = (4, 5, 6)

# Concatenación de tuplas
tupla_concatenada = tupla1 + tupla2
print(tupla_concatenada)  # Output: (1, 2, 3, 4, 5, 6)

# Multiplicación de tuplas (crea una nueva tupla con elementos repetidos)
tupla_repetida = tupla1 * 3
print(tupla_repetida)  # Output: (1, 2, 3, 1, 2, 3, 1, 2, 3)

# Verificación de pertenencia
if 3 in tupla1:
  print("El número 3 está en la tupla1")
else:
  print("El número 3 no está en la tupla1")  # Output: El número 3 está en la tupla1
 # Como mencioné antes:
 
coordenadas = (10.5, 23.7)
print(f"Coordenadas: {coordenadas}")  # Output: Coordenadas: (10.5, 23.7)

contacto = ("Juan Pérez", "+52 55 1234 5678", "juan.perez@correo.com")
print(f"Contacto: {contacto}")  # Output: Contacto: ('Juan Pérez', '+52 55 1234 5678', 'juan.perez@correo.com')

configuracion = ("español", True, 20)
print(f"Configuración: {configuracion}")  # Output: Configuración: ('español', True, 20)

10
True
Hola
(1, 2, 3, 4, 5, 6)
(1, 2, 3, 1, 2, 3, 1, 2, 3)
El número 3 está en la tupla1
Coordenadas: (10.5, 23.7)
Contacto: ('Juan Pérez', '+52 55 1234 5678', 'juan.perez@correo.com')
Configuración: ('español', True, 20)

¡Nos vemos de nuevo el 26 de abril!

Pyladies-Cuernavaca