En el mundo de la programación con Python, las operaciones matemáticas básicas como la suma, resta, multiplicación y división son fundamentales. Sin embargo, Python ofrece operaciones adicionales que expanden nuestras posibilidades.
¿Cómo realizamos las operaciones matemáticas básicas en Python?
Primero, creamos dos variables: a con valor 10 y b con valor 3. Usamos comentarios para indicar que estamos trabajando con operadores numéricos. Imprimimos los resultados de las cuatro operaciones básicas:
a =10b =3print("Suma:", a + b)print("Resta:", a - b)print("Multiplicación:", a * b)print("División:", a / b)
¿Qué es el operador módulo y cómo se usa?
El operador módulo (%) obtiene el residuo de una división. Por ejemplo, 13 % 5 devuelve 3. En Python, se usa así:
a =13b =5print("Módulo:", a % b)
¿Qué sucede al dividir por cero en Python?
Dividir por cero genera un error. Para ilustrarlo:
a =10b =0try:print(a / b)except ZeroDivisionError:print("Error: División por cero")
¿Qué es la división de enteros y cómo se implementa?
La división de enteros (//) devuelve solo la parte entera de una división. Por ejemplo:
a =10b =3print("División Entera:", a // b)
¿Cómo se realiza la potenciación en Python?
La potenciación se representa con **. Para elevar 10 al cubo, usamos:
a =10b =3print("Potenciación:", a ** b)
¿Qué es PEMDAS y cómo afecta nuestras operaciones?
PEMDAS es la regla de prioridad de operaciones: Paréntesis, Exponentes, Multiplicación y División (de izquierda a derecha), Adición y Sustracción (de izquierda a derecha). Veamos un ejemplo:
operation =(2+3)*4print(operation)# Resultado: 20
¿Cómo se manejan los operadores booleanos en Python?
Los operadores booleanos comparan valores y devuelven True o False. Ejemplos:
Gente corriganme si estoy mal, pero según yo recuerdo el acrónimo PEMDAS es:
P -> Paréntesis
E -> Exponenciación
M -> Multiplicación
D -> División
A -> Adición
S -> Sustracción
Claro estó en función de la jerarquía para resolver problemas matemáticos.
Así es, también me quedé pensando cuando vi Potenciación y Matemáticas.
PEMDAS es unaregla que indica el orden correcto de operaciones en una expresión matemática. Es una abreviación de las palabras en inglés "Parentheses" (paréntesis), "Exponents" (exponentes), "Multiplication" (multiplicación), "Division" (división), "Addition" (suma) y "Subtraction" (resta).
Sin embargo en el Resumen de la clase si lo expresan de manera correcta.
Si, yo también me confundí en esa parte. Sobre todo cuando mencionó "matemáticas". Al inicio pensaba que era otra regla propia de python pero ya me di cuenta después que si se refería al orden de las operaciones.
Me están encantado tus apuntes, los estoy guardando todos en una carpeta para completarlos los míos ¡Grande Arnol!
¡Gracias por los apuntes!, son muy útiles para ver una síntesis de la clase
# OperadoresAritméticosa =5b =3print("Operadores Aritméticos")print(f"Suma: {a} + {b} = {a + b}") # Salida:8print(f"Resta: {a} - {b} = {a - b}") # Salida:2print(f"Multiplicación: {a} * {b} = {a * b}") # Salida:15print(f"División: {a} / {b} = {a / b}") # Salida:1.6666666666666667print(f"División Entera: {a} // {b} = {a // b}") # Salida:1print(f"Módulo: {a} % {b} = {a % b}") # Salida:2print(f"Potencia: {a} ** {b} = {a ** b}") # Salida:125print("\nOperadores de Comparación")print(f"Igual: {a} == {b} -> {a == b}") # Salida:Falseprint(f"Distinto: {a} != {b} -> {a != b}")# Salida:Trueprint(f"Mayor que: {a} > {b} -> {a > b}") # Salida:Trueprint(f"Menor que: {a} < {b} -> {a < b}") # Salida:Falseprint(f"Mayor o igual que: {a} >= {b} -> {a >= b}") # Salida:Trueprint(f"Menor o igual que: {a} <= {b} -> {a <= b}") # Salida:Falseprint("\nOperadores Lógicos")print(f"and: {a} > {b} and {a} > 0 -> {a > b and a > 0}") # Salida:Trueprint(f"or: {a} > {b} or {a} < 0 -> {a > b or a < 0}") # Salida:Trueprint(f"not: not({a} > {b}) -> {not(a > b)}") # Salida:Falseprint("\nOperadores de Asignación")c =10print(f"Asignación: c = {c}") # Salida:10c +=5print(f"Asignación de suma: c += 5 -> c = {c}") # Salida:15c -=3print(f"Asignación de resta: c -= 3 -> c = {c}") # Salida:12c *=2print(f"Asignación de multiplicación: c *= 2 -> c = {c}") # Salida:24c /=4print(f"Asignación de división: c /= 4 -> c = {c}") # Salida:6.0c %=3print(f"Asignación de módulo: c %= 3 -> c = {c}") # Salida:0.0c =10c //= 2print(f"Asignación de división entera: c //= 2 -> c = {c}") # Salida:5c **=3print(f"Asignación de potencia: c **= 3 -> c = {c}") # Salida:125print("\nOperadores Bit a Bit")print(f"AND: {a} & {b} -> {a & b}") # Salida:1print(f"OR: {a} | {b} -> {a | b}") # Salida:7print(f"XOR: {a} ^ {b} -> {a ^ b}") # Salida:6print(f"NOT: ~{a} -> {~a}") # Salida:-6print(f"Desplazamiento a la izquierda: {a} << 1 -> {a << 1}") # Salida:10print(f"Desplazamiento a la derecha: {a} >> 1 -> {a >> 1}") # Salida:2```Salida OperadoresAritméticosSuma:5+3=8Resta:5-3=2Multiplicación:5 \*3=15División:5/3=1.6666666666666667DivisiónEntera:5// 3 = 1Módulo:5%3=2Potencia:5 \*\*3=125Operadores de ComparaciónIgual:5==3->FalseDistinto:5!=3->TrueMayor que:5>3->TrueMenor que:5<3->FalseMayor o igual que:5>=3->TrueMenor o igual que:5<=3->FalseOperadoresLógicos
and:5>3 and 5>0->Trueor:5>3 or 5<0->Truenot:not(5>3)->FalseOperadores de AsignaciónAsignación: c =10Asignación de suma: c +=5-> c =15Asignación de resta: c -=3-> c =12Asignación de multiplicación: c \*=2-> c =24Asignación de división: c /=4-> c =6.0Asignación de módulo: c %=3-> c =0.0Asignación de división entera: c //= 2 -> c = 5Asignación de potencia: c \*\*=3-> c =125OperadoresBit a BitAND:5&3->1OR:5|3->7XOR:5^3->6NOT:~5->-6Desplazamiento a la izquierda:5<<1->10Desplazamiento a la derecha:5>>1->2
Debes corregir la parte de los comentarios con las triples comillas simples (o dobles) a partir de Salida y luego también agregar las triples comillas simples (o dobles) al final.
Excellent!
En Chile es conocido como PAPOMUDAS el santo grial de la algebra
PA-rentesis -> Paréntesis
PO-tencias -> Exponenciación
MU-ltiplicacion -> Multiplicación
DI-vision-> División
A-dicion**** -> Adición
S-ustraccion -> Sustracción
Dejo aqui un pequeño ejercicio para prácticar el Orden de Evaluación de los Operadores Matemáticos:
resultado = 16 - 2 * 5 // 3 + 1
14 😇
14.333...
ejercicios con .format y f"string"
# Operadore Aritmeticos # Dentro de las matematicas hay operaciones basicas como lo son la suma, resta, divición, multiplicacion# pero python agrega 3 operadores.a =10b =3print("Suma:", a + b)print("Resta:", a - b)print("Divición:", a / b)print("Multiplicación:", a * b)# Modulo - Nos da el RESTO de una divicion (%)print("Modulo:", a % b)# Exponenciación - Eleva la potencia de un numero (**)print("Exponenciación:", a ** b)# Divición de enteros - Nos da la nos devuelve el resultado ENTERO (sin los decimales) de una divicion (//)print("divicion de enteros:", a // b)# Shortcuts - es un modo de abreviar operaciones comunes , simplificar codigo.# Incremento (+=)x =5x +=2print(x)# Decremento (-=)y =5y -=3print(y)# Multiplicaion (*=)z =5z *=3print(z)# Divicion (/=)e =5e /=5print(e)# Modulo (%=)t =14t %=4print(t)# PENDAS - Es conocido en matematicas como jerarquia de operaciones, dende se va a operar las operaciones dendiendo del orden de estas.# parentheses, exponents, multiply, divide, add and subtract.operation_3 =(2+3)*(4**2)/8-1print(operation_3)
Me llamó particularmente la atención el acrónimo PEMDAS ( Paréntesis, Exponentes, Multiplicación, División, Adición y Substracción) donde claramente podemos identificar el orden en el cual se realizan las operaciones. Esto aplica en el campo de la matemática en general. Algo completamente excelente para no confundirse mas al respecto.
Alguien me ayuda porque de forma automatica se pone los subtitulos lo quito y sige apareciendo en cada video :(
Junto a la velocidad de reproducción (1x), de lado derecho es el ícono inmediato, le das clic y deshabilitas los subtitulos(off) :)
Explico un poco mejor el concepto de "Módulo" por si a alguien le interesa, cuando la profe da el ejemplo de la división de 13 / 5, tenenmos que entender que 5 solo cabe dos veces en 13; es decir, 5 x 2 = 10, y nos quedarían haciendo falta 3 para llegar a 13. Estas 3 unidades que nos quedan haciendo falta es el resultado que representa la función "Módulo" EJ:
print("Módulo:", 13 % 5)
Modulo: 3
Operadores aritméticos:
+Suma
-Resta
*Multiplicación
/División
%Módulo
//División Entera
**Potenciación
Hay un error en la parte de explicar PEMDAS
la M es multiplicacion y no Matematicas:
Cada letra representa un tipo de operación, en orden de prioridad:
P → Parentheses (Paréntesis)
E → Exponents (Exponentes o potencias, raíces, etc.)
M → Multiplication (Multiplicación)
D → Division (División)
A → Addition (Suma)
S → Subtraction (Resta)
Entonces imparte tú la clase
Si se Permire la potencializaon, el modulo, parte entera
🤓 En esta clase aprendi las operaciones matemáticas esenciales en Python, desde lo más básico hasta conceptos como PEMDAS y operadores booleanos, que son fundamentales para programar eficientemente.
Lo más destacado:
✅ Explicación práctica con ejemplos sencillos (a = 10, b = 3) que facilitan la comprensión.
✅ Operadores poco conocidos como el módulo (%) y la división entera (//), muy útiles en algoritmos y programación competitiva.
✅ Manejo de errores (ej. división por cero con try-except) y buenas prácticas para evitar problemas comunes.
✅ Regla PEMDAS explicada de manera concisa, clave para evitar confusiones en operaciones complejas.
✅ Operadores booleanos (>, <, ==, !=) aplicados en comparaciones reales, esenciales para condicionales y bucles.
Agrego:
Ejemplo aplicado: Mostrar un caso real donde el módulo (%) sea útil (ej. verificar si un número es par: if num % 2 == 0).
🔹 Math vs. Operadores básicos: Mencionar brevemente cuándo usar la librería math (ej. raíces, logaritmos) vs. operadores nativos (** para potencias).
Exponenciacion y potenciacion no son similares?
son el mismo concepto
Matemáticamente es lo mismo, el concepto cambia en base al problema
x ** 3 // Potenciacion
3 ** x // Exponenciacion
Técnicamente es lo mismo
La operación módulo, representada por el signo %, devuelve el residuo de la división entre dos números. Por ejemplo, en Python, 10 % 3 resulta en 1, ya que al dividir 10 entre 3, el residuo es 1. Es útil para determinar si un número es par o impar, dado que un número es par si es divisible por 2 (residuo 0). En programación, manejar correctamente el módulo es fundamental para evitar errores, especialmente con divisiones que involucran cero.
5*3+1``````js
Operadores aritméticos básicos:
Suma (+):a + b
Resta (-):a - b
Multiplicación (*):a * b
División (/):a / b (resultado con decimales)
División entera (//):a // b (resultado entero, trunca la parte decimal)
Módulo (%):a % b (resto de la división)
Potencia ():** a ** b (a elevado a la potencia b)
Ejemplo:
Pythona = 10b = 3
suma = a + b # suma = 13resta = a - b # resta = 7multiplicacion = a * b # multiplicacion = 30division = a / b # division = 3.3333333333333335division_entera = a // b # division_entera = 3modulo = a % b # modulo = 1potencia = a ** b # potencia = 1000
Orden de las operaciones:
Python sigue el orden estándar de las operaciones matemáticas (PEMDAS/BODMAS):
Paréntesis: ()
Potencias: **
Multiplicación y División: *, /, //, % (de izquierda a derecha)
Suma y Resta: +, - (de izquierda a derecha)1
Funciones matemáticas adicionales:
El módulo math de Python proporciona funciones matemáticas más avanzadas:
Utiliza paréntesis para clarificar el orden de las operaciones, especialmente en expresiones complejas.
Explora la documentación del módulo math para descubrir más funciones matemáticas.
Practica con ejemplos para familiarizarte con las operaciones matemáticas en Python.
En el último caso donde la profesora comparó:
a = 10
b = 10.0
La comparación a == b) da True, porque Python hace una conversión implícita de tipo de dato (del valor de a (que es 10) a 10.0 (dado que el tipo float es más general que int)
Si hacemos una comparación explícita así:
a = 10
b = 10.0
# Comparación estricta entre tipo y valor
print(a == b and type(a) == type(b))
Da False, dado que una de las condiciones no se cumple: el tipo de dato. Uno es int y el otro es float.
Espero que les sirva.
a = 10b = 3
print(f'Suma {a} + {b} = {a + b}')print(f'Resta {a} - {b} = {a - b}')print(f'Multiplicación {a} * {b} = {a * b}')print(f'División {a} / {b} = {a / b}')print(f'Modulo {a} % {b} = {a % b}')print(f'Parte entera de la división {a} // {b} = {a // b}')print(f'Potenciación {a} ** {b} = {a ** b}')
a += 2print(f'Resultado de a Incrementar el valor de una variable 10 += 2 = {a}')
a = 10a -= 2print(f'Resultado de a Incrementar el valor de una variable 10 -= 2 = {a}')
a = 10a /= 2print(f'Resultado de a Incrementar el valor de una variable 10 /= 2 = {a}')
a = 10a *= 2print(f'Resultado de a Incrementar el valor de una variable 10 *= 2 = {a}')
print(f'Resultado de la operación (2+3) * (4**2) / 8 - 1 = {( 2 + 3) * ( 4 ** 2) / 8 - 1} ')
