Introducción a Python

From Apache OpenOffice Wiki
< ES‎ | Manuales‎ | GuiaAOO‎ | TemasAvanzados‎ | Macros‎ | Python
Jump to: navigation, search


Agradecimientos

Documentation note.png Nota: Estas notas están basadas en el excelente libro de Raúl González Duque Python para todos


En la red hay muchos y muy buenos manuales de Python, en la introducción ya recomendamos algunos y estas notas le deben mucho a ellos. En esta sección solo veremos los elementos mínimos de Python para poder continuar con nuestro aprendizaje de macros en AOO. Empecemos.

Python tiene una sintaxis muy sencilla pero el interprete, es decir, el programa que se encarga de validar y ejecutar nuestro código es muy estricto, recuerda bien esto, es muy estricto. Los espacios, los tabuladores y hasta los nombres que asignamos, pueden tener repercusión en la ejecución de nuestro código, también pueden ser fuente de múltiples frustraciones que deseamos se reduzcan con estas notas.

Documentation note.png Sintaxis: conjunto de reglas


Reiteramos, Python es muy estricto en su sintaxis, por ello y por otras buenas razones, Python cuenta con una guía de estilo de programación, que, en mayor medida, intentamos seguir la mayoría de los pythonistas, esta guía se le llama PEP8 y fue escrita, entre otros, por el mismo autor de Python, Guido van Rossum, tenemos una excelente traducción de nuestro amigo; Raúl González Duque, el autor del libro ya mencionado Python para todos, que puedes ver aquí: http://mundogeek.net/traducciones/guia-estilo-python.htm

Declarando y llamando macros

La estructura básica para una macro es.

def nombre_de_la_macro():
    # Instrucciones de nuestra macro
    return


En el tema anterior ya vimos como llamar a otras macros, repasemoslo aquí.

def inicio():
    solicitar_datos()
    procesar_datos()
    mostrar_info()
    print ('Fin')
    return
 
def solicitar_datos():
    return
 
def procesar_datos():
    return
 
def mostrar_info():
    return


Es muy importante que respetes la indentación de las líneas, más adelante veremos que importantes son. ¿Recuerdas que comentamos que Python es muy estricto?, comprobemoslo.

import uno
 
def pruebas():
    macro03
    return
 
def macro03():
    return


¿Ya lo notaste? nos falto poner los paréntesis al llamar la macro. Veamos otra.

import uno
 
def pruebas():
    macro03()
    return
 
def macro03()
    return


Ahora si, AOO nos muestra un mensaje de error. Observa como nos indica el archivo y la línea donde esta el error. En este caso, nos faltaron los dos puntos al final de la declaración de la macro. Lo repetiremos muchas veces: Python es muy estricto

Py img 0005.png


Variables - Tipos básicos

No es necesario declarar el tipo de dato que contendrá una variable en Python, a esta característica se le llama: tipado dinámico. Ejemplos:

import uno
 
def pruebas():
    variables()
    return
 
def variables():
    texto = 'Soy un texto'
    numero_entero = 10
    numero_flotante = 3.1416
    booleanos = True  # o False
    return


Documentation note.png Nota: de aquí en adelante, solo mostraremos los nuevos ejemplos, en el entendido de que tienen que ser ejecutados desde nuestra macro inicial pruebas


Para saber el tipo de valor que contiene una variable, usamos la función type.

def variables():
    texto = 'Soy un texto'
    numero_entero = 10
    numero_flotante = 3.1416
    booleanos = True  # o False
 
    print (type(texto))
    print (type(numero_entero))
    print (type(numero_flotante))
    print (type(booleanos))
    return


Cuidado, el que no necesites declarar el tipo de variable, no significa que puedas usarlas cuando quieras, recuerda, solo puedes usar variables asignadas previamente, la siguiente macro te tiene que dar un error.

def variables():
    t = 'Hola mundo'
    print (t)
    print (s)
    return


Variables - Colecciones

Estos tipos de variables permiten almacenar más de un valor.

Listas

La lista es un tipo de colección ordenada. Sería equivalente a lo que en otros lenguajes se conoce por arrays, o vectores. Las listas pueden contener cualquier tipo de dato: números, cadenas, booleanos, ... y también listas, para crear una lista, se usan los corchetes y sus elementos separados por comas.

def variables():
    # lista de número enteros
    mi_lista1 = [1, 2, 3, 4]
    # lista de cadenas
    mi_lista2 = ['Noemi', 'Paola', 'Claudia']
    # lista mixta
    mi_lista3 = [10, 'Alejandra', 3.14, True, [9, 8, 7]]
    return


Observa que en la ultima lista, su ultimo elemento es otra lista. Más abajo mira algunas de las operaciones que podemos hacer con las listas. Para hacer referencia a un elementos de la lista, usamos su indice o posición, este, siempre empieza en cero.

    print (mi_lista3[1])


Puedes modificar cualquier elemento de la lista.

    mi_lista3[2] = 3.1416
    print (mi_lista3)


Puedes realizar las siguiente operaciones con las listas.

    # agregar un elemento al final
    mi_lista.append(10)
    print (mi_lista)
 
    # extender la lista con otra secuencia
    mi_lista.extend([100,200,300])
    print (mi_lista)
 
    # borra un elemento
    mi_lista.remove(200)
    print (mi_lista)
 
    # insertar un elemento en la posición determinada
    mi_lista.insert(4, 500)
    print (mi_lista)


Tuplas

Son muy parecidas a las listas, se diferencian en su forma de crearse y en que son inmutables, es decir, no puede modificar sus elementos como en las listas. Para crear una tupla, usamos los paréntesis, si creas una tupla de un solo elemento, es importante uses la coma para crearla.

    mi_tupla1 = ('Un solo elemento',)
    mi_tupla2 = (12, 13, 14)
    mi_tupla3 = (10, 'Estela', False, (1,3,5))


Observa que de nuevo en la ultima tupla, en su ultimo elemento, tenemos una tupla.


Diccionarios

Los diccionarios, también llamados matrices asociativas, son colecciones que relacionan una clave y un valor, para crearlos se usan las llaves de la siguiente manera.

    peliculas = {'Vivir': 'Akira Kurosawa',
                'El Gran Pez': 'Tim Burton',
                'Amores Perros': 'Alejandro González Iñárritu'}


El primer valor se trata de la clave y el segundo del valor asociado a la clave. Como clave podemos utilizar cualquier valor inmutable: podríamos usar números, cadenas, booleanos, tuplas, ... pero no listas o diccionarios, dado que son mutables. La diferencia principal entre los diccionarios y las listas o las tuplas es que a los valores almacenados en un diccionario se les accede no por su índice, porque de hecho no tienen orden, sino por su clave.

    print (peliculas['Vivir'])


Puedes usar esta misma clave para cambiar su valor.

    peliculas['Vivir'] = 'Zhang Yimou'


Variables - Secuencias

Las listas, las tuplas y las cadenas de texto, son secuencias por que se puede acceder a sus elementos a través de un índice, no son los únicos en Python. Entre sus características están.

  • No es necesario conocer cuantos elementos contendrá la secuencia.
  • Pueden guardar cualquier tipo de objeto.
  • No hay limite para la cantidad de elementos que guardará.


Para acceder a cualquier elemento de la secuencia, usamos un índice.

def secuencias():
    mi_lista = [5, 9, 12, 1, 56]
    mi_tupla = (23, 89, 12, 56, 23)
    mi_cadena = 'Python es facil y divertido'
 
    print (mi_lista[0])
    print (mi_tupla[1])
    print (mi_cadena[2])
    return


Si intentas usar un índice inexistente, el interprete te mostrará un error. También puedes usar índices negativos, con lo cual la cuenta empezará desde el ultimo elemento.

def secuencias():
    print (mi_lista[-1])
    print (mi_tupla[-2])
    print (mi_cadena[-3])


Puedes usar funciones comunes a las secuencias, como contar su número de elementos, obtener el máximo o el mínimo.

    print (len(mi_lista))
    print (len(mi_tupla))
    print (len(mi_cadena))
 
    print (max(mi_lista))
    print (max(mi_tupla))
    print (max(mi_cadena))
 
    print (min(mi_lista))
    print (min(mi_tupla))
    print (min(mi_cadena))


Puedes conocer el índice del primer elemento encontrado.

    print (mi_lista.index(12))
    print (mi_tupla.index(56))
    print (mi_cadena.index('d'))


Puedes conocer el número de veces que aparece un elemento.

    print (mi_lista.count(9))
    print (mi_tupla.count(89))
    print (mi_cadena.count('o'))


Puedes ordenar los elementos, para ello, usamos la función sorted.

    print (sorted(mi_lista))
    print (sorted(mi_tupla))
    print (sorted(mi_cadena))


Puedes devolver solo una parte de la secuencia, a esta operación se le llama slices y se usan índices enteros (pueden ser positivos o negativos) de la forma [x:y:z], donde:

  • x = elemento inicial.
  • y = elemento final, cuidado, la posición y no es devuelta, por lo que el fin real es y-1.
  • z = salto entre elementos, de forma predeterminada z = 1.
    print (mi_cadena[7:15:1])
    print (mi_cadena[0:20:2])
    print (mi_cadena[-1:-10:-1])


Se pueden omitir los argumentos.

    # devolvemos los primeros diez
    print (mi_cadena[:10])
    # devolvemos los últimos diez
    print (mi_cadena[-10:])
    # mira que divertido
    print (mi_cadena[::-1])


Podemos saber si un elemento pertenece a una secuencia con el operador in.

    print (12 in mi_lista)
    print (100 in mi_tupla)
    print ('es' in mi_cadena)


Puedes sumar dos secuencias, con la única condición de que sean del mismo tipo, en el siguiente ejemplo, la ultima línea te dará un error.

    print (mi_lista + ['a', 'b', 'c'])
    print (mi_tupla + ('x', 'y', False))
    print (mi_cadena + (5, 10, 20))


Puedes multiplicar una secuencia por un entero, recuerda que la multiplicación es una suma abreviada.

    print (['a', 'b', 'c'] * 3)
    print (('x', 'y') * 4)
    print ('adios' * 5)


Conversión del tipo de la variable

No se permite tratar a una variable como si fuera de un tipo distinto al que tiene, es necesario convertir de forma explícita dicha variable al nuevo tipo previamente, a esta característica se le llama fuertemente tipado. Para convertir variables de un tipo a otro usamos las siguientes funciones.

    # convertimos un entero en cadena
    mi_entero = 100
    print (type(mi_entero))
    mi_entero = str(mi_entero)
    print (type(mi_entero))
 
    # convertimos un flotante en cadena
    mi_numero = 3.14
    print (type(mi_numero))
    mi_numero = str(mi_numero)
    print (type(mi_numero))
 
    # convertimos una cadena, en entero y luego el entero en flotante
    mi_cadena = '1000'
    print (type(mi_cadena))
    mi_cadena = int(mi_cadena)
    print (type(mi_cadena))
    mi_cadena = float(mi_cadena)
    print (type(mi_cadena))
 
    # convertimos una cadena (secuencia) en una lista, luego la lista en tupla
    # y al final de nuevo en cadena, CUIDADO con la ultima conversión.
    mi_cadena = 'Hola Mundo'
    print (type(mi_cadena))
    mi_cadena = list(mi_cadena)
    print (type(mi_cadena))
    mi_cadena = tuple(mi_cadena)
    print (type(mi_cadena))
    mi_cadena = str(mi_cadena)
    print (type(mi_cadena))


Operadores

Los operadores aritméticos son los siguientes:

 
    # suma
    t = 10 + 20
 
    # resta
    r = 100 - 45
 
    # multiplicación
    m = 34 * 45
 
    # exponenciación
    e = 2 ** 6
 
    # división
    d = 50.5 / 2.0
 
    # división entera
    de = 3.5 / 2
 
    # modulo, resto de una división
    mo = 7 % 2
 
    print (t, r, m, e, d, de, mo)


Los operadores de relación y booleanos son los siguientes.

    # igualdad
    r = 10 == 10
    print (r)
    r = 10 == 20
    print (r)
 
    # diferencia
    r = 'A' != 'A'
    print (r)
    r = 'A' != 'B'
    print (r)
 
    # menor que
    r = 10 < 20
    print (r)
    r = 10 < 5
    print (r)
 
    # mayor que
    r = 20 > 5
    print (r)
    r = 10 > 100
    print (r)
 
    print '\n'
    # and
    r = True and True
    print (r)
    r = True and False
    print (r)
    r = False and True
    print (r)
    r = False and False
    print (r)
 
    # or
    r = True or True
    print (r)
    r = True or False
    print (r)
    r = False or True
    print (r)
    r = False or False
    print (r)
 
    # negación
    r = not False
    print (r)
    r = not True
    print (r)

Condicionales

Estas estructuras nos permiten evaluar una instrucción y tomar un camino, dependiendo si esa es Falsa(False) o Verdadera (True), por ejemplo.

    edad = 15
    if edad < 18:
        print ('Eres menor de edad')
Documentation note.png Importante: Observa los dos puntos al final de la evaluación de la condición y la sangría al inicio de la siguiente línea, la sangría le dice al interprete, que esta línea esta dentro de la estructura if

Si solo tienes dos alternativas, puedes complementar la estructura con la instrucción else'.

    edad = 25
    if edad < 18:
        print ('Eres menor de edad')
    else:
        print ('Eres mayor de edad')


Si tienes varias alternativas, entonces complementa con la instrucción elif.

    # observa la asignacion que usa un solo signo igual
    calificacion = 7
    if calificacion < 6:
        print ('Reprobado')
    # observa la comparación que usa dos signos igual
    elif calificacion == 6:
        print ('De panzaso pasaste')
    elif calificacion > 6 and calificacion <= 7:
        print ('Hay que esforzarse más')
    elif calificacion > 7 and calificacion <= 9:
        print ('Bien Hecho')
    else:
        print ('Excelente')


Nota que independiente de la cantidad de comparaciones, cada línea termina en dos puntos y las líneas dentro de dicha condición tienen una sangría para indicarle que son parte de dicha condición. Toman en cuenta que como condición; se puede usar cualquier expresión susceptible de ser evaluada como verdadera(True) o falsa(False). Cualquier variable vacía o cero, serán evaluados como falsas, cualquier otra como verdaderas.

    # números
    numero = 10
    if numero:
        print (numero)
    numero = 0
    if not numero:
        print ('Cero')
 
    # cadenas
    cadena = 'PyUNO'
    if cadena:
        print (cadena)
    cadena = ''
    if not cadena:
        print ('Cadena vacia')
 
    # listas
    lista = []
    if not lista:
        print ('Lista vacia')
    lista = [1, 2, 3]
    if lista:
        print (lista)
 
    # tuplas
    tupla = ()
    if not tupla:
        print ('Tupla vacia')
    tupla = (1, 2, 3)
    if tupla:
        print (tupla)
 
    # diccionario
    dic = {}
    if not dic:
        print ('Diccionario vacio')
    dic = {'Nombre': 'Noemi Hernandez'}
    if dic:
        print (dic)
 
    # valor Nulo
    otro = None
    if not otro:
        print ('Sin valor')
    otro = 100
    if otro:
        print (otro)


Por ultimo, en Python no hay una estructura Select...Case de otros lenguajes, sencillamente porque no es necesaria.

Bucles

Para ejecutar una fragmento de código varias veces, usamos los bucles. La estructura for...in y la estructura while. Lo decimos una vez más; Python es muy estricto, y en el caso de los bucles lo podrás notar, pues el bloque de estas estructuras quedan delimitados por la indentación del código, no se usan paréntesis o llaves como en otros lenguajes, simplemente la sangría de las líneas es lo que determina la pertenencia y la validez de una estructura.


Estructura for..in

Esta estructura nos permite iterar en una secuencia, por ejemplo.

    for i in [1,2,3,4,5]:
        print (i)
Documentation note.png Importante: Observa los dos puntos al final de la primer línea y la sangría al inicio de la segunda, la sangría le dice al interprete, que esta línea esta dentro de la estructura for...in

Puedes apoyarte en la función range si quieres iterar un número determinado de veces.

    for i in range(5):
        print (i)


Observa que, los dos ejemplos previos, iteran el mismo número de veces (cinco), pero no en el mismo rango, esto es por que mientras no le indiques lo contrario, la función rango empieza en 0. Puedes generar un rango determinado, pasandole los argumentos correctos.

    for i in range(10, 21):
        print (i)


Como ya habrás notado, la función range recibo los mismos argumentos usados en las secuencias.

    for i in range(100, 1001, 100):
        print (i)


Incluyendo los enteros negativos.

    for i in range(0, -500, -50):
        print (i)


Como ya mencionamos, esta estructura puede iterar en los elementos de una secuencia.

    mi_lista = [5, 9, 12, 1, 56]
    mi_tupla = (23, 89, 12, 56, 23)
    mi_cadena = 'pyUNO'
 
    for i in mi_lista:
        print (i)
    print ('\n')
 
    for i in mi_tupla:
        print (i)
    print ('\n')
 
    for i in mi_cadena:
        print (i)
    print ('\n')
Documentation note.png Observa: la forma de mostrar un salto de línea en pantalla, usando la secuencia de escape '\n'

Puedes iterar en una secuencia y numerar sus elementos, usando la función enumerate.

    mi_tupla = ('Noemi', 'Claudia', 'Paola', 'Estela')
    for i,v in enumerate(mi_tupla):
        print (i, v)


De un modo similar puedes iterar un diccionario y devolver su clave y el valor de dicha clave.

    dic = {1: 'Uno', 2: 'Dos', 3: 'Tres', 4: 'Cuatro', 5: 'Cinco'}
    for k,v in dic.items():
        print (k,v)


Por ultimo, puedes tener estructuras anidadas.

    datos = (
        ('A1', 'B1', 'C2', 'D1', 'E1'),
        ('A2', 'B2', 'C2', 'D2', 'E2'),
        ('A3', 'B3', 'C3', 'D3', 'E3'),
        ('A4', 'B4', 'C4', 'D4', 'E4'),
        ('A5', 'B5', 'C5', 'D5', 'E5'),
    )
    for r in datos:
        print (r)
        for c in r:
            print (c)
Documentation note.png Importante: si, ya lo mencionamos, pero toma nota de la correcta sangría en cada línea

Otras instrucciones que complementan a esta estructura son: break que nos permite salir de un ciclo de forma anticipada y continue que nos permite saltar directamente al siguiente ciclo, por ejemplo.

    # observa como no imprime las dos ultimas cifras
    datos = (13, 67, 45, 0, 34, 56)
    for v in datos:
        if v == 0:
            break
        else:
            print (v)
    print ('\n')
    # observa como no imprime el cero, pero si las dos ultimas cifras
    datos = (13, 67, 45, 0, 34, 56)
    for v in datos:
        if v == 0:
            continue
        else:
            print (v)


Estructura while

Esta estructura nos permite ejecutar fragmentos de código mientras se cumpla o hasta que se cumpla una condición dada, por ejemplo.

    # valor inicial
    edad = 5
    # condición para continuar
    while edad < 18:
        # aumentamos la edad en uno
        edad += 1
        # mostramos la edad
        print ('Tienes ' + str(edad) + ' años')


Más adelante veremos formas más elegantes de formatear cadenas de texto. Hay que tener algo de precaución cuando se defina la condición de una estructura while, cuando se es novel es común caer en condiciones que nunca se cumplen y por lo tanto quedar atrapados en bucles infinitos.

Al igual que en la estructura for...in, en la estructura while podemos usar las instrucciones break y continue.


Funciones incorporadas

La mayor parte de las herramientas de Python, están desarrolladas en módulos independientes que hay que importar de forma explicita cada vez que se requieran, este tema lo veremos más adelante. En esta sección veremos algunas de las funciones incorporadas, algunas de las cuales ya vimos en temas anteriores, por ejemplo.

Para ver el tipo de una variable usamos type.

    n = 1001
    print (type(n))
    n = 'AOO'
    print (type(n))


Para devolver el valor absoluto de un número usamos abs.

    n = -1001
    print (abs(n))
    n = -3.1416
    print (abs(n))


Para convertir una variable en tipo booleana usamos bool.

    v = ''
    b = bool(v)
    print (b)
 
    v = 'AOO'
    b = bool(v)
    print (b)


Para devolver el valor ASCII del entero pasado usamos chr.

    v = chr(97)
    print (v)


Para convertir una cadena o entero en flotante, usamos float.

    texto = '100'
    n = float(texto)
    print n
    texto = '-10.5'
    n = float(texto)
    print n


Para convertir una cadena en entero, usamos int.

    numero = '100'
    i = int(numero)
    print (i)


Para saber si una variable es de un tipo(clase) determinado, usamos isinstance.

    numero = '100'
    if isinstance(numero, str):
        print ('Es una cadena')
 
    numero = 100
    if isinstance(numero, int):
        print ('Es un entero')


Para devolver la longitud de una secuencia o diccionario usamos len.

    lista = [1, 2, 3]
    print (len(lista))
 
    tupla = ('a', 'b', 'c', 'd', 'e')
    print (len(tupla))
 
    cadena = 'Apache OpenOffice'
    print (len(cadena))
 
    dic = {'Uno': 'Dos', 'Tres': 'Cuatro'}
    print (len(dic))


Para convertir una secuencia en lista usamos list.

    tupla = ('a', 'b', 'c', 'd', 'e')
    lista = list(tupla)
    print (type(lista), lista)


Para convertir una cadena o número en entero largo usamos long.

    cadena = '100000'
    n = long(cadena)
    print (type(n), n)


Para devolver el máximo de una secuencia usamos max.

    tupla = (10, 100, 0, 500, 999)
    print (max(tupla))


Para devolver el mínimo de una secuencia usamos min.

    tupla = (10, 100, 0, 500, 999)
    print (min(tupla))


Para abrir un archivo y escribir en el usamos usamos open. Más adelante veremos el trabajo con archivos a detalle.

    f = open('detalle.txt', 'w')
    f.write('Aprendiendo python')
    f.close()


Para elevar un número a una potencia usamos pow. El siguiente número te tiene que resultar familiar.

    print (pow(2,10))
    print (2 ** 10)


Para devolver una lista con una progresión aritmética usamos range.

    print (range(11))
    print (range(1000, 10000, 500))
    print (range(-100, -500, -50))


Para devolver una secuencia en reversa reversed. Toma en cuenta que tienes que convertir de nuevo al tipo de secuencia original.

    tupla = (10, 100, 0, 500, 999)
    print (tuple(reversed(tupla)))
 
    lista = ['a', 'd', 'p', 'g', 'z']
    print (list(reversed(lista)))


Para redondear un número flotante usamos round.

    numero = 3.1499
    print (round(numero, 2))
    # si omites el segundo argumento
    print (round(numero))


Para ordenar secuencias usamos sorted. Más adelante veremos otras técnicas de ordenamiento para secuencias y diccionarios.

    tupla = (10, 100, 0, 500, 999)
    print (sorted(tupla))
 
    lista = ['a', 'd', 'p', 'g', 'z']
    print (sorted(lista))


Para devolver la representación impresa de un objeto usamos str.

    lista = [1, 2, 3]
    print (str(lista))
 
    tupla = ('a', 'b', 'c', 'd', 'e')
    print (str(tupla))
 
    dic = {'Uno': 'Dos', 'Tres': 'Cuatro'}
    print (str(dic))


Para devolver la suma de una secuencia usamos sum, esta, solo debe contener números.

    lista = [1, 2, 3]
    print (sum(lista))
 
    tupla = [1, 2, 3, 4, 5]
    print (sum(tupla))


Para convertir una secuencia en tupla usamos tuple.

    lista = [1, 2, 3]
    print (tuple(lista))
 
    cadena = 'Apache'
    print (tuple(cadena))

Ámbito de variables

El ámbito de las variables se refiere al espacio donde son validas, al lugar desde donde se puede verlas y hacer referencia a ellas y donde no, veamos el siguiente ejemplo.

# -*- coding: utf-8 -*-
import uno
 
def pruebas():
    macro_uno()
    macro_dos()
    return
 
def macro_uno():
    var = 'Hola'
    print (var)
    return
 
def macro_dos():
    var = 'Mundo'
    print (var)
    return


Nota, al ejecutar, que las variables, aun teniendo el mismo nombre, se muestran correctamente, a este ámbito se le llama local. Para usar la misma variable en diferentes macros, asignala a nivel de modulo.

var2 = 'pyUNO'
 
def pruebas():
    print (var2)
    macro_uno()
    macro_dos()
    return
 
def macro_uno():
    var = 'Hola'
    print (var)
    print (var2)
    return
 
def macro_dos():
    var = 'Mundo'
    print (var)
    print (var2)
    return


Más adelante veremos más opciones y alternativas para ver nuestras variables.


Excepciones

Los errores, presentes en toda actividad, son susceptibles de capturarse, Python nos provee de la estructura try...except para esto.

def errores():
    # intentamos mostrar una variable no declarada
    print texto
    return


Ahora, controlemos este error.

def errores():
    try:
        print texto
    except:
        print ('Variable no declarada')
    return


Ahora, un error diferente.

def errores():
    try:
        r = 10 / 0
    except:
        print ('División entre cero')
    return


Ahora, los dos errores en la misma macro.

def errores():
    try:
        r = 10 / 0
        print texto
    except:
        print ('No se que fallo')
    return


Para determinar el tipo de error, puedes complementar con el tipo de error de la siguiente manera.

def errores():
    try:
        r = 10 / 0
        print texto
    except (NameError, ZeroDivisionError):
        print ('Variable no declarada o división entre cero')
    return


Aunque lo mejor es tratar cada error de forma separada.

def errores():
    try:
        r = 10 / 0
        print texto
    except NameError:
        print ('Variable no declarada')
    except ZeroDivisionError:
        print ('División entre cero')
    return


Nota, que en el ejemplo anterior, siempre te mostrará el primer error capturado, por ello, es una mala practica intentar meter todo tu código entre líneas try...except, resistete a esto y trata de usar la captura de errores cuando realmente se requiera, esto, solo lo sabrás con la experiencia y consultando código de otros, algo, que podemos hacer con el software libre.

La captura de errores también tiene una clausula else que se ejecuta solo cuando no ocurrió ningún error.

def errores():
    try:
        texto = 'Correct'
        r = 10 / 5
        print texto
    except ZeroDivisionError:
        print ('División entre cero')
    else:
        print ('Todo correcto')
    return


Y por ultimo, la clausula finally que se ejecuta siempre, haya ocurrido o no un error.

def errores():
    try:
        texto = 'Correct'
        r = 10 / 0
        print texto
    except ZeroDivisionError:
        print ('División entre cero')
    else:
        print ('Todo correcto')
    finally:
        print ('Siempe se ejecuta')
    return


Python permite incluso declarar tus errores personalizados, tema que se verá más adelante.


ES.Plantillas.Logo foro es.png
Si tienes dudas acerca de lo aquí explicado, tienes algún problema con AOO,
o quieres ampliar la información, no dudes en dirigirte al

Foro Oficial en español de Apache OpenOffice para Macros y API UNO

Personal tools