Tutorial SQlite3 con Python3 en Linux

SQLite es una herramienta que nos permite guardar bases de datos portables para poder usarlas en programas,scripts,etc sin tener que acceder a conexiones de Bases de Datos establecidas en un servidor especifico,en otras palabras(mis palabras) SQLite es como un MySQL portable, SQLite usa una variante no estándar del lenguaje SQL,por lo cual si conoces el lenguaje SQL como con MySQL,no sera dificil comprender el funcionamiento de SQLite.

Primero que nada debemos tener instalado el modulo para Python,en Linux no debe haber problema,he oído que en otros sistemas si,pero en GNU/Linux no,pero de todos modos comprobamos:

python -c 'import sqlite3'

Si no ven ningún error no hay problema,si ven alguno tendrán que instalar,por ejemplo con pip:

pip install sqlite3

Bueno,primero que nada vamos a abrir nuestro editor de texto favorito para comenzar con los ejemplos,pueden usar la consola de python,pero yo recomiendo un editor y la shell de bash(la termina):

O sea dos terminales:

En mi caso vim(desde aquí se puede ejecutar el código sin usar otra terminal,pero yo uso dos).

Primero que nada vamos a crear un archivo .db,si no existe lo crea si no se conecta a el.

Vamos a crear una variable objeto para conectarnos al archivo  que guardara la base de datos:

db = sqlite3.connect('hola.db')

En estos momentos ya creamos un objeto para manipular la base de datos hola.db,ahora lo que tenemos que crear es un cursor para movernos(por así decirlo) dentro de la db,osea ejecutar comandos de lenguaje SQL en la DB:

cur = db.cursor()

Ahora vamos a ejecutar algunos comandos básicos de SQL con la función execute(este tutorial supone que tienes conocimientos básicos de lenguaje SQL):

cur.execute('CREATE TABLE holamundo(pal1 text,pal2 text)')

cur.execute('INSERT INTO holamundo VALUES("Hola","Mundo")')

Con eso ya tendriamos creada una DB basica,ahora vamos a guardar lo que hicimos con la funcion commit de la db:

db.commit()

Siempre debemos ejecutar commit o no guardara los cambios.

Por ultimo vamos a ejecutar la funcion close para que cierre la conexion:

db.close()

Podemos ejecutar nuestro script,asi quedaria:

 #!/usr/bin/env python3  
 import sqlite3  
 db = sqlite3.connect('hola.db')  
 cur = db.cursor()  
 cur.execute('CREATE TABLE holamundo(pal1 text,pal2 text)')  
 cur.execute('INSERT INTO holamundo VALUES("Hola","Mundo")')  
 db.commit()  
 db.close()  

Y listo tenemos una base de datos portable,si no me creen pueden ejecutar la shell de sqlite3 de linux:

sqlite3 hola.db

.tables

SELECT * FROM hola

Bien funciona :D.

Las ordenes que dimos con exec,las podemos dar en una sola linea ejecutando un script interno,con la función executescript del cursor:

Primero vamos a usar comillas triples,que son para varios comentarios,como DATA<< en Perl,Ruby o como --[[ ]]-- en lua:

cur.executescript("""
    CREATE TABLE holamundo(pal1 text,pal2 text);
    INSERT INTO holamundo VALUES("Hola","Mundo");
    INSERT INTO holamundo VALUES("Hola","desde SQLite Python");
""")

Añadí un comando mas para ver como funciona,en este caso no necesitamos hacer un commit ya que agrega y hace un commit internamente en cada orden.

Ya vimos como agregar ahora como obtener:

Para obtener los datos que necesitamos hay varias maneras,primero la mas sencilla,pero menos potente llamar un único valor:

Como se ve arriba el comando execute usa comandos SQL,si usamos comandos de creación crea,pero si usamos comandos de recuperación donde quedan?

Quedan en variables especiales que se convierten en tuplas,en este caso la función fetchone devuelve una tupla del primer valor que coincida:

cur.execute("SELECT * FROM holamundo")
print (cur.fetchone())

Eso nos devuelve una tupla desde una funcion,por lo cual es valido hacer esto:

print (cur.fetchone()[0])

Bien,pero si queremos todo?

Es fácil saberlo (sabiendo ingles básico),con el comando fetchall:

La cual nos devuelve una tupla de dos dimensiones(en este caso),ya que la primera dimensión contiene las dos tuplas que creamos,y la segunda dimensión contiene los valores de cada tupla:

print (cur.fetchall())

Por lo cual es valido hacer esto:

print (cur.fetchall()[1][1])

En este caso nos devuelve esto:

Bien,hay otra forma de recuperación de datos la cual es iterando sobre una orden de ejecución,ya que como nos devuelve una tupla podemos iterar sobre ella:

for tup in cur.execute("SELECT * FROM holamundo"): # Iteramos en la primera dimencion
    for val in tup: # Iteramos en la segunda dimencion
        print (val)
     
Bien vamos a temas mas avanzados de agregación de datos.

Supongamos que queremos poner un dato en la query que ejecuta la API de SQLite,en otras palabras queremos definir los valores que introduciremos en la tabla desde una variable,como le hacemos,¿Podemos usar formateo de cadenas?,Si,por ejemplo:

Borren la DB que creamos desde la shell:

rm hola.db

 #!/usr/bin/env python3  
 import sqlite3  
 db = sqlite3.connect('hola.db')  
 cur = db.cursor()  
 #cur.execute('CREATE TABLE holamundo(pal1 text,pal2 text)')  
 cur.execute("SELECT * FROM holamundo")  
 x,y = "Hola","Mundo" # Creamos variables  
 cur.execute('INSERT INTO holamundo VALUES ("%s","%s")' %(x,y)) # Formateamos  
 db.commit()  
 db.close()  

Eso se puede hacer,pero no se debe hacer,porque?

Por la vulnerabilidad de formateo de strings,por ejemplo una Inyección SQL.

Entonces que hacemos?

Podemos hacerlo de dos maneras creamos un dato tipo diccionario para que la query parse el valor desde los valores de un diccionario que es clave/valor o usando una tupla que no se puede cambiar el valor:

Primer ejemplo, metodo qmark:

cur.execute('INSER INTO holamundo VALUES(?,?)',(x,y))

En este caso usamos un estilo de formateo,pero con el símbolo (?) y le pasamos el valor desde una tupla,la cual no se puede modificar.

Segundo ejemplo, metodo de nombre:

cur.execute('SELECT * FROM holamundo WHERE pal1=:hola',{"hola":"Hola"});

print(cur.fetchall())

Este se ve un poco mas complejo pero es fácil,solo hay que pesarle los valores de un diccionario y como es una string para que no de error de valor debemos anteponer dos puntos en la query SQL,veamos otro ejemplo:

x,y = "Hola", "Mundo" # X vale Hola,Y vale Mundo

dic = {'x':x,'y':y} # Adentro del diccionario X vale X que a la vez vale Hola,Y vale Y que a la vez vale Mundo

cur.execute("INSERT INTO holamundo VALUES(:x,:y)",dic) # Insertamos los valores del diccionario,anteponemos dos puntos para que se reconozca como string.

Ahora como podemos ver las columnas?,ya que podemos ver los valores que contienen pero las columnas?

Aquí falta ver que columnas son las que contienen Hola y Mundo que serian pal1 y pal2,para ello vamos a cambiar el atributo row_factory de la db a sqlite3.Row:

db.row_factory = sqlite3.Row

cur = db.cursor()

cur.execute("SELECT * FROM holamundo")

Ahora podemos acceder a las llaves de la tupla que se crea cuando buscamos algo,recuerdan fetchone:

for i in cur.fetchone().keys():
    print(i)
 
También compatible con len:

print(len(cur.fetchone().keys()))

De esa manera tendremos las columnas de la tabla ya que por defecto fetch nos devuelve una tupla sqlite,y de esta manera nos devuelve una columna sqlite compatible con las funciones keys,len,entre otra.

De hecho la funcion sqlite3.Row es opcional,podemos programar nuestra propia funcion para que sea igual al parametro de row_factory de la DB,es un poco largo de explicar pero veamos un poco:

Creamos una funcion que sea igual a row:_factory,este parametro nos pasa argumentos,asi que vamos a recorrerlos con,con *args(recuerdan el tutorial):

 #!/usr/bin/env python3  
 import sqlite3  
 def datos(*args):  
   for i in args:  
     print (i)  
 db = sqlite3.connect('hola.db')  
 db.row_factory = datos  
 cur = db.cursor()
 cur.execute("select * from holamundo")
 print(cur.fetchone())
 db.close()  

Eso nos dirá los argumentos que nos manda,los cuales son:

El primero es un objeto mas específicamente un cursor,el segundo es la columna que regresa la query que ejecutamos y nos manda un tercero Nulo(None):

Así que podemos hacer esto,para ver las funciones que tienen:

 for i in dir(args[0]):
        print i

for i in dir(args[1]):

        print i

Y nos muestra las funciones de cada uno,en la pagina oficial nos muestra una manera de crear un diccionario,en este ejemplo seria así:

 import sqlite3  
   
 def dict_factory(cursor, row):  
   d = {}  
   for idx, col in enumerate(cursor.description):  
     d[col[0]] = row[idx]  
   return d  
   
 con = sqlite3.connect("hola.db")  
 con.row_factory = dict_factory  
 cur = con.cursor()  
 cur.execute("select * from holamundo")  
   
 print (type(cur.fetchone()))  
   
 for k in cur.fetchone():  
   print (k,"->",cur.fetchone()[k])
   

Todo lo que hicimos lo podemos hacer conectandonos directamente a la memoria ram,el cual nos dara un espacio de trabajo temporal,no lo recomiendo a menos de que sea un trabajo especial como un manejo de memoria basada en un algoritmo temporal,osea como una actualización basada en datos actuales que pueden cambiar,normalmente podemos hacer todo el trabajo en archivos,como en este tutorial en la base hola.db,de todas formas podemos conectarnos a una base de datos creada directamente en la memoria RAM la base de datos se destruirá cuando se cierre la conexión:

Para hacerlo necesitamos usar el parámetro :memory: en la conexión:

  #!/usr/bin/env python3   
  import sqlite3   
  db = sqlite3.connect(':memory:')   
  cur = db.cursor()   
  cur.execute('CREATE TABLE holamundo(pal1 text,pal2 text)')   
  cur.execute('INSERT INTO holamundo VALUES("Hola","Mundo")')  
  cur.execute('SELECT * from holamundo')  
  print(cur.fetchall())   
  db.commit()   
  db.close()  
   

Bien con eso terminamos este tutorial,tal vez haga otra parte ya que falto lo mas avanzado que es crear funciones y clases para usarlas como extensión,pero de momento es todo.

Esto es muy útil cuando se programan juegos,por ejemplo con pygame,o para android,un ejemplo rápido es ponerle un historial de juegos ganados al juego de ahorcado que programe en perl,así es usar Python junto con Perl es sencillo usar lenguajes juntos,así que vamos a ver como quedaría el script y haber si le entienden o encuentran errores con lo que aprendimos en este tutorial:

 #!/usr/bin/ev python3  
   
 from sys import argv  
   
 import sqlite3  
   
 db = sqlite3.connect('records.db')  
 db.row_factory = sqlite3.Row  
 cur = db.cursor()  
 num = 0  
   
 query = "SELECT * FROM ahorcado order by puntuaje"  
   
 try:  
   cur.execute(query)  
 except:  
   cur.execute('CREATE TABLE ahorcado(nombre TEXT,puntuaje INTEGER)')  
   
 def mayor_pal(p):  
   global num  
   if len(p) > num:  
     num = len(p)  
   
 def agregar(x,y):  
   gamer = x  
   puntos = y  
   cur.execute("INSERT INTO ahorcado VALUES(:jugador,:puntuaje)",{"jugador":gamer,"puntuaje":puntos})  
   db.commit()  
   
 def ver(x):  
   for i in x.execute(query):  
     mayor_pal(i[0])   
   print "\tJugador",(" "*num),"Puntuaje\n"  
   for i in x.execute(query):  
     print "\t",i[0],(" "*(num+4)),i[1]  
   
 if len(argv) > 1:  
   if argv[1] == "-a" and len(argv) == 4:  
     agregar(argv[2],argv[3])  
   elif argv[1] == "-v":  
     ver(cur)  
   else:  
     exit()  
   
 db.close()  

Al juego de ahorcado le hice también unas pequeñas modificaciones.

Pueden descargarlo aquí:

Enlace

Esto lo he aprendido de la documentación oficial como siempre,así que pueden darle una leeida para que aprendan de la misma fuente que yo:

http://docs.python.org/2/library/sqlite3.html

Leer más...

Como usar MongoDB con Python

Como vimos en el tutorial de Perl MongoDB es una gran base datos  NoSQL y orientado a documentos con licencia GPL v3 programada en C++ lo cual es bastante bueno y cuenta con APIs para los lenguajes de programación mas populares en este caso veremos que python no es la excepción.

Como en el tutorial de Perl se supone que ya tienes instalado MongoDB en tu sistema y sabes lo básico desde su propia interfaz.

Para usarlo en Python necesitamos instalar pymongo,el cual yo recomiendo que lo hagan con pip:

pip install pymongo

Ahora vamos a iniciar nuestro script de prueba:

Primero ponemos el hashbang y la codificación como siempre:

#!/usr/bin/env python3

Ahora importamos MongoClient que es que usaremos para la consulta de datos,

 from pymongo import MongoClient

Al igual que el tutorial de Perl vamos a usar los datos por defecto en host ponemos localhost y en puerto ponemos 27017:

cliente = MongoClient('localhost', 27017) 

Como dije son los datos por defecto y esto lo sabe la API asi que es lo mismo eso de arriba y esto:

cliente = MongoClient()

Con esto ya tenemos un objeto con los datos de mongo,digamos que es como si hubiéramos iniciado sesión en la shell de mongo.

Por ejemplo estas ordenes:

Como vemos aun esta lo que hicimos en el tutorial de Perl,para ver eso desde un script en Python vamos a hacer lo siguiente:

Teniendo el objeto cliente ya creado,vamos a acceder a la base de datos,en este caso test:

Podemos hacerlo con notacion de punto o en modo diccionario,recomiendo notacion de punto en este caso:

db = cliente.test

Para autentificarnos usamos esta sintaxis:

db.authenticate('user', 'password')

Ahora la variable db ya es un objeto que contiene los datos de la base test,ahora vamos a acceder a la colección,en este caso use some_cool:

De igual manera notacion de punto o diccionario pero en esta ocasión operamos sobre la variable db:

coleccion = db["some_coll"]

En estos momentos la variable colección cuenta con los datos de la colección some_coll de Mongo,podemos usar funciones de la misma como por ejemplo ver el numero de elementos:

En la shell de Mongo usaríamos:

db.some_coll.count()

Adivinen como se hace en python? :

print(coleccion.count())

Así :D

Y para hacer lo que hicimos en la imagen?

db.some_coll.find()

Primero iteramos sobre la función find del objeto colección que creamos y despues imprimimos:

for i in coleccion.find():

   print(i)

En la función find podemos pasarle como parámetro un filtrado,por ejemplo:

for i in coleccion.find({"value" : "foobar"}):
    print(i)

Bien ahora vamos a insertar datos desde pymongo,con un diccionario,por ejemplo:

1 2 3 4 5 6

datos = { "_id" : 3, "value" : "Hola Mundo desde pymongo" } coleccion.insert(datos)

Podemos hacer algo mejor:

1 2 3 4 5 6 7 8 9 10 11 12

datos = [ { "Nombre": "Perl", "Archivos": [".pl",".cgi"], "Modulos": "CPAN" }, { "Nombre": "Python", "Archivos":[".py","pyo",".pyc"] "Modulos": ["easy_install","pip"] } ]

Ahí creamos dos diccionarios adentro de una lista.

Para ver las bases colecciones disponibles,podemos usar:

db.collection_names()

Por ejemplo para recorrer todas las colecciones de una db:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

#!/usr/bin/env python3 from pymongo import MongoClient cliente = MongoClient() db = cliente.test for collection in db.collection_names(): colecion = db[collection] print("Coleccion : %s\n\n") %(collection) print("Datos:\n") for i in colecion.find(): print(i) print("\n\n")

Podemos hacer lo mismo con las bases de datos:

for dbs in cliente.database_names():

    print(dbs)

Si nos ponemos a pensar podemos ver todos los datos:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

#!/usr/bin/env python3 from pymongo import MongoClient cliente = MongoClient() for dbs in cliente.database_names(): db = cliente[dbs] print("Base de datos %s\n") %(dbs) for collection in db.collection_names(): colecion = db[collection] print("Coleccion : %s\n\nDatos:\n") %(collection) for i in colecion.find(): print(i) print("\n\n")

Que mas podemos hacer?

Podemos borrar databases con la función drop y le pasamos como parámetro el nombre de la base de datos:

cliente.drop_database("test_database")

Podemos saber la informacion del sistema de esta manera:

1 2 3 4

info = cliente.server_info() for k,v in info.items(): print ("%s : %s ") %(k,v)

Y muchas cosas mas:

Podemos borrar una colección asi:

db.drop_collection("some_coll")

Podemos borrar los datos de una colección asi:

coleccion.remove({"value" : "foobar"})

Y mas,como supe esto,por la documentación claro,pero cuando no hay documentación y uno es autodidacta trabaja con lo que tiene a la mano,y podemos ver todas las funciones haciendo un dir sobre el objeto,eso es todo :D.

Documentación : api.mongodb.org/

Leer más...

Manejo de errores en python parte 1/2

En la programación siempre cuando ejecutamos un  una solución escrita en algún lenguaje de programación lo más seguro es que de algunos errores ,a menos de que sepamos exactamente lo que estamos haciendo y como se va a comportar lo que estemos haciendo ,no es que no haya programadores que no se equivoquen pero esto no se trata de equivocarse si no de desviar problemas a soluciones y aun así un problema mismo podría ser una solución bien manejada.

En python tenemos una gran manera de manejar errores los cuales se basan en probar,con la palabra reservada try, para manejar un error solo es necesario encontrarlo primero, para ello vamos a ver un ejemplo:

Quiero importar el siguiente modulo:

 #!/usr/bin/env python3  
 # Le ponemos de nombre mi_modulo.py  
 def pinta():  
   print ("Hola")  

Y ahora en un script lo intentamos importar,pero accidentalmente nos equivocamos de nombre,o también podría ser que no lo tengamos siempre a la mano,por ejemplo que compartimos un código el cual necesita de ese modulo y las personas que lo descarguen solo descarguen el script y no asi el modulo,entonces en nuestro script lo importamos:

import mi_modulo

Ahora si ejecutamos el script,daria un error:

Mas en especifico el error:

ImportError

Ahora vamos a aprender como manejarlo,por ejemplo ese es un error de importación,en operaciones matemáticas tambien hay errores,en tipos de datos,en IO,etc,pero la misma consola nos dice cual es:

Para manejarlo usamos la palabra reservada except:

except nombre_error:

Pero antes adentro de una sentencia try hacemos lo que causa el error:

 try:  
   import mi_modulo  
 except ImportError:  
   # Aquí hacemos lo que queramos si entra en error,por ejemplo:  
   print ("No existe el modulo")  

:D

Python también nos deja manejar los errores desde el tipo exceptions,un tipo de dato que nos devuelve una tupla, esta tupla devuelve un numero de argumentos los cuales podemos usar,para el manejo de errores,en realidad no es una tupla,ya que el tipo de dato no lo verifica,pero retorna valores de tipo lista,solo que es inmutable:

Para ello usamos la palabra reservada as:

 try:  
   import mi_modulo  
 except ImportError as error:  
   print (error)  

Para ver los argumentos de error o el nombre que le asignemos usamos esta sintaxis:

print (error.args)

Y podemos hacer esto,por ejemplo:

 try:  
   import mi_modulo  
 except ImportError as error:  
   print (error[0])  

Ahora,si queremos manejar lo que sucedería después de esto,podemos hacerlo escribiendo fuera del bloque try/except pero si queremos que se ejecute en el mismo,podemos hacer uso de else:

 try:  
   import mi_modulo  
 except ImportError as error:  
   print (error[0])  
 else:  
   print ("Usando el modulo :D")  
   print ("O cualquier otra cosa")  

Por ejemplo:

 #!/usr/bin/env python3  
   
 try:  
   ar = open ("Archivo.txt","r")  
 except IOError as io:  
   for i in io.args:  
     print ("Error: %s")%(i)  
   print ("Tipo : %s")%(type(io))  
 else:  
   print ar.read()  
   ar.close()  

Otro ejemplo:

 #!/usr/bin/env python3  
   
 while 1:  
   print ("Bucle infinito" + ("-"*30))  
   try:  
     var = input("No puedes salir a menos que escribas salir : ")  
   except EOFError:  
     print ("\n;)")  
   except KeyboardInterrupt:  
     print ("\nSin trucos ;)")  
     continue  
   else:  
     if var.lower() == "salir" or var.lower() == "s":  
       break  

Eso es todo  de esta parte :D

Leer más...

Clases y objetos python 3 parte (2/4)

Tutorial clases python 3

Ya hablamos de las clases y como se definen y funcionan con sus metodos y variables de clase,ahora toca hablar de la herencia,la cual es cuando tomamos atributos de una clase madre llamada clase super(superclass),la cual le pasa atributos y metodos a nuestra clase hija de la cual deriva de la superclass.


La clase super es la clase a la cual no le pasamos argumentos o solo le pasamos el argumento object:

class Ejemplo(object):

Cuando una clase es creada a base de otra se usa el nombre de la superclase como parametro:

class Ejemplo2(Ejemplo):

Cuando creamos una clase nueva a base de otra clase,la clase hija tiene los atributos y metodos de la clase madre:

 #!/usr/bin/env python3  
 class Madre(object):  
   def __init__(self):  
     self.hola = “Hola mundo”  
 class Hija(Madre):  
   pass  
 ejemplo = Hija()  
 print (ejemplo.hola)  

Como vemos no se ha definido una nueva,cuando esto ocurre se le conoce como sobrecarga(override):

 #!/usr/bin/env python3  
 class Madre(object):  
   def __init__(self):  
     self.hola = “Hola mundo”  
 class Hija(Madre):  
   def __init__(self):  
     self.hola = “Hola otra vez”  
 ejemplo = Hija()  
 print (ejemplo.hola)  

Como podemos ver parece que sobrecargamos la variable,pero en realidad sobrecargamos el constructor,(el metodo constructor),por ejemplo:

Si lo ejecutamos dará un error porque no hemos definido la variable hola en el constructor de la clase hija.

Aun asi podemos sobrecargar el constructor,pero no así los demás métodos:

 #!/usr/bin/env python3  
 class Madre(object):  
   def __init__(self):  
     self.hola = "Hola mundo"  
   def hola(self): # Metodo de clase madre  
     self.hola = "Hola mundo"  
     return self.hola  
 class Hija(Madre):  
   def __init__(self): # Sobrecargacamos el constructor  
     self.otra_var = "Hola otra vez"  
 ejemplo = Hija()  
 print (ejemplo.hola()) # Ahora imprimimos el método  

Veamos un ejemplo,las Pc continen un forma especial,pero existen Laptos,Netbooks y cada una tiene su hardware y software,podriamos definir una Pc de esta manera:

class Pc(object):
   def __init__(self):
       self.partes = ['hardaware','software']
       self.stdout = 'pantalla'
       self.stdin = 'teclado'
       self.nombre = 'Pc'

Ahora definimos una netbook derivada de la clase Pc:

 class Netbook(Pc):  
   def __init__(self,arch,sistema,procesador):  
   Pc.__init__(self)  
 """^Para llamar el los atributos del constructor de la clase madre lo hacemos de esta manera"""  
   self.arch = arch  
   self.portable = 'muy portatil'  
   self.sistema = sistema  
   self.procesador = procesador  
   def ver(self):  
     print ('Una netbook %s arquitectura %s' %(self.procesador,self.arch))  
     print ('Contiene un sistema %s y es %s' %(self.sistema,self.portable))  
     print ('Es de la familia %s' %(self.nombre))  
     for i in self.partes:  
       print ('Partes : %s' %(i))  
 hp_mini = Netbook("x86","GNU/Linux","intel")  
 hp_mini.ver()  

Eso es todo,de momento aun faltan dos partes de clases y objectos,espero que haya quedada clara la idea de como se heredan atributos,en las proxias partes hablaremos de lo que falta,este codigo es el final:

Enlace

Leer más...

Saber la longitud mayor de un string en un diccionario Python

Algo que he necesitado hacer es saber cual es la string mas larga de un valor y una clave de un diccionario,esto es facil recorriendo y anaizando valor por valor y clave pro clave cada elemeto del diccionario:

Algoritmo:

1.Recorren el diccionario por clave y valor

2.Llenar dos valores con los valores de la longitud de las strings(listas en este caso)

3.Teniendo las listas devolver el elemento mas largo de la lista(numéricamente hablando)

En python eso luce asi:

 #!/usr/bin/env python3  
 Dic = {  
     "Clave" : "Valor",  
     "ClaveNumero2" : "Valor_numero2"  
 } # Diccionario de prueba  
 def espacios(valor,val=False): # Val false debuelve clave  
     strvalor,strclave = [],[] # Iniciamos dos listas para trabajar en el buble  
     for clave in valor: # Iniciamos el recorrido de claves  
         strvalor.append(len(valor[clave])) # Llenamos la lista con la longitud de cada valor  
         strclave.append(len(clave)) # Llenamos la lista con la longitud de cada clave  
     if val: # Si quieren el valor trabajamos el valor  
         strvalor.sort() # Sorteamos el valor de forma ascendente  
         return (strvalor[len(strvalor)-1]) # Regresamos el ultimo valor que es el mas alto  
     else: # Igual con la calve si es lo que desean  
         strclave.sort()  
         return (strclave[len(strclave)-1])  
 print ("La string mayor de clave es : %d") %(espacios(Dic,False)) # Probamos  
 print ("La string mayor de valor es : %d") %(espacios(Dic,True))  

Para que les funcione como debe,descomenten el código y asignen bien la sangría:

Les dejo el paste:

Enlace

Espero que les sirva :D.

Leer más...

Uso avanzado de print python 3 (2/2)

Hace un tiempo coloque una entrada de el uso de print de manera avanzada o mejor dicho de manera correcta,ya tiene tiempo que lo realice y para terminar con estas dos partes vamos a ver la segunda:

Parte 1

Primero que nada vamos a ver las secuencias de escape en Python 3:

Retroceder un espacio :

\b

 Nueva linea :

\n 

Retorno de carro :

\r 

Avance de hoja :

\f

Tabulador horizontal

\t

Tabulador vertical

\v 

Cualquiera de esas secuencias las podemos probar de esta manera:

print ("\nHola \tMundo\n") 

Ahora veremos las Expresiones de Formato:

Cadena :

%s

Entero:

%d

Flotante:

%f

Flotante notación científica:

%e

Decimal negativo:

%u

Cualquiera de las Expresiones de formato se pueden usar de esta manera:

print ("Entero : %d\nTexto : %s" %(1,"T"))

También podemos usar valores de variables,por ejemplo:

cadena = "Hola esto es un texto"

flotante = 3.14

print  ("Flotante : %f\nTexto : %s" %(flotante,cadena))


Se recomienda ver el tipo de dato que estamos usando con el comando

type()

En la consola de python:

Eso es lo mas importante otra cosa curiosa es dar color a la shell,pero se necesitan usar caracteres similares a la de la shell como los que vimos en el tutorial del PS1 de Unix SH,pero no los conosco bien en python :(.

En python existe un modulo que se llama colorama,pero es para python2 :(

pypi.python.org/pypi/colorama

Leer más...

Tutorial funciones python 3 parte 2

Seguimos con los tutoriales de python,vamos a acabar con funciones para en otro tutorial comenzar con clases y objetos,pero de momento veremos:

Alcance de variables

Listas y diccionarios como funciones

args* and **kwargs

Alcance de variables

1.Las variables son valores a los que asignamos un valor o otro valor para referirnos a dicho valor y poder usarlas,como por ejemplo:

x = 10

Ahí x ya no es x ya es 10,si lo llamamos como texto crudo(si que este envuelto en comillas)

Estas variables pueden cambiar su valor en cualquier parte del script/programa pero tienen solo un limite de alcance por ejemplo las variables que definamos en una función se consideran locales y no las podemos modificar fuera de esta:

#!/usr/bin/env python3
def localv():
      x = 10

print (x)

En este ejemplo estamos llamando una variable local,que solo funciona en la funcion local,para el programa general es invisible,no podemos mutar su valor desde el script principal,podemos hacer practicas como estas:

#!/usr/bin/env python3
def localv():
      x = 10
      return x

x = localv()
print (x)

Lo que acabamos de hacer es usar la función como un solo valor de regreso,asignarlo a una variable  global y imprimirla,esto se puede hacer en ciertos casos,pero no es necesario ya que para usar solo un valor podemos definirlo directamente desde el script principal,osea las llamadas variables globales,que pueden ser vistas y modificadas en todo el script así como desde una función solo que en la función tenemos que indicar que es una variable global o sera tratada como local:

#!/usr/bin/env python3
def localv():
      x = 10
      return x
x = 5 # Variable global
print (x)
# Intentamos Cambiar el valor desde la funcion,solo con llamarla:
print (localv)
# Llamamos nuevamente la variable global
print (x) 

No pasa nada,sin embargo usamos la función de python global y podemos trabajar con variables globales desde python:

La sintaxis :

global variable

Ejemplo:

#!/usr/bin/env python3
def localv():
      global x
 # Le decimos a python que usaremos la variable global x
      x = 10
      return x

x = 5 # Variable global
 con valor de 5
print (x)
# Cambiamos el valor desde la funcion,solo con llamarla:
print (localv())
# Llamamos nuevamente la variable global
print (x)

Ahora si,x pasa al valor 10 que se le asigna desde la función local :D

Algo que se debe hacer que si no,usamos la variable global en la funcion,para modificar su valor,no debemos definirla,por ejemplo si queremos regresar x desde la funcion no necesitamos definir nada,ya que x ya esta definida en el script principal:

#!/usr/bin/env python3
def localv():
      return x
 # En ningun momento de la funcion definimos x

x = 5 # Variable global
print (x)
# Llamamos x con una funcion

print (localv())
# Llamamos nuevamente la variable global
print (x)

Las variables tambien las podemos definir desde el paso de parametros al cuerpo de la funcion,por ejemplo podemos definir una variable es esta manera dentro de una funcion:

def ejemplo():
      x = 10
      print (x)

O podemos hacerlo de esta manera:

def ejemplo(x):
      print (x)

ejemplo(10)

O de esta manera,la cual es la que menciono:

def manera(y,x = 10):
      print (x)

manera(1)

De esa manera podemos definir una variable,local para nuestra funcion desde el paso de argumentos,si definirla en el cuerpo del script global.


Listas y diccionarios como funciones

Las listas y los diccionarios se pueden usar para llamar funciones y al igual que una variable con return,no hay mucho que decir,sobre los diccionarios aqui un turial:

Enlace

Ahora podemos usar el retorno de una funcion como la llave de un diccionario y llamarla desde print


#!/usr/bin/env python3

def suma(y,x = 10):
    return y + x

diccionario = {
'entero' : 10,
'cadena' : "String",
'real' : 3.23,
'funcion' : suma(2)
}

print ("Mi funcion: %s " % (diccionario['funcion']))

"Muy facil" :D

Ahora a la inversa,usando un diccionario en una adentro de una funcion:

Al igual que las variables podemos definir diccionarios en nuestro paso de argumentos,o adentro de la funcion(en el cuerpo de la funcion), en este caso voy a definir un diccionario vació en el paso de argumentos y lo voy a llenar en el cuerpo de la funcion,usando como valor de nuestras llaves los argumentos que le pasaremos en el diccionario global,para obtener el mismo resultado a la de llamar la llave funcion de nuestro diccionario global:

#!/usr/bin/env python3

def suma(y,x = 10,diccionario = {}):
    diccionario['x'] = x
    diccionario['y'] = y
    return diccionario['y'] + diccionario['x']

diccionario = {
'entero' : 10,
'cadena' : "String",
'real' : 3.23,
'funcion' : suma(2)
}

print ("Mi funcion: %s " % (diccionario['funcion']))

El mismo resultado :D

Ahora igual con listas:

Podemos definir el valor de una lista,con el valor del retorno de una funcion y igual que en los diccionarios podemos definir una lista adentro de una funcion:


#!/usr/bin/env python3

def suma(y,x = 10):
    lista = [y,x]
 # Definimos una lista local
    return lista[0] + lista[1]
 # Regresamos los valores sumados

lista = [ suma(3),2 ]
 # Definimos una lista global con el primer valor como una funcion

print ("Mi funcion: %s " % (lista[0]))

args* and **kwargs

Hemos hablado del alcance de  las variables dentro de nuestro script,y lo hemos visto a la hora de definir nuestras variables,pero tambien debemos aprender a definirlas bien y desde donde,ya que vimos esto:

def ejemplo():
      x = 10
      print (x)

O podemos hacerlo de esta manera:

def ejemplo(x):
      print (x)

ejemplo(10)

O de esta manera:

def manera(y,x = 10):
      print (x)

manera(1)

Otra mas:

def manera(y,x = 10):
      print (x)

numero = 1 # Variable global

manera(numero) # Pasamos valor de variable global a la funcion

Tambien de esta manera que es la que digo ahora

def manera():
      print (x)

manera(x = 1) # Variable local definida en ambito global

Como podemos ver definimos una variable que usaremos desde la llamada de la funcion,esto es muy bueno,porque si lo hacemos como el penúltimo ejemplo mandaremos una variable global a local y podemos cambiar su valor en cualquier momento:

def manera(numero,x = 10):
      print (numero)

numero = 1 # Variable global

manera(numero) # Pasamos valor de variable global a la funcion

numero = 10 # Cambiamos el valor

manera(numero) # Ya no es el mismo valor

Pero si lo hacemos asi:

#!/usr/bin/env python3

def manera(numero,x = 10):
      print (numero)

numero = 1 # Variable global

manera(numero = 2) # Definimos variable local desde ambito global

numero = 10 # Cambiamos el valor

manera(numero = 2) # Ya no pasa nada

Lo malo de esto es que debemos definir el valor cada vez,pero lo bueno es que no dependemos de variables globales,como ven podemos definir variables locales de muchas maneras,y no les digo como se hace realmente,porque no existe una definicion real,si fuera asi no existirían tantas formas,solo que debemos usar la que mas nos convenga,por ejemplo si necesitamos pasarle el regreso de una funcion de un modulo a una funcion,podemos definirla en una variable global primero y despues mandarla a la funcion,asi:

#!/usr/bin/env python3

import os
import time

def whoami(login):
    print ("Tu usario es %s" % (login))

Usuario = os.getlogin()

whoami(Usuario)

Ya que no es necesario hacer esto:

#!/usr/bin/env python3

import os
import time
  
def whoami(Usuario):
    print ("Tu usario es %s" % (Usuario))

whoami(Usuario = os.getlogin()) # Esto 

También funciona pero es muy incomodo,por lo menos en este caso,asi que vean bien cual es la forma de definición que les conviene mas para realizar lo que quieran ralizar.

Bien,como vemos podemos definir muchas cosas desde la llamada de la funcion,pero que tal si queremos definir muchas o definimos muchas :O

Por ejemplo :

llamando_funcion(1,3,4,534,345,23,324,234,23423,4234,23)

En la funcion pondríamos algo como:

def llamando_funcion(a,b,c,d,f,g,h,i,j,k,z):

Para este ejemplo entra perfecto *args,con *args podemos meter todo eso en un solo valor,llamado args y de tipo tupla,las tuplas son como las listas,de hecho son iguales,solo con un cambio que radica en muchos y en mucho su uso,es inmutable :(,no podemos cambiar su valor y se definen con parentesis en vez de corchetes,pero bueno hagan de cuenta que esto:

llamando_funcion(1,3,4,534,345,23,324,234,23423,4234,23)

Es esto:

tupla = (1,3,4,534,345,23,324,234,23423,4234,23)

Al llamar esto en la funcion:

def llamando_funcion(*args):

Se ve mejor y mas limpio que esto:

llamando_funcion(1,3,4,534,345,23,324,234,23423,4234,23)

Esto es automatico,al usar *args como parametro en la funcion nos convierte todos los argumetos que declaramos en la llamada a una tupla de nombre *args,y al igual que las listas llamamos asi:

tupla[numero]

Comenzando por el cero, aquí un ejemplo:

#!/usr/bin/env python3

def ejemplo(*args):
    print (args[0] + args[6])

ejemplo(1,2,3,4,5,6,7,8,9,0)

Como ven es sencillo, también podemos usar variables,listas,diccionarios,etc:

#!/usr/bin/env python3

def ejemplo(*args):
    print (args[0] + args[6])

variable = 6
lista = [2,3,4,5,1]

ejemplo(lista[4],2,3,4,5,6,variable,8,9,0)

Pero si queremos hacer esto:

ejemplo(var1 = 1,var2 = 2,var3 = 4,muchasvar = muchas)

Para eso esta **kwargs,ya que como *args nos devuelve una tupla,adivinen que nos devuelve **kwargs,un diccionario :D,que usa:

var1 como llave

y

1 como valor

En ese ejemplo,o por ejemplo:

#!/usr/bin/env python3

def ejemplo(**kwargs):
    print (kwargs['var1'] + kwargs['var2'])
    print (kwargs['muchasvar'])

muchas = "Muchos argumentos"

ejemplo(var1 = 1,var2 = 2,var3 = 4,muchasvar = muchas)

El hecho es solo tratar kwargs como un simple diccionario,tambien hay una cosa importate y es que no es necesario usar el nombre args y kwargs,aqui lo importante es usar los asteriscos (*)


#!/usr/bin/env python3

def ejemplo(**x):
    print (x['var1'] + x['var2'])
    print (x['muchasvar'])

muchas = "Muchos argumentos"

ejemplo(var1 = 1,var2 = 2,var3 = 4,muchasvar = muchas)


Eso es todo, en otra ocasión hablaremos de funciones lambda.

Leer más...

Tutorial funciones python 3 desde Unix

Este blog trata sobre muchas cosas,muchas desde iOS y Linux hasta programación de scripting,en este caso veremos python ya que últimamente ya no había escrito nada últimamente en esta ocasión veremos las funciones de python, únicamente eso ya que en una entrada pasada mostré como usarlas pero no nos adentramos mucho,en esta ocasión si nos adentraremos mas sobre lo mas importante de usar funciones,de hecho dividiré esta información en dos entradas y esta es la primera parte:

Las funciones son partes de código que usamos varias veces en el mismo,ya que una función la podemos definir una vez pero llamarla todas las que sea necesario,por ejemplo tenemos que hacer lo siguiente:

Tenemos nuestra edad,la fecha de nacimiento, después lo que queremos es saber cuantas horas hemos vivido,esto seria un poco complicado ya que tenemos que definir los dias de los meses,muchas estructuras selectivas y demás cosas, así que solo haremos que calcule nuestra edad sacando el dato de la edad ingresado por nosotros y la fecha actual sacada de un modulo,esta la multiplicara por 365 dias de cada año y 24 horas de cada dia,para saber cuantas horas habrá uno vivido cuanto cumpla dicha edad si no es que ya la cumplio(a eso me refiero con estructuras selectivas),pero también queremos hacerlo para jugar,por ejemplo le hacemos el test a un pariente o a alguien,osea los datos serian distintos:

Ese es el problema,facil el problema porque solo trata de algunas operaciones aritmeticas:

Por ejemplo esta seria la solución pero para una sola fecha de nacimiento:


#!/usr/bin/env python3

from datetime import datetime # Importamos el tiempo actual

nacimiento = numeros # Define el año en que naciste 

fecha = datetime.now()

ahora = fecha.year

vida = ahora - nacimiento

print ("A tus ", vida, "años habas vivido", vida * 365 * 24,"horas")

Bien como vemos es un ejemplo,para saber la fecha exacta debemos definir el mes y dia y hora,luego hacer una operación de resta sobre estructuras selectivas para tener el dato exacto.

El hecho es que para hacer esto de nuevo con una nueva persona o un nuevo dato tendriamos que hacerlo de nuevo,o por lo menos definir la fecha nuevamente, vida y print:

Por ejemplo(les pongo en rojo todo lo que tendríamos que modificar) para añadir otra persona :


#!/usr/bin/env python3

from datetime import datetime # Importamos el tiempo actual

nacimiento1 = numeros # Define el año de la persona 1

nacimiento2 = numeros # Define el año de la persona 2


fecha = datetime.now()

ahora = fecha.year

vida1 = ahora - nacimiento1

vida2 = ahora - nacimiento2


print ("A tus ", vida1, "años habas vivido", vida1 * 365 * 24,"horas") # Imprime la persona 1

print ("A tus ", vida2, "años habas vivido", vida2 * 365 * 24,"horas") # Imprime la persona 2

Esto seria muy malo y muy mala practica porque para eso existen las funciones,asi que vamos a ver como son y como funcionan para reducir ese codigo o algoritmos de ese tipo a un codigo simple,limpio y funcional:



Para empezar las funciones en python se definen con def,de ingles defining tambien llevan parametros y el freno de la sintaxis se define por espacios,ya que en Perl,C o javascript la sintaxis para terminar una linea es punto y coma (;), aquí en python la estructura de funciones y de todo se define por espacios:

En C:

#include <stdio.h>


int main()
{
    printf ( "También escribo en C\n" );
    return 0;
}

En Perl:

#!/usr/bin/env perl

&hola("Hola","Mundo")

sub hola {

my ($h,$m) = @_;

print "Y en Perl :D\n";

print "$h $m\n";

}

Como podemos ver aqui los espacios de reconocimiento de terminacion de linea son definidos por (;),en python como dije son definidos por espacios,pero solo en funciones,clases,estructuras selectivas,bulces u otros operadores de datos de ese tipo,no en todo se deb usar espacios,como en C o Perl se usa (;) en casi todas las lineas:


Vamos a definir nuestra primera funcion:

#!/usr/bin/env python3

# Primera funcion

def primera(n,l): # Le pasamos dos argumentos
      print ("Argumento 1: ", l,"\nArgumento 2: ", n)

# Llamamos la funcion

primera(2,"Texto") # Le pasamos los dos datos


Lo voy a explicar mas detalladamente:

def primera(n,l):

def : # def se usa para comenzar una nueva función,seguida de esta debe ir el nombre de dicha función y termina con dos puntos (:) para indicar que comienza el contenido de nuestra funcion

primera # Es el nombre de nuestra primera funcion,podemos usar el que gustemos

(n,l) # Dentro de estos parentesis definiremos el nombre de los valores que le pasaremos cuando llamemos la funcion,estos valores/variables son locales,solo serán y tendran este valor dentro de la misma funcion.

primera(2,"Texto")

primera # Si escribimos el nombre de la función ya lejos de su alcance(fuera de los espacios) python la llama a escena,si le definimos parámetros estos se los tenemos que pasar o de otra manera tendríamos que definirlos en la misma función,en este caso n es igual a 2 y l es igual a Texto ya dentro de la función.

Bien sabiendo esto podemos realizar el código del principio de nuevo pero con funciones:

#!/usr/bin/env python3

from datetime import datetime

fecha = datetime.now() # Variables

ahora = fecha.year # Globales

def calcula(nacimiento):

    vida = ahora - nacimiento

    print ("A tus ", vida, "años habras vivido", vida * 365 * 24, "horas") 

calcula(numeros) # Numero de primer persona

calcula(numeros) # Numero de segunda persona

calcula(numeros) # Numero de tercer persona

# Etc

Igual que en todos los lenguajes manejo mis datos como salida estándar en la consola desde print,a menos que nesesite usar ese dato para otra cosa,por ejemplo si quiero ese dato pero no lo quiero imprimir no necesariamente tengo que usar print para que devuelva un numero puedo imprimirlo desde la llamada de la funcion o incluso guardar el resultado en una variable:

Todo esto se logra con return que maneja la llamada de la función como el dato que regresa:

Por ejemplo necesitamos saber las horas pero necesitamos también multiplicarlos por los minutos:

#!/usr/bin/env python3

from datetime import datetime

fecha = datetime.now()

ahora = fecha.year    

def calcula(nacimiento):

    vida = ahora - nacimiento

    return vida * 365 * 24 # Ahora estamos regresando un valor al llamar a la funcion

persona1 = calcula(1990) # Convertimos el regreso de la funcion llamada en una variable

persona2 = calcula(1980) # Convertimos el regreso de la función llamada en una variable

print ("Dias vividos de la persona1 : ", persona1, "en minutos: ", persona1 * 60)

print ("Dias vividos de la persona1 : ", persona2, "en minutos: ", persona2 * 60)

De momento eso es todo,en la próxima parte hablaremos del alcance de las variables,usar diccionarios o listas en las funciones,definir variables desde funciones y de *args & **kwargs.

Leer más...