4 mar. 2011

Un poco de python

Vi esto en un sitio abandonado, y, aunque es escueto, me parece que puede resultarle útil a alguien, así que, ahí va:

Como usar python

Desde la linea de comando. Para arrancar el intérprete (Python interactivo) ejecutar:
Escribimos en la consola python
$ python
Python 2.3.3 (#1, Dec 30 2003, 08:29:25)
[GCC 3.3.1 (cygwing special)] on cygwin
Type “help”, “copyright”, “credits” or “license” for more
information.
>>>
>>>  A este simbolo se le llama el prompt de python y sera el encargado de decir donde empieza una linea de código.
Para salir del intérprete Ctrl­D (en Linux)
>>> import sys
>>> sys.exit()
Ejemplo:Un comando simple:
>>> print “Hola Mundo”
Hola Mundo
—————————————————————————————————————————————————————–

Editores de Python

Spe, idle,  Komodo. Pero  se  puede  usar  cualquier  editor  de  texto  plano  conocido  como  el  vim, nano, gedit, kate, quanta entre otros.
—————————————————————————————————————————————————————–

¿Cómo debes guardar los Archivos?

Debemos guardar el archivo con extension .py
Luego se ejecuta colocando en consola
python archivo.py
Es  importante  localizar  la  dirección  donde  se  encuentra  el  interprete  esto  se  hace tecleando en consola.
which  python
El  resultado  de  esto  es  la  primera  linea  que  colocamos  en nuestro script como se verá a continuación:
#!/usr/bin/python
print “Hola mundo!”
—————————————————————————————————————————————————————–

Comentarios en  python

  • Comentarios de una sola linea

Se coloca con el carácter #
Ejemplo: # comentarios de una línea se indican con carácter ‘#’
  • Comentarios de varias  lineas

Se debe usar tiple comillas al inicio y al final del comentario.
Ejemplo:
“”"
Este es un comentario de varias lineas
Este es un comentario de varias lineas
Este es un comentario de varias lineas
“”"
—————————————————————————————————————————————————————–

Mostrar datos por pantalla

Con print le decimos a python que muestre datos por pantalla. Realmente lo que hace print es llamar a un módulo del espacio de nombre sys: sys.stdout.write(“cadena”).
El cual le pasa como parámetro de entrada lo que pongas a continuación del print
Import sys
sys.stdout.write(“Hola mundo!”)
Equivalente a
print “Hola mundo!”
—————————————————————————————————————————————————————–

Tomar datos desde el teclado

raw_input(“Mensaje por pantalla”)
Es muy parecido a la filosofía usada para el print, ya que en este caso haremos uso del
módulo sys.stdin.read()
Import sys
variabledeSalida=sys.stdin.read(entero)

entero es el largo de la cadena a leer
Equvalente a
variabledeSalida=raw_input(“Mensaje por pantalla”)
—————————————————————————————————————————————————————–

Operadores

  • Operadores Relacionales
>      mayor que
<      menor que
>=    mayor o igual que
<=    menor o igual que
!=     distinto
==    igual
  • Operadores Arítmeticos
+     suma (usado para números y para concatenar cadenas)
­-      resta
*     multiplicación
/      división
%    modulo o resto
  • Operadores Lógicos
and     y lógico
or        o lógico
not      no lógico
—————————————————————————————————————————————————————–

Sentencias y bloques

Las sentencias acaban en nueva línea, NO en ( ; ).
Los bloques son indicados por tabulación que sigue a una sentencia acabada en ‘:’.
E.j. (bloque.py):
#!/usr/bin/python
name = “Luis1″ # asignación de valor a variable
if name == “Luis”:
print “Hola Luis”
else:
print “¿Quién eres?”
print “¡No eres Luis!”
$ python bloque.py
Salida del terminal:
¿Quién eres?
¡No eres Luis!
—————————————————————————————————————————————————————–

Estructuras de decisiones y bucles:

La condición puede ir o no en paréntesis.
Nota: en python no existe el switch
  • Sentencia if: (simple)
if condicion:
sentencia1
sentencian
else:
sentencia11
sentencia nn
  • Sentencia if: (Doble)
if condicion:
sentencia1
sentencian
else:
sentencia11
sentencia nn
  • Sentencia if: (múltiple)
if condicion:
sentencia1
sentencian
elif condicion:
sentencia11
sentencia nn
—————————————————————————————————————————————————————–

Control de Bucles o sentencias iterativas

  • for: se utiliza para iterar sobre los miembros de una  secuencia.
Se puede usar sobre cualquier tipo de datos que sea una secuencia (lista, tupla, diccionario). La función range crea una secuencia descrita por ([start,] end [,step]), donde los campos  start y step son opcionales. Start es 0 y step  es 1 por defecto.
Ej. bucle.py
for x in range(1,5):
print x

$ python bucle.py
1 2 3 4
  • while: es otra sentencia de repetición. Ejecuta un bloque de  código hasta que una condición es falsa.
while condicion:
sentencia1
sentencian
Por ejemplo:
reply = ‘repite’
>>> while reply == ‘repite’:
print ‘Hola’
reply = raw_input(‘Introduce “repite” para hacerlo de nuevo’)
  • break: nos sirve para salir de un bucle, sirve para pasar a la próxima iteracion dejando sin ejecutar lo que se encuentra por debajo de el.
—————————————————————————————————————————————————————–

Identificadores

Sirven para nombrar variables, funciones y módulos . Deben empezar con un carácter no numérico y contener letras seguido de números y ‘_’ .
No se debe usar una  plabara  reservada  del  lenguaje  para  los  identificadores.
En  python  no  hace  falta delcarar  variables.  Simplemente  se  colocan  a  medida  que  se  vayan  usando.
El  solo entiende  de  expresiones  numericas  y  alfanumericas,  (estas  últimas  se  colocan  entre comillas dobles o simples.) Python es case sensitive
Palabras Reservadas:
and    elif    global    or    assert    else    if    pass    break  except    import    print    class    exec    in   raise continue    finally    is    return    def    for    lambda    try del    from    not    while
—————————————————————————————————————————————————————–

Tipos de Datos

Numéricos (integer, long integer, floating­point, and  complex)
  • Strings
  • Listas
  • Tuplas
  • Diccionarios
Numéricos (integer, long integer, floating­point, and  complex). Consiste en usar expresiones númericas sin delimitarlos entre comillas dobles o simples.
La función int, long, float lo que me hace es una conversión si es posible al tipo de datos en caso contario me lanzara una excepción.
>>> x = 4
>>> int (x)
4
>>> long(x)
4L
>>> float(x)
4.0
>>> complex (4, .2)
(4+0.2j)
Strings, delimitados por un par de (‘, ” ). Dos string juntos sin delimitador se unen
>>> print “Hi” “there”
Hithere
Algunos de los métodos que se pueden aplicar a un string son:
>>> len(‘La vida es mucho mejor con Python.’)
>>> 34
>>> ‘La vida es mucho mejor con Python.’.upper()
‘LA VIDA ES MUCHO MEJOR CON PYTHON’
>>> “La vida es mucho mejor con Python”.find(“Python”)
27
>>> “La vida es mucho mejor con Python”.find(‘Perl’)
­1
>>> ‘La vida es mucho mejor con Python’.replace(‘Python’, ‘Jython’)
‘La vida es mucho mejor con Jython’
—————————————————————————————————————————————————————–

El módulo string de Python library

Se definen  métodos para manipulación de strings:
>>> import string
>>> s1 = ‘La vida es mejor con Python’
>>> string.find(s1, ‘Python’)
21
‘%’ es el operador de formateo de cadenas:
>>> variable = ‘muchachos’
>>> “Hola  %s  %s” % (variable, “Como estan”)
‘La capital de Araba es Gasteiz’
—————————————————————————————————————————————————————–

Listas

Es un conjunto ordenado de valores, en el cual cada valor va identificado por un índice.
Los valores que constituyen una lista son sus elementos.
Las listas son similares a las  cadenas  de  texto  (strings),  que  son  conjuntos  ordenados  de  caracteres,  excepto  en que  los  elementos  de  una  lista  pueden  ser  de  cualquier  tipo.
Las  listas  y  las cadenas,  y otras cosas que se comportan como conjuntos ordenados, se llaman secuencias.
Para terminar, hay una lista especial que no contiene elementos.
Se la llama lista vacía y se representa [].
La sintaxis para acceder a los elementos de una lista es la misma que para acceder a los caracteres de una cadena: el operador corchetes [].
La expresión dentro de los corchetes especifica el índice. Recuerde que los índices siempre comienzan en cero:
Indexadas por un entero comienzan en 0:
ejemplo:
>>> meses = ["Enero", "Febrero"]
>>> print meses[0]
Enero
—————————————————————————————————————————————————————–

Matrices

Es común usar listas anidadas para representar matrices. Por ejemplo, la matriz:
1 2 3
7 8 9
4 5 6
Puede ser representada como:
>>> matriz = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
Matriz es una lista con tres elementos, siendo cada elemento una fila de la matriz.Podemos elegir una fila entera de la matriz de la forma normal:
>>> matriz[1]
[4, 5, 6]
Añadir un elemento a la lista: append añade un elemento al final de la lista
>>>meses=["enero","Febrero"]
>>> meses.append(“Marzo”)
>>> print meses
['Enero', 'Febrero', 'Marzo']
Dos puntos (:) es el operador de rodajas, permite trabajar con una  porción de la lista, el elemento indicado por el segundo parámetro no se incluye:
>>> print meses[1:2]
['Febrero']
Para usar una lista como una pila, se pueden usar append y pop:
>>> items.append(555)
>>> items [­1, 4, 6, 555]
>>> items.pop( )
Nota: Para mayor documentación sobre las metodos que se le pueden aplicar a una lista pydoc list
—————————————————————————————————————————————————————–

Listas pydoc list

L es el nombre de la lista
append(…)
|      L.append(object) ­­ append object to end
|  count(…)
|      L.count(value) ­> integer ­­ return number of occurrences of value
|  extend(…)
|      L.extend(iterable) ­­ extend list by appending elements from the iterable
|  index(…)
|      L.index(value, [start, [stop]]) ­> integer ­­ return first index of value
|  insert(…)
|      L.insert(index, object) ­­ insert object before index
|  pop(…)
|      L.pop([index]) ­> item ­­ remove and return item at index (default last)
|  remove(…)
|      L.remove(value) ­­ remove first occurrence of value
|
|  reverse(…)
|      L.reverse() ­­ reverse *IN PLACE* |
Las listas pueden contener cualquier tipo de objetos Python:
>>> meses=["Enero","Febrero"]
>>> meses1=["Marzo","Abril"]
>>> meses.append(meses1)
>>> print meses
['Enero', 'Febrero', ['Marzo', 'Abril']]
meses.append(1)
>>> print meses
['Enero', 'Febrero', ['Marzo', 'Abril'], 1]
—————————————————————————————————————————————————————–

Para añadir un elemento a una lista en una determinada posición:

>>> items = [4, 6]
>>> items.insert(0, ­1)
>>> print items
[­1, 4, 6]
—————————————————————————————————————————————————————–

Más (+) es el operador de concatenación:

>>> print meses+meses
['Enero', 'Febrero', 'Marzo', 'Enero', 'Febrero',
'Marzo']
lst=[1,”cad”,[1,2],12]
print lst #imprime la lista completa
print lst[1] #imprime cad
print lst[1][2] se imprime la d de cad
print lst[2][1] imprime el segundo componente del segundo componente de la lista es decir el 2
—————————————————————————————————————————————————————–

Acceder a un trozo de la lista sin incluir los extremos

>>>print lst[1:3]#imprime [1,2] no incluye los extremos con respecto al índice
>>>print lst[2:]# imprime la posicion 2 incluyendo el ultimo elemento de la lista
>>>print lst[:2]# imprime desde el primero hasta el de la posición 2­1 no incluye el extremo
—————————————————————————————————————————————————————–

Funcion range

st=range(20)                                      #Esta funcion lo que me crea es una lista que va desde el 0 al 19. no incluye
el 20
>>> lst=range(20)
>>> print lst

sintáxis de la función range

range([start,] stop[, step])                #nota no incluye el extremo final es decir stop
Ayudas en consola pydoc range me da documentacion sobre esta funcion.
Ejemplo:
range(0,20,4)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>>print lst[5:15:2]                           #imprime comenzando en la posición 5 hasta el 15 sin incuirlo con un
paso de 2
[5, 7, 9, 11, 13]
>>>
—————————————————————————————————————————————————————–

Cadenas y listas

Dos de las funciones más útiles del módulo string tienen que ver con listas de cadenas.
  • La función split divide una cadena en una lista de palabras.

Por defecto, cualquier número de caracteres de espacio en blanco se considera un límite de palabra:
>>> import string
>>> cancion = “La lluvia en Mérida…”
>>> string.split(cancion)
[’La’, ’lluvia’, ’en’, Mérida...’]
Se puede usar un argumento opcional llamado delimitador para especificar qué caracteres se usarán como límites de palabra. El siguiente ejemplo usa la cadena ll como delimitador:
>>> string.split(cancion, ’ll’)
[’La ’, ’uvia en Mérida’]
Observe que el delimitador no aparece en la lista.


  • La función join es la inversa de split. Toma una lista de cadenas y concatena los elementos con un espacio entre cada par:

>>> lista = [’La’, ’lluvia’, ’en’, Mérida...’]
>>> string.join(lista)
La lluvia en Mérida…’
Como split, join acepta un delimitador opcional que se inserta entre los elementos. El delimitador por defecto es el espacio.
>>> string.join(lista, ’_’)
La_lluvia_en_Sevilla…’
—————————————————————————————————————————————————————–

Tuplas

Son  tipo  de  datos  iguales  que  la  listas  pero  con  la  salvedad  que  no  se  pueden  modificar.
Se usan paréntesis para delimitar sus valores.
Hasta ahora, ha visto dos tipos compuestos: cadenas, que están hechas de caracteres, y listas,
que  están  hechas  de  elementos  de  cualquier  tipo.
Una  de  las  diferencias  que  señalamos  es que los elementos de una lista se pueden modificar, pero los caracteres de una cadena no.
En otras palabras, las cadenas son inmutables y las listas son mutables.
En Python hay otro tipo llamado tupla que es similar a una lista salvo en que es inmutable.
Sintácticamente, una tupla es una lista de valores separados por comas:
>>> tupla = ’a’, ’b’, ’c’, ’d’, ’e’
Aunque no es necesario, la convención     dice que  hay  que encerrar las tuplas entre paréntesis:
>>> tupla = (’a’, ’b’, ’c’, ’d’, ’e’)
Para crear una tupla con un solo elemento, debemos incluir una coma final:
>>> t1 = (’a’,)
>>> type(t1)
Sin la coma,    Python   trata (’a’) como  una cadena  entre paréntesis:
>>> t2 = (’a’)
>>> type(t2)
El operador índice selecciona un elemento de la tupla.
>>> tupla=(“a”,”b”,”c”,”d”,”e”)
>>> tupla[0]
‘a’
Y el operador  de porción elementos.
>>> tupla[1:3]
(‘b’, ‘c’)
Asignaciones multiples
i,j=10,20                     #ene ste caso i=10 y j=20
—————————————————————————————————————————————————————–

Diccionarios

Diccionarios {} arrays asociativos o mapas, indexados por una clave, el valor puede ser cualquier objeto Python, la clave normalmente es un objeto inmutables:
>>> mydict = {“altura” : “media”, “habilidad” : “intermedia”, “salario” : 1000 }
>>> print mydict
{altura’: ‘media’, ‘habilidad’: ‘intermedia’, ‘salario’: 1000
Forma de Acceder a un elemento del diccionario se hace a través de las claves
>>> print mydict["habilidad"]
intermedia
Puedes comprobar la existencia de una clave en un diccionario usando has_key:
if mydict.has_key(‘altura’):
print ‘Nodo encontrado’
Lo mismo se podría hacer:
if ‘altura’ in mydict:
print ‘Nodo encontrado’
Las claves deben ser tipos inmutables (Es decir que los valores se pueden modificar), no hay forma de saber como esta ordenado
dc={“lclave”:”valor”,”lista”:[1,2,3,4],”tupla”:([1,2,3],4),4:”entero”}
Algunos metodos aplicados a este tipo de datos (ayuda en consola pydoc dict)
clear(…)
|      D.clear() ­> None.  Remove all items from D.
|  copy(…)
|      D.copy() ­> a shallow copy of D
|  get(…)
|      D.get(k[,d]) ­> D[k] if k in D, else d.  d defaults to None.
|
|  has_key(…)
|      D.has_key(k) ­> True if D has a key k, else False
|
|  items(…)
|      D.items() ­> list of D’s (key, value) pairs, as 2­tuples
iteritems(…)
|      D.iteritems() ­> an iterator over the (key, value) items of D
¡  iterkeys(…)
|      D.iterkeys() ­> an iterator over the keys of D  |
Algunos metodos aplicados a este tipo de datos (ayuda en consola pydoc dict)
itervalues(…)
|      D.itervalues() ­> an iterator over the values of D
|  keys(…)
|      D.keys() ­> list of D’s keys
|  pop(…)
|      D.pop(k[,d]) ­> v, remove specified key and return the corresponding value
|      If key is not found, d is returned if given, otherwise KeyError is raised
|   popitem(…)
|      D.popitem() ­> (k, v), remove and return some (key, value) pair as a
|      2­tuple; but raise KeyError if D is empty
|   setdefault(…)
|      D.setdefault(k[,d]) ­> D.get(k,d), also set D[k]=d if k not in D
|  update(…)
|      D.update(E, **F) ­> None.  Update D from E and F: for k in E: D[k] = E[k]
|      (if E has keys else: for (k, v) in E: D[k] = v) then: for k in F: D[k] = F[k]
|
|  values(…)
|      D.values() ­> list of D’s values
—————————————————————————————————————————————————————–

Funciones en Python

Se usa la palabra reservada  def  seguido del identificador de la funcióny entre paréntesis los parametro; o sin parametros en caso de que no los tenga.(ojo se aplican las mismas
reglas a este identificador como si fuese una variable)def nombre_funcion(par1, par2,.., parn,): cuerpo return valor_retorno # en caso de que la función me retorne o no un parámetro
Forma de invocar a la función
nombre_funcion(arg1, arg2,.., argn,)
def myfunc(a,b):
sum = a + b
return sum
print myfunc (5,6)
En  python  tambien  se  le  pueden  colocar  a  los  parametros  de  la  función  valores  por defectos. En caso de que se llame la función y se le pase el argumento correspondiente en la función el parametro será reemplazado por el argumento.
#­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­
# funcionvaloresdefecto.py
#­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­
def myfunc(a=4,b=6):
sum = a + b
return sum
print myfunc()
print myfunc(b=8) # a es 4, sobreescribir b a 8
Pasando  una  tupla  como  parámetro. A  las  funciones  tambien  se  les  puede  pasar  una tupla  como  argumento.  Pero  entonces  el  el  parametro  dentro  de  la  función  debe  ir precedido por un asterisco (*)
#­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­
#Pasando una tupla a una función en el momento en que se invoca
# funcionvaloresdefecto.py
#­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­
def var_param(*parametros):#le estamos pasando una tupla
print “parametros es %s” %type(parametros)
for i in parametros:
print i,#la , lo que hace es que se imprima uno al lado del
otro
var_param(2,3,([1,2,3],7))
Pasando una lista como argumento: Se debe preceder los argumentos de la función por un asterisco (aunque no en este caso es opcional) al igual que sus  parametros.
#­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­
#Pasando una  a una lista a una función en el momento en que se invoca
# funcionvaloresdefecto2.py
#­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­
def var_param(parametros):#le estamos pasando una tupla
print “parametros es %s” %type(parametros)
for item in parametros:
print item#la , lo que hace es que se imprima uno al lado
del otro
lista=[2,3,([1,2,3],7)]
var_param(lista)
#Nota: La lista se transfoma en una tupla

Pasando una diccionario como argumento:
Se debe preceder los argumentos de la función por un asterisco al igual que sus  parametros.
#­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­
#Pasando una  un diccionario a una función en el momento en que se invoca
#­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­
def mas_param(**dc):
print “dc es un:%s”%type(dc)
for item in dc.keys():
print “%s : %s : %s “%(item,dc[item],type(dc[item]))
dc={“nombre”:”Richard Garcia”,”correo”:”rgarcia@fundacite­merida.gob.ve”}
mas_param(**{“nombre”:”Richard Garcia”,”correo”:”rgarcia@fundacite­merida.gob.ve”})
mas_param(**dc)
#nota:  Tanto  el  argumento  como  los  parametros  deben  estar  precedidos  por  dos asteriscos
—————————————————————————————————————————————————————–

Módulos en Python

Módulos: es una colección de métodos en un fichero que acaba en .py. El nombre del fichero determina el nombre del  módulo en la mayoría de los casos.
Uso de un módulo: En otro escript aparte invoco al modulo. Donde modulo es el nombre que se le dio al fichero. Invocando a un modulo se puede hacer de dos maneras:
import nombre_modulo
from nombre_modulo import metodo1, metodo2, …, metodo n
E.j. modulo.py:
def one(a):
print “in one”,a
def two (c):
print “in two” ,c
Ejemplo  1                                                 Ejemplo2
import modulo                                          from  modulo import one
modulo.one(2)                                          one(2)
Listando los procedimientos de un modulo en la consola interactiva
>>> import modulo
>>> dir(modulo)
['__builtins__', '__doc__', '__file__', '__name__', 'one', 'two']
Donde los que aparecen sin los guiones de pisos son los procedimientos que tiene ese modulo .
Tambien se pueden saber los modulos que tiene un archivo.(En un script de la siguiente manera)
import modulo
dir(modulo)
Forma de incluir un modulo en la ruta donde python coloca los módulosimport sys
sys.path.insert(0,’ruta absoluta donde se encuentra el módulo’)
sys.path  son los sitios donde python va a buscar donde se encuentran los módulos
nota para saber los procedimientos de un modulo hago un dir(modulo)
—————————————————————————————————————————————————————–

Manejo de ficheros en Python

Abriendo un fichero en modo de lectura
f=open(”nombrefichero”,”r”)
Abriendo un fichero en modo de ecritura .
f=open(”nombrefichero”,”w”)
Abriendo un fichero en modo de escritura conservando el contenido del mismo
f=open(”nombrefichero”,”a”)
Cerrando un fichero
f.close()
—————————————————————————————————————————————————————–

Leer un fichero (leer_fichero.py)

#!/usr/bin/python
fh = open(“archivo.py”) # open crea un objeto de tipo fichero
fh = open(“archivo.py”,”r”)
for line in fh.readlines() : # lee todas las líneas en un fichero lo convierte en una lista
print line,
fh.close() #cerrando en el fichero
#!/usr/bin/python
fh = open(“ejemplo.txt”) # open crea un objeto de tipo fichero
linea=fh.readline(); leo la primera linea como una cadena devuelve false en caso de estar
vacío
while(linea) : # lee todas las líneas en un fichero
print line
linea=fh.readline()
fh.close()
Nota:  OJO CON ESTA MANERA DE LEER FICHEROS CUANDO LA PRIMERA LINEA
ESTA EN BLANCO DEL FICHERO O HAY UNA LINEA INTERCALADA VACIA
—————————————————————————————————————————————————————–

Escribir un fichero (escribirfichero.py)

#si el fichero en el cual deseo escribir no existe automáticamente se crea el fichero,
siempre y cuando tenga permisos de escritura en el directotio donde lo estoy creando
#!/usr/bin/python
fh = open(“out.txt”, “w”)  #abrir un fichero para escritura
fh.write (“estamos escribiendo …\n”)   #Escribiendo en el fichero
fh.close()  #cerrando en el fichero
luego ejecuto en consola el script
$ python escribirfichero.py
$ cat out.txt
estamos escribiendo …
—————————————————————————————————————————————————————–

Encurtidos.

Para poner valores en un archivo, debe      convertirlos en cadenas. Ya ha visto cómo hacerlo con str:
>>> f.write (str(12.3))
>>> f.write (str([1,2,3]))
El problema es que cuando vuelve usted a leer el valor, obtiene una cadena. Ha perdido la
información del tipo de dato original. En realidad, no puede distinguir dónde termina un
valor y comienza el siguiente:
>>> f.readline()
12.3[1, 2, 3]’
La solución es un encurtido, llamado así porque “conserva” estructuras de datos.  El módulo pickle contiene las órdenes necesarias. Para usarlo, importe pickle y luego abra el
archivo de la forma habitual:
>>> import pickle
>>> f = open(“test.pck”,”w”)
Manejo de ficheros en Python. Encurtidos Para almacenar una estructura de datos, use el método dump y luego cierre el archivo de la
forma habitual:
>>> pickle.dump(12.3, f)
>>> pickle.dump([1,2,3], f)
>>> f.close()
Ahora podemos abrir el archivo para     leer  y cargar  las estructuras de datos que volcamos ahí:
>>> f = open(“test.pck”,”r”)
>>> x = pickle.load(f)
>>> x
12.3
>>> type(x)

>>> y = pickle.load(f)
>>> y
[1, 2, 3]
>>> type(y)
Cada vez que invocamos load obtenemos un valor del archivo, completo con su tipo original.
—————————————————————————————————————————————————————–

Excepciones en python

Las excepciones es el método usado por Python para controlar los errores de compilación de nuestros programas y tener control sobre ellos, para que de este modo
podamos evitar que termine la ejecución de un programa de forma fortuita.Para tener este control Python nos proporciona 3 sentencias:
try: Esta palabra le indica al compilador que las siguientes sentencias pueden lanzar excepciones.
#­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­
exp.py
#­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­
a=”Hola”
b=10
a=a+b
$ python exp.py
Traceback (most recent call last):
File “exp.py”, line 3, in ?
a=a+b
TypeError: cannot concatenate ‘str’ and ‘int’ objects
except:   Es  la  palabra  reservada  que  nos  ofrece  python  para  saber  que  a  partir  de  allí sera el tratamiento de errores para las excepciones que encontremos dentro del try
Ejemplo:
try:
a=”Hola”
b=10
a=a+b
except:
print “Error”
finally: Es la encargada de seguir el programa despues de controlar las excepciones
print “Error”
finally: Es la encargada de seguir el programa despues de controlar las excepciones
—————————————————————————————————————————————————————–

Programación orientada a objetos en python

La  programación  orientada  a  objetos  representa  una  gran  ventaja  respecto  al  método tradicional. Ene ste sentido la orientación a objetos puede considerarse como una manera
de ampliar las posibilidades de los tipos de datos de estructuras.
Sintaxis para crear clases:
Clase simple
class nombreClase:
Clase que hereda de otras clases
class nombreClase(ClaseHereda1,ClaseHereda2):
ejemplo:
Class Persona:
Sintáxis general de una clase:
class nombre_clase:
métodos_especiales
otros_métodos
Sintáxis general de una clase sin métodos:
class nombre_clase:
pass
Importar
a)Importar clases

sintaxis:
import nombreClase
b)Importar funciones de un fichero
Sintaxis:
from nombreClase import nombreMétodo1,.., nombreMétodon
Funciones o métodos de las clases
Sintaxis (Métodos especiales):
def __nombreMetodo__ (Parametros de Entrada):
Sintaxis (Otros métodos):
def nombre_metodo((Parametros de Entrada):
Ejemplo:
def __init__ (self):
self:Es la palabra reservada que usa python para referirse al objeto que estemos tratando en otros lenguajes se usa la palabra reservada this

Constructor

Es un tipo especial de método que se encarga de crear un objeto o instancia de un tipo en concreto de la clase.
En python tiene el siguiente formato
Sintaxis:
def__init__(párametrosDE entrada1,..,párametrosDE entradan):
Ejemplo:def__init__(self):

Para llamar ese constructor desde fuera de la clase se utiliza el nombre de la clase que quiere instanciar a un objeto
Sintaxis
nuevoObjeto=nombreClase(parámetrosDe Entrada1,…,Parametros de EntradaN)
Ejemplo:
persona1=Persona(‘Ana’,'Ramirez’,programador)
Class Persona:
def __init__(self):#self es una variable; el primer parametro es la clase misma
—————————————————————————————————————————————————————–

Conexion con base de datos.Sqlite

Para la base de dtos sqlite
En versiones como la 2.4 instalar: python2.4­sqlite
En versiones de 2.5 en adelante el módulo ya viene por defecto import sqlte3  esta incorporadas a partir de python 2.5. Es decir ya la trae incorporadad el lenguaje

Conexion con base de datos.Sqlite

import sqlite3 as bd #en caso de ser otra base de datos debemos importar el modulo
conn=bd.connect(“/home/richard/curso_Francisco_python/prueba36.test”)
cur=conn.cursor()
def crearTabla():
cur.execute(“create table personas(nombre text,”\
“apellidos text);”)
conn.commit()
def insertarDatosEjemplo():
personas=[['Erny','Revilla'],['Lorenzo','Gil'],['Dani','Molina']]
for persona in personas:
cur.execute(“insert into personas (nombre,apellidos) values (‘%s’,'%s’)” %
tuple(persona))
conn.commit()
**********************continua**************************
Conexion con base de datos.Sqlite
def consultarDatos():
cur.execute(“select * from personas”)
for persona in cur:
print “%20s   %20s” %(persona[0],persona[1])
“”"nota no se puede manejar la salida de una consulta dandole formato
debido a que las tuplas se devuelven en las cadenas con un caracter que
precede a las cadenas”"”
crearTabla()
insertarDatosEjemplo()
consultarDatos()
Primero debemos instalar:
  • El servidor mysql (mysql­server)
  • Instalar el API de la bas de datos (python­mysqldb)

Estableciendo una conexión

import MySQLdb as bd #importamos el API
conn=db.connect(db=”nombre_bd” , user=”nombre_usuario”,passwd=”pasword_user”,
host=”nombre_host”)
ejemplo:
conn=db.connect(db=”mysql” , user=”root”,passwd=”", host=”localhost”)

Conexión con base de datos. Postgrest

Primero debemos instalar:
  • El servidor mysql (mysql­server)
  • Instalar módulo de python para postgres (python2.5­psycopg2) en este caso si estamos trabajando  con  la  versión  de  python2.5  sino  instalar  la  correspondiente  a  la  versión  de python que estemos utilizando.
Estableciendo una conexión
import psycoppg2 as bd #importamos el modulo
conn = db.connect (database=”nombre_bd” , user=”nombre_usuario”,
password=”password”, host=”localhost”, port=”5432”)
ejemplo:
conn=db.connect(database=”asl” , user=”usuario”, password=”123″, host=”localhost”,
port=”5432″)
asl es una base de datos que ya esxiste y se creo en postgres.
Usuario es un usuario de postgres y password es la contraseña de ese usuario

No hay comentarios:

Publicar un comentario en la entrada