1. Obtener la longitud en bits con bit_length:

valor = 10
print(valor.bit_length())
Resultado: 4

2. Capitalizar la primera letra con capitalize:

cadena = "ejemplo"
resultado = cadena.capitalize()  # Las cadenas son inmutables; cualquier modificación crea un nuevo espacio.
print(resultado)
Resultado: Ejemplo

3. Capitalizar cada palabra con title:

texto = "hola mundo"
texto_transformado = texto.title()
print(texto_transformado)
Resultado: Hola Mundo

4. Buscar índice con index (lanza error si no encuentra):

secuencia = "python genial"
indice = secuencia.index("g")
print(indice)
Resultado: 7

5. Buscar índice con find (retorna -1 si no encuentra):

cadena_prueba = "programacion"
posicion = cadena_prueba.find("z")
print(posicion)
Resultado: -1

6. Unir elementos con join:

coleccion = "abcdef"
separador = "-"
unido = separador.join(coleccion)
print(unido)
Resultado: a-b-c-d-e-f

7. Centrar texto con center y rellenar:

frase = "central"
frase_centrada = frase.center(15, "*")
print(frase_centrada)
Resultado: ****central****

8. Formatear por posición con format:

plantilla = "hola {} mundo"
formateado = plantilla.format("desde Python")
print(formateado)
Resultado: hola desde Python mundo

9. Formatear por índice con format:

estructura = "datos: {0}, {1}, {2}"
salida = estructura.format("primero", "segundo", "tercero")
print(salida)
Resultado: datos: primero, segundo, tercero

10. Formatear por clave con format:

modelo = "nombre: {nom}, edad: {ed}"
texto_final = modelo.format(ed=30, nom="Carlos")
print(texto_final)
Resultado: nombre: Carlos, edad: 30

11. Intercambiar mayúsculas y minúsculas con swapcase:

ejemplo_texto = "PyThOn"
invertido = ejemplo_texto.swapcase()
print(invertido)
Resultado: pYtHoN

12. Invertir una lista:

lista_original = [10, 20, 30, 40]
# Método con slicing (nueva lista)
invertida1 = lista_original[::-1]
# Método in-place
lista_original.reverse()
print(invertida1)
print(lista_original)
Resultado: [40, 30, 20, 10]
[40, 30, 20, 10]

13. Ordenar una lista (ascendente por defecto):

numeros = [5, 2, 8, 1, 9]
numeros.sort(reverse=True)  # Descendente
print(numeros)
Resultado: [9, 8, 5, 2, 1]

14. Consultar direcciones de memoria con id:

lista_a = [1, 2, [3]]
lista_b = lista_a * 2  # Elementos compartidos en multiplicación
print(id(lista_a[0]), id(lista_b[2]))
Resultado: Direcciones iguales para elementos inmutables

15. Trampa en listas/tuplas al multiplicar:

ejemplo_lista = [1, 2, []]
ejemplo_multi = ejemplo_lista * 3
ejemplo_multi[-1].append(5)
print(ejemplo_multi)
Resultado: [1, 2, [5], 1, 2, [5], 1, 2, [5]]

16. Inicializar listas (forma corta vs. explícita):

lista1 = []  # Forma corta
lista2 = list()  # Forma explícita
print(lista1)
print(lista2)
Resultado: []
[]

17. Definir tuplas correctamente:

tupla1 = (10)  # Esto es un entero, no una tupla
tupla2 = (10,)  # Tupla con un solo elemento
tupla3 = ()  # Tupla vacía
print(type(tupla1))
print(type(tupla2))
print(type(tupla3))
Resultado: <class 'int'>
<class 'tuple'>
<class 'tuple'>

18. Crear claves en diccionario con fromkeys:

diccionario = {}
diccionario = diccionario.fromkeys(["x", "y", "z"], 100)
print(diccionario)
Resultado: {'x': 100, 'y': 100, 'z': 100}

19. Convertir lista de tuplas a diccionario:

pares = [(10, "a"), (20, "b"), (30, "c")]
diccionario_nuevo = dict(pares)
print(diccionario_nuevo)
Resultado: {10: 'a', 20: 'b', 30: 'c'}

20. Resumen de tipos de datos:

• Enteros (int): Ordenados (no soportan índice), inmutables, no iterables.
• Booleanos (bool): Inmutibles, no iterables.
• Cadenas (str): Ordenadas (soportan índice), inmutables, iterables.
• Listas (list): Ordenadas (soportan índice), mutables, iterables.
• Tuplas (tuple): Ordenadas (soportan índice), inmutibles, iterables.
• Diccionarios (dict): Desordenados (no soportan índice), mutables, iterables.
• Conjuntos (set): Desordenados (no soportan índice), mutables, iterables.

21. Trampas al eliminar en bucles:

Método directo (puede fallar):

elementos = [10, 20, 30, 40, 50]
for item in elementos:
    elementos.clear()
print(elementos)
Resultado: []

Usando remove con bucle for (error común):

datos = [10, 20, 30, 40, 50]
for valor in datos:
    if valor % 20 == 0:
        datos.remove(valor)
print(datos)
Resultado: [10, 30, 50]  # Algunos elementos pueden omitirse

Eliminar con range (seguro):

lista_eliminar = [10, 20, 30, 40, 50]
for i in range(len(lista_eliminar)):
    lista_eliminar.pop(0)
print(lista_eliminar)
Resultado: []

Eliminar con copia (seguro):

original = [10, 20, 30, 40, 50]
copia = original.copy()
for item in copia:
    original.remove(item)
print(original)
Resultado: []

Eilminar de diccionarios:

dic_datos = {"clave1": 100, "clave2": 200}
copia_dic = dic_datos.copy()
for llave in copia_dic:
    del dic_datos[llave]
print(dic_datos)
Resultado: {}

Eliminar de conjuntos:

conjunto = {1, 2, 3, 4, 5}
conjunto_copia = conjunto.copy()
for elem in conjunto_copia:
    conjunto.remove(elem)
print(conjunto)
Resultado: set()

Eliminar por índice par (ejemplo avanzado):

lista_avanzada = [11, 22, 33, 44, 55, 66]
# Método con copia
lista_temp = lista_avanzada.copy()
for idx, val in enumerate(lista_temp):
    if idx % 2 == 1:
        lista_avanzada.remove(val)
print(lista_avanzada)
Resultado: [11, 33, 55]

22. Conceptos de codificación:

Sistemas comunes:

• ASCII: Inglés, números, símbolos (1 byte por carácter).
• GBK: Chino simplificado (2 bytes por carácter chino).
• Unicode: Universal (4 bytes por carácter en representación interna).
• UTF-8: Eficiente (1-4 bytes según el carácter).

Python 3 usa Unicode internamente. La codificación en disco puede ser UTF-8 o GBK.

Codificación y decodificación:

texto_original = "hola"
texto_codificado = texto_original.encode("utf-8")
print(texto_codificado)
texto_decodificado = texto_codificado.decode("utf-8")
print(texto_decodificado)
Resultado: b'hola'
hola

Ejercicios de práctica:

1. Analizar código y predecir resultados.

lista_mutable = [1, 2, 3]
lista_ref = [lista_mutable, lista_mutable]
lista_mutable.append(4)
print(lista_ref)
Resultado: [[1, 2, 3, 4], [1, 2, 3, 4]]

2. Comprender copia superficial vs. profunda.

import copy
original = [1, [2, 3]]
copia_superficial = copy.copy(original)
copia_profunda = copy.deepcopy(original)
print(original[1] is copia_superficial[1])
print(original[1] is copia_profunda[1])
Resultado: True
False

3. Eliminar elementos de una lista basándose en condiciones.

datos_usuario = ["Ana", "Pedro", "Andrés", "Carlos"]
for nombre in list(datos_usuario):  # Usar list() para iterar sobre copia
    if nombre.startswith("A"):
        datos_usuario.remove(nombre)
print(datos_usuario)
Resultado: ['Pedro', 'Carlos']