Fundamentos de Programación y Python
¿Por qué aprender Python?
Introducción a Python
Conceptos Básicos de Programación
Práctica: Te doy la bienvenida a los ejercicios interactivos
Manipulación de Cadenas de Texto en Python
Enteros, Flotantes y Booleanos
Todo lo que Debes Saber sobre print en Python
Operaciones Matemáticas en Python
Operaciones de Entrada/Salida en Consola
Colección y Procesamiento de Datos en Python
Listas
Método slice
Listas de más dimensiones y Tuplas
Aplicación de Matrices
Diccionarios
Comprehension Lists en Python (CLASE NUEVA)
Control de Flujo en Python
Estructuras condicionales
Bucles y Control de Iteraciones
Generadores e Iteradores
Funciones y Manejo de Excepciones en Python
Uso de Funciones en Python
Funciones Lambda y Programación Funcional en Python
¿Cómo realizar una función recursiva en Python?
Manejo de Excepciones y Uso de Pass (CLASE NUEVA)
Programación Orientada a Objetos en Python
Fundamentos de Programación Orientada a Objetos en Python
Ejercicio Biblioteca con POO
Herencia en POO con Python
Objetos heredados
Los 4 pilares de la programacion orientada a objetos
Uso de super() en Python (CLASE NUEVA)
Superando los Fundamentos de Programación Orientada a Objetos en Python
Lectura y escritura de archivos
Manejo de Archivos .TXT (CLASE NUEVA)
Manejo de Archivos CSV (CLASE NUEVA)
Manejo de Archivos JSON (CLASE NUEVA)
Biblioteca estándar de Python
Biblioteca estándar en Python (CLASE NUEVA)
Librería Os, Math y Random (CLASE NUEVA)
Librería Statistics y Análisis Estadístico (CLASE NUEVA)
Proyecto final: Guerra naval
Conceptos avanzados de Python
Recapitulación de lo aprendido hasta ahora
Escribir código Pythonico y profesional
Comentarios y Docstrings en Python
Scope y closures: variables locales y globales
Anotaciones de tipo
Validación de tipos en métodos
Librería Collections y Enumeraciones
Decoradores
Decoradores en Python
Decoradores anidados y con parámetros
Uso de Decoradores en clases y métodos
Métodos y estructura de clases en Python
Métodos mágicos
Sobrecarga de operadores
Implementación de `if __name__ == "__main__":`
Metaprogramación en Python
Uso de *args y **kwargs
Métodos privados y protegidos
Gestión avanzada de propiedades
Métodos estáticos y de clase avanzados
Programación concurrente y asíncrona
Introducción a la concurrencia y paralelismo
Threading y multiprocessing en Python
Asincronismo con asyncio
Asincronismo y concurrencia
Creación de módulos y paquetes
Creación de módulos en Python
Gestión de paquetes
Publicación de paquetes en PyPI
Proyecto final
Implementación de un sistema completo
Implementación de un Sistema Completo
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
No se trata de lo que quieres comprar, sino de quién quieres ser. Invierte en tu educación con el precio especial
Antes: $249
$209
Paga en 4 cuotas sin intereses
Termina en:
12 Días
15 Hrs
43 Min
43 Seg
Operaciones Matemáticas en Python
8/63Recursos
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 = 10
b = 3
print("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 = 13
b = 5
print("Módulo:", a % b)
¿Qué sucede al dividir por cero en Python?
Dividir por cero genera un error. Para ilustrarlo:
a = 10
b = 0
try:
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 = 10
b = 3
print("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 = 10
b = 3
print("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) * 4
print(operation) # Resultado: 20
¿Cómo se manejan los operadores booleanos en Python?
Los operadores booleanos comparan valores y devuelven True o False. Ejemplos:
a = 10
b = 3
print(a > b) # True
print(a < b) # False
print(a == b) # False
print(a != b) # True
Estos operadores nos ayudan a tomar decisiones en el código, permitiendo crear condiciones y bucles efectivos.
Aportes 45
Preguntas 4
Ordenar por:
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.
```js
# Operadores Aritméticos
a = 5
b = 3
print("Operadores Aritméticos")
print(f"Suma: {a} + {b} = {a + b}") # Salida: 8
print(f"Resta: {a} - {b} = {a - b}") # Salida: 2
print(f"Multiplicación: {a} * {b} = {a * b}") # Salida: 15
print(f"División: {a} / {b} = {a / b}") # Salida: 1.6666666666666667
print(f"División Entera: {a} // {b} = {a // b}") # Salida: 1
print(f"Módulo: {a} % {b} = {a % b}") # Salida: 2
print(f"Potencia: {a} ** {b} = {a ** b}") # Salida: 125
print("\nOperadores de Comparación")
print(f"Igual: {a} == {b} -> {a == b}") # Salida: False
print(f"Distinto: {a} != {b} -> {a != b}")# Salida: True
print(f"Mayor que: {a} > {b} -> {a > b}") # Salida: True
print(f"Menor que: {a} < {b} -> {a < b}") # Salida: False
print(f"Mayor o igual que: {a} >= {b} -> {a >= b}") # Salida: True
print(f"Menor o igual que: {a} <= {b} -> {a <= b}") # Salida: False
print("\nOperadores Lógicos")
print(f"and: {a} > {b} and {a} > 0 -> {a > b and a > 0}") # Salida: True
print(f"or: {a} > {b} or {a} < 0 -> {a > b or a < 0}") # Salida: True
print(f"not: not({a} > {b}) -> {not(a > b)}") # Salida: False
print("\nOperadores de Asignación")
c = 10
print(f"Asignación: c = {c}") # Salida: 10
c += 5
print(f"Asignación de suma: c += 5 -> c = {c}") # Salida: 15
c -= 3
print(f"Asignación de resta: c -= 3 -> c = {c}") # Salida: 12
c *= 2
print(f"Asignación de multiplicación: c *= 2 -> c = {c}") # Salida: 24
c /= 4
print(f"Asignación de división: c /= 4 -> c = {c}") # Salida: 6.0
c %= 3
print(f"Asignación de módulo: c %= 3 -> c = {c}") # Salida: 0.0
c = 10
c //= 2
print(f"Asignación de división entera: c //= 2 -> c = {c}") # Salida: 5
c **= 3
print(f"Asignación de potencia: c **= 3 -> c = {c}") # Salida: 125
print("\nOperadores Bit a Bit")
print(f"AND: {a} & {b} -> {a & b}") # Salida: 1
print(f"OR: {a} | {b} -> {a | b}") # Salida: 7
print(f"XOR: {a} ^ {b} -> {a ^ b}") # Salida: 6
print(f"NOT: ~{a} -> {~a}") # Salida: -6
print(f"Desplazamiento a la izquierda: {a} << 1 -> {a << 1}") # Salida: 10
print(f"Desplazamiento a la derecha: {a} >> 1 -> {a >> 1}") # Salida: 2
```Salida
Operadores Aritméticos
Suma: 5 + 3 = 8
Resta: 5 - 3 = 2
Multiplicación: 5 \* 3 = 15
División: 5 / 3 = 1.6666666666666667
División Entera: 5 // 3 = 1
Módulo: 5 % 3 = 2
Potencia: 5 \*\* 3 = 125
Operadores de Comparación
Igual: 5 == 3 -> False
Distinto: 5 != 3 -> True
Mayor que: 5 > 3 -> True
Menor que: 5 < 3 -> False
Mayor o igual que: 5 >= 3 -> True
Menor o igual que: 5 <= 3 -> False
Operadores Lógicos
and: 5 > 3 and 5 > 0 -> True
or: 5 > 3 or 5 < 0 -> True
not: not(5 > 3) -> False
Operadores de Asignación
Asignación: c = 10
Asignación de suma: c += 5 -> c = 15
Asignación de resta: c -= 3 -> c = 12
Asignación de multiplicación: c \*= 2 -> c = 24
Asignación de división: c /= 4 -> c = 6.0
Asignación de módulo: c %= 3 -> c = 0.0
Asignación de división entera: c //= 2 -> c = 5
Asignación de potencia: c \*\*= 3 -> c = 125
Operadores Bit a Bit
AND: 5 & 3 -> 1
OR: 5 | 3 -> 7
XOR: 5 ^ 3 -> 6
NOT: ~5 -> -6
Desplazamiento a la izquierda: 5 << 1 -> 10
Desplazamiento a la derecha: 5 >> 1 -> 2
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`
Alguien me ayuda porque de forma automatica se pone los subtitulos lo quito y sige apareciendo en cada video :(
ejercicios con .format y f"string"
En el último caso donde la profesora comparó:
`a = 10`
`b = 10.0`
La comparación [`a == b`](javascript:void\(0\)) 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} ')
Excelente
Se superaron con la Edición WOW!!!!
Resultado de los artifícios ( + , - , \* , / ):
1. a += 2 -> 12
2. a -= 2 -> 8
3. a \*= 2 -> 20
4. a /= 2 -> 5.0
El módulo en Python se refiere a la operación del resto de una división, representada por el signo `%`. Por ejemplo, `10 % 3` devuelve `1`, ya que 10 dividido entre 3 da un cociente de 3 y un resto de 1. Es útil cuando deseas conocer lo que "sobra" de una división. Es importante tener cuidado con divisiones por cero, ya que esto generará un error (`ZeroDivisionError`).
Si deseas profundizar, puedes experimentar con diferentes números y ver sus resultados.
si desean ampliar o buscar otras fuentes esto se llama jerarquia de operadores matematicos
valor = 5
valor1 = 10
print ("suma", valor + valor1)
print ("resta", valor - valor1)
print ("multiplicacion", valor \* valor1)
print ("division", valor / valor1)
print ("potenciacion", valor \*\* valor1)
valor = valor + 5
print (valor)
Por usa el dobre ==? por qué no usar solo uno?
También se conoce como PAPOMUDAS
Paréntesis, Potencias, Multiplicación, División, Adición, Sustracción.
Multiplicación y división tienen la misma jerarquía. Si aparecen juntos se resuelve de izquierda a derecha.
Adición y Sustracción tienen la misma jerarquía. Si aparecen juntos se resuelve de izquierda a derecha.
Para hacer plots en Python, puedes usar la biblioteca `matplotlib`. Aquí tienes un ejemplo básico:
```python
import matplotlib.pyplot as plt
# Datos
x = [1, 2, 3, 4, 5]
y = [2, 3, 5, 7, 11]
# Crear el plot
plt.plot(x, y)
plt.title('Gráfico de ejemplo')
plt.xlabel('Eje X')
plt.ylabel('Eje Y')
plt.show()
```
Recuerda instalar `matplotlib` si no lo tienes, usando `pip install matplotlib`. Puedes profundizar en el uso de gráficos con los materiales disponibles en Platzi.
me podrian ayudar a entender cual es el resultado de la operacion: a % b
gracias.
Haciendo una breve búsqueda, pueden asociar estas formas abreviadas de escritura de operaciones matemáticas como 'Operadores de asignación compuesta'; existen para las diferentes operaciones que hemos visto hasta ahora:
Suma: +=
Resta: -=
Multiplicación: \*=
División estándar: /=
División de parte entera: //=
Módulo: %=
Potencia: \*\*=
La verdad, me parece una forma sofisticada de manejar estas operaciones, ya que, al lado derecho del igual, se indica el valor que se aplicará al número sobre el cual ejercemos la operación.
¡Hola!
Es importante comentarles que la sección de *Operadores Booleanos* que menciona la profe Carli alrededor del minuto 9:00 del respectivo vídeo, podría ser confusa.
Leyendo la documentación de Python (https://docs.python.org/es/) las operaciones booleanas están definidas por `and`, `or` y `not`; y los ejemplos que ella nos comparte están relacionados al uso de los operadores de comparación en Python (`<`, `<=`, `>` , `>=`, `==`, `!=`, `is` e `is not`).
Les dejo los hipervínculos por si alguien quiere leer más al respecto sobre ambos temas:
**Operaciones Booleanas and, or, not**
<https://docs.python.org/es/3.10/library/stdtypes.html#boolean-operations-and-or-not>
**Comparaciones**
<https://docs.python.org/es/3.10/library/stdtypes.html#comparisons>
Les envío un saludo y espero les caiga bien esta información que rescaté, 🎣!
Gente no se vayan a confundir con el Algebra de la ecuación en el min 8:40, yo estaba sacando un resultado de 11.42 en lugar de 9
la ecuación es así:
```python
number1 = 10
number2 = 5
print("Operaciones Matemáticas en Python:")
print(f"Suma {number1} + {number2}:", number1 + number2)
print(f"Resta {number1} - {number2}:", number1 - number2)
print(f"Multiplicación {number1} * {number2}:", number1 * number2)
print(f"División {number1} / {number2}:", number1 / number2)
print(f"División Entera {number1} // {number2}:", number1 // number2)
print(f"Módulo {number1} % {number2}:", number1 % number2)
print(f"Potencia {number1} ** {number2}:", number1 ** number2)
print(f"Raíz cuadrada de {number1}:", number1 ** 0.5)
print(f"Raíz cúbica de {number1}:", number1 ** (1/3))
# Operadores de Asignación
print("\n")
print("Operadores de Asignación")
number3 = 10
number3 += 5
number3 -= 5
number3 *= 5
number3 /= 5
number3 //= 5
number3 %= 5
number3 **= 5
print(number3)
# ¿Qué es PEMDAS y cómo afecta nuestras operaciones?
print("\n")
print("PEMDAS:")
print("Es la regla de prioridad de operaciones: ")
print("Paréntesis, Exponentes, Multiplicación y División, Adición y Sustracción")
operation1 = 3 + 2 * 5
print("3 + 2 * 5 = ", operation1)
operation2 = (3 + 2) * 5
print("(3 + 2) * 5 = ", operation2)
operation3 = (2+3) * (4**2) / 8 - 1
print("(2+3) * (4**2) / 8 - 1 = ", operation3)
operation4 = (2+3) * (4**2) / (8 - 1)
print("(2+3) * (4**2) / (8 - 1) = ", operation4)
# Operadores Booleanos
print("\n")
print("Operadores Booleanos")
a = 10
b = 5
print(f"{a} > {b}: ", a > b)
print(f"{a} < {b}: ", a < b)
print(f"{a} >= {b}: ", a >= b)
print(f"{a} <= {b}: ", a <= b)
print(f"{a} == {b}: ", a == b)
print(f"{a} != {b}: ", a != b)
```number1 = 10number2 = 5
print("Operaciones Matemáticas en Python:")print(f"Suma {number1} + {number2}:", number1 + number2)print(f"Resta {number1} - {number2}:", number1 - number2)print(f"Multiplicación {number1} \* {number2}:", number1 \* number2)print(f"División {number1} / {number2}:", number1 / number2)print(f"División Entera {number1} // {number2}:", number1 // number2)print(f"Módulo {number1} % {number2}:", number1 % number2)print(f"Potencia {number1} \*\* {number2}:", number1 \*\* number2)print(f"Raíz cuadrada de {number1}:", number1 \*\* 0.5) print(f"Raíz cúbica de {number1}:", number1 \*\* (1/3))
\# Operadores de Asignaciónprint("\n")print("Operadores de Asignación")number3 = 10number3 += 5number3 -= 5number3 \*= 5number3 /= 5number3 //= 5number3 %= 5number3 \*\*= 5print(number3)
\# ¿Qué es PEMDAS y cómo afecta nuestras operaciones?print("\n")print("PEMDAS:")print("Es la regla de prioridad de operaciones: ")print("Paréntesis, Exponentes, Multiplicación y División, Adición y Sustracción")operation1 = 3 + 2 \* 5print("3 + 2 \* 5 = ", operation1)
operation2 = (3 + 2) \* 5print("(3 + 2) \* 5 = ", operation2)
operation3 = (2+3) \* (4\*\*2) / 8 - 1print("(2+3) \* (4\*\*2) / 8 - 1 = ", operation3)operation4 = (2+3) \* (4\*\*2) / (8 - 1)print("(2+3) \* (4\*\*2) / (8 - 1) = ", operation4)
\# Operadores Booleanosprint("\n")print("Operadores Booleanos")a = 10b = 5print(f"{a} > {b}: ", a > b)print(f"{a} < {b}: ", a < b)print(f"{a} >= {b}: ", a >= b)print(f"{a} <= {b}: ", a <= b)print(f"{a} == {b}: ", a == b)print(f"{a} != {b}: ", a != b)
Muy buena explicación.
Muy buena explicación del uso de los operadores matemáticos
## Operaciones matemáticas en Python
🔶print("Módulo:", a % b)
Se refiere al sobrante de una división
🔶 print("Parte entera de la división:", a // b)
Se refiere a la parte que queda entera de una división (como su nombre lo indica)
🔶print("Potenciación:", a \*\* b)
Elevar un número a una potencia
🔶Shortcurts
a += 2
Evitamos poner toda la suma y solo agregamos después del nombre de la variable, el signo, se puede hacer con los demás signos.
🔶 Python siempre sigue las regla PEMDAS, a menos de que tú le indiques con paréntesis lo contrario.
```python
a=10;b=3
print("Suma:{}\n Resta:{} \nMulti:{} \nDivi{}\nDivEntero:{}\nModulo:{}".format((a+b),(a-b),(a*b),(a/b),(a//b),(a%b)))
```
```js
a=10;b=3
print("Suma:{}\n Resta:{} \nMulti:{} \nDivi{}\nDivEntero:{}\nModulo:{}".format((a+b),(a-b),(a*b),(a/b),(a//b),(a%b)))
```a=10;b=3print("Suma:{}\n Resta:{} \nMulti:{} \nDivi{}\nDivEntero:{}\nModulo:{}".format((a+b),(a-b),(a\*b),(a/b),(a//b),(a%b)))
Me queda mas claro en esta clase el concepto de las operaciones en python
Me parece que los operadores proceden de forma normal con los atajos, excepeto el operador //= que solo divide entre 2:
```js
a = 10
a = a + 2
print(a)
#12
a += 2
print(a)
#14
a -= 2
print(a)
#12
a *= 2
print(a)
#24
a **= 2
print(a)
#576
a /= 2
print(a)
#288.0
a //= 2
print(a)
#144.0
a %= 2
print(a)
#0.0
```
Buenas noches Karla Florida
Hice la tarea de probar los artificios matemáticos con los demás operadores matemáticos.
Y se cumplen también.
Así quedo el código y los resultados.
a = 10
a %= 3
print (a)
Resultado = 1
a = 10
a //= 3
print (a)
Resultado = 3
a = 10
a \*\*= 3
print (a)
Resultado = 1000
PEMDAS:
P = Paréntesis. (no potenciación)
E = Exponenciación.
M = Multiplicación (no matemáticas lol)
D = División.
A = Adición.
S= Sustracción.
Saludos.
Recuerden que existen Operadores Aritméticos y otros como lo son los Operadores Lógicos, los cuales son los siguientes:
Saludos
Me ha parecido una joya los Shortcuts, muy útiles
`#Operadores numericos`
`a= 10`
`b= 3`
`print("Suma:", a+b)`
`print("Resta:", a-b)`
`print("Multiplicación:", a*b)`
`print("División:", a/b)`
`print("Moddulo o resto:", a%b) # modulo l resto es para lo que sobra en una division `
`print("Entero de la división:", a//b) # la dobke division no es que divida dos veces es que solo me da los numeros enteres`
`print("potenciació :", a**b) # el doble asterisco sirve para elevar ala potencia aqui seria 1 al cubo`
`a= a +2`
`print(a)`
`a+= 2`
`print(a)`
`a-= 2`
`print(a)`
`a*= 2`
`print(a)`
`a/=2`
`print("A vale:",a)`
`#PEMDAS`
`# La regla PEMDAS dice que:`
`#orden de operaciones`
`# Parentheses (Paréntesis)`
`# Exponents (Exponenciación y raíces)`
`# Multiplication (Multiplicación)`
`# Division (División)`
`# Addition (Suma)`
`# Subtraction (Resta)`
`operacion1 = 2+3*4`
`print(operacion1)`
`operacion2 = 2+(3*4)`
`print(operacion2)`
`operacion3 = (2+3)*(4**2) / 8 -1`
`print(operacion3)`
`#operadores booleanos o de comparación`
`print (a>b) #Evalua si a es mayor que b y devuelve si eso es falso o verdadero`
`print (a<b) #Evalua si a es menor que b y devuelve si eso es falso o verdadero`
`print (a>=b) #Evalua si a es mayor o igual que b y devuelve si eso es falso o verdadero`
`print (a<=b) #Evalua si a es menor o igual que b y devuelve si eso es falso o verdadero`
`print (a==b) #Evalua si a es igual que b y devuelve si eso es falso o verdadero`
`print (a!=b) #Evalua si a es diferente que b y devuelve si eso es falso o verdadero`
```python
# Operadore Aritmeticos
# Dentro de las matematicas hay operaciones basicas como lo son la suma, resta, divición, multiplicacion
# pero python agrega 3 operadores.
a = 10
b = 3
print("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 = 5
x += 2
print(x)
# Decremento (-=)
y = 5
y -= 3
print(y)
# Multiplicaion (*=)
z = 5
z *= 3
print(z)
# Divicion (/=)
e = 5
e /= 5
print(e)
# Modulo (%=)
t = 14
t %= 4
print(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 - 1
print(operation_3)
```
siempre me resulata util comentar el codigo para saber que es lo que hace cada parte ![]()![]()![]()```python
a = 10
b = 3
print("en las comparaciones te devuelve un booleano, si es verdaero o falso")
print(a > b)#aqui se compara si a es mayor que b
print(a < b)#aqui se compara si a es menor que b
print(a >= b)#aqui se compara si a es mayor o igual que b
print(a <= b)#aqui se compara si a es menor o igual que b
print(a == b)#aqui se compara si a es igual que b
print(a != b)#aqui se compara si a es diferente que b
```
Para curiosidad si se preguntan para que se puede usar el % modulo prácticamente, lo podemos usar en un programa para saber entre una cantidad de números cuales son pares e impares
```python
# jerarquia de operadores
print(2 ** 3 + 3 - 7 / 1 // 4)
"""
P = paréntesis ()
E = exponentes
M = multiplicación
D = división
A = adicción
S = sustración
"""
print(2 ** 3)
print((7 / 1) // 4)
print(8 + 3 - 1)
```
```python
# jerarquia de operadores
print(2 ** 3 + 3 - 7 / 1 // 4)
"""
P = paréntesis ()
E = exponentes
M = multiplicación
D = división
A = adicción
S = sustración
"""
print(2 ** 3)
print((7 / 1) // 4)
print(8 + 3 - 1)
#print(10 / 0)
```# jerarquia de operadores
print(2 \*\* 3 + 3 - 7 / 1 // 4)
"""
P = paréntesis ()
E = exponentes
M = multiplicación
D = división
A = adicción
S = sustración
"""
print(2 \*\* 3)
print((7 / 1) // 4)
print(8 + 3 - 1)
\#print(10 / 0)
1. Suma: a+b
2. Resta: a-b
3. Multiplicación: a\*b
4. División: a/b
5. Módulo(resto en una división): a%b
6. Parte entera de división: a//b
7. Potenciación: a\*\*b
\# Operadores Aritméticos
a = 5
b = 3
print("Operadores Aritméticos")
print(f"Suma: {a} + {b} = {a + b}") # Salida: 8
print(f"Resta: {a} - {b} = {a - b}") # Salida: 2
print(f"Multiplicación: {a} \* {b} = {a \* b}") # Salida: 15
print(f"División: {a} / {b} = {a / b}") # Salida: 1.6666666666666667
print(f"División Entera: {a} // {b} = {a // b}") # Salida: 1
print(f"Módulo: {a} % {b} = {a % b}") # Salida: 2
print(f"Potencia: {a} \*\* {b} = {a \*\* b}") # Salida: 125
print("\nOperadores de Comparación")
print(f"Igual: {a} == {b} -> {a == b}") # Salida: False
print(f"Distinto: {a} != {b} -> {a != b}")# Salida: True
print(f"Mayor que: {a} > {b} -> {a > b}") # Salida: True
print(f"Menor que: {a} < {b} -> {a < b}") # Salida: False
print(f"Mayor o igual que: {a} >= {b} -> {a >= b}") # Salida: True
print(f"Menor o igual que: {a} <= {b} -> {a <= b}") # Salida: False
print("\nOperadores Lógicos")
print(f"and: {a} > {b} and {a} > 0 -> {a > b and a > 0}") # Salida: True
print(f"or: {a} > {b} or {a} < 0 -> {a > b or a < 0}") # Salida: True
print(f"not: not({a} > {b}) -> {not(a > b)}") # Salida: False
print("\nOperadores de Asignación")
c = 10
print(f"Asignación: c = {c}") # Salida: 10
c += 5
print(f"Asignación de suma: c += 5 -> c = {c}") # Salida: 15
c -= 3
print(f"Asignación de resta: c -= 3 -> c = {c}") # Salida: 12
c \*= 2
print(f"Asignación de multiplicación: c \*= 2 -> c = {c}") # Salida: 24
c /= 4
print(f"Asignación de división: c /= 4 -> c = {c}") # Salida: 6.0
c %= 3
print(f"Asignación de módulo: c %= 3 -> c = {c}") # Salida: 0.0
c = 10
c //= 2
print(f"Asignación de división entera: c //= 2 -> c = {c}") # Salida: 5
c \*\*= 3
print(f"Asignación de potencia: c \*\*= 3 -> c = {c}") # Salida: 125
print("\nOperadores Bit a Bit")
print(f"AND: {a} & {b} -> {a & b}") # Salida: 1
print(f"OR: {a} | {b} -> {a | b}") # Salida: 7
print(f"XOR: {a} ^ {b} -> {a ^ b}") # Salida: 6
print(f"NOT: ~{a} -> {~a}") # Salida: -6
print(f"Desplazamiento a la izquierda: {a} << 1 -> {a << 1}") # Salida: 10
print(f"Desplazamiento a la derecha: {a} >> 1 -> {a >> 1}") # Salida: 2
¡Me encanta este curso! He divido de esta forma mis apuntes/código.
**Introducción:**
`print("Hola Mundo")`
`saludo = "Hola "nombre = "Ana"apellidos = "Gutierrez Villanueva"`
`# Concatenacion (no se agregan espacios)``print(saludo + nombre)`
`print(type(nombre)) ``# Tipo de dato - str`
`nombre_2 = '''Soy sensible a saltos de linea'''`
`print(nombre_2)`
`mascota = "Milaneso"print(mascota[0]) ``#M``print(mascota[1]) ``#i``print(mascota[2]) ``#l`
`print(mascota[-3]) ``#e``print(mascota[-2]) ``#s``print(mascota[-1]) ``#o`
`print(3 * nombre)print(len(mascota)) ``#Longitud de la cadena (incluye espacios)`
`#Metodo ``print(nombre.upper())print(apellidos.lower())`
**Tipos y print:**
`#Integer - Entero ``x = 10 print(type(x)) `
`#Float - Flotante``y = 5.67 print(type(y))`
`#Notacion cientifica para numeros largos o muy cortos``z = 1.2E6print(z)`
`is_True = True; is_False = False; `
`#Bool - Booleano``print(type(is_True))`
`#Agrega espacios (diferente a concatenar)``print("Nunca","pares","de","aprender");`
`#Sep - separador``print("Nunca","pares","de","aprender", ``sep``="*");`
`#f-strings, permiten insertar expresiones dentro de cadenas de texto ``empresa = "Atentus"objetivo = "Monitoreo sintetico"`
`print(f"Trabajo en {empresa}, y el objetivo es el: {objetivo}")`
`#format - Otra forma de pasar valores``print("Trabajo en la {}, y nuestro objetivo es el: {}".format(empresa,objetivo))`
`#Decimales ``valor = 3.141516print("Valor: {:.2f}".format(valor))`
`#Mantener comillas simples o dobles``print('Hola soy \'Anita\'')`
`#Salto de linea``print("-Hola\nmundo-")`
`#Usar barras invertidas para evitar confudir el escape``print("La ruta de archivo es: C:\\Users\\Usuario\\Desktop\\archivo.txt")`
**Operaciones:**
`#Operadores numericos ``a = 10b = 3 print("Suma:", a + b);print("Resta:", a - b);print("Multiplicación:", a * b);print("Potenciación:", a * b);print("División:", a / b);print("Modulo:", a % b);print("Parte entera de la División:", a // b);`
`print("Shortcuts")a = a + 5a += 5`
`operacion_1 = 2 + 3 * 4operacion_2 = 2 + (3 * 4)operacion_3 = (2 + 3) * 4operacion_4 = (2+3) * (3**4) + 5`
`print(operacion_1)print(operacion_2)print(operacion_3)print(operacion_4)`
`num_a = 5 num_b = 3`
`# A es mayor que B ``print(a > b)``# A es menor que B ``print(a < b)``# A es mayor o igual que B ``print(a >= b)``# A es menor o igual que B ``print(a <= b)`
`# Igual ``print(a == b)``# Diferente``print(a != b)`
`#PEMDAS#Parentesis #Exponenciacion #Multiplicacion #Division#Adision#Sustraccion`
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?