Software Libre…"Un Mundo más por

Conocer"
software librehttp://amantesdelsoftwarelibre.wordpress.com/elegancia-programacion-python/

Tutorial para Programar en PYTHON

dejar un comentario »

Sitio Oficial del proyecto:

Logo de Python

http://www.python.org
Python fue creado por Guido van Rossum ( http://www.python.org/~guido/).
Esta inspirado por el popular grupo cómico británico Monty Pythony es considerado un
lenguaje de alto nivel, es por ello que se facilita la lectura de su código.

El cual esta pensado para simplificar el trabajo de los programadores. Es muy

potente y sencillo, tiene la capacidad de escribir programas cortos y efectivos.
Es open Source.

——————————————————————————————————————————
———————————–
Python es ideal para:

 Llevar acabo prototipo de sistemas.

 La elaboración de aplicaciones clientes.
 El desarrollo Web y de sistemas distribuidos.
 El desarrollo de tareas cientificas en las que hay que simular y prototipar
rápidamente.
——————————————————————————————————————————
———————————–
Instalar Python
Bajar versión de Python de :

http://www.python.org/download/

Para Linux en distribuciones basadas en debian instalar el paquete python:

aptitude install python
——————————————————————————————————————————
———————————–

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 CtrlD (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
1234
 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, floatingpoint, and complex)

 Strings
 Listas
 Tuplas
 Diccionarios
Numéricos (integer, long integer, floatingpoint, 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:
123
789
456
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 21 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)
<type ’tuple’>
Sin la coma, Python trata (’a’) como una cadena entre paréntesis:
>>> t2 = (’a’)
>>> type(t2)
<type ’string’>
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 2tuples
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
| 2tuple; 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@fundacitemerida.gob.ve”}
mas_param(**{“nombre”:”Richard Garcia”,”correo”:”rgarcia@fundacitemerida.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)
<type ’float’>
>>> y = pickle.load(f)
>>> y
[1, 2, 3]
>>> type(y)
<type ’list’>
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.4sqlite
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 (mysqlserver)
 Instalar el API de la bas de datos (pythonmysqldb)

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 (mysqlserver)

 Instalar módulo de python para postgres (python2.5psycopg2) 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
otros
PEP es la guia de estilo de programación de Python
La identación debe ser de 4 espacios
Nunca mezcles tabuladores y espacios
Largo maximo de la linea 19 caracteres
las importaciones se deben hacer en lineas separadas
los nombres de las funciones, clases y variables deben ser en minusculas.
Interfaces GTK
Instalamos pythonwxlgade
Para aprender interfaces GTK
http://wiki.wxpython.org/

phyton y blender
¿Estamos tod@s despiert@s? ¿Si? Tú, el del fondo, deja de charlar ya y céntrate! Bien... como
supongo que Blender ya lo controlamos todos, vamos a abrir Blender, y haremos una división
en la pantalla, para escribir nuestro script. Rompemos (Split) la pantalla y seleccionamos que
sea del tipo Text Editor. En el menú Text seleccionamos New y ya tenemos un editor de
texto bien bonito.

Ahora vamos a hacer algo rapidito para que veamos si todo funciona como debe... escribimos

dijo:
print "Hola, Blender"

y seleccionamos en el menú Text, Run Python Script

En la pantalla negra de consola, si todo ha salido bien, debe haber escrito Hola, Blender. Si te
ha dado fallo, es que seguramente has instalado mal Python, y sinceramente no tengo mucha
idea de como arreglarlo.

Bien, supongamos que todo ha salido bien, que es lo más seguro: Blender detecta tu Python, y
la miniprueba ha salido correcta.
Vamos a hacer algo más interesante: quiero hacer un cartelito con su botón de OK.
Resulta que Blender controla su interface también desde Python, es decir, podemos hacer
programas que hagan cosas en Blender y/o en el Game Engine, y lanzarlos cuando queramos
nosotros, o bien cuando se de una condición en el Game Engine.
De momento, vamos a borrar lo que escribimos en el Text Editor... y escribimos esto
(poned las mayúsculas que veis aquí, que Python es muy sensible):

dijo:
import Blender
Blender.Draw.PupBlock ("Hola", ["Esto es la linea 1", "y esta la linea
2"])

Ejecutamos con ALT + P, o bien como antes. Vemos que nos sale un cuadro con un OK? Si?
BIEN!
Analicemos el código... nos ponemos las gafas y vemos:

dijo:
import Blender
Esto carga en Python la librería de Blender, digamos que dice a Python que cargue las
instrucciones de Blender. Si no lo pones, Python no sabe que puede manejar Blender.

dijo:
Blender.Draw.PupBlock ("Hola", ["Esto es la linea 1", "y esta la linea 2"])
Esta es la linea que hace que salga nuestro cuadro.
Como véis, llama a la librería Blender, luego a una parte de esa librería (Draw), y después a un
comando de la librería Draw, PupBlock. Lo que va entre paréntesis son los argumentos de la
función, es decir, lo que quieres que escriba, línea por línea. Con esto nos vamos a conformar
por hoy.

dijo:
Resumen de la lección:
Usamos archivos de texto con código Python para controlar Blender.
ALT + P Ejecuta lo que escribimos
ALT + Q Detiene el script
import Blender permite a Python manejar los comandos de Blender
Blender.Draw.PupBlock ("Título", ["Linea 1", "Linea 2", "Línea 3"]) sirve para hacer un
cuadro de texto con su botón OK y las líneas que queramos.