No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Operadores de comparación

16/38
Recursos

Aportes 117

Preguntas 14

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Les comparto este artículo que encontré en freeCodeCamp sobre operadores básicos en Python:
https://www.freecodecamp.org/espanol/news/operadores-basicos-en-python-con-ejemplos/

Para inciar limpiando la salida por consola, colocar al inicio:

import os 
os.system('clear')

Cuando comparen string tengan en cuenta lo siguiente

(Pera> Banano) => True porque la P vale 80 y la B vale 66.
(Pera > banano) => False porque la P vale 80 y la b vale 98.

Esto paso poruqe python conpara la letra inicial en base a su valor en el codigo ASCII
En el cual cada letra tiene o caracteer tiene un valor numerico y tanto minusculos como mayusculas tiene diferntes valores.

#Operadores de comparacion-----------------------------------
#son operaores de logica y regresan booleanos

a = 10
b = 3

print(f"igual: {a == b}") #compara si las variables son iguales
print(f"diferente: {a != b}") #compara si las variables son diferentes
print(f"mayor: {a > b}") #compara si la variable a es mayor que la variable b
print(f"menor: {a < b}") #compara si la variable a es menor que la variable b
print(f"mayor o igual: {a >= b}") #compara si la variable a es mayor o igual que la variable b
print(f"menor o igual: {a <= b}") #compara si la variable a es menor o igual que la variable b
print(f"and: {a > b and a == b}") #compara si las dos variables son verdaderas
print(f"or: {a > b or a == b}") #compara si una de las variables es verdadera

Operadores de comparación

Estos operadores devuelven tipos de datos <boole>

( > / < ) Mayor / Menor
( >= / <= ) Mayor o igual / Menor o igual
( == ) Igual
( != ) Diferente


Ejemplos:

( 2 > 1 ) --> True
( 2 > 3 ) --> False
(5 > 5 ) --> False
(1 < 2) --> True
( 2 >= 1 ) --> True
( 2 >= 3 ) --> False
(1 <= 2) --> True
(5 >= 5 ) -> True
(4 == 4) --> True
(‘Apple’ == ‘Apple’) --> True
(‘Apple’ == ‘apple’) --> False
(4 == 4) --> False
(‘Apple’ == ‘Apple’) --> False
(‘Apple’ == ‘apple’) --> True

Se van a obtener siempre booleanos, y servirian en la programación para activar funciones según los resultados.

Lo hice de está forma 😉

Operadores de comparación

Otro conjunto de operadores son aquellos que se aplican a dos elementos comparándolos y devuelven un resultado booleano (un Verdadero o Falso, o, en lenguaje Python, True o False). Entre estos operadores nos encontramos con la igualdad (==), desigualdad (!=), mayor que (>), menor que (<), mayor o igual que (>=) y menor o igual que (<=).

  • Algunos ejemplos:

  • Operadores de comparación

  • Obsérvese que la igualdad se comprueba con dos signos de igualdad ("==") pues, como ya hemos visto, un único signo de igualdad ("=") está reservado para asignar un valor a una variable. La desigualdad se comprueba con el operador “!=”, no con “<>” como ocurre en otros lenguajes de programación.

Los operadores de comparación sirven para comparar números, cadenas, objetos y, en general cualquier cosa en Python. Devuelven siempre un valor lógico (True si se cumple o False si no se cumple)

( ==) igualdad
( != ) desigualdad
( <> ) desigualdad
( > ) mayor que
( < ) menor que
( >= ) mayor o igual que
( <= ) menor o igual que

Resumen 😃

# Retorna un valor True o False
# > mayor que. 
print (7 > 3)
print (3 > 7)
print (7 > 7)

# < menor que. 
print (7 < 3)
print (3 < 7)
print (5 < 5)

# >= mayor o igual que. 
print (7 >= 3)
print (3 >= 7)
print (7 >=7)
age = 18
print (age >= 18)
age = 15
print (age >= 18)

# <= menor o igual que. 
print (7 <= 3)
print (3 <= 7)
print (7 <=7)

# == igual que
# al comparar strings con mayúsculas y minúsculas retorna False. Igual que al comparar un str con un int
print (7 == 3)
print (3 == 7)
print (7 ==7)
print ("Apple" == 'Apple')
print ("Apple" == 'apple')
print ('1' == 1)

# != diferente de
print (7 != 3)
print (3 != 7)
print (7 !=7)

al momento de comparar Apple con apple a pesar que en lenguaje natural pueda ser casi identico, en lenguaje maquina es completamente diferente debido a que se rige por el código ASCII donde es reprecentado cada carácter con una serie de bits, esto lo entiende la maquina y en el lenguaje binario es un valor completamente diferente.
a en binario = 01100001
A en binario = 01000001
Como se puede ver, tienen un digito diferente que en lenguaje maquina detecta y genera la diferencia.
Adjunto el código ASCII

Es importante diferenciar el igual = de asignación del == de comparación.
Si queremos dejar una línea entre respuestas podemos colocar un print vacio print()

Buena clase!

# >
print(7>3)
print(3>7)
print(7>7)

#<
print(5<6)
print(6<5)
print(5<5)

# >=
print(2 >= 1)
print(2 >= 3)
print(2 >= 2)

# <=
print(1 <= 2)
print(2 <= 1)
print(2 <= 2)

#==
print(6 == 6)
print(5 == 2)

# !=

print(6 != 10)
print(6 != 6)

print("Apple" == 'Apple')
print("Apple" == 'apple')
print("1" == 1)

age = 15
print(age >= 18)

Mis apuntes de esta clase:
(>) Mayor que.
(<) Menor que.
(<=) Mayor o igual.
(>=) Menor o igual.
(==) Igualación.
(!=) Diferente que.

Recuerde: Estos operadores de comparación nos retorna un boolean, es decir true/false.

Acá se pueden ver los valores de cada caracter
https://elcodigoascii.com.ar/

09_comparators.py
print(7>3) #mayor que, da true o false
print(7<3) #menor que
print(1>=1) #mayor que igual, da true o false
print(7<=7) #menor que
print(7==7) #igual, da true o false
print(7!=7) #diferente, da true o false

#Con frases
print(“Apple”‘Apple’) #No importan las comillas
print(“Apple”
‘apple’) #Si distingue de mayusculas y minusculas
print(“1”==1) #Uno es str y otro num

Es muy gracioso, hace una semana comencé a leer un libro sobre SQL, me fui a la parte de "Booleanos", en dónde comencé aprender sobre estos comparadores, por lo cual estoy un poco relacionado a estos... Estoy muy emocionado con este curso de Python, va muy desmenuzado todo. Mucha éxito a tod@s compañeros Platzinautas :)
Para evitar que Replit nos autocomplete el Code al tiempo de que codeamos conforme a la clase, les adjunto una imagen con los pasos a seguir para evitar esto :) ![](https://static.platzi.com/media/user_upload/image-67874686-c8d6-4842-b8c7-ed95ec0af86b.jpg)

Resumen

> ayor que

print(7 > 3)
print(3 > 7)
print(7 > 7)

< menor que

print(2 < 5)
print(7 < 4)
print(5 < 5)

>= mayor o igual que

print(8 >= 5)
print(3 >= 3)
print(5 >= 8)

<= menor o igual que

print(4 <= 9)
print(7 <= 7)
print(9 <= 5)

== igualdad

print(5 == 5)
print(4 == 3)

!= Diferente de

print(4 != 9)
print(5 != 5)

print(“Aplle” == “Aplle”)
print(“Aplle” == ‘Aplle’)
print(“Aplle” == ‘aplle’)
print(“1” == 1 ) # no son iguales son datos diferentes uno es "str y otro es “int”

age = 18
print(age >= 18)

Aunque la primera parte se veia algo simple y obvio. Lo que si llamo mi atencion fue la declaracion de comparacion de cadenas de texto y tambien con las variables. Si que hay mucho por aprender. Espero seguir asi en este gran curso.

gracias por los recursos profe, buena profundización.

!=

print(“Apple”== ‘Apple’)
print(“Apple” == ‘apple’)

print(“table” ==“table”)
print(‘Table’ ==table’)

Les comparto mis notas 😃

a : int = 4
b : int = 2

#Los operadores de comparación comparan ambos valores y retorna False o True
print(f"Mayor que: {a > b}")
print(f'Menor que: {a < b}')
print(f'Mayor o igual que: {a >= b}')
print(f'Menor o igual que: {a <= b}')
print(f"Igual que: {a == b}") #compara números
print("Igual que: ", "Suka" == 'Suka') #los corchetes son equivalentes
print("Igual que: ", "Suka" == "suka") #una empieza con minúscula
print("Igual que: ", 4 == "4") #son tipos de datos distintos
print(f'Es diferente que: {a != b}')
print("Es diferente que: ", "Suka" != 'Suka') #los corchetes son equivalentes
print("Es diferente que: ", "Suka" != "suka") #una empieza con minúscula
print("Es diferente que: ", 4 != "4") #son tipos de datos distintos

Hice un ejercicio para comparar poblaciones de China, India y Estados Unidos al 2022. Este es mi código:

china_poblacion = 1420430000
india_poblacion = 1399120000
eeuu_poblacion = 332073000

print(eeuu_poblacion > china_poblacion)
print(india_poblacion > eeuu_poblacion)
print(china_poblacion < india_poblacion)
#Ejemplo: si la edad es menor a 18, no dar acceso
age = int(input("Por favor, ingrese su edad: "))
if(age < 18):
  print("Acceso no permitido")
else:
  print("Continuar registro")

ejemplo al momento de pagar una deuda, si es mayor que la deuda da como resultado True, sino False

no pude crear el archivo
ctrl + l Limpia la consola shell. seguro falta algo, que aprendere en los siguientes capitulos. name = input("Cual es tu nombre ") age = input("Cual es tu edad? ") age = int(age) print(age == 18, "puedes ingresar", age < 18, "no puedes ingresar")
**Uso de operadores de comparación en Python:** 1. **Comparaciones encadenadas:** Python permite encadenar comparaciones, lo que puede hacer que tu código sea más legible. Por ejemplo, en lugar de escribir if x > 1 and x < 10:, puedes escribir if 1 < x < 10:. 2. **Comparación con None:** Cuando compares un objeto con None, siempre usa el operador is o is not. Por ejemplo, if x is None: o if x is not None:. Esto se debe a que None es un singleton en Python y la comparación de identidad es más rápida y más precisa que la comparación de igualdad. 3. **Usa paréntesis para claridad:** Aunque los operadores de comparación tienen una precedencia bien definida, usar paréntesis puede hacer que tu código sea más fácil de leer y entender. Por ejemplo, (x < y) and (y < z) es más claro que x < y and y < z. **Evita comparar tipos incompatibles:** Algunos lenguajes permiten comparaciones entre tipos incompatibles (como un string y un número), pero en Python esto generalmente resultará en un TypeError.
![](https://static.platzi.com/media/user_upload/image-06abf882-b7e2-4864-b9c8-b38cd46a6d33.jpg)![]()
Los **operadores de comparación** en Python se utilizan para comparar dos o más valores y siempre devuelven **True** o **False**. 1. **Mayor que (**`>`**) y Mayor o igual que (**`>=`**)**: * El operador **mayor que** (`>`) devuelve **True** si el operando de la izquierda es estrictamente mayor que el de la derecha, y **False** en caso contrario. * El operador **mayor o igual que** (`>=`) devuelve **True** si el operando de la izquierda es mayor o igual que el de la derecha, y **False** en caso contrario. 2. **Menor que (**`<`**) y Menor o igual que (**`<=`**)**: * El operador **menor que** (`<`) devuelve **True** si el operando de la izquierda es estrictamente menor que el de la derecha, y **False** en caso contrario. * El operador **menor o igual que** (`<=`) devuelve **True** si el operando de la izquierda es menor o igual que el de la derecha, y **False** en caso contrario. 3. **Igual a (**`==`**) y Diferente a (**`!=`**)**: * El operador **igual a** (`==`) devuelve **True** si los operandos son iguales, y **False** si no lo son. * El operador **diferente a** (`!=`) devuelve **True** si los operandos son diferentes, y **False** si son iguales. Por ejemplo: * `5 > 3` devuelve **True**. * `10 >= 10` devuelve **True**. * `7 < 4` devuelve **False**. * `15 <= 20` devuelve **True**. * `8 == 8` devuelve **True**. * `9 != 9` devuelve **False**.
Excelente manera de agrupar los operadores
![](https://static.platzi.com/media/user_upload/image-03adadf3-8e8b-4b0b-bdb8-6fefb73ff32d.jpg)![](https://static.platzi.com/media/user_upload/image-56a6c1e7-7188-42f4-bac1-d3cb02601ec7.jpg)
Aqui mis apuntes sobre ***los operadores de comparación***. En esta primera parte, está la descripción de los operadores básicos aritméticos. ![](https://static.platzi.com/media/user_upload/Comparadores%20apuntes%201-20c993fe-a87c-4e4d-aac7-13bf35933ecc.jpg) En este, es el caso en el que se crea la lógica de acceso a una persona que cuente con la mayoría de edad. ![](https://static.platzi.com/media/user_upload/Comparadores%20apuntes%20%202-ff51f434-3446-4a65-916b-32f61832e7bd.jpg)
**Operadores de Comparación:** ```python == #es_igual != #diferente_de < #es_menor > #es_mayor <= #es_menor_o_igual >= #es_mayor_o_igual ```
Operadores de Comparación: ```python == #es_igual != diferente_de < es_menor > es_mayor <= es_menor_o_igual >= es_mayor_o_igual ```
Los operadores lógicos y de comparación son fundamentales en programación para realizar evaluaciones y tomar decisiones basadas en condiciones. Aquí tienes una lista de los operadores lógicos y de comparación más comunes: ### Operadores de Comparación: 1. **Igual a (==)**: Comprueba si dos valores son iguales.Ejemplo:arduinoCopy code`5 == 5 // true` 2. **No igual a (!=)**: Comprueba si dos valores no son iguales.Ejemplo:yamlCopy code`5 != 3 // true` 3. **Mayor que (>)**: Comprueba si el primer valor es mayor que el segundo.Ejemplo:arduinoCopy code`8 > 3 // true` 4. **Menor que (<)**: Comprueba si el primer valor es menor que el segundo.Ejemplo:arduinoCopy code`2 < 4 // true` 5. **Mayor o igual que (>=)**: Comprueba si el primer valor es mayor o igual que el segundo.Ejemplo:arduinoCopy code`6 >= 6 // true` 6. **Menor o igual que (<=)**: Comprueba si el primer valor es menor o igual que el segundo.Ejemplo:arduinoCopy code`3 <= 5 // true` ### Operadores Lógicos: 1. **AND (&&)**: Retorna true si ambas condiciones son verdaderas.Ejemplo:scssCopy code`(5 > 3) && (6 < 10) // true` 2. **OR (||)**: Retorna true si al menos una de las condiciones es verdadera.Ejemplo:scssCopy code`(4 == 3) || (5 > 2) // true` 3. **NOT (!)**: Niega una condición, convierte true en false y viceversa.Ejemplo:scssCopy code`!(4 < 2) // true` Estos operadores son ampliamente utilizados en la creación de expresiones condicionales en la programación para controlar el flujo del programa y la toma de decisiones basadas en diferentes condiciones.
```js #Sirve para ver la logica. 7>3 es verdadero (True) #> print(7>3) #True print(3>7) #False print(7>7) #False #< print(5<6) #True print(6<5) #falso print(5<5) #False #>= print(2 >=1) #True print(2>=3) #False print(2>=2) #Tru #<= print(1<=2 ) #True print(2<=1) #False print(2<=2) #True #== print(6==6) print(5==2) ```#Sirve para ver la logica. 7>3 es verdadero (True) \#> print(7>3) #True print(3>7) #False print(7>7) #False \#< print(5<6) #True print(6<5) #falso print(5<5) #False \#>= print(2 >=1) #True print(2>=3) #False print(2>=2) #Tru \#<= print(1<=2 ) #True print(2<=1) #False print(2<=2) #True \#== print(6==6) print(5==2)
Aqui un ejemplo practico con codigo:edad = int(input("Ingresa tu edad => "))nombre = input("Ingresa tu nombre => ") if edad >= 18: print(f"Hola {nombre}, tu edad es {edad} por lo que puedes pasar al antro")elif edad < 18: print(f"Hola {nombre}, no se aceptan menores de edad.") ```js edad = int(input("Ingresa tu edad => ")) nombre = input("Ingresa tu nombre => ") if edad >= 18: print(f"Hola {nombre}, tu edad es {edad} por lo que puedes pasar al antro") elif edad < 18: print(f"Hola {nombre}, no se aceptan menores de edad.") ```
```js def validador(): edad=int(input('Tu edad: ')) if edad>=18: print('Puedes pasar') else: print('Menor! No puedes pasar') validador() ```def validador(): edad=int(input('Tu edad: ')) if edad>=18: print('Puedes pasar') else: print('Menor! No puedes pasar') validador()
![](https://static.platzi.com/media/user_upload/Precedencia%20de%20Operadores-f1655742-2731-4895-b279-4466d4c7a9bf.jpg)
muchas gracias ,esta subtitulado
Los operadores de comparación en Python se utilizan para comparar dos valores y devolver un valor booleano (Verdadero o Falso) que indica si la comparación es verdadera o falsa. Algunos de los operadores de comparación más comunes son: * `==` (igual a): verifica si dos valores son iguales. * `!=` (distinto de): verifica si dos valores son diferentes. * `>` (mayor que): verifica si el valor de la izquierda es mayor que el valor de la derecha. * `<` (menor que): verifica si el valor de la izquierda es menor que el valor de la derecha. * `>=` (mayor o igual que): verifica si el valor de la izquierda es mayor o igual que el valor de la derecha. * `<=` (menor o igual que): verifica si el valor de la izquierda es menor o igual que el valor de la derecha. Estos operadores son útiles para realizar comparaciones y tomar decisiones en el código utilizando estructuras condicionales, como los if statements.
Hola, a alguien mas le sucede q la IA de replit, escribe todo el codigo como si estuviera escuchando el audio de la clase? Nos estan espiando en tiempo real 👀👀👀
![](https://static.platzi.com/media/user_upload/imagen-429b076f-ae88-44f2-b0a6-0ac8e5603dc3.jpg)
![](https://static.platzi.com/media/user_upload/image-bc49f38a-4456-4429-bbd8-233cb026f9da.jpg)Les comparto una prueba que quise hacer, tomando clases anteriores y una consulta en internet para el condicional, a ver opinan
`#mayor que >` `print(7>3) #devuelve un booleano true o False` `print(3>7)` `print(7>7)` `# menor que <` `print(5<6)` `print(6<5)` `print(6<6)` `#Mayor o igual >=` `print(2>=1)` `print(2>=3)` `print(2>=2)` `#menor o igual <=` `print(1<=2)` `print(2<=1)` `print(2<=2)` `#igualacion ==` `print(6==6) #true` `print(6==3) #false` `# diferente != ` `print(6 !=10) #true` `print(6 != 6) #false` `#Comparando str` `print("Apple" == 'Apple') #true` `print("Apple" == 'apple') #false` `#comparando valores con diferentes tipos de datos` `print("1" == 1) #false` `#comparando variables` `age= 18` `print(age>=18)`
muy buenas aportaciones :)
hola! como hago para que aparezcan los resultados pasados cuando se corre el programa?
![](https://static.platzi.com/media/user_upload/image-efb47fd9-ea09-4fef-bb35-3d37c3934e85.jpg) ![](https://static.platzi.com/media/user_upload/image-cb80a79c-25ff-4ef4-9b0d-bf74d51d93e4.jpg)

excelente clase, un instructor que explica muy bien, que permite mejorar mis competencias.

print(7>3) # True
print(7>=3) # True
print(7<3) # False
print(7<=3) # False
print(7==3) # False
print(7!=3) # True
print(7!=7) # False
print(7==7) # True
print(7>7) # False
print(7<7) # False
print(7>=7) # True
print(7<=7) # True

Chat:
En Python, los operadores de comparación se utilizan para comparar dos valores y determinar la relación entre ellos. Estos operadores devuelven un valor booleano True o False según se cumpla o no la condición. Aquí están los operadores de comparación en Python:
Igualdad (==): Comprueba si dos valores son iguales.

a = 5
b = 5
resultado = (a == b) # resultado es True

Desigualdad (!=): Comprueba si dos valores no son iguales.

a = 5
b = 10
resultado = (a != b) # resultado es True

Mayor que (>): Comprueba si el valor de la izquierda es mayor que el valor de la derecha.

a = 10
b = 5
resultado = (a > b) # resultado es True

Menor que (<): Comprueba si el valor de la izquierda es menor que el valor de la derecha.

a = 5
b = 10
resultado = (a < b) # resultado es True

Mayor o igual que (>=): Comprueba si el valor de la izquierda es mayor o igual que el valor de la derecha.

a = 10
b = 10
resultado = (a >= b) # resultado es True

Menor o igual que (<=): Comprueba si el valor de la izquierda es menor o igual que el valor de la derecha.

a = 5
b = 10
resultado = (a <= b) # resultado es True

Estos operadores de comparación se utilizan comúnmente en las estructuras de control de flujo, como las sentencias if, elif y while, para tomar decisiones basadas en las condiciones que se evalúan.

MI aporte Práctico, Gracias a la comunidad de Platzi por sus aportes y preguntas !!

NOTES: ![](https://static.platzi.com/media/user_upload/image-65d45c96-6707-451a-a051-d3e4bbd79131.jpg)CODE: ![](https://static.platzi.com/media/user_upload/image-70a2b701-bc7c-448c-89f8-cb9606a7c56b.jpg) OUTPUT: ![](https://static.platzi.com/media/user_upload/image-10250a23-a799-4776-a499-1d54d19073d2.jpg)
![](https://static.platzi.com/media/user_upload/image-04e6695e-7d8d-42a4-bdcb-ed4ab9ba1dcc.jpg)

print(10 > 5) # mayor que
print(10 < 5) # menor que
print(10 >= 5) # mayor o igual que
print(10 <= 5) # menor o igual que
print(10 == 5) # igual que
print(10 != 5) # diferente de
print(“Orange” == “Orange”)
print(“10” == 10)

age = 16

if age >=18:

print("Puedes ingresar a la disco amigo")

else:
print(“Vete a casa niño”)

\# > mayor que print(7 > 3) print(3 > 7) print(7 > 7) \# < menor que print(5 < 6) print(6 < 5) print(5 < 5) \# >= debe ser mayor o mismo valor para que salga True print(2 >= 1) print(2 >= 3) print(2 >= 2) \#<= debe ser menor o mismo valor para que salga True print(1 <= 2) print(2 <= 1) print(2 <= 2) \# == debe ser igual el mismo valor par que salga True print(6 == 6) print(5 ==2) \# != diferente de valor saldra True o si son lo mismo valor sera False print( 6 != 10) print(6 != 6) print("Apple" == 'Apple')# debe ser mayuscula sera mismo valor True print("Apple" == "apple")# si es primero mayuscula y el otro es minuscula saldra False print("1" == 1)# "1"esto es un string 1 esto es un entero age = 18 print(age >= 18) \# >= no puede bajar el valor determinado \# <= no puede subir el valor determinado

La función upper convierte en mayusculas todo la cadena de strings:

print (("apple").upper() == ("ApPle").upper()) 

así al compararlos si es mayúscula o minúscula ya no haría diferencia, en algunos casos esta podría ser una función muy útil para las comparaciones.

Aquí les dejo unos ejercicios que encontré que me ayudaron a practicar los operadores de comparación:

print(“Operador de comparación mayor que >”)
print(7 > 3)
print(3 > 7)
print(7 > 7)

print(“Operador de comparación menor que <”)
print(5 < 6)
print(6 < 5)
print(5 < 5)

print(“Operador de comparación mayor o igual a >=”)
print(2 >= 1)
print(2 >= 3)
print(2 >= 2)

print(“Operador de comparación menor o igual a <=”)
print(1 <= 2)
print(2 <= 1)
print(2 <= 2)

print(“Operador de comparación igual ==”)
print(6 == 6)
print(5 == 2)

print(“Operador de comparación diferente que !=”)
print(6 != 10)
print(6 != 6)

print(“Comparación de strings”)
print(“Apple” == ‘Apple’)
print(“Apple” == ‘apple’)
print(“1” == 1)

print(“Comparación de integers”)
age = 15
print(age >= 18)

Operadores Relacionales
Un operador relacional se emplea para comparar y establecer la relación entre ellos. Devuelve un valor booleano (true o false) basado en la condición.
( ==) igualdad
( != ) desigualdad
( <> ) desigualdad
( > ) mayor que
( < ) menor que
( >= ) mayor o igual que
( <= ) menor o igual que

Algunos de los operadores de comparación más comunes son:


Las expresiones se evalúan de izquierda a derecha y se deben utilizar paréntesis para agrupar y controlar el orden de evaluación.

Además, Python permite encadenar operadores de comparación, lo que significa que puedes evaluar expresiones como x < y <= zpara comprobar si x es menor que y y, a su vez, si y es menor o igual que z.

En esta url hay mas informacion: https://docs.python.org/es/3/library/stdtypes.html#comparisons

Existe una librería denominada operador, que contiene funciones equivalentes a las operaciones estándar de Python.

Aquí les comparto el enlace:https://docs.python.org/es/3/library/operator.html

Operadores de Comparación

Los operadores de comparación nos devolverán siempre un True o un False, lo que harán estos operadores es validar dos valores y si se cumple el criterio regresará True, en caso contrario regresará False.


Operador < y >

print(7 > 3) # True
print(3 > 7) # False

print(7 < 3) # False
print(3 < 7) # True

Operador <= y >=

print(2 >= 1) # True
print(2 >= 3) # False
print(2 >= 2) # True


print(1 <= 2) # True
print(2 <= 1) # False
print(2 <= 2) # True

Operador de igualación ==

print(6 == 6) # True
print(5 == 2) # False

Operador de Diferencia !=

print(6 != 10) # True
print(6 != 6) # False

Comparación de Strings

print("Apple" == 'Apple') # True
print("Apple" == 'apple') # False
print("1" == 1) # False
#operadores de comparacion nos sirven para la logica #y regresan booleanos (True or False)

# > = mayor 
print(7 > 3)
print(3 > 7)
print(7 > 7)

# < = menor
print(5 < 6)
print(6 < 5)
print(5 < 5)

# >= moyrial igual
print(2 >= 1)
print(2 >= 3)
print(2 >= 2)

# <= menor igual
print(1 <= 2)
print(2 <= 1)
print(2 <= 2)

# == igualacion

print(6 == 6)
print(5 == 2)

# != diferencial

print(6 != 10)
print(6 != 6)

#tambien se pueden comparar strings
print("Apple" == 'Apple')
print("Apple" == 'apple')
print("1" == 1)

#usando variable age
age = 15
print(age >= 18)

Muy interesante, me gusta mucho la forma de explicar del profe, hace que todo se sienta muy sencillo, ademas que no se pierde el hilo, almenos en mi caso

MI aporte 😊

###comparacion de edades

# Si el usuario es menor de 18 años, le saldrá, debajo de su nombre completo 
# y año de nacimiento, el mensaje:
# “Eres menor de edad, no podemos darte de alta hasta el año XXXX” 
# (XXXX será el año en que tendrá 18 años y que debermos calcular previamente)
# Si es mayor de 18 años y menor de 25, le saldrá el mensaje: 
# “Tienes un 10% de descuento”
# Si es mayor de 25 años, le saldrá el mensaje:
# “Lo sentimos, pero no tienes descuento”
# Si tiene justo 18 o 25 años, le saldrá el mensaje:
# “Premio, tienes un descuento especial del 20%”


nombre_usuario = input("Ingresa el nombre del usuario: ")
edad_usuario = int(input("Ingresa tu edad: "))


añoNacimiento = 2023-edad_usuario

print(f"Hola {nombre_usuario}  tu año de nacimiento es {añoNacimiento} ")


if(edad_usuario < 18):
    añosRestantes = 18 - edad_usuario;
    añoDescuento = 2023 + añosRestantes
    
    print(f"Eres menor de edad, no podemos darte de alta hasta el año {añoDescuento}")
    
if (edad_usuario > 18 and  edad_usuario  < 25):
    
    print("Tienes un descuento de 25 %")
    

if (edad_usuario > 25):
    print("No tienes descuento")

if (edad_usuario == 18 or edad_usuario == 25  ):
    print('premio !! tienes un descuento especial del 20%')

Igual a ==: Verifica si dos valores son iguales.

a = 5
b = 5
resultado = a==b
print(resultado)

No igual a !=: Verifica si dos valores no son iguales.

a = 5
b = 3
resultado = a!=b
print(resultado)

Mayor que >: Verifica si el valor de la izquierda es mayor que el valor de la derecha.

a = 5
b = 3
resultado = a>b
print(resultado)

Menor que <: Verifica si el valor de la izquierda es menor que el valor de la derecha.

a = 5
b = 5
resultado = a<b
print(resultado)

Mayor o igual que >=: Verifica si el valor de la izquierda es mayor o igual que el valor de la derecha.

a = 5
b = 3
resultado = a>=b
print(resultado)

Menor o igual que <=: Verifica si el valor de la izquierda es menor o igual que el valor de la derecha.

a = 3
b = 3
resultado = a<=b
print(resultado)

Mi práctica en Replit, me encanta la ventana flotante porque puedo ir practicar al mismo tiempo que voy viendo la clase.

Cómo se hace una comparacion en Python?
Operadores en Python: Aritméticos, comparación, lógicos …
Los operadores de comparación se utilizan, como su nombre indica, para comparar dos o más valores. El resultado de estos operadores siempre es True o False . Mayor que. True si el operando de la izquierda es estrictamente mayor que el de la derecha; False en caso contrario.

<

=
<=
==
!=
Con números y caracteres

# >
print(7>3)
print(3>7)
print(7>7)

# <
print(5 < 6)
print(6 < 5)
print(5 < 5)

# >= 
print(2 >= 1)
print(2 >= 3)
print(2>= 2)

# <= es una especie de es < ó =
print(1 <= 2)
print(2 <= 1)
print(2 <= 2)

# ==
print(6 == 6)
print(5 == 2)

# != diferente de 
print(6 != 10)
print(6!= 6)

print("apple" == 'apple')
print("Apple" == "apple")

age = 18
print(age >= 18)

Conocer y entender los operadores de comparación nos permitirá trabajar posteriormente en algo llamado “estructuras de control de flujo”, allí se usan las declaraciones condicionales (if-else) y declaraciones de bucle (while,for).

Las decisiones basadas en condiciones son importantes porque permiten que el código se adapte y tome diferentes caminos según las circunstancias.

En Python, existen varios operadores de comparación que se utilizan para comparar valores y evaluar expresiones booleanas. Aquí están los operadores de comparación más comunes en Python:

== (igual): Comprueba si dos valores son iguales.
!= (distinto): Comprueba si dos valores son diferentes.

(mayor que): Comprueba si el valor de la izquierda es mayor que el valor de la derecha.
< (menor que): Comprueba si el valor de la izquierda es menor que el valor de la derecha.
= (mayor o igual que): Comprueba si el valor de la izquierda es mayor o igual que el valor de la derecha.
<= (menor o igual que): Comprueba si el valor de la izquierda es menor o igual que el valor de la derecha.
Estos operadores devuelven un valor booleano (True o False) según el resultado de la comparación. Aquí tienes un ejemplo:

x = 5
y = 3

# Operadores de comparación
print(x == y)   # False, ya que 5 no es igual a 3
print(x != y)   # True, ya que 5 es diferente de 3
print(x > y)    # True, ya que 5 es mayor que 3
print(x < y)    # False, ya que 5 no es menor que 3
print(x >= y)   # True, ya que 5 es mayor o igual que 3
print(x <= y)   # False, ya que 5 no es menor o igual que 3

Recuerda que los operadores de comparación también se pueden utilizar con otros tipos de datos, como cadenas de texto, listas y objetos.

Igualdad: ==

Verifica si dos valores son iguales.

Desigualdad:!=
Verifica si dos valores no son iguales.

Mayor que: >
Verifica si el valor de la izquierda es mayor que el valor de la derecha.

Menor que: <
Verifica si el valor de la izquierda es menor que el valor de la derecha.

Mayor o igual que: >=
Verifica si el valor de la izquierda es mayor o igual que el valor de la derecha.

Menor o igual que: <=
Verifica si el valor de la izquierda es menor o igual que el valor de la derecha.

Mi pequeña practica

name = input(“Cuanto años tiene Emmanuel”)
name_2 = input(“Cuantos años tiene Rogelio”)

print(f"es igual Emmanuel a Rogelio =>" , {name} == {name_2})

No tenía idea sobre lo de las comparativas de texto y las mayúsculas, menos con el tipo de dato 😅 muy buen tip!

print(2 > 1)  #--> True
print(2 > 3)  #--> False
print(5 > 5)  #--> False
print(1 < 2)  #--> True
print(2 >= 1)  # --> True
print(2 >= 3)  #--> False
print(1 <= 2)  #--> True
print(5 >= 5)  #-> True
print(4 == 4)  #--> True
print('Apple' == 'Apple')  #--> True
print('Apple' == 'apple')  #--> False
print(4 == 4)  #--> False
print('Apple' == 'Apple')  #--> False
print('Apple' == 'apple')  #--> True

> mayor

print(7>3)
print(3>7)
print(7>7)

< menor

print(5<6)
print(6<5)
print(6<6)

>= mayor igual

print(2>=1)
print(2>=3)
print(2>=2)

<= menor igual

print (1<=2)
print (2<=1)
print (2<=2)

== igualacion

print (66)
print (5
6)

!= diferente de

print (6!=10)
print (6!=6)

print (“apple” == “orange”)
print (“apple” == “apple”)
print (“1” == 1)

age = 15
print(age>=18)

ages = 22
print(ages>=18)

# Útiles para cierto flujo de trabajo
# >, devuelve true or false
print(7 > 3)
print(3 > 7)
print(7 > 7)

# <
print(5<6)
print(6<5)
print(5<5)

# >=
print(2>=1)
print(2>=3)
print(2>=2)

# <=
print(1<=2)
print(2<=1)
print(2<=2)

# ==
print(6==6)
print(5==2)

# !=
print(6!=10)
print(6!=6)

print('Apple' == "Apple")
print('Apple' == "apple")
print('1' == 1)

age = 15
print(age >= 18)

Comparando strings, en este caso me imagino que la comparación se da debido a la cantidad de caracteres que tenga cada string:

# >
print(7 > 3)  # True
print(3 > 7)  # False
print(7 > 7)  # False

# <
print(5 < 6)  # True
print(6 < 5)  # False
print(5 < 5)  # False

# >=
print(2 >= 1)  # True
print(2 >= 3)  # False
print(2 >= 2)  # True

# <=
print(1 <= 2)  # True
print(2 <= 1)  # False
print(2 <= 2)  # True

# ==
print(6 == 6)  # True
print(5 == 2)  # False

# !=
print(6 != 10)  # True
print(6 != 6)  # False

# Comparando Strings

print("Apple" == 'Apple')  # True (No hay diferencia entre "" y '')

print("Apple" == 'apple')  # False (Hay diferencia en mayúsculas y minúsculas)

print("1" == 1)  # False (Tipos de datos diferentes)

age = 15
print(age >= 18)  # False (15 no es mayor o igual a 18)

#Sirven para la lógica
#>, <, <=, >=, = dan True o False
print(7>3) #True
print(7>7) #False

#== estrictamente igual
print(6==6) #True
print(5==2) #False

#diferente de !=
print(6!=6) #False
print(5!=2) #True

'''Con strings'''
print("Apple" == 'Apple') #True. La comilla doble o sencilla no afecta, mayúsculas y minúsculas sí.
print("Apple" == 'apple') #False. Por la minúscula.
print("1" == 1) #False. Porque cambia el tipo de dato.

'''Se puede usar variables'''
#se quiere saber si la edad califica para entrar a un bar
age = 18
print(age>=18)

Python Operators

Operadores de comparación

Los operadores de comparación se utilizan para comparar dos valores

Operator Name Example
== Equal x == y
!= Not equal x != y
> Greater than x > y
< Less than x < y
>= Greater than or equal to x >= y
<= Less than or equal to x <= y
from os import system
system ('clear')

# > 
print ('operador mayor que')
print('Es 7 > 3  : ', 7 > 3)
print('Es 3 > 7  : ', 3 > 7)
print('Es 7 > 7  : ', 7 > 7)
print(' ')

# <
print ('operador menor que')
print('Es 5 < 6 : ',   5 < 6)
print('Es 6 < 5 : ',   6 < 5)
print('Es 5 < 5 : ',   5 < 5)
print(' ')

# >=
print ('operador mayor igual que')
print('Es 2 >= 1  : ',   2 >= 1)
print('Es 2 >= 3  : ',   2 >= 3)
print('Es 2 >= 2  : ',   2 >= 2)
print(' ')

# <=
print ('operador menor igual que')
print('Es 1 <= 2   : ',  1 <= 2)
print('Es 2 <= 1   : ',  2 <= 1)
print('Es 2 <= 2   : ',  2 <= 2)
print(' ')

# ==
print('operdor de igualdad')
print('Es 6 == 6  :',  6 == 6)
print('Es 6 == 6  :',  5 == 2)
print(' ')

print ('Casos a considerar')
print('Caso 1   "Apple" == "Apple"    :',  "Apple" == 'Apple')
print('Caso 2   "Apple" == "apple"    :',  "Apple" == 'apple')
print('Caso 3   "1" == 1              :',  "1" == 1)

print(' ')
print('caso 1 ')
print('No importa si se usa comilla doble o comilla simple ')
print('caso2')
print('Si hay diferencia entre las comillas simples y dobles')
print('caso3')
print('Hay deferencia entre un sting y un numero')

# !=
print('operador de diferencia')
print('6 != 10 : ',  6 != 10)
print('6 != 6  : ',  6 != 6)
print(' ')

un poco mas ordenado

#operador suma
print(10 +10)

#operador resta
print(10 - 10)

#operador multiplicacion
print(10 * 10)

#operador division
print(10 / 3 )

#operador de residuo
print(10 % 3)

#operador con division numero entero
print(10 // 3)

#operador exponencial
print(10 ** 10)
""""
P = parentesis
E = exponentes
M = multiplicacion 
D = division
A = adicion
S = sustraccion
"""
print(2 ** 3 + 3 -7 / 1 // 4)
print(2 ** 3)
print((7 / 1) // 4)
print(8 + 3 - 1)

Hi 😃

Ya ahora recuerdo la función de los boleans en el día a día gracias bien explicado

Yo complemento el conocimiento de platzi con lo actualmente estoy viendo en la maestría, aquí les dejo un ejemplo de un programa que hace diferencia entre pares e impares usando el operador lógico if

En el examen cuando es
4 != 10 TRUE
Lo califica como respuesta mala