No tienes acceso a esta clase

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

Tipos de datos

9/38
Recursos

Aportes 176

Preguntas 30

Ordenar por:

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

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.

Python data Types

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’>

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:

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))

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.

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

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'>
# 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))

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.

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”}.

Se viene tema de Casteo 😮

# 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

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().

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

Algo para tener en cuenta cuando usamos los inputs para solicitarle información al usuario es que si sabemos que un valor debe ser explícitamente un dato numérico, se puede convertir ```js my_age = int(input('¿Cual es tu edad?')) ```Así evitamos tener errores futuros en la lógica de nuestro código
\#variable str my\_name = "Juan Esteban" \#variable int my\_age = 27 \#variables float my\_weight = 60.1 my\_height = 1.61 \#variable booleans is\_single = True print("my\_name =>", my\_name) print(type(my\_name)) print("my\_age =>", my\_age) print("my\_weight =>", my\_weight) print(type(my\_weight)) print("my\_height =>", my\_height) print(type(my\_height)) print(type(my\_age)) print("is\_single =>", is\_single) print(type(is\_single))
print("=====") print("clase 8: tipos de datos") print("=====") print("\\\n") \#type es una funcion que nos indica el tipo de datos \#tipo de datos: string print("Tipo de datos string") print("=====") my\_name= "Angel" my\_last\_name= 'Quintero' print("Name: ", my\_name) print("last Name:", my\_last\_name) print("tipo de dato de my\_age: ", type(my\_name)) print("tipo de dato de my\_las\_name: ", type(my\_last\_name)) print("\\\n") ''' \#salida Tipo de datos string \===== Name: Angel last Name: Quintero tipo de dato de my\_age: \<class 'str'> tipo de dato de my\_las\_name: \<class 'str'> ''' \#Tipo de datos: int print("Tipo de datos int") print("=====") my\_age=27 print("Age",my\_age) print("tipo de dato de my\_age: ", type(my\_name)) print("\\\n") ''' \#salida Tipo de datos int \===== Age 27 tipo de dato de my\_age: \<class 'str'> ''' \#Tipo de datos: boolean True / False, la primera letra de True/false \#debe ser mayuscula print("Tipo de datos boolean") print("=====") is\_single= True print("is single",is\_single) print("tipo de dato de my\_age: ", type(is\_single)) print("\\\n") ''' \#salida Tipo de datos boolean \===== is single True tipo de dato de my\_age: \<class 'bool'> ''' \#Los tipos de datos ingresados por consolas son string print("Ingrese sus edad y su nombre") print("=====") my\_name = input("Ingrese su nombre: ") my\_age = input("Ingrese su edad: ") print("Su nombre es: ",my\_name," y su edad es: ",my\_age," años") print("Tipo de dato my\_age, my\_name ", type(my\_age) ," ", type(my\_name)) print("Tipo de dato de la variable my\_age, my\_name") print("\\\n") ''' \#salida Ingrese sus edad y su nombre \===== Ingrese su nombre: Angel Ingrese su edad: Quintero Su nombre es: Angel y su edad es: Quintero años Tipo de dato my\_age, my\_name \<class 'str'> \<class 'str'> Tipo de dato de la variable my\_age, my\_name '''
\# string my\_name = "Luis Vareles" my\_name = 'Caroll Romero' print('my\_name =>', my\_name) \# la función type nos dice que tipo de dato es la variable print(type(my\_name)) \# int my\_age = 40 print('my\_age =>', my\_age) print(type(my\_age)) \# la función int nos dice que tipo de dato es la variable \# boolean is\_single = True print('is\_single =>', is\_single) print(type(is\_single)) \# boolean es un tipo de dato que solo puede tener dos valores, True o False \# inputs my\_age = input('Cual es tu edad? ') print('my\_age => ', my\_age) print(type(my\_age)) \#input siempre nos devuelve un string
Hola! Realicé el ejercicio final con el input para ingresar la edad, pero el tipo de variable que me arrojó no fue tipo string sino tipo INT, Estoy haciendo algo mal? ![](https://static.platzi.com/media/user_upload/image-583dba0a-8b58-4826-b2f6-18f9fd63c53a.jpg)
![](https://static.platzi.com/media/user_upload/image-9c41b26c-3192-4d33-b640-8d1e3c25c5a7.jpg)
#### **¿Cuál es la importancia de los tipos de datos?** Los tipos de datos son categorías o clasificaciones que se utilizan para definir el tipo de información que se almacena en una variable. Estos determinan cómo se almacena y se opera la información en la memoria de la computadora. Al utilizar los tipos de datos adecuados, podemos optimizar el rendimiento de nuestros programas y garantizar la integridad de los datos. En la mayoría de los lenguajes de programación, incluidos Python, existen varios tipos de datos predefinidos que podemos utilizar para almacenar información. Estos tipos pueden ser numéricos, cadenas de texto, listas, tuplas, conjuntos, diccionarios y booleanos, entre otros. #### **Importancia de los tipos de datos en la programación** Los tipos de datos son fundamentales en la programación por varias razones: 1. **Claridad y legibilidad:** * Al utilizar tipos de datos, podemos comunicar de manera clara y legible la información que estamos manipulando en nuestro código. * Ejemplo: Si tenemos una variable que almacena un número entero, utilizamos el tipo de dato int para indicar que se trata de un número entero. 2. **Validación y prevención de errores:** * Los tipos de datos nos permiten validar y prevenir errores al manipular la información. * Ejemplo: Si intentamos sumar una cadena de texto con un número, Python mostrará un error, ya que son tipos de datos incompatibles. 3. **Optimización de recursos:** * Al utilizar tipos de datos adecuados, podemos optimizar el uso de recursos en nuestros programas. * Ejemplo: Si una variable solo necesita almacenar valores true o false, utilizamos el tipo de dato booleano (bool) en lugar de un tipo de dato más complejo. [<u>https://elblogpython.com/tecnologia/tipos-de-datos-en-python-ejemplos-y-aplicaciones/</u>](https://elblogpython.com/tecnologia/tipos-de-datos-en-python-ejemplos-y-aplicaciones/)
**Tipos de datos en Python: ejemplos y aplicaciones** [<u>https://elblogpython.com/tecnologia/tipos-de-datos-en-python-ejemplos-y-aplicaciones/</u>](https://elblogpython.com/tecnologia/tipos-de-datos-en-python-ejemplos-y-aplicaciones/)
**Es bueno aclarar que conforme van saliendo versiones nuevas de python puede variar el uso de concatenado.** **Desde sus inicios Python acepta** `print("Your name: ", name)` `print("tu nombre es:" + name)` **En la versión 2.6 se implementó el método str.format()** `name = "John"` `age = 30` `print("My name is {} and I am {} years old.".format(name, age))` **Luego se llegó a la versión 3.6 los f-strings permitiendo mejor legibilidad en el código con las variables.** `print(f"My name is {name} and I am {age} years old."`) **Esto siempre es bueno tenerlo presente a la hora de hacer mantenimiento a código que ya esta operativo**
![](https://static.platzi.com/media/user_upload/image-29cfa6ed-fbf7-4fad-81d9-93bb829cd95e.jpg)
tipo de datos string cadena de texto int numeros enteros bool 0/1 true/false //en py SIEMPRE EN MAYUS True, False double numeros decimales float numeros decimales mas grandes print(type(variable)) R= imprime el TIPO de dato de la variable 2024
\# String mi\_nombre ='David' print('Mi nombre es: ', mi\_nombre) print(type(mi\_nombre)) \# Int mi\_edad=32 print("Mi edad es: ", mi\_edad) print(type(mi\_edad)) \# Boolean \# Cuando se asigne una variable boleana esta debe de iniciar en mayuscula is\_single = True print(is\_single) print(type(is\_single)) \# Consultando la edad mi\_edad=input("Cual es tu edad: ") print(type(mi\_edad))
**Tipos de datos primitivos:** 1. **Integers (Enteros)**: Representan números enteros sin parte decimal, como -1, 0, 1, 2, etc. 2. **Floats (Punto flotante)**: Representan números con parte decimal, como 3.14, 2.718, etc. 3. **Strings (Cadenas)**: Representan texto, como "hola mundo", "Python es genial", etc. 4. **Booleanos**: Representan valores verdaderos o falsos, es decir, True o False. **Tipos de datos adicionales:** 1. **Datos en texto (str)**: Similar a las cadenas, pero más general, incluye caracteres Unicode. 2. **Datos numéricos**: Incluye int (enteros), float (flotantes) y complex (números complejos). 3. **Datos en secuencia**: * **List (Listas)**: Colección ordenada y modificable de elementos. * **Tuple (Tuplas)**: Colección ordenada e inmutable de elementos. * **Range**: Representa una secuencia inmutable de números. 4. **Datos de mapeo (dict)**: Colección desordenada de pares clave-valor. 5. **Set Types**: * **Set**: Colección desordenada y mutable de elementos únicos. * **Frozenset**: Colección inmutable de elementos únicos. 6. **Datos booleanos (bool)**: Representa los valores True o False. 7. **Datos binarios**: * **Bytes**: Secuencia inmutable de bytes. * **Bytearray**: Secuencia mutable de bytes. * **Memoryview**: Permite acceder a la memoria de objetos buffer.
Intento imprimir la linea de codigo y no me permite #String My\_nam = "Nicolas" My\_nam = 'Nicolas' print("My\_nam =>", My\_nam)
[En Replit, cuando estás escribiendo código, la herramienta de autocompletado de código de Replit AI te proporcionará sugerencias de código en línea](https://docs.replit.com/power-ups/replitai/complete-code). [Para aceptar estas sugerencias de código, simplemente debes presionar la tecla `TAB` cuando aparezca un contorno tenue del código](https://ask.replit.com/t/how-to-display-suggestion/79366). [Si deseas desactivar la función de autocompletado de código, puedes hacerlo yendo a la parte inferior de tu editor, haciendo clic en `AI` y desmarcando el botón `Enable`](https://docs.replit.com/power-ups/replitai/complete-code)
Los datos que se pueden manejar en Python son: 1. **Text Type (**`str`**)**: Para almacenar cadenas de texto. Por ejemplo, `"Hola Mundo"`. 2. **Numeric Types (**`int`**,** `float`**,** `complex`**)**: Para almacenar números. `int` es para números enteros (por ejemplo, `10`), `float` es para números reales (por ejemplo, `9.8`), y `complex` es para números complejos (por ejemplo, `3 + 4j`). 3. **Sequence Types (**`list`**,** `tuple`**,** `range`**)**: Para almacenar secuencias de elementos. `list` es una colección ordenada y modificable (por ejemplo, `[1, 2, 3]`), `tuple` es una colección ordenada e inmutable (por ejemplo, `(1, 2, 3)`), y `range` es una secuencia inmutable de números, utilizada generalmente en bucles `for`. 4. **Mapping Type (**`dict`**)**: Para almacenar pares clave-valor. Por ejemplo, `{"nombre": "Juan", "edad": 30}`. 5. **Set Types (**`set`**,** `frozenset`**)**: Para almacenar conjuntos de elementos únicos. `set` es una colección no ordenada y modificable (por ejemplo, `{1, 2, 3}`), y `frozenset` es una colección no ordenada e inmutable. 6. **Boolean Type (**`bool`**)**: Para almacenar valores de verdad. Los únicos dos valores booleanos son `True` (verdadero) y `False` (falso). 7. **Binary Types (**`bytes`**,** `bytearray`**,** `memoryview`**)**: Para almacenar datos binarios. 8. **None Type (**`NoneType`**)**: Este tipo tiene un único valor, `None`, que se utiliza para representar la ausencia de valor o un valor nulo.
Python tiene varios tipos de datos incorporados que son comúnmente utilizados en la programación. Aquí te presento algunos de ellos: 1. **Integers (enteros)**: Son números enteros, positivos o negativos. Por ejemplo, `5`, `-3`, `0`. Python`edad = 20` `print(edad) # Imprime: 20` 1. **Floats (números de punto flotante)**: Son números reales (es decir, pueden tener una parte decimal). Por ejemplo, `3.14`, `-0.01`, `5.0`. Python`pi = 3.14` `print(pi) # Imprime: 3.14` 1. **Strings (cadenas de texto)**: Son secuencias de caracteres. Se definen utilizando comillas simples o dobles. Por ejemplo, `"Hola"`, `'Python'`. Python`saludo = "Hola, mundo!"` `print(saludo) # Imprime: Hola, mundo!` 1. **Booleans (valores booleanos)**: Son los valores `True` (verdadero) y `False` (falso) que se utilizan para representar la verdad o falsedad. Python`es_mayor = True` `print(es_mayor) # Imprime: True` 1. **Lists (listas)**: Son colecciones ordenadas de elementos. Los elementos pueden ser de cualquier tipo y se definen utilizando corchetes `[]`. Python`frutas = ["manzana", "banana", "cereza"`] `print(frutas) # Imprime: ['manzana', 'banana', 'cereza']` 1. **Dictionaries (diccionarios)**: Son colecciones no ordenadas de pares clave-valor. Se definen utilizando llaves `{}`. Python`persona = {"nombre": "Juan", "edad": 30`} `print(persona) # Imprime: {'nombre': 'Juan', 'edad': 30}` Fuente: Copilot
\# Ejemplo de tipos de datos en Python \# Entero (int) edad = 25 \# Flotante (float) altura = 1.75 \# Booleano (bool) es\_mayor\_de\_edad = True \# Cadena (str) nombre = "Juan" \# Lista (list) numeros = \[1, 2, 3, 4, 5] \# Tupla (tuple) coordenadas = (10, 20) \# Diccionario (dict) persona = {'nombre': 'Juan', 'edad': 25, 'altura': 1.75} \# Conjunto (set) vocales = {'a', 'e', 'i', 'o', 'u'} \# Imprimir los valores de las variables print("Edad:", edad) print("Altura:", altura) print("¿Es mayor de edad?", es\_mayor\_de\_edad) print("Nombre:", nombre) print("Números:", numeros) print("Coordenadas:", coordenadas) print("Persona:", persona) print("Vocales:", vocales) \# Ejercicio de tipos de datos en Python \# 1. Crea una variable llamada "precio" y asígnale el valor 10.99. precio = 10.99 \# 2. Crea una variable llamada "cantidad" y asígnale el valor 5. cantidad = 5 \# 3. Calcula el total multiplicando el precio por la cantidad. total = precio \* cantidad \# 4. Imprime el total. print("Total:", total)
Los tipos de datos manejados, vienen siendo muy parecidos en varios lenguajes, son más flexibles en Python, me he dado cuenta, estoy en exploración. Un saludo a todos los ensutiastas y estudiantes de platzi, vamos con todo...jejej
`#string` `my_name = 'Carlos'` `print('my_name =>', my_name)` `print(type(my_name))` \--- `#inputs` `my_age = input('¿Cuál es tu edad?')` `print('my_age =>', my_age)` `print(type(int(my_age)))` \<class 'int'>
**Tipos de Datos:** Incluyen enteros (int), flotantes (float), cadenas (str), booleanos (bool), listas (list), tuplas (tuple), conjuntos (set) y diccionarios (dict). `y = 3.14` `nombre = "Carlos"` `es_mayor_de_edad = True` `mi_lista = [1, 2, 3, 4, 5]`
no me corre la consola shell
Python tiene varios tipos de datos: * Numéricos: incluyen enteros (int), números de punto flotante (float) y números complejos (complex). * Secuencias: como cadenas de texto (str), listas (list) y tuplas (tuple). * Mapeo: como diccionarios (dict). * Conjuntos: (set). * Booleanos: (bool), con valores verdadero (True) o falso (False).
ejemplos de tipos de datos en Python? Claro, aquí tienes algunos ejemplos de tipos de datos en Python: 1. **Enteros (int)**: Representan números enteros, como 1, 2, -3, etc. Por ejemplo:`x = 5` `y = -10` 2. **Flotantes (float)**: Representan números con decimales, como 3.14, -0.5, etc. Por ejemplo:`pi = 3.14` `temperature = -0.5` 3. **Cadenas (str)**: Representan secuencias de caracteres, como "Hola", "Mundo", etc. Se pueden definir utilizando comillas simples o dobles. Por ejemplo:`name = "Juan"` `message = 'Hola, ¿cómo estás?'` 4. **Booleanos (bool)**: Representan valores de verdad, pueden ser verdadero (True) o falso (False). Por ejemplo:`is_true = True` `is_false = False` 5. **Listas (list)**: Representan colecciones ordenadas de elementos, que pueden ser de cualquier tipo de datos. Por ejemplo:`numbers = [1, 2, 3, 4, 5`] `names = ["Juan", "María", "Pedro"`] 6. **Tuplas (tuple)**: Representan colecciones ordenadas e inmutables de elementos, que pueden ser de cualquier tipo de datos. Por ejemplo:`coordinates = (10, 20`) `colors = ("rojo", "verde", "azul"`) 7. **Conjuntos (set)**: Representan colecciones no ordenadas de elementos únicos. Por ejemplo:`fruits = {"manzana", "plátano", "naranja"`} 8. **Diccionarios (dict)**: Representan colecciones no ordenadas de pares clave-valor. Por ejemplo:`person = {"nombre": "Juan", "edad": 30, "ciudad": "Madrid"`} Estos son solo algunos ejemplos de los tipos de datos en Python. Cada tipo de dato tiene sus propias propiedades y métodos, que se pueden utilizar para trabajar con ellos de manera más eficiente.
Tipos de datos python En Python, los tipos de datos más comunes son: 1. **Enteros (int)**: Representan números enteros, como 1, 2, -3, etc. 2. **Flotantes (float)**: Representan números con decimales, como 3.14, -0.5, etc. 3. **Cadenas (str)**: Representan secuencias de caracteres, como "Hola", "Mundo", etc. 4. **Booleanos (bool)**: Representan valores de verdad, pueden ser verdadero (True) o falso (False). 5. **Listas (list)**: Representan colecciones ordenadas de elementos, que pueden ser de cualquier tipo de datos. Por ejemplo, \[1, "Hola", True]. 6. **Tuplas (tuple)**: Representan colecciones ordenadas e inmutables de elementos, que pueden ser de cualquier tipo de datos. Por ejemplo, (1, "Hola", True). 7. **Conjuntos (set)**: Representan colecciones no ordenadas de elementos únicos. Por ejemplo, {1, 2, 3}. 8. **Diccionarios (dict)**: Representan colecciones no ordenadas de pares clave-valor. Cada valor se accede a través de su clave. Por ejemplo, {"nombre": "Juan", "edad": 30}. Estos son solo algunos ejemplos de los tipos de datos en Python. Python es un lenguaje flexible y también permite crear tipos de datos personalizados utilizando clases. Recuerda que en Python no es necesario declarar explícitamente el tipo de datos de una variable, ya que el intérprete de Python infiere el tipo de datos automáticamente según el valor asignado a la variable.
name = Juan Pablo lastname = Perez age = 25 info = f"Hola mi nombre es {name} {lastname} y mi edad es {age}" print(info)
### 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
![](https://static.platzi.com/media/user_upload/image-9dfa86a5-a5d9-48fc-a1d1-783a774e8e34.jpg)deben corregir esta pregunta
a = int(input("Ingresa un primer número: "))
b = int(input("Ingresa un segundo número: "))

print ("La suma de los números es: ",a+b)

Ingresa un primer número: 13
Ingresa un segundo número: 12
La suma de los números es: 25

a = input("Ingresa un primer número: ")
b = input("Ingresa un segundo número: ")

print ("La suma de los números es: ",a+b)

Ingresa un primer número: 13
Ingresa un segundo número: 12
La suma de los números es: 1312

Muy buena la clase

Hecho :D ![](https://static.platzi.com/media/user_upload/imagen-bfbebfda-accd-433a-9684-616d34c13a2a.jpg)

Aquí mi aporte mas que todo en el código, intente abarcar un poquito mas de otros tipos de datos, además de otras cositas que puse en comentarios, las cuales inferí de lectura.



Puedes convertir un str a int con esta sentencia: ```js my_age = int(input('Cual es tu edad?')) print('my_age =>', my_age) print(type(my_age)) ```
Puedes convertir un str a int con esta sentencia: `my_age = int(input('Cual es tu edad?'))` `print('my_age =>', my_age)` `print(type(my_age))`
Los booleanos solo admiten `True` o `False`
![](https://static.platzi.com/media/user_upload/imagen-a250253a-8840-4b67-9558-a4ea762c865a.jpg)

inputs (son datos del usuario) que nos devolverá una cadena de caracteres, “string”

porque cuando declara las variables de tipo String usa " " y tambien usa ' ', en que caso se usa?
![](https://static.platzi.com/media/user_upload/image-32519862-f72d-460c-a651-b320d17e9720.jpg)
![](https://static.platzi.com/media/user_upload/image-8e1b3a6a-b3b6-495e-a962-0069b0dd46ed.jpg) Para cambiar el tipo de variable "**str**" a "**int**" con el uso de **"input"**
¿No hay alguna forma de no escribir 03\_types.py cada vez que uno ejecute el código?
excelente clase
Si se quiere recibir mediante el input un valor distinto a un string es necesario realizar una conversión, indicando el tipo de dato y encerando la sentencia input: Ejemplo: my\_age = int(input("¿Cuál es tu edad?")) En este caso el valor ingresado será reconocido con un int por python ![](https://static.platzi.com/media/user_upload/image-a0e3b567-04da-445d-a5f8-364b11b63996.jpg)
![](https://static.platzi.com/media/user_upload/image-66418be9-98dd-45c3-b4ad-fdeec33ec172.jpg)![](https://static.platzi.com/media/user_upload/image-93f1eb0b-e6fb-4485-9140-f9977006cd15.jpg) Mi humilde aporte. Excelente curso.

Mis anotaciones para esta clase:

String: Es una cadena de texto, o cadena de caracteres (str).

type: Se imprime el tipo de dato que es la variable, no se imprime el valor de la variable.

int: Son aquellos numeros enteros (int).

boolean: Tiene 2 valores: true/false. Nota: La primera letra debe ser en mayuscula, al no hacerlo dara un error (bool).

input: Son aquellos datos que son ingresados por el usuario.

Extra:

float: Son aquellos numeros decimales.

Los tres tipos de datos son strings para las variables tipo texto, int para las variables de tipo número entero y boolean que son solo verdadero o falso y si se usan con un input siempre regresará un elemento tipo string

😅 Alguien sabe cómo se escribe rápido en el Shell la instucción de ejecución?, intenté con copiar y pegar y al menos es posible con el mouse

Interesante intentar los tipos de informacion y como identificarlos. Que emocionante.

Cordial saludo al club python: Quisiera saber como poner la comilla sencilla. No la he podido ejecutar. Gracias por su atencion.
\# Take user input name = input("Enter your name: ") \# Print a greeting print("Hello, " + name + "!") print(type(name))
My notes: ![](https://static.platzi.com/media/user_upload/image-440fe145-10bd-4785-81b9-90da7a5572f0.jpg) CODE: ![](https://static.platzi.com/media/user_upload/image-dc47df46-516a-40c8-842a-efc59283983f.jpg) Console output: ![](https://static.platzi.com/media/user_upload/image-fb6add60-e652-4765-abcf-13fdd7c99eb0.jpg)

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".