Ejercicio 1: Creación de Bytes
# 1. Crea un objeto de bytes a partir de la cadena literal "Hola"
utilizando la codificación UTF-8.
hola_bytes = b"Hola" # Python asume UTF-8 por defecto si se usa el prefijo 'b'
hola_bytes_explicit = "Hola".encode('utf-8')
print(f"Bytes de 'Hola': {hola_bytes}")
print(f"Bytes de 'Hola' (explícito UTF-8): {hola_bytes_explicit}")
# 2. Crea un objeto de bytes a partir de una lista de enteros que representen
códigos ASCII para las letras "mundo".
mundo_ascii = [109, 117, 110, 100, 111]
mundo_bytes = bytes(mundo_ascii)
print(f"Bytes de 'mundo' (desde ASCII): {mundo_bytes}")
# 3. Crea un objeto de bytes vacío.
vacio_bytes = b''
print(f"Bytes vacío: {vacio_bytes}")
Ejercicio 2: Acceso a Bytes
mensaje_bytes = b'Hola'
numeros_bytes = b'\x01\x02\x03'
datos_bytes = b'Python'
# 1. Dado el objeto de bytes mensaje_bytes = b'Hola', accede al primer byte.
¿Qué tipo de dato obtienes?
primer_byte_mensaje = mensaje_bytes[0]
print(f"Primer byte de b'Hola': {primer_byte_mensaje}")
print(f"Tipo de dato del primer byte: {type(primer_byte_mensaje)}")
# Obtienes un entero, que representa el valor numérico del byte (en este caso,
el código ASCII de 'H', que es 72).
# 2. Dado el objeto de bytes numeros_bytes = b'\x01\x02\x03', accede al segundo
byte. ¿Cómo se representa este byte?
segundo_byte_numeros = numeros_bytes[1]
print(f"Segundo byte de b'\\x01\\x02\\x03': {segundo_byte_numeros}")
# Este byte se representa como el entero 2. La notación \x02 es la
representación hexadecimal del valor 2.
# 3. Itera sobre el objeto de bytes datos_bytes = b'Python', e imprime el valor
entero de cada byte.
print("Valores enteros de los bytes en b'Python':")
for byte in datos_bytes:
print(byte)
# Cada byte en la secuencia se imprime como su valor entero ASCII:
# 80 (P)
# 121 (y)
# 116 (t)
# 104 (h)
# 111 (o)
# 110 (n)
Ejercicio 3: Creación de Bytearrays
# 1. Crea un bytearray a partir de la cadena literal "Ejemplo" utilizando la
codificación UTF-8.
ejemplo_bytearray = bytearray("Ejemplo".encode('utf-8'))
print(f"Bytearray de 'Ejemplo': {ejemplo_bytearray}")
# 2. Crea un bytearray a partir de una lista de enteros que representen códigos
ASCII para las letras "texto".
texto_ascii = [116, 101, 120, 116, 111]
texto_bytearray = bytearray(texto_ascii)
print(f"Bytearray de 'texto' (desde ASCII): {texto_bytearray}")
# 3. Crea un bytearray vacío.
vacio_bytearray = bytearray()
print(f"Bytearray vacío: {vacio_bytearray}")
Ejercicio 4: Manipulación de Bytearrays
# Dado el bytearray buffer = bytearray(b'inicial')
buffer = bytearray(b'inicial')
print(f"Bytearray inicial: {buffer}")
# 1. Cambia el byte en el índice 0 al valor ASCII de 'f' (102).
buffer[0] = 102
print(f"Bytearray después de cambiar el índice 0 a 'f': {buffer}")
# Dado el bytearray datos = bytearray([65, 66, 67])
datos = bytearray([65, 66, 67])
print(f"Bytearray datos inicial: {datos}")
# 2. Agrega al final el valor ASCII de 'D' (68).
datos.append(68)
print(f"Bytearray datos después de append(68): {datos}")
# Dado el bytearray valores = bytearray(b'abcdef')
valores = bytearray(b'abcdef')
print(f"Bytearray valores inicial: {valores}")
# 3. Elimina el byte en el índice 2.
del valores[2]
print(f"Bytearray valores después de eliminar el índice 2: {valores}")
# Dado el bytearray segmento = bytearray(b'parte1')
segmento = bytearray(b'parte1')
print(f"Bytearray segmento inicial: {segmento}")
# 4. Inserta los bytes correspondientes a la cadena "nueva" (codificada en UTF-8)
en el índice 5.
nueva_bytes = b'nueva'
segmento[5:5] = nueva_bytes # El slicing [5:5] indica insertar en esa posición
sin eliminar nada
print(f"Bytearray segmento después de insertar b'nueva' en el índice 5:
{segmento}")
Ejercicio 5: Conversión entre Bytes y
Bytearrays
# Dado el
objeto de bytes constante = b'inmutable'
constante = b'inmutable'
print(f"Objeto de bytes constante: {constante}")
# 1. Convierte el objeto de bytes constante a un bytearray.
mutable_desde_bytes = bytearray(constante)
print(f"Bytearray desde bytes: {mutable_desde_bytes}")
# Dado el bytearray mutable = bytearray([70, 71, 72])
mutable = bytearray([70, 71, 72])
print(f"Bytearray mutable: {mutable}")
# 2. Convierte el bytearray mutable a un objeto de bytes.
bytes_desde_array = bytes(mutable)
print(f"Bytes desde bytearray: {bytes_desde_array}")
Ejercicio 6: Métodos de Bytes y
Bytearrays (Similitudes)
info_bytes =
b'Python es genial'
info_array = bytearray(b'Python es genial')
buscar_bytes = b'banana'
buscar_array = bytearray(b'banana')
reemplazar_bytes = b'viejo texto'
# 1. Dado el objeto de bytes info_bytes = b'Python es genial', utiliza el método
startswith() para verificar si comienza con la secuencia de bytes b'Py'.
comienza_bytes = info_bytes.startswith(b'Py')
print(f"¿b'{info_bytes.decode()}' comienza con b'Py'?: {comienza_bytes}")
# 2. Dado el bytearray info_array = bytearray(b'Python es genial'), utiliza el
método endswith() para verificar si termina con la secuencia de bytes b'ial'.
termina_array = info_array.endswith(b'ial')
print(f"¿bytearray(b'{info_array.decode()}') termina con b'ial'?: {termina_array}")
# 3. Dado el objeto de bytes buscar_bytes = b'banana', utiliza el método find()
para encontrar la primera aparición de b'na'.
indice_find_bytes = buscar_bytes.find(b'na')
print(f"Índice de la primera aparición de b'na' en b'{buscar_bytes.decode()}': {indice_find_bytes}")
# 4. Dado el bytearray buscar_array = bytearray(b'banana'), utiliza el método
count() para contar la ocurrencia del byte con valor 97 (ASCII de 'a').
conteo_array = buscar_array.count(97)
print(f"Número de ocurrencias de byte 97 ('a') en bytearray(b'{buscar_array.decode()}'):
{conteo_array}")
# 5. Dado el objeto de bytes reemplazar_bytes = b'viejo texto', utiliza el
método replace() para reemplazar b'viejo' con b'nuevo'.
reemplazado_bytes = reemplazar_bytes.replace(b'viejo', b'nuevo')
print(f"b'{reemplazar_bytes.decode()}' después de reemplazar b'viejo' con
b'nuevo': {reemplazado_bytes}")