Enteros, Flotantes y Booleanos



Tipos de datos: * Enteros: Son todos los números enteros. Se representa con la palabra Integer (INT) * Flotantes: Son todos los números decimales. Se representa con la palabra FLOAT * Booleanos: Representa verdadero (true) o falso (false). La notación cientifica (exponencial) se utiliza cuando tenemos números muy grandes o muy pequeños y se utiliza con la nomenclatura e o E. Para comentar en Python se comienza el texto con # y automaticamente se coloca de color verde indicando que Python ignora esta sentencia.

Un dato importante sobre la función `print` y su presentación en consola: la función `print` acepta varios argumentos. Por ejemplo, cuando la profesora empezó a sumar las variables `print('Resultado de x + x:', x + x)` `print('Resultado de x + y:', x + y)` `print('Resultado de y + y:', y + y)` Como no hay un separador declarado, por defecto, la coma genera un espacio entre los argumentos.  Espero que les sirva.

El **typecasting** en Python se refiere a la conversión explícita de un tipo de dato a otro. Por curiosidad los invito a que lo intente. Acá les comparto unos cuantos ejemplos: ```python # Typecasting print(float(2)) print(int(2.6)) print(int(True)) print(int(False)) print(bool(1)) print(float(True)) print(type("hello" == "world")) ```

Dato curioso : El nombre de "bool" viene del matemático "George Boole" ya que creo el algebra booleana, un algebra que solo puede ser "True" o "False" y que en la actualidad forma la base de la lógica computacional moderna

corrijanme si me equivoco, pero a diferencia de js aca los valores booleanos deben empezar con mayuscula. otro punto a tener en cuenta es que si operas flotante con otro numerico el resultado sera flotante.

#### Enteros Los **enteros** son un tipo de datos que representan números sin decimales. En Python, se definen simplemente escribiendo el número sin ningún decimal. Por ejemplo, `5` es un entero.Aquí tienes un ejemplo de cómo se define y se utiliza un entero en Python: ```js # Definición de un entero numero_entero = 10 print(f"El número entero es: {numero_entero}") ```Al ejecutar este código, la salida será: `El número entero es: 10` #### Flotantes Los **flotantes** o números de punto flotante son un tipo de datos que representan números reales, es decir, números que pueden tener una parte decimal. En Python, se definen escribiendo el número con un punto decimal. Por ejemplo, `5.0` es un flotante.Aquí tienes un ejemplo de cómo se define y se utiliza un flotante en Python: ```js # Definición de un flotante numero_flotante = 10.5 print(f"El número flotante es: {numero_flotante}") ```Al ejecutar este código, la salida será: `El número flotante es: 10.5` #### Booleanos Los **booleanos** son un tipo de datos que representan verdadero o falso. En Python, se definen como `True` para verdadero y `False` para falso.Aquí tienes un ejemplo de cómo se define y se utiliza un booleano en Python: ```js # Definición de un booleano valor_booleano = True print(f"El valor booleano es: {valor_booleano}") ```Al ejecutar este código, la salida será: `El valor booleano es: True` 

En Python, `len()` es una función integrada que devuelve la longitud de un objeto. Aunque funciona con cadenas, no es un método de cadena, lo que significa que no pertenece a la clase `str`. Esto es parte de la filosofía de Python, donde se utilizan funciones en lugar de métodos para operaciones comunes que se aplican a múltiples tipos de datos. Por lo tanto, no puedes usar `"mi string".len()` porque `len()` no está definido como un método en la clase `str`. En su lugar, usas `len("mi string")`. Esta estructura permite que `len()` funcione con otros tipos de colecciones, como listas y tuplas, manteniendo la consistencia en el lenguaje.

Hola! me surgió una duda sobre la cantidad de decimales que python define en un print. Por qué surge lo siguiente?: x = 10 y = 5.678 print(x + y) Resultado: 15.678 vs. x = 10 y = 5.123 print(x + y) Resultado: 15.123000000000001 Agradezco desde ya cualquier aporte 😊?

Me pareció súper interesante que en el minuto 4:15, cuando se ejecuta el script con las variables z y a comentadas. El script empieza ejecutarse y de hecho imprime los tipos de las primeras variables y es cuando llega al print de z que el intérprete busca la variable, no la encuentra y da el error 😅

Hola 👋! les dejo un pequeño tutorial que escribí sobre los tipos de datos en Python como parte del cuso anterior \[Fundamentos de Python]\(https://platzi.com/cursos/python-fundamentos/) \[Aquí el tutorial]\(https://platzi.com/tutoriales/4227-python-fundamentos/21277-tipos-de-datos-en-python/) Espero este aporte les sea de utilidad 💜.


A las variables se les puede asignar tres tipos de datos los cuales son: Numero entero (int), decimal (float) y booleano que o verdadero y falso (bool)

seria genial poder ver los videos de platzi en ingles y español así podría practicar mi ingles, en caso de no entender bien un tema poderlo ver en español seria genial amo platzi y su comunidad son geniales

Hola! Les comparto el código de la clase. ```python # 6. Enteros, Flotantes y Booleanos x = 10 print(x) print(type(x)) # int y = 5.432 print(y) print(type(y)) # float z = 1.2e6 print(z) # 1200000.0 print(type(z)) # float a = 1E6 print(a) # 1000000.0 print(type(a)) # float b = 1.2E-6 print(b) # 1.2e-06 print(type(b)) # float print(x + x) # 20 print(x + y) # 15.432 print(y + y) # 10.864 print(z + a) # 2200000.0 # Booleans is_true = True print(is_true) # True print(type(is_true)) # bool is_false = False print(is_false) # False print(type(is_false)) # bool # https://chatgpt.com/share/679288da-0260-8003-8555-6ca278de58ca x = 10 y = 5.123 print(x + y) # 15.123000000000001 ```

``` x = 10 y= 5.678 z= 1.2E6 a= 1.2E-6 print( type (x) ) print( type (y) ) \# print( type (z) ) \# print( type (a) ) \# \<class 'int'> \# \<class 'float'> ```

Algo que me ha parecido curioso sobre los números en notación científica es que se utilizan para representar números muy grandes o muy pequeños, ya que necesitamos ser muy precisos con ellos. Es por eso que, en Python, los números en notación científica siempre serán de tipo float, incluso si no tienen decimales

Algo que me parece muy característico de Python, en comparación con lenguajes como C o Java, es que **no requiere declarar el tipo de dato al crear una variable**. Esto agiliza mucho la escritura del código y lo hace más flexible, especialmente en etapas tempranas del desarrollo. Sin embargo, esa misma flexibilidad exige que seamos **más rigurosos al validar los datos que recibimos**, ya que Python determina el tipo **en tiempo de ejecución**, no en tiempo de compilación. Esta característica puede ser una ventaja o una fuente de errores, dependiendo del contexto. Un caso clásico ocurre cuando se reciben datos desde el usuario, como texto (tipo `str`), y se espera realizar una operación matemática. Si no convertimos explícitamente el valor a un tipo numérico (`int` o `float`), el programa puede comportarse de manera inesperada, como concatenar cadenas en vez de sumar números. ```js # Entrada de usuario (siempre es tipo str por defecto) entrada = input("Ingresa un número: ") # Supongamos que escribe "5" # Si no se convierte, ocurre una concatenación (no suma) resultado_incorrecto = entrada + "10" print("Resultado sin conversión:", resultado_incorrecto) # Imprime: 510 # Conversión correcta a entero numero = int(entrada) resultado_correcto = numero + 10 print("Resultado con conversión:", resultado_correcto) # Imprime: 15 ```Por eso, comprender los tipos de datos y cómo se comportan en Python **no es solo teoría**, sino una práctica esencial para evitar errores silenciosos que pueden ser difíciles de detectar, especialmente en programas con interacción de usuario o integración de datos externos.


\#Enteros, Flotantes y BooleanosX = 10 #vamos a crear una nueva variable con YY = 5.678#z = 1.2E6#a = 1.2E-6 resultado = X + Yprint(X)#Preguntar cual es el tipo de este datoprint(type(X))print(Y)#Float hace referencia a punto flotante en español en phyton #cuando se hace referencia a numeros muy grandes o muy pequeños se recomienda usar la notación científicaprint(type(Y))#print(z)#print(a)print(X + Y)print(X - Y)print(X \* Y)#boolean puede crear estados como verdadero o falso \<class 'bool'>#este tipo de dato es poderoso a la hora de usar condicionalesis\_true = Trueis\_false = Falseprint(is\_true)print(type(is\_true)) \#ejercicio practico#1 Identificar tipos de datosprint(type(42)) # intprint(type(3.14)) # floatprint(type("hello")) # Strprint(type(True)) # bool#2 Operaciones con enteros y flotantesprint(resultado) # deberia traer 15.678print(type(resultado)) #deberia ser float \#Tu código está bien estructurado y ahora debería ejecutarse sin#problemas. Solo asegúrate de que las variables y funciones estén#correctamente escritas en minúsculas y mayúsculas, ya que Python es#sensible a las mayúsculas.```python ```

Un booleano es un tipo de dato que puede tener uno de dos valores: verdadero (True) o falso (False). Se usa comúnmente en programación para representar estados lógicos, como encendido/apagado o aprobado/reprobado. En Python, se define con la primera letra en mayúscula. En el contexto del curso de Python, se utilizan booleanos en estructuras condicionales para tomar decisiones en el código.

Una clase muy increíble! Como de poco en poco vamos descubriendo todas las infinitas maneras en las que podemos utilizar Python. Es supremamente increíble.

✅

Cómo puedo activar el Intellisense en Python? Por alguna razón no me aparece. Ya he intentado reiniciar VS.

```js name="Nicolas" print(len(name)) #1. Manipulación de cadenas #str.upper():Convierte todos los caracteres en mayúsculas. print("hola".upper()) # 'HOLA' #str.lower():Convierte todos los caracteres en minúsculas. print("HOLA".lower()) # 'hola' #str.capitalize(): #Capitaliza la primera letra de la cadena. print("hola".capitalize()) # 'Hola' #str.title(): #Capitaliza la primera letra de cada palabra. print("hola mundo".title()) # 'Hola Mundo' #str.strip(): #Elimina los espacios en blanco al inicio y al final de la cadena. print(" hola ".strip()) # 'hola' #str.replace(old, new): #Reemplaza todas las ocurrencias de una subcadena por otra. print("hola mundo".replace("mundo", "Python")) # 'hola Python' #str.split(sep): #Divide la cadena en una lista usando el separador dado. print("hola mundo".split()) # ['hola', 'mundo'] #str.join(iterable): #Une una secuencia de elementos en una sola cadena, utilizando el string como separador. print(", ".join(['hola', 'mundo'])) # 'hola, mundo' #2. Métodos para consultar características #str.startswith(substring): #Devuelve True si la cadena comienza con la subcadena dada. print("hola mundo".startswith("hola")) # True #str.endswith(substring): #Devuelve True si la cadena termina con la subcadena dada. print("hola mundo".endswith("mundo")) # True #str.isalpha(): #Devuelve True si la cadena contiene solo letras y no está vacía. print("hola".isalpha()) # True #str.isdigit(): #Devuelve True si la cadena contiene solo dígitos. print("1234".isdigit()) # True #str.isalnum(): #Devuelve True si la cadena contiene solo caracteres alfanuméricos (letras y números). print("hola123".isalnum()) # True #str.isspace(): #Devuelve True si la cadena contiene solo caracteres de espacio en blanco. print(" ".isspace()) # True #3. Métodos para búsqueda #str.find(substring): #Devuelve el índice de la primera aparición de la subcadena, o -1 si no se encuentra. print("hola mundo".find("mundo")) # 5 #str.index(substring): #Similar a find(), pero lanza una excepción si la subcadena no se encuentra. print("hola mundo".index("mundo")) # 5 #str.count(substring):Devuelve el número de veces que aparece la subcadena en la cadena. print("hola hola".count("hola")) # 2 ```name="Nicolas"print(len(name)) \#1. Manipulación de cadenas#str.upper():Convierte todos los caracteres en mayúsculas. print("hola".upper()) # 'HOLA'#str.lower():Convierte todos los caracteres en minúsculas. print("HOLA".lower()) # 'hola'#str.capitalize(): #Capitaliza la primera letra de la cadena. print("hola".capitalize())  # 'Hola'#str.title(): #Capitaliza la primera letra de cada palabra. print("hola mundo".title())  # 'Hola Mundo'#str.strip(): #Elimina los espacios en blanco al inicio y al final de la cadena. print("   hola   ".strip())  # 'hola'#str.replace(old, new): #Reemplaza todas las ocurrencias de una subcadena por otra. print("hola mundo".replace("mundo", "Python"))  # 'hola Python'#str.split(sep): #Divide la cadena en una lista usando el separador dado. print("hola mundo".split()) # \['hola', 'mundo']#str.join(iterable): #Une una secuencia de elementos en una sola cadena, utilizando el string como separador. print(", ".join(\['hola', 'mundo']))  # 'hola, mundo'#2. Métodos para consultar características#str.startswith(substring): #Devuelve True si la cadena comienza con la subcadena dada. print("hola mundo".startswith("hola"))  # True#str.endswith(substring): #Devuelve True si la cadena termina con la subcadena dada. print("hola mundo".endswith("mundo"))  # True#str.isalpha(): #Devuelve True si la cadena contiene solo letras y no está vacía. print("hola".isalpha())  # True#str.isdigit(): #Devuelve True si la cadena contiene solo dígitos. print("1234".isdigit())  # True#str.isalnum(): #Devuelve True si la cadena contiene solo caracteres alfanuméricos (letras y números). print("hola123".isalnum())  # True#str.isspace(): #Devuelve True si la cadena contiene solo caracteres de espacio en blanco. print("   ".isspace()) # True#3. Métodos para búsqueda#str.find(substring): #Devuelve el índice de la primera aparición de la subcadena, o -1 si no se encuentra. print("hola mundo".find("mundo"))  # 5#str.index(substring): #Similar a find(), pero lanza una excepción si la subcadena no se encuentra. print("hola mundo".index("mundo"))  # 5#str.count(substring):Devuelve el número de veces que aparece la subcadena en la cadena. print("hola hola".count("hola")) # 2

`name="Nicolas"print(len(name))` `#1. Manipulación de cadenas#str.upper():Convierte todos los caracteres en mayúsculas.` `print("hola".upper()) # 'HOLA'#str.lower():Convierte todos los caracteres en minúsculas.` `print("HOLA".lower()) # 'hola'#str.capitalize(): #Capitaliza la primera letra de la cadena.` `print("hola".capitalize())  # 'Hola'#str.title(): #Capitaliza la primera letra de cada palabra.` `print("hola mundo".title())  # 'Hola Mundo'#str.strip(): #Elimina los espacios en blanco al inicio y al final de la cadena.` `print("   hola   ".strip())  # 'hola'#str.replace(old, new): #Reemplaza todas las ocurrencias de una subcadena por otra.` `print("hola mundo".replace("mundo", "Python"))  # 'hola Python'#str.split(sep): #Divide la cadena en una lista usando el separador dado.` `print("hola mundo".split()) # ['hola', 'mundo']#str.join(iterable): #Une una secuencia de elementos en una sola cadena, utilizando el string como separador.` `print(", ".join(['hola', 'mundo']))  # 'hola, mundo'#2. Métodos para consultar características#str.startswith(substring): #Devuelve True si la cadena comienza con la subcadena dada.` `print("hola mundo".startswith("hola"))  # True#str.endswith(substring): #Devuelve True si la cadena termina con la subcadena dada.` `print("hola mundo".endswith("mundo"))  # True#str.isalpha(): #Devuelve True si la cadena contiene solo letras y no está vacía.` `print("hola".isalpha())  # True#str.isdigit(): #Devuelve True si la cadena contiene solo dígitos.` `print("1234".isdigit())  # True#str.isalnum(): #Devuelve True si la cadena contiene solo caracteres alfanuméricos (letras y números).` `print("hola123".isalnum())  # True#str.isspace(): #Devuelve True si la cadena contiene solo caracteres de espacio en blanco.` `print("   ".isspace()) # True#3. Métodos para búsqueda#str.find(substring): #Devuelve el índice de la primera aparición de la subcadena, o -1 si no se encuentra.` `print("hola mundo".find("mundo"))  # 5#str.index(substring): #Similar a find(), pero lanza una excepción si la subcadena no se encuentra.` `print("hola mundo".index("mundo"))  # 5#str.count(substring):Devuelve el número de veces que aparece la subcadena en la cadena.` `print("hola hola".count("hola")) # 2`

x = 10y = 5.678#z = 1.2E6#a = 1.2E-6 print(x)print(type(x)) #tipo INT print(y)print(type(y)) #tipo float \#print(z)#print(a) print(x + x)print(x + y)print(y + y) is\_true = Trueis\_false = False print(is\_true)print(is\_false) print(type(is\_true))

Notas: x = 1 y = 2.2 z = 2E2 #E es para numero elevado a la print(type(x)) print(type(y)) print(z) \#comentario -Boolean es verdadero o falso

Me pareció interesante como se invoca la notación cientifica, ciertamente un lenguaje muy práctico y versatil.. Muchas gracias profe Carla..

En esta clase estudiamos 3 tipos de datos , los cuales son: números enteros Int , números decimales Float y booleanos , verdadero o falso.

En esta clase vimos 3 tipos de datos: Intergers : Números enteros Float: Números con decimales Booleanos: Verdadero o Falso (La primera letra siempre debe de ir con mayúscula)

\- Los tipos de datos en Python definen la clase de información que una variable puede contener, identificable mediante la función type(). \- Enteros (int) representan números sin decimales, útiles para operaciones aritméticas básicas. \- Flotantes (float) manejan números con decimales y pueden usar notación científica para valores muy grandes o pequeños. \- Booleanos (bool) tienen dos valores posibles: True o False, fundamentales para operaciones lógicas y control de flujo. \- Las operaciones entre enteros y flotantes devuelven resultados en float. \- Los comentarios en Python se crean con el símbolo # y son ignorados durante la ejecución. \- Python permite realizar operaciones matemáticas básicas como suma, resta, multiplicación y división.

¿Por qué siempre está el archivo License en recursos? Van 5 clases y nunca se explicó para qué es.

## **Int** Int, o entero, es un número entero, positivo o negativo, sin decimales, de longitud ilimitada. ```js x = 1 y = 35656222554887711 z = -3255522 ```Un número flotante o "número de punto flotante" es un número, positivo o negativo, que contiene uno o más decimales. ```js x = 1.10 y = 1.0 z = -35.59 ```


como aporte compañe@s Python soporta decimal, hexadecimal, octal y binario.

```js x = 10 y = 5.678 # z = 1.2e8 # a = 1.2e-8 print(type(x)) print(type(y)) #print(z) #print(a) print(x+x) print(x+y) print(y+y) is_true = True is_false = False print(is_true) print(type(is_true)) ```x = 10y = 5.678# z = 1.2e8# a = 1.2e-8print(type(x))print(type(y))#print(z)#print(a)print(x+x)print(x+y)print(y+y)is\_true = Trueis\_false = Falseprint(is\_true)print(type(is\_true))

Esto pasa si intentan hacer operaciones con Booleanos. Algunos ejemplos: ```js is_true = True is_false = False print(type(is_true)) # <class 'bool'>. True y False deben iniciar con mayúscula. print(type(is_false)) # <class 'bool'> print(is_true * is_false) # True = 1, False = 0. 1 x 0 = 0 print(is_true + is_false) # True = 1, False = 0. 1 + 0 = 1 print(is_true / is_true) # True = 1, 1 / 1 = 1. Devuelve un flotante. print(is_false - is_true) # False = 0, 0 - 1 = -1. Devuelve un entero. ```

**Resumen:** 


 <https://github.com/iecgerman/10002-python>

Muy buena explicación!


```txt ``` ```python #ENTEROS - Son numeros sin punto decimal, desde positivos, negativos e incluso 0 # pueden ser de cualquier tamano entero_1 = 5 entero_2 = 10 # Pueden hacer cualquier operacion comun (suma, resta, divicion, etc.) print ( entero_1 + entero_2) print ( entero_1 - entero_2) print ( entero_1 / entero_2) #FLOTANTES - Son numeros que tienen numero decimal, se utilizan para las fracciones y decimales. flotante_1 = 5.0 flotante_2 = 11.865 # print(type(flotante_1)) # Estos tambien tienen los mismas operaciones que los enteros (suma, resta, divicion, etc). print(flotante_1 + flotante_2) print(flotante_1 - flotante_2) print(flotante_1 / flotante_2) # *CUIDADO* Al hacer operaciones entre enteros y flotantes, son dara un flotante, pero si usamos un entero # con un entero obtenemos un entero, hay que tener en cuenta estos resultados al momento de utilizarlos. # BOOLEANOS - Son datos que solo pueden tener dos valores 'True' y 'False' estos deben de comenzar por mayuscula # son utilizados para operaciones logicas y condiconales. a = True b = False ```

En Python, existen varios tipos de variables, cada una con sus propias características. 1. **Enteros (int):** * Las variables de tipo entero almacenan números enteros sin decimales. * Por ejemplo, podemos declarar una variable llamada “edad” y asignarle el valor 25. * Los enteros pueden ser positivos o negativos. 2. **Flotantes (float):** * Las variables de tipo flotante almacenan números decimales. * Por ejemplo, podemos tener una variable “precio” con el valor 19.99. * Los flotantes también pueden representar números científicos, como 3.14e-2. 3. **Booleanos (bool):** * Las variables booleanas almacenan valores de verdad: `True` o `False`. * Son útiles para expresar condiciones o resultados lógicos en el código. * Por ejemplo, una variable “es\_mayor\_de\_edad” podría ser `True` o `False`. 4. **Complejos (complex):** * Las variables de tipo complejo almacenan números complejos, que tienen una parte real y una parte imaginaria. * Por ejemplo, podemos declarar una variable “numero\_complejo” con el valor `3 + 2j`. 5. **Cadenas (string):** * Las variables de tipo cadena almacenan texto. * Pueden contener letras, números, espacios y caracteres especiales. * Por ejemplo, una variable “nombre” podría contener el valor “Juan”.

Saludos, un pequeño aporte usando separador de Miles para el campo flotante: