Tutorial Java en Linux Basico 6

En este tutorial veremos Objetos.

Un Objeto es una instancia de una clase,un Objeto se puede tratar separado de los demás teniendo sus propios métodos y variables,para crear un método de una clase se usa la sintaxis:

Clase objeto = new Clase();

Lo que se pasa entre paréntesis es lo que recibe como argumentos el constructor.

Vayamos por partes:

La clase mas simple y que siempre se usa es donde esta el main,por ejemplo nuestro programa HolaMundo.java tiene esto adentro:

1 2 3 4 5

class HolaMundo { public static void main(String [] args) { System.out.println("Hola Mundo"); } }

Como ven pueden pensar que el main es el constructor,pero primero hay que saber que es un constructor,en mis palabras un constructor es:

Una función que se ejecuta antes que ninguna para inicializar o ejecutar acciones especificas.

En java todas las clases publicas deben tener el nombre del archivo que las contiene,en este caso HolaMundo,porque el archivo es HolaMundo.java.

Como crear un constructor?

El constructor es una función sin retorno y sin modificadores,esta debe tener el mismo nombre de la clase,vamos a crear un constructor para ese código:

1 2 3

HolaMundo(int x) { System.out.println("Hola se a creado el objeto numero "+x); }

Este constructor lo único que hace es mostrar el numero de veces que se ha creado el archivo,basado en el paso por argumentos,veamos el código completo:

1 2 3 4 5 6 7 8 9 10 11

class HolaMundo { HolaMundo(int x) { // Constructor System.out.println("Hola se a creado el objeto numero "+x); } public static void main(String [] args) { System.out.println("Hola Mundo"); for (int i = 1;i < 11;i++) { HolaMundo objeto = new HolaMundo(i); // Creamos objetos basados en el bucle } } }

Eso demuestra como se crean los constructores y como es que se ejecutan,no es el mejor ejemplo y de hecho veo mala practica al usar una variable renovada en cada iteracion del bucle,pero eso no es lo que importa,lo que importa es ver como se ejecuta lo que esta adentro del constructor.

Algunas cosas que debemos saber de un constructor es que:

1. Siempre hay un constructor aunque no creemos uno javac lo hace por nosotros.

2. Puede haber mas de un constructor (overloaded;lo veremos mas adelante).

3. Repito, un constructor no lleva ni modificador y modificador de acceso.

Ahora si podemos ver algo un poco mas bueno que la mala practica de arriba,por ejemplo si queremos ver cuantas veces se ha creado un objeto usamos una variable static,como dije en el primer tutorial una variable de modificador static solo se crea una vez,solo una vez.

Algunas cosas que hay que saber o recordar de static:

1. No se considera OOP.

2. Solo se crea una vez.

3. Solo se pueden usar metodos static en métodos del mismo tipo de modificador(static),pero no así a la inversa.

4. Los métodos static en una clase se consideran métodos de clase y no métodos de objeto.

Veamos un ejemplo:

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

class Ejemplo { private static int veces = 0; Ejemplo() { System.out.println("Hola se a creado el objeto numero " + veces); veces++; } public static void main(String[] args) { System.out.println("Hola Mundo"); Ejemplo objeto = new Ejemplo(); Ejemplo objeto1 = new Ejemplo(); Ejemplo objeto2 = new Ejemplo(); } }

De ese modo podemos usar esa variable static para ver como cuantas veces se ejecuta,como dije los métodos static en una clase se llaman métodos de clase,para llamarlos no necesitamos crear un objeto,por ejemplo:

1 2 3

public static void getVeces() { System.out.println("Numero de objetos creados: "+veces); }

Para usar este metodo no tenemos que instanciar un objeto y luego llamar el metodo:

Ejemplo objeto = new Ejemplo();

objeto.getVeces();

Aunque si funciona,lo que podemos hacer es:

Ejemplo.getVeces(); // Directamente

O mejor aun,las variables static se llaman variables de clase y podemos llamarlas asi:

Ejemplo.veces;

Código completo:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

class Ejemplo { private static int veces = 0; Ejemplo() { System.out.println("Hola se a creado el objeto numero " + veces); veces++; } public static void main(String[] args) { System.out.println("Hola Mundo"); Ejemplo objeto = new Ejemplo(); Ejemplo objeto1 = new Ejemplo(); Ejemplo objeto2 = new Ejemplo(); Ejemplo.getVeces(); } public static void getVeces() { System.out.println("Numero de objetos creados: "+veces); } }

Como vemos estamos trabajando solo con la clase del main,pero como creamos nuevas,para crear otras clases podemos hacerlo de distintas maneras para distintas ocasiones,ya que podemos crear clases locales,anónimas,etc pero en este caso veremos clases normales,al gual que la que guarda el main.

Para crear una clase creamos un archivo en el mismo PATH(directorio) donde esta el main,en su momento también hablaremos de paquetes,pero de momento creen una clase,llamada Animales.java:

Esta clase va ademas de la que contiene el main que se llama Ejemplo.java:

vim Animales.java

La clase debe ser publica y el nombre debe ser el mismo del archivo:

public class Animales {

}

Vamos a crear unas funciones y variables para definir un animal,las cuales deben ser private:

Las variables private solo son visibles para la misma clase,objeto instanciado no lo podra llamar,lo cual hace que sean ocultadas para todo lo que no sea la misma clase,a esto se le conoce en el OOP como encapsulamiento.

Vamos a crear las variables:

private String especie;
private String sexo;
private boolean hambre = true;

Luego vamos a crear un constructor que reciba como parámetros las mismas variables,pero estas seran para definir las variables miembro(las de arriba):

Animales (String e,String s) {
       especie = e;
       sexo = s;
}

Ahora debemos crear una funcion que nos muestre el nombre,el sexo y si tiene hambre,ademas de una funcion para dar de comer:

Primero las funciones para ver el sexo y la especie,como son variables privadas no las podemos ver,asi que vamos a retornarlas como String,para ello tenemos que usar el token this,ya que this hace referencia a la variable del objeto actual,asi:

public String getEspecie() {
return this.especie;
}

Código completo:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

public class Animales { private String especie; private String sexo; private boolean hambre = true; public Animales(String e,String s) { especie = e; sexo = s; } public String getSexo() { return this.sexo; } public String getEspecie() { return this.especie; } public void tienesHambre() { if (hambre) System.out.println("Tengo hambre :("); else System.out.println("No tengo hambre :D"); } public void darDeComer() { this.hambre = false; } }

Como ven uso this para retornar,pero tambien se puede usar para definir,por ejemplo que los parámetros tuvieran el mismo nombre,usariamos this para hacer referencia a la variable miembro:

1 2 3 4

public Animales(String especie,String sexo) { this.especie = especie; this.sexo = sexo; }

Ahora en la clase Ejemplo podemos crear un animal:

1 2 3 4 5 6

class Ejemplo { public static void main(String[] args) { Animales Mono = new Animales("Primate", "Macho"); System.out.println(Mono.getEspecie()); } }

De esa manera hemos usado una clase mas ademas de la que contiene el main,podemos crear tantos animales como queramos y nuevos métodos,pero eso no es lo importante ahora ya que por ejemplo,en este ejemplo a la hora de comer se define en true,pero como vuelve a false(darle hambre de nuevo),pues esto lo veremos cuando veamos Threads,y como poder definir un animal mas especifico,esto lo veremos en herencia,pero de momento solo vimos como crear un objeto de una clase ajena al main.

Al ejecutar veremos esto:

Bien,algo que falta explicar en este tutorial basico de creación de objetos es la sobrecarga de métodos en la cual también veremos la sobrecarga de constructores:

En una clase puede haber distintos metodos con el mismo nombre,pero como se diferencian?

Con el simple hecho del paso por parametros:

Podemos tener estas dos funciones en la misma clase:

1 2 3 4 5 6 7

public void verNumero() { System.out.println(veces); } public void verNumero(String x) { System.out.println(x+veces); }

Esto hará que podamos usar en el objeto:

Objeto.verNumero();

o

Objeto.verNumero("Veces creado : ");

Como dije lo único que lo distingue son los parametros,podriamos decir que lo distinguen los retornos,pero no,ya que el compilador no puede reconocer esto:

1 2 3 4 5 6 7

public void verNumero() { System.out.println(veces); } public int verNumero() { return veces; }

Bien,de igual manera pasa con los constructores,podemos definir dos constructores para los Animales,supongamos esto,podemos darle de comer antes de crearlo,asi que así seria el constructor:

1 2 3 4 5

public Animales(String e,String s,boolean x) { especie = e; sexo = s; hambre = x; }

Esto aun teniendo el constructor pasado, de esta manera podemos usar dos constructores:

new Animales("Primate", "Hembra");

o

new Animales("Primate", "Hembra",false);

Aunque no se obstruye uno con otro es recomendable iniciar todos los constructores,para ello usamos this,pero ahora con parámetros:

Por ejemplo llamamos:

Animales mono = new Animales("Primate", "Hembra");

En el constructor usamos this antes que nada:

1 2 3 4 5

public Animales(String e,String s) { this(e,s,false); especie = e; sexo = s; }

El this inicia el otro constructor.

Como dije al principio podemos si no usamos constructores el compilador creara uno,si existen variables miembro sin iniciar,las cuales iniciaremos en un método,las variables se inician al valor por defecto:

Por ejemplo int 0,String u Objeto null,etc:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

public class Ejemplo2 { private int vint; private boolean vbool; private char vchar; private short vshort; private long vlong; private double vdouble; private String vString; public void ver() { System.out.println(vint); System.out.println(vbool); System.out.println(vchar); System.out.println(vshort); System.out.println(vlong); System.out.println(vdouble); System.out.println(vString); } }

En el main:

1 2 3 4 5 6 7

class Ejemplo { public static void main(String[] args) { Ejemplo2 ejemplo = new Ejemplo2(); ejemplo.ver(); } }

Aqui terminal la sexta parte de los tutoriales de Java.

Leer más...

Solucion Eclipse no muestra menus en Ubuntu 13.04 13.10

Hace un tiempo traigo un problema de menus en Ubuntu 13.10,lo que pasa es que no muestra las opciones como debe,y es que se puede deber a que la versión que tengo de eclipse la descargue de Internet y no de los repos.

No se si ocurra este problema con mas programas ya que también me ha sucedido en rhythmbox y eso que viene por defecto en Ubuntu,pero bueno encontré una solución en internet:

Tutorial

Abrimos una terminal:

Ctrl+Alt+T

Luego editamos el lanzador:

Primero vamos a donde se guardan:

cd /usr/share/applications

Ahora por ejemplo yo cree el lanzador de mi aplicación,se llama android-dev.desktop:

Abren con nano como super usaurio su lanzador,por defecto puede ser eclipse-* o si lo crearon ustedes lo abren con su nombre,en mi caso:

sudo nano android-dev.desktop

Ahora añadimos antes de la ejecucion:

Por ejemplo yo tengo asi:

Exec=/home/user/adt-bundle-linux-x86/eclipse/eclipse

 Añado entre el exec y la ruta:

env UBUNTU_MENUPROXY=0

También puede decir:

Exec=eclipse 

De igual forma que quede así:

 Exec=env UBUNTU_MENUPROXY=0 eclipse 

Eso es todo :

Esto no funciona en rhythmbox ya que usa otro tipo de menus :(

Fuente : askubuntu.com/

Leer más...

Tutorial SQlite3 Tipos DML DDL

Este es el primer tutorial para usar Sqlite en su versión 3 que es la versión que uso,yo tengo instalada la versión 3.7.17 , no la instale directamente pero se debe haber instalado como dependencia con algún conjunto de herramientas que instale en sistema,por lo que lo mas seguro es que no necesiten instalar en su sistema o lo que es lo mismo ya la deben tener instalada.

Antes que nada este tutorial o serie de tutoriales va dedicado solamente a sistemas Linux de escritorio,no BSD,no Windows,no iOS, no Android,etc.Ya que estos tutoriales los vamos a realizar desde la misma shell de SQlite o sea desde la interfaz que nos ofrece la terminal de nuestro sistema Linux.

Bien el titulo de la entrada parece un poco raro ya que no acostumbro a hacer referencia a las introducciones de temas que hago,pero vamos a explicarlo un poco.porque en este caso es necesario:

SQL es un lenguaje de consulta mas en especifico un lenguaje de consulta estructurados ahora en ingles :

Structured Query Language

Los SQL se usan para hacer consultas a bases de datos,en este caso SQlite3 es nuestro consultor y aunque vamos a usar un nivel intermedio para comunicarnos con las bases de datos y no me refiero al nivel de dificultad,bueno un poco ya que por ejemplo hasta un usuario de una Pc que no sepa nada de programación o de nada,solo que entre a un navegador web y busque algo en google,por ejemplo ya esta manipulando una base de datos,pero a un nivel muy alto,de usuario final,en este caso nosotros usaremos un nivel intermedio gracias a SQL,en este caso SQLite.

El DML es llamado así por la abreviación de Lenguaje de Manipulación de Datos,ahora en ingles:

Data Manipulation Language 

Los comandos(en rojo) se usan para lo siguiente(morado):


SELECT Consulta registros

INSERT Inserta datos en una sola operación.

DELETE Borra(modifica) los datos especificados de un registro.

UPDATE Actualiza(modifica) los datos especificados de un registro.


Esto se usa para  manipular datos en una base de datos de modelo relacional ,lo que es SQLite.

DML es llamado así por la abreviación de Lenguaje de Definicion de Datos,en ingles:

Data definition language

Los comandos(en rojo) se usan para lo siguiente(morado):

CREATE  Crea nuevas tablas e índices
DROP Elimina tablas e índices
ALTER Modifica las tablas agregando columnas o modificando su valor.

Bien no me gusta mucho meterme en esa parte pero bueno,primero que nada vamos a abrir una terminal y vamos a crear un archivo db llamado hola.db:

sqlite3 hola.db

Si no encuentras sqlite3 deben instalarlo según su distribución,pero lo mas seguro es que ya lo tengan.

En este caso crea un base de datos hola.db si ya existe la abre si no existe la crea.

Los comentarios en SQLite son similares a los de Lua para una sola linea,deben comenzar con dos guion medio:

-- Un comentario

Y para los de varias lineas se parecen a los de PHP:

/*
 Un comentario de varias lineas
 De varias lineas :D
*/;

Los  comandos básicos que podemos usar son:

.help -- Muestra ayuda

.version -- Muestra la versión

.databases -- Muestra las bases de datos

..exit -- Sale

.quit -- Sale

.tables -- Muestra las tablas

.read script(lineas de ordenes SQL) -- Ejecuta scripts en .sqlite

.prompt estilo->PS1 estilo->PS2 -- Cambia el estilo de la prompt

Estos son los tipos de datos que podemos implementar en SQLite3:

NULL Valor nulo.

INTEGER Numero entero almacenado en  1, 2, 3, 4, 6 bytes.

REAL Valor de punto flotante, guardado en 8-byte como numero de coma flotante.

TEXT Texto.

BLOB Dato no especificado(Binario) que se guarda como entra.

De momento eso es todo en las siguientes partes veremos ejemplos del uso de DLL y DML.

Leer más...

Tutorial lua en linux(modulos) parte 1

Este tutorial es un poco mas avanzado,para realizar este tutorial ya se deb saber como usar funciones,estructuras selectivas y variables. Cambien es bueno saber usar tablas pero aun no esta listo el tutorial de ellas aquí,cuando se tenga listo lo citare y se podrán leer los dos tutoriales para complementarse entre si.

Un modulo en teoría podríamos decir que es una variable que toma el contenido de un archivo,los módulos nos hacen fácil el trabajo a la hora de programar programas largos,ya que podemos dividirlos en subprogramas o módulos y resolver los problemas de forma mas sencilla.

Un modulo en lua es como un objeto,no tanto como en Perl que se usa para crear clases pero se parece a lo que seria una clase,también se parece mucho a la forma que usa módulos Python,asi que si ya lo conocen verán el parecido,es como una mezcla de referencias Perl y módulos Python.

Primero que nada vamos a usar módulos que están definidos por el sistema y luego crearemos nosotros mismos algunos.

Primero que nada los módulos los llamamos con la palabra especial require,como en otros lenguajes,los módulos del sistema en algunos casos no es necesario llamarlos,pero como he dicho antes es bueno para saber que usamos.

El modulo os:

Para llamarlo:

require 'os'

Los módulos pueden ser escritos en C o en Lua,tienen terminación .lua o .so,se guardan en el PATH de Lua por defecto,o en el caso de los que creamos en el mismo directorio.

No necesitamos usar la extensión a la hora de llamarlos.

El Path lo podemos consultar en el modulo package,de la siguiente manera desde la terminal:

lua -e 'print(package.path)'

Y los módulos de C:

lua -e 'print(package.cpath)'

Continuamos con el módulos os:

Como ya hemos llamado os,podemos usar sus funciones:

Por ejemplo podemos llamar variables de entorno con la función getenv:

Por ejemplo en la shell de bash podemos saber el usuario actual asi:

echo $USER

O el PATH de los programas del sistema así:

echo $PATH

En lua:

print(os.getenv("USER"))

print(os.getenv("PATH"))

Podemos borrar un archivo así:

os.remove("archivo")

Podemos renombrar un archivo así:

os.rename("viejo_nombre", "nuevo_nombre")

Podemos ejecutar un comando del sistema asi:

os.execute('date')

Para cerrar el programa:

os.exit(1)

Existen muchas librerías,pero ese es un ejemplo de como se pueden usar,otra cosa que se debe aclarar es que se puede cambiar el nombre del modulo como en python:

sistema = require 'os'

print(sistema.getenv("PATH"))

Bien ahora vamos a crear nuestro modulos:

Primero que nada el modulo lo guardamos en la carpeta donde estamos,si queremos crear una tipo biblioteca,ascendente al path actual podemos usar la notación de punto,por ejemplo:

Tenemos el sistema así:

A la hora de llamarlo usaríamos:

requite 'lib.modulo'

Bien vamos a crear un modulo,por ejemplo itimetux.lua:

vim itimetux.lua

Lo primero que vamos a hacer es que todo lo que usemos va a ser local,para amarrarlo dentro del modulo creamos una tabla local:

local itimetux = {}

Ahora podemos crear una función:

function itimetux.info()
    print("Version 1.0")
end

function itimetux.saluda(x)
    print("Hola "..x.." soy itimetux")
end

Luego tenemos que regresar el modulo,como esta todo amarrado basta con retornar la tabla:

return itimetux

Ahora en el programa principal,vamos a llamarlo pasandole el valor a una variable:

#!/usr/bin/env lua

itime = require 'lib.itimetux' -- Pasamos valor a una variable

itime.info()

itime.saluda("Atheyus")

Podemos usar funciones privadas haciéndolas locales y no metiendolas en la tabla que es el modulo,de esta manera podremos usar funciones privadas para nuestro modulo,por ejemplo:

local itimetux = {}

local function dominio() -- funcion privada
    return "http://www.itimetux.com"
end

function itimetux.info()
    print("Dominio : "..dominio())
    print("Version 1.0")
end

function itimetux.saluda(x)
    print("Hola "..x.." soy itimetux")
end

return itimetux

Ahora podemos usar la función privada desde el modulo pero no la podremos usar desde el programa principal.

Para no usar un nuevo nombre basta con hacer que la tabla no sea local,en vez de:

local itimetux = {}

Usamos:

itimetux = {}

Y en programa principal usamos:

require 'itimetux'

itimetux.info()

Hay otra manera de crear módulos,el cual es que no tengamos que usar una tabla,es un metodo mas raro,ya que tenemos que retornar cada función,pero se puede hacer de esta manera tambien:

local function dominio() -- funcion privada
     return "http://www.itimetux.com"
end

local function info()
    print("Dominio : "..dominio())
    print("Version 1.0")
end

local function saluda(x)
    print("Hola "..x.." soy itimetux")
end

return { info = info ,saluda = saluda} -- retornamos las funciones que usaremos en el programa principal,las demas seran privadas

En el programa principal se puede usar de la misma manera el modulo.

Vamos a hacer algo mas útil,vamos a crear un modulo que lea los contenidos de un directorio:

local function read(dir) 
    local _files = {} -- Creamos una tabla para guardar los archivos
    local i = 1
    for files in io.popen("ls "..dir):lines() do -- Iteramos con un pipe,que use ls(funcion del sistema)
         table.insert(_files,i,files) -- Insertamos en la tabla los archivos
         i = i + 1
     end
     return _files -- Regresamos una tabla con los archivos (return de la funcion)
end

return {read = read} -- Regresamos la funcion (return del modulo)

Ahora supongamos que le llamamos readdir.lua y lo tenemos en lib/,para llamarlo en el programa principal hacemos esto:

readir = require 'lib.readdir'

archivos = readir.read(".") -- Leemos los archivos del directorio actual

-- Y por ultimo iteramos:

for i=1,#archivos do -- De i al numero de elementos de la tabla
    io.write(string.format("Archivo %d : %s\n",i,archivos[i])) -- Formateamos la cadena
end

Eso es todo de la parte 1,faltan cosas mas avanzadas las cuales hacen uso de metatablas,entornos,etc,pero primero haré tutoriales sobre eso para que se entienda mejor.

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

Tutorial Vim

Vim y es un editor de texto tipo consola muy poderoso,solo que las personas que están acostumbradas a las interfaces de Gtk,Tk,Qt o cualquier otro,se les puede hacer raro como usarlo.

En esta entrada se pretende entender como funciona y dejar de depender  de las interfaces gráficas,ya que un editor de tipo consola como este o como nano,joe se pueden usar en shell,osea desde una conexión ssh o desde la tty lo que nos vendrá muy bien en distintas situaciones.

Como dije aprenderemos como usarlo como editor por defecto,o preferido,ya que tiene grandes ventajas.

Programar scripts para el sistema desde la shell,cuando no tengamos entorno de escritorio.

Configurar el sistema cuando no tengamos entorno de escritorio,muy bueno para instalaciones de linux como gentoo,arch o FreeBSD.

Otra cosa que es muy propia para mi es que al usar este editor sin extensiones de lenguaje,aprenderemos mas a programar,esto lo digo y es muy propio porque cuando usamos un IDE,solo ponemos una letra y tab y nos autocompleta toda la sintaxis de una orden del lenguaje de programacion(claro ejemplo java en IDE),tal vez sea mas practico a la hora de velocidad,pero siento que hace a uno mas flojo.

Como dije vamos a aprender lo básico,hay algunas cosas mas practicas para cuando ya sabemos la básico,lo cual podemos verlo en este enlace.

Tutorial

Primero que nada debemos instalarlo en nuestro sistema

Ubuntu/Debian

sudo apt-get install vim

Gentoo

sudo emerge -av vim

FreeBSD

sudo pkg_add -rv vim

Son los sistemas que uso,para otros solo usen el comando de instalación de su sistema.

Ahora podemos iniciar a usarlo de dos maneras:

Abrimos una terminal(si estamos usando un entorno de escritorio).

La primera es desde su propio explorador ya que tiene un explorador propio,podemos escribir:

vim ~

Y nos abre su explorador en nuestro home,pero eso es un poco mas avanzado asi que nos concentraremos en la otra forma.

Si entraron con el comando anterior,para salir:

ZZ

La segunda es usar el explorador de archivos de bash(unix) con los comandos cd,ls,etc.

Nos damos locación en una carpeta,por ejemplo:

cd ~/Documentos

Y escribimos vim.

Al hacer esto veremos una pantalla como esta:

Ahí estaremos en modo comando,en el cual teclearemos todos los comandos que veremos.

Para comenzar a escribir tecleamos:

i

Esto es lo mas común a la hora de iniciar un nuevo archivo.

Para guardar nos ponemos en modo comando de nuevo de la siguiente manera:

boton esc

o

ctrl + c

Luego escribimos:

:wq nombre archivo

Por ejemplo si quisiéramos que se llamara hola.lua,lo haríamos así:

:wq hola.lua

Bien ahora los comandos de manejo de archivo:

:w => Salvar (posibilidad de añadir nombre del fichero).

:q => Quitar(si no tocamos).

:q! => Quitar(si tocamos), no guarda los cambios.

ZZ => Salvar y quitar.

:wq => Salvar y quitar(posibildad de añadir nombre del fichero).

:w! => Salva(en archivos de solo lectura),esto lo vimos en los permisos de unix,podemos quitarle los permisos de escritura desde bash con chmod -w archivo.

Ahora que ya tenemos un archivo,la próxima ves podemos abrir el archivo así:

vim hola.lua # ejemplo de archivo

Ahora estamos en modo comando,podemos comenzar a escribir con i,como arriba pero tenemos mas opciones:

Escribe me refiero a donde puedes comenzar a escribir.

i => Escribe antes de la letra señalada.

I => Escribe al principio de la linea señalada.

a => Escribe después de la letra señalada.

A => Escribe al final de la linea señalada.

o => Crea una nueva linea para escribir.

O => Crea una nueva linea para escribir(antes).

De esa manera podemos comenzar a escribir de una buena manera.

Vim cuenta con la función undo,algo que es inestable en nano,lo cual es muy bueno ya que nos permite deshacer los cambios que hayamos hecho,para ello escribimos en modo comando la letra:

u

Eso seria lo que seria ctrl + z,ahora lo contrario que es lo que seria ctrl + y,lo hacemos escribiendo en modo comando un punto:

.

También contamos con opciones de borrado en modo comando:

x =>  Para borrar el carácter siguiente a donde esta la letra señalada,seria el equivalente a supr.

X => Para borrar el carácter antes de  le letra señalada,seria el equivalente a del.

Y también tenemos opciones de copy and paste,en modo comando:

dd => Corta la linea señalada.

P => Pega una linea antes.

p => Pega una linea despues.

yy => Copia la linea señalada.

También podemos copiar o cortar varias lineas,solo debemos señalarlas antes,por ejemplo cortar 5 lineas:

5dd

o cortar 3:

3yy

Esto también vale para x(para cortar palabras).

Por ejemplo cotar una palabra de 3 letras:

3x

O borrar cualquier palabra se puede en modo comando con:

dw => Se borrara la palabra señalada.

Algo que también es muy bueno en vim es que nos podemos dirigir a una linea en especifico,por ejemplo si programamos un script y nos da error en la linea 345,solo tenemos que hacer esto para dirigirnos a ella:

En modo comando:

:345

Podemos poner cualquier numero de linea del archivo,pero también contamos con caracteres especiales:

:$ => Final del archivo.

:0 => Principio del archivo.

En nano por ejemplo es muy fácil buscar algo en un archivo con ctrl + w,en vim solo tenemos que escribir esto en modo comando:

/palabra_a_buscar

Por ejemplo buscar funciones en un script en python,como en python las funciones se declaran con la palabra def seguida de un espacio,hacemos lo siguiente:

/def\s

Aquí buscamos la palabra def seguida de un espacio(\s en regex es espacio),cuando tengamos la palabra presionamos enter,y la busca si no la encuentra nos dirá,si encuentra mas de una nos desplazamos con la tecla:

n => A la siguiente coincidencia.

El comando anterior busca hacia adelante de donde estamos con el cursor de vim,si queremos buscar hacia atrás usamos el  signo ?:

?def\s

Si queremos buscar desde la primera linea estemos donde estemos, usamos primero el simbolo ^,que quiere decir inicio:

/^def\s

Por ultimo,si queremos remplazar una palabra podemos usar este comando que es al estilo perl:

:linea_inicio,linea_final, s/palabra/remplazo/g

La g del final se usa para que recorra toda la linea,si queremos remplazar la palabra en todo el archivo usamos:

:1,$ s/palabra/remplazo/g

Por ejemplo remplazar print,por say en un script en perl:

:1,$ s/print/say/g

Faltan muchísimas cosas ya que vim es un editor con mucha potencia,por ejemplo insertar texto mezclando archivos,convertir a hexadecimal,octal,etc ejecutar ordenes de la shell,encriptar,etc,pero de momento es todo :D.

Leer más...

Tutorial lua en linux (condicionales)

En esta parte de los tutoriales de Lua aprenderemos a usar condicionales o como aprendí a decirles,estructuras selectivas las cuales deciden que "camino" elegir para un programa,y decidir que ejecutar basado en esta elección.

Tenemos de ejemplo esto:

Voy a usar mi pc con Internet,primero debo ver si tengo electricidad,si tengo la prendo,si no la conecto o no la prendo,luego si la prendo necesito Internet,si hay lo uso,si no hay me conecto a wifi,etc.

Vamos a ver un ejemplo y después lo explico:

 #!/usr/bin/env lua  
   
 -- Vemos si tiene energia la pc  
   
 t = {"Si","No"}  
   
 math.randomseed(os.time())  
   
 num = math.random(1,2)  
   
 -- ^ Funciones para elegir un numero al azar y asociarlo a una respuesta  
   
 res = t[num] -- Asociamos respuesta  
   
 function enciende()  
     repeat  
       io.write("Encender? (S/N):")  
       response = io.read()  
     until response == "S" or response == "N"  
     if response == "S" then  
       print("Encendida :D")  
       while true do  
         io.write("Ejemplo terminado\nEscribe exit para salir: ")  
         local response = io.read()  
         if response == "exit" then  
           break  
         end  
       end  
       os.exit(0)  
     else  
       print ("No encendida")  
       print ("Hasta luego")  
       os.exit(0)  
     end  
 end  
   
 while true do  
   if res == "Si" then  
     print ("Tienes energia")  
     enciende()  
   else  
     print("No tienes energia")  
     repeat  
       io.write("Conectar a la luz? (S/N):")  
       response = io.read()  
     until response == "S" or response == "N"  
     if response == "S" then  
       res = t[1]  
     end  
     if response == "N" then  
       print ("No conectada,hasta luego.")  
       os.exit(0)  
     end  
   end  
 end  
   

Ahora lo ejecutan y podrán ver lo practicas que son las selecciones:

En este caso vimos las palabras especiales:

if,else,while,repeat,until,end

Primero que nada debemos saber que una estructura selectiva siempre decide basado en una condición verdadera,aunque esta sea falsa a simple vista:

Me explico,cuando un lenguaje de programación elige una acción se basa en una decisión verdadera,lógica booleana,verdadero o falso,en este caso en lua solo admite,false o true:

Vamos a ver unos ejemplos:

1 es igual a 1 -- Es verdadero

2 es igual a 1 -- Es falso

1 no es igual a 2 -- Es falso

1 es menor a 10 -- Verdadero

1 es mayor a 10 -- Falso


Para usar esto en lua se usan los simbolos de asociacion:

== -- Igual a

=~ -- No igual a

< -- Menor a

> -- Mayor a

<= -- Menor o igual a

>= -- Mayor o igual a

Ahora vemos los ejemplos de arriba con simbolos

1 == 1 -- Es verdadero

2 == 1 -- Es falso

1 ~= 2 -- Es verdadero

1 < 10 -- Verdadero

1 > 10 -- Falso

Bien sabiendo eso podemos usar las elecciones de control:

Las cuales son:

Si..
Si no..
No

La sintaxis es:

if condicion then -- Condición principal

elseif condicion then -- Segunda condición(opcional)

else -- Error en condicionales anteriores(opcional,es para manejo de errores)

end

Vamos a ver un ejemplo:

 uno = 1  
   
 if 1 == 1 then  
   print ("Es verdadero")  
 elseif 2 == 1 then  
   print("Es falso")  
 elseif 1 ~= 2 then  
   print ("Es verdadero")  
 elseif 1 < 10 then  
   print ("Verdadero")  
 elseif 1 > 10 then  
  print("Falso")  
 else  
   print("Otro valor")  
 end  

Si ejecutamos ese codigo obiamente no veremos la palabra es falso,ya que al ser falso no entra en la condicion,de hecho no pasa a las siguientes estructuras si encuentra una verdadera primero.

Si queremos probar todas las posibles concidencias verdaderas tendriamos que usar solo if's:

 if 1 == 1 then  
   print ("1 == 1 : Es verdadero")  
 end  
 if 2 == 1 then  
   print("2 == 1 : Es falso")  
 end  
 if 1 ~= 2 then  
   print ("1 ~= 2 : Es verdadero")  
 end  
 if 1 < 10 then  
   print ("1 < 10: Verdadero")  
 end  
 if 1 > 10 then  
   print("1 > 10 : Falso")  
 end  
   

Algo muy importante de lua es que no necesita identacion ni punto y coma,como es el caso de python en identacion(sangria) y perl(punto y coma),lua usa el estilo shell scripting o el de ruby,usa llaves de terminación,en el caso de if,else,elseif usa:

then -> end

o mas adelante veremos:

do -> end

Por ejemplo podemos hacer una if en una linea:

if 1 ~= 2 then print ("1 ~= 2 : Es verdadero") end

Pero como siempre hay reglas de una buena programación y es bueno identar,comentar,usar varias lineas,usar varios espacios de linea,etc.

Esas son las estructuras de elección,básica ahora vamos a ver las estructuras de repetición,también de elección ya que deciden igual basado en una respuesta booleana.

El primero es while,el cual repite el código hasta que su condición inicial termine,la sintaxis es:

while condicion do
    -- codigo a ejecutar
end

Con while podemos crear repeticiones infinitas (bucles infinitos),solo basta con crear una condicion infinita,una condición que no cambiara,por ejemplo:

while true do print("Bucle infinito") end

Si no tenemos una variable bandera o una terminación no esperada no terminara,a menos que cerremos el proceso del sistema.

Terminación inesperada con break:

while true do
    print ("Bucle no infinito)
    break
end

Terminación con variable bandera:

uno = 1

while uno == 1 do
    print ("Cambiamos el valor de uno,la variable que controla while")
    uno = 2
end

Bucle de repetición for,el bucle for se usa basado en una variable o variables banderas que hasta que terminen de recorrer su valor no se detendrá,la sintaxis es:

for var = inicio,final,argumento do
    -- codigo a ejecutar
end

Veamos un ejemplo de una cuenta hasta diez desde uno:

for var = 1,10 do
    print(var)
end

Una cuenta de 10 a uno:

for var = 10,1,-1 do
    print(var)
end

Una cuenta de 0 a 100 de 5 en 5:

for var = 0,100,5 do
    print(var)
end

Con un bluce while eso se puede escribir así:

var = 0
while var < 105 do
    print(var)
    var = var + 5
end

Normalmente lo que se puede hacer con un bucle se puede hacer con otro,otro ejemplo es el bucle repeat/until,solo que este es inverso al bucle while,el bucle while se rompe cuando la condición sea falsa y este se rompe cuando la condición sea verdadera:

var = 5
repeat
    print(var)
    var = var + 5
until var == 105

Pues eso es lo mas importante de las estructuras selectivas en lua,existen mas cosas como la iteracion,pero lo veremos cuando hable de funciones y tablas mas a fondo.

Leer más...