Imprimir

Manual de Python: Estructuras de control

Estructuras de control

En Python los bloques de código se agrupan mediante el sangrado o indentado de las sentencias que los componen. Todas las líneas de un bloque deben estar sangradas al mismo nivel.

#!/usr/bin/python
# función que devuelve el factorial
def factorial(x):
    <span class="code">if x == 0:</span>
        return 1
    <span class="code">else:</span>
        return x * factorial(x-1)

Nota

  • En Python 0 es FALSE y cualquier otro valor entero es TRUE.
  • Cualquier secuencia o lista vacía es FALSE y cualquier cosa con longitud no cero es TRUE.
  • Los operadores de comparación son menor que ("<"), mayor que (">"), igual ("=="), menor o igual ("<="), mayor o igual (">="), diferente ("!="), está en ("in"), no está en ("not in"), es ("is") y no es ("is not").
  • Los operadores lógicos son y ("and"), o ("or") y no ("not").
  • if

    En la estructura if la parte else es opcional. La palabra clave elif es una abreviatura de else if. Una secuencia if ... elif ... elif equivale a las sentencias switch o case de otros lenguajes.

    #!/usr/bin/python
    x = int(raw_input("Introduce un numero: "))
    if x < 0:
        x = 0
        print "Negativo"
    elif x == 0:
        print "Cero"
    elif x == 1:
        print "Uno"
    else:
        print "Positivo"

    ... obtenemos:

    $ python test.py
    Introduce un numero: -6
    Negativo
  • for

    La estructura for de Python recorre los elementos de una secuencia, como una lista o una cadena, en el orden en que aparecen en la secuencia.

    #!/usr/bin/python
    a = ["hola", "mundo", "hola mundo"]
    for x in a:
        print x, len(x)

    ... obtenemos:

    $ python test.py
    hola 4
    mundo 5
    hola mundo 10

    Nota

    • Una coma al final de la sentencia print evita el retorno de carro.

    Para recorrer una secuencia de números utilizaremos la función range(a, b, c), que genera listas con progresiones aritméticas, siendo a el punto inicial, b el punto final (no incluido) y c el step (puede ser negativo):

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

    Para recorrer los índices de una secuencia combinaremos range() y len():

    #!/usr/bin/python
    a = ["Cinco", "lobitos", "tiene", "la", "loba"]
    for i in range(len(a)):
        print i, a[i]

    ... obtenemos:

    $ python test.py
    0 Cinco
    1 lobitos
    2 tiene
    3 la
    4 loba
  • while

    El bucle while se ejecuta mientras la condición sea cierta. Este código calcula e imprime la serie de Fibonacci hasta n:

    #!/usr/bin/python
    a = 0
    b = 1
    n = 200
    while b < n:
        print b,
        a = b
        b = a + b

    ... obtenemos:

    $ python test.py
    1 2 4 8 16 32 64 128
  • break

    La sentencia break sale del bucle for o while en curso.

  • continue

    La sentencia continue salta a la siguiente iteración del bucle for o while en curso.

  • else

    Los bucles for y while pueden tener una cláusula else que se ejecuta cuando se termina el bucle por agotamiento de la lista (con for) o cuando la condición se hace falsa (con while), pero no cuando se termina el bucle con break.

    Un ejemplo for ... else:

    #!/usr/bin/python
    for n in range(2, 10):
        for x in range(2, n):
            if n % x == 0:
                print n, "=", x, "*", n/x
                break
        else:
            print n, "es primo"

    ... obtenemos:

    $ python test.py
    2 es primo
    3 es primo
    4 = 2 * 2
    5 es primo
    6 = 2 * 3
    7 es primo
    8 = 2 * 4
    9 = 3 * 3

    Un ejemplo while ... else:

    #!/usr/bin/python
    i = 0
    while i < 10:
        print i
        i = i + 3
    else:
        print "i ya no es menor que 10"

    ... obtenemos:

    $ python test.py
    0
    3
    6
    9
    i ya no es menor que 10
  • try ... except

    Podemos capturar errores incluyendo el código que puede generar un error o provocar una excepción en un bloque try. Si se produce el error se ejecuta la sentencia except:

    #!/usr/bin/python
    import sys
    try:
        i=1/0
    except:
        print "Unexpected error:", sys.exc_info()[0]
        raise

    ... obtenemos:

    $ python test.py
    Unexpected error: <type 'exceptions.ZeroDivisionError'>
    Traceback (most recent call last):
      File "test.py", line 4, in <module>
        i=1/0
    ZeroDivisionError: integer division or modulo by zero

    Podemos incluir varias sentencias except para capturar distintos errores:

    #!/usr/bin/python
    import sys
     
    try:
        f = open('myfile.txt', 'r')
        s = f.readline()
        i = int(s.strip())
    except IOError as (errno, strerror):
        print "I/O error({0}): {1}".format(errno, strerror)
    except ValueError:
        print "No ha sido posible covertir los datos a entero."
    except:
        print "Unexpected error:", sys.exc_info()[0]
        raise

    La estructura try ... except admite una sentencia else que se ejecutará si try no hace saltar ninguna excepción:

    #!/usr/bin/python
    arg = 'myfile.txt'
    try:
        f = open(arg, 'r')
    except IOError:
        print 'cannot open', arg
    else:
        print arg, 'has', len(f.readlines()), 'lines'
        f.close()

    Nota

    • La sentencia raise hace saltar una excepción concreta.
    • La sentencia raise sin argumentos vuelve a generar la última excepción.

1 comentario en “Manual de Python: Estructuras de control”

  • Roberto dice:

    Quetal amigos es un gusto saludarlos.

    Están excelentes los ejemplos gracias por compartir.
    Que pasen un excelente día.

Deja un comentario