No tienes acceso a esta clase

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

Tipos de datos: booleanos

4/17
Recursos

Los tipos de datos booleanos consisten en representar la lógica binaria, únicamente dos valores 0 y 1. Generalmente, este tipo de dato es representado por los valores verdadero (1) y falso (0), en inglés True y False.

Cómo utilizar los tipos booleanos

A través de datos booleanos, podemos realizar operaciones lógicas, para saber si un proceso se debe realizar (verdadero) o no (falso).

Por ejemplo, cuando inicias sesión en Platzi, tu estado cambia a verdadero, entonces ejecuta una serie de pasos, como mostrarte cursos o tus puntos. Cuando cierras sesión, tu estado cambia a falso, entonces ejecuta otras instrucciones, como mostrarte la página inicial.

En un diagrama de flujo se graficaría de la siguiente manera:

Diagrama de flujo para tipos booleanos

Contribución creada por Andrés Guano (Platzi Contributor).

Aportes 265

Preguntas 12

Ordenar por:

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

📝Notas

Datos tipo booleano: Este tipo de datos representa una cantidad lógica que es una respuesta a una pregunta de verdadero o falso.
Su representación
True = 1
False = 0

Si la condición se cumple sería true y si no se cumple sería false. En este caso del diagrama de flujo nos podría llevar a otro proceso o incluso al final.

Reto de la clase, ejemplo evaluación True / False

  1. Inicio
  2. Estudiar
  3. Aplicar los aprendido
  4. Tomar exámen y aprovarlo
  5. Aprovaste exámen?
    (True, ir al paso 6. False. Ir al paso 2)
  6. Continuar aprendiendo otro tema.

a este lo llamo el diagrama de nunca pares de aprender😊

Ejemplo de caso :

  1. Inicio
  2. Entrar a la tienda, elegir y probarte la prenda que te guste
  3. ¿ Te quedo bien la prenda seleccionada?
    ( True = Pasar a caja a pagar ; False = Probarse otra talla)
  4. Fin

Diagrama de flujo usando un tipo de dato booleano:

NOTA RAPIDA:

DATOS BOOLEANOS:

Variantes similares:
(cambia la cantidad de espacio físico en memoria)

El tipo de dato lógico o booleano es en computación aquel que puede representar valores de lógica binaria, esto es 2 valores, que normalmente representan falso o verdadero

Les dejo un enlace, para revisar un poco más a profundidad, a quien desarrollo el concepto de este tipo de datos, George Boole.
https://www.repositoriodigital.ipn.mx/bitstream/123456789/22017/1/GEORGE BOOLE Y LA LOGICA SIMBOLICA.pdf

Los datos booleanos se usan en donde el estado únicamente tiene 2 valores. Ejemplos:

  • inició sesión / no inició sesión.
  • es mayor de edad / no es mayor de edad.
  • suscripción activa / suscripción inactiva
    En general, solo existirían 2 posibles estados.

Los datos booleanos son un tipo de dato fundamental en la programación y la lógica que representa dos valores posibles: verdadero (true) o falso (false). Estos valores se utilizan para evaluar condiciones y tomar decisiones dentro de un programa.

En la mayoría de los lenguajes de programación, los datos booleanos se representan mediante palabras clave reservadas, como “true” y “false”. Estas palabras clave suelen ser sensibles a mayúsculas y minúsculas, lo que significa que “True” o “FALSE” pueden no ser reconocidos como valores booleanos válidos.

Los datos booleanos son utilizados en muchas situaciones, como en estructuras de control condicionales, donde una determinada instrucción o bloque de código se ejecuta si una expresión booleana se evalúa como verdadera, o se salta si es falsa. También se utilizan en bucles para controlar la repetición de un conjunto de instrucciones mientras una condición sea verdadera.

Además de los valores literales “true” y “false”, los datos booleanos también se pueden obtener como resultado de operaciones de comparación o evaluaciones lógicas. Algunos operadores relacionales, como “mayor que” (>), “menor que” (<), “igual a” (==), “mayor o igual que” (>=) y “menor o igual que” (<=), devuelven un valor booleano como resultado de la comparación.

También se pueden utilizar operadores lógicos, como “y” (&&), “o” (||) y “no” (!), para combinar expresiones booleanas y obtener resultados más complejos. Por ejemplo, la expresión “A && B” evaluará como verdadera solo si tanto A como B son verdaderas.

En resumen, los datos booleanos son un tipo de dato fundamental que representa valores de verdad, permitiendo la evaluación de condiciones y toma de decisiones en la programación. Los valores booleanos pueden ser verdadero (true) o falso (false), y se utilizan en estructuras de control condicionales, bucles y operaciones lógicas.

ahora voy a hacerme algo de almorzar

Los tipos de datos booleanos representan la lógica binaria y se componen únicamente de dos valores: verdadero (1) y falso (0), que también pueden ser representados en inglés como True y False, respectivamente.

Estos datos booleanos son ampliamente utilizados en programación para tomar decisiones basadas en condiciones lógicas. Las operaciones lógicas se realizan evaluando si una condición es verdadera o falsa, lo que permite ejecutar ciertas acciones dependiendo del resultado obtenido.

Un ejemplo sencillo de cómo se utilizan los datos booleanos sería en un sistema de inicio de sesión. Cuando un usuario inicia sesión en una plataforma, su estado cambia a verdadero (True), lo que permite ejecutar una serie de pasos o acciones adicionales, como mostrar cursos, puntos o contenido personalizado. Por otro lado, cuando el usuario cierra sesión, su estado cambia a falso (False), lo que desencadena otras instrucciones, como mostrar la página de inicio o la página de registro.

Las operaciones lógicas se basan en los principios de la lógica booleana, que es una rama de la lógica matemática desarrollada por George Boole en el siglo XIX. Estas operaciones se utilizan para evaluar expresiones lógicas y se combinan mediante los operadores lógicos más comunes: AND (y), OR (o) y NOT (no).

Los datos booleanos son fundamentales en la programación, ya que permiten crear algoritmos y programas que toman decisiones y ejecutan diferentes acciones según las condiciones que se cumplan. Al evaluar expresiones lógicas con datos booleanos, los programas pueden responder de manera inteligente y adaptarse al comportamiento del usuario o al estado de las variables en tiempo de ejecución.

![](

1.- Inicio el video: true | if video no se re reproduce (f5)
2.- Estás viendo el video: true | if no estás viendo el video, dile a tu hermano que deje de ver Netflix.

Los tipos de datos booleanos representan valores lógicos, es decir, valores que pueden ser verdaderos o falsos. Estos son fundamentales en la programación para la toma de decisiones y la lógica condicional.
Comparto mi aporte ![](https://static.platzi.com/media/user_upload/image-94380e65-ea1d-4af8-a41d-207632370744.jpg)
Acá el ejemplo ![](https://static.platzi.com/media/user_upload/Captura%20de%20pantalla%202023-10-06%20a%20la%28s%29%2010.12.07-638eeec6-e15a-413e-b43a-94a799129fd0.jpg)

Ejemplo en donde se muestra una desicion al final que el resultado es True:

Diagrama de flujo de un usuario hecho con Mermaid en Notion. simple y bonito : ).

ejemplo:

  1. inicio.
  2. ¿tengo hambre? false=>continuo con lo que estaba
    haciendo.
    =>FIN.
    true=>me dirijo a la cocina.
  3. me preparo algo de comer.
  4. me como la que prepare.
  5. fin.
/*Ejemplo de uso de un tipo de dato boolean*/

Tengo sed? =>True="Busco un vaso de agua💧"
	|False
	V
	"Sigo aprendiendo en Platzi💚"
  • Booleanos:

    Definición🗒️: Hacen referencia a aquellos dos posibles estados de Verdadero o Falso característicos del sistema binario o la lógica proposicional. True(1) y False(0).

    Usos🪚: Son ampliamente usados en el flujo de nuestros programas, sobre todo en las estructuras condicionales y cíclicas, o incluso en las bases de datos.

    Operaciones🧨: Podemos obtener datos de tipo booleano al usar operadores relacionales(mayor, menor, igual, etc), y además entre booleanos podemos usar los operadores lógicos vistos en cursos anteriores(Y, O, XOR, NO, SI, SI Y SÓLO SI, etc)

Ejemplo🚀:

.

Asi nomas quedo mi compuerta !!!

🖥💻Datos booleanos

Mini-diagrama de flujo usando (true/false) como datos booleanos:

1.Inicio
2.Encender una motocicleta
3.Meter llave en el switch y dar vuelta
4.Poner en neutra moto
5.Tiene gasolina la moto?
(True ir al paso 6, Falso ir al paso 7)
6.Dar patada a palanca de arranque y acelerar un poco.
7. Fin

Algoritmo para verificar si la puerta está bien cerrada

Datos booleanos:

  • Datos booleanos:
    • True
    • False
  • Permite identificar el valor de verdad, ausencia o no de un dato.
1.- inició, 2.-te sabes las tablas de multiplicar; true( comienza hacer operaciones mentales) false (repasa las tablas una vez más) 3.- realiza la prueba final, 4.- fin.

Inicio
ir a la tienda
comprar huevos
hay suficientes huevos para comprar?
true /false
fin

es mejor opcion tomarle foto a los apuntes que ver en si la clase
Mi reto: ![](https://static.platzi.com/media/user_upload/Conducir%20al%20trabajo-396e47b7-be5f-46f3-9ed8-07337e738345.jpg)
Sempre tendre asociado los datos booleanos con el sistema binario :D
Diagrama de flujo, impresión tickets entrada cine ![](https://static.platzi.com/media/user_upload/Impresion%20Ticket-c2358e3c-adc5-4cbd-b6f8-91382d996f14.jpg)
**Ejemplo de booleano:** \-------------------------- Algoritmo: Ducharse 1. **Inicio** 2. **Verificar si hace frío** * **Dato booleano**: `haceFrio` 3. **Si haceFrio es verdadero** * **Acción**: Usar agua caliente * **Acciones**: * Abrir la llave de agua caliente * Ajustar la temperatura * Ducharse 4. **Si haceFrio es falso** * **Acción**: Usar agua fría * **Acciones**: * Abrir la llave de agua fría * Ajustar la temperatura * Ducharse 5. **Fin**
Los datos de tipo booleano, que representan valores de verdad (verdadero o falso), están disponibles en la mayoría de los lenguajes de programación modernos. Sin embargo, la representación y el uso de los booleanos pueden variar ligeramente entre lenguajes. Aquí tienes algunos ejemplos: ### <u>Python</u> verdadero = True falso = False ### <u>JavaScript</u> let verdadero = true; let falso = false; ### <u>Java</u> boolean verdadero = true; boolean falso = false; ### <u>C#</u> bool verdadero = true; bool falso = false; ### <u>PHP</u> $verdadero = true; $falso = false; ### <u>C++</u> bool verdadero = true; bool falso = false; En todos estos lenguajes, los valores booleanos se utilizan de manera similar, aunque la sintaxis puede variar. Además, algunos lenguajes permiten usar otros valores (como 0 y 1) para representar booleanos, pero es una práctica menos común y puede depender del contexto del lenguaje.
Aquí está mi ejemplo: Una pregunta basica de un formulario para un usuario y saber si es mayor de edad o no: `flowchart TD` ` A[Inicio] --> B[Ingresar edad]` ` B --> C{¿Edad >= 18?}` ` C -- Sí --> D[Asignar mayorEdad = True]` ` C -- No --> E[Asignar mayorEdad = False]` ` D --> F[Mostrar "Mayor de edad"]` ` E --> G[Mostrar "Menor de edad"]` ` F --> H[Fin]` ` G --> H[Fin]`
Diagrama Principales fallas en la SNES y su reparación![](https://static.platzi.com/media/user_upload/Diagram-SNES-f6385e9f-a695-41b6-a94a-d4f4beaad940.jpg)
Los datos Booleanos pueden desenvolverse en True (0) o False (0), concluyendo en un proceso de nuestro algoritmo o a su final. Ejemplo: ¿Estás conforme con los métodos de enseñanza de Platzi? 1 True (1) -> Fin del proceso 2 False (0) -> Te comparten el foro de alumnos para que aprendas en comunidad y resuelvas tus dudas.
![](https://static.platzi.com/media/user_upload/Diagrama%20sin%20t%C3%ADtulo.drawio%20%281%29-f25a7f77-a377-4ace-a8fe-96ce503c16a4.jpg)
Hola a todos! ![](https://static.platzi.com/media/user_upload/image-18a8b756-1c10-4eeb-930b-4bb835ba3b1d.jpg)
El mío quedó de la siguiente forma: ![](https://static.platzi.com/media/user_upload/did%20flujo%20booleano.drawio-f0c79e3c-ce05-4891-8e51-7cf529c4e89e.jpg)
![](https://static.platzi.com/media/user_upload/Captura%20de%20pantalla%202025-01-20%20153535-441ea3f5-eadc-47c7-b18a-ee093e7e89bd.jpg)
![](https://static.platzi.com/media/user_upload/image-068dc621-8e3f-4c6b-a83e-e806a7e9d046.jpg)
* Estudiar en Platzi? 1 -> True -> Aprender Algoritmos 0 -> False -> No Aprender Algoritmos
```js int num1; int num2; bool resultado; Console.WriteLine("Ingrese dos numeros enteros"); num1 = int.Parse(Console.ReadLine()); num2 = int.Parse(Console.ReadLine()); resultado = num1 > num2; Console.WriteLine($" la comparacion es {resultado}"); ```int num1; int num2; bool resultado; Console.WriteLine("Ingrese dos numeros enteros"); num1 = int.Parse(Console.ReadLine()); num2 = int.Parse(Console.ReadLine()); resultado = num1 > num2; Console.WriteLine($"El resultado es {resultado}");
Algoritmo calcularArea Definir area, radio Como Real Repetir Escribir 'ingrese el radio del circulo:' Leer radio Hasta Que radio>0 area <- (radio\*radio)\*PI Escribir 'el area del circulo es: ', area FinAlgoritmo
Gracias\_por\_la\_clase
`buenas_aquí_el_flujo_de_trabajo` Inicio 1. Cocinar 2. Ir a la nevera 3. ¿Hay comida? (1, ir al siguiente paso. 0, ir de compras) 4. Preparar los productos 5. ¿Hay útiles de cocina?(1, ir al siguiente paso. 0, ir a comprarlos) 6. Prender la cocina 7. poner el producto encima del útil de cocina 8. ¡A cocinar! Fin
![](https://static.platzi.com/media/user_upload/True%20False-07260684-f6c8-4a3c-9a35-5d2db0a9d8d9.jpg)
![](https://static.platzi.com/media/user_upload/Datos_booleanos-im%C3%A1genes-0-df9cb390-bd91-4a5d-8f82-aa54bbc22d97.jpg)![](https://static.platzi.com/media/user_upload/Datos_booleanos-im%C3%A1genes-1-609f977c-1540-4fe5-9f72-f716e83eb851.jpg)
**Los tipos de datos booleanos consisten en representar la lógica binaria, únicamente dos valores 0 y 1.** Generalmente, este tipo de dato es representado por los valores verdadero (`1`) y falso (`0`), en inglés *True* y *False*.
Algoritmo para ingreso a la universidad: Validacion\_cedula= True Si (Validacion\_cedula==False) { “Acceso denegado” } Sino { “Acceso exitoso” }
![](https://static.platzi.com/media/user_upload/image-4cceec7e-0039-4961-a04d-0566d48b4629.jpg) Pronostico del tiempo
🍃 Los tipos de datos booleanos son fundamentales en la programación, ya que permiten representar la lógica binaria con solo dos valores: 0 y 1. Generalmente, estos valores se representan como **verdadero** (1 o `true`) y **falso** (0 o `false`). ### Utilización de los Tipos Booleanos A través de datos booleanos, podemos realizar operaciones lógicas y controlar el flujo de un programa. Los booleanos se utilizan para determinar si un proceso debe ejecutarse o no, basándose en condiciones evaluadas como verdaderas o falsas. ### Ejemplo de Uso: Sesión en Platzi Cuando inicias sesión en Platzi: * El estado de sesión cambia a `true`. * Se ejecutan una serie de pasos, como mostrar cursos y puntos acumulados. Cuando cierras sesión en Platzi: * El estado de sesión cambia a `false`. * Se ejecutan otras instrucciones, como mostrar la página inicial. ### Ejemplos en Diferentes Lenguajes de Programación ### JavaScript En JavaScript, los booleanos se representan como `true` y `false`. Se utilizan en estructuras de control como `if`, `while` y `for`. let usuarioLogueado = true; if (usuarioLogueado) { console.log("Mostrar cursos y puntos"); } else { console.log("Mostrar página inicial"); } ### PHP En PHP, los booleanos también se representan como `true` y `false`. Se utilizan de manera similar en estructuras de control. \ ### Python En Python, los booleanos se representan como `True` y `False` (notar la mayúscula inicial). Se utilizan en estructuras de control y expresiones lógicas. usuario\_logueado = True if usuario\_logueado: print("Mostrar cursos y puntos") else: print("Mostrar página inicial") ### Operaciones Lógicas con Booleanos Los datos booleanos son esenciales para realizar operaciones lógicas. Aquí hay algunos ejemplos de operaciones lógicas comunes en los tres lenguajes: ### JavaScript let a = true; let b = false; // Operador AND (&&) console.log(a && b); // false // Operador OR (||) console.log(a || b); // true // Operador NOT (!) console.log(!a); // false ### PHP \ ### Python a = True b = False \# Operador AND (and) print(a and b) # False \# Operador OR (or) print(a or b) # True \# Operador NOT (not) print(not a) # False ### Aplicaciones de los Booleanos 1. **Autenticación**: Verificar si un usuario está autenticado para permitir el acceso a ciertas partes de una aplicación.if usuario\_autenticado: mostrar\_panel\_control() else: mostrar\_pagina\_inicio() 2. **Validación de Datos**: Comprobar si los datos ingresados por el usuario son válidos antes de procesarlos.let formularioValido = true; if (formularioValido) { enviarFormulario(); } else { mostrarErrores(); } 3. **Control de Flujo**: Decidir si se debe repetir una operación basándose en una condición.\ ### Conclusión Los tipos de datos booleanos son esenciales en la programación, ya que permiten realizar operaciones lógicas y controlar el flujo de los programas. Comprender cómo utilizar booleanos en diferentes lenguajes de programación es crucial para escribir código efectivo y eficiente. Los ejemplos en JavaScript, PHP y Python muestran cómo los booleanos se utilizan en diversas situaciones prácticas.
import random \# Generar un valor booleano aleatorio P = bool(random.randint(0, 1)) print(P) if P: print("True") else: print("False")
![](https://static.platzi.com/media/user_upload/image-5874bb3f-c26a-49d6-a0a1-cb5c7bd9d969.jpg)
```js if (aprobo) { curso = "New Job"; } else { curso = "intenta de nuevo"; } ```if (hour < 18) { greeting = "Good day"; } else { greeting = "Good evening"; }
Adjunto un algoritmo sencillo donde utilizamos true y false Para los que quieran diagramar pueden utilizar software libre como Dia en linux o en windows. ![](https://static.platzi.com/media/user_upload/imagen-82720946-b0af-4b8e-a6f4-71a3b3d7a2e0.jpg)
![](https://static.platzi.com/media/user_upload/Proceso%20de%20venta-69753bad-cf1a-40ad-b4c6-ee1583ea094d.jpg)
DEFINE num INTEGER LET num=7 IF num<=10 THEN DISPLAY "El número es menor o igual a 10" ELSE DISPLAY "El número es mayor a 10" END IF
DEFINE num INTEGER LET num = 7 IF num <= 10 THEN DISPLAY "El número es menor o igual a 10" ELSE DISPLAY "El número es mayor de 10" END IF
DEFINE num INTEGER LET num = 7 IF num <= 10 THEN DISPLAY "El número es menor o igual a 10" ELSE DISPLAY "El número es mayor de 10" END IF
Define num INTEGER LET num=7 IF num <=10 THEN DISPLAY("El número es menor o igual a 10") ELSE DISPLAY("El número es mayor de 10") END IF
![](https://static.platzi.com/media/user_upload/Diagrama_PC-85f8785f-5832-4516-8d05-914d1f077e48.jpg)
```html ``` ```js ```
Algoritmo para el consumo de scoop de proteina luego de entrenar en el gimnasio: ![](https://static.platzi.com/media/user_upload/image-f025460c-e7ad-41f1-a700-642c8e50439d.jpg) ![]()
Los algoritmos de clasificación de ML tipo arboles de decisión usa evaluación de condiciones para determinar si es true o false y poderlo encasillar de determinado grupo.
Mi Ejercicio De Un Diagrama De Flujo Con El Método Booleano: Por favor necesito que alguien me diga como voy.👇 ![](https://static.platzi.com/media/user_upload/Dublin-a73226ac-d473-4930-90e3-4b01e1e25078.jpg)
* Inicio de sesión de una plataforma WEB ![](https://static.platzi.com/media/user_upload/diagram-export-7-3-2024-07_44_08-b80f08fa-9a18-4ecf-8e7a-0cf5980427db.jpg)
![](https://static.platzi.com/media/user_upload/Booleano1.drawio-2821c1ca-fe35-44ac-b0ca-0ea5b7455ca2.jpg)
![](https://static.platzi.com/media/user_upload/Untitled%20diagram-2024-03-05-032032-6b28cde9-38b6-40d5-9ad1-7f331c3bfe0f.jpg)
PIKACHUUUUUUUUUUU
![](https://static.platzi.com/media/user_upload/image-da415fb4-2354-4f25-b98a-bd16d7e2ebf7.jpg)Cada cierto tiempo debo estar pendiente de la comida de mis gatos, ya sé que más o menos cada 2 semanas debo pedir la comida, pero igual para tomar la decisión es así
Los tipos booleanos se utilizan en programación para representar valores de verdad, es decir, valores que pueden ser verdaderos o falsos. Aquí te muestro algunos ejemplos de cómo puedes utilizar los tipos booleanos en diferentes contextos: 1. **En instrucciones condicionales (if-else)**: Puedes utilizar tipos booleanos para controlar el flujo de ejecución en tu programa. Por ejemplo: pythonCopy code`x = 5` `if x < 10`: ` print("x es menor que 10"`) `else`: ` print("x no es menor que 10"`) 1. **En expresiones de comparación**: Puedes usar expresiones de comparación que devuelvan valores booleanos. Por ejemplo: pythonCopy code`a = 3` `b = 7` `es_menor = a < b # True` `es_igual = a == b # False` 1. **En operaciones lógicas**: Puedes combinar valores booleanos con operadores lógicos como AND, OR y NOT. Por ejemplo: pythonCopy code`x = 5` `y = 10` `z = 15` `resultado = (x < y) and (y < z) # True` 1. **Almacenamiento de valores de verdad**: Puedes almacenar valores booleanos en variables para utilizarlos más tarde en tu programa. Por ejemplo: pythonCopy code`es_verdadero = True` `es_falso = False` 1. **En bucles**: Puedes usar tipos booleanos para controlar cuándo un bucle debe continuar ejecutándose o detenerse. Por ejemplo: pythonCopy code`contador = 0` `while contador < 5`: ` print("Hola"`) ` contador += 1` En este ejemplo, `contador < 5` es una expresión booleana que evalúa si el contador es menor que 5. Mientras esta expresión sea verdadera, el bucle continuará ejecutándose. Estos son solo algunos ejemplos de cómo puedes utilizar los tipos booleanos en programación. Son una herramienta fundamental para controlar el flujo de ejecución y tomar decisiones en tus programas.
Se podria utilizar como ejemplo para saber si alguien es mayor de edad, si es igual o mayor a 18 es mayor de edad y si es menor que de 18 es menor de edad![](https://static.platzi.com/media/user_upload/image-53eabcb5-8550-4913-a165-03b8531a4b90.jpg)

Según mi lógica debería funcionar como los diagramas pasados pero solo que internamente manejamos como variables true o false

1. Voy a comprar un juego 2. me gusta el juego? - True: Puedo comprar el juego? - True: Compro el juego y Fin - False: No habia dinero, Fin - False: Buscar otro juego
![](https://static.platzi.com/media/user_upload/IMG_0008-0e6a291b-0ee7-4998-83dc-8d498c6221a7.jpg)
![](https://static.platzi.com/media/user_upload/image-c35eb2e8-192d-4df6-bec5-4363c21dabc9.jpg)
![]()![]()![](C:\Users\Andre\Downloads)![]()![]()![](https://static.platzi.com/media/user_upload/Diagrama%20de%20flujo%20de%20Electronica-3b6f058a-acdf-4a5b-bce7-4deccd60c57c.jpg) Este es mi aporte.

Los postulantes a una universidad que acaban de rendir un examen:

  • si han obtenido una nota mayor o igual a 80, pasan
  • si han obtenido una nota menor a 80, no pasan.
Si hay frio 1 Usar sueter Si hay frio 0 No usar sueter
Envío mis ejemplos: * not true = false * not false = true * true and true = true * false or false = false * 7 < 2 = false * 7 > 2 = true * 5 = 5 = true
# Tipos de datos: booleanos Se representan en `True o False ` 1 0 True: Activo False: Inactivo Sin importantes para conectar flujos de trabajo.

En electronica un voltaje osea un 1 es un true y un bajo es un 0 o un false, esto lo puedes ver en una funcion seno por ejemplo que es ciclica y tine altoa y bajos, generalmente en eletroniva esto se mira con un osciloscopio

Hola, comparto mi reto. Agradezco el feedback.

Alguien que me indique como subir una foto acá por favor, el botón de añadir imágenes no me funciona XD
![](https://ton.twitter.com/1.1/ton/data/dm/1723186732600819816/1723186730268868608/UhmOz2oJ.jpg:large)![](https://static.platzi.com/media/user_upload/399735504_871362801293722_8052094626777549083_n-6479c77e-4d00-4af0-8e4c-55e40a1d6cff.jpg) Mi diagrama, recibo comentarios jajaja