PROGRAMACIÓN EN PYTHON

Cuaderno Práctico de Aprendizaje y Casos de Uso

Juan Miguel Pérez García

4 de agosto de 2026
Índice general

1. Sintaxis de Python 2
1.1. Identificadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2. Comentarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.3. Sangría y Tipado Dinámico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.4. Simulación de Constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2. Tipos Primitivos, Operadores y Cadenas de Texto 6

2.1. Operadores Aritméticos, Compuestos y de Bits . . . . . . . . . . . . . . . . . . . 6
2.2. Lógica Booleana y Comparaciones . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.3. Manipulación Avanzada de Cadenas (str) y Slicing . . . . . . . . . . . . . . . . . 8
2.4. Conversión Explícita de Tipos (Casting) . . . . . . . . . . . . . . . . . . . . . . 10

3. Estructuras de Datos y Colecciones 11

3.1. Listas (list): Indexación, Métodos y Ordenación . . . . . . . . . . . . . . . . . 11
3.2. Tuplas (tuple): Empaquetado y Desempaquetado . . . . . . . . . . . . . . . . . 13
3.3. Diccionarios (dict): Estructuras Clave-Valor . . . . . . . . . . . . . . . . . . . . 14
3.4. Conjuntos (set): Operaciones Algebraicas . . . . . . . . . . . . . . . . . . . . . 15

4. Control de Flujo e Iteración 16

4.1. Condicionales: if, elif y else . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
4.2. Bucle while y Cláusula else . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
4.3. Bucle for, Secuencias y Función range() . . . . . . . . . . . . . . . . . . . . . . 18
4.4. Control Interno (break, continue) e Iteradores (iter, next) . . . . . . . . . . . 19

5. Funciones, Argumentos y Modularidad 21

5.1. Definición de Funciones (def) y Retornos (return) . . . . . . . . . . . . . . . . 21
5.2. Argumentos Posicionales, Nombrados y Valores por Defecto . . . . . . . . . . . 21
5.3. Argumentos Indeterminados (*args y **kwargs) . . . . . . . . . . . . . . . . . 22

6. Programación Orientada a Objetos (POO) 24

6.1. Definición de Clases y Método __init__ . . . . . . . . . . . . . . . . . . . . . . 24
6.2. Atributos y Métodos de Instancia . . . . . . . . . . . . . . . . . . . . . . . . . . 24
6.3. Herencia y Reutilización de Código . . . . . . . . . . . . . . . . . . . . . . . . . 25

7. Tratamiento de Excepciones y Archivos 27

7.1. Control de Excepciones: try, except, else y finally . . . . . . . . . . . . . . 27
7.2. Lectura y Escritura de Archivos (open, with) . . . . . . . . . . . . . . . . . . . 28

8. Librerías Estándar y Entorno Científico 29

8.1. Uso de Módulos Estándar (math, random) . . . . . . . . . . . . . . . . . . . . . 29
8.2. Introducción a NumPy para Cálculo Vectorial . . . . . . . . . . . . . . . . . . . 30

1
1. Sintaxis de Python
1.1 Identificadores
Son nombres que asignaremos a elementos (funciones, variables, etc.) para hacerles referencia
más adelante en el código.
Reglas de sintaxis:

Los identificadores pueden contener letras, números y el guión bajo (_).

No pueden empezar por un número ni utilizar caracteres especiales (@, !, #, etc.).

Pueden tener cualquier longitud.

Distinguen estrictamente entre mayúsculas y minúsculas (case-sensitive).

Código Python: Asignación e Identificadores

1 _contador = 0
2 variable = 1
3 otra_variable = " Otra "
4 mas_variables = [1 , 3 , 4]
5 Variable_4 = True
6

7 # Impresion de los identificadores creados

8 print ( _contador )
9 print ( variable )
10 print ( otra_variable )
11 print ( mas_variables )
12 print ( Variable_4 )

Salida en Consola / Resultado

0
1
Otra
[1, 3, 4]
True

1.2 Comentarios
Son partes del código que el intérprete de Python no ejecuta. Nos permiten escribir aclara-
ciones para mejorar la interpretabilidad del programa, tanto para otros desarrolladores como
para nosotros mismos en el futuro.
Sintaxis de los comentarios:

Comentarios de una línea: Comienzan con el carácter almohadilla (#). Todo lo escrito
a su derecha en esa misma línea será ignorado por el intérprete.

Comentarios multilínea o bloques: Se delimitan utilizando tres comillas dobles (

"...") o tres comillas simples (”’...”’). Se suelen emplear para explicaciones extensas
o documentación de funciones (docstrings).

2
 Código Python: Ejemplo de Comentarios

1 # Esto es un comentario de linea completo

2 variable_c on_comenta rio = 100 # Comentario al final de una
instruccion
3

4 """
5 Esto es un comentario multilinea .
6 Python no ejecutara nada de lo que
7 este escrito en este bloque .
8 """
9 mensaje = " Los comentarios no afectan a la ejecucion "
10

11 print ( mensaje )
12 print ( variab le_con_com entario )

Salida en Consola / Resultado

Los comentarios no afectan a la ejecucion
100

1.3 Sangría y Tipado Dinámico

Python no utiliza llaves ({}) ni delimitadores de inicio y fin para diferenciar bloques de
código, sino que emplea la sangría (indentation). Asimismo, gestiona el tipo de las variables
de forma automática en tiempo de ejecución.
Características clave:

Sangría obligatoria: Define la pertenencia de las instrucciones a un bloque ejecutable

(como dentro de un if, for o una función). La convención estándar es usar 4 espacios.

Tipado dinámico: Una misma variable puede cambiar de tipo a lo largo de la ejecución
del programa según el valor asignado.

Tipo None: Representa la ausencia de valor o un valor nulo.

3
 title

1 # Ejemplo de una sangria :

2 variable = 1
3 # La sangria define el bloque ejecutable dentro del condicional
4 if variable == 1:
5 print ( " Aqui pongo el codigo a ejecutar " )
6 print ( " Tiene una sangria de 4 espacios " )
7

8 # Asignacion y cambio de tipo de dato

9 dato = 23
10 print ( type ( dato ) )
11

12 dato = " Hola Mundo "

13 print ( type ( dato ) )
14

15 # Tipo None
16 variable_vacia = None
17 print ( type ( variable_vacia ) )

title
Bloque identado con 4 espacios
Segunda instruccion del mismo bloque
<class ’int’>
<class ’str’>
<class ’NoneType’>

4
1.4 Simulación de Constantes
Python no posee una palabra reservada (como const o final) para definir constantes
cuyo valor esté protegido contra modificaciones. En su lugar, se recurre a una convención de
nomenclatura respaldada por la comunidad.
Reglas y buenas prácticas:

Nombres en mayúsculas: Se emplean letras mayúsculas con palabras separadas por

guiones bajos (SNAKE_CASE_UPPERCASE ) para indicar que una variable debe ser
tratada como constante.

Carácter indicativo: El uso de mayúsculas es una señal conceptual para los desarrolla-
dores; el intérprete de Python no impedirá la reasignación del valor si se intenta modificar
más adelante.

title

1 # Definicion de constantes por convencion

2 IVA = 0.21
3

4 # Calculo utilizando constantes

5 precio = 25.0
6 precio_total = precio * (1 + IVA )
7

8 print ( f " Precio con IVA : { precio_total } " )

title
Precio con IVA: 121.0

5
2. Tipos Primitivos, Operadores y Cadenas de Texto
2.1 Operadores Aritméticos, Compuestos y de Bits
Python proporciona operadores para realizar operaciones matemáticas estándar, asignacio-
nes simplificadas y manipulación directa a nivel de bit.
Categorías de operadores:

Aritméticos: Realizan operaciones matemáticas. Destacan la división real (/), que siem-
pre retorna un float; la división entera (//), que trunca los decimales; el módulo ( %),
que devuelve el resto; y la exponenciación (**).

Asignación compuesta: Combinan una operación aritmética con una asignación (+=,
-=, *=, etc.), permitiendo modificar el valor de una variable de forma abreviada.

A nivel de bits (bitwise): Operan directamente sobre la representación binaria de los

números enteros (& para AND, | para OR, ^ para XOR, y « / » para desplazamientos).

title

1 # Operadores aritmeticos basicos

2 a = 15
3 b = 4
4 suma = a + b
5 resta = a - b
6 multi = a * b
7 div_real = a / b
8 div_entera = a // b
9 modulo = a % b
10 potencia = a ** b
11

12 # Operadores de asignacion compuesta

13 x = 10
14 x += 5
15 x *= 2
16

17 # Operadores a nivel de bits

18 p = 0 b0101 # 5 en binario
19 q = 0 b0011 # 3 en binario
20

21 and_bit = p & q
22 or_bit = p | q
23 xor_bit = p ^ q
24 shift_l = p << 1
25 shift_r = p >> 1
26

27 # Impresion de resultados
28 print ( f " Suma : { suma } , Resta : { resta } , Division real : { div_real } ,
Division entera : { div_entera } " )
29 print ( f " Modulo : { modulo } , Potencia : { potencia } " )
30 print ( f " Valor final de x : { x } " )
31 print ( f " Bitwise -> AND : { and_bit } , OR : { or_bit } , XOR : { xor_bit } " )
32 print ( f " Desplazamientos -> Izq : { shift_l } , Der : { shift_r } " )

6
 title
Suma: 19, Division real: 3.75, Division entera: 3
Modulo: 3, Potencia: 50625
Valor final de x: 30
Bitwise ->AND: 1, OR: 7, XOR: 6
Desplazamientos ->Izq: 10, Der: 2

2.2 Lógica Booleana y Comparaciones

El tipo de dato bool representa valores de verdad y solo admite dos estados: True y False.
Constituye la base para el control de flujo y la toma de decisiones en Python.
Conceptos y reglas clave:

Operadores de comparacion: Evaluan la relacion entre dos valores y devuelven un

booleano (== para igualdad, != para desigualdad, <, >, ≤ y ≥).

Operadores logicos: Permiten combinar multiples condiciones mediante relacionales

logicos:

• and: Devuelve True solo si ambas condiciones son verdaderas.

• or: Devuelve True si al menos una condicion es verdadera.
• not: Invierte el valor booleano de la expresion.

Evaluacion en cortocircuito (Short-circuit evaluation): Python evalua las expre-

siones logicas de izquierda a derecha y se detiene en cuanto el resultado global esta de-
terminado. Por ejemplo, en un and, si el primer operador es False, el segundo ni siquiera
se ejecuta (evitando errores en tiempo de ejecucion como la division por cero).

7
 title

1 # Operadores de comparacion
2 x = 10
3 y = 20
4

5 es_igual = ( x == y)
6 no_igual = ( x != y)
7 mayor_que = ( x > y)
8 menor_igual = ( x <= 10)
9

10 # Logica booleana
11 edad = 25
12 tiene_carnet = True
13

14 puede_conducir = ( edad >= 18) and tiene_carnet

15 descuento = ( edad < 18) or ( edad >= 65)
16 bloqueado = not tiene_carnet
17

18 # Evaluacion en cortocircuito ( evita ZeroDivisionError )

19 resultado_ cortocircui to = False and (10 / 0 == 1)
20

21 # Impresion de resultados
22 print ( f " Comparaciones -> Igual : { es_igual } , Diferente : { no_igual } ,
Menor / Igual : { menor_igual } " )
23 print ( f " Puede conducir : { puede_conducir } , Descuento : { descuento } ,
Bloqueado : { bloqueado } " )
24 print ( f " Resultado en cortocircuito : { resultado_c ortocircuit o } " )

title
Comparaciones ->Igual: False, Diferente: True, Menor/Igual: True
Puede conducir: True, Descuento: False, Bloqueado: False
Resultado en cortocircuito: False

2.3 Manipulación Avanzada de Cadenas (str) y Slicing

Las cadenas de texto en Python son **inmutables**. Una vez creadas, sus caracteres no
pueden modificarse individualmente; cualquier transformación genera un nuevo objeto en me-
moria.
Conceptos y reglas clave:

Indexación y Slicing (Rebanado): Permite extraer subcadenas mediante la sintaxis

cadena[inicio:fin:paso].

• El índice inicio es inclusivo, mientras que fin es exclusivo (el carácter en esa
posición no se incluye).
• Se pueden emplear índices negativos para contar desde el final (-1 es el último
carácter).
• Un paso negativo ([::-1]) invierte el orden completo de la cadena.

8
 Métodos fundamentales: Transforman o procesan el texto sin modificar la cadena
original:

• .strip(): Elimina espacios en blanco u otros caracteres delimitadores en ambos

extremos.
• .upper() / .lower(): Convierte el texto completo a mayúsculas o minúsculas.
• .replace(viejo, nuevo): Sustituye todas las ocurrencias de una subcadena.
• .split(delimitador): Divide la cadena en una lista de subcadenas según el deli-
mitador especificado.

Formato con f-strings: Permite interpolar variables de forma eficiente e indicar el

formato de salida mediante modificadores numéricos (por ejemplo, :.2f para redondear
a 2 decimales).

title

1 # Indexacion y Slicing ( Rebanado )

2 texto = " Python_Cientifico "
3

4 primer_char = texto [0] # ’P ’

5 ultimo_char = texto [ -1] # ’o ’ ( indice negativo )
6

7 subcadena1 = texto [0:6] # ’ Python ’

8 subcadena2 = texto [7:] # ’ Cientifico ’
9 paso_dos = texto [::2] # ’ Pto_ienio ’ ( salta de 2 en 2)
10 invertida = texto [:: -1] # ’ ocifitneiC_nohtyP ’ ( cadena
invertida )
11

12 # Metodos de cadena mas utilizados

13 mensaje = " Hola , mundo desde Python "
14

15 limpio = mensaje . strip ()

16 mayus = limpio . upper ()
17 remplazado = limpio . replace ( " Python " , " UNIR " )
18 partes = limpio . split ( " ," )
19

20 # Formato de cadenas (f - strings )

21 nombre = " Juan "
22 precision_pi = 3.14159265
23 fmt = f " Usuario : { nombre } | PI con 2 decimales : { precision_pi :.2 f }
"
24

25 # Impresion de resultados
26 print ( f " Slicing -> Sub1 : { subcadena1 } , Sub2 : { subcadena2 } ,
Invertida : { invertida } " )
27 print ( f " Limpio : ’{ limpio } ’ | Reemplazado : ’{ remplazado } ’ " )
28 print ( f " Partes tras split : { partes } " )
29 print ( fmt )

9
 title
Slicing ->Sub1: Python, Sub2: Cientifico, Invertida: ocifitneiC_nohtyP
Limpio: ’Hola, mundo desde Python’ | Reemplazado: ’Hola, mundo desde
UNIR’
Partes tras split: [’Hola’, ’ mundo desde Python’]
Usuario: Juan | PI con 2 decimales: 3.14

2.4 Conversión Explícita de Tipos (Casting)

Python es un lenguaje de tipado fuerte, lo que significa que no realiza conversiones auto-
maticas entre tipos de datos incompatibles. La conversion explicita se realiza mediante funciones
constructoras integradas.
Conceptos y reglas clave:

Funciones de conversion principales:

• int(x): Convierte una cadena de digitos o un numero flotante a entero. Al convertir

desde flotante, trunca los decimales (elimina la parte decimal sin redondear).
• float(x): Convierte un entero o una cadena numerica a numero de punto flotante.
• str(x): Convierte cualquier objeto en su representacion textual.

Evaluacion booleana (Truthiness):

• La funcion bool(x) evalua la veracidad de cualquier valor.

• Evaluan como False: el numero cero (0, 0.0), cadenas vacias (), el valor nulo None
y colecciones vacias ([], {}, ()).
• Cualquier otro valor numerico distinto de cero o contenedor con elementos evalua
como True.

10
 title

1 # Conversiones entre tipos primitivos

2 cadena_num = " 123 "
3 entero = int ( cadena_num ) # Convierte str a int (123)
4 flotante = float ( entero ) # Convierte int a float (123.0)
5

6 # Truncado de decimales ( no redondea )

7 val_float = 9.87
8 val_int = int ( val_float ) # Resultado : 9
9

10 # Conversion a cadena
11 num = 456
12 texto_num = str ( num ) # Resultado : "456"
13

14 # Evaluacion booleana de otros tipos ( Truthiness )

15 b_cero = bool (0) # False
16 b_num = bool (42) # True
17 b_vacio = bool ( " " ) # False
18 b_texto = bool ( " Texto " ) # True
19

20 # Impresion de resultados
21 print ( f " Entero : { entero } | Flotante : { flotante } | Truncado : {
val_int } " )
22 print ( f " Bool 0: { b_cero } | Bool 42: { b_num } " )
23 print ( f " Bool ’ ’: { b_vacio } | Bool ’ Texto ’: { b_texto } " )

title
Entero: 123 | Flotante: 123.0 | Truncado: 9
Bool 0: False | Bool 42: True
Bool ”: False | Bool ’Texto’: True

3. Estructuras de Datos y Colecciones

3.1 Listas (list): Indexación, Métodos y Ordenación
Las listas son secuencias **mutables** y ordenadas de elementos. Permiten almacenar ti-
pos de datos heterogéneos (mixtos) y modificar su contenido dinámicamente sin cambiar su
identidad en memoria.
Conceptos y reglas clave:

Acceso y modificación: Los elementos se direccionan mediante índices basados en

cero. Al ser mutables, se pueden reasignar valores directamente mediante lista[i] =
nuevo_valor.

Métodos principales de inserción y extracción:

• .append(x): Añade el elemento x al final de la lista.

• .insert(i, x): Inserta el elemento x en la posición de índice i.
• .pop([i]): Elimina y devuelve el elemento en el índice i (por defecto, el último).

11
 • .remove(x): Elimina la primera aparición del valor x en la lista.

Ordenación (in-place vs funcional):

• .sort(): Modifica la lista original directamente (in-place) y no devuelve nada (None).

Admite el argumento reverse=True.
• sorted(lista): Función integrada que devuelve una **nueva** lista ordenada sin
alterar la original.

Comprensión de listas (List Comprehension): Sintaxis compacta para crear nuevas

listas aplicando una expresión a cada elemento de un iterable.

title

1 # Creacion y modificacion directa

2 vector = [10 , 20 , 30 , 40 , 50]
3 vector [0] = 99 # Modifica el primer elemento
4

5 # Insercion y extraccion
6 vector . append (60) # Anade al final
7 vector . insert (1 , 15) # Inserta en el indice 1
8 elem = vector . pop () # Extrae y devuelve el ultimo elemento (60)
9 vector . remove (15) # Elimina la primera aparicion del valor 15
10

11 # Ordenacion
12 datos = [4 , 1 , 9 , 2]
13 datos . sort () # Orden ascendente in - place : [1 , 2 , 4 , 9]
14 datos_desc = sorted ( datos , reverse = True ) # Nueva lista descendente
15

16 # Comprension de listas
17 cuadrados = [ x **2 for x in range (5) ]
18

19 # Impresion de resultados
20 print ( f " Vector modificado : { vector } | Elemento pop : { elem } " )
21 print ( f " Datos ordenados : { datos } | Descendente : { datos_desc } " )
22 print ( f " Cuadrados ( comprehension ) : { cuadrados } " )

title
Vector modificado: [99, 20, 30, 40, 50] | Elemento pop: 60
Datos ordenados: [1, 2, 4, 9] | Descendente: [9, 4, 2, 1]
Cuadrados (comprehension): [0, 1, 4, 9, 16]

12
3.2 Tuplas (tuple): Empaquetado y Desempaquetado
Las tuplas son secuencias **inmutables** y ordenadas de elementos. Su inmutabilidad las
hace ideales para agrupar conjuntos de datos heterogéneos estáticos que no deben modificarse
durante la ejecución del programa, aportando mayor seguridad de código y optimización de
memoria.
Conceptos y reglas clave:
Inmutabilidad: Una vez creada, no es posible añadir, eliminar ni modificar sus elemen-
tos. Cualquier intento de reasignación directa (tupla[0] = x) genera un error de tipo
(TypeError).
Empaquetado y Desempaquetado (Unpacking ):
• Asignar múltiples valores separados por comas a una sola variable crea implícita-
mente una tupla (packing).
• Asignar una tupla a una secuencia de variables distribuye sus elementos de forma
posicional (unpacking). El número de variables debe coincidir con la longitud de la
tupla.
Desempaquetado extendido (Extended Unpacking ): El operador asterisco (*) per-
mite capturar múltiples elementos sobrantes dentro de una lista durante el desempaque-
tado.
Retorno múltiple de funciones: Las funciones que devuelven varios valores separados
por comas retornan en realidad una única tupla.
title

1 # Definicion y desempaquetado directo

2 coordenada = (37.98 , -1.13)
3 x , y , z = (10 , 20 , 30)
4

5 # Desempaquetado con operador asterisco (*)

6 valores = (1 , 2 , 3 , 4 , 5)
7 primero , * resto , ultimo = valores
8

9 # Retorno multiple en funciones ( uso de tuplas )

10 def obtener_min_max ( lista ) :
11 return min ( lista ) , max ( lista )
12

13 minimo , maximo = obtener_min_max ([5 , 2 , 8 , 1])

14

15 # Impresion de resultados
16 print ( f " Coordenadas : { coordenada } | Punto : x ={ x } , y ={ y } , z ={ z } " )
17 print ( f " Primero : { primero } | Resto : { resto } | Ultimo : { ultimo } " )
18 print ( f " Minimo : { minimo } | Maximo : { maximo } " )

title
Coordenadas: (37.98, -1.13) | Punto: x=10, y=20, z=30
Primero: 1 | Resto: [2, 3, 4] | Ultimo: 5
Minimo: 1 | Maximo: 8

13
3.3 Diccionarios (dict): Estructuras Clave-Valor
Los diccionarios son colecciones **mutables** y optimizadas para la búsqueda rápida de
datos mediante pares de asociación clave: valor.
Conceptos y reglas clave:

Restricción de claves: Las claves deben ser obligatoriamente de tipos **inmutables**

y *hashables* (como str, int, float o tuple). Los valores, por el contrario, pueden ser
de cualquier tipo y modificarse libremente.

Acceso seguro con .get(): El acceso directo por corchetes (dict[clave]) lanza un
error KeyError si la clave no existe. El método .get(clave, valor_por_defecto) per-
mite consultar de forma segura, devolviendo None o un valor alternativo parametrizado.

Inserción y actualización: Asignar un valor a una clave existente sobreescribe su con-

tenido; asignarlo a una clave inexistente la crea e inserta de forma dinámica.

Métodos de iteración:

• .keys(): Devuelve una vista con las claves.

• .values(): Devuelve una vista con los valores.
• .items(): Devuelve pares tupla (clave, valor) ideales para desempaquetar en
bucles for.

Comprensión de diccionarios (Dict Comprehension): Permite la creación dinámica

de diccionarios aplicando una regla de asignación clave-valor sobre un iterable.

title

1 # Definicion de diccionario
2 constantes = {
3 " pi " : 3.14159 ,
4 " e " : 2.71828 ,
5 " c " : 299792458
6 }
7

8 # Acceso seguro mediante . get ()

9 velocidad_luz = constantes . get ( " c " , 0)
10 desconocida = constantes . get ( " h " , None )
11

12 # Asignacion y actualizacion
13 constantes [ " h " ] = 6.62607 e -34 # Inserta nueva clave
14 constantes [ " pi " ] = 3.1416 # Actualiza valor existente
15

16 # Comprension de diccionarios ( Dict Comprehension )

17 cuadrados_dict = { x : x **2 for x in range (4) }
18

19 # Impresion de resultados
20 print ( f " Constante c : { velocidad_luz } | Constante h buscada : {
desconocida } " )
21 print ( f " Constante h creada : { constantes [ ’ h ’]} " )
22 print ( f " Dict Comprehension : { cuadrados_dict } " )

14
 title
Constante c: 299792458 | Constante h buscada: None
Constante h creada: 6.62607e-34
Dict Comprehension: {0: 0, 1: 1, 2: 4, 3: 9}

3.4 Conjuntos (set): Operaciones Algebraicas

Los conjuntos son colecciones desordenadas de elementos **únicos** e **inmutables**. Im-
plementan directamente las operaciones y propiedades de la teoría matemática de conjuntos.
Conceptos y reglas clave:
Unicidad y eliminación de duplicados: Un conjunto no admite elementos repetidos.
Es habitual convertir una lista a conjunto (set(lista)) para filtrar elementos duplicados
de forma eficiente.
Restricción de elementos: Los elementos individuales deben ser de tipos inmutables
y *hashables* (int, str, tuple). No se pueden incluir objetos mutables como listas o
diccionarios dentro de un conjunto.
Operadores algebraicos de conjuntos:
• Unión (A ∪ B): set_a | set_b — Devuelve todos los elementos presentes en al
menos uno de los conjuntos.
• Intersección (A ∩ B): set_a & set_b — Devuelve únicamente los elementos pre-
sentes en ambos conjuntos.
• Diferencia (A \ B): set_a - set_b — Devuelve los elementos que pertenecen al
primer conjunto pero no al segundo.
• Diferencia simétrica (A∆B): set_a ˆ set_b — Devuelve los elementos que per-
tenecen a uno u otro conjunto, pero no a ambos a la vez.
title

1 # Declaracion de conjuntos
2 set_a = {1 , 2 , 3 , 4 , 5}
3 set_b = {4 , 5 , 6 , 7 , 8}
4

5 # Eliminacion automatica de duplicados

6 lista_duplicados = [1 , 2 , 2 , 3 , 3 , 3]
7 unicos = set ( lista_duplicados )
8

9 # Operaciones algebraicas de conjuntos

10 union = set_a | set_b
11 interseccion = set_a & set_b
12 diferencia = set_a - set_b
13 dif_simetrica = set_a ^ set_b
14

15 # Impresion de resultados
16 print ( f " Unicos desde lista : { unicos } " )
17 print ( f " Union ( A | B ) : { union } " )
18 print ( f " Interseccion ( A & B ) : { interseccion } " )
19 print ( f " Diferencia ( A - B ) : { diferencia } " )
20 print ( f " Dif . Simetrica ( A ^ B ) : { dif_simetrica } " )

15
 title
Unicos desde lista: {1, 2, 3}
Union (A | B): {1, 2, 3, 4, 5, 6, 7, 8}
Interseccion (A & B): {4, 5}
Diferencia (A - B): {1, 2, 3}
Dif. Simetrica (A ˆ B): {1, 2, 3, 6, 7, 8}

4. Control de Flujo e Iteración

4.1 Condicionales: if, elif y else
Las estructuras condicionales permiten alterar el flujo lineal de ejecución de un programa
evaluando expresiones booleanas en secuencia. La cláusula elif permite encadenar múltiples
condiciones sin generar anidamientos innecesarios y profundos.
Conceptos y reglas clave:

Evaluación secuencial y excluyente: Las condiciones se evalúan de arriba a abajo. En

el momento en que una condición resulta verdadera (True), se ejecuta su bloque asociado
y se omiten todas las cláusulas restantes del bloque condicional.

Uso de operadores lógicos: Es común combinar condiciones mediante and, or y not.

En Python, las comparaciones encadenadas como 0 <= temperatura <= 30 también son
sintácticamente válidas y equivalentes.

Operador Ternario (Conditional Expression): Permite asignar o retornar un valor

en una sola línea evaluando una condición. La sintaxis es: valor_si_true if condicion
else valor_si_false.

title

1 # Estructura condicional multiple

2 temperatura = 22.5
3

4 if temperatura < 0:
5 estado = " Congelacion "
6 elif temperatura >= 0 and temperatura < 18:
7 estado = " Frio "
8 elif temperatura >= 18 and temperatura <= 30:
9 estado = " Confortable "
10 else :
11 estado = " Calor extremo "
12

13 # Operador Ternario
14 modo = " Alerta " if temperatura > 30 else " Normal "
15

16 # Impresion de resultados
17 print ( f " Temperatura : { temperatura } degC " )
18 print ( f " Estado del entorno : { estado } " )
19 print ( f " Modo de operacion : { modo } " )

16
 title
Temperatura: 22.5 degC
Estado del entorno: Confortable
Modo de operacion: Normal

4.2 Bucle while y Cláusula else

El bucle while permite repetir un bloque de instrucciones de manera iterativa mientras una
condición booleana se mantenga verdadera (True). Python incorpora una sintaxis singular al
permitir acoplar una cláusula else a las estructuras de control repetitivas.
Conceptos y reglas clave:

Evaluación de la condición: Se comprueba la condición antes de cada iteración. Si

evalúa a False desde el inicio, el cuerpo del bucle no se ejecuta ninguna vez.

Comportamiento de la cláusula else: El bloque asociado a else se ejecuta **única-

mente** cuando el bucle finaliza de forma natural (es decir, cuando la condición evalúa
a False).

Interrupción con break: Si la ejecución del bucle se interrumpe de forma explícita

mediante la instrucción break, el flujo de control sale inmediatamente del bucle y la
cláusula else es **omitida**.

title

1 # Bucle while convencional con clausula else

2 contador = 0
3

4 while contador < 3:

5 print ( f " Iteracion numero : { contador } " )
6 contador += 1
7 else :
8 print ( " Bucle completado sin interrupciones . " )
9

10 # Busqueda lineal con interrupcion prematura

11 objetivo = 7
12 numero = 0
13

14 while numero < 10:

15 if numero == objetivo :
16 print ( f " Elemento { objetivo } encontrado . " )
17 break # Omite el bloque else al salir
18 numero += 1
19 else :
20 print ( " Elemento no encontrado en el rango . " )

17
 title
Iteracion numero: 0
Iteracion numero: 1
Iteracion numero: 2
Bucle completado sin interrupciones.
Elemento 7 encontrado.

4.3 Bucle for, Secuencias y Función range()

En Python, el bucle for no opera como un contador numérico tradicional estilo C, sino
como un mecanismo de **iteración sobre elementos** de cualquier objeto iterable (secuencias,
colecciones o generadores).
Conceptos y reglas clave:

La función range(inicio, fin_excluido, paso): Genera una secuencia inmutable

de números enteros de forma eficiente en memoria (*lazy evaluation*). El límite superior
nunca se incluye.

Indexación explicita con enumerate(): Permite iterar sobre un ejecutable obteniendo

simultáneamente el índice numérico posicional y el elemento correspondiente en cada paso.

Iteración paralela con zip(): Agrupa elementos de múltiples iterables en tuplas posi-
cionales. La iteración se detiene al agotar el iterable de menor longitud.

title

1 # Generacion de secuencias numericas con range ()

2 for i in range (1 , 10 , 2) :
3 print ( f " Numero impar : { i } " )
4

5 # Iteracion con indice usando enumerate ()

6 frutas = [ " Manzana " , " Banana " , " Naranja " ]
7 for indice , fruta in enumerate ( frutas ) :
8 print ( f " Indice { indice }: { fruta } " )
9

10 # Iteracion simultanea sobre multiples listas con zip ()

11 nombres = [ " Ana " , " Carlos " , " Elena " ]
12 notas = [8.5 , 9.0 , 7.8]
13 for nombre , nota in zip ( nombres , notas ) :
14 print ( f " Estudiante : { nombre } | Nota : { nota } " )

18
 title
Numero impar: 1
Numero impar: 3
Numero impar: 5
Numero impar: 7
Numero impar: 9
Indice 0: Manzana
Indice 1: Banana
Indice 2: Naranja
Estudiante: Ana | Nota: 8.5
Estudiante: Carlos | Nota: 9.0
Estudiante: Elena | Nota: 7.8

4.4 Control Interno (break, continue) e Iteradores (iter, next)

Las sentencias de control de salto permiten modificar de forma explícita el flujo de un
bucle. En un nivel más profundo, el mecanismo de iteración en Python se fundamenta en el
**Protocolo del Iterador**, el cual gestiona cómo se recorren los elementos entre bastidores.
Conceptos y reglas clave:

Instrucciones de salto de flujo:

• continue: Omite el resto de las instrucciones del cuerpo del bucle para la iteración
actual y salta inmediatamente a la evaluación del siguiente elemento o condición.
• break: Interrumpe y finaliza de forma inmediata la ejecución completa del bucle,
transfiriendo el control a la siguiente línea fuera del mismo (y omitiendo la cláusula
else del bucle).

Protocolo del Iterador (iter y next):

• iter(objeto): Obtiene el objeto **iterador** a partir de un iterable (como una

lista, tupla o cadena).
• next(iterador): Devuelve el siguiente elemento de la secuencia en cada llamada.
Cuando no quedan elementos por procesar, lanza la excepción interna StopIteration,
la cual es capturada de forma invisible por los bucles for.

19
 title

1 # Control de salto : break y continue

2 for num in range (10) :
3 if num % 2 == 0:
4 continue # Omite pares
5 if num > 7:
6 break # Detiene el bucle al superar 7
7 print ( f " Procesando impar : { num } " )
8

9 # Mecanismo interno de iteracion

10 datos = [100 , 200 , 300]
11 iterador = iter ( datos ) # Obtencion del objeto iterador
12

13 # Extraccion manual con next ()

14 elem1 = next ( iterador )
15 elem2 = next ( iterador )
16 elem3 = next ( iterador )
17

18 print ( f " Elementos extraidos manualmente : { elem1 } , { elem2 } , { elem3 }

")

title
Procesando impar: 1
Procesando impar: 3
Procesando impar: 5
Procesando impar: 7
Elementos extraidos manualmente: 100, 200, 300

20
5. Funciones, Argumentos y Modularidad
5.1 Definición de Funciones (def) y Retornos (return)
Las funciones permiten modularizar el código encapsulando bloques de lógica reutilizables.
Promueven la mantenibilidad, evitan la repetición de código (*DRY - Don’t Repeat Yourself*)
y facilitan las pruebas unitarias.
Conceptos y reglas clave:

Declaración e identación: Se definen mediante la palabra clave def, seguida del nombre
de la función, paréntesis con los parámetros requeridos y dos puntos (:). El cuerpo de la
función debe estar correctamente sangrado.

Docstrings: Cadenas de texto situadas en la primera línea interna del cuerpo ("...")
destinadas a documentar el propósito, parámetros y valores devueltos por la función.

Instrucción return: Finaliza la ejecución de la función y devuelve uno o múltiples

valores al punto desde donde fue invocada. Si una función no incluye un return explícito,
devuelve implícitamente None.

title

1 def calcul ar _e ner gi a_ cin et ica ( masa , velocidad ) :

2 " " " Calcula la energia cinetica : E_k = 0.5 * m * v ^2 " " "
3 energia = 0.5 * masa * ( velocidad ** 2)
4 return energia
5

6 # Invocacion y almacenamiento del resultado

7 e_k = calcu la r_ ene rg ia _ci ne ti ca (70.0 , 5.0)
8

9 # Impresion de resultados
10 print ( f " Energia cinetica calculada : { e_k } J " )

title
Energia cinetica calculada: 875.0 J

5.2 Argumentos Posicionales, Nombrados y Valores por Defecto

Los parámetros de una función pueden configurarse con valores predeterminados (*default
values*) o invocarse mediante asignación explícita por nombre (*keyword arguments*), lo que
aporta flexibilidad y claridad a las llamadas.
Conceptos y reglas clave:

Orden de declaración: Los parámetros requeridos (sin valor por defecto) deben decla-
rarse **antes** que cualquier parámetro con valor opcional.

Invocación posicional vs nombrada:

• Posicional: Los argumentos se asignan a los parámetros según el orden en el que se

pasan en la llamada.
• Nombrada (Keyword ): Se especifica explícitamente el nombre del parámetro
(parametro=valor). Permite alterar el orden de los argumentos en la llamada.

21
 Evaluación de valores por defecto: Los valores predeterminados se evalúan **una
sola vez** en el momento en que se define la función, no en cada ejecución.

title

1 # Definicion con parametros obligatorios y opcionales

2 def simular_caida ( tiempo , g =9.80665 , altura_inicial =0.0) :
3 " " " Calcula la posicion en caida libre : h = h0 - 0.5 * g * t ^2 "
""
4 posicion = altura_inicial - 0.5 * g * ( tiempo ** 2)
5 return posicion
6

7 # Llamada posicional utilizando valores por defecto

8 res1 = simular_caida (2.0)
9

10 # Llamada nombrada alterando el orden y sobreescribiendo h0

11 res2 = simular_caida ( tiempo =2.0 , altura_inicial =100.0)
12

13 # Impresion de resultados
14 print ( f " Caida desde 0 m en 2 s : { res1 :.2 f } m " )
15 print ( f " Caida desde 100 m en 2 s : { res2 :.2 f } m " )

title
Caida desde 0m en 2s: -19.61 m
Caida desde 100m en 2s: 80.39 m

5.3 Argumentos Indeterminados (*args y **kwargs)

Cuando no se conoce de antemano el número exacto de argumentos que recibirá una fun-
ción, Python permite empaquetar un número variable de entradas posicionales o nombradas
utilizando los operadores asterisco (*) y doble asterisco (**).
Conceptos y reglas clave:

Argumentos posicionales variables (*args): Agrupa todos los argumentos posicio-

nales adicionales pasados a la función dentro de una **tupla**.

Argumentos nombrados variables (**kwargs): Agrupa todos los argumentos de

clave-valor adicionales dentro de un **diccionario**.

Orden estándar de parámetros: Al combinar distintos tipos de parámetros en una

misma declaración, debe respetarse estrictamente el siguiente orden:

1. Parámetros posicionales estándar.

2. Parámetros posicionales variables (*args).
3. Parámetros por defecto.
4. Parámetros nombrados variables (**kwargs).

Desempaquetado en llamadas: Los operadores * y ** también pueden usarse al in-

vocar funciones para desempaquetar listas/tuplas o diccionarios existentes directamente
como argumentos.

22
 title

1 def procesar_experimento (* mediciones , ** metadatos ) :

2 " " " Procesa un numero variable de lecturas y metadatos
asociados . " " "
3 promedio = sum ( mediciones ) / len ( mediciones ) if mediciones
else 0.0
4 sensor = metadatos . get ( " sensor " , " Desconocido " )
5 ubicacion = metadatos . get ( " ubicacion " , " N / A " )
6 return f " Sensor : { sensor } ({ ubicacion }) | Promedio : { promedio
:.2 f } "
7

8 # Invocacion pasando multiples valores posicionales y clave - valor

9 resultado = procesar_experimento (12.4 , 15.1 , 13.8 , sensor = " Temp_A "
, ubicacion = " Lab_1 " )
10

11 # Impresion de resultados
12 print ( resultado )

title
Sensor: Temp_A (Lab_1) | Promedio: 13.77

23
6. Programación Orientada a Objetos (POO)
6.1 Definición de Clases y Método __init__
Las clases actúan como plantillas o planos conceptuales para la creación de objetos. Permiten
agrupar bajo una misma entidad tanto el estado (representado mediante atributos) como el
comportamiento (definido mediante métodos).
Conceptos y reglas clave:

Definición de clases: Se utiliza la palabra clave class seguida del nombre de la clase
en convencion *PascalCase* (por ejemplo, Particula).

Método constructor (__init__): Es un método especial que se ejecuta automática-

mente al instanciar un nuevo objeto. Se utiliza para inicializar los atributos del estado
inicial.

El parámetro self: Representa la instancia concreta del objeto que se está creando o
manipulando. Debe ser obligatoriamente el primer parámetro de todos los métodos de
instancia.

title

1 # --- ESTRUCTURA BASICA DE UNA CLASE ---

2 class Particula :
3 def __init__ ( self , carga , masa ) :
4 self . carga = carga # Atributo de instancia
5 self . masa = masa # Atributo de instancia
6

7 # Instanciacion de objetos
8 p1 = Particula (1.6 e -19 , 9.11 e -31)
9

10 # Acceso a los atributos de la instancia

11 print ( f " Carga de la particula : { p1 . carga } C " )
12 print ( f " Masa de la particula : { p1 . masa } kg " )

title
Carga de la particula: 1.6e-19 C
Masa de la particula: 9.11e-31 kg

6.2 Atributos y Métodos de Instancia

Los atributos de instancia definen las propiedades individuales de cada objeto, mientras que
los métodos de instancia representan las acciones o comportamientos que dichos objetos pueden
ejecutar operando sobre sus propios datos a través de la referencia self.
Conceptos y reglas clave:

Referencia self: Permite al método acceder y modificar las variables de entorno aso-
ciadas a la instancia particular que lo invoca.

Invocación de métodos: Se realiza utilizando la notación de punto ([Link]()).

Python pasa de manera automática la instancia como primer argumento implícito (self).

24
 Encapsulamiento del comportamiento: Los métodos operan directamente sobre el
estado interno de la clase, promoviendo la cohesión y manteniendo el código organizado
y modular.

title

1 # --- METODOS DE INSTANCIA ---

2 class Vector2D :
3 def __init__ ( self , x , y ) :
4 self . x = x
5 self . y = y
6

7 def modulo ( self ) :

8 " " " Calcula la magnitud o modulo del vector 2 D . " " "
9 return ( self . x **2 + self . y **2) ** 0.5
10

11 # Instanciacion de un vector
12 v = Vector2D (3 , 4)
13

14 # Invocacion del metodo de instancia e impresion del resultado

15 print ( f " Modulo del vector (3 , 4) : { v . modulo () } " )

title
Modulo del vector (3, 4): 5.0

6.3 Herencia y Reutilización de Código

La herencia es un principio fundamental de la Programación Orientada a Objetos que per-
mite crear nuevas clases (subclases o clases hijas) a partir de clases existentes (superclases o
clases padres). Esto promueve la reutilización de código y facilita la jerarquización de conceptos.
Conceptos y reglas clave:

Sintaxis de herencia: Para derivar una clase, se especifica el nombre de la clase base
entre paréntesis tras el nombre de la subclase: class SubClase(SuperClase):.

Función super(): Devuelve un objeto proxy que delega las llamadas a métodos a la
superclase. Es esencial para invocar el constructor del padre (super().__init__(...))
e inicializar correctamente los atributos heredados.

Extensión y especialización: La subclase no solo hereda todos los atributos y métodos

de la superclase, sino que puede incorporar sus propios atributos adicionales y definir
comportamientos específicos.

25
 title

1 # --- HERENCIA Y EXTENSION DE CLASES ---

2 class CuerpoCeleste :
3 def __init__ ( self , nombre , masa ) :
4 self . nombre = nombre
5 self . masa = masa
6

7 class Planeta ( CuerpoCeleste ) :

8 def __init__ ( self , nombre , masa , radio ) :
9 super () . __init__ ( nombre , masa ) # Llamada al constructor
padre
10 self . radio = radio
11

12 # Instanciacion de la subclase Planeta

13 tierra = Planeta ( " Tierra " , 5.972 e24 , 6371.0)
14

15 # Verificacion de atributos heredados y propios

16 print ( f " Cuerpo celeste : { tierra . nombre } " )
17 print ( f " Masa : { tierra . masa } kg " )
18 print ( f " Radio medio : { tierra . radio } km " )

title
Cuerpo celeste: Tierra
Masa: 5.972e+24 kg
Radio medio: 6371.0 km

26
7. Tratamiento de Excepciones y Archivos
7.1 Control de Excepciones: try, except, else y finally
El manejo de excepciones permite interceptar y responder a errores que ocurren durante la
ejecución de un programa (*runtime errors*). Esto evita interrupciones abruptas del sistema y
garantiza un comportamiento controlado frente a entradas o circunstancias imprevistas.
Conceptos y reglas clave:

Bloque try: Enmarca el fragmento de código susceptible de generar un error o excepción

durante su ejecución.

Bloque except: Captura y procesa tipos de excepciones específicas. Es recomendable

atajar clases de excepciones concretas (como ZeroDivisionError o ValueError) en lugar
de excepciones genéricas.

Bloque else: Opcional. Se ejecuta de forma exclusiva si **no** se produjo ninguna

excepción dentro del bloque try.

Bloque finally: Opcional. Se ejecuta **siempre**, independientemente de si ocurrió o

no un error. Es ideal para tareas de limpieza y liberación de recursos.

title

1 # --- GESTION DE EXCEPCIONES ---

2 def realizar_division ( denominador_str ) :
3 try :
4 denominador = float ( denominador_str )
5 resultado = 100 / denominador
6 except ZeroDivisionError :
7 print ( " Error : No se puede dividir entre cero . " )
8 except ValueError :
9 print ( " Error : Debe ingresar un valor numerico valido . " )
10 else :
11 print ( f " Resultado exitoso : { resultado } " )
12 finally :
13 print ( " Operacion finalizada . " )
14

15 # Ejecucion controlada con prueba de concepto

16 realizar_division ( " 20 " )

title
Resultado exitoso: 5.0
Operacion finalizada.

27
7.2 Lectura y Escritura de Archivos (open, with)
El manejo de archivos de texto en Python se realiza mediante la función incorporada open().
Para asegurar un tratamiento seguro y eficiente de las fuentes de datos, se emplea la sentencia
with, la cual implementa el protocolo de gestores de contexto (*context managers*).
Conceptos y reglas clave:

Gestor de contexto (with): Garantiza la liberación e interrupción de los recursos del

sistema operativo (cerrando el archivo automáticamente) al finalizar el bloque, incluso si
se producen excepciones durante las operaciones de entrada/salida.

Modos de apertura principales:

• ’r’: Modo lectura (*read*). Es el modo predeterminado. Genera un error si el archivo

no existe.
• ’w’: Modo escritura (*write*). Crea el archivo si no existe o sobreescribe completa-
mente su contenido previo si ya existía.
• ’a’: Modo anexo (*append*). Añade nuevo contenido al final del archivo sin alterar
el ya existente.

Codificación de caracteres (encoding): Especificar encoding=ütf-8" previene incon-

sistencias de lectura/escritura al manipular caracteres especiales, acentos o tildes entre
distintos sistemas operativos.

title

1 # --- ESCRITURA Y LECTURA DE ARCHIVOS ---

2 # Escritura en modo texto ( ’ w ’)
3 with open ( " mediciones . txt " , " w " , encoding = " utf -8 " ) as f :
4 f . write ( " 10.5\ n20 .3\ n30 .8\ n " )
5

6 # Lectura linea por linea ( ’ r ’)

7 with open ( " mediciones . txt " , " r " , encoding = " utf -8 " ) as f :
8 lineas = f . readlines ()
9 valores = [ float ( l . strip () ) for l in lineas ]
10

11 # Procesamiento de datos procesados e impresion de resultados

12 print ( f " Valores leidos del archivo : { valores } " )
13 print ( f " Promedio de mediciones : { sum ( valores ) / len ( valores ) :.2 f } "
)

title
Valores leidos del archivo: [10.5, 20.3, 30.8]
Promedio de mediciones: 20.53

28
8. Librerías Estándar y Entorno Científico
8.1 Uso de Módulos Estándar (math, random)
La biblioteca estándar de Python incluye un amplio conjunto de módulos preinstalados que
extienden las capacidades base del lenguaje sin necesidad de instalar paquetes de terceros. Entre
los más representativos para el trabajo técnico y analítico se encuentran math y random.
Conceptos y reglas clave:

Módulo math: Proporciona acceso a funciones matemáticas de bajo nivel y constantes

numéricas fundamentales (como π o e). Ofrece operaciones trigonométricas, funciones
exponenciales, logarítmicas y funciones de redondeo de alta precisión.

Módulo random: Permite la generación de números pseudoaleatorios para simulaciones,

muestreos y pruebas.

Funciones representativas de random:

• random(): Genera un float aleatorio en el intervalo continuo [0,0, 1,0).

• randint(a, b): Genera un entero aleatorio en el intervalo discreto cerrado [a, b].
• choice(secuencia): Selecciona un elemento al azar a partir de una secuencia no
vacía.

title

1 import math
2 import random
3

4 # --- MODULO MATH ---

5 angulo_rad = math . radians (45)
6 seno = math . sin ( angulo_rad )
7 raiz = math . sqrt (16)
8

9 print ( f " Seno de 45 grados : { seno :.4 f } " )

10 print ( f " Raiz cuadrada de 16: { raiz } " )
11

12 # --- MODULO RANDOM ---

13 random . seed (42) # Fijacion de semilla para reproducibilidad
14 num_flotante = random . random () # Entre 0.0 y 1.0
15 num_entero = random . randint (1 , 6) # Simulacion de dado (1 a
6)
16 elemento = random . choice ([ " A " , " B " , " C " ]) # Seleccion aleatoria
17

18 print ( f " Flotante aleatorio : { num_flotante :.4 f } " )

19 print ( f " Resultado del dado : { num_entero } " )
20 print ( f " Elemento seleccionado : { elemento } " )

29
 title
Seno de 45 grados: 0.7071
Raiz cuadrada de 16: 4.0
Flotante aleatorio: 0.6394
Resultado del dado: 1
Elemento seleccionado: B

8.2 Introducción a NumPy para Cálculo Vectorial

NumPy es la biblioteca fundamental para el cálculo científico y numérico en Python. Su
estructura de datos principal es el arreglo multidimensional ndarray, el cual permite almacenar
datos homogéneos en memoria contigua y realizar operaciones matemáticas vectorializadas de
alto rendimiento sin necesidad de bucles explícitos.
Conceptos y reglas clave:

Estructura ndarray: Colección homogenea de datos que optimiza el acceso y la mani-

pulación en memoria a bajo nivel (escrito eficientemente en C).

Generación de arreglos: Funciones como [Link](), [Link]() o [Link]()

permiten inicializar estructuras numéricas de dimensiones concretas de forma rápida y
estructurada.

Vectorización y Broadcasting : Las operaciones elementales (+, *, [Link]()) se aplican

de forma paralela a cada elemento de la estructura, mejorando radicalmente la eficiencia
sintáctica y temporal.

Álgebra Lineal y Estadística: Incorpora operaciones de producto algebraico ([Link]())

y funciones estadísticas avanzadas ([Link](), [Link]()).

30
 title

1 import numpy as np
2

3 # --- CREACION DE ARRAYS VECTORIALES ---

4 arr = np . array ([1.0 , 2.0 , 3.0 , 4.0])
5 matriz = np . zeros ((3 , 3) ) # Matriz nula de 3 x3
6 espacio = np . linspace (0 , 10 , 100) # 100 puntos de 0 a 10
7

8 # --- OPERACIONES VECTORIZADAS ---

9 # Operaciones elemento a elemento ( sin bucles explicitos )
10 duplicados = arr * 2 # [2.0 , 4.0 , 6.0 , 8.0]
11 senos_vector = np . sin ( espacio )
12

13 # Producto matricial y estadistica

14 v1 = np . array ([1 , 2])
15 v2 = np . array ([3 , 4])
16 prod_escalar = np . dot ( v1 , v2 ) # 1 * 3 + 2 * 4 = 11
17

18 promedio = np . mean ( arr ) # 2.5

19 desviacion = np . std ( arr ) # 1.1180...
20

21 # Impresion de verificacion
22 print ( f " Vector duplicado : { duplicados } " )
23 print ( f " Producto escalar v1 . v2 : { prod_escalar } " )
24 print ( f " Promedio de arr : { promedio } " )
25 print ( f " Desviacion estandar de arr : { desviacion :.4 f } " )

title
Vector duplicado: [2. 4. 6. 8.]
Producto escalar v1 . v2: 11
Promedio de arr: 2.5
Desviacion estandar de arr: 1.1180

31