Variables y Tipos de Datos en Python

Introducción

En este laboratorio, aprenderás los conceptos fundamentales de las variables y los tipos de datos en Python. Las variables son bloques de construcción esenciales en la programación que te permiten almacenar, acceder y manipular datos en tu código. Comprender los diferentes tipos de datos es crucial para escribir programas eficaces en Python.

Crearás varias variables, explorarás los diferentes tipos de datos disponibles en Python, realizarás conversiones de tipo y aprenderás cómo usar variables en expresiones. Estas habilidades forman la base de la programación en Python y son necesarias para desarrollar aplicaciones más complejas.

Al final de este laboratorio, te sentirás cómodo creando y usando variables con diferentes tipos de datos en Python.

Skills Graph

Creando tus primeras variables en Python

En este paso, aprenderás cómo crear y usar variables en Python. Las variables son contenedores que almacenan valores de datos y les dan nombres significativos para una referencia más fácil en tu código.

Comencemos creando un nuevo archivo de Python y definiendo algunas variables básicas:

1. Abre el archivo /home/labex/project/variables.py en el WebIDE.

2. Agrega el siguiente código para definir tres variables:

## Creating basic variables
water_supply = 100    ## Amount of water in gallons
food_supply = 50      ## Amount of food in pounds
ammunition = 40       ## Number of ammunition rounds

En Python, creas una variable especificando un nombre seguido del signo igual (=) y luego el valor que deseas asignarle.

3. Agreguemos código para mostrar los valores de estas variables:

## Displaying variable values
print("Water supply:", water_supply)
print("Food supply:", food_supply)
print("Ammunition:", ammunition)

4. Ejecuta tu script abriendo una terminal en el WebIDE y ejecutando:

python3 /home/labex/project/variables.py

Deberías ver la siguiente salida:

Water supply: 100
Food supply: 50
Ammunition: 40

Felicidades. Has creado tus primeras variables en Python y mostrado sus valores. Estas variables almacenan información que tu programa puede acceder y manipular.

Comprendiendo los tipos de datos numéricos

Python tiene varios tipos de datos que se utilizan para clasificar diferentes tipos de información. En este paso, aprenderás sobre dos tipos de datos numéricos: enteros (integers) y números de punto flotante (floats).

1. Abre el archivo /home/labex/project/variables.py en el WebIDE.

2. Agrega el siguiente código al archivo para definir variables con diferentes tipos de datos numéricos:

## Numeric data types
integer_value = 42        ## Integer (whole number)
float_value = 3.14159     ## Float (decimal number)

3. Exploremos los tipos de estas variables utilizando la función type():

## Check the data types
print("\nUnderstanding data types:")
print("integer_value:", integer_value, "- Type:", type(integer_value))
print("float_value:", float_value, "- Type:", type(float_value))

4. Ahora, realicemos algunas operaciones básicas con estos tipos numéricos:

## Basic operations with numbers
sum_result = integer_value + float_value
product_result = integer_value * float_value

print("\nBasic operations:")
print(f"{integer_value} + {float_value} = {sum_result}")
print(f"{integer_value} * {float_value} = {product_result}")

5. Ejecuta tu script:

python3 /home/labex/project/variables.py

Deberías ver una salida similar a la siguiente:

Water supply: 100
Food supply: 50
Ammunition: 40

Understanding data types:
integer_value: 42 - Type: <class 'int'>
float_value: 3.14159 - Type: <class 'float'>

Basic operations:
42 + 3.14159 = 45.14159
42 * 3.14159 = 131.94678

Observa que cuando realizas operaciones con enteros y números de punto flotante, Python convierte automáticamente el resultado a un número de punto flotante si es necesario.

Trabajando con cadenas (strings) y booleanos

Además de los tipos de datos numéricos, Python ofrece cadenas (strings) para datos de texto y booleanos para valores verdadero/falso. Exploremos estos tipos:

1. Abre el archivo /home/labex/project/variables.py en el WebIDE.

2. Agrega el siguiente código para definir variables de tipo cadena y booleana:

## String data type - for text
camp_name = "Python Base Camp"
location = 'Programming Valley'  ## Strings can use single or double quotes

## Boolean data type - for true/false values
is_safe = True
has_water = True
enemy_nearby = False

3. Agrega código para verificar y mostrar estas variables:

## Displaying string and boolean variables
print("\nString variables:")
print("Camp name:", camp_name, "- Type:", type(camp_name))
print("Location:", location, "- Type:", type(location))

print("\nBoolean variables:")
print("Is the camp safe?", is_safe, "- Type:", type(is_safe))
print("Is water available?", has_water, "- Type:", type(has_water))
print("Is enemy nearby?", enemy_nearby, "- Type:", type(enemy_nearby))

4. También demostremos algunas operaciones con cadenas:

## String operations
full_location = camp_name + " in " + location
print("\nFull location:", full_location)

## String repetition
border = "-" * 20
print(border)
print("Camp Information")
print(border)

5. Ejecuta tu script:

python3 /home/labex/project/variables.py

Deberías ver una salida similar a la siguiente:

Water supply: 100
Food supply: 50
Ammunition: 40

Understanding data types:
integer_value: 42 - Type: <class 'int'>
float_value: 3.14159 - Type: <class 'float'>

Basic operations:
42 + 3.14159 = 45.14159
42 * 3.14159 = 131.94678

String variables:
Camp name: Python Base Camp - Type: <class 'str'>
Location: Programming Valley - Type: <class 'str'>

Boolean variables:
Is the camp safe? True - Type: <class 'bool'>
Is water available? True - Type: <class 'bool'>
Is enemy nearby? False - Type: <class 'bool'>

Full location: Python Base Camp in Programming Valley
--------------------
Camp Information
--------------------

Observa cómo las cadenas se pueden concatenar con el operador + y repetir con el operador *. Los booleanos son útiles para representar condiciones y controlar el flujo del programa.

Conversión de tipos y comprobación de tipos

A veces, es necesario convertir valores de un tipo de dato a otro o comprobar el tipo de dato de una variable. Esto se llama conversión de tipos (o casting de tipos). Exploremos este concepto:

1. Abre el archivo /home/labex/project/variables.py en el WebIDE.

2. Agrega código para demostrar la conversión de tipos:

## Type conversion examples
print("\nType Conversion Examples:")

## Converting string to integer
supplies_str = "75"
supplies_int = int(supplies_str)
print(f"String '{supplies_str}' converted to integer: {supplies_int} - Type: {type(supplies_int)}")

## Converting integer to string
days_int = 30
days_str = str(days_int)
print(f"Integer {days_int} converted to string: '{days_str}' - Type: {type(days_str)}")

## Converting integer to float
distance_int = 100
distance_float = float(distance_int)
print(f"Integer {distance_int} converted to float: {distance_float} - Type: {type(distance_float)}")

## Converting float to integer (note: this truncates the decimal part)
temperature_float = 32.7
temperature_int = int(temperature_float)
print(f"Float {temperature_float} converted to integer: {temperature_int} - Type: {type(temperature_int)}")

3. Agrega código para comprobar los tipos de datos:

## Type checking
print("\nType Checking Examples:")
value1 = 42
value2 = "42"
value3 = 42.0

print(f"Is {value1} an integer? {isinstance(value1, int)}")
print(f"Is {value2} an integer? {isinstance(value2, int)}")
print(f"Is {value3} a float? {isinstance(value3, float)}")
print(f"Is {value2} a string? {isinstance(value2, str)}")

4. Ejecuta tu script:

python3 /home/labex/project/variables.py

Deberías ver una salida similar a la siguiente:

...previous output...

Type Conversion Examples:
String '75' converted to integer: 75 - Type: <class 'int'>
Integer 30 converted to string: '30' - Type: <class 'str'>
Integer 100 converted to float: 100.0 - Type: <class 'float'>
Float 32.7 converted to integer: 32 - Type: <class 'int'>

Type Checking Examples:
Is 42 an integer? True
Is 42 an integer? False
Is 42.0 a float? True
Is 42 a string? True

Observa que:

• int() convierte valores a enteros.
• float() convierte valores a números de punto flotante.
• str() convierte valores a cadenas.
• Al convertir un número de punto flotante a entero, la parte decimal se trunca (no se redondea).
• La función isinstance() comprueba si una variable es de un tipo específico.

Estas funciones de conversión son útiles cuando es necesario procesar la entrada de los usuarios o trabajar con datos de diferentes fuentes.

Variables en expresiones y toma de decisiones

Las variables se vuelven realmente poderosas cuando se utilizan en expresiones y estructuras de toma de decisiones. Exploremos cómo usar variables en cálculos y declaraciones condicionales:

1. Abre el archivo /home/labex/project/variables.py en el WebIDE.

2. Agrega código para demostrar el uso de variables en cálculos:

## Variables in expressions
print("\nVariables in Expressions:")

water_per_day = 4  ## gallons
food_per_day = 2.5  ## pounds

## Calculate how long supplies will last
water_days = water_supply / water_per_day
food_days = food_supply / food_per_day

print(f"With {water_supply} gallons of water, consuming {water_per_day} gallons per day, water will last {water_days} days")
print(f"With {food_supply} pounds of food, consuming {food_per_day} pounds per day, food will last {food_days} days")

3. Agrega código para demostrar el uso de variables en declaraciones condicionales:

## Using variables for decision making
print("\nDecision Making with Variables:")

## Check which supply will run out first
if water_days < food_days:
    limiting_factor = "Water"
    limiting_days = water_days
else:
    limiting_factor = "Food"
    limiting_days = food_days

print(f"{limiting_factor} will run out first, after {limiting_days} days")

## Check if supplies are sufficient for a 10-day journey
journey_days = 10
sufficient_supplies = water_days >= journey_days and food_days >= journey_days and ammunition >= 20

print(f"Planning a {journey_days}-day journey.")
print(f"Do we have sufficient supplies? {sufficient_supplies}")

## Provide specific supply status
if water_days < journey_days:
    print(f"Warning: Water will only last {water_days:.1f} days.")
if food_days < journey_days:
    print(f"Warning: Food will only last {food_days:.1f} days.")
if ammunition < 20:
    print(f"Warning: Only {ammunition} rounds of ammunition available.")

4. Ejecuta tu script:

python3 /home/labex/project/variables.py

Deberías ver una salida similar a la siguiente:

...previous output...

Variables in Expressions:
With 100 gallons of water, consuming 4 gallons per day, water will last 25.0 days
With 50 pounds of food, consuming 2.5 pounds per day, food will last 20.0 days

Decision Making with Variables:
Food will run out first, after 20.0 days
Planning a 10-day journey.
Do we have sufficient supplies? True

Esto demuestra cómo se pueden usar variables en cálculos y cómo tomar decisiones basadas en los valores de las variables. Observa cómo se utilizan operadores de comparación (<, >=) y operadores lógicos (and) para crear condiciones.

La sintaxis {water_days:.1f} especifica que el número de punto flotante debe mostrarse con un decimal.

Resumen

En este laboratorio (lab), has aprendido los conceptos fundamentales de las variables y los tipos de datos en Python. Has creado y utilizado variables de diferentes tipos, incluyendo:

• Enteros (integers) para números enteros.
• Números de punto flotante (floats) para números decimales.
• Cadenas (strings) para datos de texto.
• Booleanos (booleans) para valores verdadero/falso.

También has aprendido cómo:

• Comprobar el tipo de una variable utilizando la función type().
• Convertir entre diferentes tipos de datos utilizando funciones como int(), float() y str().
• Utilizar variables en expresiones y cálculos.
• Tomar decisiones basadas en los valores de las variables utilizando declaraciones condicionales.

Estos conceptos forman la base de la programación en Python. Las variables te permiten almacenar y manipular datos, mientras que comprender los diferentes tipos de datos te ayuda a elegir el tipo adecuado para cada situación. A medida que continúes tu viaje en Python, construirás sobre estos conceptos básicos para crear programas más complejos y potentes.