Guia Python: alta, listado, consulta y borrado de datos (2a parte).

agosto 31, 2013 0 comments

Python es un lenguaje de script desarrollado por Guido van Rossum.

Podemos codificar empleando programación lineal, estructurada y orientada a objetos (tengamos en cuenta que esta última es la que se ha impuesto en la actualidad).

Se cuenta con intérpretes de Python en múltiples plataformas: Windows, Linux, Mac etc. Se pueden desarrollar aplicaciones de escritorio como aplicaciones web. Empresas como Google, Yahoo, Nasa etc. utilizan este lenguaje para sus desarrollos (actualmente el creador de Python Guido van Rossum trabaja para Google.)

Se puede ejecutar instrucciones de Python desde la línea de comando o creando archivos con extensión *.py. Cuando uno comienza a aprender este lenguaje la línea de comandos nos provee una retroalimentación del resultado en forma inmediata.

El objetivo de este tutorial es presentar en forma progresiva los conceptos fundamentales de este lenguaje y poder analizar los problemas resueltos y codificar los problemas propuestos en este mismo sitio, sin tener que instalar en un principio el Python en su equipo (o luego de instalado poder avanzar con el tutorial en cualquier máquina conectada a internet).

Modificación de datos (App Engine).
Trabajaremos nuevamente con el problema de usuarios. Dispondremos un formulario que solicite la carga del nombre de un usuario y pasaremos a un segundo formulario donde mostraremos los datos actuales de dicho usuario. En una tercer página procedemos a modificar los datos ingresados.

import cgi
import wsgiref.handlers

from google.appengine.ext import webapp
from google.appengine.ext import db

class Formulario1(webapp.RequestHandler):
def get(self):
    self.response.out.write("""
<html>
<head></head>
<body>
<form action="formulario2" method="post">
Ingrese nombre de usuario a modificar:
<input type="text" name="nombre"><br>
<input type="submit" value="Buscar"><br>
</form>
</body>
</html>
""")

class TablaUsuarios(db.Model):
nombre=db.StringProperty()
clave=db.StringProperty()

class Formulario2(webapp.RequestHandler):
def post(self):
    self.response.out.write("<html><head></head><body>")
    nom=cgi.escape(self.request.get('nombre'))
    usuario=db.GqlQuery("select * from TablaUsuarios where nombre=:1",nom)
    usu=usuario.fetch(1)
    if len(usu)>0:
      self.response.out.write("""
<html>
<head></head>
<body>
<form action="procformulario2" method="post">
Nombre actual:
""")
      self.response.out.write("<input type=\"text\" name=\"nombre\" value=\""+usu[0].nombre+"\"><br>")
      self.response.out.write("Clave actual:")
      self.response.out.write("<input type=\"text\" name=\"clave\" value=\""+usu[0].clave+"\"><br>")
      self.response.out.write("<input type=\"hidden\" name=\"nombreoculto\" value=\""+usu[0].nombre+"\">")
      self.response.out.write("""
<input type="submit" value="Modificar"><br>
</form>
</body>
</html>
""")
    else:
      self.response.out.write("No existe un usuario con dicho nombre<br>")
    self.response.out.write("</body></body>")


class ProcFormulario2(webapp.RequestHandler):
def post(self):
    self.response.out.write("<html><head></head><body>")
    nomoculto=cgi.escape(self.request.get('nombreoculto'))
    nom=cgi.escape(self.request.get('nombre'))
    cla=cgi.escape(self.request.get('clave'))
    usuario=db.GqlQuery("select * from TablaUsuarios where nombre=:1",nomoculto)
    usu=usuario.fetch(1)
    if len(usu)>0:
      usu[0].nombre=nom
      usu[0].clave=cla
      usu[0].put()
    else:
      self.response.out.write("No existe un usuario con dicho nombre<br>")
    self.response.out.write("<a href=\"\\\">Principal</a>")
    self.response.out.write("</body></body>")

def main():
application = webapp.WSGIApplication([('/', Formulario1),
                                        ('/formulario2', Formulario2),
                                        ('/procformulario2', ProcFormulario2),
                                       ],
                                       debug=True)
wsgiref.handlers.CGIHandler().run(application)

if __name__ == '__main__':
main()

El segundo formulario debemos inicializar los atributos value de los dos controles text para que aparezcan cargados inicialmente con los datos actuales.
Por otro lado también es necesario definir un campo oculto donde almacenar el nombre de usuario actual, ya que si lo modifica no sabremos cual buscar:

class Formulario2(webapp.RequestHandler):
def post(self):
    self.response.out.write("<html><head></head><body>")
    nom=cgi.escape(self.request.get('nombre'))
    usuario=db.GqlQuery("select * from TablaUsuarios where nombre=:1",nom)
    usu=usuario.fetch(1)
    if len(usu)>0:
      self.response.out.write("""
<html>
<head></head>
<body>
<form action="procformulario2" method="post">
Nombre actual:
""")
      self.response.out.write("<input type=\"text\" name=\"nombre\" value=\""+usu[0].nombre+"\"><br>")
      self.response.out.write("Clave actual:")
      self.response.out.write("<input type=\"text\" name=\"clave\" value=\""+usu[0].clave+"\"><br>")
      self.response.out.write("<input type=\"hidden\" name=\"nombreoculto\" value=\""+usu[0].nombre+"\">")
      self.response.out.write("""
<input type="submit" value="Modificar"><br>
</form>
</body>
</html>
""")
    else:
      self.response.out.write("No existe un usuario con dicho nombre<br>")
    self.response.out.write("</body></body>")

La tercer página recupera el usuario que ingresó en el primer formulario, pero rescatado del campo oculto. Procedemos seguidamente a modificar los datos rescatados de la tabla y confirmamos los nuevos datos llamando al método put:

class ProcFormulario2(webapp.RequestHandler):
def post(self):
    self.response.out.write("<html><head></head><body>")
    nomoculto=cgi.escape(self.request.get('nombreoculto'))
    nom=cgi.escape(self.request.get('nombre'))
    cla=cgi.escape(self.request.get('clave'))
    usuario=db.GqlQuery("select * from TablaUsuarios where nombre=:1",nomoculto)
    usu=usuario.fetch(1)
    if len(usu)>0:
      usu[0].nombre=nom
      usu[0].clave=cla
      usu[0].put()
    else:
      self.response.out.write("No existe un usuario con dicho nombre<br>")
    self.response.out.write("<a href=\"\\\">Principal</a>")
    self.response.out.write("</body></body>")

Listado, Alta, Baja y Modificación (App Engine).

Ahora plantearemos todos los conceptos vistos para el manejo de una tabla de datos utilizando el Google App Engine.
Mostraremos un listado con una tabla con todos los nombres de usuarios y claves, dos hipervínculos uno para poder borrar el usuario y otro para poder modificar el registro. Por último dispondremos un hipervínculo para llamar a un formulario de alta de usuario.

import cgi
import wsgiref.handlers

from google.appengine.ext import webapp
from google.appengine.ext import db

class TablaUsuarios(db.Model):
nombre=db.StringProperty()
clave=db.StringProperty()

class Listado(webapp.RequestHandler):
def get(self):
    self.response.out.write("<html><head></head><body>")
    self.response.out.write("<table border=\"1\">")
    self.response.out.write("<tr>")


self.response.out.write("<td>Usuario</td><td>Clave</td><td>Borrar</td><td>Modificar&l

t;/td>")
    self.response.out.write("</tr>")
    usuarios=db.GqlQuery("select * from TablaUsuarios")
    for usu in usuarios:
      self.response.out.write("<tr>")
      self.response.out.write("<td>" + usu.nombre +"</td>")
      self.response.out.write("<td>" + usu.clave +"</td>")
      self.response.out.write("<td><a href=\"baja?nombre="+usu.nombre+"\">Borra?</a>"+"</td>")
      self.response.out.write("<td><a

href=\"formulariomodificacion?nombre="+usu.nombre+"\">Modifica?</a>"+"</td>")
      self.response.out.write("</tr>")
    self.response.out.write("<tr>")
    self.response.out.write("<td colspan=\"4\"><a href=\"formularioalta\">Alta</a></td>")
    self.response.out.write("</tr>")
    self.response.out.write("</table>")
    self.response.out.write("</body></html>")

class FormularioAlta(webapp.RequestHandler):
def get(self):
    self.response.out.write("""
<html>
<head></head>
<body>
<form action="alta" method="post">
Ingrese su nombre:
<input type="text" name="nombre"><br>
Ingrese su clave:
<input type="password" name="clave"><br>
<input type="submit" value="Alta"><br>
</form>
</body>
</html>
""")

class Alta(webapp.RequestHandler):
def post(self):
    nom=cgi.escape(self.request.get('nombre'))
    cla=cgi.escape(self.request.get('clave'))
    usuario=TablaUsuarios()
    usuario.nombre=nom
    usuario.clave=cla
    usuario.put()
    self.redirect("/")

class Baja(webapp.RequestHandler):
def get(self):
    nom=cgi.escape(self.request.get('nombre'))
    usuario=db.GqlQuery("select * from TablaUsuarios where nombre=:1",nom)
    usu=usuario.fetch(1)
    if len(usu)>0:
      usu[0].delete()
    self.redirect("/")

class FormularioModificacion(webapp.RequestHandler):
def get(self):
    self.response.out.write("<html><head></head><body>")
    nom=cgi.escape(self.request.get('nombre'))
    usuario=db.GqlQuery("select * from TablaUsuarios where nombre=:1",nom)
    usu=usuario.fetch(1)
    if len(usu)>0:
      self.response.out.write("""
<html>
<head></head>
<body>
<form action="modificacion" method="post">
Nombre actual:
""")
      self.response.out.write("<input type=\"text\" name=\"nombre\" value=\""+usu[0].nombre+"\"><br>")
      self.response.out.write("Clave actual:")
      self.response.out.write("<input type=\"text\" name=\"clave\" value=\""+usu[0].clave+"\"><br>")
      self.response.out.write("<input type=\"hidden\" name=\"nombreoculto\" value=\""+usu[0].nombre+"\">")
      self.response.out.write("""
<input type="submit" value="Modificar"><br>
</form>
</body>
</html>
""")
    else:
      self.response.out.write("No existe un usuario con dicho nombre<br>")
    self.response.out.write("</body></body>")

class Modificacion(webapp.RequestHandler):
def post(self):
    nomoculto=cgi.escape(self.request.get('nombreoculto'))
    nom=cgi.escape(self.request.get('nombre'))
    cla=cgi.escape(self.request.get('clave'))
    usuario=db.GqlQuery("select * from TablaUsuarios where nombre=:1",nomoculto)
    usu=usuario.fetch(1)
    if len(usu)>0:
      usu[0].nombre=nom
      usu[0].clave=cla
      usu[0].put()
    self.redirect("/")


def main():
application = webapp.WSGIApplication([('/', Listado),
                                        ('/formularioalta',FormularioAlta ),
                                        ('/alta',Alta ),
                                        ('/baja', Baja),
                                        ('/formulariomodificacion', FormularioModificacion),
                                        ('/modificacion', Modificacion),
                                       ],
                                       debug=True)
wsgiref.handlers.CGIHandler().run(application)

if __name__ == '__main__':
main()

En la función main() debemos inicializar la lista que vincula las URL de las páginas y las clases que se ejecutan:

def main():
application = webapp.WSGIApplication([('/', Listado),
                                        ('/formularioalta',FormularioAlta ),
                                        ('/alta',Alta ),
                                        ('/baja', Baja),
                                        ('/formulariomodificacion', FormularioModificacion),
                                        ('/modificacion', Modificacion),
                                       ],
                                       debug=True)
wsgiref.handlers.CGIHandler().run(application)

La clase Listado es la que muestra la raiz del sitio y tiene por objetivo crear una tabla HTML con todos los usuarios almacenados en la TablaUsuarios. Además de imprimir cada registro disponemos un hipervínculo pasando como parámetro el nombre de usuario a borrar o modificar:

class Listado(webapp.RequestHandler):
def get(self):
    self.response.out.write("<html><head></head><body>")
    self.response.out.write("<table border=\"1\">")
    self.response.out.write("<tr>")


self.response.out.write("<td>Usuario</td><td>Clave</td><td>Borrar</td><td>Modificar&l

t;/td>")
    self.response.out.write("</tr>")
    usuarios=db.GqlQuery("select * from TablaUsuarios")
    for usu in usuarios:
      self.response.out.write("<tr>")
      self.response.out.write("<td>" + usu.nombre +"</td>")
      self.response.out.write("<td>" + usu.clave +"</td>")
      self.response.out.write("<td><a href=\"baja?nombre="+usu.nombre+"\">Borra?</a>"+"</td>")
      self.response.out.write("<td><a

href=\"formulariomodificacion?nombre="+usu.nombre+"\">Modifica?</a>"+"</td>")
      self.response.out.write("</tr>")
    self.response.out.write("<tr>")
    self.response.out.write("<td colspan=\"4\"><a href=\"formularioalta\">Alta</a></td>")
    self.response.out.write("</tr>")
    self.response.out.write("</table>")
    self.response.out.write("</body></html>")

La clase FormularioAlta muestra los dos controles text y el botón submit, cuando se presiona dicho botón se procede a llamar a la URL alta:

class FormularioAlta(webapp.RequestHandler):
def get(self):
self.response.out.write("""
<html>
<head></head>
<body>
<form action="alta" method="post">
Ingrese su nombre:
<input type="text" name="nombre"><br>
Ingrese su clave:
<input type="password" name="clave"><br>
<input type="submit" value="Alta"><br>
</form>
</body>
</html>
""")

La clase Alta inicializa un objeto de la clase TablaUsuarios, procede a registrar los datos y mediante el método redirect redirige a la raiz del sitio (es decir la clase Listado):

class Alta(webapp.RequestHandler):
def post(self):
    nom=cgi.escape(self.request.get('nombre'))
    cla=cgi.escape(self.request.get('clave'))
    usuario=TablaUsuarios()
    usuario.nombre=nom
    usuario.clave=cla
    usuario.put()
    self.redirect("/")

Cuando se presiona el hipervínculo "Borra?" en el listado se ejecuta la clase Baja y recibe como parámetro en el hipervínculo el nombre de usuario a borrar. Recuperamos el registro, llamamos al método delete y redirigimos nuevamente a la página de listado:

class Baja(webapp.RequestHandler):
def get(self):
    nom=cgi.escape(self.request.get('nombre'))
    usuario=db.GqlQuery("select * from TablaUsuarios where nombre=:1",nom)
    usu=usuario.fetch(1)
    if len(usu)>0:
      usu[0].delete()
    self.redirect("/")

Cuando se presiona el hipervínculo "Modificación?" se ejecuta la clase FormularioModificacion, en este recuperamos el nombre de usuario e inicializamos los controles text y el campo oculto:

class FormularioModificacion(webapp.RequestHandler):
def get(self):
    self.response.out.write("<html><head></head><body>")
    nom=cgi.escape(self.request.get('nombre'))
    usuario=db.GqlQuery("select * from TablaUsuarios where nombre=:1",nom)
    usu=usuario.fetch(1)
    if len(usu)>0:
      self.response.out.write("""
<html>
<head></head>
<body>
<form action="modificacion" method="post">
Nombre actual:
""")
      self.response.out.write("<input type=\"text\" name=\"nombre\" value=\""+usu[0].nombre+"\"><br>")
      self.response.out.write("Clave actual:")
      self.response.out.write("<input type=\"text\" name=\"clave\" value=\""+usu[0].clave+"\"><br>")
      self.response.out.write("<input type=\"hidden\" name=\"nombreoculto\" value=\""+usu[0].nombre+"\">")
      self.response.out.write("""
<input type="submit" value="Modificar"><br>
</form>
</body>
</html>
""")
    else:
      self.response.out.write("No existe un usuario con dicho nombre<br>")
    self.response.out.write("</body></body>")

Cuando se presiona el botón modificación del formulario anterior se ejecuta la clase Modificacion donde se procede a modificar el nombre y clave del usuario. Por último se redirige a la raiz del sitio:

class Modificacion(webapp.RequestHandler):
def post(self):
    nomoculto=cgi.escape(self.request.get('nombreoculto'))
    nom=cgi.escape(self.request.get('nombre'))
    cla=cgi.escape(self.request.get('clave'))
    usuario=db.GqlQuery("select * from TablaUsuarios where nombre=:1",nomoculto)
    usu=usuario.fetch(1)
    if len(usu)>0:
      usu[0].nombre=nom
      usu[0].clave=cla
      usu[0].put()
    self.redirect("/")

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Guias y Tutoriales

0 comments:

No insertes enlaces clicables, de lo contrario se eliminará el comentario. Si quieres ser advertido via email de los nuevos comentarios marca la casilla "Notificarme". Si te ayudé con la publicación o con las respuestas a los comentarios, compártelo en Facebook, Twitter, Tumblr, Google +, Pinterest o Instagram. Gracias.

Guia Python: alta, listado, consulta y borrado de datos (1a parte).

agosto 30, 2013 0 comments

Alta y listado de una base de datos (App Engine)
El almacenamiento de datos utilizando la infraestructura de Google es bastante distinta a las metodologías de MySql, Oracle, Sql Server etc.
Google utiliza una tecnología llamada 'Bigtable', básicamente es un sistema de almacenamiento distribuido que permite escalar de forma muy sencilla, evitando que por ejemplo las consultas de tablas con millones de registros se resientan.

Para hacer uso de esta tecnología debemos importar el paquete db:

from google.appengine.ext import db

Desarrollaremos una aplicación que permita almacenar el nombre de usuario y su clave. Luego imprimiremos todos los registros almacenados.

import cgi
import wsgiref.handlers

from google.appengine.ext import webapp
from google.appengine.ext import db

class Formulario1(webapp.RequestHandler):
def get(self):
    self.response.out.write("""
<html>
<head></head>
<body>
<form action="procformulario1" method="post">
Ingrese su nombre:
<input type="text" name="nombre"><br>
Ingrese su clave:
<input type="password" name="clave"><br>
<input type="submit" value="enviar"><br>
</form>
</body>
</html>
""")

class TablaUsuarios(db.Model):
nombre=db.StringProperty()
clave=db.StringProperty()

class ProcFormulario1(webapp.RequestHandler):
def post(self):
    self.response.out.write("<html><head></head><body>")
    nom=cgi.escape(self.request.get('nombre'))
    cla=cgi.escape(self.request.get('clave'))
    usuario=TablaUsuarios()
    usuario.nombre=nom
    usuario.clave=cla
    usuario.put()
    self.response.out.write("<a href=\"listadousuarios\">Listado</a>")
    self.response.out.write("</body></body>")

class ListadoUsuarios(webapp.RequestHandler):
def get(self):
    self.response.out.write("<html><head></head><body>")
    usuarios=db.GqlQuery("select * from TablaUsuarios")
    for usu in usuarios:
      self.response.out.write("Nombre:" + usu.nombre +"<br>")
      self.response.out.write("Clave:" + usu.clave +"<br>")
      self.response.out.write("<hr>")
    self.response.out.write("<a href=\"\\\">Principal</a>")
    self.response.out.write("</body></body>")


def main():
application = webapp.WSGIApplication([('/', Formulario1),
                                        ('/procformulario1', ProcFormulario1),
                                        ('/listadousuarios', ListadoUsuarios)],
                                       debug=True)
wsgiref.handlers.CGIHandler().run(application)

if __name__ == '__main__':
main()

Veamos todo lo que debemos agregar:

Debemos importar el paquete db:

from google.appengine.ext import db

Debemos declarar una clase que representa una tabla.

Esta clase debe heredar de la clase Model contenida en el paquete db.

Definimos dos atributos de tipo StringProperty.

StringProperty es una clase contenida en el paquete db y que encapsula el manejo de un campo de cadena de caracteres:

class TablaUsuarios(db.Model): nombre=db.StringProperty() clave=db.StringProperty()

Para efectuar el alta de un registro en la tabla:

class ProcFormulario1(webapp.RequestHandler):
def post(self):
    self.response.out.write("<html><head></head><body>")
    nom=cgi.escape(self.request.get('nombre'))
    cla=cgi.escape(self.request.get('clave'))
    usuario=TablaUsuarios()
    usuario.nombre=nom
    usuario.clave=cla
    usuario.put()
    self.response.out.write("<a href=\"listadousuarios\">Listado</a>")
    self.response.out.write("</body></body>")

Creamos un objeto de la clase Tablausuarios:

usuario=TablaUsuarios()

Inicializamos los atributos nombre y clave con los datos extraidos del formulario.

usuario.nombre=nom
usuario.clave=cla

Llamamos al método put que confirma los datos previamente cargados:

usuario.put()

Para obtener un listado de todos los registros almacenados:

class ListadoUsuarios(webapp.RequestHandler):
def get(self):
    self.response.out.write("<html><head></head><body>")
    usuarios=db.GqlQuery("select * from TablaUsuarios")
    for usu in usuarios:
      self.response.out.write("Nombre:" + usu.nombre +"<br>")
      self.response.out.write("Clave:" + usu.clave +"<br>")
      self.response.out.write("<hr>")
    self.response.out.write("<a href=\"\\\">Principal</a>")
    self.response.out.write("</body></body>")

Creamos un objeto de la clase GqlQuery pasando como parámetro al constructor los datos a recuperar:

usuarios=db.GqlQuery("select * from TablaUsuarios")

Mediante un for recorremos la lista de usuarios y los imprimimos:

for usu in usuarios:
      self.response.out.write("Nombre:" + usu.nombre +"<br>")
      self.response.out.write("Clave:" + usu.clave +"<br>")
      self.response.out.write("<hr>")

Como esta aplicación requiere tres páginas luego debemos registrarlas cuando creamos un objeto de la clase WSGIApplication:

def main():
application = webapp.WSGIApplication([('/', Formulario1),
                                        ('/procformulario1', ProcFormulario1),
                                        ('/listadousuarios', ListadoUsuarios)],
                                       debug=True)
wsgiref.handlers.CGIHandler().run(application)

Consulta de datos (App Engine).

Confeccionaremos una aplicación que nos permita ingresar el nombre de usuario y nos recupere y muestre su clave. Tener en cuenta los datos cargados en el concepto anterior:

Creamos un formulario para ingresar el nombre de usuario a buscar:

class Formulario1(webapp.RequestHandler):
def get(self):
self.response.out.write("""
<html>
<head></head>
<body>
<form action="procformulario1" method="post">
Ingrese nombre de usuario:
<input type="text" name="nombre"><br>
<input type="submit" value="enviar"><br>
</form>
</body>
</html>
""")

El botón submit hace que se ejecute la clase ProcFormulario1:

class ProcFormulario1(webapp.RequestHandler):
def post(self):
    self.response.out.write("<html><head></head><body>")
    nom=cgi.escape(self.request.get('nombre'))
    usuario=db.GqlQuery("select * from TablaUsuarios where nombre=:1",nom)
    usu=usuario.fetch(1)
    if len(usu)>0:
      self.response.out.write("Clave:" + usu[0].clave +"<br>")
    else:
      self.response.out.write("No existe un usuario con dicho nombre<br>")
    self.response.out.write("<a href=\"\\\">Principal</a>")
    self.response.out.write("</body></body>")

Primero generamos una consulta a la tabla y le pasamos como parámetro en el campo nombre el valor rescatado del formulario, debemos utilizar los dos puntos y un uno para indicar que dicho espacio será remplazado por el segundo parámetro:

usuario=db.GqlQuery("select * from TablaUsuarios where nombre=:1",nom)

La clase GqlQuery tiene un método llamado fetch que retorna todos los registros generados en la consulta. Al método fetch le pasamos la cantidad de registros que queremos rescatar y por último accedemos a la primer componente de la lista siempre y cuando la cantidad de elementos sea mayor a cero.

Borrado de datos (App Engine).

Confeccionaremos una aplicación que nos permita ingresar el nombre de usuario y efectúe su borrado.. Tener en cuenta los datos cargados en conceptos anterioriores.

Si lo comparamos con la consulta es prácticamente igual con la salvedad donde en lugar de mostrarlo procedemos a borrarlo:

nom=cgi.escape(self.request.get('nombre'))
    usuario=db.GqlQuery("select * from TablaUsuarios where nombre=:1",nom)
    usu=usuario.fetch(1)
    if len(usu)>0:
      usu[0].delete()
      self.response.out.write("Se borro el usuario<br>")

    else:
      self.response.out.write("No existe un usuario con dicho nombre<br>")

El método delete borrar el registro.

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Guias y Tutoriales

0 comments:

Guia Python: Formularios HTML.

agosto 29, 2013 0 comments

python Funciones con parámetros por defecto1

Formulario HTML - control radio (App Engine).
Realizaremos una aplicación que muestre un formulario con dos controles de tipo text, luego dos controles de tipo radio que indiquen si queremos sumar o restar los valores ingresados en los controles text.

import cgi
import wsgiref.handlers

from google.appengine.ext import webapp

class Formulario1(webapp.RequestHandler):
def get(self):
    self.response.out.write("""
<html>
<head></head>
<body>
<form action="procformulario1" method="post">
Ingrese primer valor:
<input type="text" name="valor1">
<br>
Ingrese segundo valor:
<input type="text" name="valor2">
<br>
<input type="radio" name="radio1" value="suma">sumar
<br>
<input type="radio" name="radio1" value="resta">restar
<br>
<input type="submit" value="operar">
</form>
</body>
</html>
""")

class ProcFormulario1(webapp.RequestHandler):
def post(self):
    self.response.out.write("<html><head></head><body>")
    v1=int(self.request.get('valor1'))
    v2=int(self.request.get('valor2'))
    operacion=self.request.get('radio1')
    if operacion=="suma":
      resultado=v1+v2
    else:
      resultado=v1-v2
    self.response.out.write("El resultado de la " + operacion + " es " + str(resultado))
    self.response.out.write("</body></body>")


def main():
application = webapp.WSGIApplication([('/', Formulario1),
                                        ('/procformulario1', ProcFormulario1)],
                                       debug=True)
wsgiref.handlers.CGIHandler().run(application)

if __name__ == '__main__':
main()

En la página principal del sitio asociamos la clase que despliega el formulario HTML:

('/', Formulario1)

Luego la clase que procesa los datos ingresados en el formulario es ProcFormulario1, en esta primero rescatamos los dos valores ingresados en los controles text y procedemos a convertilos a entero:

v1=int(self.request.get('valor1'))
v2=int(self.request.get('valor2'))

Rescatamos la propiedad value del control radio seleccionado:

operacion=self.request.get('radio1')

Y mediante un if verificamos si tenemos que sumar o restar los contenidos de los text:

if operacion=="suma":
      resultado=v1+v2
    else:
      resultado=v1-v2

Por último procedemos a imprimir el resultado de la operación:

self.response.out.write("El resultado de la " + operacion + " es " + str(resultado))

Formulario HTML - control select (App Engine).

Veamos el control HTML de tipo select. Este tipo de control el funcionamiento es similar al de un conjunto de controles de tipo radio.
Confeccionaremos el mismo problemas del concepto anterior es decir cargar dos números y posteriormente mediante un control de tipo select seleccionar si queremos sumarlos o restarlos (solo una de estas operaciones se puede elegir)
La sintaxis del control de tipo select es:

<select name="operacion">
<option value="suma">Sumar</option>
<option value="resta">Restar</option>
</select>

Es importante notar que la sintaxis es bastante distinta a los controles de tipo text y radio.
El elemento select tiene definido la propiedad name mediante la cual rescataremos el valor seleccionado en el servidor.
El elemento select contiene un conjunto de elementos option. Cada elemento option tiene definido la propiedad value. El que quede seleccionado el control select rescata su propiedad value.
Luego el programa en Python utilizando Google App Engine:

import cgi
import wsgiref.handlers

from google.appengine.ext import webapp

class Formulario1(webapp.RequestHandler):
def get(self):
    self.response.out.write("""
<html>
<head></head>
<body>
<form action="procformulario1" method="post">
Ingrese primer valor:
<input type="text" name="valor1">
<br>
Ingrese segundo valor:
<input type="text" name="valor2">
<br>
<select name="operacion">
<option value="suma">Sumar</option>
<option value="resta">Restar</option>
</select>
<br>
<input type="submit" value="operar">
</form>
</body>
</html>
""")

class ProcFormulario1(webapp.RequestHandler):
def post(self):
    self.response.out.write("<html><head></head><body>")
    v1=int(self.request.get('valor1'))
    v2=int(self.request.get('valor2'))
    op=self.request.get('operacion')
    if op=="suma":
      resultado=v1+v2
    else:
      resultado=v1-v2
    self.response.out.write("El resultado de la " + op + " es " + str(resultado))
    self.response.out.write("</body></body>")



def main():
application = webapp.WSGIApplication([('/', Formulario1),
                                        ('/procformulario1', ProcFormulario1)],
                                       debug=True)
wsgiref.handlers.CGIHandler().run(application)

if __name__ == '__main__':
main()

De forma similar como venimos trabajando en una clase desplegamos el formulario HTML (Formulario1) y otra clase procesa el contenido del formulario (ProcFormulario1).
En la página que procesamos los datos del formulario rescatamos los valores de los controles text y los convertimos a entero:

v1=int(self.request.get('valor1'))
v2=int(self.request.get('valor2'))

Seguidamente rescatamos la propiedad name de la opción seleccionada del control select:

op=self.request.get('operacion')

Mediante un if verificamos si tenemos que sumar o restar

if op=="suma":
      resultado=v1+v2
    else:
      resultado=v1-v2

Por último mostramos el resultado:

self.response.out.write("El resultado de la " + op + " es " + str(resultado))

Formulario HTML - control select con selección múltiple (App Engine).

Veamos una variante del control select la cual permite seleccionar varias opciones de su contenido. Para esto debemos agregar la propiedad multiple cuando lo definimos:

<select name="operacion" multiple>

Con este simple cambio podemos seleccionar más de un elemento del interior del control select.
Confeccionaremos el mismo problema anterior, solo que ahora podremos seleccionar las dos operaciones en forma simultanea:

import cgi
import wsgiref.handlers

from google.appengine.ext import webapp

class Formulario1(webapp.RequestHandler):
def get(self):
    self.response.out.write("""
<html>
<head></head>
<body>
<form action="procformulario1" method="post">
Ingrese primer valor:
<input type="text" name="valor1">
<br>
Ingrese segundo valor:
<input type="text" name="valor2">
<br>
<select name="operacion" multiple>
<option value="suma">Sumar</option>
<option value="resta">Restar</option>
</select>
<br>
<input type="submit" value="operar">
</form>
</body>
</html>
""")

class ProcFormulario1(webapp.RequestHandler):
def post(self):
    self.response.out.write("<html><head></head><body>")
    v1=int(self.request.get('valor1'))
    v2=int(self.request.get('valor2'))
    operaciones=self.request.get_all('operacion')
    for op in operaciones:
      if op=="suma":
        resultado=v1+v2
        self.response.out.write("El resultado de la " + op + " es " + str(resultado) + "<br>")
      if op=="resta":
        resultado=v1-v2
        self.response.out.write("El resultado de la " + op + " es " + str(resultado) + "<br>")
    self.response.out.write("</body></body>")


def main():
application = webapp.WSGIApplication([('/', Formulario1),
                                        ('/procformulario1', ProcFormulario1)],
                                       debug=True)
wsgiref.handlers.CGIHandler().run(application)

if __name__ == '__main__':
main()

Para recuperar la lista de valores seleccionados del control select debemos llamar al método get_all del objeto request en lugar de get:

operaciones=self.request.get_all('operacion')

Luego mediante una estructura repetitiva recorremos la lista de valores devuelto y comparamos con los valores posibles:

for op in operaciones:
      if op=="suma":
        resultado=v1+v2
        self.response.out.write("El resultado de la " + op + " es " + str(resultado) + "<br>")
      if op=="resta":
        resultado=v1-v2
        self.response.out.write("El resultado de la " + op + " es " + str(resultado) + "<br>")

Formulario HTML - control checkbox (App Engine).

Otra forma de hacer selecciones múltiples es utilizar un conjunto de controles de tipo checkbox. Cada control de tipo checkbox es independiente.
Resolvamos el problema del concepto anterior empleando dos controles de tipo checkbox:

import cgi
import wsgiref.handlers

from google.appengine.ext import webapp

class Formulario1(webapp.RequestHandler):
def get(self):
    self.response.out.write("""
<html>
<head></head>
<body>
<form action="procformulario1" method="post">
Ingrese primer valor:
<input type="text" name="valor1">
<br>
Ingrese segundo valor:
<input type="text" name="valor2">
<br>
<input type="checkbox" name="check1" value="suma">sumar
<br>
<input type="checkbox" name="check2" value="resta">restar
<br>
<input type="submit" value="operar">
</form>
</body>
</html>
""")

class ProcFormulario1(webapp.RequestHandler):
def post(self):
    self.response.out.write("<html><head></head><body>")
    v1=int(self.request.get('valor1'))
    v2=int(self.request.get('valor2'))
    su=self.request.get('check1')
    if su=="suma":
       resultado=v1+v2
       self.response.out.write("El resultado de la " + su + " es " + str(resultado) + "<br>")
    re=self.request.get('check2')
    if re=="resta":
       resultado=v1-v2
       self.response.out.write("El resultado de la " + re + " es " + str(resultado) + "<br>")
    self.response.out.write("</body></body>")

def main():
application = webapp.WSGIApplication([('/', Formulario1),
                                        ('/procformulario1', ProcFormulario1)],
                                       debug=True)
wsgiref.handlers.CGIHandler().run(application)

if __name__ == '__main__':
main()

Cada checkbox lo recuperamos en forma independiente:

su=self.request.get('check1')
    if su=="suma":
       resultado=v1+v2
       self.response.out.write("El resultado de la " + su + " es " + str(resultado) + "<br>")

Si se encuentra seleccionado el método get retorna el valor de la propiedad value del control HTML, en caso de no estar seleccionado retorna un string vacío.

Alta y listado de una base de datos (App Engine).
El almacenamiento de datos utilizando la infraestructura de Google es bastante distinta a las metodologías de MySql, Oracle, Sql Server etc.
Google utiliza una tecnología llamada 'Bigtable', básicamente es un sistema de almacenamiento distribuido que permite escalar de forma muy sencilla, evitando que por ejemplo las consultas de tablas con millones de registros se resientan.
Para hacer uso de esta tecnología debemos importar el paquete db:

from google.appengine.ext import db

Desarrollaremos una aplicación que permita almacenar el nombre de usuario y su clave. Luego imprimiremos todos los registros almacenados.

import cgi
import wsgiref.handlers

from google.appengine.ext import webapp
from google.appengine.ext import db

class Formulario1(webapp.RequestHandler):
def get(self):
    self.response.out.write("""
<html>
<head></head>
<body>
<form action="procformulario1" method="post">
Ingrese su nombre:
<input type="text" name="nombre"><br>
Ingrese su clave:
<input type="password" name="clave"><br>
<input type="submit" value="enviar"><br>
</form>
</body>
</html>
""")
class TablaUsuarios(db.Model):
nombre=db.StringProperty()
clave=db.StringProperty()

class ProcFormulario1(webapp.RequestHandler):
def post(self):
    self.response.out.write("<html><head></head><body>")
    nom=cgi.escape(self.request.get('nombre'))
    cla=cgi.escape(self.request.get('clave'))
    usuario=TablaUsuarios()
    usuario.nombre=nom
    usuario.clave=cla
    usuario.put()
    self.response.out.write("<a href=\"listadousuarios\">Listado</a>")
    self.response.out.write("</body></body>")

class ListadoUsuarios(webapp.RequestHandler):
def get(self):
    self.response.out.write("<html><head></head><body>")
    usuarios=db.GqlQuery("select * from TablaUsuarios")
    for usu in usuarios:
      self.response.out.write("Nombre:" + usu.nombre +"<br>")
      self.response.out.write("Clave:" + usu.clave +"<br>")
      self.response.out.write("<hr>")
    self.response.out.write("<a href=\"\\\">Principal</a>")
    self.response.out.write("</body></body>")

def main():
application = webapp.WSGIApplication([('/', Formulario1),
                                        ('/procformulario1', ProcFormulario1),
                                        ('/listadousuarios', ListadoUsuarios)],
                                       debug=True)
wsgiref.handlers.CGIHandler().run(application)

if __name__ == '__main__':
main()

Veamos todo lo que debemos agregar:

Debemos importar el paquete db:
from google.appengine.ext import db
Debemos declarar una clase que representa una tabla. Esta clase debe heredar de la clase Model contenida en el paquete db. Definimos dos atributos de tipo StringProperty. StringProperty es una clase contenida en el paquete db y que encapsula el manejo de un campo de cadena de caracteres:
class TablaUsuarios(db.Model): nombre=db.StringProperty() clave=db.StringProperty()
Para efectuar el alta de un registro en la tabla:

Creamos un objeto de la clase Tablausuarios:

usuario=TablaUsuarios()

Inicializamos los atributos nombre y clave con los datos extraidos del formulario.

usuario.nombre=nom
usuario.clave=cla

Llamamos al método put que confirma los datos previamente cargados:

usuario.put()

Para obtener un listado de todos los registros almacenados:

Creamos un objeto de la clase GqlQuery pasando como parámetro al constructor los datos a recuperar:

usuarios=db.GqlQuery("select * from TablaUsuarios")

Mediante un for recorremos la lista de usuarios y los imprimimos:

for usu in usuarios:
      self.response.out.write("Nombre:" + usu.nombre +"<br>")
      self.response.out.write("Clave:" + usu.clave +"<br>")
      self.response.out.write("<hr>")

Como esta aplicación requiere tres páginas luego debemos registrarlas cuando creamos un objeto de la clase WSGIApplication:

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Guias y Tutoriales

0 comments:

Como liberar memoria SWAP con Swapon y Swapoff.

agosto 29, 2013 0 comments

A veces ocurre que si tenemos abierta una aplicación ejecutando un proceso muy pesado que requiera de mucha memoria, acabe inundando la memoria RAM y parte de la memoria Swap.
Después de cerrar la aplicación parte de la memoria RAM se queda libre como es obvio, pero muchos procesos que antes estaban en la memoria RAM han pasado a la Swap para dejar libre el proceso de la aplicación que acabamos de cerrar.
Eso provoca que el sistema responda con mas latencias y tarde mas tiempo en ejecutar tareas nuevas que no estén en RAM. En esos casos mucha gente lo que hace es reiniciar, pero de lejos es una opción molesta y completamente innecesaria.

liberar memoria SWAP con Swapon y Swapoff

Con el comando free podemos ver la memoria disponible en la terminal. Nos dice la memoria libre, la memoria ocupada por cache y la memoria ocupada por la Swap.
Por ejemplo así es como queda mi ordenador portátil después de hacer un render pesado con Blender, como podéis ver, hay mucha memoria Swap ocupada y sin embargo hay memoria RAM disponible que no se esta utilizando.

liberar memoria SWAP con Swapon y Swapoff1

Ahora podemos pasar el contenido de la Swap a la memoria RAM, pero para ello primero nos tenemos que asegurar que la cantidad de memoria Swap utilizada ocupe menos espacio de lo que nos queda libre en la memoria RAM, obviamente seria una barbaridad forzar un traspaso de memoria Swap a la RAM si no nos queda memoria RAM libre, por que entonces ocurriría un desborde de memoria haciendo que muchos procesos vitales se colgaran y el kernel entraría en un bucle irrecuperable o mas conocido como Kernel Panic.

Por ejemplo en mi caso tengo 40,8 MB de Swap utilizada, y me queda 139,7 MB de RAM libre como podéis ver en la imagen.
Ahora tenemos que desactivar la partición Swap con la instrucción swap <función>, para desactivarla seria con el siguiente comando:

sudo swapoff -a
Con esto todas las particiones de intercambio que pudiera tener nuestro sistema se desactivaran temporalmente haciendo que todo su contenido se copie a la memoria RAM (la velocidad dependerá de lo rápida que sea la memoria RAM y el bus del chipset). Ahora volvemos a comprobar el estado con el comando free, y podemos observar que la Swap tiene 0 Bytes de capacidad, lo que significa que esta desactivado.

liberar memoria SWAP con Swapon y Swapoff2

Ahora para volver a activarlo (no se recomienda en absoluto mantenerla desactivada), la activamos con el siguiente comando:

sudo swapon -a

Ahora al volver a ejecutar el comando free, vemos que efectivamente no se esta utilizando por que se ha copiado a la RAM, pero la partición vuelve a tener el tamaño original, es decir, que esta activado.

liberar memoria SWAP con Swapon y Swapoff3

Con esta simple función podemos ganar mas respuesta de vez en cuando si el sistema es sometido a grandes cargas de memoria. En el caso de que tengamos mas de una partición Swap, como por ejemplo ocurría con el caso de la PlayStation 3 que podíamos usar la memoria gráfica como Swap mas la que tengamos en la partición del disco duro, entonces podemos ver la prioridad de las particiones con la función -s, el comando completo seria este:

sudo swapon -s
Y nos saldrá algo así:

En mi caso solo tengo una partición que es lo recomendado para la gran mayoría de sistemas. Lo que indica diciendo -1 significa que tiene menos prioridad que la memoria RAM, si tuviésemos otra partición nos lo diría con -2, -3, etc—
Man Page (8)

NOMBRE
swapon, swapoff - (des)habilita dispositivos o ficheros para el paginado y el trasiego
DESCRIPCIÓN
Swapon se emplea para especificar dispositivos sobre los cuales van a tener lugar las actividades de paginado y trasiego. Las llamadas a swapon se hacen normalmente en el fichero de inicio del sistema en modo multi-usuario, normalmente /etc/rc, haciendo ahí que todos los dispositivos de trasiego estén disponibles, de modo que las actividades de paginado y trasiego se intercalen entre varios dispositivos o ficheros.

Normalmente, se emplea la primera forma:
-h
Proporciona ayuda.
-V
Muestra la versión.
-s
Muestra un sumario del uso del trasiego por dispositivo.
-a
Se hacen disponibles para el trasiego todos los dispositivos marcados con ``sw'', de tipo `swap', en el fichero /etc/fstab.
-p prioridad
Especifica la prioridad para swapon. Esta opción sólo está disponible si swapon se ha compilado y se está usando bajo un núcleo 1.3.2 ó superior. prioridad es un valor entre 0 y 32767. Vea swapon(2) para una descripción completa de las prioridades de trasiego. Añada pri=valor al campo de opciones de /etc/fstab para el empleo con swapon -a.
Swapoff deshabilita el trasiego en los dispositivos o ficheros especificados, o en todas las entradas de tipo `swap' de /etc/fstab cuando se da la opción -a.

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Sistema

0 comments:

Guia Python: subir nuestra aplicación a Internet y recuperar el dato de un text (App Engine).

agosto 29, 2013 0 comments

Python es un lenguaje de script desarrollado por Guido van Rossum.
Podemos codificar empleando programación lineal, estructurada y orientada a objetos (tengamos en cuenta que esta última es la que se ha impuesto en la actualidad).
Se cuenta con intérpretes de Python en múltiples plataformas: Windows, Linux, Mac etc. Se pueden desarrollar aplicaciones de escritorio como aplicaciones web. Empresas como Google, Yahoo, Nasa etc. utilizan este lenguaje para sus desarrollos (actualmente el creador de Python Guido van Rossum trabaja para Google.)
Se puede ejecutar instrucciones de Python desde la línea de comando o creando archivos con extensión *.py. Cuando uno comienza a aprender este lenguaje la línea de comandos nos provee una retroalimentación del resultado en forma inmediata.
El objetivo de este tutorial es presentar en forma progresiva los conceptos fundamentales de este lenguaje y poder analizar los problemas resueltos y codificar los problemas propuestos en este mismo sitio, sin tener que instalar en un principio el Python en su equipo (o luego de instalado poder avanzar con el tutorial en cualquier máquina conectada a internet).

Subir nuestra aplicación Hola mundo a internet.
Si ya tenemos nuestra aplicación ejecutándose en forma correcta localmente:

http://localhost:8080

Ahora para que la puedan acceder todos en internet debemos seguir los siguientes pasos:

El primer paso es registrarnos en Google si todavía no lo hemos hecho para obtener una cuenta y esto lo podemos hacer desde aquí
Si ya dispone la cuenta suministrada por Google desde el panel de administración podemos crear una aplicación presionando el botón "Create an Application".
Debemos seleccionar un nombre para nuestra aplicación que correrá como un subdominio de appspot.com.
Seleccionado un nombre disponible (podemos comprobar disponibilidad presionando el botón "Check Availability") asignamos un título y aceptamos los términos del servicio. Ya estamos en condiciones de subir nuestra aplicación
Controlar que nuestro archivo app.yaml tiene una estructura similar a:

application: tutorialya
version: 1
runtime: python
api_version: 1

handlers:
- url: /.*
script: tutorialya.py

Del ejemplo anterior deberá modificar la propiedad de application con el nombre de aplicación que gestionó desde su panel de control del Google App Engine. Lo mismo pasa con la propiedad script.
Desde la línea de comandos del sistema operativo ejecutar el siguiente programa en Python que tiene por objetivo hacer el upload de todo nuestro proyecto a la cuenta que tenemos asignada en Google App Engine:

c:\Archivo de programa\Google\google_appengine>appcfg.py update tutorialya/

En ese momento se nos solicitará nuestro mail y clave.

Ya tenemos en el servidor almacenado nuestro sitio, solo nos falta llamarlo para verlo correr en la web.

http://tutorialya.appspot.com/

Recordar de remplazar el nombre tutorialya con el nombre con el que crearon su aplicación desde el panel del Google App Engine.
Recuperar el dato de un text (App Engine).
Realizaremos una aplicación que muestre un formulario con un control de tipo text y cuando se presione el botón submit mostraremos el dato ingresado en otra página.

import cgi
import wsgiref.handlers

from google.appengine.ext import webapp

class Formulario1(webapp.RequestHandler):
def get(self):
    self.response.out.write("""
<html>
<head></head>
<body>
<form method="post" action="procformulario1">
Ingrese su nombre:<input type="text" name="nombre" size="20"><br>
<input type="submit" value="Ok">
</form>
</body>
""")

class ProcFormulario1(webapp.RequestHandler):
def post(self):
    self.response.out.write("<html><head></head><body>")
    self.response.out.write(cgi.escape(self.request.get('nombre')))
    self.response.out.write("</body></body>")



def main():
application = webapp.WSGIApplication([('/', Formulario1),
                                        ('/procformulario1', ProcFormulario1)],
                                       debug=True)
wsgiref.handlers.CGIHandler().run(application)

if __name__ == '__main__':
main()

El programa se inicia al ser verdadera la condición:

if __name__ == '__main__':
main()

Los módulos son objetos y todos los módulos tienen un atributo llamado __name__. El valor del __name__ de un módulo depende de cómo esté usándolo. Si se importa el módulo, luego la propiedad __name__ es el nombre del fichero del módulo, sin el directorio de la ruta ni la extensión del archivo. Pero también puede ejecutar el módulo directamente como si fuera un programa, en cuyo caso __name__ tendrá un valor especial predefinido __main__.
El if se verifica como verdadero y llama a la función main().
En la función main debemos crear un objeto de la clase WSGIApplication y pasar como parámetro una lista con elementos de tipo tupla que asocian una URL y la clase que procesa dicha petición.
Cuando hacemos referencia a la raiz de nuestro sitio:

http://localhost:8080/

El servidor ejecuta Formulario1 según la tupla indicada con: ('/', Formulario1)
De forma similar cuando se presiona el botón submit del formulario se llama:

http://localhost:8080/procformulario1

y mediante la asociación ('/procformulario1', ProcFormulario1) se ejecutará el código de la clase ProcFormulario.
Todas las páginas de nuestro sitio deben ser mapeadas en la lista:

application = webapp.WSGIApplication([('/', Formulario1),
('/procformulario1', ProcFormulario1)],
debug=True)

El segundo parámetro del constructor de la clase WSGIApplication es el modo de ejecución, normalmente el parámetro debug lo inicializamos en true mientras estamos depurando nuestra aplicación, cuando la finalizamos y la subimos al servidor el parámetro debug le asignamos False.
La clase WSGIApplication se encuentra en el módulo webapp que se encuentra en el paquete google.appengine.ext:

from google.appengine.ext import webapp

La clase Formulario1 hereda de la clase RequestHandler que se encuentra en el paquete webapp. Para generar la página solo debemos reescribir el método get que será el que genere la página web. Para generar el contenido de la página llamamos al método write. La clase RequestHandler contiene un atributo llamado response y este un atributo out que es el que contiene el método write, es decir cada vez que queremos imprimir en la página debemos disponer el siguiente código:

self.response.out.write("Hola Mundo")

Si se trata de generar un bloque grande de HTML podemos utilizar la característica de Python de definir un String de varias líneas encerrándolas entre triple comillas:

self.response.out.write("""
<html>
<head></head>
<body>
<form method="post" action="procformulario1">
Ingrese su nombre:<input type="text" name="nombre" size="20"><br>
<input type="submit" value="Ok">
</form>
</body>
""")

Como vemos no es necesario escapar con el caracter '\' las comillas dobles cuando usamos triple comillas.
Podemos llamar tantas veces al método write como se necesite, todos los string se almacenan en un archivo de memoria que es el que se enviará al navegador que hizo la petición.
Una vez que la página que contiene el formulario se muestra en el navegador el operador ingresa el nombre y al presionar el botón submit el navegador procede a enviar el dato ingresado al servidor.
En la propiedad action del formulario hemos indicado quien procesará el dato en el servidor:

action="\procformulario1\"

Recordemos que tenemos mapeada dicha url :

application = webapp.WSGIApplication([('/', Formulario1),
('/procformulario1', ProcFormulario1)],
debug=True)

Es decir que la clase ProcFormulario1 recibe el dato. Esta clase también hereda de RequestHandler pero debe redefinir el método post. Luego procedemos de forma similar a la otra clase para crear una página en forma dinámica llamando al método write, con la salvedad que para recuperar el dato cargado en el formulario procedemos a llamar al método get del objeto request que contiene la clase:

class ProcFormulario1(webapp.RequestHandler):
def post(self):
    self.response.out.write("<html><head></head><body>")
    self.response.out.write(cgi.escape(self.request.get('nombre')))
    self.response.out.write("</body></body>")

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Guias y Tutoriales