Inturiasgary’s Blog

mayo 12, 2010

Módulos en Python

Filed under: Python — inturiasgary @ 6:42 pm

Si sale del intérprete de Python y entra de nuevo, las definiciones que ha hecho (funciones y variables) se pierden. Por lo tanto, si desea escribir un programa algo más largo, es mejor usar un editor de texto para preparar la entrada para el intérprete y ejecutarlo con ese archivo como entrada en su lugar. Esto se conoce como la creación de un script. A medida que su programa se hace más largo, puede dividirlo en varios archivos para facilitar su mantenimiento. También puede utilizar una función que ha escrito en varios programas sin copiar su definición en cada programa.

Para apoyar esto, Python tiene una forma de poner definiciones en un archivo y utilizarlos en una secuencia de comandos o en una instancia interactiva del intérprete.  Este archivo se denomina un módulo, las definiciones de un módulo se pueden importar a otros módulos o dentro del módulo principal (la colección de variables que se tiene acceso a un programa ejecutado en el nivel superior y en el modo de calculadora).

Un módulo es un archivo que contiene definiciones y declaraciones de Python. El nombre del archivo es el nombre del módulo con el sufijo. py anexado. Dentro de un módulo, el nombre del módulo (como cadena) está disponible como el valor de la variable global __name__. Por ejemplo, utilice su editor de texto favorito para crear un archivo llamado fibo.py en el directorio actual con el siguiente contenido:

# Fibonacci numbers module

def fib(n):    # write Fibonacci series up to n
    a, b = 0, 1
    while b < n:
        print b,
        a, b = b, a+b

def fib2(n): # return Fibonacci series up to n
    result = []
    a, b = 0, 1
    while b < n:
        result.append(b)
        a, b = b, a+b
    return result


Ahora ingrese al interprete Python e  importe el módulo con el siguiente comando:

>>> import fibo

Ahora usando en nombre del módulo podemos acceder a sus funciones como por ejemplo:

>>> fibo.fib(1000)
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'

si se va a hacer uso de una función con frecuencia, se puede asignar a un nombre local:

>>> fib = fibo.fib
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377

Anuncios

Uso de la clausula else en declaraciones de bucle en Python

Filed under: Python — inturiasgary @ 5:18 pm

Las declaraciones de bucle podrían tener una clausula else; que se ejecuta cuando el bucle termina por agotamiento de la lista (con for) o cuando la condición se vuelve false (con while), pero no cuando el bucle es terminado por una declaración break. Ejemplificaremos en el siguiente bucle, que realiza la búsqueda de números primos:

>>> for n in range(2, 10):
… for x in range(2, n):
…     if n % x == 0:
…         print n, ‘equals’, x, ‘*’, n/x
…        break
…     else:
…         # loop fell through without finding a factor
…         print n, ‘is a prime number’

2 is a prime number
3 is a prime number
4 equals 2 * 2
5 is a prime number
6 equals 2 * 3
7 is a prime number
8 equals 2 * 4
9 equals 3 * 3

Strings Unicode en Python

Filed under: Python — inturiasgary @ 5:00 pm

En Python 2.0 y en sus versiones posteriores un nuevo tipo de dato para almacenar texto esta disponible al programador: el objeto Unicode. Este puede ser usado para almacenar y manipular datos Unicode (referencia http://www.unicode.org/) y se integra bien con los objetos de cadena existentes, siempre que las auto conversiones sean necesarias.
Unicode tiene la ventaja de proporcionarnos un ordinal para cada personaje en cada script utilizado en los textos antiguos y modernos. Anteriormente había solo 256 caracteres ordinales posibles para la secuencia de comandos. Los textos estaban vinculados normalmente a una página de código que asignaba los ordinales a los caracteres. Esto llevó a la confusión muy especialmente con respecto a la internacionalización (normalmente escrito como i18n — ‘i’ + 18 characters + ‘n’) de software. Unicode resuelve estos problemas mediante la definición de una página de códigos para todos los scripts.
La creación de caracteres Unicode en Python e tan simple como la creación normal:

>>> u’Hola Mundo !’
u’Hola Mundo !’

El pequeño ‘u’ en el principio del mensaje indica que una cadena Unicode es creada. Si quisiéramos incluir caracteres especiales en la cadena, podríamos realizarlo usando la codificación Python Unicode-Scape. El siguiente ejemplo nos muestra como:

>>> u’Hola\u0020Mundo !’
u’Hola Mundo !’

La salida de la secuencia \u0020 indica que se inserta un caractér Unicode con el valor ordinal 0x0020 (El caractér espacio) en la posición dada.
Otros caracteres son interpretados usando sus respectivos valores ordinales como ordinales Unicode. Si tienes cadenas literales en la codificación estandard Latin-1 que es usado mayormente en los paises del lado oeste, tu encontraras conveniente que los pocos 256 caracteres de Unicode son los mismos que los 256 caracteres del Latin-1.
Para los expertos, hay también el modo raw. para usarlos se debe colocar al principio ‘ur’ el cual dirá que está haciendo uso de la codificación Raw-Unicode-Escape.
ejemplo:

>>> ur’Hola\u0020Mundo!’
u’Hola Mundo !’
>>> ur’Hola\\u0020Mundo !’
u’Hola\\\\u0020Mundo !’

Aparte de estas codificaciones estandard, Python provee un conjunto de formas para la creacion de cadenas Unicode basándonos en codificaciones conocidas.
La función unicode() nos provee acceso a todos los codecs (COdificador y DECodificadores) Unicode. Algunos de esto como ser Latin-1, ASCII, UTF-8, y UTF-16.
Ejemplo:

>>> u”abc”
u’abc’
>>> str(u”abc”)
‘abc’
>>> u”äöü”
u’\xe4\xf6\xfc’
>>> str(u”äöü”)
Traceback (most recent call last):
File “”, line 1, in ?
UnicodeEncodeError: ‘ascii’ codec can’t encode characters in position 0-2: ordinal not in range(128)

Scripts de Python ejecutables

Filed under: Uncategorized — inturiasgary @ 3:43 pm

En sistemas operativos derivados del sistema Unix, los scripts hechos con Python pueden ser directamente ejecutados, de igual forma como los scripts de shell, poniendo la linea:
#!/usr/bin/env python

(asumiendo que el interprete esta en el PATH del usuario) al inicio del script y dado que el script esta en modo ejecutable.
El #! debe ser los primeros dos caracteres de el archivo. En algunas plataformas, estas primeras lineas deberían terminar con un ‘\n’, no confundir con el fin de linea de Windows (‘\r\n’). Note que el carácter ‘#‘ también es usado para iniciar un comentario en Python.
El script puede ser dado el modo ejecutable o permiso, usando el comando chmod:

$ chmod +x myscript.py

En sistemas Windows, no existe la opción modo ejecutable. El instalador de Python automáticamente asocia los archivos .py con python.exe de tal forma que al dar doble click sobre el archivo, Python ejecutará el script. La extensión también puede ser .pyw, en este caso cuando la consola de windows que normalmente aparece sera suprimida.

Intérprete de Python

Filed under: Uncategorized — inturiasgary @ 3:14 pm

El interprete de Python se suele instalar en /usr/local/bin/python en aquellas maquinas en la que se encuentran disponible; poniendo /usr/local/bin en la ruta de búsqueda de la Shell de Unix hace posible la ejecución del comando:

python

En maquinas Windows, la instalación de Python es usualmente colocado en c:\Python26 , es posible cambiar el lugar por defecto cuando se ejecuta la instalación. Para adicionar este directorio al Path(ruta), tienes que escribir el siguiente comando en dentro del interprete de comando DOS.

set path=%path%;C:\python26

para salir del interprete de comando Python, podemos escribir un carácter de fin de archivo (Control-D en Unix o Control-Z en Windows) esto causara un salida del interprete con un mensaje salida cero. Si eso no funciona, se puede salir del interprete tecleando el siguiente comando: quit()

La capacidad de edición de lineas de código mediante el interprete Python no es muy sofisticado. En Unix, hay una opción de poder usar la librería readline GNU, que añade la capacidad de una edición mas interactiva y con algunas otras funcionalidades mas.

El interprete Python interactua de la misma forma como el Unix Shell: cuando se convoca con una entrada estandard conectado a un dispositivo tty, lee y ejecuta los comandos de forma interactiva, cuando se convoca con un argumento de nombre de archivo o con un archivo como entrada estándar, lee y ejecuta un script de ese archivo.

Una segunda forma de iniciar el interprete de comandos Python seria python -c command [arg] … , el cual ejecuta las declaraciones en el comando, análogo a la opcion -c del shell. las opciones en el interprete siempre tienen que estar separadas por un espacio u otro caracter que son especiales para el shell, que generalmente estan declarados entre comillas.

Algunos módulos de Python son muy útiles como scripts. Estos pueden ser invocados usando python -m module [arg] … , el cual ejecuta el archivo de origen para el módulo como si hubiera escrito su nombre completo en la linea de comandos.

Existe diferencia entre python file y python , en este ultimo caso, las solicitudes de entrada del programa, como ser input() y raw_input(), se realizan desde el archivo. Dado que este archivo ya ha sido leído hasta el final por el analizador antes de que el programa inicie su ejecución, el programa se encontrará al final de su archivo de inmediato. En el primer caso (que es generalmente lo que usted quiere) que se cumple desde cualquier archivo o dispositivo que está conectado a la entrada estándar del intérprete de Python.

Cuando un archivo de script es usado, a veces es util ser capaz de ejecutar el script y despues entrar en modo interactivo. Esto se puede hacer pasando -i antes de la secuencia de comandos.

Modo interactivo

Cuando los comandos se leen desde un tty, el interprete se dice que esta en modo interactivo. En este modo el carácter de espera de ordenes(prompt) cambia a (>>>); para lineas continuas el prompt cambia  a (…). El interprete imprime un mensaje de bienvenida mostrando el numero de versión y las notas de copyright, antes de mostrarnos el primer prompt.

python
Python 2.6 (#1, Feb 28 2007, 00:02:06)
Type "help", "copyright", "credits" or "license" for more information.
>>>

La continuación de lineas, gracias al segundo prompt son necesarias para escribir código. un ejemplo:




>>> the_world_is_flat = 1
>>> if the_world_is_flat:
...     print "Be careful not to fall off!"
...
Be careful not to fall off!

mayo 11, 2010

Usando el módulo doctest

Filed under: Uncategorized — inturiasgary @ 1:15 pm

Python tiene un soporte considerable para pruebas, con los módulos doctest y unittest para pruebas de unidad y el módulo de pruebas para pruebas de regresión.

Cuando creamos un módulo, estos están diseñados para ser importados y los objetos ser proveidos. Cuando el módulo es importado las pruebas de unidad simplemente son ignorados; pero cuando el modulo esta siendo ejecutado las pruebas de unidad son ejecutados. Estas acciones son llevadas a cabo gracias al modulo doctest.

El modulo doctest nos permite realizar pruebas unidad de la manera mas simple y facil como sea posible.

Para realizar las pruebas todo lo que necesitamos es adicionar ejemplos a nuestro docstring, escribiendo lo mismo que en el interprete de Python y el resultado que quisieramos obtener de retorno. Como por ejemplo:

def unique_words(page):
  ''' Returns set of the unique words in list of lines of text

    Example:

    >>> from StringIO import StringIO
    >>> fileText = """the cat sat on the mat
    ... the mat was ondur the cat
    ... one fish two fish red fish
    ... blue fish
    ... This fish has a yellow car
    ... This fish has a yellow star"""
    >>> file = StringIO(fileText)
    >>> page = file.readlines()
    >>> words = unique_words(page)
    >>> print sorted(list(words))
    ["This", "a", "blue", "car", "cat", "fish", "has", "mat",
     "on", "ondur", "one", "red", "sat", "star", "the", "two",
     "was", "yellow"]
    >>>
  '''

  return set(word  for line in page  for word in line.split())

def _test():
    import doctest
    doctest.testmod()

if __name__ == "__main__":
    _test()

El docstring contiene una pequeña descripcion de lo que se intenta probar, seguido del codigo que hubieramos
tipeado para realizar la prueba en el interprete de Python.
El modulo doctest usa esta sintaxis ya que nos es mas familiar.

Para realizar la respectiva prueba basta con escribir:

python NombreDelPrograma.py -v

Crea un blog o un sitio web gratuitos con WordPress.com.