Cómo crear una lista con un rango de números en Python

Introducción

Las listas de Python son estructuras de datos versátiles que pueden almacenar una amplia gama de elementos, incluyendo números. En este tutorial, aprenderás cómo crear una lista con un rango de números en Python, lo cual puede ser una técnica útil para diversas tareas de programación. Exploraremos métodos para generar listas con secuencias de números y discutiremos cómo aplicar efectivamente estas listas con rangos en tus programas de Python.

Skills Graph

Creación y comprensión de listas de Python

Las listas de Python son una de las estructuras de datos más utilizadas que te permiten almacenar múltiples elementos en una sola variable. Antes de adentrarnos en la creación de listas con rangos, comprendamos los conceptos básicos de las listas de Python.

Primero, creemos un nuevo archivo de Python para trabajar. En el WebIDE:

1. Haz clic en el menú "File" en la parte superior.
2. Selecciona "New File".
3. Nombrar el archivo python_lists.py.
4. Guárdalo en el directorio /home/labex/project.

Ahora, escribamos un poco de código para entender cómo funcionan las listas de Python:

## Basic list creation
numbers = [1, 2, 3, 4, 5]
print("Basic list:", numbers)

## Lists can contain different data types
mixed_list = [1, "hello", 3.14, True]
print("Mixed data types:", mixed_list)

## Accessing list elements (indexing starts at 0)
print("First element:", numbers[0])
print("Last element:", numbers[4])

## Getting the length of a list
print("List length:", len(numbers))

## Modifying list elements
numbers[2] = 30
print("Modified list:", numbers)

## Adding elements to a list
numbers.append(6)
print("After append:", numbers)

## Removing elements from a list
numbers.remove(30)
print("After remove:", numbers)

Ejecutemos este script para ver la salida. En la terminal:

1. Asegúrate de estar en el directorio /home/labex/project.
2. Ejecuta el siguiente comando:

python3 python_lists.py

Deberías ver la siguiente salida:

Basic list: [1, 2, 3, 4, 5]
Mixed data types: [1, 'hello', 3.14, True]
First element: 1
Last element: 5
List length: 5
Modified list: [1, 2, 30, 4, 5]
After append: [1, 2, 30, 4, 5, 6]
After remove: [1, 2, 4, 5, 6]

Como puedes ver, las listas de Python tienen varias características importantes:

• Las listas son colecciones ordenadas, lo que significa que los elementos tienen un orden definido.
• Las listas son mutables, lo que te permite cambiar, agregar o eliminar elementos después de la creación.
• Las listas pueden contener elementos de diferentes tipos de datos.
• Cada elemento de una lista se puede acceder utilizando su índice (posición).

Ahora que comprendemos los conceptos básicos de las listas de Python, podemos pasar a la creación de listas con rangos de números.

Creación de listas con la función range()

La función range() en Python es una función incorporada que genera una secuencia de números. Se utiliza comúnmente con la función list() para crear listas que contengan rangos de números.

Creemos un nuevo archivo de Python para explorar la función range():

1. Haz clic en el menú "File" en la parte superior.
2. Selecciona "New File".
3. Nombrar el archivo range_lists.py.
4. Guárdalo en el directorio /home/labex/project.

Ahora, agreguemos código para explorar diferentes formas de usar la función range():

## Basic usage of range() function
## Note: range() returns a range object, not a list directly
## We convert it to a list to see all values at once

## range(stop) - generates numbers from 0 to stop-1
numbers1 = list(range(5))
print("range(5):", numbers1)

## range(start, stop) - generates numbers from start to stop-1
numbers2 = list(range(2, 8))
print("range(2, 8):", numbers2)

## range(start, stop, step) - generates numbers from start to stop-1 with step
numbers3 = list(range(1, 10, 2))
print("range(1, 10, 2):", numbers3)

## Creating a list of descending numbers
numbers4 = list(range(10, 0, -1))
print("range(10, 0, -1):", numbers4)

## Creating even numbers from 2 to 10
even_numbers = list(range(2, 11, 2))
print("Even numbers:", even_numbers)

## Creating odd numbers from 1 to 9
odd_numbers = list(range(1, 10, 2))
print("Odd numbers:", odd_numbers)

Ejecutemos este script para ver los resultados:

python3 range_lists.py

Deberías ver la siguiente salida:

range(5): [0, 1, 2, 3, 4]
range(2, 8): [2, 3, 4, 5, 6, 7]
range(1, 10, 2): [1, 3, 5, 7, 9]
range(10, 0, -1): [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
Even numbers: [2, 4, 6, 8, 10]
Odd numbers: [1, 3, 5, 7, 9]

La función range() se puede utilizar de tres maneras diferentes:

1. range(stop): Genera números desde 0 hasta stop - 1.
2. range(start, stop): Genera números desde start hasta stop - 1.
3. range(start, stop, step): Genera números desde start hasta stop - 1, incrementando en step.

Al entender estas diferentes formas, puedes crear varios tipos de secuencias numéricas:

• Números secuenciales (contando hacia arriba).
• Números descendentes (contando hacia abajo).
• Números pares.
• Números impares.
• Números con intervalos personalizados.

Recuerda que la función range() en sí misma devuelve un objeto de rango (range object), que es eficiente en términos de memoria. Lo convertimos a una lista utilizando la función list() para ver todos los valores a la vez o para realizar operaciones de lista en él.

Uso de comprensiones de listas con range

Python ofrece una característica poderosa llamada comprensiones de listas (list comprehensions) que te permite crear listas de una manera concisa y legible. Cuando se combinan con la función range(), las comprensiones de listas ofrecen una solución elegante para crear listas con patrones específicos.

Creemos un nuevo archivo de Python para explorar las comprensiones de listas:

1. Haz clic en el menú "File" en la parte superior.
2. Selecciona "New File".
3. Nombrar el archivo list_comprehensions.py.
4. Guárdalo en el directorio /home/labex/project.

Ahora, agreguemos código para explorar cómo funcionan las comprensiones de listas con rangos:

## Basic list comprehension with range
## Format: [expression for item in iterable]
squares = [x**2 for x in range(1, 6)]
print("Squares of numbers 1-5:", squares)

## List comprehension with condition
## Format: [expression for item in iterable if condition]
even_squares = [x**2 for x in range(1, 11) if x % 2 == 0]
print("Squares of even numbers 1-10:", even_squares)

## Creating a list of numbers divisible by 3
divisible_by_3 = [x for x in range(1, 31) if x % 3 == 0]
print("Numbers divisible by 3 (1-30):", divisible_by_3)

## Converting Celsius temperatures to Fahrenheit
celsius_temps = list(range(0, 101, 20))
fahrenheit_temps = [(c * 9/5) + 32 for c in celsius_temps]

print("Celsius temperatures:", celsius_temps)
print("Fahrenheit temperatures:", [round(f, 1) for f in fahrenheit_temps])

## Creating a list of tuples (number, square)
number_pairs = [(x, x**2) for x in range(1, 6)]
print("Numbers with their squares:")
for num, square in number_pairs:
    print(f"Number: {num}, Square: {square}")

Ejecutemos este script para ver los resultados:

python3 list_comprehensions.py

Deberías ver la siguiente salida:

Squares of numbers 1-5: [1, 4, 9, 16, 25]
Squares of even numbers 1-10: [4, 16, 36, 64, 100]
Numbers divisible by 3 (1-30): [3, 6, 9, 12, 15, 18, 21, 24, 27, 30]
Celsius temperatures: [0, 20, 40, 60, 80, 100]
Fahrenheit temperatures: [32.0, 68.0, 104.0, 140.0, 176.0, 212.0]
Numbers with their squares:
Number: 1, Square: 1
Number: 2, Square: 4
Number: 3, Square: 9
Number: 4, Square: 16
Number: 5, Square: 25

Las comprensiones de listas tienen una sintaxis concisa que te permite crear listas en una sola línea de código. La sintaxis general es:

[expression for item in iterable if condition]

Donde:

• expression es lo que quieres incluir en la nueva lista.
• item es cada elemento del iterable.
• iterable es la secuencia a la que estás recorriendo (como range()).
• if condition es opcional y filtra qué elementos se incluyen.

Las comprensiones de listas son más legibles y, a menudo, más eficientes que crear una lista utilizando un bucle for tradicional con el método append(). Son especialmente útiles cuando se combinan con la función range() para crear listas numéricas con patrones o transformaciones específicas.

Aplicaciones prácticas de listas con rangos

Ahora que hemos aprendido cómo crear listas con rangos, exploremos algunas aplicaciones prácticas. Estos ejemplos demostrarán cómo se pueden utilizar las listas con rangos para resolver problemas comunes de programación.

Creemos un nuevo archivo de Python para nuestros ejemplos prácticos:

1. Haz clic en el menú "File" en la parte superior.
2. Selecciona "New File".
3. Nombrar el archivo range_applications.py.
4. Guárdalo en el directorio /home/labex/project.

Ahora, agreguemos código para varias aplicaciones prácticas:

## Example 1: Sum of numbers from 1 to 100
total = sum(range(1, 101))
print(f"Sum of numbers from 1 to 100: {total}")

## Example 2: Creating a multiplication table
def print_multiplication_table(n):
    print(f"\nMultiplication table for {n}:")
    for i in range(1, 11):
        result = n * i
        print(f"{n} × {i} = {result}")

print_multiplication_table(7)

## Example 3: Generating a calendar of years
current_year = 2023
years = list(range(current_year - 5, current_year + 6))
print(f"\nYears (5 past to 5 future): {years}")

## Example 4: Creating a countdown timer
def countdown(seconds):
    print("\nCountdown:")
    for i in range(seconds, 0, -1):
        print(i, end=" ")
    print("Blast off!")

countdown(10)

## Example 5: Calculating factorial
def factorial(n):
    result = 1
    for i in range(1, n + 1):
        result *= i
    return result

num = 5
print(f"\nFactorial of {num}: {factorial(num)}")

## Example 6: Creating a simple number guessing game
import random

def number_guessing_game():
    ## Generate a random number between 1 and 100
    secret_number = random.randint(1, 100)
    attempts = list(range(1, 11))  ## Maximum 10 attempts

    print("\nNumber Guessing Game")
    print("I'm thinking of a number between 1 and 100.")
    print("You have 10 attempts to guess it.")

    for attempt in attempts:
        ## In a real game, we would get user input
        ## For demonstration, we'll just print the logic
        print(f"\nAttempt {attempt}")
        print(f"(If this were interactive, you would guess a number here)")
        print(f"The secret number is: {secret_number}")

        ## Break after the first attempt for demonstration purposes
        break

number_guessing_game()

Ejecutemos este script para ver los resultados:

python3 range_applications.py

Deberías ver una salida que demuestre cada una de las aplicaciones prácticas:

1. La suma de todos los números del 1 al 100.
2. Una tabla de multiplicar para el número 7.
3. Una lista de años (5 años pasados a 5 años futuros).
4. Una cuenta regresiva del 10 al 1.
5. El factorial del número 5.
6. Una demostración de cómo podría funcionar un juego de adivinar números.

Estos ejemplos demuestran cómo los rangos combinados con listas se pueden utilizar para resolver diversos problemas de programación de manera eficiente. Algunos beneficios clave de utilizar listas con rangos en tus programas son:

1. Código simplificado para iterar sobre una secuencia de números.
2. Uso eficiente de la memoria (los objetos de rango no almacenan todos los números en memoria).
3. Fácil creación de patrones y secuencias numéricas.
4. Integración conveniente con otras funciones de Python como sum(), min() y max().

Al dominar la creación y manipulación de listas con rangos, puedes escribir código Python más conciso y eficiente para una amplia variedad de aplicaciones.

Resumen

En este laboratorio (lab), has aprendido cómo crear y utilizar listas con rangos de números en Python. Aquí está un resumen de lo que has logrado:

1. Has aprendido los fundamentos de las listas de Python, incluyendo cómo crearlas, acceder a ellas y modificarlas.
2. Has explorado la función range() y cómo usarla para generar secuencias de números.
3. Has descubierto cómo usar las comprensiones de listas (list comprehensions) para crear listas más complejas basadas en rangos.
4. Has aplicado estas técnicas para resolver problemas prácticos de programación.

Estas habilidades son fundamentales para muchas tareas de programación en Python, desde el procesamiento simple de datos hasta algoritmos más complejos. La capacidad de generar y manipular rápidamente secuencias de números es una herramienta poderosa que te ayudará a escribir código Python más eficiente y efectivo.

A medida que continúes tu viaje en Python, encontrarás estas técnicas útiles en muchos contextos, incluyendo el análisis de datos, el desarrollo web, la computación científica y más. La combinación de listas y la función range() proporciona una base sólida para trabajar con datos numéricos en Python.