Operadores lógicos y de comparación en Python

Mi pequeño resumen:

• and para comparar si dos valores son verdaderos.
  -or para comparar si dos valores son falsos.
  -not para invertir el valor booleano.
  -== Compara dos valores y te dice si son iguales o no.
  -!= Compara dos valores y te dice sin son diferentes o no.
  -> Compara si es mayor que otro valor.
  -> Compara si es menor que otro valor.
  >= igual o mayor que el valor a comparar.
  <= igual o menor que el valor a comparar.

Seguro que muchos lo podéis explicar mucho mas claro. Un saludo!

Ciencia de Datos:
R
SQL
Java
Scala
Python

Desarrollo de videojuegos:
JS
C#
Java
C++

Desarrollo Web
CSS
PHP
HTML
Python

Inteligencia Artificial:
R
Java
C++
Python

Desarrollo Móvil:
JS
Java
Dart
Swift
Kotlin

Ciberseguridad:
JS
PHP
C++
Python

Python está muy presente al día de hoy.

**and **devuelve Verdadero si las todas las variables que estoy comparando son Verdaderas
**or **Devuelve verdadero si al menos una de las variables que estoy comparando es verdadera.
**not **Invertir el valor boleano.
== Compara dos variables/valores, y devuelve verdadero si son iguales y falso si no lo son
!= Compara dos variables/valores, devuelve verdadero si son diferentes o falso de lo contrario
> Compara dos variables/valores, devuelve verdadero si el primero es mayor que el segundo.
< Compara dos variables/valores, devuelve verdadero si el primero es menor que el segundo.
>= Compara dos variables/valores, devuelve verdadero si el primero es mayor o igual que el segundo.
<= Compara dos variables/valores, devuelve verdadero si el primero es menor o igual que el segundo.

Tablas de verdad de las compuertas AND y OR con dos entradas y su respectiva salida. (Tomar 1 como Verdadero y 0 como Falso)

Desde Python 3 es posible usar el & como and y para utilizar el operador or se puede con el carácter |.

Ejemplo:

• Trabaja & es_estudiante
• Trabaja | es_estudiante

mi apunte que realicé, espero les sea de ayuda c:

Tip:
-Para comprender mejor los operadores lógicos hagamos esto:
True = 1 y False = 0
en el operador and que es una conjunción multiplicas:
1 * 0 = 0 | 1 * 1 = 1 | 0 * 0 = 0
con el operador or que es una disyunción sumas:
1 + 0 = 1 | 1 + 1 = 1(se pone 1 porque 2 no existe en binario) |
0 + 0 = 0
Con not solamente inviertes, osea que si es 1 ahora pasa a ser 0 y viceversa 😉

Este tema quedo mejor explicado en el ultimo vídeo del curso de programación básica: https://platzi.com/clases/1050-programacion-basica/15968-que-son-tablas-de-verdad-y-compuertas-logicas/

les dejo un mi apunte que hice, espero les ayude. c:

""" OPERADORES LOGICOS """

es_estudiante = True
trabaja = False

# AND
""" El operador AND devuelve VERDADERO si y solo si TODAS las variables son verdaderas
    y devolvera falso cuando al menos una variable es falsa"""
pivot = es_estudiante and trabaja
print(f'Es estudiante Y trabaja: {pivot}')

# OR
""" El operador OR devuelve VERDADERO si y solo una de las variables es verdadera
     y devolvera falso cuando todas una variables sean falsas"""
pivot = es_estudiante or trabaja
print(f'Es estudiante O trabaja: {pivot}')

# NOT
""" NOT invierte el valor logico de una variable, de verdadero a falso y de falso a verdadero """
pivot = not es_estudiante
print(f'Estudia? invertido -> {pivot}')

pivot = not trabaja
print(f'Trabaja? invertido -> {pivot}')

""" OPERADORES DE COMPARACION """

numero1 = 5
numero2 = 5
numero3 = 7

#IGUALDAD
pivot = numero1 == numero2
print(f'Es n1 igual a n2 -> {pivot}')
pivot = numero1 == numero3
print(f'Es n1 igual a n3 -> {pivot}')

#DISTINTO
pivot = numero1 != numero3
print(f'Es n1 distinto a n3 -> {pivot}')

#MAYOR
pivot = numero1 > numero3
print(f'Es n1 mayor a n3 -> {pivot}')

#MENOR
pivot = numero1 < numero3
print(f'Es n1 menor a n3 -> {pivot}')

#MAYOR-IGUAL
pivot = numero1 >= numero2
print(f'Es n1 mayor o igual a n2 -> {pivot}')

#MENOR-IGUAL
pivot = numero1 <= numero2
print(f'Es n1 menor o igual a n2 -> {pivot}')

and se usa para comparar si todos los valores son verdaderos. Ejemplo var1 and var2= true o false (dependiendo si todas las variables son verdaderas si una o mas de una es falsa saldra false)

or sirve para comparar las variables y si una de ellas es verdadero saldra true a pesar de que alguna pueda ser false. (con que una sea true saldra true) esto se debe porque una de las variables resulta ser verdadero.

not sirve para invertir el valor booleano. (true o false)

== con esta opción podemos comparar valores y te dice si son iguales o no (con un booleano “o sea true o false”).

!= esta opción nos dice justamente al reves, es decir si los valores comparados si son distintos o no. (e igual te regresan un booleano “o sea true o false”)

Esta opcion nos dice si el valor es si es mayor que el otro valor puesto a comparar.

< Esta opcion nos dice si el valor es si es menor que el otro valor puesto a comparar.

= Esta opcion nos dice si el valor es igual o mayor que el valor a comparar.

<= Esta opcion nos dice si el valor es igual o menor que el valor a comparar.

Qué fácil es venir de otro lenguaje y ver que todo es igual.
Puede cambiar algo en la sintaxis pero la lógica siempre será la misma 😃

Operadores Lógicos

1. and ( y ) -> compara dos valores, y si ambos son verdaderos, devuelve True.
2. or ( ó ) -> si al comparar dos valores y uno de los dos se cumple, devuelve True. Solo devuelve falso cuando los dos valores no se complen.
3. not ( no) -> invierte el valor de una variable, dando el valor contrario al de la variable evaluada.

Operadores de Comparación

1. == ( igual qué ) -> Determina si dos valores son iguales o no.
2. != (distinto de) -> Determina si dos valores son distintos o no. Si los valores son diferentes devuelve True, si son iguales devuelve False.

3. (mayor que) -> Compara dos valores, y determina si es mayor que el otro.

4. < (menor que) -> Compara dos valores y determina si es menor que el otro.

5. = (mayor o igual) -> compara dos valores y determinas si es mayor o igual que el otro.

6. <= (menor o igual) -> compara dos valores y determinas si es menor o igual que el otro.

Comparto una pequena tabla de verdad con los operadores logicos AND , OR , NOT .

El mayor aporte para ti programador junior

Un programador siempre esta estudiando y actualizando su conocimiento, algo que en lo personal me molesta demasiado.
Si quieres aprender un lenguaje solo basta con aprender la sintaxis de uno y lo demas es repetir en otr lenguaje.
Siempre que quieras aprender un nuevo lenguaje lo mas importante es su documentacion y su sintaxis.
Por ello te dejo una guia entera de como se usa python, muy explicativa por cierto.
https://devdocs.io/
https://freecomputerbooks.com/
El segundo link es mi favorito.
literalmente con practica y leyendo la documentacion un poco cada dia, se abre un mundo entero.
Muchos consideran que leer documentacion no es tan importante, yo creo que si y que no hay qu darle mucha importancia a los problemas, nadie tiene limites y cualquier problema se puede resolver.

TRUE / FALSE
AND : Verdadero solo si todas son True
OR: Es verdadero si hay al menos un valor True
NOT: Solo invierte los valores
!= diferente de
== igual
< menor que

mayor que
<= menor igual
= mayor igual

Esto de los operadores lógicos me recordó al álgebra booleana.

Un poco de teoría.

Conjunción (and)
La conjunción es un operador, que actúa sobre dos valores de verdad, típicamente los valores de verdad de dos proposiciones, devolviendo el valor de verdad verdadero cuando ambas proposiciones son verdaderas, y falso en cualquier otro caso. Es decir, es verdadera cuando ambas son verdaderas.

En términos más simples, será verdadera cuando las dos proposiciones son verdaderas.

La disyunción (or)
Es un operador lógico que actúa sobre dos valores de verdad, típicamente los valores de verdad de dos proposiciones, devolviendo el valor de verdad verdadero cuando una de las proposiciones es verdadera, o cuando ambas lo son, y falso cuando ambas son falsas.

En términos más simples, será verdadera cuando por lo menos una de las proposiciones es verdadera de lo contrario será falsa.

La tabla de verdad de la disyunción es la siguiente:

para entender los operadores lógicos es necesario que tengan en cuenta las tablas de verdad y la lógica proposicional

Operadores lógicos y de comparación

And sirve para comparar si dos valores son verdaderos

es_estudiante and trabaja

or te indica si alguno de los valores es verdadero

es_estudiante or trabaja

== te confirma la igualdad de las variables

variable7 == numero1

!= Es el contrario de == te dice si son distintas o no

variable7 != numero1

<> Mayor o menor que

variable7 > numero1
variable7 < numero1

<= >= Mayor o igual que y menor o igual que

varible7 <= numero1
variable7 <= numero1

me gustan estas clases.

😃 Los operadores de comparación, nos devolverán un valor booleano. Este determinara si es True ó False.

Tengo mas de 10 años programando y estoy viendo este curso haciendo como si no supiera nada.
¡Nunca paremos de aprender!

AND: Compara los argumentos y regresará un valor true si “TODOS” los argumentos se cumplen o son true, si alguno “NO” se cumple regresará falso

OR: Compara los argumentos y regresara un valor true “SI POR LO MENOS” uno se cumple, regresara falso solamente cuando “NINGUNO” se cumpla.

NOT: Regresa lo “CONTRARIO” del argumento

not true= false
not false = true

3>1 and 6<8
True

3>1 or 9<8
True

not 3>1
False

o algo así XD

**Operadores lógicos
**

Operadores relacionales

Creo que os puede interesar esta página para esta clase:
https://www.freecodecamp.org/espanol/news/operadores-basicos-en-python-con-ejemplos/

también podemos guardar el valor del not en una variable

>>> not trabaja
True
>>> not es_estudiante
False
>>> no_es_estudiante = not es_estudiante
>>> no_es_estudiante
False
>>> not no_es_estudiante 
True

Operadores lógicos y de comparación

• and o desde python3 también & para comparar si los dos valores son verdaderos
• or o desde python3 | compara si alguno es verdadero
• not invierte el valor booleano
• == compara la igualdad de dos valores
• != Compara la diferencia de dos valores
• < Compara si el primer valor es menor que el segundo
• > Compara si el primer valor es mayor que el segundo
• <= Compara si el primer valor es menor o igual que el segundo
• >= Compara si el primer valor es mayor o igual que el segundo

Además de los operadores aritméticos, en Python tenemos muchos más para llevar nuestra programación más allá.

Operadores lógicos

• and (también válido &): devuelve verdadero si todas las variables que se comparan son verdaderas

  is_student = True
  works = False 
  
  is_student and works 
  > False 
  
  is_venezuelan = True
  is_student & is_venezuelan 
  > True
  

• or (también válido |): devuelve verdadero si al menos uno de los valores es verdadero

  is_venezuelan or works 
  > True
  
  is_student | works
  > True
  

• not: Permite invertir el valor booleano de la variable o indicar que una variable tiene un valor False

  not works 
  > True
  
  not is_student
  > False
  
  number = not 3
  number
  > False
  

Operadores de comparación

• == (igualdad): Devuelve verdadero si dos valores son iguales

  4 == 4
  > True
  
  5 == 2
  > False
  

• != (no igual): Devuelve verdadero si dos valores no son iguales

  "Sebastian" != "Sebastian"
  > False
  
  1 != 3
  > True
  

• > (mayor que): Compara si un valor es mayor al otro

  1 > 5
  > False
  
  10 > 5
  > True
  

• < (menor que): Compara si un valor es menor al otro

  3 < 5 
  > True
  
  5 < 3
  > False
  

• >= (mayor o igual que): devuelve verdadero si un valor es mayor o igual al otro

  3 >= 3
  > True
  
  4 >= 3
  > True
  
  2 >= 3
  > False
  

• <= (menor o igual que): devuelve verdadero si un valor es menor o igual al otro

  3 <= 3
  > True
  
  2 <= 3
  > True
  
  4 <= 3
  > False
  

Operadores lógicos:

1. and: compara si los valores son verdaderos.
2. or: para identificar si al menos una variable cuenta con los requisitos que busco.
3. not: invertir el valor de una variable

OPERADORES DE COMPARACION:
== igualdad
!= distinto

mayor
< menor
= mayor igual
<= menor igual

Operadores lógico y de comparación

Operadores lógicos

and: Para comparar si dos valores son verdaderos

or: Para comparar si dos valores son falsos

not: Para invertir el valor booleano

#Uso del and
es_estudiante = True
trabaja = False

es_estudiante and trabaja
>>> False

#Uso del or
es_estudiante or trabaja
>>> True

#Uso del not
not es_estudiante
>>> False
not trabaja
>>> True

Operadores de comparación

==: Compara dos valores y te dice si sn iguales o no

!=: Compara dos valores y te dice si son diferentes o no

>: Compara si es mayor que otro valor

<: Compara si es menor que otro valor

>=: Igual o mayor que el valor a comparar

<=: Igual o menor que el valor a comparar

```python
#Uso de ==
numero1 = 5
numero2 = 5
numero1 == numero2
>>> True

numero3 = 7
numero1 == numero3
>>> False

#Uso de !=
numero1 != numero3
>>> True

#Uso de >
numero1 > numero3
>>> False

#Uso de <
numero1 < numero3
>>>True

#Uso de >=
numero1 >= numero3
>>> False

numero1 >= numero2
>>> True

#Uso de <=
numero1 <= numero2
>>> True

numero1 <= numero3
>>> True

Conversor de monedas ? entonces ya puedo hacer mi app de conversor de monedas ? :v - broma , no sabia nada , recién empiezo , un gusto 😃

estas explicaciones son muy sencillas, con este maestro si se aprende muy rapido y de manera interactiva

Operadores lógicos:

and : compara las variables y devuelve si son verdaderas.
or : compara las variables y devuelve si alguna de ellas coincide.
not : se usa al inicio y devuelve al valor contrario

Operadores de Comparación:

== : se usa para asignar igualdad.
!= : se usa para especificar que es distinto.

: se usa para definir si mayor qué.
< : se usa para definir si es menor qué.
= : se usa para definir si es mayor o igual qué.
<= : se usa para definir su es menor o igual qué.

Un valor que es igual a Ture es igual a 1 y un valor que es igual a False es igual a 0, con esto en mente, el operador and solo regresara True cuando tados las condiciones que se analizan son iguales a 1 o Ture.
El operador or solo regresara True cuando cualquiera de las condiciones es True o 1.

Entendido

Para comprender el flujo de nuestro programa debemos entender un poco sobre estructuras y expresiones booleanas
== se refiere a igualdad
!= no hay igualdad.

mayor que
< menor que
= mayor o igual
<= menor o igual
and unicamente es verdadero cuando ambos valores son verdaderos
or es verdadero cuando uno de los dos valores es verdadero.
not es lo contrario al valor. Falso es Verdadero. Verdadero es Falso.

Con este conocimiento ya complementamos con lo que el profesor estima suficiente para enfrentar el primer reto de programacion. Esperemos poder cumplir las espectativas de lo aprendido hasta ahora en este curso.

True and True = True
True and False = False
False and True = False
False and False = False

Operadores lógicos y de comparación

• and
• or
• not
• ==
• !=
• <

• =

• <=

Operadores lógicos o booleanos

A la hora de operar con valores booleanos, tenemos a nuestra disposición los operadores and, or y not.

![](

OPERADORES LÓGICOS Y DE COMPARACIÓN
Operadores Lógicos
Se pueden asignar valores lógicos (True o False) a variables Booleanas, por ejemplo:

>>> es_estudiante = True
>>> es_estudiante
True
>>> trabaja = False
>>> trabaja
True

Estos valores lógicos pueden ser operados por operadores lógicos, los cuales se explican a continuación:

• AND: Compara dos valores, solo si ambos son verdaderos, devuelve un valor verdadero.
• OR: Compara dos valores, si al menos uno es verdadero, devuelve un valor verdadero.
• NOT: Devuelve el valor lógico inverso al ingresado.

Operadores de comparación
Los operadores de comparación, como lo indica su nombre, sirven para comparar el contenido de dos variables.
A continuación lo listan estos operadores:

• ==, igual a:
  Compara dos valores y devuelve un valor verdadero si son exactamente iguales.

• !=, diferente de:
  Compara dos valores y devuelve un valor verdadero si son diferentes entre sí.

• >, mayor que:
  Compara dos valores y devuelve un valor verdadero si el número que se encuentra a la izquierda del símbolo es mayor que el de la derecha.

• >=, mayor o igual que:
  Compara dos valores y devuelve un valor verdadero si el número que se encuentra a la izquierda del símbolo es mayor o igual que el de la derecha.

• <, menor que:
  Compara dos valores y devuelve un valor verdadero si el número que se encuentra a la izquierda del símbolo es menor que el de la derecha.

• <=, menor o igual que:
  Compara dos valores y devuelve un valor verdadero si el número que se encuentra a la izquierda del símbolo es menor o igual que el de la derecha.

Hay 6 operadores de comparación
== comparará dos valores, si son iguales nos retornará True
!= comparará dos valores , si no son iguales nos retornará True
> El Mayor que nos retornará True si el valor de la izquierda es mayor que el valor de la derecho
< El Menor que nos retornará True si el valor de la izquierda es menor que el valor de la derecha
>= El Mayor o igual que nos retornará True si el valor de la izquierda es igual o mayor que el valor de la derecha
<= El Menor o igual que nos retornará True si el valor de la izquierda es igual o menor que el valor de la derecha

a=1
b=1
a == b
>> True
a != b
>> False

a=5
b=2
a > b
>> True
a < b
>> False

a=1
b=1
a >= b
>> True
a <= b
>> True

Hay 3 operadores lógicos: and, or y not.
and nos retornará True si ambas comparaciones son True

es_estudiante = True
trabaja = True
es_estudiante and trabaja
>> True
#Si una de ellas fuera false, nos retornaría false
es_estudiante = True
trabaja = False
es_estudiante and trabaja
>> False

or nos retornará True si alguno de los dos es True

es_estudiante = True
trabaja = False
es_estudiante or trabaja
>> True
#Si ambas son False, retornará False
es_estudiante = False
trabaja = False
es_estudiante or trabaja
>> False

not invertirá el valor de nuestra variable, si True nos retornará False y viceversa

es_estudiante = True
trabaja = False
not es_estudiante
>> False
not trabaja
>> True

OPERADORES LÓGICOS

• and: regresa True cuando todas las variables son verdaderas
• or: regresa False cuadno todas las variables son falsas
• not: regresa el **boleano contrario ** al de la variable

Pero yo trabajo y estudio :v

resumen:

and para comparar si dos valores son verdaderos.
-or para comparar si dos valores son falsos.
-not para invertir el valor booleano.
-== Compara dos valores y te dice si son iguales o no.
-!= Compara dos valores y te dice sin son diferentes o no.
-> Compara si es mayor que otro valor.
-> Compara si es menor que otro valor.

= igual o mayor que el valor a comparar.
<= igual o menor que el valor a comparar.
Seguro que muchos lo podéis explicar mucho mas claro. Un saludo!

Operadores lógicos

• and: Sirve para evaluar si dos valores son verdaderos, en caso de que ambos sean verdaderos la salida será el valor booleano True. Solo retorna False cuando uno de los dos valores o ambos valores son falsos.
• or: Lo utilizamos para evaluar si uno de los dos resultados es verdadero, si uno de los dos lo es, retornará True, lo mismo si los dos son verdaderos. Solo retorna False cuando los dos valores son falsos.
• not: Este es el operador de negación, si le pasamos una proposición de resultado True entonces nos devolverá False, y viceversa

Operadores de comparación

• == Es el operador de igualdad, evalúa si los dos valores que estamos comparando son iguales. No debemos confundir con el operador de asignación “=”.
• != Compara si dos valores son diferentes, en caso de que así sea esto retornara True, si son iguales retornará False.
• > Evalúa si el valor de la izquierda es mayor que el de la derecha.
• < Evalúa si el valor de la izquierda es menor que el de la derecha.
• >= Evalúa si el valor de la izquierda es mayor o igual al de la derecha.
• <= Evalúa si el valor de la izquierda es menor o igual al de la derecha.

'''Programa para saber cuál es el número mayor'''

num_1 = int(input("Ingrese un número"))
num_2 = int(input("Ingrese otro número"))

if num_1 > num_2:
    print("El num_1 es mayor")
else:
    print("El num_2 es mayor")

Esto ilustra un poco más los operadores lógicos.

<numero1 = int(input("Escribe un número \n"))
numero2 = int(input('Escribe sgundo número\n'))

suma = (numero1 + numero2)
print("El numero que ingresaste es: ",suma)> 

Hice pruebas para los operadores lógicos, y también funciona & para el and y | para el or

Python 3.10.4 (main, Apr  2 2022, 09:04:19) [GCC 11.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> es_estudiante = True
>>> trabaja = False
>>> es_estudiante & trabaja
False
>>> es_estudiante | trabaja
True
>>> 

Muchisimas gracias profe Facundo, hice el curso de lógica y lo entendí en su momento, pero debo decir que como usted lo explica, creo que será mucho más fácil de entender y que se quede en la mente de muchos otros que leí y que no entendieron esto en el curso de lógica.

Mi pequeño resumen:

and para comparar si dos valores son verdaderos.
-or para comparar si dos valores son falsos.
-not para invertir el valor booleano.
-== Compara dos valores y te dice si son iguales o no.
-!= Compara dos valores y te dice sin son diferentes o no.
-> Compara si es mayor que otro valor.
-> Compara si es menor que otro valor.

= igual o mayor que el valor a comparar.
<= igual o menor que el valor a comparar.
Seguro que muchos lo podéis explicar mucho mas claro. Un saludo!

RESUMEN DE LA CLASE:

Operadores Logicos y Comparacion

and para comparar si dos valores son verdaderos.
or para comparar si dos valores son falsos.
not para invertir el valor booleano.
== Compara dos valores y te dice si son iguales o no.
!= Compara dos valores y te dice sin son diferentes o no.

Compara si es mayor que otro valor.
-> Compara si es menor que otro valor.
= igual o mayor que el valor a comparar.
<= igual o menor que el valor a comparar.

Ej. 1

es_estudiante = True
es_estudiante
True

trabaja = False
trabaja
False

Ej. 2 (And devolve verdadero, cuando todas las variables comparadas contengan el valor de verdadero o true)

es_estudiante and trabaja
False

Ej. 3 (Or, devuelve falso, cuando todas las variables comparadas contengan el valor de falso o false)

es_estudiante or trabaja
True

Ej. 4 (Not, invierte el resultado, si es true es false y si es false es true)

not es_estudiante
False

not trabaja
True

OPERADORES DE COMPARACION

Ej. 5 (==, comparar dos valores si son iguales o no)

numero1 = 5
numero2 = 5
numero1
5

numero2
5

numero1 == numero2
True

numero3 = 7
numero1 == numero3
False

Ej. 6 (!=, comparar dos valores si son diferentes o no, LO CONTRARIO QUE EL ANTERIOR)

numero1 != numero3
True

Ej. 7 (>, mayor que) el numero 5 es mayor que 7, pues es falso

numero1 > numero3
False

Ej. 8 (<, menor que) el numero 5 es menor que 7, pues es verdadero

numero1 < numero3
True

Ej. 9 (>=, mayor o igual que) el numero 5 no es mayor igual a 7, pues es falso

numero1 >= numero3
False

Ej. 10 (<=, menor o igual que) el numero 5 es menor igual a 7, pues es verdadero

numero1 <= numero3
True

En verdad que se me hace facil este tipo de logica, he sido bendecida con eso xD

Realice una pequeña tabla con los operaciones indicados

Mi practica en VS

## Operador Igual que == ##
numero1= 5
numero2= 5
numero3= 7

## Operador Igual igual##
# Este operador me valida si las variables en comparacion son iguales en cantidad y tipo y ne da como resultado False o True
print(numero1 == numero2)
#True
print(numero1 == numero3)
#False
################################
##  Operador diferente de != ##
# Valida si las variable en comparacion son diferentes y nos da True o False como resultado
print(numero1 != numero3)
#False
print(numero1 != numero2)
################################
##  mayor que > ##
# Valida si la variable a es mayor que la variable b, nos da como resultado True o False
print(numero1 > numero2)
#False
print(numero3 > numero1)
#True
################################
##  Menor que < ##
# Valida si la varible a es menor que la variable b, nos da como resultado True o False
print(numero1 < numero2)
#False
print(numero1 < numero3)
#True
################################
##  Mayor o Igual que >= ##
# Valida si la varible a es mayor o igual que la variable b
print(numero1 >= numero2)
#True
print(numero1 >= numero3)
#False
################################
##  Menor o Igual que <= ##
# Valida si la varible a es menor o igual que la variable b
print(numero1 <= numero2)
#True
print(numero1 <= numero3)
#True
################################

se pone and en python para poner la conjunción de dos premisas. y or para poner la disyunción.

not es invierte el valor de una variable.

operadores aritmeticos: +, -, *, /, %
operadores lógicos: and, or, not
operadores de comparación: ==, !=, >, <, >=, <=

Operadores de comparación

7 == 7 # Igual, resultado: true 
7 == 8 # Igual, resultado: false 
7 != 8 # Es distinto, resultado: true 
7 != 7 # Es distinto, resultado: false 
7 <  8 # Es menor, resultado: true 
7 >  8 # Es mayor, resultado: false 
7 <= 8 # Es menor o igual, resultado: false
7 >= 8 # Es mayor o igual, resultado: false 

Operador
= asignación
== compración

Se tiene los siguientes operadores:

1. Aritméticos
   Suma (+)
   Resta (-)
   Multilicación (*)
   División (/)
   División entera (//)
   Módulo (%)
   Exponente (%)

2. Asignación
   Asignación simple (=)
   Suma y asignación (+=)
   Resta y asignación (-=)
   Multiplicación y asignación (*=)
   División y asignación (/=)
   División entera y asiganción (//=)
   Módulo y asignación (%=)
   Exponente y asignación (**=)

3. Lógicos
   AND (and)
   OR (or)
   NOT (not)

4. Comparación
   Menor (<)
   Menor igual (<=)
   Mayor (>)
   Mayor igual ( >=)
   Igual (==)
   Distinto (!=)

Amigos si quieren invertir el valor lógico de una variable de manera permanente pueden hacer esto:

>> var_x = True
>> var_x = not(var_x)

Buenas noches compaleros aqui les dejo lo que practique en la consola. Tuve un error debido a que en vez de teclear True con la primer letra en mayuscula la teclee en minuscula.

Python 3.8.10 (default, Sep 28 2021, 16:10:42)
[GCC 9.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>
>>> #operadores logicos y de comparacion
>>> #Aqui tuve el error de asignar el valor con la primera minuscula al parecer
>>> #python es case sensitive
>>> es_estudiante = true
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'true' is not defined
>>> #termino del error
>>> es_estudiante = True
>>> trabaja = False
>>> es_estudiante and trabaja
False
>>> es_estudiante or trabaja
True
>>> not es_estudiante
False
>>> not trabaja
True
>>> numero1 = 5
>>> numero2 = 5
>>> numero1
5
>>> numero2
5
>>> numero1 == numero2
True
>>> numero1 != numero2
False
>>> numero1 > numero2
False
>>> numero1 < numero2
False
>>> numero1 >= numero2
True
>>> numero1 <= numero2
True
>>> numero3 = 8
>>> numero3
8
>>> numero1 == numero3
False
>>> numero1 != numero3
True
>>> numero1 > numero2
False
>>> numero1 < numero2
False
>>> numero1 >= numero2
True
>>> numero1 <= numero2
True
>>>

Como en todos los lenguajes, en Python existen los operadores lógicos.

• and (y). Compara dos o más expresiones y devuelve true si todas se cumplen, false si una no se cumple.

• or (o). Compara dos o más expresiones y devuelve true si por lo menos una es verdadera, si todas son falsas devuelve False.

• not (negar). niega el valor de la variable. Si se le aplica a un true devuelve false y viceversa.

También tenemos operadores de comparación, estos operadores trabajan con cualquier tipo de dato a diferencia de los lógicos que trabajan con expresiones.

• == Compara dos valores y devuelve true si son iguales, devuelve false si no. Este operador funciona a nivel tipo (devolvería false si se compara 10 (int) contra 10.0 (float) ).

• != Compara dos valores, devuelve true si son diferentes, devuelve false si son iguales. Este operador funciona a nivel tipo.

• > Compara dos valores, devuelve true si el primero es mayor al segundo, false si no.

• < Compara dos valores, devuelve true si el primero es menor al segundo, false si no.

• >= Lo mismo que los anteriores pero también compara la igualdad. Mayor o igual qué.

• <= Igual que los anteriores.

esto parece me recuerda a mi clase de filosofía donde veíamos negaciones 😅

la negación de la negación se hace verdadera 😬

Les quiero compartir que para escribir los valores booleanos, es siempre con MAyuscula al principio, vengo de javascript y me trabé un segundo jajaja

ejemplo:

estudiante = True
trabaja = false
//NOs arroja este error por escribir con minuscula el valor booleano de la linea 2
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
NameError: name 'false' is not defined

Operadores lógicos

and: compara dos variables y te indican si todas son ciertas o no. Es decir, si el dato booleano para cada una es True o si hay alguna que no lo sea.

or: Te indica si alguna de las dos variables son ciertas.

Operadores de comparación

== : te indica si ambas variables tienen un ismo valor o no.

!= : Te indica si ambas variables tinen un vaor diferente o no.

< : Te indica si una variable tiene un valor menor a la otra.

: Te indica si una variable tiene un valor mayor a la otra.

<=: Te indica si una variable tiene una valor menor o igual a la otra.

=: Te indica si una variable tiene un valor mayor o igual a la otra

Yo adicionalmente recomendaría profundizar en lógica proposicional, ya que nos ayuda a comprender mejor estos operadores y es un buen inicio para entender cálculo, un área matemática muy importante y necesaria en la programación.

and = todas las variables comparadas deben ser True para que arroje una resultado verdadero
or = Todas las variables deben ser falsas para que devuelva un falsas, si no devuelve un true
not = Invierte el valor de una variable
! = distinto

mayor que
< menor que
= mayor o igual
<= menor o igual

operadores lógicos y de comparación

and
or este operador es para evaluar si alguna de los dos comparaciones se cumple es verdadero caso contrario es falso
not

🤖🤖🤖
Lógicos:
and: si ambas condiciones se cumplen, regresa True.
Or: si UNA de las dos condiciones se cumple, regresa True.
Not: para invertir el valor booleano.
🤖🤖🤖
De comparación:
== Compara dos valores y te dice si son iguales o no.
!= Compara dos valores y te dice sin son diferentes o no.
-=== devuelve TRUE si ambos objetos son el mismo (en memoria)

Compara si es mayor que otro valor.
< Compara si es menor que otro valor.
= igual o mayor que el valor a comparar.
<= igual o menor que el valor a comparar.

numero1 = 5
>>> numero2 = 5
>>> numero1 == numero2
True
>>> numero3 = 7
>>> numero1 == numero3
False
>>> 

Resumen
Operadores lógicos

and

• Cuando ambas variables son True nos da resultado True

or

• Cuando uno de las variables es True nos da resultado True

not

• Cuando la variable es False nos da resultado True

>>> student = True
>>> employee = False
>>> student and employee
False
>>> student or employee
True
>>> not student
False
>>> not employee
True

Operadores de comparación

==

• Compara si ambos son iguales

!=

• Compara si ambos no son iguales

>

• Compara si es mayor que la otra variable

<

• Compara si es menor que la otra variable

>=

• Compara si la otra variable es mayor o igual que la otra variable

<=

• Compara si la otra variable es menor o igual que la otra variable

>>> number1 = 10
>>> number2 = 15
>>> number3 = 15
>>> number2 == number3
True
>>> number1 != number2
True
>>> number1 > number2
False
>>> number2 < number3
False
>>> number2 >= number3
True
>>> number3 <= number2
True

Me encanta como explica el profesor.
/
literalmente no deja nada para despues y eso me gusta. Si tiene que decirte que las variables tiene un scope y como funciona, te lo dice de una vez sin dejar nada para otro video u otra clase, en fin me gusta que no anda sin rodeos y directo al grano.

Operadores Lógicos y de Comparación
Practica:

True and True = True
True and False = False

True or True = True
True or False = True
False or False = False

not True = False
nor False = True

#Existe 3 tipos de operadores lógicos

log1 = False
log2 = True

#El operador AND
print(log1 and log2)
#El resultado va a ser:
"""False"""
"""Esto pasa porque el operardor AND nos da True sólo 
cuando las dos variables son True."""

#El operador OR
print(log1 and log2)
#El resultado va a ser:
"""True"""
"""Esto pasa porque el operardor OR nos da False sólo 
cuando las dos variables son False."""

#El operador NOT
print(not log2)
#El resultado va a ser:
"""False"""
"""Esto pasa porque el operardor NOT contradice el valor 
lógico de una variable."""

#Tabla de verdad

""" |p|AND|q|  |Resultado|
    |T|   |F|  |    F    |
    |F|   |T|  |    F    |
    |F|   |F|  |    F    |
    |T|   |T|  |    T    |"""

""" |p|OR|q|  |Resultado|
    |T|  |F|  |    T    |
    |F|  |T|  |    T    |
    |F|  |F|  |    F    |
    |T|  |T|  |    T    |"""

"""  NOT|p|  |Resultado|
        |T|  |    F    |
        |F|  |    T    |"""

#Operadores de comparación

num1 = 10
num2 = 20

#Operador '=='
#Se le conoce como operador de equivalencia

print(num1 == num2)
#El resultado va a ser:
"""False"""
"""Esto pasa porque lo que hace el operador '==' es comparar dos
variables para ver si son equivalentes o no."""

#Operador '!='
#Se le conoce como operador de diferencia

print(num1 != num2)
#El resultado va a ser:
"""True"""
"""Esto pasa porque lo que hace el operador '!=' es comparar dos
variables para ver si son diferentes o no."""

#Operador ">"
#Se le conoce como operador mayor

print(num1 > num2)
#El resultado va a ser:
"""False"""
"""Esto pasa porque lo que hace el operador '>' es ver si la primera
variable es mayor a la segunda variable o no."""

#Operador "<"
#Se le conoce como operador menor

print(num1 < num2)
#El resultado va a ser:
"""True"""
"""Esto pasa porque lo que hace el operador '<' es ver si la primera
variable es menor a la segunda variable o no."""

#Operador ">="
#Se le conoce como operador mayor o igual

print(num1 >= num2)
#El resultado va a ser:
"""False"""
"""Esto pasa porque lo que hace el operador '>=' es ver si la primera
variable es mayor o igual a la segunda variable o no."""

#Operador "<="
#Se le conoce como operador menor o igual

print(num1 <= num2)
#El resultado va a ser:
"""True"""
"""Esto pasa porque lo que hace el operador '<=' es ver si la primera
variable es menor o igual a la segunda variable o no."""

Operadores de Comparación

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.

Recuerden que:
Con AND
True + True = TRUE
True + False = False
False + True = False
False + False = False
Mientras que con OR
True + True = TRUE
True + False = False
False + True = TRUE
False + False = False

Aprendiendo mucho!! 😎💪🏻

>>> numero3 = 6        
>>> numero1 == numero3 
False                  
>>> numero1 != numero3 
True                   
>>> numero1 > numero3  
False                  
>>> numero1 < numero3  
True                   
>>> numero1 >= numero3 
False                  
>>> numero1 >= numero2 
True                   

son los operadores logicos que siempre nos ensenaron en la escuelita y ahora todo tiene sentido para que podemos usar xd

Buena clase!

Genial! muy buena explicacion, algo basico pero que es muy util en el desarrollo.

VAMOS POR EL PRIMER PROGRAMA!

Operadores Aritméticos, Operadores Lógicos y Operadores de Comparación

me encanta python, es tan entendible.

Este curso está excelente para refrescar el conocimiento empírico. El profesor es genial.

Estas tablas me ayudaron a comprender cómo funciona, son de circuitos electrónicos pero se aplica la misma lógica.