Operadores y expresiones en Python

1. Operadores Aritméticos

Los operadores aritméticos se utilizan para realizar operaciones matemáticas básicas.

Suma (+): Suma dos operandos.
```
a = 10
b = 5
suma = a + b  # 15
```
Resta (-): Resta el segundo operando del primero.
```
resta = a - b  # 5
```
Multiplicación (*): Multiplica dos operandos.
```
multiplicacion = a * b  # 50
```
División (/): Divide el primer operando por el segundo. El resultado es un número flotante.
```
division = a / b  # 2.0
```
División Entera (//): Divide el primer operando por el segundo y devuelve la parte entera del resultado.
```
division_entera = a // b  # 2
```
Módulo (%): Devuelve el resto de la división del primer operando por el segundo.
```
modulo = a % b  # 0
```
Exponenciación (**): Eleva el primer operando a la potencia del segundo.
```
potencia = a ** b  # 100000
```

2. Operadores de Asignación

Los operadores de asignación se utilizan para asignar valores a las variables.

Asignación Simple (=): Asigna el valor del operando de la derecha a la variable de la izquierda.
```
x = 5
```

Asignación Aritmética: Realiza una operación aritmética y asigna el resultado a la variable.

x += 3  # Equivalente a x = x + 3
x -= 2  # Equivalente a x = x - 2
x *= 4  # Equivalente a x = x * 4
x /= 2  # Equivalente a x = x / 2
x //= 2 # Equivalente a x = x // 2
x %= 3  # Equivalente a x = x % 3
x **= 2 # Equivalente a x = x ** 2

3. Operadores de Comparación

Los operadores de comparación se utilizan para comparar dos valores y devolver un valor booleano (True o False).

Igual a (==): Verifica si los operandos son iguales.
```
es_igual = (a == b)  # False
```
Distinto de (!=): Verifica si los operandos son diferentes.
```
es_distinto = (a != b)  # True
```
Mayor que (>): Verifica si el primer operando es mayor que el segundo.
```
mayor_que = (a > b)  # True
```
Menor que (<): Verifica si el primer operando es menor que el segundo.
```
menor_que = (a < b)  # False
```
Mayor o igual que (>=): Verifica si el primer operando es mayor o igual que el segundo.
```
mayor_igual = (a >= b)  # True
```
Menor o igual que (<=): Verifica si el primer operando es menor o igual que el segundo.
```
menor_igual = (a <= b)  # False
```

4. Operadores Lógicos

Los operadores lógicos se utilizan para combinar expresiones booleanas.

Y Lógico (and): Devuelve True si ambas expresiones son True.
```
resultado = (a > b) and (b < 10)  # True
```
O Lógico (or): Devuelve True si al menos una de las expresiones es True.
```
resultado = (a > b) or (b > 10)  # True
```
No Lógico (not): Devuelve True si la expresión es False y viceversa.
```
resultado = not (a > b)  # False
```

5. Operadores de Identidad

Los operadores de identidad se utilizan para comparar la identidad de dos objetos.

Es (is): Devuelve True si ambas variables apuntan al mismo objeto.

lista1 = [1, 2, 3]
lista2 = lista1
es_mismo_objeto = (lista1 is lista2)  # True

No es (is not): Devuelve True si ambas variables no apuntan al mismo objeto.

lista3 = [1, 2, 3]
es_diferente_objeto = (lista1 is not lista3)  # True

6. Operadores de Pertenencia

Los operadores de pertenencia se utilizan para verificar si un valor está presente en una secuencia (como una lista, tupla o cadena).

En (in): Devuelve True si el valor está presente en la secuencia.
```
esta_presente = (2 in [1, 2, 3])  # True
```
No en (not in): Devuelve True si el valor no está presente en la secuencia.
```
no_esta_presente = (4 not in [1, 2, 3])  # True
```

7. Operadores a Nivel de Bits

Los operadores a nivel de bits realizan operaciones directamente sobre los bits de un número.

AND a nivel de bits (&): Realiza una operación AND a nivel de bits.
```
resultado = a & b  # Bitwise AND
```
OR a nivel de bits (|): Realiza una operación OR a nivel de bits.
```
resultado = a | b  # Bitwise OR
```
XOR a nivel de bits (^): Realiza una operación XOR a nivel de bits.
```
resultado = a ^ b  # Bitwise XOR
```
NOT a nivel de bits (~): Realiza una operación NOT a nivel de bits.
```
resultado = ~a  # Bitwise NOT
```
Desplazamiento a la izquierda (<<): Desplaza los bits hacia la izquierda.
```
resultado = a << 2  # Shift left
```
Desplazamiento a la derecha (>>): Desplaza los bits hacia la derecha.
```
resultado = a >> 2  # Shift right
```

Expresiones

Las expresiones son combinaciones de valores, variables, operadores y llamadas a funciones que Python evalúa y devuelve un resultado.

Ejemplos de Expresiones:

Expresiones Aritméticas:

resultado = (a + b) * 2  # Suma y multiplicación

Expresiones Booleanas:

es_valido = (a > b) and (b < c)  # Evaluación lógica

Expresiones Combinadas:

expresion_compleja = (a + b) * (c - d) / e  # Combinación de operadores aritméticos

Llamadas a Funciones:

longitud = len("Python")  # Llamada a una función

Variables y asignación en Python

1. ¿Qué es una Variable? Una variable es un contenedor para almacenar datos. En Python, una variable se puede entender como un nombre que hace referencia a un valor almacenado en la memoria. Las variables permiten que los programas recuerden y manipulen datos. Ejemplo Básico: # Creación de una variable y asignación de un valor x = 10 y = "Hola" z = 3.14 2. Asignación de Valores La asignación de valores en Python se realiza utilizando el operador = . La variable aparece a la izquierda del operador de asignación y el valor asignado a la derecha. a = 5 # Asigna el valor 5 a la variable 'a' b = "Texto" # Asigna la cadena "Texto" a la variable 'b' c = 4.5 # Asigna el valor flotante 4.5 a la variable 'c' 3. Reglas para Nombres de Variables Debe comenzar con una letra (a-z, A-Z) o un guion bajo ( _ ), pero no con un número. Puede contener letras, números y guiones bajos. Python distingue entre mayúsculas y minúsculas, ...

JRVidal en la IA

Buscar este blog