domingo, 22 de septiembre de 2013

Tutorial Python



Tutorial Python


Introducción a Python

Antes de empezar con el manual de Python es bueno empezar sabiendo la historia y  caraceterísticas de este lenguaje de programación.

Documentación extraída de la Wikipedia ...

¿Qué es Python?

Python es un lenguaje de programación interpretado cuya filosofía hace hincapié en una sintaxis muy limpia y que favorezca un código legible.
Se trata de un lenguaje de programación multiparadigma, ya que soporta orientación a objetos, programación imperativa y, en menor medida, programación funcional. Es un lenguaje interpretado, usa tipado dinámico y es multiplataforma.
Es administrado por la Python Software Foundation. Posee una licencia de código abierto, denominada Python Software Foundation License,1 que es compatible con la Licencia pública general de GNU a partir de la versión 2.1.1, e incompatible en ciertas versiones anteriores.

Historia

Python fue creado a finales de los ochenta2 por Guido van Rossum en el Centro para las Matemáticas y la Informática (CWI, Centrum Wiskunde & Informatica), en los Países Bajos, como un sucesor del lenguaje de programación ABC, capaz de manejar excepciones e interactuar con el sistema operativo Amoeba.3
El nombre del lenguaje proviene de la afición de su creador original, Guido van Rossum, por los humoristas británicos Monty Python.4
Van Rossum es el principal autor de Python, y su continuo rol central en decidir la dirección de Python es reconocido, refiriéndose a él como Benevolente Dictador Vitalicio (en inglés: Benevolent Dictator for Life, BDFL).
En 1991, van Rossum publicó el código de la versión 0.9.0 en alt.sources.5 En esta etapa del desarrollo ya estaban presentes clases con herencia, manejo de excepciones, funciones y los tipos modulares, como: str, list, dict, entre otros. Además en este lanzamiento inicial aparecía un sistema de módulos adoptado de Modula-3; van Rossum describe el módulo como “una de las mayores unidades de programación de Python”.2 El modelo de excepciones en Python es parecido al de Modula-3, con la adición de una cláusula else.3 En el año 1994 se formó comp.lang.python, el foro de discusión principal de Python, marcando un hito en el crecimiento del grupo de usuarios de este lenguaje.
Python alcanzó la versión 1.0 en enero de 1994. Una característica de este lanzamiento fueron las herramientas de la programación funcional: lambda, reduce, filter y map. Van Rossum explicó que “hace 12 años, Python adquirió lambda, reduce(), filter() y map(), cortesía de un hacker de Lisp que las extrañaba y que envió parches”.6 El donante fue Amrit Prem; no se hace ninguna mención específica de cualquier herencia de Lisp en las notas de lanzamiento.
La última versión liberada proveniente de CWI fue Python 1.2. En 1995, van Rossum continuó su trabajo en Python en la Corporation for National Research Initiatives (CNRI) en Reston, Virginia, donde lanzó varias versiones del software.
Durante su estancia en CNRI, van Rossum lanzó la iniciativa Computer Programming for Everybody (CP4E), con el fin de hacer la programación más accesible a más gente, con un nivel de 'alfabetización' básico en lenguajes de programación, similar a la alfabetización básica en inglés y habilidades matemáticas necesarias por muchos trabajadores. Python tuvo un papel crucial en este proceso: debido a su orientación hacia una sintaxis limpia, ya era idóneo, y las metas de CP4E presentaban similitudes con su predecesor, ABC. El proyecto fue patrocinado por DARPA.7 En el año 2007, el proyecto CP4E está inactivo, y mientras Python intenta ser fácil de aprender y no muy arcano en su sintaxis y semántica, alcanzando a los no-programadores, no es una preocupación activa.8
En el año 2000, el equipo principal de desarrolladores de Python se cambió a BeOpen.com para formar el equipo BeOpen PythonLabs. CNRI pidió que la versión 1.6 fuera pública, continuando su desarrollo hasta que el equipo de desarrollo abandonó CNRI; su programa de lanzamiento y el de la versión 2.0 tenían una significativa cantidad de traslapo.9 Python 2.0 fue el primer y único lanzamiento de BeOpen.com. Después que Python 2.0 fuera publicado por BeOpen.com, Guido van Rossum y los otros desarrolladores de PythonLabs se unieron en Digital Creations.
Python 2.0 tomó una característica mayor del lenguaje de programación funcional Haskell: listas por comprensión. La sintaxis de Python para esta construcción es muy similar a la de Haskell, salvo por la preferencia de los caracteres de puntuación en Haskell, y la preferencia de Python por palabras claves alfabéticas. Python 2.0 introdujo además un sistema de recolección de basura capaz de recolectar referencias cíclicas.9
Posterior a este doble lanzamiento, y después que van Rossum dejó CNRI para trabajar con desarrolladores de software comercial, quedó claro que la opción de usar Python con software disponible bajo GNU GPL era muy deseable. La licencia usada entonces, la Python License, incluía una cláusula estipulando que la licencia estaba gobernada por el estado de Virginia, por lo que, bajo la óptica de los abogados de Free Software Foundation (FSF), se hacía incompatible con GPL. CNRI y FSF se relacionaron para cambiar la licencia de software libre de Python para hacerla compatible con GPL. En el año 2001, van Rossum fue premiado con FSF Award for the Advancement of Free Software.
Python 1.6.1 es esencialmente el mismo que Python 1.6, con unos pocos arreglos de bugs, y con una nueva licencia compatible con GPL.1

Código Python con coloreado de sintaxis.
Python 2.1 fue un trabajo derivado de Python 1.6.1, así como también de Python 2.0. Su licencia fue renombrada a: Python Software Foundation License. Todo el código, documentación y especificaciones añadidas, desde la fecha del lanzamiento de la versión alfa de Python 2.1, tiene como dueño a Python Software Foundation (PSF), una organización sin ánimo de lucro fundada en el año 2001, tomando como modelo la Apache Software Foundation.1 Incluido en este lanzamiento fue una implementación del scoping más parecida a las reglas de static scoping (del cual Scheme es el originador).10
Una innovación mayor en Python 2.2 fue la unificación de los tipos en Python (tipos escritos en C), y clases (tipos escritos en Python) dentro de una jerarquía. Esa unificación logró un modelo de objetos de Python puro y consistente.11 También fueron agregados los generadores que fueron inspirados por el lenguaje Icon.12
Las adiciones a la biblioteca estándar de Python y las decisiones sintácticas fueron influenciadas fuertemente por Java en algunos casos: el package logging,13 introducido en la versión 2.3, está basado en log4j; el parser SAX, introducido en 2.0; el package threading,14 cuya clase Thread expone un subconjunto de la interfaz de la clase homónima en Java.

Características y Paradigmas

Python es un lenguaje de programación multiparadigma. Esto significa que más que forzar a los programadores a adoptar un estilo particular de programación, permite varios estilos: programación orientada a objetos, programación imperativa y programación funcional. Otros paradigmas están soportados mediante el uso de extensiones.
Python usa tipado dinámico y conteo de referencias para la administración de memoria.
Una característica importante de Python es la resolución dinámica de nombres; es decir, lo que enlaza un método y un nombre de variable durante la ejecución del programa (también llamado enlace dinámico de métodos).
Otro objetivo del diseño del lenguaje es la facilidad de extensión. Se pueden escribir nuevos módulos fácilmente en C o C++. Python puede incluirse en aplicaciones que necesitan una interfaz programable.
Aunque la programación en Python podría considerarse en algunas situaciones hostil a la programación funcional tradicional del Lisp, existen bastantes analogías entre Python y los lenguajes minimalistas de la familia Lisp como puede ser Scheme.






Instalación de Python

La instalación depende del sistema operativo que uses, si te encuentras en una plataforma de linux, no es necesario ya que python viene instalado por defecto, si de lo contrario tu sistema operativo es Windows tienes que descargar el Kit de instalación en la siguiente url ... http://www.python.org/download/ o si quieres tener algo más avanzado proporcionado por la comunidad Python y con la posibilidad de instalar fácilmente nuevos módulos instala ActivePython puedes descárgarlo también directamente desde aquí, los enlaces apuntan directamente al kit de instalación ...

Versiones desarrolladas por la comunidad Python. ActivePython

VersionWindows
(x86)
Windows
(64-bit, x64)
Mac OS X
(10.5+, x86_64/i386)
Linux
(x86)
Linux
(x86_64)
2.7.2.5
3.2.2.3



Versiones con el path básico


Después de la instalación hay que hacer que python.exe pueda ser ejecutado desde cualquier lugar en el sistema, para ello habrá que incluirlo como una variable del sistema, sigue los siguientes pasos ...

Ir al "Panel de Control", hacer click en "Rendimiento y mantenimiento", hacer click en "Sistema", aparece una ventana como la siguiente ...

Instalación de Python

Hacer click en Variables de entorno ...


Ahora hacer doble click en PATH e incluir la ruta donde se encuentra python.exe en mi caso es ...  C:\Python27;


Aceptar a todo, ahora abre una consola de comandos y escribe python, te aparecerá  la aplicación funcionando correctamente ...

Instalación de Python


Con python puedes programar a través de las líneas de comando, realizaremos una prueba imprimiendo un texto 'Hola Mundo', introduce las siguientes línea de código ...

>>> texto = 'Hola Mundo'
>>> print texto

Como puedes ver la variable 'Hola Mundo' se ha imprimido correctamente, aunque esto está bien para probar que todo funciona correctamente, aunque lo normal y lógico es programar a partir de ficheros, para ello haremos lo siguiente, create una carpeta en el escritorio o donde quieras llamada 'tutorial-python', abre un editor de código como el notepad++ y escribe ...

texto = 'Hola Mundo'
print texto

Guárdalo en la carpeta creada anterioremente como hola-mundo.py, ahora saldremos de la consola de comando de python haciendo Control+z 

Dirígete a la ruta donde se encuentra el archivo hola-mundo.py, en mi caso es ... 

cd C:\Documents and Settings\manu\Escritorio\tutorial-python

Ejecuta python seguido del nombre del fichero ...

python hola-mundo.py

Instalación de Python


Como se puede ver el código del archivo ha sido ejecutado por python, pulsa enter para salir de la aplicación.





Tipos básicos de datos en Python

En este apartado del manual veremos los tipo básicos de datos que pueden ser manejados a través de Python, así como operadores aritméticos y de comparación básicos  ...

Nota: Para hacer comentarios en python se utiliza la almohadilla "#".

Los principales son ...

str -> Para cadenas de texto
int -> Para números enteros
long ->  Para números enteros largo
float -> Números decimales
bollean -> True | False


Ejemplos de tipos de datos string ...

También puedes utilizar caracteres escapados dentros de las cadenas de texto. Ejemplo: \n -> Salto de línea

#Cadena de texto simple con salto de linea ...

cadena = 'hola \n'
print cadena

#Cadena de texto con concatenacion ...

cadena = 'hola'+' '+'mundo'
print cadena

#Cadena de texto concatenando texto y variables ...

variable = 'Me gusta '
cadena = variable + 'Python'

print cadena


Para los ejemplos he utilizado comillas simples, aunque también puedes utilizar comillas dobles.

Ejemplos de tipos de datos  Numéricos ...

*Tener en cuenta que para imprimir en la consola datos númericos hay que utilizar la función str(valor), de lo contrario devolverá un error.

#Numero entero simple ...

entero = 10
print str(entero)

#Numero entero largo, el numero entero finaliza con una "L" ...

largo = 10L
print str(largo)

#Numero decimal

decimal = 3.14
print str(decimal)

#La suma de todos los numeros

total = entero + largo + decimal
print str(total)

Operadores aritméticos básicos ...

+  Suma
-  Resta o negación por ejemplo: (-3)
* Multiplicar
/ Dividir
** Exponente
// División entera
% Módulo


Ejemplos de tipos de datos Booleanos ...

#Booleanos

verdad = 1
if verdad == 1:
 print 'ok'
else:
 print 'Mal'



Operadores de comparación básicos ...

and : Se cumplen a y b
or : Se cumple a ó b
is not : Si no es el valor indicado. Ejemplo; if a is not 0: ...
== : igualdad. Ejemplo; if a == b:
!= : distintos. Ejemplo: if a != b:
< : menor que. Ejemplo: if a < b:
> : mayor que. Ejemplo: if a > b:

Tipos Básicos de Datos en Python






Arrays en Python

En Python al igual que en otros lenguajes de programación se pueden crear arrays de distintos tipos, los arrays o listas sirven para almacenar un conjunto de elementos para su posterior ejecución en alguna parte de la aplicación. El array contiene los elementos encerrados entre corchetes y separados por comas, los elementos pueden ser de cualquier tipo de datos, arrays multidimensionales y arrays asociativos o diccionarios llamados comunmente en Python, el array asociativo en lugar de ir entre [] va entre {}

#Arrays

print '--------------------------------'

#Array simple
array = ["cero", "uno"]
print 'Elemento 0 del array simple: '+array[0]
print 'Elemento 1 del array simple: '+array[1]

print '--------------------------------'

#Array con distintos tipos de datos
#Tener en cuenta que para imprimir tipos de datos numericos en la consola

#es necesario su transformacion a string -> str(valor)
array = ["uno", 2, 3L, 2.34]
print 'Elemento 0 del array con distintos tipos de datos: '+array[0]
print 'Elemento 2 del array con distintos tipos de datos: '+str(array[1])
print 'Elemento 3 del array con distintos tipos de datos: '+str(array[2])
print 'Elemento 4 del array con distintos tipos de datos: '+str(array[3])

print '--------------------------------'

#Array multidimensional ...
array = ["string", ["array0", "array1"]]
print 'Elemento 0 del array multidimensional: '+array[0]
print 'Elemento 1-0 del array multidimensional: '+array[1][0]
print 'Elemento 1-1 del array multidimensional: '+array[1][1]

print '--------------------------------'

#Array asociativo o diccionario ...
array = {"uno" : "uno", "dos" : "dos"}
print 'Elemento 0 del array asociativo: '+array["uno"]
print 'Elemento 1 del array asociativo: '+array["dos"]


Arrays en Python







Control de flujo en Python

El Control de flujos es una serie de condicionales o búcles que permiten condicionar el resultado o la acción a ejecutar, sin el control de flujo la aplicación se ejecuta de forma secuencial o lineal, es decir de arriba a abajo.

Lo primero que vamos a ver son las condicionales, las condicionales permiten ejecutar una acción u otra dependiendo de la condición dada, para ello utilizaremos if elif else

print '----------------------------------------'

#Condicional if
#En python no se usan llaves de cierre, se declara la accion finalizando con ':'
#La accion a ejecutar debe de ir indentado de lo contrario devuelve un error

producto = 'coche'
if producto=='coche':
 print 'El producto es un coche'

print '----------------------------------------'
 

#Condicional if else
producto = 1
if producto > 2:
  print 'Producto es mayor que 2'
else:
  print 'producto es menor que 2'

print '----------------------------------------'
   

#condicional if elif else
producto = 'zapato'
if producto == 'camisa':
 print 'El producto es una camisa'
elif producto == 'correa':
 print 'El producto es una correa'
elif producto == 'zapato':
 print 'El producto es un zapato'
else:
 'El producto no tiene valor'

print '----------------------------------------'



A continuación veremos los distintos tipos de búcles que pueden ser utilizados en Python, los búcles son iteraciones que pueden conjugarse con condicionales hasta encontrar la condición correcta o deseada, si no se indica un límite la iteración se convierte en un búcle infinito,  ejemplo: while 0 == 0: ...

Búcle while ...

#bucle while
numero = 10
x = 0
while x < numero:
 print str(x)
 x = x + 1

print '----------------------------------------'

#bucle while con break
numero = 10
stop = 5
x = 0
while x < numero:
 x = x + 1
 if x == stop:
  print 'Ejecucion detenida en el numero 5'
  break
 
print '----------------------------------------'



Búcle for in ...

#bucle for in
elementos = ["uno", "dos", "tres"]
for elem in elementos:
 print elem



Control de flujos en Python





Funciones en Python

A continuación veremos como crear funciones con python. Las funciones sirven para almacenar un determinado código y poder utilizarlo o reutilizarlo cada vez que sea necesario simplemente llamándolos por su nombre.

Las funciones se declaran con la palabra reservada def, no llevan llaves de cierre, sino que siguen el mismo procedimiento que hemos visto en las sentencias if o en los búcles while o for in.

Entre los ejemplo se encuentran una función básica, función básica con parámetro, funcion con parámetros uno opcional, función con parámetros opcionales a modo de array o lista. Creo que esta serie de ejemplo describe bastante claro el uso de funciones en Python.
 
#funciones

print '------------------------------------------------'

#funcion basica
def funcion_basica():
 return 'Funcion basica'

print funcion_basica()

print '------------------------------------------------'

#funcion basica con parametro
def funcion_basica_parametro(string):
 return string

print funcion_basica_parametro('Funcion basica con parametro')

print '------------------------------------------------'

#funcion con parametros, uno de ellos opcional
def funcion_parametro_opcional(numero, opcional=1):
 return numero + opcional

print  'La suma total es ... ' + str(funcion_parametro_opcional(1));
print  'La suma total es ... ' + str(funcion_parametro_opcional(1, 20));

print '------------------------------------------------'

#funcion con parametros opcionales como lista o array
def clientes(precio_total, *clientes):
 for client in clientes:
  print client + ':' + str(precio_total)

clientes(20, 'pedro', 'juan', 'alberto', 'diego')

print '------------------------------------------------'


Funciones en Python



Python Orientado a Objetos

En este apartado del manual veremos lo sencillo que es crear objetos con Python, los objetos definidos también como clases son creadas para realizar determinadas operaciones que requieren de múltiples métodos asociados entre si, para declarar un objeto se utiliza la palabra resevada class seguido del nombre de la clase ... 

class Clase:

 Las clases son iniciadas a través de la instancia ...

 def __init__(self):
  return

A partir de la instancia __init__ el resto de métodos declarados serán ligados al objeto a través de "self" ...

def un_metodo(self, string)
 return string

El siguiente ejemplo consiste en la creación de un objeto principal llamado "Clientes" con una serie de métodos que retornarán el cliente, los productos y el precio total + iva ...

#Orientado a Objetos

#clase principal
class Clientes:

 def __init__(self):
  return

 def nombre_cliente(self, nombre):
  return nombre

 def productos_seleccionados(self, *productos):
  total = ""
  for pro in productos:
   total = total + pro + ' '
  return total

 def coste_total(self, coste_total):
  return coste_total * 0.21 + coste_total
#clase principal


print "-------------------------clase principal------------------------------"

#Llamar a la clase
client = Clientes()
#Llamar a los metodos
print 'Nombre de cliente ... ' + client.nombre_cliente("Pedro")
print 'Productos seleccionados ... ' + client.productos_seleccionados("Arroz", "Leche", "Frutas")
print 'Coste total + iva ... ' + str(client.coste_total(20))



Herencias de objetos en Python ...

Anteriormente hemos visto como crear un objeto o clase principal, ahora surge la necesidad de crear subclases que tomen como herencia esta clase, es decir, una herencia permite a la subclase obtener los mismos métodos y propiedades de la clase principal, pero con la ventaja de añadirle nuevos métodos que la hagan más completa para la función específica a realizar, la clase "Clientes" es un objeto que define una serie de métodos que sirven como conjunto una base para otras subclases, supongamos que necesitamos reflejar el nombre de la tienda y la ciudad donde el cliente ha realizado la compra, podemos crear una subclase llamada "Tienda" que tome como herencia a la clase "Clientes" y además agregarle dos nuevos métodos "nombre_tienda" y "ciudad_tienda", para ello declararemos la nueva clase he incluyendo el "nombre" de la clase principal como parámetro ...

class Tienda(Clientes):

Recuerden que las clases son iniciadas a través de __init__, y en este caso, no va a ser menos ...

def __init__(self):
  return

 

La subclase "Tienda" con estas simples líneas de código ya ha heredado los métodos de la clase "Clientes", ahora completaremos la subclase añadiendo dos nuevos métodos ...

 def nombre_tienda(self, nombre_tienda):
  return nombre_tienda

 def ciudad_tienda(self, ciudad_tienda):
  return ciudad_tienda



Y para llamar a la subclase y hacer uso de todos los métodos ...

#Llamar a la subclase Tienda que hereda la clase Clientes
shop = Tienda()

#Llamar a los metodos de la subclase Tienda
print 'Nombre de la tienda ... ' + shop.nombre_tienda("Python Shop")
print 'Ciudad de la tienda ... ' + shop.ciudad_tienda("Madrid")
print 'Nombre de cliente ... ' + shop.nombre_cliente("Carmen")
print 'Productos seleccionados ... ' + shop.productos_seleccionados("Pescado", "Patatas", "Refrescos", "Pasta")
print 'Coste total + iva ... ' + str(shop.coste_total(48))



* Notas: si se quiere declarar una variable o método de forma privada hay que anteponer dos guiones bajos al nombre ...

__VariablePrivada
def __MetodoPrivado():

Si se muestra por consola el resultado de la clase principal y la subclase, vemos que todo funciona correctamente ...

Python orientado a objetos


Y a continuación el código completo de la aplicación ...

 #Orientado a Objetos

#clases
# Clase principal

class Clientes:

 def __init__(self):
  return

 def nombre_cliente(self, nombre):
  return nombre

 def productos_seleccionados(self, *productos):
  total = ""
  for pro in productos:
   total = total + pro + ' '
  return total

 def coste_total(self, coste_total):
  return coste_total * 0.21 + coste_total
#Clase principal
 
# Subclase con herencia de la clase Clientes
class Tienda(Clientes):
 def __init__(self):
  return

 def nombre_tienda(self, nombre_tienda):
  return nombre_tienda

 def ciudad_tienda(self, ciudad_tienda):
  return ciudad_tienda
# Subclase con herencia de la clase Clientes
#clases


#Llamar a la clase principal Clientes
client = Clientes()

print "-------------------------clase principal------------------------------"

#Llamar a los metodos de la clase principal Clientes
print 'Nombre de cliente ... ' + client.nombre_cliente("Pedro")
print 'Productos seleccionados ... ' + client.productos_seleccionados("Arroz", "Leche", "Frutas")
print 'Coste total + iva ... ' + str(client.coste_total(20))


print "-------------------------subclase-------------------------------------"

#Llamar a la subclase Tienda que hereda la clase Clientes
shop = Tienda()

#Llamar a los metodos de la subclase Tienda
print 'Nombre de la tienda ... ' + shop.nombre_tienda("Python Shop")
print 'Ciudad de la tienda ... ' + shop.ciudad_tienda("Madrid")
print 'Nombre de cliente ... ' + shop.nombre_cliente("Carmen")
print 'Productos seleccionados ... ' + shop.productos_seleccionados("Pescado", "Patatas", "Refrescos", "Pasta")
print 'Coste total + iva ... ' + str(shop.coste_total(48))








Métodos esenciales de Python


 A continuación podéis ver una serie de métodos esenciales de Python para el manejo de listas y cadenas de texto ...


#Metodos

#METODOS PARA DICCIONARIOS
print 'METODOS PARA DICCIONARIOS'

#get busca en un diccionario o array asociativo, si encuentra la clave devuelve su valor,
#de lo contrario devuelve 'null' si no se especifica nada en el segundo parametro

print 'Metodo get:'
diccionario = {"primero" : "uno", "segundo" : "dos"}
buscar = diccionario.get("segundo", "No existe")
print buscar

#has_key buscar en un diccionario o array asociativo,
#devuelve un valor boolenado True | False dependiendo de si la clase es encontrada

print 'Metodo has_key:'
diccionario = {"chico" : "Antonio", "chica" : "Rosa"}
buscar = diccionario.has_key("chica")
print buscar

#items devuelve todos los elementos del diccionario o array asociativo -> clave:valor
print 'Metodo items:'
diccionario = {1 : "uno", 2 : "dos", 3 : "tres"}
pares = diccionario.items()
print pares

#keys devuelve todas las claves del diccionario o array asociativo.
print 'Metodo keys:'
diccionario = {"Spain" : "Hola", "English" : "Hello"}
claves = diccionario.keys()
print claves

#append inserta un nuevo elemento en la lista
print 'Metodo append'
diccionario = ["uno"]
resultado = diccionario.append("dos")
print diccionario

#extend es como append pero permite insertar multiples elementos a la lista
print 'Metodo extend'
diccionario = ['uno']
resultado = diccionario.extend(["dos", "tres", "cuatro"])
print diccionario

#insert permite agregar un nuevo elemento a una lista en la posicion index seleccionada
#insert(index, object)

print 'Metodo insert:'
diccionario = ["0", "1", "2", "4", "5"]
resultado = diccionario.insert(3, 3)
print diccionario

#pop remueve un elemento de la lista a traves del index indicado, si no se indica nada
#elimina el ultimo de la lista

print 'Metodo pop:'
diccionario = ["eliminame", "dos", "tres", "cuatro"]
resultado = diccionario.pop(0)
print diccionario

#remove elimina el primer elemento de la lista que coincida con el parametro value
#remove(value)

print 'Metodo remove:'
diccionario = ["uno", "uno", "uno"]
resultado = diccionario.remove("uno")
print diccionario

#sort permite ordenar una lista
print 'Metodo sort:'
diccionario = [9, 6, 7, 8, 4, 3, 1, 2, 5]
resultado = diccionario.sort()
print diccionario


#METODOS PARA CADENAS DE TEXTO
print 'METODOS PARA CADENAS DE TEXTO'
#count cuenta el numero de veces que se repite el valor en el array
#puede establecer el inicio y el final del intervalo del index donde buscar -> lista.count(0, 3)

print 'Metodo count:'
lista = ["uno", "dos", "uno", "tres"]
buscar = lista.count("uno")
print buscar

#find buscar la posicion de un substring dentro de una cadena de texto,
#puede indicarse tanto el inicio como el final de la posicion en la que buscar cadena.find(string, start, end)

print 'Metodo find:'
cadena = 'Hola estoy aprendiendo python'
substring = cadena.find("python")
print substring

#join es el equivalente a join en javascript o implode en php, establece el caracter o separador del elemento seleccionado,
#es muy util para extraer los elementos de un array como se puede ver a continuacion ...

print 'Metodo join:'
lista = ["uno", "dos", "tres", "cuatro"]
separador = '**'
print separador.join(lista)

#split es el equivalente de split en javascript o explode en php, convierte en un array los elementos de una cadena
#a traves del separador indicado

print 'Metodo split:'
cadena = 'Hola estoy aprendiendo python'
lista = cadena.split(' ')
for element in lista:
 print element

#replace reemplaza la cadena indicada por otra nueva en el string seleccionado
#replace(old, new, max)

print 'Metodo replace:'
cadena = 'hola hola hola hola'
resultado = cadena.replace('hola', 'adios', 3)
print resultado

#index devuelve la primera posicion del substring seleccionado en un string, se puede indicar
#inicio y el final del intervalo de busqueda -> index(string, start, end)

print 'Metodo index:'
cadena = 'Buscando la primera posicion de p'
print cadena.index("p");
print cadena.index("p", 13, 30)




Métodos esenciales de python



Excepciones en Python

Las excepciones son una manera de controlar los posibles errores que se pueden producir durante la ejecución del programa, si no se declaran las excepciones el programa se detiene o interrumpe en el punto donde se produce el error.

Por ejemplo, se puede producir un error cuando se hace uso de una variable que no ha sido declarada ...

if x:
 print "ok"


Devuelve el siguiente error, indicando que x no ha sido definido ...

    if x:
NameError: name 'x' is not defined


Para coger este error y evitar que la ejecución del programa se detenga se utilizan las excepciones try | except ...

#excepcion de variable
try:
 if x:
  print "ok"
except:
 print "error, la variable x no ha sido declarada"


Ahora devuelve una excepción, controlando de este modo el flujo del programa ...

error, la variable x no ha sido declarada

Otro ejemplo muy común es el devuelto tras realizar una división por cero, veamos un ejemplo ...

def dividir(x, y):
 return x / y

print dividir(1, 0)


Esta ejecución devuelve un error, indicando que no es posible dividir entre 0 ...

ZeroDivisionError: integer division or modulo by zero

A continuación se evita este error a través de una excepción ...

def dividir(x, y):
 return x / y


try:
 print dividir(1, 0)
except:
 print 'No es posible dividir entre 0'


Devuelve la excepción, sin detener el programa ...

 print 'No es posible dividir entre 0'

Como se puede observar las excepciones son muy útiles para controlar posible errores durante la ejecución del script.


Excepciones en Python


Importar módulos en Python

En python existen múltiples módulos, los módulos son librerías que permiten realizar una operación determinada, python proveé una amplia gama de módulos que se encuentran en la carpeta "Lib" ...

Importar módulos en python


Los módulos son llamados a través del nombre del fichero exceptuando la extensión, por ejemplo en "Lib" existe un módulo llamado "random" este módulo permite manejar números, diccionarios y cadenas de texto aleatorias, para llamar al módulo se utiliza la palabra reservada import ...

import random

Cada módulo puede contener una serie de clases, métodos y funciones específicas, para este ejemplo crearemos un número aleatorio en un rango de 0 a 1000 a través de la función randint(start, end) ...

import random

aleatorio = random.randint(0, 1000)
print aleatorio


Importar módulos en python


El módulo random contiene múltiples funciones, pero supongamos que sólo queremos hacer uso de una de ellas como en el caso anterior, pues en lugar de llamar al módulo completo podríamos referirnos sólo a la función en concreto ...

from random import randint

aleatorio = randint(0, 1000)
print aleatorio

También es posible incluir varios módulos en la misma línea, simplemente separándolos por comas ...

import random, urllib, urllib2

O crear nuestros propios módulos, para ello debemos guárdarlo en la misma carpeta donde tengamos el script que se ejecutará, ejemplo ...

ModuloFruta.py:

#ModuloFruta.py
def fruta(tipo):
 return tipo

ScriptDemo.py:

#Llamar al modulo ModuloFruta
import ModuloFruta

manzana = ModuloFruta.fruta("manzana")
print manzana

Los módulos son muy útiles para organizar el programa en partes y así no tener que meter todo el código en un solo script, lo que sería algo emborronoso, por eso cuando se trata de aplicaciones que requieren muchas líneas de código es lógico repartirlo en módulos a los que simplemente se llamen dónde realmente sean necesarios.




Entrada y salida de datos en Python

En este parte del manual veremos como interactuar mediante la consola de comandos, para ello haremos uso de la entrada y salida de datos, si has seguido el manual hasta este punto habrás podido observar el uso constante de print, la palabra reservada print tiene como función la salida de datos, por ejemplo ...

print 'hola' 

Imprimirá en la consola hola.

Para la entrada de datos por consola existen dos formas básicas y necesarias para cualquier aplicación python, sys y raw_input

sys: es un módulo que ha de ser importado en el script -> import sys, su función principal es la de pasar parámetros cuando el script se ejecuta a través de una lista argv[] ...

import sys

#parametros
if len(sys.argv) > 1:
 print 'Has introducido correctamente los parametros argv'
 print 'A continuacion se sumaran ambos parametros'
 num_1 = sys.argv[1]
 num_2 = sys.argv[2]
 total = int(num_1) + int(num_2)
 print 'El total es ... ' + str(total)


Si estás habituado al uso de la consola, en más de una ocasión habrás introducido parámetros, por ejemplo ...

C:\Documents and Settings\manu>netstat -h


Se puede ver como incluye un parámetro -h que te lleva a la ayuda de la aplicación netstat.

De este modo si quisieramos ejecutar el código anterior, suponiendo que el script se llama comandos.py, escribiríamos en consola, por ejemplo ...

python comandos.py 22 20

Obtendríamos la suma de ambos parámetros -> 42, ya que la variable total suma ambas variables y finalmente se imprime con print, también hay que reseñar que la suma sólo se realizará si sys.argv es mayor que uno, es decir que si no le pasas parámetros la suma no se llevará a cabo ya que no se da la condición.

raw_input: Esta función permite obtener un valor introducido por consola, por ejemplo ...

#raw_input()
print 'Ejemplo con raw_input para sumar dos numeros:'
print 'Introduce un numero entero ...'
num_1 = raw_input();
print 'Introduce otro numero entero ...'
num_2 = raw_input();

total = int(num_1) + int(num_2)

print 'El total es ... ' + str(total)


Como se puede observar se le asigna a las variables num_1 y num_2 un comando de entrada respectivamente, la variable total recibe el valor de ambas variables y las suma y finalmente se imprime el valor total.

Entrada y salida de datos en Python