Mostrando entradas con la etiqueta python. Mostrar todas las entradas
Mostrando entradas con la etiqueta python. Mostrar todas las entradas

domingo, 4 de junio de 2017

Problema al crear una carpeta src en un proyecto con PyDev

Hace poco tiempo tuve un problema bastante tonto, y me costo un poco resolverlo, así que decidí realizar esta entrada a modo de nota mental, para que si en un futuro cercano (o lejano), me ocurre nuevamente, recordar como fue la solución. 

Siempre, por usos y costumbres suelo generar una carpeta /src dentro de mis proyectos. De forma tal que el árbol del proyecto quedaría mas o menos así.. 


El tema, surgió, porque al momento de crear el proyecto con PyDev, no seleccione el checkbox que dice "Create src folder and add to PYTHONPATH".


Es por ese motivo, que las carpetas base de datos, dialogs, forms, etc.. no las gráfica como si fueran paquetes, y es también por ese motivo, que si yo dentro de un archivo .py quiero hacer un import del tipo:

from base_de_datos.conexion import conexion 

No me lo va a permitir, ya que el interprete no relaciona la carpeta  base_de_datos con un paquete importable, por mas que dentro hayamos puesto el archivo __init__.py. 

La forma de solucionar este problema, si no tuvimos la precaución de hacer de entrada el check en el checkbox arriba expuesto, es haciendo click derecho sobre el proyecto, luego abrir Properties
 
 

Vamos al menú. PyDev -> PYTHONPATH y apretamos el boton "Add Source Folder"


Seleccionamos la carpeta src, que se encuentra dentro del proyecto, y luego apretamos OK.


A continuación removemos la carpeta que aparecía por defecto como /$/PROJECT_DIR_NAME, seleccionándola y apretando sobre Remove.


Luego apretamos OK, y hacemos un Refresh sobre el proyecto. 


y a continuación veremos el proyecto de la siguiente manera: 

y ya estaremos en condiciones de realizar los imports que deseemos. 

Espero a alguien le sirva esta simple información. No se si sera un problema recurrente o no, pero como nota mental, al menos a mi me va a servir seguro.. :) 


sábado, 10 de noviembre de 2012

Framework Python

Bueno lo prometido es deuda.. :)..

Así que pasare a mostrar mi framework.

Básicamente es un framework que sirve para hacer aplicaciones de escritorio utilizando Python, hace uso de un ORM que es SqlAlchemy y para la parte de interfaz gráfica utiliza PyQT... Cabe aclararar que esta es una primera aproximacion a lo que realmente estoy buscando... por lo cual tiene varias cosas que pulir, y el que quiera colaborar puede hacerlo.. :)..

Por ahora tiene soporte solo para las Bases de Datos:

  • SQLite
  • MySQL
Pero es fecalmente extensible a PostgreSQL.

Es importante como dije en el vídeo seguir ciertas convensiones, la principal es que el nombre del archivo con el cual se guarda el Form, sea igual al nombre del objeto form.. :). el resto practica mente queda a gusto del usuario..

En cuanto a la definición del modelo, hay unas pocas palabras reservadas por el momento:

  • tabla:  # Especifica que se debe crear una nueva tabla, con el nombre que sigue a continuación de los dos puntos
  • campo: # Especifica el nombre del campo y su tipo.
  • ucamp: # Especifica que es el ultimo campo de la tabla.
Tener en cuentas que tabla, campo y ucamp SI O SI deben estar seguidas de dos puntos ":"

En cuanto a los tipos de datos tenemos:

  • entero: Tipo de dato entero. :)
  • cadena: Tipo de dato String. Debe seguir a continuación la longitud de la cadena, en caso que no se especifique la longitud, se toma por defecto 50 caracteres.
  • real. Tipo de dato Real.
Para comprender un poco mas el uso del Framework, recomiendo ver estos dos videitos, que espero se entiendan.. :).. Si no lo logran ver bien, ponganlo en pantalla completa y mejorenle la calidad a 480p y lo verán perfectamente.

Video 1

Video 2

Para descargar el Ejecutable para Windows, pueden hacerlo desde el siguiente Link:

Descargar PyFrame

Espero que les guste, y que les sirva.. Cualquier comentario o sugerencia sera bienvenido..

Saludos y hasta la próxima.. 

sábado, 28 de julio de 2012

Metodos Estaticos (Python)

Los metodos estaticos son aquellos metodos que se pueden ejecutar aun cuando la clase no se a instanciado.

Es decir no es necesario hacer:

p = Persona()

para llamar por ejemplo al metodo obtenerTodas

se podria hacer simplemente

personas = Persona.obtenerTodas()

Veamos un ejemplo como para que quede todo mas claro.

class Persona(object): 
    nombre = "sin nombre" 
     
    def __init__(self): 
        self.nombre = "con nombre" 
     
    def getNombre(self): 
        return self.nombre

Para poder trabajar con esta clase, lo primero que habria que hacer es instanciarla.

p = Persona()
print p.getNombre()

lo cual mostraria el mensaje "con nombre" ya que al hacer Persona(), lo que hace es llamar al constructor de la clase persona, que a su vez le da el valor "con nombre" al atributo nombre.

La forma de declarar un metodo como estatico es la siguiente:

class Persona(object): 
    nombre = "sin nombre"

    def __init__(self): 
        self.nombre = "con nombre" 

    @staticmethod     
    def getNombreStatic(self): 
        return self.nombre

    @classmethod
    def getNombreClass(self): 
        return self.nombr

La diferencia, entre el método estático y el método de clase en Python, es que mientras el método estático no recibe por defecto ningún parámetro, el método de clase recibe como primer argumento el objeto classtype, esto es, la referencia a la declaración de la clase.

# El método estático, recibiendo la clase, retorna True
print Persona.getNombreStatic(OtraClase) 
  
# Mientras que el método de clase ya recibe la clase, y retorna True
print Persona.getNombreClass()

En definitiva no hace falta instanciar la clase persona para utilizar el metodo getNombre.. :)

Espero les sirva!

lunes, 6 de febrero de 2012

Aplicaciones con Interfaz grafica Python (GUI)

Prácticamente cualquier aplicación comercial que quiera hacerse debe contar con tres patas fundamentales.

Lógica programática.
Interfaz grafica
Base de datos.

Hablando desde mi experiencia personal, les cuento que yo me recibí en la facultad como Licenciado en Informática sin haber escrito nunca un programa que contuviera estas tres patas completas. Por lo cual cuando llego la hora de ponerme a laburar, no me sentía completamente capacitado para hacer sistemas.
Cuando salí de la facultad era un muy buen programador de scripts, pero un pésimo Programador de aplicaciones de escritorio.

Si bien la lógica de un programa suele ser la parte más compleja, es la primera que se aprende y esta bien que así sea. Desde nuestros comienzos cuando estudiamos cualquier lenguaje de programación y escribimos nuestros primeros algoritmos ya estamos desarrollando la lógica computacional que puede servir para resolver problemas de casi cualquier índole. El problema surge cuando queremos tomar datos o mostrar los resultados en una pantalla que sea amigable para el usuario final.
Ahí es cuando entra la Interfaz Grafica de Usuario también conocida como GUI. El tema es que cuando comencé a programar utilizaba Pascal o C, los cuales tienen un soporte para generar interfaces grafica muy muy pobres, luego “evolucione” a Visual Basic y a Java pero así y todo no terminaba de convencerme la manera en que se manejaban estas cuestiones. Por suerte apareció PyQt en mi vida…. J
En lo referente a las Bases de datos, en un primer momento lo hacia en archivos de Texto plano en donde tenia que ocuparme de TOOOOOODAAAA la lógica, para asegurar la integridad de los datos, trabajo tedioso si los hay. Luego comencé a trabajar con bases de datos relacionales pero haciendo todo a mano. Y por ultimo descubrí la “magia” de los ORM… Seba esta Feliz.. J  

Comencemos a ver algunas cositas pequeñas.

Como creo que ya dije en alguna oportunidad hoy en día (Febrero de 2012) me encuentro programando en Python 2.6, y para lo que son las interfaces graficas utilizo PyQt GPL v4.4.3 for Python v2.6. Como en el ejemplo que presentare a continuación usaremos Sqlite les recomiendo bajarse el Sqlite Manager del siguiente enlace:


PyQT tiene la particularidad de que genera archivos XML que luego pueden compilarse para generar interfaces graficas que se puedan utilizar en varios lenguajes, entre los que se encuentran C y Python entre otros.

El ejemplo que haremos será sencillo, crear un formulario que acepte 3 campos, Nombre, Apellido y dirección y que tenga tres botones, uno para guardar los datos en la Base de datos, otro para resetear el formulario y otro para cerrar.



Abrimos el Designer de PyQT y generamos la siguiente pantalla… Es muy intuitivo para utilizar, así que no me pondré a explicar paso a paso como hacerla (Si tenes dudas comenta, pregunta, googlea y seguro que obtenes respuesta)



Renombramos el formulario en el editor de propiedades que aparece a la derecha.




Modificamos el titulo de la ventaja tocando la propiedad siguiente:




La convención que utilizo para los nombres de los botones es btn<Accion>.


Agregamos tres labels con los textos:

Nombre
Apellido
Direccion

A los labels a menos que sea completamente necesarios le dejo el nombre por defecto que le pone PyQt.

Agregamos tres controles de los denominados lineEdit y los nombramos txtNombre, txtApellido y txtDireccion.

La pantalla final queda de la siguiente manera:


La guardamos con el nombre FormCargarPersona.ui.

Vamos a agregar un evento a un botón desde el PyQt Designer. Primero vamos a Edit Signals/Slots



Oprimimos clic derecho sobre el botón cerrar y luego arrastramos y soltamos sobre el fondo del Form. Se mostrara algo similar a esto:



Y se nos abrirá la siguiente pantalla. Sobre la parte izquiera se observan las señales habilitadas que puede enviar el boton:

clicked(), clicked(bool), pressed(). Etc..


Seleccionamos clicked() y checkeamos donde aparece la leyenda Show signals and slots inherited form QWidget. Nos apareceran mas opciones:



Seleccionamos clicked() y close(), y le damos click al boton Aceptar.

Volvemos a la edición de widget común clickeando en Edit Widgets



Y probamos que todo ande como nosotros queremos. Con CTRL+R corremos el formulario, ahora si pinchamos sobre el botón cerrar el mismo debería cerrarse.

Guardamos y listo por ahora… :)

Si editamos el archivo ui con un editor de texto, veremos que es código puramente XML.
Para compilarlo a lo que

Para compilar el código XML a código Python se utiliza un compilador llamado Pyuic4 que se encuentra por lo general en el Path: C:\Python25\Lib\site-packages\PyQt4 dependiendo la versión de Python que tengamos instalada.

Abrimos una consola y nos paramos en el Path en donde guardamos el archivo FormCargarPersona.ui. En ese lugar ejecutamos el siguiente comando:

>pyuic4 –x FormCargarPersona.ui –o FormCargarPersona.py



Esto generara en la carpeta C:\Python25\Lib\site-packages\PyQt4> el archivo FormCargarPersona.py. Cabe aclarar que no es recomendable modificar este archivo auto-generado. No es recomendable modificarlo, ya que ante cualquier modificación en la interfaz grafica, deberemos volver a compilar el archivo ui y esta compilación pisara cualquier cambio que se haya realizado en dicho archivo.

Por ahora pondremos todo en una misma carpeta, pero luego es aconsejable utilizar algún árbol de directorios como puede llegar a ser el siguiente:

Por gusto personal cuando debo crear una aplicación utilizo el sistema árbol de directorios, no es mi estilo decir cual es la forma correcta de trabajar.. J.. para mi la forma correcta es la que nos queda cómoda y da resultados…



En la carpeta archivos, guardo archivos que genere con mi aplicación, archivos de Texto, reportes en PDF y demás cuestiones.

En la carpeta Base de datos guardo todo lo referente a la conexión con la Base de datos, la creación de tablas, y las Clases de negocio que luego serán las que mapeo por medio del ORM con las tablas propiamente dichas.

En la carpeta diálogos guardo los códigos fuentes de lo que vendría a ser el controlador de las vistas… Al trabajar con Qt es casi obligatorio usar el patrón de diseño MVC, donde las vistas son los formularios creados con Qt y los controladores serian los diálogos en donde se pone toda la funcionalidad.

En la carpeta form_ui, guardo los formularios sin que hayan sido compilados, solo para tener el resguardo de la última versión.

En la carpeta forms, pongo los formularios ya compilados.

En images pongo las imágenes que usare dentro de mi aplicación, tanto iconos usados en los botones, como imágenes de fondo, etc.

En la carpeta impresión suelo poner los códigos fuentes de los programas dedicados a realizar reportes en PDF que luego se imprimen desde el sistema.

Por ultimo en la carpeta útiles, pongo código genérico que puedo utilizar en varios programas, para aumentar la reusabildiad de código.



Veamos un ejemplo funcional de cómo se realizaría la escritura en una Base de datos sencilla.

Ya tenemos nuestro FormCargarPersona.py… Ahora creemos el resto de los archivos necesarios para hacer funcional nuestro programa.

#conexion.py

import sqlalchemy as sql
from PyQt4.QtGui import *
from sqlalchemy.orm import sessionmaker

class conexion():
   
    def __init__(self):
        self.my_db = sql.create_engine('sqlite:///personas')
        self.metadata  = sql.MetaData(self.my_db)
   
   
    def crearSession(self):
        Session = sessionmaker(bind=self.my_db)
        session = Session()
        return session

#creacionTablas.py

from sqlalchemy import Table, Column, Integer, String, MetaData, Sequence
from conexion import conexion
from sqlalchemy.orm import mapper

from Personas import Personas

class creacionTablas():
    def __init__(self):
        bd = conexion()
        metadata = MetaData()
        print 'Creacion de tablas'


        tabla_personas = Table('personas', metadata,
            Column('idPersona', Integer, Sequence('user_id_seq'), primary_key=True),
            Column('nombre', String(30)),
            Column('apellido', String(30)),
            Column('direccion', String(30))
        )

        metadata.create_all(bd.my_db)

        mapper(Personas,tabla_personas)





#Personas.py

class Personas(object):

    def __init__(self, nombre, apellido, direccion):
        self.nombre = nombre
        self.apellido = apellido
        self.direccion = direccion


#PrincipalPersona.py

import sys
import PyQt4
sys.path.append("..")

import creacionTablas
from PyQt4.QtGui import *
from PyQt4 import QtGui
from PyQt4 import QtCore

from dlgCargarPersonas import dlgCargarPersonas

if __name__ == "__main__":
    app = QtGui.QApplication(sys.argv)
    creacionTablas.creacionTablas()
    d = dlgCargarPersonas()
    d.exec_()


#dlgCargarPersonas.py

from PyQt4 import QtCore, QtGui
from FormCargarPersona import Ui_FormCargarPersona
from Personas import Personas
import conexion
import PyQt4
import sys

class dlgCargarPersonas(QtGui.QDialog):

    def __init__(self):
        QtGui.QDialog.__init__(self)
        self.ui = Ui_FormCargarPersona()
        self.ui.setupUi(self)
        conect = conexion.conexion()
        self.session = conect.crearSession()
        self.connect(self.ui.btnAceptar, QtCore.SIGNAL("clicked()"), self.prueba)
       
    def cargarPersona(self):
        if(self.ui.txtApellido.text() <> "" and
           self.ui.txtNombre.text() <> ""):
            nombre = str(self.ui.txtNombre.text())
            apellido = str(self.ui.txtApellido.text())
            direccion = str(self.ui.txtDireccion.text())
            persona = Personas(nombre, apellido, direccion)
            self.session.add(persona)
            self.session.commit()
   
Poniendo estos 5 archivos en una misma carpeta y ejecutando PrincipalPersona.py, debería poderse guardar personar en la base de datos. Para ver si efectivamente se guardaron los datos en la base de datos podemos usar el sqliteman, que ya descargamos previamente, abrimos la base de datos que se llama personas, que se encontrara en la misma carpeta en donde tenemos todos los fuentes, y hacemos un Select * from personas. 

ORM – Sqlalchemy (Bases de datos Python)

Desde ya hace un buen tiempo que trabajar con Bases de Datos dejo de ser algo tedioso y complicado, mucha de esta simplificación se la debemos a los ORM.

Los ORM básicamente sirven para realizar una conversión directa de objetos software a registros o tablas de una Base de datos relacional.

Supongamos que tenemos la clase Persona con los atributos, nombre, apellido y dirección.
Por otro lado deberíamos tener la tabla tPersona en la Base de datos, con los campos idPersona, apellido, nombre y dirección.

Antiguamente y a grandes razgos para guardar una persona en la Base de datos se tenia que escribir dentro del código fuente de nuestro programa, la sentencia sql que ejecutaba el insert. Así como también hacer el mapeo uno a uno de los atributos de la clase con los campos de la tabla. También se debía crear la conexión manualmente y los programas quedaban fuertemente acoplados con la Base de Datos utilizada. Es decir migrar un programa que usara MySql a uno que usara PostgreSql no era algo trivial.
Por esta razón el código quedaba “sucio” y su escalabilidad y mantenimiento se volvía complicado.

Los ORM sirven para subsanar estos inconvenientes, y hacer que el hecho de trabajar con Bases de datos relacionales sea algo mucho más llevadero.

Por ejemplo si quisiéramos escribir en la Base de datos una persona sin utilizar la potencia de un ORM, seria más o menos así...

(NO ESTA DE MAS ACLARAR QUE ESTE ES UN EJEMPLO ILUSTRATIVO Y NO FUNCIONAL…)

class Persona(object):

    def __init__(self, nombre, apellido, direccion):
        self.nombre = nombre
        self.apellido = apellido
        self.direccion = direccion

tablaPersona = Table('tPersona', self.metadata, autoload=True)

persona = Persona(“Seba”, “Bataglia”, “Dire seba”)

sentenciaSql = “Insert into tPersona (nombre, apellido, direccion) values(‘“ + persona.nombre + “’,’” + persona.apellido + “’,’”+persona.direccion+”’)”

ejecutarSql(sentenciaSql)

Ahora bien, si quisiéramos hacer lo mismo con un ORM bastaría con hacer algo así.

persona = Persona(“Seba”, “Bataglia”, “Dire seba”)
persona.Save()

Como puede observarse el código queda muchísimo más limpio. Y nos desligamos completamente de escribir Sql dentro de nuestro código fuente.

Esta es una muy muy breve introducción a lo que son los ORM. En la próxima entrega veremos como crear una aplicación con interfaz grafica por medio de PyQT y luego haremos una aplicación que sirva para persistir datos, bien basica. 

DICCIONARIOS PYTHON! [:-)]

**************************

Un diccionario es una estructura de datos que se caracteriza por realizar la indexación a sus datos por medio de una palabra o clave. En lugar de que el índice de la estructura sea un entero, en el diccionario la clave puede ser cualquier valor, un entero, un carácter o una palabra.

El formato típico de los diccionarios es el siguiente:

Diccionario = <clave, valor>

En donde la clave es el índice por el cual se accede al valor que le corresponde.

En Python se mantiene dicha nomenclatura para lo que son los diccionarios. En el siguiente ejemplo se puede observar como crear un diccionario en Python.

>>> dictPersona = {}
>>> dictPersona["nombre"] = "Pedro"
>>> dictPersona["apellido"] = "Andrade"
>>> dictPersona["dni"] = 31914936
>>> print dictPersona
{'nombre': 'Pedro', 'dni': 31914936, 'apellido': 'Andrade'}
>>> print dictPersona["nombre"]
Pedro

Los diccionarios son una estructura de datos fundamental cuando se quiere trabajar con Bases de Datos, ya que la mayoría de los ORM (Modelo Objeto-Relacional), utilizan listas de diccionarios para devolver el contenido de las consultas. Esto se debe a que la lista de diccionarios debe ser la forma mas cómoda y natural de representar una tabla, ya que los distintos elementos de la lista representarían cada uno de los reglones/registros y cada una de las tuplas Clave:Valor, reprensaría las columnas.

>>> tablaPersona = [{"nombre": "Jose", "apellido": "Thomas"},
...                 {"nombre": "Marcos", "apellido": "Aguirre"},
...                 {"nombre": "Rodolfo", "apellido": "Ricardi"}]


>>> for dict in tablaPersona:
...     print "-----------------------------"
...     for clave in dict.keys():
...             print str(clave) + "  =  " + str(dict[clave])
...     print "-----------------------------"
...


-----------------------------
nombre  =  Jose
apellido  =  Thomas
-----------------------------
-----------------------------
nombre  =  Marcos
apellido  =  Aguirre
-----------------------------
-----------------------------
nombre  =  Rodolfo
apellido  =  Ricardi
-----------------------------

El utilizar diccionarios nos da independencia de la posición física del dato dentro de la estructura.

Por ejemplo si tenemos el vector Persona y lo definimos de la siguiente manera:

>>> persona = ["Sebastian", "Schanz"]
>>> def mostrarPersonaVector(persona):
...     print "Nombre: " + persona[0]
...     print "Apellido: " + persona[1]
...
>>> mostrarPersonaVector(persona)
Nombre: Sebastian
Apellido: Schanz
>>> persona.insert(0,"31914934")
>>> mostrarPersonaVector(persona)
Nombre: 31914934
Apellido: Sebastian

Si tienes alguna consulta no dudes en dejar tu comentario que tratare de darte una mano a la mayor brevedad posible!...

Recorda que esto es una simple muestra de la potencia que tienen los diccionarios de Python y de cualquier lenguaje.

miércoles, 18 de enero de 2012

(ALGO INTERESANTE) - FUNCIONES COMO PARAMETROS

Quizás a esta altura ya hayan olvidado las funciones que habíamos creado en algún momento, en algún articulo de este BLOG. :). Por esta razón vamos a refrescar un poco su memoria y vamos a volver a escribirlas en la consola interactiva de Python.

>>> def sumar(num1, num2):
...     return num1+num2
...
>>> def mostrarMensaje(mensaje):
...     print mensaje
...
>>> def multiplicar(num1, num2):
...     return num1*num2
...
>>> mostrarMensaje("Otro dia")
Otro dia
>>> sumar(3,5)
8
>>> multiplicar(5,5)
25

Como se dijo previamente estas dos funciones van a ser accesibles solo desde esta sesión de consola.
Esto quiere decir que si cerramos y abrimos la consola interactiva de Python vamos a tener que volver a crear dichas funciones si deseamos utilizarlas.
De todas formas esto es suficiente para mostrar el ejemplo siguiente:

LISTA DE FUNCIONES

En Python las funciones son objetos de primer grado, esto quiere decir que se le pueden dar varios usos importantes, entre ellos se puede destacar que a las funciones se las puede pasar como parámetros o cargar dentro de una lista como si fueran variables, lo cual puede llegar a ser de muchísima ayuda. Esta funcionalidad  esta implementada muuuuuy sencillamente en Python a diferencia de otros lenguajes como por ejemplo C.

Veamos como se utiliza esto:

Antes de meternos de lleno en lo que son las listas de funciones, estaría bueno mostrarles como se hace en Python para pasar una función como parámetro. La realidad es que esto es muy simple.
Lo primero que hay que hacer es definir la funcion que va a recibir otra funcion por parametro.. :)
Luego internamente esa función se debería usar como se utilizaría normalmente.

>>> def operacion(funcion, operando1, operando2):
...     result = funcion(operando1,operando2)
...     return result
...
>>> operacion(multiplicar, 5,5)
25
>>> operacion(sumar,5,5)
10

Cabe aclarar que hay que tener cuidado con estos temas ya que pueden provocar muchos problemas en tiempo de ejecución. Por ejemplo si los tipos de los parámetros no concuerdan con los que debería recibir la función o si la cantidad de parámetros tampoco es la correcta, se producirán errores como se muestra a continuación.

>>> operacion(sumar,'a','b')
'ab'
>>> operacion(multiplicar,'b',7)
'bbbbbbb'

Como se explico anteriormente las cadenas pueden concatenarse utilizando el operador '+', y también puede multiplicarse una cadena por un entero X, lo cual genera la repeticion de la cadena X cantidad de veces.
En el ejemplo el carácter 'b' se multiplica por 7, lo que genera 'bbbbbbb'.
Lo que daría un error seria tratar de multiplicar dos cadenas.

>>> operacion(multiplicar,'a','b')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in operacion
  File "<stdin>", line 2, in multiplicar
TypeError: can't multiply sequence by non-int of type 'str'

Así como también tratar de llamar a la función mostrarMensaje con más de un parámetro.

>>> operacion(mostrarMensaje,'Hola','Mundo')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in operacion
TypeError: mostrarMensaje() takes exactly 1 argument (2 given)

Una lista de funciones se define de la misma manera que una lista de enteros, o una lista de cadenas.

Veamos un ejemplo.

Supongamos que deseamos aplicarle un conjunto de funciones a dos enteros en particular, para esto lo que hacemos es meter en una lista las funciones que deseamos aplicar y luego creamos un método que reciba esta lista de funciones y los enteros a los que le tenemos que aplicar las operaciones.

>>> # Se crea la lista de funciones
>>> listaFunciones = [sumar,multiplicar]
>>>
>>> # Se crea la funcion que recibe dicha lista y los enteros.
>>> def aplicarFunciones(lfunc,num1,num2):
...     for f in lfunc:
...             result = f(num1,num2)
...             print result
...
>>> # Llamamos a la funcion que aplicara cada una de las operaciones a ambos enteros.
>>> aplicarFunciones(listaFunciones,5,5)
10
25

Como puede observarse esto es muuuy potente, el hecho de poder modificar el comportamiento en tiempo de ejecución de una función en particular, nos da muchísima versatilidad para escribir código. Es cierto  que si se abusa de estas técnicas el código puedo volverse difícil de mantener y de seguir, pero los beneficios que conlleva la utilización de esta técnica, muchas veces puede superar ampliamente las problemáticas.

(MANEJO DE LISTAS)

Una de las cosas que más me atrajo de Python es la simplicidad con la que maneja las listas. Python brinda muchisimas facilidades que hacen que trabajar con listas no sea una tarea compleja.

Vamos a divertirnos un rato.. :)

NOTA: El primer elemento de la lista se encuentra en la posicion 0.



Creemos una lista con 5 elementos ordenados aleatoriamente:

>>> lista = [1,4,3,5,2]
>>> lista
[1, 4, 3, 5, 2]
>>> lista[0]
1

Si por ejemplo quisieramos tomar solo los elementos que se encuentran en la posicion 2 y 3 , es decir tomar una revanada de la lista, lo unico que deberiamos hacer seria lo siguiente:

>>> revanada = lista[2:4]
>>> revanada
[3, 5]

NOTA: Observar que se toman los elementos que se encuentran en el intervalo [2:4) es decir que no se toma el elemento que se encuentra en la posicion 4.

Si queremos tomar una revenada de la lista desde una posicion especifica hasta el final de la lista, hay que escribir lo siguiente:

>>> revanada = lista[2:]
>>> revanada
[3, 5, 2]

Como puede verse, se esta dejando abierto el final del intervalo mediante la expresión lista[2:]. De esta misma manera para tomar una revanada desde el principio de la lista hasta una posicion especifica, lo unico que habria que hacer es dejar abierto el intervalo pero de esta forma lista[:4].

>>> revanada = lista[:4]
>>> revanada
[1, 4, 3, 5]

Si haz pasado por otros lenguajes sabras que en la mayoria de ellos ordenar listas suele ser bastante tedioso, sin embargo Python trae un metodo de ordenamiento incorporado denominado sort. Podes probarlo haciendo lo siguiente:

>>> lista.sort()
>>> lista
[1, 2, 3, 4, 5]

Si te hiciera falta dar vuelta una lista, es decir que el primer elemento pase a ser el ultimo y que el ultimo pase a ser el primero, existe un método en Python que hace este trabajo por nosotros.

>>> lista = [1,2,3,4,5]
>>> lista
[1, 2, 3, 4, 5]
>>> lista.reverse()
>>> lista
[5, 4, 3, 2, 1]

NOTA: Tener en cuenta que el reverse es una operación "destructiva" ya que modifica el objeto sobre el cual se aplica la operación.

Se pueden ordenar listas heterogeneas como se muestra a continuación:

>>> listaHeterogenea = [2,1,'b','a']
>>> listaHeterogenea 
[2, 1, 'b', 'a']
>>> listaHeterogenea.sort()
>>> listaHeterogenea 
[1, 2, 'a', 'b']

Si tenes que contar la cantidad de apariciones de un elemento dentro de una lista, no te compliques que Python tiene una función que hace esto más fácil.

>>> lista = [1,2,3,2,2,5,3]
>>> lista.count(2)
3
>>> lista.count(3)
2
>>> lista.count(5)
1

Para agregar un elemento al final de una lista lo que hay que hacer es utilizar la función append() de listas y LISTO.. :)

>>> lista = [1,2,3,4]
>>> lista
[1, 2, 3, 4]
>>> lista.append(5)
>>> lista
[1, 2, 3, 4, 5]

Algo muy complejo es insertar un elemento en una posición específica de la lista, ya que hay que correr todos los elementos un espacio hacia adelante, para hacer un hueco en el cual pueda entrar el elemento que se desea insertar. Pero como esta es una función bastante común, Python cuenta con ella entre sus funciones integradas.
La función se llama insert y recibe la posición y el elemento en ese orden. Otro punto a favor.. :)

>>> lista = [1,2,3,4,5]
>>> lista.insert(0,0)
>>> lista
[0, 1, 2, 3, 4, 5]
>>> lista.insert(8,6)
>>> lista
[0, 1, 2, 3, 4, 5, 6]
>>> lista.insert(4,9)
>>> lista
[0, 1, 2, 3, 9, 4, 5, 6]

En el ejemplo puede observarse que se ingreso el elemento 0 (cero) en la posición 0 (cero) es decir al inicio de la lista. Luego se inserto el elemento 6 en la posición 8, como la lista tiene menos de 8 elementos se ingresa el elemento 6 al final de la lista. Y por ultimo se inserto el elemento 9 en la posición 4 de la lista. Todos los corrimientos se hacen automáticamente lo cual nos ahorra una gran cantidad de líneas de código.

Si lo que queremos saber es la posicion en la que aparece un elemento en la lista, debemos utilizar la funcion index() de listas.

>>> lista = [5,4,3,2,1]
>>> posicion = lista.index(5)
>>> posicion
0

Puede observarse que el numero 5 se encuentra en la posicion 0 (cero) de la lista.

NOTA: Hay que tener cuidado cuando se utiliza esta funcion ya que si se intenta realizar un index, con un elemento que no pertenece a la lista, se produce un error.

>>> posicion = lista.index(6)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: list.index(x): x not in list

Podría utilizarse en conjunto con la funcion "count()", ya que si se verifica que count es mayor que 0 (cero) es seguro que la funcion "index()" nos devolvera algo.
Cabe aclarar tambien que la funcion index() solo devolverá la posición de la primera aparición del elemento.

Para borrar un elemento de la lista se utiliza la función remove().

>>> lista = [5,4,3,2,1]
>>> lista
[5,4,3,2,1]
>>> lista.remove(2)
>>> lista
[5, 4, 3, 1]

Para concatenar dos o más listas hay dos formas sencillas, una es utilizando la función "extend()" y la otra utilizando el operador '+'.


Concatenacion con  extend()

>>> lista = [1,2,3]
>>> lista
[1, 2, 3]
>>> lista.extend([4,5])
>>> lista
[1, 2, 3, 4, 5]

con el operador '+'

>>> lista = [1,2,3]
>>> lista2 = [4,5]
>>> lista3 = lista + lista2
>>> lista3
[1, 2, 3, 4, 5]

NOTA: Al igual que con las cadenas con las listas también es valido utilizar el operador '*' (Multiplicación).

El resultado es el siguiente:

>>> lista = [1,2,3]
>>> lista2 = lista*2
>>> lista2
[1, 2, 3, 1, 2, 3]

Para tomar el mínimo y el máximo elemento de una lista, Python nos provee los métodos min() y max(), los cuales se utilizan de la siguiente manera:

>>> lista = [1,2,5,4,3]
>>> min(lista)
1
>>> max(lista)
5

Para saber el tamaño de una lista contamos con la funcion len(), la cual tambien puede aplicarse a cadenas y a otros tipos de datos que se veran más adelante.

>>> lista = [1,2,5,4,3]
>>> len(lista)
5

Para sumar los elementos de una lista Python nos provee una funcion llamada sum(), la cual recibe una lista de  numero y devuelve la suma de todos ellos.

>>> lista = [1,2,5,4,3]
>>> sum(lista)
15



Hay que tener cuidado al usar esta funcion ya que si la lista contiene elementos no numericos, la misma tirara un error como se muestra a continuacion.

>>> lista = [1,2,3,'a','b']
>>> sum(lista)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'

Si se quiere obtener una lista sin repeticiones se puede utilizar el metodo set(), que nos retorna un conjunto con los elementos de la lista sin repeticiones.

>>> lista = [1,2,3,4,4,4,5,6,7,6]
>>> lista2 = set(lista)
>>> lista2
set([1, 2, 3, 4, 5, 6, 7])

NOTA: Hay que tener en cuenta que los conjuntos (set) no son indexsables por lo cual la ejecucion de lista2[1] nos dara el error que se muestra a continuacion.

>>> lista2[1]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'set' object does not support indexing

Para acceder uno a uno a los elementos del set, lo mejor es hacerlo por medio de un "for" ya que el set es una estructura iterable.. :P

Por ultimo y para terminar con listas, puedo comentarles que Python nos da la posibilidad de trabajar con las listas como si fueran una estructura de datos de tipo cola o de tipo pila, ya que nos brinda la funcion append() para ingresar elementos al final de la "lista" y también nos brinda la función pop() para ir tomando el ultimo elemento de la lista.
Hay que tener en cuenta que las estructuras de datos de tipo Pila son aquellas en las que el ultimo elemento en insertarse es el primero en sacarse, es por esta razón que se dice que son de tipo LIFO (Last In First Out), por lo cual una Pila en Python estaría dada por una lista que utilice los metodos append() para insertar elementos y pop() para quitarlos.

Lista como Pila

>>> lista = [1,2,3]
>>> lista
[1, 2, 3]
>>> lista.append(4)
>>> lista
[1, 2, 3, 4]
>>> lista.pop()
4
>>> lista
[1, 2, 3]
>>> lista.pop()
3
>>> lista
[1, 2]

Por otro lado una cola, que es una estructura de datos de tipo FIFO (First In First Out) debido a que los elementos se van tomando por orden de llegada, es una estructura igual de facil de implementar pero menos eficiente.
Python esta muy bien preparado para tomar el último elemento de una lista y para insertar un elemento al final de una lista. Pero pierde bastante performance al tomar el primer elemento de una lista y al insertar un elemento al principio de una lista.
De todas formas si se va trabajar con listas pequeñas, esto no es un problema.
Se puede simular una cola mediante una lista que utiliza el método append() para la inserción de elementos y el método pop(0) para tomar los elementos. O tambien utilizando la funcion insert() para insertar al principio de la lista y la funcion pop() para tomar los elementos del final. Esto puede quedar mas claro con el siguiente ejemplo:

>>> lista = [1,2,3]
>>> lista.append(4)
>>> lista
[1, 2, 3, 4]
>>> lista.pop(0)
1
>>> lista.pop(0)
2
>>> lista.append(5)
>>> lista
[3, 4, 5]

NOTA: En Python existe una forma más eficiente de trabajar con Colas, pero lo miraremos mas adelante. Si alguno quiere investigar por su cuenta le comento solamente que deben importar desde collections la clase deque

            from collections import deque