Categoría: Python

En Python se pueden convertir datos de un tipo a otro utilizando funciones integradas o métodos específicos para cada tipo de dato. Estas conversiones son útiles cuando necesitamos operar con diferentes tipos de datos o cuando queremos mostrar información en un formato específico. A continuación detallaremos las conversiones más comunes en Python, y proporcionaremos ejemplos prácticos para cada caso.

Conversión a enteros (int)

Podemos convertir datos a enteros utilizando la función int():

# Convertir un número decimal a entero
decimal = 5.75
entero = int(decimal)  # 5 (se descarta la parte decimal)

# Convertir una cadena numérica a entero
cadena_numero = "123"
entero_desde_cadena = int(cadena_numero)  # 123

Conversión a flotantes (float)

Podemos convertir datos a números flotantes utilizando la función float():

# Convertir un entero a número flotante
entero = 10
flotante_desde_entero = float(entero)  # 10.0

# Convertir una cadena numérica a número flotante
cadena_numero = "3.14"
flotante_desde_cadena = float(cadena_numero)  # 3.14

Conversión a cadenas (str)

Podemos convertir datos a cadenas utilizando la función str():

# Convertir un número entero a cadena
entero = 42
cadena_desde_entero = str(entero)  # "42"

# Convertir un número flotante a cadena
flotante = 3.14
cadena_desde_flotante = str(flotante)  # "3.14"

Conversión a booleanos (bool)

Podemos convertir datos a booleanos utilizando la función bool(). En general, los siguientes valores se evaluarán como False en Python, y todo lo demás se evaluará como True:

• Cualquier número que sea 0 (entero o flotante).
• Cadenas vacías.
• Listas, tuplas, diccionarios o conjuntos vacíos.
• El valor especial None.

# Convertir un número entero a booleano
entero = 10
booleano_desde_entero = bool(entero)  # True

# Convertir un número flotante a booleano
flotante = 0.0
booleano_desde_flotante = bool(flotante)  # False

# Convertir una cadena a booleano
cadena_vacia = ""
booleano_desde_cadena = bool(cadena_vacia)  # False

# Convertir una lista vacía a booleano
lista_vacia = []
booleano_desde_lista = bool(lista_vacia)  # False

# Convertir un valor None a booleano
valor_nulo = None
booleano_desde_nulo = bool(valor_nulo)  # False

Conversión a otras bases o representaciones

En Python también podemos convertir datos a representaciones en formato binario, octal o hexadecimal utilizando las funciones bin(), oct() y hex():

numero = 42

# Convertir a binario
binario = bin(numero)  # '0b101010'

# Convertir a octal
octal = oct(numero)    # '0o52'

# Convertir a hexadecimal
hexadecimal = hex(numero)  # '0x2a'

Es importante tener en cuenta que no todos los tipos de datos se pueden convertir a todas las representaciones. Por ejemplo, no podemos convertir una cadena a binario directamente.

Las cadenas de texto (también conocidas como strings) son secuencias de caracteres encerradas entre comillas simples o comillas dobles, y nos permiten almacenar y manipular texto en los programas. En Python, las cadenas son objetos inmutables, lo que significa que no se pueden modificar una vez creadas, pero podemos crear nuevas cadenas a partir de ellas con diferentes manipulaciones. Vamos a detallar a continuación la sintaxis básica relacionada con las cadenas, e incluiremos ejemplos prácticos.

Creación de cadenas

Podemos crear una cadena asignando un valor entre comillas (simples o dobles) a una variable:

mensaje = "Hola, Python!"
nombre = 'María'
direccion = "Calle San José, 123"

También podemos utilizar triples comillas (simples o dobles) para crear cadenas de varias líneas:

parrafo = """Este es un ejemplo
de una cadena con varias líneas.
Puedes usar triples comillas para ello."""

Operaciones con cadenas

Longitud de una cadena

Podemos obtener la longitud de una cadena utilizando la función len():

mensaje = "Hola, Python!"
longitud = len(mensaje)  # 13 (incluyendo espacios y signos de puntuación)

Concatenación

Podemos unir cadenas utilizando el operador +:

saludo = "Hola, "
nombre = "María"
mensaje_completo = saludo + nombre  # "Hola, María"

Repetición

Podemos repetir una cadena utilizando el operador *:

cadena = "abc"
repetida = cadena * 3  # "abcabcabc"

Indexación y segmentación

Las cadenas son secuencias de caracteres, lo que significa que podemos acceder a caracteres individuales utilizando índices y también podemos segmentar la cadena para obtener subcadenas:

texto = "Python es genial"

primer_caracter = texto[0]  # "P" (el primer carácter tiene índice 0)
ultimo_caracter = texto[-1]  # "l" (el último carácter tiene índice -1)

segmento = texto[7:9]  # "es" (segmento desde el índice 7 hasta el índice 8, no incluye el índice 9)

# También puedes omitir el índice de inicio o de fin para segmentar desde el principio o hasta el final, respectivamente.
inicio_omitiendo = texto[:6]  # "Python"
fin_omitiendo = texto[10:]   # "genial"

Búsqueda en cadenas

Podemos buscar subcadenas dentro de una cadena utilizando los métodos find() e index():

texto = "Python es un lenguaje de programación"
posicion_find = texto.find("lenguaje")  # 13 (posición de la primera ocurrencia)
posicion_index = texto.index("lenguaje")  # 13 (posición de la primera ocurrencia)

# Si la subcadena no se encuentra, find() devuelve -1, mientras que index() genera una excepción ValueError.
posicion_find_no_encontrada = texto.find("Java")  # -1
posicion_index_no_encontrada = texto.index("Java")  # ValueError: substring not found

Reemplazo y formato

Podemos reemplazar subcadenas en una cadena utilizando el método replace():

mensaje = "Hola, NAME!"
nuevo_mensaje = mensaje.replace("NAME", "María")  # "Hola, María!"

También podemos utilizar el método format() para que la cadena incluya los valores de diferentes variables:

nombre = "Juan"
edad = 30
saludo = "Hola, mi nombre es {} y tengo {} años.".format(nombre, edad)
# "Hola, mi nombre es Juan y tengo 30 años."

Caracteres especiales

Python admite varios caracteres especiales que se pueden incluir en las cadenas, como por ejemplo:

• \n: Nueva línea.
• \t: Tabulación.
• \': Comilla simple.
• \": Comilla doble.
• \\: Barra invertida.

mensaje_multilinea = "Hola,\nPython!"
print(mensaje_multilinea)
# Salida:
# Hola,
# Python!

mensaje_tabs = "Hola,\tPython!"
print(mensaje_tabs)
# Salida: Hola,    Python!

mensaje_comillas = "Ella dijo: \"Hola, Python!\""
print(mensaje_comillas)
# Salida: Ella dijo: "Hola, Python!"

Métodos útiles para cadenas

Python incluye varios métodos para trabajar con cadenas. Algunos de los más útiles son:

texto = "Python es un lenguaje de programación"

# Convertir a mayúsculas y minúsculas
texto_mayusculas = texto.upper()  # "PYTHON ES UN LENGUAJE DE PROGRAMACIÓN"
texto_minusculas = texto.lower()  # "python es un lenguaje de programación"

# Capitalizar la primera letra de la cadena
texto_capitalizado = texto.capitalize()  # "Python es un lenguaje de programación"

# Contar ocurrencias de una subcadena
ocurrencias = texto.count("a")  # 3 (número de veces que aparece "a" en la cadena)

# Verificar si una cadena comienza o termina con una subcadena
comienza_con = texto.startswith("Python")  # True
termina_con = texto.endswith("programación")  # True

# Separar una cadena en una lista de subcadenas por un carácter específico
palabras = texto.split(" ")  # ['Python', 'es', 'un', 'lenguaje', 'de', 'programación']

# Eliminar espacios en blanco al principio y al final de la cadena
texto_limpio = "   Hola, Python!   "
texto_sin_espacios = texto_limpio.strip()  # "Hola, Python!"

F-strings

Las f-strings (o cadenas formateadas) nos proporcionan una forma muy legible para construir cadenas en Python (están disponibles a partir de la versión 3.6). Las f-strings nos permiten incorporar expresiones dentro de las cadenas, lo que facilita la inclusión de variables y otros valores en ellas sin tener que utilizar métodos de formato o concatenación. Para usar f-strings, simplemente debemos colocar una «f» o «F» antes del inicio de la cadena y luego añadimos las expresiones utilizando llaves {} dentro de la cadena:

nombre = "Juan"
edad = 30

# Usando f-string para formatear la cadena
mensaje = f"Hola, mi nombre es {nombre} y tengo {edad} años."
print(mensaje)
# Salida: "Hola, mi nombre es Juan y tengo 30 años."

Las expresiones dentro de las llaves serán evaluadas y su valor se incluirá en la cadena final. Se puede incluir cualquier tipo de expresión válida dentro de las llaves, como operaciones matemáticas, llamadas a funciones, y más:

a = 10
b = 5

# Operaciones matemáticas dentro de una f-string
resultado = f"La suma de {a} y {b} es {a + b}, y el producto es {a * b}."
print(resultado)
# Salida: "La suma de 10 y 5 es 15, y el producto es 50."

También se puede aplicar formato a las expresiones dentro de las llaves. Por ejemplo, podemos especificar la cantidad de decimales para un número flotante o el ancho para un número entero:

precio = 9.99

# Formato de número flotante dentro de una f-string
mensaje_precio = f"El precio es: ${precio:.2f}"
print(mensaje_precio)
# Salida: "El precio es: $9.99"

cantidad = 100

# Formato de número entero dentro de una f-string
mensaje_cantidad = f"La cantidad es: {cantidad:05d}"
print(mensaje_cantidad)
# Salida: "La cantidad es: 00100"

En el ejemplo anterior, :.2f indica que queremos mostrar el número flotante con dos decimales, mientras que :05d indica que queremos que el número entero tenga un ancho de 5 dígitos, rellenando con ceros a la izquierda si es necesario.

Los operadores en Python son símbolos especiales que se emplean para realizar diferentes acciones y cálculos utilizando variables y valores. Estas operaciones pueden ser matemáticas, de comparación, lógicas, de asignación, etc. Los operadores son fundamentales en la programación, ya que nos permiten realizar cálculos, tomar decisiones y manipular datos de manera eficiente.

Operadores Aritméticos

Los operadores aritméticos se utilizan para realizar operaciones matemáticas en números. Aquí están los principales operadores aritméticos en Python:

• Suma (+): Suma dos valores.
• Resta (-): Resta el segundo valor del primero.
• Multiplicación (*): Multiplica dos valores.
• División (/): Divide el primer valor por el segundo. Siempre devuelve un flotante.
• División entera (//): Divide el primer valor por el segundo y redondea el resultado hacia abajo al entero más cercano.
• Módulo (%): Devuelve el resto de la división entera entre el primer valor y el segundo.
• Potencia (**): Eleva el primer valor a la potencia del segundo.

a = 10
b = 3

suma = a + b          # 13
resta = a - b         # 7
producto = a * b      # 30
division = a / b      # 3.3333333333333335
division_entera = a // b  # 3
resto = a % b         # 1
potencia = a ** b     # 1000

Operadores de Comparación

Los operadores de comparación se utilizan para comparar dos valores y devuelven un valor booleano (True o False). Aquí están los principales operadores de comparación en Python:

• Igual que (==): Comprueba si los valores son iguales.
• Diferente que (!=): Comprueba si los valores son diferentes.
• Mayor que (>): Comprueba si el primer valor es mayor que el segundo.
• Menor que (<): Comprueba si el primer valor es menor que el segundo.
• Mayor o igual que (>=): Comprueba si el primer valor es mayor o igual que el segundo.
• Menor o igual que (<=): Comprueba si el primer valor es menor o igual que el segundo.

x = 10
y = 5

igual_que = x == y               # False
diferente_que = x != y           # True
mayor_que = x > y                # True
menor_que = x < y                # False
mayor_o_igual_que = x >= y       # True
menor_o_igual_que = x <= y       # False

Operadores Lógicos

Los operadores lógicos se utilizan para combinar expresiones booleanas y devuelven un valor booleano. Aquí están los principales operadores lógicos en Python:

• and (y): Devuelve True si ambas expresiones son verdaderas.
• or (o): Devuelve True si al menos una de las expresiones es verdadera.
• not (no): Devuelve el valor opuesto de la expresión.

a = True
b = False

resultado_and = a and b         # False
resultado_or = a or b           # True
resultado_not_a = not a         # False
resultado_not_b = not b         # True

Operadores de Pertenencia

Los operadores de pertenencia se utilizan para comprobar si un valor está presente en una secuencia, como una lista, tupla o cadena.

• in: Devuelve True si el valor está presente en la secuencia.
• not in: Devuelve True si el valor no está presente en la secuencia.

mi_lista = [1, 2, 3, 4, 5]

esta_en_lista = 3 in mi_lista         # True
no_esta_en_lista = 6 not in mi_lista  # True

mi_cadena = "Hola, Python!"

esta_en_cadena = "Python" in mi_cadena          # True
no_esta_en_cadena = "Java" not in mi_cadena     # True

Operadores de Identidad

Los operadores de identidad se utilizan para comparar si dos variables se refieren al mismo objeto en memoria.

• is: Devuelve True si ambas variables apuntan al mismo objeto.
• is not: Devuelve True si ambas variables no apuntan al mismo objeto.

a = [1, 2, 3]
b = a  # b apunta a la misma lista en memoria que a

es_mismo_objeto = a is b         # True

c = [1, 2, 3]

es_distinto_objeto = a is not c  # True

Operadores de Asignación

Los operadores de asignación se utilizan para asignar valores a variables.

• = : Asignación básica.
• += : Asignación con suma.
• -= : Asignación con resta.
• *= : Asignación con multiplicación.
• /= : Asignación con división.

a = 10

a = 5   # Ahora a tiene el valor de 5
a += 2  # Ahora a tiene el valor de 7
a -= 3  # Ahora a tiene el valor de 4
a *= 2  # Ahora a tiene el valor de 8
a /= 4  # Ahora a tiene el valor de 2.0

Operador Ternario

El operador ternario nos permite escribir una expresión condicional de una forma muy concisa:

edad = 18

es_mayor_edad = True if edad >= 18 else False

En este caso, es_mayor_edad será True si la edad es mayor o igual a 18, y False en caso contrario.

Las variables en Python son etiquetas o nombres que se utilizan para almacenar datos en la memoria del ordenador. Son fundamentales en la programación, ya que nos permiten guardar y manipular información de manera dinámica. A continuación explicaremos cómo declarar variables, los tipos de datos que pueden almacenar y proporcionaremos diversos ejemplos.

Declaración de variables

En Python no necesitas especificar el tipo de datos al declarar una variable, ya que es un lenguaje de tipado dinámico. Simplemente asignas un valor a un nombre de variable y Python determinará automáticamente el tipo de datos.

Para declarar una variable, se utiliza el símbolo = y luego se asigna el valor deseado:

# Declaración de variables
edad = 30
nombre = "Juan"
promedio = 9.5
es_estudiante = True

Tipos de datos básicos en Python

Números

• int: Números enteros (por ejemplo, 10, -5, 0).
• float: Números decimales (por ejemplo, 3.14, -2.5).

# Números
edad = 25
altura = 1.75

Texto

• str: Cadenas de caracteres (por ejemplo, «Hola», ‘Python’).

# Texto
nombre = "María"
mensaje = '¡Hola, Python!'

Booleanos

• bool: Puede ser True o False.

# Booleanos
es_estudiante = True
aprobo_examen = False

Operaciones con variables

Las variables se pueden utilizar en operaciones matemáticas y en la manipulación de datos:

# Operaciones con variables numéricas
a = 10
b = 5
suma = a + b
resta = a - b
producto = a * b
division = a / b
modulo = a % b
potencia = a ** b

# Operaciones con variables de texto (concatenación)
nombre = "Ana"
apellido = "Gómez"
nombre_completo = nombre + " " + apellido

# Operaciones con variables booleanas
es_dia_soleado = True
es_dia_frio = False
dia_ideal = es_dia_soleado and not es_dia_frio

Cambio del valor de una variable

Puedes cambiar el valor de una variable simplemente asignándole un nuevo valor:

edad = 30
print(edad)  # Salida: 30

edad = 40
print(edad)  # Salida: 40

Convenciones para nombrar variables

• Los nombres de las variables deben ser descriptivos y estar en minúsculas.
• Si un nombre de variable tiene varias palabras, se recomienda usar guiones bajos entre las palabras (snake_case).
• Evita usar nombres reservados por Python, como if, else, for, while, etc.

Ejemplos:

# Ejemplo de nombres de variables apropiados
nombre_completo = "Juan Pérez"
numero_telefono = "1234567890"
total_puntos = 100

# Evitar nombres de variables no descriptivos
a = "Hola"
b = 50
x = True