El post que buscas se encuentra eliminado, pero este también te puede interesar

Un poco de Python

Anuncios

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)
<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 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)
<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.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

http://galegolinux.blogspot.com

Anuncios

12 comentarios - Un poco de Python

elviejodelahorquilla +4
eh loco aguante python amigo!
sabé está re piola porque es re versatil vite?
jajaja
GNU
mrvdr
elviejodelahorquilla dijo:eh loco aguante python amigo!
sabé está re piola porque es re versatil vite?
jajaja
GNU

aguante PHP, de mucho mas facil aprendizaje y mas potente
facuumunoz
aguante python lejos!!! super simple! buen post!
usa [*code] para sacar las caritas en el código..
mrvdr
facuumunoz dijo:aguante python lejos!!! super simple! buen post!
usa [*code] para sacar las caritas en el código..

naaaa
drjamaica +1
a favs, tengo ganas de aprender python! solo use pascal hace como 7 años y era bastante maleta!!!
Gracias
EpilepticMAN

Import sys 
sys.stdout.write(“Hola mundo!”) 


esto no me salió
EpilepticMAN
perdon es que lo copie y lo pegué y no vi que lo pusiste en mayuscula van +10
zonadober
algunas cap seria mejor usar