Python >> Tutorial de Python >  >> Python

Operadores de Python

Los operadores en Python se utilizan para realizar una operación específica en variables y valores. Python tiene muchos operadores que son palabras clave o caracteres especiales . Los valores o variables sobre los que trabajan estos operadores se denominan operandos .


Tipos de operadores de Python

Los operadores de Python se pueden clasificar en las siguientes categorías.

  1. Operadores aritméticos
  2. Operadores lógicos
  3. Operadores de comparación
  4. Operadores bit a bit
  5. Operadores de asignación
  6. Operadores de membresía
  7. Operadores de identidad

1. Operadores Aritméticos

Los operadores aritméticos en Python generalmente funcionan con números. Hay operadores para suma, resta, multiplicación, división, módulo y operaciones exponenciales. Algunos de estos operadores también funcionan para cadenas. Todos los operadores aritméticos son caracteres especiales.

  • +:operador de suma
  • -:operador de resta
  • *:operador de multiplicación
  • /:operador de división
  • **:operador exponencial
  • //:operador de división de piso

Veamos un ejemplo de operadores aritméticos en Python.

x = 15
y = 7

sum = x + y
print("addition =", sum)

subtraction = x - y
print("subtraction =", subtraction)

multiplication = x * y
print("multiplication =", multiplication)

division = x / y
print("division =", division)

modulus = x % y
print("modulus =", modulus)

exponent = x ** 2
print("exponent =", exponent)

floor_division = x // y
print("division =", floor_division)  # 2

Salida:

Python admite operadores de suma y multiplicación para cadenas.

print("addition of strings =", ("Python" + " " + "Operators"))
print("multiplication of strings =", ("Python" * 2))

Salida:

addition of strings = Python Operators
multiplication of strings = PythonPython

2. Operadores de comparación

Los operadores de comparación de Python se utilizan para comparar dos valores. El resultado es siempre un valor booleano:True o False .

La lista de operadores de comparación en Python es:

  • ==:devuelve True si ambos valores son iguales.
  • !=:devuelve True si ambos operandos no son iguales.
  • >:devuelve True si el operando izquierdo es mayor que el operando derecho.
  • <:devuelve True si el operando izquierdo es menor que el operando derecho.
  • >=:devuelve True si el valor de la izquierda es mayor o igual que el valor de la derecha.
  • <=:devuelve True si el valor de la izquierda es menor o igual que el valor de la derecha.

Veamos un ejemplo para usar operadores de comparación en Python.

x = 10
y = 20

print(f'equals = {x == y}')
print(f'not equals = {x != y}')
print(f'greater than = {x > y}')
print(f'less than = {x < y}')
print(f'greater than or equal to = {x >= y}')
print(f'less than or equal to = {x <= y}')

Salida:

Estos operadores también funcionan en cadenas. Una cadena se considera mayor que otra cadena si le sigue lexicográficamente. Por ejemplo, "Hola" es mayor que "Hola" en la comparación lexicográfica.


3. Operadores bit a bit

También se denominan operadores binarios y solo funcionan con números enteros. Los valores del operando se convierten a binario y luego la operación se realiza en cada bit. Finalmente, el valor se vuelve a convertir a decimal y se devuelve.

Hay 6 operadores bit a bit en Python.

  • &:Operador AND bit a bit
  • |:Operador OR bit a bit
  • ^:Operador XOR bit a bit
  • ~:Operador complemento a unos binarios
  • <<:Operador binario de desplazamiento a la izquierda
  • >>:Operador binario de desplazamiento a la derecha
x = 10  # 1010
y = 4  #  0100

print(f'Binary AND = {x & y}')
print(f'Binary OR = {x | y}')
print(f'Binary XOR = {x ^ y}')
print(f'Binary Ones Complement = {~x}')
print(f'Binary Left Shift by 2 = {x << 2}')
print(f'Binary Right Shift by 3 = {x >> 3}')

Salida:

Binary AND = 0
Binary OR = 14
Binary XOR = 14
Binary Ones Complement = -11
Binary Left Shift by 2 = 40
Binary Right Shift by 3 = 1

4. Operadores lógicos de Python

Hay tres operadores lógicos en Python. Trabajan con operandos booleanos y devuelven un valor booleano. Están hechos de palabras clave reservadas en Python.

  • y:operador lógico AND
  • or:operador lógico OR
  • not:operador lógico NOT
b1 = True
b2 = False

print(f'{b1} and {b2} = {b1 and b2}')
print(f'{b1} and {b2} = {b1 or b2}')
print(f'not {b1} = {not b1}')

Salida:


5. Operadores de asignación

El operador de asignación (=) se usa para asignar el valor del operando izquierdo al operando derecho.

Hay algunos operadores de asignación compuesta para realizar alguna operación aritmética entre los dos operandos y luego asignar el valor al operando izquierdo.

  • =:operador de asignación simple
  • +=:suma los dos operandos y luego asigna el valor al operando correcto
  • -=:resta el operando derecho del izquierdo y luego asigna el valor al operando izquierdo
  • *=:multiplica ambos operandos y luego los asigna a la izquierda
  • /=:divide el operando izquierdo del operando derecho y luego asigna el valor al operando izquierdo
  • %=:módulo de los operandos izquierdo y derecho y luego asignado al operando izquierdo
  • **=:exponencial de los operandos de izquierda a derecha y luego asignado al operando de la izquierda
  • //=:división mínima de los operandos izquierdo y derecho y luego se asigna el valor al operando izquierdo
a = 10  # simple assignment operator
b = 5

a += b  # same as a=a+b
print(a)  # 15

a -= b  # same as a=a-b
print(a)  # 10

a *= b  # same as a = a*b
print(a)  # 50

a /= b  # same as a = a/b
print(a)  # 10.0

a %= b  # same as a = a%b
print(a)  # 0.0

a = 2
b = 4

a **= b  # same as a = a**b
print(a)  # 16

a //= b  # same as a = a // b (floor division)
print(a) # 4

6. Operadores de membresía

Los operadores de membresía en Python se usan para verificar la presencia de un valor en una secuencia. Hay dos operadores de membresía en Python.

  1. en
  2. no en

Estos operadores generalmente se usan con las condiciones if-else.

x = 3

my_tuple = (1, 2, 3, 4)
my_list = [1, 2, 3, 4]
my_str = "Hello"

print(f'{x} is present in {my_tuple} = {x in my_tuple}')

if x in my_list:
    print(f'{x} is present in {my_list}')

if 'a' not in my_str:
    print(f'a is not present in {my_str}')

7. Operadores de identidad

Los operadores de identidad de Python se utilizan para verificar si dos variables apuntan a la misma ubicación de memoria o no. Hay dos operadores de identidad.

  1. es:devuelve True si ambas variables apuntan a la misma ubicación de memoria
  2. no es:devuelve True si ambas variables apuntan a la ubicación de memoria diferente
s1 = [1, 2]
s2 = [1, 2]
s3 = s1

print(s1 is s2)  # False
print(s1 is s3)  # True

print(s1 is not s2)  # True
print(s1 is not s3)  # False

Precedencia de operadores en Python

A veces, una expresión contiene varios operadores. En ese caso, se utiliza la precedencia de operadores para determinar el orden de ejecución.

  • Podemos crear un grupo de expresiones usando paréntesis. La expresión entre paréntesis se evalúa primero antes de que puedan participar en cálculos posteriores.
  • Algunos operadores tienen el mismo nivel de precedencia. En este caso, la expresión se evalúa de izquierda a derecha.

La siguiente tabla enumera la precedencia de los operadores en orden decreciente.

Precedencia de operadores (orden decreciente)
** (Exponente)
~ (Complemento de unos)
*, /, //, % (multiplicación, división, división de piso, operadores de módulo)
+, – (suma, resta)
<<,>> (operadores de desplazamiento a la derecha e izquierda)
&(Y bit a bit)
|, ^ (O bit a bit, XOR)
==, !=,>, <,>=, <=(Operadores de comparación)
=, +=, -=, *=, /=, //=, %=(Operadores de asignación)
es, no es (operadores de identidad)
in, not in (Operadores de membresía)
no, y, o (operadores lógicos)

Sobrecarga del operador de Python

Python admite la sobrecarga de operadores. Existen métodos específicos para sobrecargar un operador para un objeto.

Veamos qué sucede cuando un operador no es compatible con una clase.

class Data:
    id = 0

    def __init__(self, i):
        self.id = i


d1 = Data(10)
d2 = Data(20)

d3 = d1 + d2
print(d3.id)

Salida:

Traceback (most recent call last):
  File "/Users/pankaj/Documents/PycharmProjects/PythonTutorialPro/hello-world/operators_examples.py", line 9, in <module>
    d3 = d1 + d2
TypeError: unsupported operand type(s) for +: 'Data' and 'Data'

Si tenemos que soportar el operador + para la clase de datos, tenemos que definir el método __add__() para ello. Veamos el código actualizado y el resultado.

class Data:
    id = 0

    def __init__(self, i):
        self.id = i

    def __add__(self, other):
        return Data(self.id + other.id)


d1 = Data(10)
d2 = Data(20)

d3 = d1 + d2
print(d3.id)

Salida: 30

La siguiente tabla proporciona los métodos que se deben anular para sobrecargar un operador en Python.

Operador Descripción Método
+ Adición __add__(uno mismo, otro)
Sustracción __sub__(uno mismo, otro)
* Multiplicación __mul__(uno mismo, otro)
/ División Verdadera __truediv__(uno mismo, otro)
// División de Piso __floordiv__(uno mismo, otro)
% Restante __mod__(uno mismo, otro)
** Poder __pow__(uno mismo, otro)
& Y bit a bit __y__(uno mismo, otro)
| Bitbit O __or__(uno mismo, otro)
^ XOR bit a bit __xor__(uno mismo, otro)
> Mayor que __gt__(uno mismo, otro)
>= Mayor o igual que __ge__(uno mismo, otro)
< Menor que __lt__(uno mismo, otro)
<= Menor o igual que __le__(uno mismo, otro)
== Igual a __eq__(uno mismo, otro)
!= No es igual a __ne__(uno mismo, otro)

Módulo de operador de Python

El módulo de operador de Python proporciona un conjunto de funciones correspondientes a los operadores de Python. Estos nombres de funciones son los mismos que los métodos especiales, sin los guiones bajos dobles.

Veamos un ejemplo de una clase personalizada que admite operadores:+,> y *. Usaremos las funciones del módulo operador para llamar a estos métodos en los objetos de la clase.

import operator


class Data:
    id = 0

    def __init__(self, i):
        self.id = i

    def __add__(self, other):
        return Data(self.id + other.id)

    def __gt__(self, other):
        return self.id > other.id

    def __mul__(self, other):
        return Data(self.id * other.id)


d1 = Data(10)
d2 = Data(20)

d3 = operator.add(d1, d2)
print(d3.id)

d3 = operator.mul(d1, d2)
print(d3.id)

flag = operator.gt(d1, d2)
print(flag)

Resumen

Python admite muchos operadores para ayudarnos en operaciones aritméticas, de comparación, asignación, binarias o lógicas comunes. La mejor parte es que muchos de estos operadores pueden sobrecargarse definiendo métodos especiales en nuestra clase. Si desea que su programa se vea más orientado a objetos, puede usar el módulo de operador que proporciona funciones correspondientes a estos operadores.

Referencias:

  • Módulo de operador de Python

Publicación anterior
Publicación siguiente