Tipos de Datos Fundamentales en Python

  1. Números

Python maneja diferentes tipos de números, principalmente enteros y flotantes. Los enteros pueden variar en tamaño dependiendo de la arquitectura del sistema (32 o 64 bits), con rangos definidos.

Representación de Enteros

En sistemas de 32 bits, los enteros abarcan el rango de -231 a 231-1. En sistemas de 64 bits, este rango se expande a -263 a 263-1.

Métodos Comunes de Enteros

Los objetos enteros en Python disponen de varios métodos para operaciones específicas:

  • bit_length(): Devuelve el número mínimo de bits necesarios para representar el entero en binario.
  • conjugate(): Retorna el propio entero (los enteros no tienen parte imaginaria).
  • __abs__(): Equivalente a abs(x), devuelve el valor absoluto.
  • __add__(y): Equivalente a x + y.
  • __and__(y): Equivalente a x & y (operación AND a nivel de bits).
  • __cmp__(y): Compara dos números.
  • __coerce__(y): Fuerza la conversión a una tupla.
  • __divmod__(y): Equivalente a divmod(x, y), devuelve el cociente y el residuo.
  • __div__(y): Equivalente a x / y.
  • __float__(): Convierte el entero a un número de punto flotante.
  • __floordiv__(y): Equivalente a x // y (división entera).
  • __format__(*args, **kwargs): Para formateo de cadenas.
  • __getattribute__(name): Accede a atributos.
  • __getnewargs__(*args, **kwargs): Utilizado internamente en la creación de objetos.
  • __hash__(): Devuelve el valor hash del objeto, usado en estructuras de datos como diccionarios.
  • __hex__(): Devuelve la representación hexadecimal del entero.
  • __index__(): Usado para operaciones de slicing.
  • __int__(): Convierte el valor a entero.
  • __invert__(): Equivalente a ~x (inversión a nivel de bits).
  • __long__(): Convierte el valor a un entero largo (en versiones antiguas de Python).
  • __lshift__(y): Equivalente a x << y (desplazamiento a la izquierda).
  • __mod__(y): Equivalente a x % y (módulo).
  • __mul__(y): Equivalente a x * y.
  • __neg__(): Equivalente a -x (negación).
  • __new__(S, *more): Método estático para la creación de instancias.
  • __nonzero__(): Equivalente a x != 0.
  • __oct__(): Devuelve la representación octal del entero.
  • __or__(y): Equivalente a x | y (operación OR a nivel de bits).
  • __pos__(): Equivalente a +x.
  • __pow__(y, z=None): Equivalente a pow(x, y[, z]) (potencia).
  • __radd__(y), __rand__(y), etc.: Métodos para operaciones inversas (ej., y + x).
  • __repr__(): Devuelve la representación "oficial" del objeto.
  • __str__(): Devuelve la representación "amigable" del objeto.
  • __sub__(y): Equivalente a x - y.
  • __truediv__(y): Equivalente a x / y (división real).
  • __trunc__(): Devuelve la parte entera truncada.
  • __xor__(y): Equivalente a x ^ y (operación XOR a nivel de bits).

Los atributos denominator, imag, numerator y real están asociados con números racionales o complejos, pero para los enteros puros, estos atributos no tienen un significado directo o son triviales (como el denominador y numerador siendo 1 y el número mismo, respectivamente).

  1. Booleanos

Los valores booleanos representan la verdad lógica. Solo existen dos valores:

  • True (Verdadero)
  • False (Falso)

Estos valores son fundamentales para la toma de decisiones en el código, a menudo resultantes de comparaciones u operaciones lógicas.

Ejemplo de Uso

Los booleanos se utilizan comúnmente en declaraciones condicionales:


valor1 = 10
valor2 = 20
print(valor1 > valor2)  # Salida: False
print(valor1 < valor2)  # Salida: True

# Evaluación de expresiones lógicas complejas
# El orden de precedencia es: paréntesis, NOT, AND, OR
expresion_compleja = (valor1 == 10 and valor2 == 20) or (valor1 > 5 and False)
print(expresion_compleja) # Salida: True
  1. Cadenas (Strings)

Las cadenas de texto son secuencias inmutables de caracteres. Se definen utilizando comillas simples ('...') o dobles ("...").

Operaciones Comunes con Cadenas

  • Eliminar espacios en blanco (strip(), lstrip(), rstrip()).
  • Dividir cadenas en subcadenas (split(), rsplit(), partition(), rpartition(), splitlines()).
  • Obtener la longitud (len()).
  • Acceder a caracteres individuales mediante índice (cadena[indice]).
  • Extraer subcadenas mediante slicing (cadena[inicio:fin:paso]).
  • Reemplazar subcadenas (replace()).
  • Verificar si una cadena empieza o termina con un prefijo/sufijo (startswith(), endswith()).
  • Contar ocurrencias de subcadenas (count()).
  • Convertir a mayúsculas o minúsculas (upper(), lower()).
  • Capitalizar o convertir a formato título (capitalize(), title()).
  • Unir elementos de un iterable en una cadena (join()).
  • Formatear cadenas (format()).

Métodos Detallados de Cadenas

Python proporciona una rica API para manipulación de cadenas:

  • capitalize(): Pone en mayúscula el primer carácter y el resto en minúscula.
  • center(width, fillchar=None): Centra la cadena en un ancho especificado, rellenando con fillchar.
  • count(sub, start=None, end=None): Cuenta ocurrencias de sub.
  • decode(encoding=None, errors=None): Decodifica la cadena (usualmente de bytes a Unicode).
  • encode(encoding=None, errors=None): Codifica la cadena (usualmente de Unicode a bytes).
  • endswith(suffix, start=None, end=None): Verifica si la cadena termina con suffix.
  • expandtabs(tabsize=None): Expande caracteres de tabulación a espacios.
  • find(sub, start=None, end=None): Encuentra la subcadena devolviendo el índice más bajo o -1 si no se encuentra.
  • format(*args, **kwargs): Formatea la cadena usando argumentos posicionales y nominales.
  • index(sub, start=None, end=None): Similar a find, pero lanza un error si no se encuentra.
  • isalnum(): Verifica si todos los caracteres son alfanuméricos.
  • isalpha(): Verifica si todos los caracteres son alfabéticos.
  • isdigit(): Verifica si todos los caracteres son dígitos.
  • islower(): Verifica si todos los caracteres en mayúscula están en minúscula.
  • isspace(): Verifica si todos los caracteres son espacios en blanco.
  • istitle(): Verifica si la cadena tiene formato de título.
  • isupper(): Verifica si todos los caracteres en minúscula están en mayúscula.
  • join(iterable): Concatena elementos de un iterable usando la cadena como separador.
  • ljust(width, fillchar=None): Justifica a la izquierda, rellenando a la derecha.
  • lower(): Convierte la cadena a minúsculas.
  • lstrip(chars=None): Elimina caracteres de espacio en blanco (o especificados) del inicio.
  • partition(sep): Divide la cadena en tres partes alrededor de la primera ocurrencia del separador.
  • replace(old, new, count=None): Reemplaza old por new, opcionalmente un número limitado de veces.
  • rfind(sub, start=None, end=None): Similar a find, pero buscando desde el final.
  • rindex(sub, start=None, end=None): Similar a index, pero buscando desde el final.
  • rjust(width, fillchar=None): Justifica a la derecha, rellenando a la izquierda.
  • rpartition(sep): Divide la cadena en tres partes alrededor de la última ocurrencia del separador.
  • rsplit(sep=None, maxsplit=None): Divide la cadena desde la derecha.
  • rstrip(chars=None): Elimina caracteres de espacio en blanco (o especificados) del final.
  • split(sep=None, maxsplit=None): Divide la cadena usando sep como delimitador.
  • splitlines(keepends=False): Divide la cadena en líneas.
  • startswith(prefix, start=None, end=None): Verifica si la cadena comienza con prefix.
  • strip(chars=None): Elimina caracteres de espacio en blanco (o especificados) de ambos extremos.
  • swapcase(): Intercambia mayúsculas y minúsculas.
  • title(): Convierte la cadena a formato de título.
  • translate(table, deletechars=None): Aplica una tabla de traducción y/o elimina caracteres.
  • upper(): Convierte la cadena a mayúsculas.
  • zfill(width): Rellena la cadena con ceros a la izquierda hasta alcanzar un ancho especificado.

Los métodos __add__, __contains__, __eq__, __format__, __getattribute__, __getitem__, __getslice__, __ge__, __gt__, __hash__, __init__, __len__, __le__, __lt__, __mul__, __new__, __ne__, __repr__, __rmod__, __rmul__, __sizeof__, __str__ implementan la funcionalidad de los operadores y funciones incorporadas para las cadenas.

  1. Listas

Las listas son colecciones ordenadas y mutables de elementos. Pueden contener elementos de diferentes tipos.

Creación de Listas

Se crean encerrando elementos entre corchetes [] o usando el constructor list():


nombres = ['Alice', 'Bob', 'Charlie']
nombres_desde_iterable = list(('Alice', 'Bob', 'Charlie'))

Operaciones Básicas con Listas

  • Acceso por índice (lista[indice]).
  • Slicing (lista[inicio:fin:paso]).
  • Añadir elementos (append()).
  • Insertar elementos en una posición específica (insert()).
  • Eliminar elementos (remove(), pop(), del lista[indice]).
  • Obtener la longitud (len()).
  • Iterar sobre la lista (bucles for).
  • Verificar si un elemento está contenido en la lista (operador in).
  • Extender la lista con elementos de otro iterable (extend()).
  • Contar ocurrencias de un valor (count()).
  • Obtener el índice de la primera ocurrencia de un valor (index()).
  • Invertir la lista in-place (reverse()).
  • Ordenar la lista in-place (sort()).

Métodos de Listas

  • append(p_object): Añade p_object al final.
  • count(value): Devuelve el número de veces que value aparece.
  • extend(iterable): Añade todos los elementos de iterable al final.
  • index(value, start=None, stop=None): Devuelve el índice de la primera ocurrencia de value. Lanza ValueError si no se encuentra.
  • insert(index, p_object): Inserta p_object antes del índice especificado.
  • pop(index=None): Elimina y devuelve el elemento en el índice dado (por defecto, el último). Lanza IndexError si la lista está vacía o el índice es inválido.
  • remove(value): Elimina la primera ocurrencia de value. Lanza ValueError si no se encuentra.
  • reverse(): Invierte los elemantos de la lista in-place.
  • sort(cmp=None, key=None, reverse=False): Ordena los elementos de la lista in-place.

Los métodos __add__, __contains__, __delitem__, __delslice__, __eq__, __getattribute__, __getitem__, __getslice__, __ge__, __gt__, __iadd__, __imul__, __init__, __iter__, __len__, __le__, __lt__, __mul__, __new__, __ne__, __repr__, __reversed__, __rmul__, __setitem__, __setslice__, __sizeof__ son fundamentales para la operación de listas como objetos mutables y secuencias.

  1. Tuplas

Las tuplas son colecciones ordenadas e inmutables de elementos. Una vez creadas, no se pueden modificar sus elementos.

Creación de Tuplas

Se crean encerrando elementos entre paréntesis () o usando el constructor tuple():


edades = (11, 22, 33, 44, 55)
edades_desde_iterable = tuple([11, 22, 33, 44, 55])

Operaciones Básicas con Tuplas

  • Acceso por índice (tupla[indice]).
  • Slicing (tupla[inicio:fin:paso]).
  • Iterar sobre la tupla.
  • Obtener la longitud (len()).
  • Verificar si un elemento está contenido en la tupla (operador in).
  • Contar ocurrencias de un valor (count()).
  • Obtener el índice de la primera ocurrencia de un valor (index()).

Métodos de Tuplas

Las tuplas tienen menos métodos que las listas debido a su inmutabilidad:

  • count(value): Devuelve el número de veces que value aparece.
  • index(value, start=None, stop=None): Devuelve el índice de la primera ocurrencia de value. Lanza ValueError si no se encuentra.

Los métodos __add__, __contains__, __eq__, __getattribute__, __getitem__, __getnewargs__, __getslice__, __ge__, __gt__, __hash__, __init__, __iter__, __len__, __le__, __lt__, __mul__, __new__, __ne__, __repr__, __rmul__, __sizeof__ definen el comportamiento de las tuplas como secuencias inmutables.

  1. Diccionarios

Los diccionarios son colecciones no ordenadas (en versiones anteriores a Python 3.7) o ordenadas (a partir de Python 3.7) de pares clave-valor. Las claves deben ser únicas e inmutables.

Creación de Diccionarios

Se crean usando llaves {} con pares clave:valor, o usando el constructor dict():


persona = {"nombre": "Sr. Wu", "edad": 18}
persona_desde_dict = dict({"nombre": "Sr. Wu", "edad": 18})
persona_desde_args = dict(nombre="Sr. Wu", edad=18)

Operaciones Comunes con Diccionarios

  • Acceso a valores por clave (diccionario[clave]).
  • Añadir o actualizar elementos (diccionario[clave] = valor).
  • Eliminar elementos (del diccionario[clave], pop(), popitem()).
  • Obtener el valor asociado a una clave, con un valor por defecto si la clave no existe (get(clave, default)).
  • Verificar si una clave existe (operador in, has_key() - obsoleto).
  • Obtener listas de claves (keys()), valores (values()) o pares (clave, valor) (items()).
  • Iterar sobre claves, valores o pares.
  • Obtener la longitud (número de pares clave-valor) (len()).
  • Actualizar un diccionario con otro (update()).
  • Limpiar el diccionario (clear()).
  • Crear copias (copy() - copia superficial).

Métodos de Diccionarios

  • clear(): Elimina todos los elementos del diccionario.
  • copy(): Devuelve una copia superficial del diccionario.
  • fromkeys(S, v=None): Crea un nuevo diccionario con claves de S y valores iguales a v (por defecto None).
  • get(k, d=None): Devuelve el valor para la clave k si existe, de lo contrario devuelve d (por defecto None).
  • has_key(k): (Obsoleto en Python 3) Verifica si la clave k existe. Usar k in dict.
  • items(): Devuelve una lista de tuplas (clave, valor).
  • iteritems(): Devuelve un iterador sobre los pares (clave, valor).
  • iterkeys(): Devuelve un iterador sobre las claves.
  • itervalues(): Devuelve un iterador sobre los valores.
  • keys(): Devuelve una lista de las claves.
  • pop(k, d=None): Elimina la clave k y devuelve su valor. Si k no se encuentra, devuelve d o lanza KeyError.
  • popitem(): Elimina y devuelve un par (clave, valor) arbitrario (o el último insertado en Python 3.7+). Lanza KeyError si el diccionario está vacío.
  • setdefault(k, d=None): Si k está en el diccionario, devuelve su valor. Si no, inserta k con valor d y lo devuelve.
  • update(E=None, **F): Actualiza el diccionario con pares clave-valer de E (otro diccionario o iterable) y/o argumentos nominales F.
  • values(): Devuelve una lista de los valores.
  • viewitems(), viewkeys(), viewvalues(): (En Python 2) Devuelven vistas sobre los elementos, claves y valores respectivamente. En Python 3, .keys(), .values(), .items() devuelven objetos de vista directamente.

Los métodos __cmp__, __contains__, __delitem__, __eq__, __getattribute__, __getitem__, __ge__, __gt__, __init__, __iter__, __len__, __le__, __lt__, __new__, __ne__, __repr__, __setitem__, __sizeof__ son cruciales para el funcionamiento de los diccionarios como mapeos mutables y contenedores.

Etiquetas: Python tipos de datos enteros booleanos cadenas

Publicado el 7-26 20:40

Etiquetas populares

©2026 Friki Work