Docsity
Docsity

Prepara tus exámenes
Prepara tus exámenes

Prepara tus exámenes y mejora tus resultados gracias a la gran cantidad de recursos disponibles en Docsity


Consigue puntos base para descargar
Consigue puntos base para descargar

Gana puntos ayudando a otros estudiantes o consíguelos activando un Plan Premium


Orientación Universidad
Orientación Universidad


Estructura de control while y if en Python, Apuntes de Algoritmos y Programación

La estructura y funcionamiento de las sentencias while y if en el lenguaje de programación Python. Se detalla cómo se controla la repetición de bloques de código mediante la condición de un while, así como cómo se utiliza una sentencia if para realizar acciones condicionales. Además, se muestra un ejemplo práctico para clarificar el concepto.

Tipo: Apuntes

2018/2019

Subido el 16/08/2022

jose-gerardo-carrillo-gonzalez
jose-gerardo-carrillo-gonzalez 🇲🇽

4 documentos

1 / 21

Toggle sidebar

Esta página no es visible en la vista previa

¡No te pierdas las partes importantes!

bg1
1
TUTORIAL 2
Lenguaje de programación: Python
Autor: José Gerardo Carrillo González
Contenido:
Escribir código .................................................................................................................................... 2
Indentación ...................................................................................................................................... 2
Sentencia While .................................................................................................................................. 2
Ejemplo 1 ........................................................................................................................................ 3
Ejemplo 2 ........................................................................................................................................ 4
Ejemplo 3 ........................................................................................................................................ 5
Ejemplo 4 ........................................................................................................................................ 5
Ejemplo 5 ........................................................................................................................................ 6
Sentencia If .......................................................................................................................................... 7
Ejemplo 6 ........................................................................................................................................ 7
Ejemplo 7 ........................................................................................................................................ 8
Ejemplo 8 ........................................................................................................................................ 9
Sentencia For ..................................................................................................................................... 10
Ejemplo 9 ...................................................................................................................................... 12
Ejemplo 10 .................................................................................................................................... 14
Ejemplo 11 .................................................................................................................................... 15
Ejemplo 12 .................................................................................................................................... 15
Ejemplo 13 .................................................................................................................................... 16
Ejemplo 14 .................................................................................................................................... 17
Para practicar ..................................................................................................................................... 19
Ejemplo 15 .................................................................................................................................... 19
Ejemplo 16 .................................................................................................................................... 20
Ejemplo 17 .................................................................................................................................... 21
Ejemplo 18 .................................................................................................................................... 21
pf3
pf4
pf5
pf8
pf9
pfa
pfd
pfe
pff
pf12
pf13
pf14
pf15

Vista previa parcial del texto

¡Descarga Estructura de control while y if en Python y más Apuntes en PDF de Algoritmos y Programación solo en Docsity!

Lenguaje de programación: Python

Autor: José Gerardo Carrillo González

  • TUTORIAL
  • Escribir código Contenido:
    • Indentación
  • Sentencia While
    • Ejemplo
    • Ejemplo
    • Ejemplo
    • Ejemplo
    • Ejemplo
  • Sentencia If..........................................................................................................................................
    • Ejemplo
    • Ejemplo
    • Ejemplo
  • Sentencia For.....................................................................................................................................
    • Ejemplo
    • Ejemplo
    • Ejemplo
    • Ejemplo
    • Ejemplo
    • Ejemplo
  • Para practicar
    • Ejemplo
    • Ejemplo
    • Ejemplo
    • Ejemplo

Escribir código Para escribir un código lo podemos hacer en un editor de texto cualquiera, o bien en la ventana Python Shell accedemos a File, New file. Nos aparece la ventana de la Figura 1. Figura 1. En la ventana anterior podemos escribir código. Este lo guardaremos con extensión .py (Python files) y lo podemos ejecutar seleccionando la pestaña Run, Run Module, o directamente con F5.

Indentación

El bloque que comprende las instrucciones de una función, sentencia if, ciclo for o while, debe estar indentado, es decir se debe dejar el mismo número de espacios al inicio de cada renglón que comprende el bloque. Ejemplo: Se dejaron 4 espacios en la línea 2 (única instrucción del bloque if) y se dejaron 4 espacios en la línea 4 (única instrucción del bloque else). Sentencia While La sentencia while la usaremos para hacer que su bloque de código (indentado) se ejecute repetidamente siempre y cuando la condición se evalué True, con False el bloque no se ejecutara. La estructura del while es: while (condición): bloque de código

Ejemplo 2

Pedir al usuario introducir un número en el rango [1, 10 ]. En la línea 1 tenemos: n1=int(input('Introduce un número entre 1 y 1 0 : ')) La función input() se usa para capturar información con el teclado y muestra en pantalla la cadena dentro de los paréntesis (la cadena es opcional y pueden ser instrucciones), en este caso 'Introduce un número entre 1 y 10: ', luego espera a que el usuario introduzca una cadena y presione enter. La información introducida por el usuario se convierte a clase 'int' con int() y se asigna a n1. En la línea 3 tenemos la sentencia while, las líneas 4 y 5 conforman su bloque de instrucciones. La condición del while es: ( (n1<1) or (n1>10) ) y se lee: si n1 es menor que 1 o si n1 es mayor que 10. Si la condición se evalúa True significa que n1 no está en el rango especificado y se ejecuta el bloque de instrucciones del while. Notar que el operador lógico or es para obtener True ya sea que n1<1 o que n1>10. En línea 4 tenemos: print('El', n1, 'no está en el rango correcto, introduce otro número:') La función print() se usa para imprimir en pantalla cadenas y valores de nombres. Lo que va entre comillas es una cadena, para separar una cadena de un nombre (o un nombre de una cadena) se usan comas. Entonces la línea 4 es para informar al usuario que el número que introdujo no está en el rango correcto y que introduzca otro número. En la línea 5 se usa nuevamente la función input(), esta vez sin cadena. Lo capturado es convertido a número entero con int() y asignado a n1. La siguiente iteración del while se ejecuta o no, dependiendo del valor actual de n1. La condición del while se evalúa False cuando el número asignado en n1 satisfaga que 1<=n1<=10, de ser así no se ejecutan las líneas 4 y 5, es decir el bloque de instrucciones del while, y pasamos a la siguiente línea fuera del bloque, es decir la línea 7 , en la cual con print() se da a conocer el valor de n1 y el programa termina.

Ejemplo 3

Imprimir en pantalla la tabla de multiplicar del 1 al 10 para un número entre 1 y 10. En n1 se asigna, por medio de la función input(), el número del cual se desea imprimir la tabla de multiplicar. A n1 lo multiplicaremos por cada número entero entre 1 y 10, por lo que iniciamos n2=1. La condición n2<= 10 del while en línea 6, controla que mientras que n2 sea menor o igual que 10 se ejecuta el bloque de instrucciones que comprende las líneas 7 y 8. En línea 7 con print() se muestra en pantalla el resultado de multiplicar n1 por n2, con sep='' se especifica el separador entre nombres y cadenas, que en este caso es sin separador. En línea 8 usamos el operador += para incrementar el valor de n2 en una unidad. Cuando n2=11, la condición del while se evalúa False y finaliza el ciclo. Notar en línea 4 que dentro de la función print() tenemos '\n', esta combinación de caracteres se usa para hacer un cambio de línea.

Ejemplo 4

Imprimir los números pares en el rango [1,100]. La condición del while (línea 3), es decir 0 == 0 , se evalúa siempre True. En línea 5 incrementamos n1 en una unidad. En la línea 6 se tiene una sentencia if, que tiene por condición n1>n2, cuando resulta True (que será cuando 101>100) la sentencia break en línea 7 finaliza el ciclo while en línea 3, por lo que ya no se ejecutan el resto de las instrucciones del bloque (líneas 9 a 12). Con el if en línea 9 lo que se hace es que si la condición 𝑛1%2! = 0 resulta True, se tiene que n1 es impar ya que al dividirlo entre 2 el residuo es diferente de 0, y se ejecuta la línea 10, la sentencia continue es para pasar a la siguiente iteración del ciclo while sin ejecutar el resto de las instrucciones del bloque (línea 12). Cuando la condición en

Sentencia If La sentencia if se usa para ejecutar un bloque de código, una vez, si la condición resulta True. La estructura de la sentencia if es: if (condición): bloque de código elif (condición): bloque de código else: bloque de código Si la condición del if resulta False, se puede usar la sentencia elif (uno o varios, que llevan condición) para ejecutar un bloque de código, si la condición de este (o estos) resulta false se puede usar la sentencia else (que no lleva condición) para ejecutar un bloque de código. Si la condición del if da True, el bloque de instrucciones de la(s) sentencia(s) elif y del else no se ejecutan. Si la condición del if es false, al resultar True la condición de una sentencia elif, no se ejecuta el bloque de código de siguientes elif y else. Si la condición del if y de la(s) sentencia(s) elif resultan False, se ejecuta el bloque de la sentencia else. Podemos usar la sentencia if por si sola, if y elif (uno o varios), if y else, o if, elif (uno o varios) y else.

Ejemplo 6

Solicitar al usuario que escriba un número entero e imprimir en pantalla si es positivo, negativo, o neutro. En línea 1 se pide introducir un número entero que se captura por medio de la función input(), la cadena capturada la convertimos a entero con int() y se asigna a x. En línea 3 tenemos un if, si su condición se cumple, es decir que x sea menor que cero se ejecuta su bloque de instrucciones (la línea 4). En la línea 5 tenemos un elif que tiene como condición que x sea mayor que cero, de ser así se ejecuta la instrucción en línea 6. En la línea 7 tenemos else, que no tiene condición pero se llega a este cuando x es igual a cero (y si en x se introdujo un número entero), se puso para si la condición del if y la condición del elif dan False se ejecute la instrucción en línea 8.

Ejemplo 7

Guardar en una lista cinco calificaciones introducidas por el usuario, que estén en el rango [ 0 , 100 ]. Sacar el promedio de las calificaciones. En línea 1 tenemos tres instrucciones separadas por punto y coma, cada una para definir una variable: i=0, suma=0, lista1=[]. Con i llevaremos la cuenta de las calificaciones introducidas correctamente, además puede ser el índice de lista1. Con suma llevaremos la sumatoria de las calificaciones. Con lista 1 (que se definió como una lista vacía) guardaremos cada calificación. El ciclo while en línea 3 ejecuta su bloque de instrucciones (líneas de la 4 a la 1 1 ) cuando la condición i<5 resulte True. En línea 4 con input() se pide al usuario introducir una calificación (que puede tener punto decimal), la convertimos a número decimal con float() y es asignada en n. En línea 6 tenemos un if con condición: ((n<0) or (n>100)), esta condición da True si la calificación no está en el rango correcto, de ser así se ejecuta la instrucción en línea 7 , que es para imprimir en pantalla que la calificación no está entre 0 y

  1. Si la condición da False la calificación está en el rango correcto y se ejecuta el bloque de instrucciones (líneas 9 a 11) del else en línea 8. En línea 9 tenemos: lista1.append(n), que es para agregar n a lista1 con el método append(). En línea 10 tenemos el equivalente a suma=suma+lista1[i], por lo que sumamos la calificación en lista1[i] con suma y a su vez el resultado se asigna en suma, entonces con suma se lleva la sumatoria de calificaciones. En línea 11 se incrementa i en una unidad, por lo que en esta parte del código el valor de i es el número de calificaciones introducidas en el rango correcto. Cuando en línea 3 se tiene que i= 5 el ciclo while finaliza y se tendrán 5 calificaciones en lista1 , con posiciones en el rango de 0 a 4. Pasamos a la línea 13 para imprimir en pantalla el promedio, es decir la sumatoria de las calificaciones (valor actual de suma ) entre el número de calificaciones (valor actual de i ). Al correr el módulo, la salida depende de las calificaciones que introduzcan: Introduce una calificación: 100 Introduce una calificación: 90 Introduce una calificación: 80 Introduce una calificación: 70 Introduce una calificación: 60 El promedio es: 80.

En este código hay que tener cuidado con la indentación que le corresponde al unico while, y a cada if, elif, y else. El while (línea 1 ) comprende el bloque de instrucciones de la línea 2 a la 46. La condición del while es True, por lo que el while ejecutara su bloque de instrucciones repetidamente hasta que la sentencia break (línea 46 ) lo termine. En líneas 2, 3 , y 4 pedimos introducir modelo, transmisión, y color, respectivamente. Notar que se usó el método lower(), que es para convertir la cadena capturada a minúsculas. La condición del if en línea 6 es True si modelo tiene asignado la cadena 'mustang', la condición del elif en línea 23 es True si modelo tiene asignado 'camaro', y con el else en línea 39 se tendría que modelo es diferente que 'mustang' y que 'camaro'. Si modelo== 'mustang' es True, con el if en línea 8 evaluamos la condición transmision== 'automatico', con un elif (línea 15 ) la condición transmision== 'estandar', y con el else en línea 20 se tiene que transmision es diferente que 'automatico' y que 'estandar'. Si transmision== 'automatico' es True, tenemos un if, elif, y else (líneas 9 , 11 , y 13 , respectivamente) para evaluar la condición color== 'negro', color== 'blanco', y si ninguna de las dos anteriores fue True, respectivamente. Si transmision== 'estandar' es True, tenemos un if y un else (líneas 16 y 18 ) para evaluar la condición color== 'azul', o si la condición anterior es False, respectivamente. Si modelo== 'camaro' y transmision== 'automatico' resultan True, tenemos un if, dos elif, y un else para determinar el valor de color , si transmision== 'estandar' es True, se imprime en pantalla que no hay vehículo en existencia con tales características. Una vez que se llegó a un valor de modelo , transmision , y color que si se tiene en existencia, se imprime en pantalla el costo. Con la línea 42 se pide introducir al usuario una cadena ('si' o 'no') que será asignada en continuar. La condición del if en línea 43, es decir continuar== 'si', si es True se ejecuta la sentencia pass (línea 4 4), que es una sentencia nula (no tiene efecto y el programa continua), por lo que pasamos a la siguiente iteración del while. El else en línea 45 es para cuando la condición continuar== 'si' es False, de ser así se ejecuta la sentencia break (línea 46), la cual termina el while. Al correr el programa, dependiendo de lo que se le asigne a modelo , transmision , y color , se tendrá una salida: mustang o camaro: camaro automatico o estandar: automatico Escoja color: gris Un camaro automatico gris cuesta 160, Volver a intentar? si/no: si mustang o camaro: mustang automatico o estandar: estandar Escoja color: verde No tenemos mustang estandar verde Volver a intentar? si/no: no Sentencia For Con la sentencia for se puede acceder a cada objeto de un objeto iterable (lista, tupla, diccionario). La estructura es:

for ( objeto ) in ( iterable ): bloque de código Además, con la sentencia for se puede ejecutar un bloque de código un número de veces que va de un valor inicial (incluyéndolo) a un valor final (sin incluirlo) mediante un incremento, la numeración se lleva con índice. La estructura es: for ( índice ) in range ( valor inicial, valor final, incremento ): bloque de código En la primera iteración índice = valor inicial , en la siguiente iteración índice = índice + incremento , y así sucesivamente hasta que índice = valor final , en tal caso no se ejecuta el bloque de código. La estructura: for ( índice ) in range ( valor final ): bloque de código y por defecto valor inicial=0 e incremento= 1. La estructura: for ( índice ) in range ( valor inicial, valor final ): bloque de código y por defecto incremento=1. Ejemplos: for i in range(8): print(i) Imprime en pantalla del 0 al 7 en incrementos de 1. for i in range(1,5): print(i) Imprime en pantalla del 1 al 4 en incrementos de 1. for i in range(0,10,2): print(i) Imprime en pantalla del 0 al 8 en incrementos de 2. for i in range(0,-5,-1): print(i) Imprime en pantalla del 0 a - 4 en incrementos de - 1. Nota: los valores valor inicial, valor final , e incremento , deben ser números enteros, es decir clase 'int'.

lo que se agrega una 'B' a lista2. Y así sucesivamente con cada número en lista1. Luego se ejecuta la línea 2 0 para imprimir en pantalla lista. Procedimiento 2 va de la línea 2 3 a la 37. En línea 2 3 asignamos a lista_letras una lista con las letras a las que es posible convertir una calificación. En línea 2 4 cambiamos el contenido de lista2 por una lista vacía (ya que es donde agregaremos las calificaciones convertidas a letra) y definimos n2 =10, que usaremos para ir modificando el rango en el que puede estar una calificación. El primer for en línea 2 6 , y comprende el bloque de línea 27 a 35. Este for hace una iteración por cada calificación en lista1 , la cual es asignada a elemento. En línea 28 definimos n1=100 , ya que a partir de este número iremos definiendo el rango en el cual puede estar una calificación. El segundo for comprende el bloque de línea 3 0 a 35. En este for i va de valor inicial= 0 a valor final=len(lista_letras)= 5 , con incremento=1 , por lo que ejecutara su bloque de código tantas veces como el número de letras al que puede convertirse una calificación, de no ser terminado antes por el break en línea 3 3. En línea 31 tenemos un if con condición: ( elemento ==100 or ( elemento =n1-n2) or i == 4 ) Que en la primera iteración equivale a: ( elemento ==100 or ( elemento <100 and elemento >=90) or i == 4 ) Si la condición es False pasamos a línea 35 , que es para al valor actual de n1 restarle 10 y el resultado asignarlo en n1 , luego pasamos a la siguiente iteración por lo que ahora la condición del if cambia a: ( elemento ==100 or ( elemento <90 and elemento >=80) or i == 4 ) y así sucesivamente hasta que la condición se evalúe True. De ser así en línea 3 2 : lista2.append(lista_letras[i]), el valor de i es la posición en lista_letras de la letra que corresponde con la calificación en elemento. Entonces se escoge la letra de acuerdo con el valor de i , por ejemplo si elemento está en el rango [90,100] entonces en línea 31 elemento== 100 es True, o bien ( elemento <100 and elemento >=90) es True, se tendría que i=0 y en lista2 agregamos lista_letras [0] = 'A'. Si elemento esta en el rango [80,90) entonces (elemento< 90 and elemento>= 80 ) es True, se tendría que i =1 y en lista2 agregamos lista_letras [1] = 'B'. Para los rangos [70,80) y [60,70) se tendría que i =2 y que i =3, respectivamente, que de acuerdo con lista_letras [ i ] son los índices que corresponden a las letras 'C' y 'D', respectivamente. Cuando i== 4 se tiene que elemento no esta en el rango [60,100], por lo que lista_letras [4]= 'NA'. Para cualquiera de los casos anteriores después de agregar la letra correspondiente a lista2 en línea 32, en línea 33 la sentencia break es para terminar el bucle for en línea 29. Cuando el for en línea 2 6 ha hecho una iteración por cada calificación en lista1 , por lo que ya se tiene en lista2 la letra correspondiente a cada calificación, pasamos a la línea 37 para imprimir en pantalla lista.

Notar que en procedimiento 2 con el for en línea 29 y el if en línea 3 1 se logra lo mismo que en procedimiento 1 con el if , 3 elif, y else, en líneas 9 , 1 1 , 1 3 , 1 5 , y 1 7 , respectivamente. Al ejecutar el módulo la salida es: ['C', 'B', 'A', 'D', 'NA'] ['C', 'B', 'A', 'D', 'NA']

Ejemplo 10

Obtener los números primos en el rango [2,12). El for en línea 1 es para fijar el rango en el que buscaremos por números primos. El for en línea 2 es para que x vaya tomando un valor en el rango [2, n ). Ya que los números primos solo tienen división exacta entre sí mismos y la unidad, probaremos dividir n entre cada número en el rango [2, n ), que son los valores que puede tomar x. El if de la línea 3 tiene como condición n%x==0, si esta condición da True para un valor de entre los que puede tomar x , n no es primo. Esto se debe a que si al dividir n entre x el residuo es cero, la división es exacta (el cociente es un número entero que multiplicado por el divisor es igual al dividendo). Si se determinó que el valor actual de n no es primo, se termina el for en línea 2 con el break en línea 5. Cuando el for en línea 2 finaliza sin que se deba al break en línea 5, es decir no hubo un valor de x para que la condición en línea 3 de True, pasamos al else en línea 6 para ejecutar la línea 7, que es para imprimir en pantalla que n es primo. Al correr el módulo la salida es: 2 es número primo 3 es número primo 4 no es número primo 5 es número primo 6 no es número primo 7 es número primo 8 no es número primo 9 no es número primo 10 no es número primo 11 es número primo

En línea 1 definimos lista1 como una lista vacía. El for en línea 2 (que ejecuta la línea 3) es para ir agregando en lista1 el valor actual de n , que va cambiando de valor en el rango [1,10). Para llevar la sumatoria en línea 5 definimos sumatoria = 0. En cada iteración del for en línea 6 a e se le asigna el valor en turno de lista1 , en línea 7 este valor se suma con sumatoria y el resultado a su vez se asigna en sumatoria, por lo que la línea 7 equivale a sumatoria=sumatoria+e. Al finalizar el for en línea 6 pasamos a la línea 9 para imprimir en pantalla el promedio, que es sumatoria/len(lista1). La función len( lista1 ) regresa el número de objetos en lista1 , un nueve en este caso. Al correr el módulo la salida es: Promedio = 5. Notar que se puede hacer la siguiente simplificación: Y más aún: Ya que la función sum( lista1 ) devuelve la sumatoria de los valores en lista1, por lo que devuelve un 45.

Ejemplo 13

Definir una lista que contenga tres listas de acuerdo con la siguiente información: A = [ [1, 0, 1], [1, 1, 1],[0, 1, 0] ] Obtener una lista a partir de A, de modo que los 0 sean remplazados por 1, y los 1 por 0.

En línea 1 importamos el módulo copy. Con la función copy.deepcopy(A) creamos una copia (sin referencia) de A y la asignamos en B. Para acceder a los valores de cada lista en A lo hacemos con dos for (en líneas 7 y 9 , respectivamente). Con el for en línea 7 haremos una iteración por cada lista en A, el índice de las listas se lleva con i. Con el for en línea 9 haremos una iteración por cada valor de la lista en turno de A, el índice de los valores se lleva con j. De acuerdo con los for en líneas 7 y 9, los valores ( i,j ) serán: (0,0), (0,1), (0,2), (1,0), (1,1), (1,2), (2,0), (2,1), (2,2). Para cada par de valores, con el if en línea 10 si A[ i ][ j ] tiene asignado un uno, en B[ i ][ j ] se asigna un cero, y con el if en línea 12 si A[ i ][ j ] tiene asignado un cero, en B[ i ][ j ] se asigna un uno. La salida de correr el módulo es: A = [[1, 0, 1], [1, 1, 1], [0, 1, 0]] B = [[0, 1, 0], [0, 0, 0], [1, 0, 1]]

Ejemplo 14

Dada una lista con números ( lista1 ), determinar el número de veces que se repite cada número.

Para practicar

Ejemplo 15

Se tiene una lista de números que son las matrículas de las personas que asistieron a un seminario. El usuario del programa desea conocer si determinada matricula está en la lista de los asistentes. Desarrollar el código de manera que, si se introduce una matrícula no valida, la pida de nuevo. Una matrícula valida es un numero entero. Al conocer si una matrícula está o no en la lista, preguntar si se desea continuar o si se desea salir del programa. Tenemos la sentencia try (línea 7 ) y la sentencia except (línea 1 0 ). Si una instrucción en el bloque del try (líneas 8 y 9 ) da error, específicamente si en la línea 8 la instrucción int(n1) no es posible de realizar (es decir, no se puede convertir el valor en n1 a clase 'int'), el intérprete pasa directamente a ejecutar la instrucción en línea 11, que corresponde al bloque del except en línea 10. De no haber error en las instrucciones en el bloque del try, el intérprete no ejecuta las instrucciones en el bloque del except. Ejemplo de correr el programa: Introduzca una matrícula: 5 La persona con matrícula 5 si asistió

Desea continuar (si/no): si Introduzca una matrícula: 6 La persona con matrícula 6 no asistió Desea continuar (si/no): no

Ejemplo 16

Hacer un programa que, dada una lista con nombres de países, determine la cantidad de nombres en la lista y el número de letras de cada nombre. Instrucciones adicionales: no usar la función len(). Al correr el programa: Canadá = 6 letras Alemania = 8 letras México = 6 letras India = 5 letras Egipto = 6 letras Vietnam = 7 letras El número de nombres de países en lista1 es 6