Conocimiento de Python:

1. ¿Qué función se usa para ordenar un diccionario? Ejemplifique.

La función utilizada para ordenar diccionarios es sorted(), que puede ordenar por clave o valor.

</div>**2. ¿Qué palabra clave se usa para formatear cadenas? Ejemplifique.**

`format()` acepta un número ilimitado de argumentos y permite posiciones no secuenciales.

<div>```
# Ejemplo con variables
usuario = {'user': 'admin', 'clave': '123456'}
print("Usuario:{user}, Contraseña:{clave}".format(**usuario))

</div>**3. ¿Cuál es la diferencia entre append() e insert() en listas? Ejemplifique.**

`append()` agrega un elemento al final de la lista, mientras que `insert()` lo inserta en un índice específico.

<div>```
lista_ejemplo = [2, 6, 'ok', 9, 'hola']
lista_ejemplo.append('nuevo')
print(lista_ejemplo)  # Agrega al final

lista_ejemplo.insert(3, 'insertado')
print(lista_ejemplo)  # Inserta en índice 3

Las listas son mutables (se pueden modificar), mientras que las tuplas son inmutables (no se pueden cambiar después de su creación).

5. ¿Qué palabras clave se usan para ver el tipo de un objeto y su dirección de memoria?

Para el tipo: type(); para la dirección de memoria: id().

6. ¿Cómo se obtiene la información de índice de una cadena?

</div>**7. Ejemplifique el uso de listas por comprensión.**

Forma: `[expresión for variable in lista]` o `[expresión for variable in lista if condición]`.

<div>```
lista_generada = [x for x in range(10) if x > 4]
print(lista_generada)

Si una tupla tiene un solo elemento, se debe añadir una coma; de lo contrario, se considera una cadena u otro tipo.

9. ¿Cómo se entiende el valor de retorno de una función?

Toda función tiene un valor de retorno; si no se usa return, el valor es None. Con return, el valor es lo que sigue a la palabra clave. Una función puede tener múltiples valores de retorno.

10. ¿Cómo se entienden los parámetros dinámicos en funciones?

Se usan cuando el número y tipo de argumentos son desconocidos o variables.

11. Conversión entre cadenas y listas.

</div>**12. ¿Qué método se usa para reemplazar en cadenas?**

El método es `replace()`.

<div>```
texto = "Hola mundo"
print("Reemplazar 'Hola' por 'Adiós':", texto.replace("Hola", "Adiós"))

is compara direcciones de memoria (tipo y contenido implícitos); in verifica pertenencia (incluye verificación de tipo); == compara contenido y tipo de datos.

14. Uso de la biblioteca os para rutas de archivos.

def ruta_base(): return os.path.dirname(os.path.dirname(file))

def ruta_archivo(directorio='datos', nombre_archivo=None): return os.path.join(ruta_base(), directorio, nombre_archivo)

</div>**15. Entendiendo serialización y deserialización.**

Serialización: convertir objetos Python a cadenas JSON. Deserialización: convertir cadenas JSON a objetos Python.

**16. Modos de archivo: `a`, `w`, `r`.**

`a`: añadir al final, crea archivo si no existe, no sobrescribe. `w`: escribir, crea o sobrescribe. `r`: solo lectura, error si no existe.

**17. Uso de `with` para manejo de archivos.**

<div>```
with open('registro.txt', 'r', encoding='utf-8') as archivo:
    print(archivo.read())

Codificación: convertir str a bytes con encode(). Decodificación: convertir bytes a str con decode().

19. Obtener hora actual con datetime.

</div>**20. Esperar 5 segundos con `time`.**

<div>```
import time as t
t.sleep(5)

Los decoradores permiten modificar funciones sin cambiar su código, útil para funcionalidades comunes.

22. Variables locales y globales.

Las locales se definen dentro de funciones; las globales, fuera. En conflictos, la local tiene prioridad dentro de la función.

23. Herencia en Java vs. Python.

Java soporta herencia múltiple; Python, herencia simple (aunque con mixins puede simular múltiple).

24. Sobreescritura de métodos en herencia.

Si una subclase redefine un método de la superclase, al instanciar la subclase, se usa el método de la subclase.

def mostrar(self):
    print(f'Nombre: {self.nombre}, Edad: {self.edad}')

class Hijo(Padre): def init(self, nombre, edad, salario): super().init(nombre, edad) self.salario = salario

def mostrar(self):  # Sobreescritura
    print(f'Nombre: {self.nombre}, Edad: {self.edad}, Salario: {self.salario}')

obj_hijo = Hijo('Ana', 30, 50000) obj_hijo.mostrar() # Usa el método del Hijo

</div>**Conocimiento de Linux:**

1\. Comando para ver procesos: `ps`

2\. Comandos para ver puertos: `lsof`, `netstat`

3\. Asignar permisos: `chmod`

4\. Valores numéricos: r=4, w=2, x=1

5\. Ejemplo: `chmod 421 archivo`

6\. Git: `git add archivo`, `git commit -m "mensaje"`

7\. Crear repositorio: `git init`

8\. Ver memoria: `nmon`

9\. Editar archivos: `vim archivo`, usar `a` o `i` para insertar

10\. Primeras 5 líneas: `head -n 5 archivo`

11\. Últimas 10 líneas: `tail -n 10 archivo`

12\. Ver archivos: `ls`, `cat archivo`

13\. Carga promedio: `uptime`

**Conocimiento de API:**

1\. Flujo HTTP: conexión TCP, solicitud request, respuesta response, cierre TCP.

2\. GET vs. POST: GET para obtener recursos, POST para enviar datos.

3\. Postman: pruebas en pestaña Tests.

4\. Collections en Postman: agrupadores para pruebas de APIs, permiten ejecución por lotes.

5\. Parámetros dinámicos: ejemplo con gestión de libros: obtener ID, establecer variable, usar en eliminación.

6\. Variables en Postman: se llaman con `{{variable}}`.

7\. Aserciones: código de estado de negocio, código de estado de protocolo, datos de respuesta.

8\. Código 404: recurso no encontrado.

9\. Error 400: revisar parámetros, tipos, encabezados.

10\. Comunicación síncrona: cliente espera respuesta del servidor; puede bloquear.

11\. Comunicación asíncrona: usa intermediarios como MQ; cliente y servidor no se bloquean mutuamente.

12\. Cookie, Session, Token: mecanismos de autenticación; cookie en cliente, session/token en servidor.

13\. Flujo de sesión: cliente envía login, servidor genera sessionID, cliente lo almacena en cookie, envía en solicitudes.

14\. Error 500: fallo del servidor, revisar código.

15\. Códigos de estado: HTTP (protocolo) vs. negocio (aplicación).

**Teoría de Pruebas:**

1\. Ciclo de vida de un bug: reporte, asignación, resloución, verificación, cierre.

2\. Elementos de un caso de prueba: ID, nombre, propósito, entorno, precondiciones, pasos, resultados esperados.

3\. Pruebas de caja negra vs. caja blanca: negra enfocada en funcionalidad sin ver código; blanca basada en estructura interna.

4\. Fases de pruebas: unitarias, integración, sistema, aceptación.

5\. Clases de equivalencia y valores límite: dividen entradas en válidas/inválidas; límite para casos extremos.

6\. Flujo de pruebas: análisis, diseño, ejecución, reporte.

**Automatización de Pruebas UI:**

1\. Métodos de localización de elementos: ID, NAME, CLASS\_NAME, XPATH, CSS\_SELECTOR, LINK\_TEXT, PARTIAL\_LINK\_TEXT (singles), TAG\_NAME (múltiples).

<div>```
from selenium import webdriver
import time as t

driver = webdriver.Chrome()
driver.get('https://ejemplo.com')
driver.find_element_by_id('campo').send_keys("texto")  # Ejemplo con ID
t.sleep(5)

3. Para marcos (iframe): usar switch_to.frame() antes de localizar elementos.

4. Patrón Page Object Model: clases por página, encapsulan eelmentos; facilita mantenimiento.

5. Esperas implícitas y explícitas: implícita global, explícita para elementos específicos.

</div>6\. Manejo de múltiples ventanas: cambiar con `switch_to.window()`, identificar por handle o URL.

**Frameworks de Pruebas Unitarias:**

1\. Unittest vs. pytest: unittest más estructurado, pytest más flexible.

2\. Componentes de unittest: TestFixture, TestCase, TestRun, TestSuit, TestReport.

3\. TestFixture: configuración inicial/limpieza.

4\. setUp()/tearDown(): ejecutados por cada caso; setup\_class/teardown\_class una vez por clase.

5\. Cargar módulos: `discover()` con parámetros: ruta, patrón, nivel superior.

6\. Reportes: usar librerías como HTMLTestRunner.

7\. Pasos de un caso de prueba: análisis, escritura, priorización.

8\. Parametrización: usar para múltiples datos en una misma prueba.

9\. Caso de prueba completo: inicialización, pasos, aserción, limpieza.

10\. Independencia de casos: cada prueba debe ser autónoma.

</div>