VirtualEnv para Django

Image
¿Que hace VirtualEnv?
virtualenv es una herramienta para crear entornos python insolados.Ventajas:

  • Seguimiento de paquetes instalados
  • Mantiene el entorno del sistema limpio
  • Duplica fácilmente el entorno de producción o desarrollo.

Instalación (asumiendo que tienen una distribución basada en debian):

Código:

$ sudo apt-get install python-virtualenv

O si estas usando un sistema basado en fedora:

Código:

# yum install python-virtualenv

Creación de un entorno virtual:

Código:

$ virtualenv venv

Activar entorno virtual:

Código:

$ source venv/bin/activate

Instalando paquetes:

Código:

(venv)$ pip install django

Instalando paquetes con una versión especifica:

Código:

(venv)$ pip install django==1.3

Desinstalando paquetes:

Código:

(venv)$ pip uninstall django

Actualizando paquetes:

Código:

(venv)$ pip install --upgrade django

Respaldando paquetes instalados

Código:

(venv)$ pip freeze > requirements.txt

Instalando paquetes desde un archivo requirements.txt

Código:

(venv)$ pip install -r requirements.txt

Aquí solo he mostrado los comandos mas básicos de pip para uso mas avanzado pueden checar la documentación.

Una vez que hayan terminado de usar el entorno virtual y deseen desactivar el entorno solo tienen que hacer lo siguiente:

Código:

(venv)$ deactivate

Fuente: http://www.forosdelweb.com

Expresiones regulares Python y Django

Las expresiones regulares, también llamadas regex o regexp, consisten en patrones que describen conjuntos de cadenas de caracteres.

Algo parecido sería escribir en la línea de comandos de Windows

dir *.exe

‘*.exe’ sería una “expresión regular” que describiría todas las cadenas de caracteres que empiezan con cualquier cosa seguida de ‘.exe’, es decir, todos los archivos exe.

El trabajo con expresiones regulares en Python se realiza mediante el módulo re, que data de Python 1.5 y que proporciona una sintaxis para la creación de patrones similar a la de Perl. En Python 1.6 el módulo se reescribió para dotarlo de soporte de cadenas unicode y mejorar su rendimiento.

 

El módulo re contiene funciones para buscar patrones dentro de una cadena (search), comprobar si una cadena se ajusta a un determinado criterio descrito mediante un patrón (match), dividir la cadena usando las ocurrencias del patrón como puntos de ruptura (split) o para sustituir todas las ocurrencias del patrón por otra cadena (sub). Veremos estas funciones y alguna más en la próxima sección, pero por ahora, aprendamos algo más sobre la sintaxis de las expresiones regulares.

Expresiones regulares: Patrones

La expresión regular más sencilla consiste en una cadena simple, que describe un conjunto compuesto tan solo por esa misma cadena. Por ejemplo, veamos cómo la cadena “python” coincide con la expresión regular “python” usando la función match:

import re

if re.match("python", "python"):
   print "cierto"

Si quisiéramos comprobar si la cadena es python, jython, cython o cualquier otra cosa que termine en “ython”, podríamos utilizar el carácter comodín, el punto ‘.’:

re.match(".ython", "python")
re.match(".ython", "jython")

La expresión regular “.ython” describiría a todas las cadenas que consistan en un carácter cualquiera, menos el de nueva línea, seguido de “ython”. Un carácter cualquiera y solo uno. No cero, ni dos, ni tres.

En el caso de que necesitáramos el carácter ‘.’ en la expresión regular, o cualquier otro de los caracteres especiales que veremos a continuación, tendríamos que escaparlo utilizando la barra invertida.

Para comprobar si la cadena consiste en 3 caracteres seguidos de un punto, por ejemplo, podríamos utilizar lo siguiente:

re.match("...\.", "abc.")

Si necesitáramos una expresión que sólo resultara cierta para las cadenas “python”, “jython” y “cython” y ninguna otra, podríamos utilizar el carácter ‘|’ para expresar alternativa escribiendo los tres subpatrones completos:

re.match("python|jython|cython", "python")

o bien tan solo la parte que pueda cambiar, encerrada entre paréntesis, formando lo que se conoce como un grupo. Los grupos tienen una gran importancia a la hora de trabajar con expresiones regulares y este no es su único uso, como veremos en la siguiente sección.

re.match("(p|j|c)ython", "python")

Otra opción consistiría en encerrar los caracteres ‘p’, ‘j’ y ‘c’ entre corchetes para formar una clase de caracteres, indicando que en esa posición puede colocarse cualquiera de los caracteres de la clase.

re.match("[pjc]ython", "python")

¿Y si quisiéramos comprobar si la cadena es python0, python1, python2, … , python9? En lugar de tener que encerrar los 10 dígitos dentro de los corchetes podemos utilizar el guión, que sirve para indicar rangos. Por ejemplo a-d indicaría todas las letras minúsculas de la ‘a’ a la ‘d’; 0-9 serían todos los números de 0 a 9 inclusive.

re.match("python[0-9]", "python0")

Si quisiéramos, por ejemplo, que el último carácter fuera o un dígito o una letra simplemente se escribirían dentro de los corchetes todos los criterios, uno detras de otro.

re.match("python[0-9a-zA-Z]", "pythonp")

Es necesario advertir que dentro de las clases de caracteres los caracteres especiales no necesitan ser escapados. Para comprobar si la cadena es “python.” o “python,”, entonces, escribiríamos:

re.match("python[.,]", "python.")

y no

re.match("python[\.,]", "python.")

ya que en este último caso estaríamos comprobando si la cadena es “python.”, “python,” o “python\”.

Los conjuntos de caracteres también se pueden negar utilizando el símbolo ‘^’. La expresión “python[^0-9a-z]“, por ejemplo, indicaría que nos interesan las cadenas que comiencen por “python” y tengan como último carácter algo que no sea ni una letra minúscula ni un número.

re.match("python[^0-9a-z]", "python+")

El uso de [0-9] para referirse a un dígito no es muy común, ya que, al ser la comprobación de que un carácter es un dígito algo muy utilizado, existe una secuencia especial equivalente: ‘\d’. Existen otras secuencias disponibles que listamos a continuación:

  • \d

    un dígito. Equivale a [0-9]

  • \D

    cualquier carácter que no sea un dígito. Equivale a [^0-9]

  • \w

    Cualquier caracter alfanumérico. Equivale a [a-zA-Z0-9_].

  • \W

    Cualquier carácter no alfanumérico. Equivale a [^a-zA-Z0-9_].

  • \s

    Cualquier carácter en blanco. Equivale a [ \t\n\r\f\v]

  • \S

    Cualquier carácter que no sea un espacio en blanco. Equivale a [^ \t\n\r\f\v]

Veamos ahora cómo representar repeticiones de caracteres, dado que no sería de mucha utilidad tener que, por ejemplo, escribir una expresión regular con 30 caracteres ‘\d’ para buscar números de 30 dígitos. Para este menester tenemos los caracteres especiales ‘+’, ‘*’, ‘?”, además de las llaves ‘{}’.

El carácter ‘+’ indica que lo que tenemos a la izquierda, sea un carácter como ‘a’, una clase como ‘[abc]‘ o un subpatrón como (abc), puede encontrarse una o mas veces. Por ejemplo la expresión regular “python+” describiría las cadenas “python”, “pythonn”, “pythonnn”, pero no “pytho”, ya que debe haber al menos una n.

El carácter ‘*’ es similar a ‘+’, pero en este caso lo que se sitúa a su izquierda puede encontrarse cero o mas veces.

El carácter ‘?’ indica opcionalidad, es decir, lo que tenemos a la izquierda puede o no aparecer (puede aparecer 0 o 1 veces).

Finalmente las llaves sirven para indicar el número de veces exacto que puede aparecer el carácter de la izquierda, o bien un rango de veces que puede aparecer. Por ejemplo {3} indicaría que tiene que aparecer exactamente 3 veces, {3,8} indicaría que tiene que aparecer de 3 a 8 veces, {,8} de 0 a 8 veces y {3,} tres veces o mas (las que sean).

Otro elemento interesante en las expresiones regulares, para terminar, es la especificación de las posiciones en que se tiene que encontrar la cadena, esa es la utilidad de ^ y $, que indican que el elemento sobre el que actúa debe ir al principio de la cadena o al final de esta.

La cadena “http://mundogeek.net”, por ejemplo, se ajustaría a la expresión regular “^http”, mientras que la cadena “El protocolo es http” no lo haría, ya que el http no se encuentra al principio de la cadena.

Expresiones regulares: Usando el módulo re

Ya hemos visto por encima cómo se utiliza la función match del módulo re para comprobar si una cadena se ajusta a un determinado patrón. El primer parámetro de la función es la expresión regular, el segundo, la cadena a comprobar y existe un tercer parámetro opcional que contiene distintos flags que se pueden utilizar para modificar el comportamiento de las expresiones regulares.

Algunos ejemplos de flags del módulo re son re.IGNORECASE, que hace que no se tenga en cuenta si las letras son mayúsculas o minúsculas o re.VERBOSE, que hace que se ignoren los espacios y los comentarios en la cadena que representa la expresión regular.

El valor de retorno de la función será None en caso de que la cadena no se ajuste al patrón o un objeto de tipo MatchObject en caso contrario. Este objeto MatchObject cuenta con métodos start y end que devuelven la posición en la que comienza y finaliza la subcadena reconocida y métodos group y groups que permiten acceder a los grupos que propiciaron el reconocimiento de la cadena.

Al llamar al método group sin parámetros se nos devuelve el grupo 0 de la cadena reconocida. El grupo 0 es la subcadena reconocida por la expresión regular al completo, aunque no existan paréntesis que delimiten el grupo.

>>> mo = re.match(“http://.+\net”, “http://mundogeek.net”)
>>> print mo.group()

http://mundogeek.net

Podríamos crear grupos utilizando los paréntesis, como aprendimos en la sección anterior, obteniendo así la parte de la cadena que nos interese.

>>> mo = re.match(“http://(.+)\net”, “http://mundogeek.net”)
>>> print mo.group(0)

http://mundogeek.net

>>> print mo.group(1)
mundogeek

El método groups, por su parte, devuelve una lista con todos los grupos, exceptuando el grupo 0, que se omite.

>>> mo = re.match(“http://(.+)\(.{3})”, “http://mundogeek.net”)
>>> print mo.groups()
(‘mundogeek’, ‘net’)

La función search del módulo re funciona de forma similar a match; contamos con los mismos parámetros y el mismo valor de retorno. La única diferencia es que al utilizar match la cadena debe ajustarse al patrón desde el primer carácter de la cadena, mientras que con search buscamos cualquier parte de la cadena que se ajuste al patrón. Por esta razón el método start de la función match siempre devolverá 0, mientras que en el caso de search esto no tiene por qué ser así.

Otra función de búsqueda del módulo re es findall. Este toma los mismos parámetros que las dos funciones anteriores, pero devuelve una lista con las subcadenas que cumplieron el patrón.

Otra posibilidad, si no queremos todas las coincidencias, es utilizar finditer, que devuelve un iterador con el que consultar uno a uno los distintos MatchObject.

Las expresiones regulares no solo permiten realizar búsquedas o comprobaciones, sino que, como comentamos anteriormente, también tenemos funciones disponibles para dividir la cadena o realizar reemplazos.

La función split sin ir más lejos toma como parámetros un patrón, una cadena y un entero opcional indicando el número máximo de elementos en los que queremos dividir la cadena, y utiliza el patrón a modo de puntos de separación para la cadena, devolviendo una lista con las subcadenas.

La función sub toma como parámetros un patrón a sustituir, una cadena que usar como reemplazo cada vez que encontremos el patrón, la cadena sobre la que realizar las sustituciones, y un entero opcional indicando el número máximo de sustituciones que queremos realizar.

Al llamar a estos métodos lo que ocurre en realidad es que se crea un nuevo objeto de tipo RegexObject que representa la expresión regular, y se llama a métodos de este objeto que tienen los mismos nombres que las funciones del módulo.

Si vamos a utilizar un mismo patrón varias veces nos puede interesar crear un objeto de este tipo y llamar a sus métodos nosotros mismos; de esta forma evitamos que el intérprete tenga que crear un nuevo objeto cada vez que usemos el patrón y mejoraremos el rendimiento de la aplicación.

Para crear un objeto RegexObject se utiliza la función compile del módulo, al que se le pasa como parámetro la cadena que representa el patrón que queremos utilizar para nuestra expresión regular y, opcionalmente, una serie de flags de entre los que comentamos anteriormente.

 

Robado de: http://mundogeek.net/archivos/2008/04/09/python-expresiones-regulares/

EMPEZAR CON AJAX

Nunca es tarde para comenzar a estudiar algo nuevo, y en mi caso, ese algo se llama AJAX.

Debido a mis nuevas pretensiones y a la necesidad de adaptar alguna pagina web comercial a el nuevo internet, mucho mas vistoso, y mas agradable para el usuario, y ante diferentes problemas que se me estaban acumulando por intentar hacer cosas en PHP, HTML y javascript no estando estos preparados para ello, he decidido aumentar conocimientos con AJAX.

Para empezar he visto este libro: Introducción a AJAX de Javier Eguíluz Pérez y con licencia creativecommons
Cuando termine de leerlo intentaré evaluarlo.