Rangos y enumerados en Python – range y enumerate

Range enumerate en Python

En Python es muy común el uso de iteradores y para mejorar la usabilidad se disponen dos tipos básicos muy útiles. Estos tipos son range y enumerate, los cuales hacen la tarea de iterar sobre elementos muy conveniente en diferentes aspectos.

Range y enumerate se usan principalmente en iteraciones de elementos.

¿Qué son los range en Python?

El tipo range es un tipo especial en Python y permite crear una serie de elementos numérios de forma intuitiva.

Las características principales de range son las siguientes:

  • Se crean en un intervalo de valores enteros.
  • Se puede especificar el paso.
  • Los enteros de comienzo, fin y paso pueden ser negativos.
  • Las iteraciones son muy eficientes en memoria en Python 3.
  • Se usan en bucles for, bucles while o construcciones por comprehensión principalmente.
  • La ejecución para cuando el valor a devolver es superior al valor de parada.

¿Cómo crear rangos en Python?

La sintáxis para la creación de rangos es la siguiente:

range(start, stop, step)

  • range(stop): crea un iterador desde el 0 hasta el valor de stop añadiendo 1 en cada iteración.
  • range(start, stop): crea un iterador desde start hasta stop con paso 1.
  • range(start, stop, step): crea un iterador desde start hasta stop con paso step.

A continuación se muestran ejemplos de rangos en Python:

>>> range(5)
range(0, 5)
>>> list(range(5))
[0, 1, 2, 3, 4]
>>> list(range(5, 10))
[5, 6, 7, 8, 9]
>>> list(range(5, 10, 2))
[5, 7, 9]
>>> list(range(5, 10, -2))
[]
>>> list(range(10, -6, -2))
[10, 8, 6, 4, 2, 0, -2, -4]
>>> list(range(10, -6, -7))
[10, 3, -4]
>>> list(range(-5))
[]
>>> list(range(-5, 0))
[-5, -4, -3, -2, -1]
>>> list(range(-5, 10, 3))
[-5, -2, 1, 4, 7]

Como se puede ver en los ejemplos, es muy util para crear secuencias numéricas de forma elegante y simple.

¿Cómo usar range en Python?

Ejemplos de uso de range:

>>> for n in range(5):
...     print(n * n)
... 
0
1
4
9
16
>>> [x for x in range(0, 10, 2)] # números pares
[0, 2, 4, 6, 8]
>>> {x: chr(x + 65) for x in range(26)} # dict de letras
{0: 'A', 1: 'B', 2: 'C', 3: 'D', 4: 'E', 5: 'F', 6: 'G', 7: 'H', 8: 'I', 9: 'J', 10: 'K', 11: 'L', 12: 'M', 13: 'N', 14: 'O', 15: 'P', 16: 'Q', 17: 'R', 18: 'S', 19: 'T', 20: 'U', 21: 'V', 22: 'W', 23: 'X', 24: 'Y', 25: 'Z'}
>>> numbers = iter(range(10))
>>> while numbers:
...     n = next(numbers)
...     if n % 2:
...         print(f'{n} es impar')
...     else:
...         print(f'{n} es par')
... 
0 es par
1 es impar
2 es par
3 es impar
4 es par
5 es impar
6 es par
7 es impar
8 es par
9 es impar
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
StopIteration

Métodos disponibles para range

>>> dir(range)
['__bool__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', 
'__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', 
'__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', 
'__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__setattr__', '__sizeof__', 
'__str__', '__subclasshook__', 'count', 'index', 'start', 'step', 'stop']
MétodoDescripciónEjemplo
countDevuelve el número de ocurrencias del valor como argumento.range.count(5)
indexDevuelve la posición donde se encuentra el valor como argumento, o un error si no lo encuentra.range.index(7)
startDevuelve el valor de inicio del rango.range.start
stepDevuelve el valor del paso del rango.range.step
stopDevuelve el valor de fin del rango.range.stop

¿Qué son los enumerate en Python?

El tipo enumerate es un tipo auxiliar que ayuda a iterar una secuencia de elementos, obteniendo pares de elementos con la posición y el elemento.

Sus características son las siguientes:

  • Devuelve un iterador de pares de valores.
  • Cada par de valores contiene la posición y el elemento.
  • Permiten cualquier tipo de datos.
  • Permite definir el primer número de indice a usar. Por defecto 0.

Casos de uso de enumerados en Python

El principal uso de este tipo de dato es para acceder a los elementos de un iterador sabiendo la posición como por ejemplo en listas, tuplas o cadenas, pero no solo esos usos.

>>> for i, val in enumerate(['A', 'B', 'C']):
...     print(i, val)
... 
0 A
1 B
2 C
>>> for i, val in enumerate(['A', 'B', 'C'], start=5):
...     print(i, val)
... 
5 A
6 B
7 C
>>> for i, val in enumerate(range(5, 15, 3), start=1):
...     print(f'Pos: {i} -> {val}')
... 
Pos: 1 -> 5
Pos: 2 -> 8
Pos: 3 -> 11
Pos: 4 -> 14
>>> dd = dict(tipo='Moto', marca='Honda', power=599)
>>> print(list(enumerate(dd)))
[(0, 'tipo'), (1, 'marca'), (2, 'power')]
>>> for idx, key in enumerate(dd):
...     print(f'Pos: {idx} - dict_key {key} - value {dd[key]}')
... 
Pos: 0 - dict_key tipo - value Moto
Pos: 1 - dict_key marca - value Honda
Pos: 2 - dict_key power - value 599

Se puede utilizar para recorrer facilmente matrices:

>>> m = [['enteros', 1, 2, 3, 4],
...  ['complex', 1j, 2j, 3j, 4j],
...  ['float', 1.0, 2.0, 3.0, 4.0]]
# [['enteros', 1, 2, 3, 4], ['complex', 1j, 2j, 3j, 4j], ['float', 1.0, 2.0, 3.0, 4.0]]
>>> for i, elems in enumerate(m):
...     for j, jelem in enumerate(elems):
...         print(f'row {i} - column {j}: {jelem}')
... 
row 0 - column 0: enteros
row 0 - column 1: 1
row 0 - column 2: 2
row 0 - column 3: 3
row 0 - column 4: 4
row 1 - column 0: complex
row 1 - column 1: 1j
row 1 - column 2: 2j
row 1 - column 3: 3j
row 1 - column 4: 4j
row 2 - column 0: float
row 2 - column 1: 1.0
row 2 - column 2: 2.0
row 2 - column 3: 3.0
row 2 - column 4: 4.0

Libros recomendados para aprender Python

Estos son los libros que pueden ayudarte a aprender Python, aprender a programar, tipos de datos, algoritmia y mucho más.

Disponible en:

Compartir

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Información básica sobre protección de datos Ver más

  • Responsable Oscar Ramirez.
  • Finalidad Moderar los comentarios. Responder las consultas.
  • Legitimación Su consentimiento.
  • Destinatarios  ionos.
  • Derechos Acceder, rectificar y suprimir los datos.

Publicar un comentario