miércoles, 26 de agosto de 2015

Tarea 2 Leyes de Amdahl ,Gutafsons y Procesamiento Pipeline


Pipeline
En computación, se le llama pipeline a una serie de elementos de procesamiento de datos ordenados de tal modo que la salida de cada uno es la entrada del siguiente, como quien dice una cadena de montaje pero en vez de orientada a la manufactura, orientada al procesamiento de datos e instrucciones.

La arquitectura en pipeline (basada en filtros) consiste en ir transformando un flujo de datos en un proceso comprendido por varias fases secuenciales, siendo la entrada de cada una la salida de la anterior.
Esta arquitectura es muy común en el desarrollo de programas para el intérprete de comandos, ya que se pueden concatenar comandos fácilmente con tuberías (pipe).
También es una arquitectura muy natural en el paradigma de programación funcional, ya que equivale a la composición de funciones matemáticas.



Ley de Amdahl


El aumento de rendimiento que puede obtenerse al mejorar alguna parte de una computadora puede calcularse utilizando la Ley de Amdahl. 
La Ley de Amdahl establece que la mejora obtenida en el rendimiento al utilizar algún modo de ejecución más rápido está limitada por la fracción de tiempo que se pueda utilizar ese modo más rápido. 
La Ley de Amdahl define la ganancia de rendimiento o aceleración (speedup) que puede lograrse al utilizar una característica particular. 

La aceleración nos indica la rapidez con que se realizará una tarea utilizando una máquina con la mejora con respecto a la máquina original. La Ley de Amdahl nos da una forma rápida de calcular la aceleración, que depende de dos factores:

1. La fracción del tiempo de cálculo de la máquina original que pueda utilizarse para aprovechar la mejora. Por el ejemplo, si 20 segundos del tiempo de ejecución puede utilizar la mejora de un programa que toma 60 segundos en total, la fracción es 20 /60. Este valor, que se llama Fracción mejorada, es siempre menor o igual que 1.

2. La optimización lograda por el modo de ejecución mejorado; es decir, cuánto más rápido con la que se ejecutaría la tarea si solamente se utilizase el modo mejorado. Este valor es el tiempo del modo original con respecto al tiempo del modo mejorado. Si el modo mejorado toma 2 segundos para alguna porción de programa que puede usar el modo completamente mientras que el modo original tomaba 5 segundos para la misma porción de programa, la mejora es 5/2. Este valor es siempre mayor que 1 y se llama Aceleración mejorada.

El tiempo de ejecución utilizando la máquina original con el modo mejorado será el tiempo empleado utilizando la parte no mejorada de la máquina más el tiempo empleado utilizando la parte mejorada.

Ley de Gustafson


La ley de Gustafson (también conocida como ley de Gustafson-Barsis)1 es una ley en ciencia de la computación que establece que cualquier problema suficientemente grande puede ser eficientemente paralelizado. La ley de Gustafson está muy ligada a la Ley de Amdahl, que pone límite a la aceleración que se puede obtener gracias a la paralelización, dado un conjunto de datos de tamaño fijo, ofreciendo así una visión pesimista del procesamiento paralelo. Por el contrario la ley de Gustafson ofrece un nuevo punto de vista y así una visión positiva de las ventajas del procesamiento paralelo. John L. Gustafson enunció por primera vez la ley que lleva su nombre en 1988.

La ley de Gustafson aborda las limitaciones de la Ley de Amdahl, la cual no escala la disponibilidad del poder de cómputo a medida que el número de máquinas aumenta. La ley de Gustafson propone que los programadores establezcan el tamaño de los problemas para utilizar el equipamiento disponible en su solución en un tiempo práctico. Por consiguiente, si existe equipamiento más rápido disponible, mayores problemas se pondrán resolver en el mismo tiempo.

La Ley de Amdahl se basa en una carga de trabajo o tamaño de entrada prefijados. Esto implica que la parte secuencial de un programa no cambia con respecto al número de procesadores de la máquina, sin embargo, la parte paralelizable es uniformemente distribuida en el número de procesadores. El impacto de la ley de Gustafson fue el cambio de dirección de los objetivos de investigación hacia la selección o reformulación de problemas a fin de que fuera posible la solución de mayores problemas en el mismo intervalo de tiempo. En particular la ley redefine la eficiencia como una necesidad para minimizar la parte secuencial de un programa, incluso si esto incrementa la cantidad total de cálculos


Referencias
http://www.infor.uva.es/~bastida/Arquitecturas%20Avanzadas/General.pdf
https://es.wikipedia.org/wiki/Ley_de_Gustafson
http://mixteco.utm.mx/~merg/AC/2009/2.7-principios_cuantitativos.h ml


martes, 25 de agosto de 2015

Programación android con python



PROGRAMACION ANDROID CON PYTHON

Android es un sistema operativo inicialmente pensado para teléfonos móviles, al igual que iOS, Symbian y Blackberry OS. Lo que lo hace diferente es que está basado en Linux, un núcleo de sistema operativo libre, gratuito y multiplataforma.


QPython es un motor de secuencias de comandos que se ejecutan en los dispositivos Android. Permite correr proyectos y scripts python en nuestros dispositivos Android. Contiene un intérprete Python, consola, un editor, y la librería SL4A para Android. Es Python corriendo en Android!

Ofrece un kit de desarrollo que permite desarrollar fácilmente proyectos y scripts de Python en los dispositivos Android.

Características principales:
Soporta programación Python en Android incluyendo aplicaciones web, juegos y programación SL4A.
Ejecutar Scripts de Python y Proyectos en dispositivos Android.
Se puede ejecutar código Python y archivos de QRCode.
QEdit le permite crear/editar los scripts de Python y Proyectos fácilmente.
incluye muchas librerías útiles de Python.


Programacion android con Python
Primero tendremos que descargar el SDK de android en el siguiente link: http://developer.android.com/sdk/index.html


mi recomendación es crear una carpeta en nuestra unidad C: que se llame android y dentro instalar nuestro SDK,una vez instalado vamos a crear nuestro android emulado, por lo que vamos a ejecutar nuestro SDK para poder instalar las APIS necesarias y ejecutamos sdk.exe y instalaremos por ejemplo las de la 3.0


  • le damos a install packages y después aceptamos la licencia y le damos a install.
una vez instaladas las apis nos vamos a crear nuestro emulador y ejecutamos avd.exe.
Le pulamos en new para crear un nuevo emulador y escogemos la versión que nos hemos descargado antes en este caso la 3.0 y lo demás lo podemos dejar así, creo que no es necesario decir nada mas en este punto, lo demás es intuitivo, como por ejemplo escoger el tipo de dispositivo que queremos utilizar...

device: tipo de dispositivo

target:versión del dispositivo

cpu/abi: tipo de cpu(la que mas les convenga)

memori ram: ram para el dispositvo (recomendaria entre 250 y 500)

internal storage: la memoria interna del dispositivo(se puede dejar así)

sd card: memoria de la sd(recomendaría entre 1000 y 1500 MIB)

  • una vez escogido como lo queremos pulsamos ok y esperamos que se cree, después lo seleccionamos y le damos a start y se nos abrirá otra ventana en la que seleccionamos scale display to real size para seleccionar el tamaño de nuestra pantalla del dispositivo y ponemos en screen size 7 que es un buen tamaño y pulsamos oky esperamos que se inicie

  • una vez arrancado nos dirigiremos a nuestro navegador y nos pondremos a instalar sl4a de android poniendo en google sl4a accediendo a la direccion que pone en la imagen


  • una vez dentro nos descargamos el archivo sl4a_r6 para la instalación del programa
Cuando se descargue lo instalamos y procedemos a descargar python para android poniendo en google python for android y accediendo al enlace descargamos el archivo llamado pythonforandroid_r5 y lo instalamos
  • una vez instalado accedemos a el programa python for android y pulsamos en browse modules y nos llevara a una pagina web donde descargaremos el archivo pytbluez y seguidamente volveremos a entrar en python for android y le daremos a import modules e importaremos este modulo descargado, después pulsaremos en la parte de arriba instal

  • una vez hecho todo esto crearemos en nuestro escritorio una carpeta y la llamaremos android o python for android

  • Descargamos el archivo python_extra_r14 en nuestro pc desde la pagina de andtes de python for android y lo extraemos, después accedemos a la carpeta idlelib y todo lo que contenga lo copiamos a la carpeta de nuestro escritorio android, no copiaremos la carpeta si no todo lo de dentro, lo seleccionamos todo, copiamos y pegamos en la carpeta del escritorio, también el archivo android.py de la carpeta anterior.

  • Despues nos vamos a C:/WINDOWS/system32 y buscamos el archivo llamado cmd.exe y le damos a enviar a escritorio(acceso directo)

  • Cuando este en el escritorio lo cortamos y lo pegamos en nuestra carpeta android, una vez dentro pulsamos en nuestro acceso directo cmd.exe y le damos botón derecho y propiedades y modificamos donde dice iniciar en y ponemos la ruta de nuestra carpeta copiando la ruta de donde dice dirección en nuestra carpeta pegándola donde dice iniciar en

  • Despues copiamos el archivo adb.exe y adbwinapi.dll de la carpeta de donde instalamos el sdk en C:\Android\platform-tools copiamos estos dos archivos y los pegamos en C:\WINDOWS\system32 

  • Ya lo tenemos todo preparado para empezar y abrimos nuestro sl4a en el emulador, una vez dentro de sl4a pulsamos en el botón menú y después en VIEW el la ventana que se abre abajo

  • Despues en interpreters, y volvemos a darle en el botón menú y pulsamos start server y pulsamos private y accedemos a ver que dirección va a usar para comunicarse con el pc

Ahora nos dirigimos a la carpeta que creamos en nuestro escritorio y ejecutamos el cmd.exe y ejecutamos lo siguiente:

1-adb forward tcp:9999 tcp:(direccion dispositivo android)
2-set AP_PORT=9999
3-idle.bat

se nos abrirá el idle de python y le damos a file y new windows y ya podemos empezar a escribir en nuestro idle de python y ver los resultados en nuestro emulador, por ejemplo veamos el típico mensaje de hola mundo poniendo lo siguiente:

import android
droid = android.Android()
droid.makeToast("hola mundo")









Programación Google App Engine con Python



Google App Engine o también conocido más comúnmente como GAE o App Engine nos abre la infraestructura de producción de Google de forma gratuita como plataforma de desarrollo y hospedaje de aplicaciones web.

El servicio fue lanzado el 7 de abril del 2008 como un servicio de cloud pero a diferencia de otros servicios en la nube como Amazon Web Services o Azure Services Platform de Microsoft, el servicio ofrecido por Google es un servicio de Plataforma como Servicio y no de Infraestructura como Servicio.



Características

GAE soporta de manera oficial los lenguajes de programación Python y Java de manera estable y en modo de beta testing en lenguaje de programación Go creado por ellos mismos. Al soportar Java, es posible además utilizar cualquier lenguaje JVM o lo que es lo mismo, cualquier lenguaje que pueda ejecutarse sobre una máquina virtual de Java, aunque eso si, con serias limitaciones. Entre dichos lenguajes se encuentran:

· Groovy

· JRuby

· Scala

· PHP

· Clojure

· Perl

GAE soporta varios frameworks bajo Python como CherryPy, Pylons, Flask y Django 0.96 y 1.2. Además la misma Google ha desarrrollado un framework propio llamado —viva la originalidad que les caracteriza— webapp para aplicaciones web que van mejorando y actualizando. También existe un framework desarrollado específicamente para GAE y siguiendo —supuestamente— la filosofía de Django llamado GAE framework.



Restricciones

· Las aplicaciones solo tienen permisos de lectura a los archivos del sistema de archivos. Para almacenar datos y archivos en modo lectura y escritura es necesario utilizar un sistema de archivos virtual sobre el DataStore.

· Solo se puede ejecutar código a través de consultas HTTP

· Las aplicaciones Java solo pueden usar el conjunto considerado seguro de clases del JREestándar. ( Comprueba el Listado de clases)

· Las aplicaciones no pueden crear nuevos hilos de ejecución

· Los usuarios de Python pueden subir módulos para su uso en la plataforma pero no aquellos que están completamente desarrollados en C o Pyrex

· El soporte para SSL solo está disponible par dominios *.appspot.com

· Un proceso iniciado en el servicio para responder a una consulta no puede durar más de treinta segundos

· No soporta sesiones persistentes, solo sesiones replicadas a las que además se les aplican ciertos límites.

· No se pueden abrir sockets, por lo tanto, no se puede usar Twisted



Introduccion con python

App Engine se ejecuta el código de aplicación Python usando un intérprete de pre-cargado de Python en un ambiente seguro "espacio aislado". Su aplicación recibe peticiones web, realiza un trabajo, y envía las respuestas mediante la interacción con este entorno.

Una aplicación web de Python interactúa con el servidor Web App Engine mediante el protocolo WSGI, por lo que las aplicaciones pueden utilizar cualquier framework de aplicaciones web compatibles con WSGI. App Engine incluye un marco de aplicación web sencilla, llamada webapp2, para hacer más fácil para empezar. Para aplicaciones más grandes, los marcos de terceros maduros, como Django, trabajar bien con App Engine.

El intérprete de Python puede ejecutar cualquier código Python, incluyendo módulos de Python que usted incluya con su solicitud, así como la biblioteca estándar de Python. El intérprete no puede cargar módulos de Python con el código C; se trata de un entorno de Python "puro".

El entorno de "sandbox" asegurado aísla su solicitud de servicio y seguridad. Asegura que las aplicaciones sólo pueden realizar acciones que no interfieren con el rendimiento y la escalabilidad de otras aplicaciones. Por ejemplo, una aplicación no puede escribir datos en el sistema de archivos local o realizar conexiones de red arbitrarias. En su lugar, las aplicaciones utilizan los servicios escalables proporcionadas por App Engine para almacenar datos y comunicarse a través de Internet. El intérprete de Python lanza una excepción cuando una aplicación intenta importar un módulo de la biblioteca estándar conocido para no trabajar dentro de las restricciones de entorno limitado.

La plataforma App Engine proporciona muchos servicios que su código puede llamar. Su aplicación también puede configurar tareas programadas que se ejecutan a intervalos especificados.

Selección del tiempo de ejecución de Python

App Engine sabe utilizar el entorno de ejecución de Python para el código de aplicación cuando se utiliza la herramienta llamadaappcfg.py desde el SDK de Python con un archivo de configuración llamado app.yaml

Se especifica el runtime los elementos de app.yaml Para utilizar Python 2.7, añada lo siguiente a app.yaml


runtime: python27


api_version: 1
threadsafe: true
...

Bibliotecas personalizadas en Python 2.7
Adición de Bibliotecas de terceros Python
El SDK y herramientas Python



El primer elemento, runtime selecciona el entorno de ejecución de Python.

El segundo elemento, api_version selecciona la versión del entorno de ejecución de Python para usar. Al escribir estas líneas, App Engine sólo tiene una versión del entorno de Python, 1 Si el equipo de App Engine nunca necesita liberar los cambios en el medio ambiente que pueden no ser compatibles con el código existente, lo harán con un nuevo identificador de versión. Su aplicación va a seguir utilizando la versión seleccionada hasta que cambie la api_version configuración y cargar su aplicación.

En el tiempo de ejecución de Python 2.7, los siguientes módulos han sido reemplazados o personalizada:

· tempfile está desactivado, a excepción de TemporaryFile que es un alias para StringIO.

· el registro está disponible y su uso es muy aconsejable! Ver registro.

Además de la biblioteca estándar de Python y las bibliotecas de App Engine, el tiempo de ejecución de Python 2.7 incluye variasbibliotecas de terceros.

Puede incluir terceros bibliotecas Python partido con su aplicación, poniendo el código en el directorio de la aplicación. Si comete un enlace simbólico al directorio de un módulo en el directorio de la aplicación, appcfg.py seguirá el enlace para insertar el módulo en su aplicación.

El módulo de Python incluye ruta incluye directorio raíz de la aplicación (el directorio que contiene el app.yaml archivo). Los módulos que se crean en el directorio raíz de la aplicación están disponibles con una ruta desde la raíz. No te olvides de crear __init__.pyarchivos en subdirectorios, así que Python reconocerá los subdirectorios como paquetes.

La App Engine Python SDK incluye herramientas para probar la aplicación, la posibilidad de subir sus archivos de la aplicación, la gestión de los índices del almacén de datos, la descarga de datos de registro, y la posibilidad de subir grandes cantidades de datos para el almacén de datos.

El servidor de desarrollo se ejecuta la aplicación en el equipo local para probar la aplicación. El servidor simula el almacén de datos de App Engine, servicios y restricciones sandbox. El servidor de desarrollo también puede generar la configuración del almacén de datos para los índices basados ​​en las consultas de la aplicación realiza durante la prueba.

Una herramienta multipropósito llamado appcfg.py maneja toda la interacción de línea de comandos con la aplicación que se ejecuta en App Engine. appcfg.py puede subir su aplicación en App Engine, o simplemente actualizar la configuración del índice de almacén de datos para que pueda construir nuevos índices antes de actualizar el código. También puede descargar los datos del registro de la aplicación, por lo que puede analizar el rendimiento de su aplicación utilizando sus propias herramientas.

REFERENCIAS
https://cloud.google.com/appengine/docs/python/

http://www.genbetadev.com/programacion-en-la-nube/introduccion-a-google-app-engine

http://www.genbetadev.com/programacion-en-la-nube/nuestra-primera-aplicacion-con-google-app-engine-python


lunes, 17 de agosto de 2015

Programación Web con Python


Aplicación Web con Python

Configuración del servidor Web

WebPy, a diferencia de otros frameworks, no posee un servidor de aplicaciones potente propio, y por ello, es mejor apoyarse en uno que ya esté funcionando. Entre los posibles candidatos se encuentran Apache, Lighttpd y nginx. Para este artículo he optado por Apache, dada su gran popularidad.

Una vez instalado Apache en nuestra máquina, es necesario agregar el módulo mod_wsgi, que permite hacer uso de Apache como servidor para aplicaciones escritas en Python. Este proyecto está alojado en: http://code.google.com/p/modwsgi

Una vez descargado, si estamos usando Windows, renombrar el archivo a mod_wsgi.so y copiarlo al directorio modules de Apache. En el caso de Linux, compilar el módulomod_wsgi (consultar: http://code.google.com/p/modwsgi/wiki/QuickInstallationGuide)

Una vez instalado el módulo, hay que configurar Apache para que reconozca dicho módulo. Para ello, editar el archivo httpd.conf (en el directorio conf de Apache), y agregar la siguiente línea en la misma parte en que Apache utiliza otras cargas LoadModule:

LoadModule wsgi_module modules/mod_wsgi.so

Al arrancar Apache desde la terminal debería dar un mensaje similar a éste:

Apache/2.2.2 (Unix) mod_wsgi/1.0 Python/2.3 configured

Si se lanzó desde Windows, el Apache Service Monitor, debería dar el mensaje en la parte inferior:





Instalación de WebPy

Hay varias maneras de instalar WebPy (consultar http://webpy.org/download).

Se puede descargar directamente la última versión desde la siguiente URL (consultarhttp://webpy.org/download para conocer cuál es la última versión):

http://webpy.org/static/web.py-0.34.tar.gz

También se puede descargar desde el repositorio en github:

http://github.com/webpy/webpy

Una vez descargado, descomprimir el archivo tar.gz, y ejecutar la siguiente sentencia para instalarlo como librería en Python:

python setup.py install


Primera aplicación Web

Para ilustrar la sencillez de desarrollo de una página Web con WebPy, vamos a crear la típica aplicación “Hola, Mundo”.

import web

urls = (
'/', 'index'
)

app = web.application(urls, globals())

class index:
def GET(self):
return "Hola, Mundo"

if __name__ == "__main__":
app.run()


La variable urls es una tupla que contiene pares de direccionamientos URL y nombres de clase. En este ejemplo, el direccionamiento “/” (root), estará asociado a la clase index. Se pueden definir tantos pares como sean necesarios para la aplicación Web.

El objeto app contendrá la definición de la aplicación Web. En este ejemplo se asocian las URL’s de la aplicación a namespace global.

La clase index contiene un método GET, el cual se lanzará cuando se invoque a la página, pudiendo recibir parámetros. En su interior, retornará el literal “Hola, Mundo”, el cual se imprimirá en el navegador. Existe también un método POST, que funciona como GET, pero ofuscando los parámetros. Estos dos métodos son los medios habituales de invocar a una página Web pasando (o no) parámetros.

Por último, las dos últimas líneas indican a WebPy que comience a servir páginas web con la configuración indicada.

Una vez se ejecuta este programa, el intérprete de Python se queda en modo de espera. El servicio Web está en marcha, esperando peticiones. Para probarlo, abrimos un navegador web e introducimos la URL:

http://localhost:8080

Debería aparecer nuestro bien conocido mensaje “Hola, Mundo”.


Parámetros y HTML

En una aplicación Web introduciremos elementos HTML para formatear el aspecto de las páginas. Además, añadiremos dinamismo permitiendo que las páginas muestren datos parametrizados (por ejemplo, recogidos de un formulario, o capturados de una base de datos).

Vamos a añadir más funcionalidad a nuestra aplicación anterior:

import web

urls = (
'/hola', 'Saludo'
)

app = web.application(urls, globals())

class Saludo:
def GET(self):
data = web.input()
return """
<html>
<head></head>
<body background='#AAAAFF'>
<h1>Hola, %s %s %s</h1>
</body>
</html>""" % (data.nombre, data.apellido1, data.apellido2)

if __name__ == "__main__":
app.run()

El primer cambio lo hemos realizado en la sección de urls, donde ahora, el mapeo a la página Web será el siguiente:

http://localhost:8080/hola

Cuando se apunta a /hola, se invocará a la clase Saludo, concretamente a su método GET, en donde hemos agregado varios cambios. El primero de ellos ha sido definir una variabledata, la cual recogerá los parámetros que se pasen por URL, lo que se consigue mediante la función input() del módulo web. Estos parámetros se recogerán en formato de diccionario, y son pares de parámetro y valor.

A la hora de retornar la salida, se retornará HTML, en donde hemos añadido un mensaje con formato de título (<h1>), un saludo con nombre y apellidos (extraídos de los parámetros pasados), los cuales se formatean mediante %s, e indicando después qué parámetros extraer.

Para invocar a la nueva página se pasan los parámetros en la misma URL, tal y como haría una llamada desde un formulario:

http://localhost:8080/hola?nombre=Carmen&apellido1=Martinez&apellido2=Salguero

El resultado es el siguiente:





Referencias

https://librosweb.es/libro/python/capitulo_13/python_bajo_apache.html

http://rafinguer.blogspot.mx/2010/10/aplicaciones-web-sencillas-con-python.html





Programación Gui en Python con Tkinter


GUI EN PYTHON

Python es un lenguaje de programación orientado a objetos de programación utilizado por muchos programadores para el desarrollo de software. El código de Python es fácil de mantener y relativamente sencillo de aprender.

Entre muchas características que hacen de Python un gran lenguaje de programación las principales son:
  • Alto nivel - Ya que su sintaxis es sencilla, lo hace un gran lenguaje para aprender a programar por primera vez. A su vez facilita el desarrollo de aplicaciones, ya que acorta el número de líneas de código a desarrollar con respecto a otros lenguajes de programación. 
  • Multipropósito - Puede ser usado para desarrollar tanto scripts sencillos como para desarrollar sitios web dinámicos. 
  • Posee una gran librería pre-instalada de apoyo - Cabe la posibilidad que dentro de la librería ya estén desarrolladas muchas de las cosas comunes que quieras hacer, así nos evitamos programar un módulo desde cero.
Antes de que puedas empezar a programarlo en tu computadora con Windows, tendrás que instalar el intérprete de Python.

Windows

Descarguemos desde python.org/releases la versión ‘Windows X86-64 MSI Installer’ (Última versión estable de Python 2 para Windows hasta la fecha del tutorial). Una vez descargado, hacemos doble-click en el instalador y aceptamos todas la condiciones del instalador, no hay que preocuparnos por configuraciones avanzadas, el instalador es sencillo de usar. Una vez finalizada la instalación, ya deberíamos tener Python corriendo en nuestro sistema.

Una vez instalado, nos vamos a encontrar con tres maneras de usar Python:

Python Shell - la consola de Python, la cual nos permite ejecutar comandos línea por línea.

IDLE GUI - una aplicación que nos permite escribir scripts más complejos para luego ejecutarlos de manera sencilla.

Editor de texto - cualquier editor de texto que corra en tu sistema operativo te permitirá escribir un script. Luego lo guardarás con la extensión .py y lo ejecutarás desde el Shell.

PROGRAMA CON LA BIBLIOTECA TKINTER EN PYTHON

Primero, debemos importar los componentes de la librería TkInter, para poder tenerlos disponible

from Tkinter import *

Luego creamos la ventana principal de nuestra aplicación. Frame es uno de los componentes que nos proporciona TkInter y es una ventana (la ventana principal de la aplicación)

frame = Frame()

Para el campo de texto usaremos el componente Entry de Python. Este componente permite meter o visualizar una línea de texto simple. Para múltiples líneas debemos usar Text.

Cuando creemos nuestro campo de texto, necesitamos crear una variable de tipo StringVar. Esta variable simplemente contiene dentro una cadena de texto y le diremos a nuestro campo de texto que coja y deje el texto dentro de esa variable. La forma de hacer esto es sencilla


v = StringVar()

campoTexto = Entry (frame, textvariable=v)

Con esto hemos creado la variable v de tipo StringVar y luego hemos creado el campoTexto de tipo Entry. Los parámetros son el frame donde queremos que vaya este campo de texto y con textvariable=v indicamos cual es la StringVar donde queremos que deje el texto escrito por el usuario o en el que queremos dejar nosotros el texto que se muestre.

Los métodos v.get() y v.set() nos permitirán obtener o fijar este texto.

Para el botón, usaremos el componente Button de Python.

boton = Button(frame, text="hola", command=funcion)

donde frame es la ventana en la que queremos que esté el botón, text="hola" es el texto que queremos que presente el botón y command=funcion es la función que queremos que se ejecute cuando pulsemos el botón. Por supuesto, debemos tener creada previamente una función de nombre función (), así que antes de crear el botón, debemos definir la función

def función ():

v.set ("Hola")


Esta función simplemente pone "Hola" dentro del StringVar que asociamos previamente al campo de texto Entry. Cuando se ejecute esta función, se meterá dentro de v un texto "Hola" y este se mostrará en el campo Entry de la ventana.

--------------------------------------Código Completo en Python -------------------------------------------------

from Tkinter import *

def funcion():

v.set("Hola")

frame = Frame()

button=Button(frame, text="hola", command=funcion)

button.pack(side=LEFT)

v = StringVar()

text = Entry(frame, textvariable=v )

text.pack(side=LEFT);

frame.pack()

frame.mainloop()


--------------------------------------------------------------------------------------------------------------------------

Para cada widget creado (Button, Entry y Frame) necesitamos llamar a su método pack() para que coja las dimensiones adecuadas y se coloque en su sitio dentro de la ventana. Podemos o no poner parámetros a esta llamada, para dejar las opciones por defecto o decidir nosotros la localización. En el ejemplo, hemos puesto side=LEFT para que el botón y el campo de texto aparezcan alineados en horizontal.

Una vez terminado el programa, para siga activo y la ventana funcionando, debemos meternos en el bucle principal de tratamiento de eventos de frame. Es decir, hacemos la llamada a frame.mainloop(). Si no lo hacemos así, el programa termina inmediatamente y no veremos nada (salvo que escribamos línea a línea en el intérprete de python). Esta llamada lo único que tiene dentro es un bucle infinito, en el que va recogiendo los eventos de teclado o ratón para "despacharlos" a los componentes de la ventana y que estos puedan tratarlos, por ejemplo, el click sobre el botón.

Referencias

https://es.wikibooks.org/wiki/Interfaz_gr%C3%A1fica_con_Tkinter/Introduccion/Acerca_de_Tk


https://underc0de.org/foro/python/curso-introductorio-a-python-con-interfaces-graficas-tk/


http://codehero.co/python-desde-cero-instalacion-y-configuracion/

miércoles, 12 de agosto de 2015

Metodos de Ordenacion Practica #1

#Jaqueline Ventura Salinas
#Programacion Paralela
#MetodoS de Ordenación

def Burbuja(lista,tam):
    for i in range(1,tam):
        for j in range(0,tam-i):
            if(lista[j] > lista[j+1]):
                k = lista[j+1]
                lista[j+1] = lista[j]
                lista[j] = k
def selectionsort(lista,tam):
    for i in range(0,tam-1):
        min=i
        for j in range(i+1,tam):
            if lista[min] > lista[j]:
                min=j
        aux=lista[min]
        lista[min]=lista[i]
        lista[i]=aux
               
def insercionDirecta(lista,tam):
    for i in range(1,tam):
        v=lista[i]
        j=i-1
        while j >= 0 and lista[j] > v:
            lista[j+1] = lista[j]
            j=j-1
        lista[j+1]=v
       


def quicksort(lista,izq,der):
    i=izq
    j=der
    x=lista[(izq + der)/2]

    while( i <= j ):
        while lista[i]<x and j<=der:
            i=i+1
        while x<lista[j] and j>izq:
            j=j-1
        if i<=j:
            aux = lista[i]; lista[i] = lista[j]; lista[j] = aux;
            i=i+1;  j=j-1;

        if izq < j:
            quicksort( lista, izq, j );
    if i < der:
        quicksort( lista, i, der );

def mergeSort(lista):
    print("Splitting ",lista)
    if len(lista)>1:
        mid = len(lista)//2
        lefthalf = lista[:mid]
        righthalf = lista[mid:]

        mergeSort(lefthalf)
        mergeSort(righthalf)

        i=0
        j=0
        k=0
        while i < len(lefthalf) and j < len(righthalf):
            if lefthalf[i] < righthalf[j]:
                lista[k]=lefthalf[i]
                i=i+1
            else:
                lista[k]=righthalf[j]
                j=j+1
            k=k+1

        while i < len(lefthalf):
            lista[k]=lefthalf[i]
            i=i+1
            k=k+1

        while j < len(righthalf):
            lista[k]=righthalf[j]
            j=j+1
            k=k+1
    print("Merging ",lista)




       
def imprimeLista(lista,tam):
    for i in range(0,tam):
        print lista[i]

def leeLista():
    lista=[]
    cn=int(raw_input("Cantidad de numeros a ingresar: "))

    for i in range(0,cn):
        lista.append(int(raw_input("Ingrese numero %d : " % i)))
    return lista



A=leeLista()
print "Metodo Burbuja"
Burbuja(A,len(A))
imprimeLista(A,len(A))
print "Metodo Selección"
selectionsort(A,len(A))
imprimeLista(A,len(A))
print "Metodo Inserción"
insercionDirecta(A,len(A))
imprimeLista(A,len(A))
print "Metodo Quick sort"
quicksort(A,0,len(A)-1)
imprimeLista(A,len(A))
print "Metodo Merge sort"
mergeSort(A)
print(A)


# basado en :
#https://saforas.wordpress.com/2011/01/24/metodos-de-ordenamiento-hechos-en-python/
#http://ict.udlap.mx/people/ingrid/Clases/IS211/Ordenar.html