Gráficos de tortuga

Comandos de la Tortuga

Los comandos son la forma de decirle a Tracy la Tortuga que haga cosas.
Tracy conoce varios comandos integrados.

Movimiento

El comando avanzar hace que Tracy avance una distancia determinada

forward(10)
forward(50)
forward(200)

El comando hacia atrás hace que Tracy retroceda una distancia determinada

backward(10)
backward(50)
backward(200)

También se pueden utilizar valores negativos para desplazar Tracy hacia delante o hacia atrás

backward(-200)
forward(-200)

Posición

Tracy se posiciona en un plano de coordenadas (x, y) así:
Cada punto del mundo de Tracy puede localizarse mediante una coordenada (x, y). Por ejemplo

• El centro del mundo es (0, 0)
• La parte superior central del mundo es (0, 200)
• La parte inferior izquierda del mundo es (-200, -200)
• Y así sucesivamente...

Podemos utilizar los comandos setposition o goto para enviar a Tracy a un lugar concreto

# Envía a Tracy al centro del mundo
setposition(0, 0)
goto(0, 0)

# Envía a Tracy al centro derecha del mundo
setposition(100, 0)
goto(100, 0)

# Envía a Tracy a la esquina superior derecha del mundo
setposition(200, 200)
goto(200, 200)

También podemos establecer sólo la posición x o y de Tracy utilizando setx o sety.

# Establece la posición x de Tracy en 100
# La posición y permanece igual
setx(100)

# Establece la posición y de Tracy en 100
# La posición x se mantiene igual
sety(100)

Giro

Tenemos unas cuantas opciones de comando cuando queremos girar Tracy para que mire en una nueva dirección.
El comando left(degrees) girará a Tracy hacia la izquierda un número determinado de grados.

# Tracy girará 90 grados a la izquierda
left(90)

# Tracy girará 180 grados a la izquierda y
# mirará en la dirección opuesta
left(180)

# Tracy girará a la izquierda 360 grados completos
# y hará un giro completo
left(360)

El comando right(degrees) hará girar a Tracy hacia la derecha un número determinado de grados.

right(90)
right(180)
right(360)

También se pueden utilizar valores negativos para girar Tracy a la derecha o a la izquierda

right(-90)
left(-90)

Podemos utilizar el comando setheading (o seth) para establecer Tracy en una dirección concreta

# Establece que Tracy apunte a la derecha
setheading(0)

# Haz que Tracy apunte hacia arriba
setheading(90)

# Pon a Tracy hacia abajo
seth(270)

Círculos

El comando círculo hace que Tracy dibuje un círculo sobre ella con el radio especificado

circle(10)
circle(100)

Se puede utilizar otro parámetro para dibujar sólo determinadas partes de un círculo

# Este comando dibujará un semicírculo
circle(10, 180)

# Este comando dibujará un cuarto de círculo
circle(10, 90)

Se puede utilizar un parámetro adicional para controlar el número de puntos de la forma

# Este comando dibujará un triángulo
circle(10, 360, 3)

# Este comando dibujará un cuadrado
circle(10, 360, 4)

Pen

Cuando se utiliza el comando penup, Tracy no dejará rastro al moverse

# Tracy se moverá 50 píxeles sin dejar rastro
penup()
forward(50)

Cuando se utiliza el comando pendown, Tracy dejará un rastro cuando se mueva

# Tracy se moverá a la posición (50, 50) dejando un rastro tras de sí
pendown()
goto(50, 50)

Nota: ¡Tracy siempre empieza con la pluma hacia abajo!

Control del tamaño del lápiz
Podemos utilizar el comando pensize para establecer el tamaño del bolígrafo

# Normal, ancho de línea de 1
# Este es el tamaño por defecto
pensize(1)

# Más grande, ancho de línea de 10
pensize(10)

Velocidad

Podemos establecer la velocidad de Tracy utilizando el comando speed.
Nota: Las opciones de velocidad van de 0 a 10.

# Más lento
speed(1)

# Normal
speed(6)

# Rápido
speed(10)

# Más rápido (casi inmediato)
speed(0)

Color

El comando color se puede utilizar para cambiar el color de Tracy y su rastro, mientras que el comando bgcolor se utiliza para cambiar el color del lienzo. Encuentra una lista de nombres de colores aceptables en este sitio web.

# Dibuja una línea roja
color("red")
forward(50)

# Dibuja una línea azul
color("blue")
forward(50)

# Algunas opciones de color:
color("black") # negro
color("blue") # azul
color("brown") # marrón
color("cyan") # cian
color("gold") # dorado
color("gray") # gris
color("green") # verde
color("indigo") # índigo
color("orange") # naranja
color("pink") # rosa
color("purple") # morado
color("red") # rojo
color("violet") # violeta
color("white") # blanco
color("yellow") # amarillo

Los códigos hexadecimales también se pueden utilizar para establecer un array mayor de colores. Este sitio web del selector hexadecimal de colores puede utilizarse para generar códigos hexadecimales de colores.

# Establece el color a un morado específico utilizando el código hexadecimal #8631C3
color("#8631C3")

También puedes establecer el color del fondo utilizando el comando bgcolor.

# Establece el color de fondo como morado
bgcolor("purple")

Relleno

Los comandos begin_fill() y end_fill() pueden invocarse alrededor de un conjunto de comandos de movimiento para rellenar la forma que se está dibujando.

# Para dibujar una forma rellena, empieza con esta llamada
begin_fill()

# Dibuja tu forma
for i in range(3):
    forward(50)
    left(120)

# Deja de rellenar cuando hayas dibujado la forma
end_fill()

Forma del cursor

Por defecto, el cursor tendrá la forma de Tracy, que es una tortuga. Podemos utilizar el comando shape para cambiar la forma del cursor.
Las opciones de forma que se pueden utilizar son:

• "arrow" (flecha)
• "turtle" (tortuga)
• "circle" (círculo)
• "square" (cuadrado)
• "triangle" (triángulo)
• "classic" (clásico)

# Esto cambiará la forma del cursor a un círculo
shape("circle")

Borrar pantalla

Para limpiar la pantalla de cualquier marca, utiliza el comando clear, que puede utilizarse en cualquier momento a lo largo del código.

# Esto limpiará la pantalla después de dibujar el cuadrado
for i in range(4):
    forward(50)
    left(90)
clear()

# Esto limpiará la pantalla antes de dibujar el cuadrado
circle(50)
clear()
for i in range(4):
    forward(50)
    left(90)

Bucles

Los bucles nos ayudan a repetir comandos, lo que hace que nuestro código sea mucho más corto.
¡Asegúrate de que todo lo que hay dentro del bucle tiene indentación de un nivel!

Para bucles

Utiliza los for loops cuando quieras repetir algo un número fijo de veces.

# En lugar de repetir código una y otra vez
forward(10)
left(90)
forward(10)
left(90)
forward(10)
left(90)
forward(10)
left(90)

# ¡Usa un bucle for para repetir el código!
for i in range(4):
    forward(10)
    left(90)

Puedes utilizar la variable i dentro del bucle.
i empieza en 0 y llega hasta CONTAR-1.

# Esto hará que Tracy avance 0, luego 1, luego 2
for i in range(3):
    forward(i)

# Puedes cambiar el valor de i dentro de un for loop utilizando expresiones matemáticas
for i in range(3):
    forward(i*10)

También puedes controlar el valor de i utilizando parámetros extendidos. for i in range(STARTING_VALUE, ENDING_VALUE, INCREMENT):

# Esto hará que Tracy avance 25, 50 y 75 píxeles
for i in range(25, 76, 25):
    forward(i)

Nota: No se incluye el valor final.

Bucles while

Utiliza los while loops cuando quieras repetir algo un número indeterminado de veces o hasta que una condición se vuelva false.
Si no hay ningún punto en el que la condición se convierta en false, crearás un bucle infinito que siempre debes evitar.

# Sigue dibujando círculos hasta que la variable 'count' sea mayor que 5
# Si la variable 'count' no se actualiza, se producirá un bucle infinito
count = 0
while count <= 5
    circle(50)
    count = count + 1 #OR count += 1

También puedes utilizar entradas del usuario para controlar un while loop

# Este código continuará ejecutándose mientras el usuario responda 'Yes'
should_continue = input("¿Continuar código?: ")
while should_continue == "Yes":
    forward(10)
    left(90)
    should_continue = input("¿Continuar código?: ")

Una condición que podemos utilizar es while True: que, por sí sola, crearía un bucle infinito, cosa que no queremos.
Si emparejamos esta condición con una declaración break en algún lugar dentro del bucle, entonces hay otra forma de salir del bucle y se puede evitar el bucle infitie.

# Este código seguirá ejecutándose mientras el usuario responda 'Yes'
while True:
    should_continue = input("¿Continuar código?: ")
    if not should_continue == "Yes":
        break
    else:
        forward(10)
        left(90)

Nota: La instrucción break es no seguida de un conjunto de paréntesis.

Funciones

Escribir una función es como enseñar a Tracy la Tortuga una palabra new.
Cómo nombrar las funciones: Puedes nombrar tus funciones como quieras, pero no puedes poner espacios en el nombre de la función. En lugar de espacios, utiliza guiones bajos ( _ ):
como_esto_por_ejemplo
¡Asegúrate de que todo el código dentro de tu función tiene indentación de un nivel!

Definir una función

Definimos una función para enseñar a Tracy las instrucciones para la palabra new.

# Código que se ejecutará cuando hagas una llamada a esta función.
def name_of_your_function():

# EJEMPLOS

# Enseña a Tracy a dibujar una arista
def draw_edge():
    forward(50)
    left(90)

# Enseña a Tracy a dibujar un borde azul
def draw_blue_edge():
    color("blue")
    forward(50)
    left(90)

# Enseña a Tracy a dibujar un cuadrado
def draw_square():
    for i in range(4):
        draw_edge()

Utilización de parámetros en funciones

Utilizamos parámetros para modificar determinados comandos de nuestra función.

# Utiliza un parámetro para controlar el radio del círculo que se dibuja
def draw_circle(radius):
    circle(radius)

# Se pueden utilizar varios parámetros en una función

# Los parámetros controlan la longitud de los lados del cuadrado y el color
def draw_square(length, color_choice):
    color(color_choice)
    for i in range(4):
        forward(length)
        left(90)

Llamar a una función

Llamamos a una función para que Tracy ejecute realmente el new comando.

# Llama una vez a la función draw_edge()
# Tracy dibujará una arista
draw_edge()

# Llama a la función draw_edge() 3 veces
# Tracy dibujará 3 aristas
draw_edge()
draw_edge()
draw_edge()

# Llama a la función draw_square() con parámetros
# Tracy dibujará 3 cuadrados con tamaños y colores diferentes
draw_square(50, "red")
draw_square(100, "blue")
draw_square(75, "orange")

Devolver valores de una función

Podemos utilizar la palabra clave return para devolver un valor de una función al código desde el que se llamó.

# Actualiza el valor de 'num' y devuélvelo
def increase(num):
    num += 100
    return num

Podemos utilizar este valor devuelto directamente en nuestros comandos:

# Dibuja un círculo con el radio devuelto por la función 'increase'
def increase(num):
    num += 100
    return num

circle(increase(50))

Variables

Variables & Operadores Abreviados

Utilizamos variables para almacenar valores que pueden utilizarse para controlar comandos en nuestro código. Los valores de las variables también se pueden modificar a lo largo del código.

# Crea una variable para llevar la cuenta de algo
count = 0

# Podemos actualizar el valor de la variable mediante expresiones matemáticas

# Esto añadirá uno al valor de la variable 'count'
count = count + 1
# Nota: ¡Este operador abreviado hará lo mismo!
count += 1

# Los valores de las variables también se pueden modificar dentro de las estructuras de control

# El valor de la variable 'count' aumentará en 1 en cada iteración del bucle
for i in rango(4):
    forward(10)
    count += 1

Nota: Para obtener más información sobre los operadores abreviados, consulta este artículo!

Tipos de datos

Lo más probable es que los datos que almacenemos en variables se ajusten a uno de los siguientes tipos:

• Cadena (str): Un carácter o grupo de caracteres
• Integer (int): Un número entero
• Número en coma flotante (float): Un valor decimal
• Booleano (bool): Un valor verdadero o falso

Podemos convertir un tipo en otro (siempre que sea posible) utilizando algo llamado casting.

# Convierte var_1 en un entero
var_1 = "10"
var_1 = int(var_1)
# Ahora var_1 se puede utilizar en expresiones matemáticas

# Convierte var_2 en una cadena
var_2 = "505"
var_2 = str(var_2)
# Ahora var_2 se puede concatenar con otras cadenas para imprimir un mensaje

# Convierte var_3 en un número de coma flotante
var_3 = 5
var_3 = float(var_3)
# Ahora var_3 se tratará como 5,0 cuando se utilice en expresiones matemáticas

También podemos utilizar la función type para determinar el tipo de una variable.

# Imprime el tipo del valor introducido
print(type("25")
# Imprimirá el tipo como 'str'

Entrada

Podemos utilizar las entradas del usuario para controlar nuestro código.

La función de entrada

Podemos pedir la entrada de texto al usuario con la función input.

# Pide al usuario que introduzca texto y guárdalo en una variable para usarla en el código.
# Esto sólo funcionará si la entrada se utiliza como cadena de texto
circle_color = input("¿Cuál es el color del círculo?")

# Si la entrada debe utilizarse como un número, cámbialo a un 'int'
radius = int(input("¿Cuál es el radio del círculo? "))

# Esta entrada se puede utilizar para controlar distintas partes del código
color(circle_color)
circle(radius)

El método onclick

Podemos permitir que el usuario interactúe con nuestros programas utilizando el método onclick, que realiza una llamada a una función de devolución de llamada.

# Define la función de llamada de retorno
# (debe tomar parámetros para las coordenadas x e y del clic del ratón)
def make_square(x, y):
    for i in range(4):
        forward(50)
        left(90)

# Cuando el usuario hace clic en el cursor, ejecuta la función de devolución de llamada
onclick(make_square)

Nota: No se utiliza un conjunto de paréntesis cuando se llama a la función de devolución de llamada dentro del método onclick.

También podemos permitir que el usuario haga clic en cualquier parte del lienzo utilizando la función getscreen.

# Guarda la pantalla en la variable 'canvas'
canvas = getscreen()

# Llama a la función move_to_click cuando se haga clic en el lienzo
canvas.onclick(move_to_click)

Para utilizar una variable dentro de una función de devolución de llamada, defínela después de utilizar el método onclick y utilízala en el nombre de la variable en la que se guarda la pantalla.

# Aumenta e imprime el valor de 'count' cada vez que el usuario haga clic en la pantalla
def increase(x, y):
    canvas.count += 1
    print(canvas.count)

canvas = getscreen()
canvas.onclick(increase)
canvas.count = 0

Afirmaciones if/else

Podemos decirle a Tracy cómo tomar decisiones mediante declaraciones if/else.
¡Asegúrate de que todo el código dentro de tu declaración if/else está sentado un nivel!

Declaraciones if

Utiliza una declaración if para decirle a Tracy que haga algo sólo cuando una condición sea true. Si la condición es false, Tracy omitirá los comandos indentados debajo.

# Tracy sólo dibujará un círculo si la variable 'count' es menor que 5
if count < 5:
    circle(50)

Declaraciones if/else

Utiliza una declaración if/else para obligar a Tracy a tomar una decisión entre varias condiciones. Si la primera condición es false, Tracy pasará a la siguiente hasta que encuentre una que sea true. Si ninguna condición es true, se ejecutarán los comandos del bloque 'else'.

# Tracy dibujará un círculo si la variable 'count' es menor que 5
if count < 5:
    circle(50)
# Tracy dibujará un cuadrado si la variable 'count' es mayor que 5
elif count > 5:
    circle(50,360,4)
# En cualquier otro caso, Tracy dibujará una línea
# El único otro caso que existe fuera de los límites indicados es if 'count' = 5
# No incluimos una condición para las declaraciones else
else:
    forward(50)

Texto

Imprimir

La función print se puede utilizar para imprimir texto en la consola (la caja que hay debajo del lienzo).

# Imprime el mensaje
print("¡Hola Mundo!")

# Imprime el número
print(50)

Podemos combinar distintos valores dentro de nuestras sentencias print. Podemos utilizar el operador + para combinarlos, lo que se denomina concatenación. También podemos utilizar el método format para combinar valores.
Nota: Todo el texto que se combine debe ser del mismo tipo.

# Imprime el mensaje personalizado
name = "Tracy"
print("Hola " + name)

message = "Hola {}"
print(message.format(name))

# Imprime la etiqueta
# Nota: 'value' debe ser de tipo str
value_type = "Radius"
value = 35
print(value_type + ": " + str(value))

label = "{}: {}"
print(label.format(value_type, str(value)))

Escribe

Para añadir texto al lienzo (la caja donde dibuja Tracy), utilizamos la función write. La etiqueta para el texto se da como parámetro, con parámetros opcionales para cambiar los atributos de fuente o la ubicación del texto.

# Añade una etiqueta utilizando los atributos de texto por defecto
write("¡Hola Mundo!")

# Añade una etiqueta con la fuente Arial 20pt
write("Hola", font=("Arial", 20))

# Añade una etiqueta centrada en Tracy
write("Tracy", align="center")

Algunas fuentes que se pueden utilizar son

• "Arial"
• "Courier New"
• "Georgia"
• "Times New Roman"
• "Trebuchet MS"
• "Verdana"
• "Futura"
• "Comic Sans MS"
• "Monospace"
• "Cursive"
• "Fantasy"

Los atributos de alineación que se pueden utilizar son:

• "center" (centro)
• "left" (izquierda)
• "right" (derecha)

Nota: Estos valores indican dónde se sitúa Tracy con respecto al texto. Si estableces la alineación como "derecha", Tracy estará a la derecha del texto.

Métodos con cadenas

Podemos utilizar métodos con cadenas para manipular o analizar el texto.
Algunos métodos que podemos utilizar son

• capitalize (capitalizar): Poner en mayúscula la primera letra de la cadena y minúsculas todas las letras siguientes
• upper (superior): escribe en mayúsculas todas las letras de una cadena
• lower (inferior): escribe todas las letras de una cadena en minúscula
• strip (eliminar): quita los espacios en blanco del principio y el final de una cadena
• replace(old_value, new_value) (reemplazar): reemplaza todas las apariciones del valor antiguo en la cadena por el valor nuevo
• find(element) (encontrar): devuelve el índice de la primera aparición del elemento en la cadena (-1 si no se encuentra)
• count(element) (contar): devuelve el número de veces que aparece el elemento en la cadena

string = "hola mundo"

# Imprime la cadena con 'H' y 'W' en mayúsculas
print(string.capitalize())

# Imprime la cadena con todas las letras en mayúscula
print(string.upper())

# Imprime 'he!!o wor!d'
print(string.replace('l', '!'))

# Imprime 2 (la primera 'l' se encuentra en el índice 2)
print(string.find('l'))

# Imprime 3 (se han encontrado 3 "l" en la cadena)
print(string.count('l'))

También tenemos algunos métodos de cadena que se pueden utilizar en condicionales basados en los valores dentro de una cadena.
Algunos métodos de cadena condicionales son

• isalpha: devuelve True si todos los caracteres son letras a-z or A-Z
• isdigit: devuelve True si todos los caracteres son números del 0 al 9
• isnumeric: devuelve True si todos los caracteres son números del 0 al 9
• isupper: devuelve True si todas las letras de la cadena están en mayúsculas
• islower: devuelve True si todas las letras de la cadena están en minúsculas
• startswith(value): devuelve True si la cadena empieza por el valor dado
• endswith(value): devuelve True si la cadena termina con el valor dado

# Dibuja un círculo azul
name = "ronaldo"

if name.islower(): #Verdadero
    color("blue")
if name.isdigit(): #Falso
    penup()
if name.startswith("r"): #Verdadero
    circle(50)

Comentarios

Utilizamos los comentarios para dejar notas sobre el código al lector. En realidad, los comentarios no los ejecuta Python, sólo están ahí para ayudarnos a leer el código.
Podemos hacer comentarios multilínea con """ y comentarios de una sola línea con #.

"""
Un comentario multilínea describe tu código
a alguien que lo esté leyendo.
"""

# Utiliza comentarios de una sola línea para aclarar el código.

Listas

Una lista es una estructura de datos que puede almacenar varios valores dentro de una variable.

Generalidades

Crear una lista
Las listas se inicializan utilizando corchetes.

# Inicializa una lista vacía:
list_name = []

# Inicializar una lista con valores:
list_name = [item_1, item_2, item_3, ...]

Recuerda: ¡Las listas pueden contener cualquier número de valores que pueden ser una mezcla de cualquier tipo de datos!

Acceso a los elementos de una lista
Los elementos de una lista utilizan valores de índice que empiezan por 0 para el primer valor de la lista, y aumentan en 1 a medida que avanzas por los valores.
También se pueden utilizar valores de índice negativos, en los que al último elemento de la lista se le asigna el valor -1 y disminuye en 1 a medida que te desplazas hacia la izquierda por los valores.

Valor de índice positivo:  0       1       2       3
             my_list = ["Hola", "Mundo", "Soy", "Tracy"]
Valor de índice negativo: -4      -3      -2      -1

Se accede a los elementos utilizando el valor del índice dentro de los corchetes.

# Guarda el primer elemento en la variable 'word':
word = my_list[0]

# Imprime el último elemento:
print(my_list[-1])

También se puede acceder a los elementos mediante rebanadas que anotan el valor del índice inicial (incluido en la rebanada) y el valor del índice final (no incluido en la rebanada):
my_list[starting_index:ending_index]

my_list = ["a", "b", "c", "d"]
print(my_list[1:3])
    
# Imprimirá ['b', 'c']

print(my_list[2:])

# Imprimirá ['c', 'd'] (Todos los elementos desde el valor del índice inicial hasta el final)

print(my_list[:2])

# Imprimirá ['a', 'b'] (Todos los elementos hasta el valor del índice final, sin incluirlo)

Actualización de elementos de una lista
Los elementos se actualizan utilizando el valor del índice entre corchetes y asignándole un nuevo valor.

# Actualiza el primer elemento de una lista:
my_list[0] = "Hola"

Métodos de lista

Los Métodos de Lista se pueden utilizar para realizar diversas alteraciones en las listas que hemos creado.

Añadir elementos a una lista
Los siguientes métodos se pueden utilizar para añadir elementos a una lista de distintas formas:

• append: Añade un elemento al final de una lista

my_list = [1, 2, 3]
my_list.append(4)

# my_list ahora contiene [1, 2, 3, 4]

• extend: Añade varios elementos al final de una lista

my_list = [1, 2, 3]
my_list.extend([4, 5])

# my_list ahora contiene [1, 2, 3, 4, 5]

# Los elementos extendidos también se pueden guardar dentro de una lista aparte
my_list = [1, 2, 3]
new_values = [4, 5]
my_list.extend(new_values)

# my_list ahora contiene [1, 2, 3, 4, 5]

• insert: Inserta un elemento en un lugar específico de una lista (el primer parámetro es el valor del índice, el segundo parámetro es el nuevo elemento)

my_list = [1, 2, 3]
my_list.insert(1, 4)

# my_list ahora contiene [1, 4, 2, 3]

Eliminar elementos de una lista
Los siguientes métodos se pueden utilizar para eliminar elementos de una lista de distintas formas:

• pop: Elimina un elemento en un índice específico de una lista (Si no se indica ningún índice, se elimina el último elemento)

my_list = [1, 2, 3]
my_list.pop(2)

# my_list contiene ahora [1, 2]

my_list.pop()

# my_list ahora contiene [1]

• remove: Elimina un elemento concreto (si existe) de una lista

my_list = [1, 2, 3]
my_list.remove(2)

# my_list ahora contiene [1, 3]

my_list.remove(4)

# my_list ahora contiene [1, 3] porque 4 no es un elemento de la lista

• del (Una palabra clave, no un método): Elimina un elemento en un índice específico de una lista.

my_list = [1, 2, 3]
del my_list[2]

# my_list ahora contiene [1, 2]

Métodos de lista adicionales

• sort (ordenar): Ordena los elementos de una lista de menor a mayor o por orden alfabético

my_num_list = [2, 3, 1]
my_num_list.sort()

# my_num_list ahora contiene [1, 2, 3]

my_word_list = ["Gato", "Manzana", "Arbol"].
my_word_list.sort()

# my_word_list ahora contiene ["Arbol", "Gato", "Manzana"].

• reverse (invertir): Invierte el orden de los elementos de una lista

my_list = ["Gato", "Manzana", "Arbol"]
my_list.reverse()

# Ahora my_list contiene ["Arbol", "Manzana", "Gato"].

Longitud de la lista

Se puede acceder a la longitud de una lista utilizando la función len.

my_list = ["a", "b", "c", "d"]

# Imprimirá 4
print(len(my_list))

# Imprimirá el último elemento de la lista, "d"
print(my_list[len(my_list) - 1])

Bucle sobre los elementos de la lista

Hay 2 formas de recorrer los elementos de una lista- por índice y por elemento.

Bucle sobre una lista por índice
Recorre los elementos mediante un bucle for con la palabra clave range, accediendo a los elementos por su valor de índice.

for i in range(len(my_list)):
    # Comandos indentados aquí

Nota: Ésta es la mejor forma de acceder a los elementos si lo necesitas:

• Utilizar el valor del índice dentro de los comandos de bucle
• Alterar los ítems de una lista

letters = ["a", "b", "c", "d"]

for i in range(len(letters)):
    print(str(i+1) + ": " + letters[i])

# Salida:
 1: a
 2: b
 3: c
 4: d

Bucles sobre una lista por elemento
Realiza un bucle sobre los elementos utilizando una variable que tomará el valor de cada elemento de la lista uno a uno.

for item in list:
    # Comandos indentados aquí

Nota: Los elementos de la lista no se pueden modificar con esta estructura de bucle.

letters = ["a", "b", "c", "d"]

for letter in letters:
    print(letter)

# Salida:
 a
 b
 c
 d