Tipos de datos

Tipos de datos primitivos

• Integers: números Enteros
• Floats: números de punto flotante (decimales)
• Strings: cadena de caracteres (texto)
• Boolean: boolenaos (Verdadero o Falso)

Tipos de dato adicionales

• Datos en texto: str
• Datos numéricos: int, float, complex
• Datos en secuencia: list, tuple, range
• Datos de mapeo: dict
• Set Types: set, frozenset
• Datos booleanos: bool
• Datos binarios: bytes, bytearray, memoryview

Como tipo de datos tenemos:

• string (“una cadena de caracteres”)
• int (para numeros enteros)
• float (para numeros decimales)
• boolean (para datos verdaderos y falsos)
• inputs (son datos provenientes del usuario)

Les recomiendo este libro para complementar el curso, lo estoy estudiando y ahonda mas en cada tema por ejemplo nos muestra un dato no tan usado que es el de Complex que se ve algo asi:

>>> type(1j)
<class’complex’>

la verdad me sirve demasiado espero le sea de ayuda :
https://drive.google.com/drive/folders/150r8EJNAW9vauYZdm6Crzk2-Tgoqyjtv?usp=sharing

recordar que python es de tipado dinamico, esto quiere decir que después de que le asignamos un contenido a una variable , esta tomara el tipo que corresponde al contenido, a diferencia de otros lenguajes no debemos especificar el tipo.

podemos forzar el tipo de un input así
edad2= int(input("su edad por favor "))
print(“su edad =>”,edad2,type(edad2))
La salida es
su edad por favor 38
su edad => 38 <class ‘int’>

Python data Types

Categoría de los tipos de datos:

Saludos!!!

Resumen SM 🚀

Tipos de datos

Existen varios tipos de datos en Python, los 3 mas conocidos son:

• String: Cadenas de texto.

  • nombreVariable = “texto”
  • nombreVariable = ‘texto’

• Int: números enteros.

  • nombreVariable = 12

• Boleanos: Tiene dos estados True(verdadero) ó False(falso).

  • nombreVariable = True

Para saber cual es el tipo de una variable podemos usar la función type(variable) y se puede imprimir usando print().

• print(type(variable))

By SsimorPro

Saludos, quiero comentar que me está gustando mucho el curso y que estoy aprendiendo y tomando mis notas, es importante para mí.

Muchas gracias Nico, hasta ahora todo ha sido muy sencillo de comprender.

Data Types samples:

Python tiene los siguientes tipos de datos integrados de forma predeterminada, en estas categorías:

• Tipo de texto: str
• Tipos numéricos: int, float, complex
• Tipos de secuencia: list, tuple, range
• Tipo de mapeo: dict
• Establecer tipos: set,frozenset
• Tipo booleano: bool
• Tipos binarios: bytes, bytearray, memoryview
• Ninguno Tipo: NoneType

Los inputs (entradas de usuario) en Python, que se capturan utilizando la función input(), son siempre considerados como cadenas de texto (str). Esto significa que, independientemente de lo que el usuario ingrese, input() lo interpretará como una cadena.

Jajaja está interesante eso de los inputs

# string
my_string = "Jorge"
my_other_string = 'Santiago'

print(my_string)
print(my_other_string)

# int

my_int = 12
my_other_int = 15

print(my_int)
print(my_other_int)
print(my_int + my_other_int)

# boolean

boolean = True

print('my_boolean =>', boolean)

# inputs

my_input = input('Cuál es tu edad?')

print("Hola ", my_other_string, ', es un placer conocerte,', 'es intersante saber que tienes la edad de ', my_input, '. Yo tengo ', my_int, 'y voy a ser 100% ', boolean, 'contigo! :).')

print(type(my_input))

Mi practica de la clase:

Algunos datos a recordar:

• Al trabajar con variables tipo bool, colocar la primera letra con mayúscula.
• Al usar input, el valor que se registra será guardado como tipo string.

Hola, aquí mi ejercicio

Tipos de datos primitivos:

• Enteros (int): números enteros sin decimales, por ejemplo: 5, -10, 100.

• Flotantes (float): números con decimales, por ejemplo: 3.14, -2.5, 0.001.

• Cadenas (str): secuencias de caracteres que representan texto, por ejemplo: “Hola mundo”, “Python es genial”, “12345”.

• Booleanos (bool): valores que representan verdadero o falso, por ejemplo: True, False.

Tipos de datos adicionales:

• Listas (list): colecciones ordenadas de elementos que pueden ser de diferentes tipos de datos, por ejemplo: [1, 2, 3], [“manzana”, “naranja”, “banana”].

• Tuplas (tuple): similares a las listas, pero son inmutables, por ejemplo: (1, 2, 3), (“rojo”, “verde”, “azul”).

• Diccionarios (dict): colecciones de pares clave-valor, donde cada valor está asociado a una clave, por ejemplo: {“nombre”: “Juan”, “edad”: 25, “país”: “México”}.

• Conjuntos (set): colecciones no ordenadas de elementos únicos, por ejemplo: {1, 2, 3}, {“manzana”, “naranja”, “banana”}.

Type

Dentro de la programación es importante conocer cuál es el type de dato que tenemos, pues asi podemos determinar su categoría.

Estructura del código

string

my_name = "Camilo"
print('my name is: ', my_name)
print(type(my_name))

Producción

my name is:  Camilo
<class 'str'>

int

age = 33
print('my age is: ', age)
print(type(age))

Producción

my age is:  33
<class 'int'>

input

my_age = input('¿Cual es tu edad?: ')
print('my age is: ', my_age)
print(type(my_age))

Producción:

¿Cual es tu edad?: 31
my age is:  31
<class 'str'>

Se viene tema de Casteo 😮

my code
#tipos de datos en python
un_nombre= "Diego"
print(“un estring es”,un_nombre)
#tipo entero
su_edad_de_diego=5
print(“la edad de diego”,su_edad_de_diego,“años”,“es un numero entero en python”)
#tipo de dato bolean
es_un_perro=True
print(“es un perro verdad o falso, true o false”,es_un_perro,“es un dato boolean”)
print(type(es_un_perro))

resultado
un estring es Diego
la edad de diego 5 años es un numero entero en python
es un perro verdad o falso, true o false True es un dato boolean
<class ‘bool’>

Los tipos de datos en Python se pueden clasificar en los siguientes grupos:

Tipos numéricos:

int: enteros, como 42, -5, 0.
float: números de punto flotante, como 3.14, 2.5e-3.
complex: números complejos, como 1+2j, 1.5-2.5j.
Tipos de secuencia:

str: cadenas de caracteres, como “Hola”, “Python”.
bytes: secuencia de bytes, como b’\x00\x01\x02’.
bytearray: secuencia mutable de bytes, como bytearray(b’Hola’).
list: lista mutable, como [1, 2, 3], [“Hola”, 42, True].
tuple: tupla inmutable, como (1, 2, 3), (“Hola”, 42, True).
range: rango de valores, como range(0, 10, 2).
Tipos de mapeo:

dict: diccionario mutable, como {“nombre”: “Juan”, “edad”: 25}.
Tipos de conjunto:

set: conjunto mutable, como {1, 2, 3}.
frozenset: conjunto inmutable, como frozenset({1, 2, 3}).
Tipos booleanos:

bool: valores booleanos True y False.
Tipo de valores binarios:

memoryview: objeto que permite acceder a la memoria de un objeto mutable de manera eficiente.

Les comparto un ejercicio donde usando input en lugar de ‘str’ da un <class 'int>

Por lo tanto, si deseas recibir números u otros tipos de datos diferentes a cadenas de texto, debes convertir manualmente la entrada del usuario al tipo de dato deseado utilizando funciones como int() o float().

# string
my_name = "Nicolas"
my_name = 'Santiago'
print('my_name =>', my_name)
print(type(my_name))

# int
my_age = 12
print('my_age =>', my_age)
print(type(my_age))

# boolean
is_single = True 
print('is_single =>', is_single)
print(type(is_single))

# inputs
my_age = input('¿Cuál es tu edad?')
print('my_age =>', my_age)
print(type(my_age))

execelente curso

Hice esto:

my_name = 'Miguel'
my_age = 24
my_data = {
  "weight": 68.7,
  "height": 173
}
my_skills = ['Python', 'JavaScript', 'SQL', 'English C1']
has_job = True

print(f'My name is {my_name} and age is {my_age}. I have this skills: {my_skills} and my data is {my_data}. Do I have a job? {has_job}')
print(type(my_name))
print(type(my_age))
print(type(my_data))
print(type(my_skills))
print(type(has_job))

Y el resultado fue:

$ py data_types.py
My name is Miguel and age is 24. I have this skills: ['Python', 'JavaScript', 'SQL', 'English C1'] and my data is {'weight': 68.7, 'height': 173}. Do I have a job? True
<class 'str'>
<class 'int'>
<class 'dict'>
<class 'list'>
<class 'bool'>

Mi resumen click aqui

Cuando ingresas un numero por medio de un input, ese numero sera tomado en cuenta como tipo string

En Python, existen los siguientes tipos de datos básicos:

Números: incluye int (enteros), float (números de punto flotante) y complex (números complejos).

Cadenas de caracteres: str (cadenas de texto).

Listas: list (colecciones ordenadas de valores).

Tuplas: tuple (colecciones ordenadas e inmutables de valores).

Conjuntos: set (colecciones sin orden y sin elementos repetidos).

Diccionarios: dict (colecciones sin orden que asocian claves con valores).

Además de estos tipos de datos básicos, también existen otros tipos de datos más avanzados, como los tipos de datos de archivos, funciones, clases, etc.

Tipo de texto: str
Tipos numéricos: int, float, complex
Tipos de secuencia: list, tuple, range
Tipo de mapeo: dict
Establecer tipos: set,frozenset
Tipo booleano: bool
Tipos binarios: bytes, bytearray, memoryview
Ninguno Tipo: NoneType

""" Tipos de datos """
# Strings
my_name = "Lucia"
my_last_name = 'Novachrono'
print("Mi nombre es:", my_name)
print(type(my_name))
print('Mi apellido es:', my_last_name)
print(type(my_last_name))

# nunbers int float double
my_age = 23
print("Tengo:", my_age, "años")
print(type(my_age))
my_height = 1.71
print("Mi estatura es:", my_height, "m")
print(type(my_height))

# boolean
is_alien = True
print("Soy un alienigena:", is_alien)
print(type(is_alien))

# input
name = input("Cual es tu nombre? ")
age = input("Que edad tienes: ")
height = input("Cual es tu estatura? ")
alien = input("Eres un alienigena? ")
print("My name is:", name)
print(type(name))
print("I'm", age, "years old")
print(type(age))
print("My height is:", height, "m")
print(type(height))
print("Am i an alien?:", alien)
print(type(alien))

para mejor comprensión:

• string (“hola mundo”)
• int ( 125 )
• float ( 2.5)
  *boolean (verdadero o falso)
  *inputs (datos del usuario)

Python tiene los siguientes tipos de datos de forma redeterminada:

• Tipo de texto: str
• Tipos numéricos: int, float, complex
• Tipos de secuencia: list, tuple, range
• Tipo de mapeo: dict
• Establecer tipos: set,frozenset
• Tipo booleano: bool
• Tipos binarios: bytes, bytearray, memoryview
• Ninguno Tipo: NoneType

buena explicación

al ingresar un input, lo reconoce somo string aun cuando sea número.

Tipos de datos en Python.

En Python, existen varios tipos de datos que puedes utilizar para representar diferentes tipos de información. Aquí tienes una descripción de algunos de los tipos de datos más comunes en Python:

1. Enteros (int): Representan números enteros, como -3, 0 y 42.

2. Flotantes (float): Representan números decimales, como 3.14, -0.5 y 2.718.

3. Cadenas (str): Representan secuencias de caracteres, como “Hola, mundo” o “Python es genial”.

4. Booleanos (bool): Representan valores de verdad, que son True (verdadero) o False (falso). Se utilizan en expresiones lógicas y de control de flujo.

5. Listas: Representan secuencias ordenadas y mutables de elementos. Pueden contener diferentes tipos de datos y se definen utilizando corchetes: [elemento1, elemento2, ...].

6. Tuplas: Son similares a las listas, pero son inmutables, es decir, no se pueden modificar una vez creadas. Se definen utilizando paréntesis: (elemento1, elemento2, ...).

7. Diccionarios: Representan mapeos de clave-valor. Cada elemento tiene una clave única asociada a un valor. Se definen utilizando llaves: {clave1: valor1, clave2: valor2, ...}.

8. Conjuntos (sets): Representan colecciones no ordenadas y sin duplicados. Se definen utilizando llaves: {elemento1, elemento2, ...}.

9. None: Representa la ausencia de un valor. Es útil para inicializar variables antes de asignarles un valor concreto.

10. Bytes y bytearray: Se utilizan para representar secuencias de bytes. Son útiles para manejar datos binarios.

11. Rangos (ranges): Representan una secuencia inmutable de números. Se utilizan para crear iteradores en bucles.

12. Objetos personalizados: Puedes definir tus propias clases para crear tipos de datos personalizados.

TIPOS DE DATOS QUE ESTAN EN LA CLASE

Tipo Text(‘str’, string): cadena de texto
Tipo Entero(‘int’ integer): números enteros que no están divididos en partes (1,2,3)(-1,-2,-3)
Tipo Booleano(‘bool’,Boolean): Valor de Verdadero o Falso

Tipos de datos

Tipos de datos primitivos

Strings

Son cadenas de texto, estas normalmente se encuentran escritas entre comillas "", como pueden ser: "Nicolás", "Santiago, "867", en el último ejemplo aunque tenemos un número, al momento de ponerlo entre comillas este dato se convierte en una cadena de texto.

Podemos ver el tipo de dato utilizando la función integrada type()

my_name = "Nicolás
my_name = "Santiago

print("Mi nombre es: ", my_name)
print(type(my_name))@ <class 'str'>

Números (integrales)

Los números son cualquier tipo de número, ya sea que este sea positivo o negativo.

my_age = 12
print(type(my_age)) @ <class 'int'>

Booleanos

Solo hay dos tipos True y False, este se utiliza para validar si un estado es Verdadero o Falso.

is_single = False
print(type(is_sigle)) @ <class 'bool'>

También puedes cambiar el valor de edad (String) a un valor numérico como indica en la 6ta línea del código

<my_name = input("Hola, ¿cuál es tu nombre? ")
my_edad = input("¿Cuántos años tienes? ")
print("Hola "+my_name+" tienes "+my_edad+" años de edad")
print("Bienvenido a PLATZI :D")
print(type(my_name))
my_edad=int(my_edad)
print(type(my_edad))> 

Resultado

Comprendi el tyte data…

print("example of types")
#string
my_name = "Ricky"
my_name = 'Santi'
my_name = "25"
print('my name =>', my_name)
print(type(my_name))

#int
my_age = 12
print('my_age =>', my_age)
print(type(my_age))

#boolean
is_single = False
print('is_single =>', is_single)
print(type(is_single))

#inputs
my_age = input('How old are you?: ')
print("your are", my_age, "years old.")
print(type(my_age))

Aqui aprendiste sobre los tipos de datos que te vas a enfrentar en el lenguaje desde los basicos hasta los mas complejos, son complejos porque tienen una funcionalidad especial para poder usarlos, pero vamos poco a poco.
Tipos de datos primitivos:
Int = Son los valores enteros. (1,2343,21,23), no tienen partes decimales.
float = Son valores que si tienen decimales. (1.1,12.1,2312.1).
Str = son los caracteres, es decir, son letras o simbolos.
Bool = Estos son valores True y False.

Booleanos (bool): Representan valores verdadero o falso. Son útiles para expresar condiciones y decisiones. Los valores válidos son True y False.

Cadenas de texto (str): Representan secuencias de caracteres. Las cadenas se definen entre comillas simples o dobles. Ejemplo: "Hola", 'Python', "42".

string

my_name = "Juan"
my_name1 = 'Pablo'
print(f"Hola, soy {my_name} {my_name1}")
print(f"El tipo de dato de mi nombre ({my_name} {my_name1}) es: {type(my_name)}")

int

print(" ")
my_age = 37
print(f"Mi nombre es: {my_name} {my_name1} y tengo {my_age} años")
print(f"Mi edad ({my_age}) es un tipo de dato:{type(my_age)}")

bool

print("  ")
is_single = True
is_single1 = False
print(f"({is_single} y {is_single1}) son tipos de dato: {type(is_single)}")

inputs

print("  ")
my_age = input("Cuál es tu edad: ")
print("  ")
print(f"Tu edad es: {my_age} y soy un tipo de dato: {type(my_age)}")
print("Porque capture la edad con la funcion (input()). Esto significa que independientemente de lo que ingreses (input()) lo considera como (string)")
print(" ")
print(f"Lo puedes convertir al tipo de dato correcto con (int(my_age)), ahora el tipo de dato correcto es :  {type(int(my_age))}")

Listas (List)

print(" ")
numbers = [1, 2, 3, 4, 5]
names = ["Juan", "Pablo"]
print(f"{numbers} y {names} son tipos de datos: {type(numbers)} {type(names)}")

Tuplas (tuple)

print(" ")
colors = ("Red", "Blue", "white")
print(f"{colors} es un tipo de datos: {type(colors)}")

Conjuntos (set)

print(" ")
fruits = {"aplle", "orange", "pear"}
print(f"{fruits} es un tipo de datos: {type(fruits)}")

Diccionarios (dic)

print(" ")
person = {
    "nombre": "Juan",
    "edad": 30,
    "ciudad": "Madrid",
    "email": "[email protected]"
}
print(f"{person} es un tipo de datos: {type(person)}")

Hola 😃

#tipos de datos:
#string: cadenas de texto, cadena de caracteres
my_name = 'Diana'
print('my_name ->', my_name)
#validar el tipo de dato, con la función type(nombre_var)
print(type(my_name))
#int: son datos enteros
my_age = 9
print('El valor de la var int es:', my_age)
print(type(my_age))

#booleano: True or False
is_single = True
print(is_single)
print(type(is_single))

#inputs
my_age = input('Cuál es tu edad:')
print('My age is:', my_age)
print(type(my_age))```

ella no te ama, ¿truo o false?true
my_age => true
<class ‘str’>
efectivamente, siempre va a decir string

hola dejo mi resumen

Aqui te retornará como tipo string porque cuando lo solicitas en el input, lo ingresas como ese tipo a la variable

# input

my_age = input(" Escribe tu edad:  ")
print("My edad es", my_age)
print(type(my_age))

# string 
# La comillas indican que es un string y pueden ser doble o sencilas
my_name =  "Carlos"
print('My name is', my_name)
print(type(my_name))

# tipo int 
# El numero indica que es un int es decir un entero, porque no tiene punto decimal
my_age = 21
print('My age is ', my_age)
print(type(my_age))

# booleans
# si importa las mayusculas y las minusculas al escribir True y False, debe ser mayuscula 
is_single = True
print('is single', is_single)
print(type(is_single))```

Tipos de datos

Tipos de datos en python que podemos usar en variables:

string (cadena de texto o cadena de carácteres)

my_name = “Dobles comillas”

my_name = ‘comillas sencillas’

función type: nos ayudará a saber qué tipo de dato es

#int

son números y lo reconocemos sin comillas, solo el num

my_age = 12

#boolean

se caracterisan por tener 2 valores = True or False. Y este debe ser asignado con mayúscula al inicio del valor asignado. Siempre en MAYUS porque sino es error.

Ejemplo:

is_single = True

#inputs

my_ age = input(’Cual es tu edad?’)

print(’my_age’, my_age)

INPUT: función con la que tomar información del usuario a través de la consola y que siempre se guarda en formato ‘string’

cosas que recordar 1=> los datos de tipo bool que se almacenan en una variable simpre se le tiene que asignar su valor en mayusculas ej var=True 2=> los datos que se reciben de un input siempre se almacenan como int

#String
my_name = "Nicolas"
my_name = " Santiago"
print( " My name is:", my_name)
print(type(my_name))

# int
my_age = 12
print( "My age is:", my_age)
print(type(my_age))

# boolean
is_single = True
print( "is single?", is_single)
print(type(is_single))

# inputs
my_age = input( "What is your age?")
print(" My age is:", my_age)
print(type(my_age))

cual es la funcion de la flecha

Mi ejercicio , estoy emocionada de lo que he aprendido. Gracias NIcolas

El interfaz de Replit me está gustando, tiene colores bonitos

Aquí dejo mi actividad:

function encontrarNumeroMasGrande(lista) {
let maximo = 0;

for (let i = 0; i < lista.length; i++) {
if (lista[i] > maximo) {
maximo = lista[i];
}
}

return maximo;
}

const numeros = [10, 5, 8, 20, 3, 15];
const numeroMasGrande = encontrarNumeroMasGrande(numeros);
console.log("El número más grande es: " + numeroMasGrande);

muy interesante

En Python, existen varios tipos de datos incorporados que se utilizan para representar diferentes tipos de información. Los tipos de datos básicos en Python incluyen:

1. Números:

   • int (enteros): números enteros, por ejemplo, 1, 100, -5.
   • float (flotantes): números decimales, por ejemplo, 3.14, -0.5, 2.0.

2. Cadenas de texto:

   • str (cadenas): secuencias de caracteres, por ejemplo, “Hola”, ‘Python’, “123”.

3. Booleanos:

   • bool (booleanos): valores de verdadero (True) o falso (False), que se utilizan en expresiones lógicas y de control de flujo.

4. Listas:

   • list (listas): secuencias ordenadas y mutables de elementos, que pueden ser de diferentes tipos de datos.

5. Tuplas:

   • tuple (tuplas): secuencias ordenadas e inmutables de elementos, similares a las listas pero no se pueden modificar una vez creadas.

6. Conjuntos:

   • set (conjuntos): colecciones desordenadas de elementos únicos, no permiten duplicados.

7. Diccionarios:

   • dict (diccionarios): colecciones de pares clave-valor, donde cada valor se accede a través de su clave única.

Estos son solo algunos de los tipos de datos básicos en Python. Además, Python también permite la creación y uso de tipos de datos más complejos y personalizados mediante la definición de clases y la programación orientada a objetos.

Me gusta como el profe explica 😁

#String
my_name = "Hola, mis amores :3"
print("un string =>", my_name)
print(type(my_name))

#Numbers or Int
my_age = 15
print("my_age =>", my_age)
print(type(my_age))

#Boolean 
is_single = False
print("is_single =>", is_single)
print(type(is_single))

#input 
my_age = input("¿Cual es tu edad?")
print("my_age =>", my_age)
print(type(my_age))

string

name = ‘Piero’

Int

number = 2

Float

FloatingNumber = 3.14

Boolean

i_am_studying_in_Platzi = True

Una clase muy instructiva, gracias

# string
my_name = 'Andres'
my_name = "Sebastian"
print('my_name =>', my_name)

print(type(my_name))

# int
my_age = 22
print('my_age =>', my_age)
print(type(my_age))

# boolean
is_single = False
print('is_single =>', is_single)
print(type(is_single))

# inputs
my_age = input('¿Cuál es tu edad?')
print('my_age =>', my_age)
print(type(my_age))

# siempre que se utiliza input devuelve un string

Excelente. Muchas gracias profe Nicolás. Siento que esta noche (que inicié el curso en Platzi) he superado muchas barreras. Pensaba que debía hacer muchos más cursos antes de iniciar el de fundamentos de Python

.

Muy buena clase

Cuando estaba ejecutando los prints me salía error en la linea 9, el error era:

TypeError: can only concatenate str (not "int") to str

El error decía que no puedo concatenar la cadena “my_age =>” con un enero “12”, que es el valor de la variable my_age.

Revisando cometi un gran error y este es que yo estaba escribiendo la linea de codigo de sta forma:

print('my_age => ' + my_age)

y mi error fue que para concatenar la cadena yo estaba utilizando el simbolo “+” cuando en python se debe utilizar la coma ","
Esto porque vengo de practicar en JAVA y empecé a escribir automaticamente si revisar.
y lo correcto es que debería ser de esta forma:

print('my_age => ',  my_age)

asi que ya saben espero no les suceda a ustedes y revisen su código ejjeje 😃

Saludos

Cabe destacar que si estamos trabajando con Notebooks, el valor del input será revisionado, y convertido.

your_age = input(‘How old are you?’)
print('your_age is ', your_age)
print(type(my_age))

How old are you?15
your_age is 15
<class ‘int’>

string : cadena de texto

Nombre = "camilo"
print ( " Mi nombre es: " , Nombre )

funcion type permite ver que tipo de variable es

print (type(Nombre))

#int: numeros enteros
edad= 22
print("el tiene: " ,edad , “años de edad”)
print (type(edad))

#boolean
es_soltero = True
print(" el esta soltero: " , es_soltero)
print(type(es_soltero))

es_casado = False
print(" el esta casado :" , es_casado)
print(type(es_casado))

input

edad = input(" ¿ cual es tu edad ? “)
print(” mi edad es: " , edad)
print(type(edad))

# string
my_name = "Jairo"
my_name = 'Sistejairos'
my_name = "1"
print('my_name =>', my_name)
print(type(my_name))

# int
my_age = 1
print('my_age =>', my_age)
print(type(my_age))

# boolean
is_single = False
print('is_single =>', is_single)
print(type(is_single))

# inputs
my_age = input('¿Cuál es tu edad? ')
print('my_age =>', my_age)
print(type(my_age))

print(“este curso me esta gustando”)

ha esta version me gusta mas

gracias por tus aportes Cristian

Encontré un buen ejemplo ahi abajo y este es mi versión

# string
my_name = "Rubén"
print(my_name)
print(type(my_name))

#int
my_age = 30
print(my_age)
print(type(my_age))

#bool
is_single = True
print(is_single)
print(type(is_single))

#input

days = input("Cuantos días llevas estudiando?")

print(days)
print(type(days))

# string
my_name = "Nicolas"
print(my_name)  #imprime la variable
print(type(my_name))  # muestra el tipo de dato

# int
my_age = 12
print(my_age)
print(type(my_age))

# boolean
is_single = False
print(is_single)
print(type(is_single))

# Inputs
my_name = input('¿Cuál es tu nombre? ')
my_age = input('¿Cuántos años tienes? ')
print(type(my_name)) # con type, podemos ingresar un string
print(type(my_age)) # aunque ingresemos un numero, sera tomado como string

Me encanta, hacen que aprender sea sesillo.
![](

Esto esta mas interesante y por el momento muy fácil

#Tipos de datos

#String: Cadena de texto o caracteres
my_name="Alejandro"
my_name='Melissa'
print("Mi nombre es",my_name)
print(type(my_name))

#int
my_age=12
print("Mi edad es",my_age)
print(type(my_age))

#booleanos
soltero=False
print("Es soltero",soltero)
print(type(soltero))

#input:todo lo que recibe lo transforma a string
my_edad=input("Ingresa tu edad:")
print("Mi edad es",my_edad)
print(type(my_edad))

asi se convierte el input en un numero (int)

<#String
my_name="Maycol"
my_name="Salvador"
print("my_name =>",my_name)
print(type(my_name))

#int
my_age=22
print("my_age =>",my_age)
print(type(my_age))

# boolean
is_single =True
print("is_single =>",is_single)
print(type(is_single))

#inputs
my_age=input("Cual es tu edad?")
print("my_age =>",my_age)
print(type(my_age))> 

Los input podemos solicitarlos al usuario dependiendo el valor que queremos, por ejemplo:

edad = int(input(“Por favor ingrese su edad”))

Lo mismo se aplica para los demás tipos de variables.

por otro lado para poder realizar impresión de datos sin necesidad de escribir múltiples print(), podemos darle un formato a la impresión de la siguiente manera.

print(f"La edad ingresada es {edad} y el tipo de dato es {type(edad)}")

espero sea de utilidad amigos.

Si quieres que el dato numérico lo tome como Integer, puedes agregar una función por fuera del input:

Lo mas importante es recordar que cuando ingresemos un valor dado por la función input. asi sea un valor numerico, sera de clase string

Para que el input sea un entero usamos la función int():

my_age = int(input('Cuál es tu edad? '))

Tipo de datos

En Python existen tipo de datos, y podemos ver cómo python puede interpretar un valor con la función type()

x = 5
y = "John"
print(type(x)) #<class 'int'>
print(type(y)) #<class 'str'>

Los datos recibido por el input de la terminal siempre será texto

Tipos de datos primitivos

• Integers: números Enteros
• Floats: números de punto flotante (decimales)
• Strings: cadena de caracteres (texto)
• Boolean: boolenaos (Verdadero o Falso)

Una nota importante para inicializar un valor en los booleanos se usa las siguientes palabras reservadas: True o False es importa mencionar que la primera letra va en mayúsculas

pueden transformar el string a int en el input

de esta manera

my_age = int(input('Cual es tu edad? :'))

# Enteros
x = 5  # asigna el valor 5 a la variable x
y = -2  # asigna el valor -2 a la variable y

# Flotantes
z = 3.14  # asigna el valor 3.14 a la variable z

# Cadenas
s = "Hola"  # asigna la cadena "Hola" a la variable s
t = "Mundo"  # asigna la cadena "Mundo" a la variable t

# Booleanos
b1 = True  # asigna el valor True a la variable b1
b2 = False  # asigna el valor False a la variable b2

# Listas
lst = [1, 2, 3]  # asigna la lista [1, 2, 3] a la variable lst

# Tuplas
tpl = (1, 2, 3)  # asigna la tupla (1, 2, 3) a la variable tpl

# Conjuntos
s1 = {1, 2, 3}  # asigna el conjunto {1, 2, 3} a la variable s1
s2 = {"a", "b", "c"}  # asigna el conjunto {"a", "b", "c"} a la variable s2

# Diccionarios
d = {'a': 1, 'b': 2, 'c': 3}  # asigna el diccionario {'a': 1, 'b': 2, 'c': 3} a la variable d

Que aprendimos

• Manejo de tipos de datos
  String, int, boolean
• y que el profesor tiene Nicolas tiene 34 años

TIP, ahora el botón para mostrar/ocultar la barra de archivos es esta (Close Sidebar):

Text Type: str
Numeric Types: int, float, complex
Sequence Types: list, tuple, range
Mapping Type: dict
Set Types: set, frozenset
Boolean Type: bool
Binary Types: bytes, bytearray, memoryview
None Type: NoneType

Resource: https://www.w3schools.com/python/python_datatypes.asp