lunes, 22 de abril de 2013

Expresiones regulares con python tutorial (1/2)

En python existe un modulo llamado re,el cual nos permite realizar regex sobre variables de nuestro script como en muchos otros lenguajes de programación,en python no es la excepción y podemos hacer regex facilmente :D.

Este tutorial lo dividire en dos partes ya que hay varias cuestiones a tratar,pero primero que nada que son las expresiones regulares o regex o patrón:


Una expresión regular, a menudo llamada también patrón, es una expresión que describe un conjunto de cadenas sin enumerar sus elementos. Por ejemplo, el grupo formado por las cadenas Handel, Händel y Haendel se describe mediante el patrón "H(a|ä|ae)ndel". La mayoría de las formalizaciones proporcionan los siguientes constructores: una expresión regular es una forma de representar a los lenguajes regulares (finitos o infinitos) y se construye utilizando caracteres del alfabeto sobre el cual se define el lenguaje.
En informática, las expresiones regulares proveen una manera muy flexible de buscar o reconocer cadenas de texto.

Mas info es.wikipedia.org

Eso dice wikipedia,en mi opinión las expresiones regulares son la forma mas potente y sencilla de buscar texto,existe en muchos lenguajes de programación y también se aplica en lo que es las wildcards de Unix,es algo rara sus sintaxis pero asi debe de ser,ya que por ejemplo le pedimos que busque un texto que comience con H que tenga 2 numeros en medio de la cadena,que no le importe el demas contenido pero que termine en o,suena complicado ordenare eso a la maquina y es complicado,con o sin expresiones regulares,ya que sin expresiones regulares tendriamos que usar infinidad de condicionales anidadas sobre bucles anidados que recorran cada valor de las cadenas por separado :O

Así que hay que dar gracias que existen las regex :D

Tutorial:

Si se preguntan si se puede hacer el ejemplo que dije:

Algo como esto:

Hola 03 Mundo

En regex para buscar esa cadena hacemos esto:

"^H.*\d{2}.*o$"
Se supone que para el final de este tutorial debes entender eso.

Bien en primer lugar debemos importar el modulo re al principio de nuestro script o modulo como sea que le digas:

import re

Abajo del shebang y si nos gusta o necesitamos usar codificación, también abajo de la codificación:

Ahora como sabemos(o si no sabemos) python usa el punto (.) para llamar funciones de los modulos,el modulo re tiene varias funciones pero en esta ocasion nos concentraremos en search(buscar):

re.search()
Adentro de search() le pasamos los parámetros a la función del modulo:


re.search("izquierda","derecha")


en la izquierda tenemos la sintaxis de nuestra expresion regular, y en la derecha la cadena de texto a la cual le vamos a aplicar el comparador de cadena(re.search):

#!/usr/bin/env python3

import re

cadena = "Hola 03 Mundo"

if re.search("^H.*\d{2}.*o$", cadena):
    print ("True")
else:
    print ("False")



En este caso trabajamos con operadores booleanos,si la expresión encuentra lo que busca, es True:


if re.search("^H.*\d{2}.*o$", cadena):

Si no es False,bueno en realidad si no encuentra nada regresa None,pero como usamos un estructura de si o no es 1 o 0 True or False,aunque si gustamos podemos hacer esto:

#!/usr/bin/env python3

import re

cadena = "Hola 03 Mund"

if re.search("^H.*\d{2}.*o$", cadena):
    print ("True")
elif re.search("^H.*\d{2}.*o$", cadena) == None:
    print ("None")
else:
    print ("False")

Esto hará que el 1 y 0 sea if y elif y else sea otra cosa.

re.search no nos sirve solo como comprobador aunque nos funciona muy bien para hacer switching,en un tutorial pasado mostre un sencillo juego de piedra paperl o tijera  en el use un algoritmo sencillo para la eleccion del numero de juegos el cual es asi:

while True:
   n_juegos = input("Numero de juegos : ")
   try:
      int(n_juegos)
      break
   except:
      print("(numeros); ")
      continue


Con regex el algoritmo queda asi y funciona igual:


while True:
   n_juegos = input("Numero de juegos : ")
   if not re.search("\D",n_juegos):
      break
   else:
      print("(numeros); ")
      continue

Como ven se pueden hacer algunas cosas o mejor dicho se pueden hacer las mismas cosas de muchas maneras,en este caso si use re,les dejo el script completo:

Enlace

Bien,entonces porque no use re desde antes?

No fue porque no sabia de su existencia,ni porque no sepa usar expresiones regulares de hecho los perleros somos maestros en las regex ;).Fue porque hay que saber programar y tener un codigo limpio,en ese caso eso se resolvia con un simple try,except y no era necesario llamar un modulo a facilitarnos el trabajo,pero bueno eso depende de nuestro modo de programar:

Izquierda
Izquierda

Como ven la sintaxis de la regex esta a la izquierda,las regex se basan en simbolos especiales los cuales son:

^

Que quiere decir principio de una cadena:

Por ejemplo si buscamos la H en Hola que inicie al principio

re.search("^H","Hola"):
Si no usamos ^ buscara en toda la cadena:

re.search("H","Otro Hola"):

Y en ambos casos es verdadero.

El lado contrario de esto es el símbolo:

$

Este simbolo busca en el final de la cadena:


re.search("H$","Otro Hola"):

En este caso regresa None,ya que seria True si buscáramos a.

Tambien existe el que seria el comodin Unix * (después) el cual busca caracteres después de otro,en este caso para que re de python de el mismo resultado que Unix necesita estar * seguido de un (.) que quiere decir un caracter,por ejemplo:

re.search("...o","Otro Hola"):
Aquí da True porque cada punto es una letra:

O punto (.) 1 caracter de la regex

t punto (.) 2 caracter de la regex

r punto (.) 3 caracter de la regex

o o 4 caracter de la regex

Otro ejemplo:

re.search("..o","Otro Hola"):
Da None porque esta buscando la o donde esta la r.

En el caso de * busca lo que sigue o lo siguiente,antes o despues,sin importar el numero de caracteres:

re.search(".*o","Otro Hola"):

Da True y no es necesario colocal el numero exacto de caracteres,muy util si o estuviera el la posición 1000000 de un texto.

Al igual que en Unix se puede al reves:

re.search("o.*","Otro Hola"):
También da True porque también encuentra la "o" de derecha a izquierda.

Otro simbolo que usaremos en las regex es la (\) este simbolo seguido de una letra en particular quiere decir muchas cosas,por ejemplo en el algoritmo que mostré arriba,en Pseudocódigo es:

si(afirmación) no hay letras en la entrada de la respuesta

Ahora ese algoritmo codificado a python luce así:


if not re.search("\D",respuesta):
Asi que con \D estamos buscando no letras solo numeros,el Pseudocodigo original(texto plano) es:

Pide un numero de juegos, mientras no sea un digito el numero de juegos vuelve a pedir el numero,cuando el numero sea un digito vamos a juegar

Y eso luce asi codificado a python:

while True:
   n_juegos = input("Numero de juegos : ")
   if not re.search("\D",n_juegos):
      break
   else:
      print("(numeros); ")
      continue


En la solución use una negacion lógica porque si usaba una afirmación no daba el resultado que necesitaba,ya que para buscar digitos se usa este simbolo \d solo que tambien recibe las letras,por ejemplo si escribimos:


1ytextoalotontoperousamosunnumeroenmedio


Da True ya que la funcion search busca un numero o una coincidencia en toda la cadena,para que pudiera usar una afirmación tendría que usar la función

match de re

re.match()

Ya que match busca que toda la cadena sea la coincidencia se hubiera podido hacer de esta manera el algoritmo/solucion:


while True:
   n_juegos = input("Numero de juegos : ")
   if re.match("\d",n_juegos):
      break
   else:
      print("(numeros); ")
      continue


Y funciona completamente igual :D

Después vemos match,ahora estos son los caracteres mas importantes:


\d # Se usa para dígitos

\D # Se usa para no digitos

\s # Se usa para espacios en blanco

\S # Se usa para no espacios en blanco espacios

\t # Cualquier tabulador

\w # Cualquier caracter alfanumérico(no símbolos).

\W # No caracteres alfanuméricos (solo simbolos)


De alguna manera el primer algoritmo que deje podria dar problemas por los espacios,asi que podríamos decir:

Que sea un numero y que no tenga espacios



Ya que el usuario podria poner algo como

22 22

Y ese espacio haria que diera errores,asi que se podria hacer esto

if not re.search("\D",n_juegos) and not re.search("\s",n_juegos):

Pero python nos pone todo fácil y ya no es necesario,pero es un ejemplo que puedes llegar a utilizar en otro caso.

Por ultimo en esta parte veremos las llaves {} 


Las llaves se usan para definir un numero de veces que queremos que aparezca algo:


\d{2} digito dos veces
\d{2,4} digitos de dos a cinco veces
\d{4,} digitos cuatro veces o mas

\d{1,3}    digitos de 1 a tres veces
\d{,4}      cuatro digitos o menos

De momento eso es todo,en la próxima parte veremos como compilar nuestro propia variable para usarla como regex y el resto de los simbolos :D.

Leer más...

Como usar gnome 3.8 modo clasico en Archlinux

Hace algo de tiempo que salio Gnome 3.8 para desarrolladores para que estos la pongan en su distribucion,en algunas ya ha llegado como en openSUSE,pero en Arch no :(

Bueno en el ultimo pacman -Syu que hice no me salia en las repos estables,solo en las testing.

Asi que hoy por hoy 23/04/2013 debemos activar las repos testing para poder usar gnome 3.8,si ya hace mucho de esta fecha es posible que ya este en los repos oficiales.

De todas formas aunque sea testing no me ha dado problemas(algunos menores) pero bueno vale la pena (en mi opinión) a comparación de 3.4 o 3.6.

Tutorial

Activamos las repos testing:

En terminal

nano /etc/pacman.conf
Buscamos



#[testing]
#Include = /etc/pacman.d/mirrorlist

Y les quitamos el gato (#) ahora salvamos y salimos

ctr + o

ctrl + x

Actualizamos las repos y el sistema:

Si tenemos instalado gnome shell 3.6 o 3.4

sudo pacman -Syu

Si no tenemos gnome(no tenemos nada o LXDE,etc):


sudo pacman -Syu gnome
Eso nos instala Gnome Shell 3.8

Ahora instalamos el modo clasico

sudo pacman -S extra/gnome-shell-extensions

Eso es todo,elegimos desde el login manager Gnome Clasic


Un video :D



La verdad este Entorno es una maravilla,yo que soy usuario de Gnome la versión 3.6 me había decepcionado un poco porque donde la uso es una netbook y no estaba optimizada,pero esta version en modo clásico me va perfecto.

Y no les digo mas,prueben ustedes mismos :D

Leer más...

domingo, 21 de abril de 2013

Como poner en español gnome shell opensuse 12.x



openSUSE es la distribución simple mas me gusta,osea para tareas normales ver videos,internet,escribir documentos,etc ya que trae todo bien configurado y no se traba tanto y tiene tantos errores como Ubuntu,si es que tiene o que lo son,como en este caso,instale openSUSE 12.2 con Gnome Shell 3.4 y no venia en español traía configuraciones por defecto en español pero no todo el sistema,esto me habia pasado en Fedora pero se soluciona desde la configuración de Gnome,en este caso openSUSE no trae esa opción :(.

Pero trae Yast y desde ahí se arregla todo fácilmente en modo clic (en serio todo),sin tener que usar consola ni nada.

Tutorial

1.Abre Configuración del sistema(Config Settings)

Ve a Yast



Nos pide la contraseña de root,por la configuración de openSUSE la contraseña de root es la de root no la de nuestro usuario.



Ya en Yast entramos a  Languaje:





Si les paso igual que ami,estará en Español ?

Si esta en español ,vamos a opciones pero si no cliqueamos donde dice el idioma y buscamos español luego le damos en opciones:


En configuración de localización elegimos nuestro locale,en mi caso es_M

Por ultimo le damos aceptar y aceptar,esto nos instalar los idiomas del sistema y programas como firefox,libreoffice y otros especiales.



Luego cerramos sesión y nos logeamos de nuevo y listo :D

Leer más...

sábado, 20 de abril de 2013

Mostrar menu crear documentos nautilus 3.6



Hace mucho que no usaba nautilus para crear documentos,lo hacia directamente desde los programas dedicados a esto,como Vim,Gedit,Libre Office,nano,etc pero apenas hoy me encuentro conque nautilus no trae un menu de crear documento,a mucho que salio esta version,creo que si lo habia visto en la primera revision que hize cuando salio para Archlinux pero no le habia tomado importancia hasta que lo necesite :\.

Y bueno es sencillo obtener este elemento del menu:

Nautilus guarda en su carpeta o mejor dicho en tu carpeta Home/Plantillas (~) las plantillas para crear nuevos documentos,basados en una plantilla desde .txt o documentos vacíos hasta cuerpos de algoritmos en algún lenguaje de programación para la escritura de un programa/script,en mi caso los que mas uso son:

Lua .lua

Perl .pl

Python .py

Javascript .js

Bash .sh

Documento en blanco

Así que para añadir un documento abrimos terminal y escribimos:

cd ~/Plantillas && printf "Ahora estas en la carpeta plantillas : " && pwd

Con eso entramos a la carpeta de plantillas

Para crear un documento(que saldra en el menu) escribimos:

Por ejemplo para crear un .txt

echo "" > "Archivo txt.txt"

Esto nos crea una plantilla vacia con extension .txt

Ahora para crear un documento en blanco que seria igual que un .txt pero sin extensión seria asi:

echo "" > "Documento en Blanco"

Esto también se puede hacer así:

touch "Documento en Blanco"

Ahora por ejemplo para crear una plantilla para python con su extensión y hashbang usamos:

printf '#!'"`which python`\n\n" > "Script en Python.py"

Eso luce un poco raro pero asi lo hacemos los unixeros :D,ahora un modo sencillo es solo crear el documento en blanco y luego abrimos nautilus en plantillas:

nautilus ./

Y damos clic derecho -> crear nuevo -> Documento en Blanco




Le ponemos el nombre y la extensión si le queremos añadir un cuerpo de plantilla o simplemente el hashbang como a python solo le damos doble clic y nos abre el editor y luego añadimos y guardamos,facil :D como en windows :\ pero facil :D.


Leer más...

jueves, 18 de abril de 2013

Como conectarse a varias pc por ssh y hacer que hagan lo mismo

Ese titulo es muy coloquial,en términos mas "profecionales" es algo asi como,agrupar entrada estándar(stdin) a multiconexion ssh,bien el punto de este tutorial es que aveces por trabajo o por andar "jugando" como es mi caso nos conectamos a varios host,sean pc locales de nuestra red local o servers a nivel web,pero el hecho es que algunas veces necesitamos que todas hagan lo mismo y al mismo tiempo,para eso es este tutorial para hacer que nuestros host a los cuales estamos conectados por ssh hagan lo mismo desde la entrada estandar(al escribir solo en una cosa),para ello yo uso y recomendare dos herramientas:

1.Terminator y openSSH:

Instalamos:

Ubuntu:

sudo apt-get install terminator

Gentoo:

sudo emerge -av terminator

Arch:

sudo pacman -S terminator


Terminator es una consola(emulador de terminal) con el cual podemos agrupar las ordenes de un cierto grupo o de todas las terminales divididas,solo basta con dividir la ventana en 4 o los host que nosotros queramos:



Luego escribimos en cada una la conexion ssh:

Por ejemplo en una:

ssh root@192.161.1.13

En otra


ssh root@192.161.1.11

etc

Luego entramos con la contraseña y ahora lo que hacemos es dar clic en el menu de la izquierda y le damos clic a:

Retransmitir a todos
Ahora lo que se escriba en una terminal se escribira en otra y tendremos una ejecución exactamente igual,pero ojo mas bien es un stdin exactamente igual,la aceptación de la orden y stdout depende de la conexión a Internet que poses.



2. La segunda opcion es cssh(clusterssh):

Clusterssh me gusta mucho porque usa Perl para muchas cosas entre ellas el cliente stdin que esta programado en Tk,por lo cual aparte de los sistemas Unix podemos usar clusterssh en Windows:

Instalamos

Solo lo he usado en Gentoo:

sudo emerge clusterssh
No se si en Arch,Ubuntu,etc sea igual clusterssh o cssh con su administrador de paquetes.

Ahora solo abrimos una terminal, y escribimos:


cssh root@192.161.1.13 root@192.161.1.12 root@192.161.1.11 etc

Y nos abre terminales miniatura con cada uno de los host,ademas del cliente donde si escribimos mandara todas las ordenes a todas las terminales y host's:


Video de ejemplo



Asi se ve en mas servers:



Las opciones de cssh son las mismas de ssh (en cuanto a conexion),asi que depende de como tengas configurado el ssh se usara cssh(puertos,credenciales,etc)

Leer más...

miércoles, 17 de abril de 2013

Clases y objetos python 3 parte (1/4)

Comenzamos con las clases y objetos :D,como bien decía a uno de los lectores del blog,aprendiendo a programar desde Unix(shell de Linux,FreeBSD,Mac,etc) podemos entender mas fácilmente o fácilmente la documentación de modulos de python,como gtk(pygtk),sys,os,re,PyQt4,etc,lo unico que pasa es que aun no están listos todos los tutoriales o por lo menos los fundamentales,en el cual algo de lo fundamental es saber trabajar y manejar objetos creados por clases, así que como es un tema un tanto largo dividiré este en cuatro partes,y esta es la primera.

Primero que nada necesitamos conocimiento basico para esto,asi que si no tienes ni idea de funciones,bucles y tipos de datos hecha un vistaso a los otros tutoriales:


Enlace

Primero que nada debemos saber que las clases son metodos de construcción para crear objetos,yo no explico mucho ya que voy directo a la practica pero hay que estar informado:

Python nos brinda la OOP:

La programación orientada a objetos o POO (OOP según sus siglas en inglés) es un paradigma de programación que usa los objetos en sus interacciones, para diseñar aplicaciones y programas informáticos. Está basado en varias técnicas, incluyendo herencia, cohesión, abstracción, polimorfismo, acoplamiento y encapsulamiento. Su uso se popularizó a principios de la década de los años 1990. En la actualidad, existe variedad de lenguajes de programación que soportan la orientación a objetos.

En la programación orientada a objetos, una clase es una construcción que se utiliza como un modelo (o plantilla) para crear objetos de ese tipo. El modelo describe el estado y el comportamiento que todos los objetos de la clase comparten. Un objeto de una determinada clase se denomina una instancia de la clase. La clase que contiene (y se utilizó para crear) esa instancia se puede considerar como del tipo de ese objeto. Por ejemplo, una instancia del objeto de la clase "Persona" sería del tipo "Persona".

Un ejemplo de instancia en un lenguaje de programación visual, sería tomar o arrastrar un objeto de la barra de herramientas o de la lista de librerías y colocarlo en el escritorio o escenario de trabajo (estamos creando una instancia de ese objeto, una copia). Si arrastramos 10 botones al entorno visual de trabajo, estamos creando una instancia del botón original, si a cada botón le cambiamos el nombre, tendremos 10 botones que heredan las mismas propiedades y métodos del objeto original. Tenemos como resultado que con un solo botón hicimos 10 y nuestro archivo pesara como si tuviese uno solo.

Una clase por lo general representa un sustantivo, como una persona, lugar o (posiblemente bastante abstracta) cosa - es el modelo de un concepto dentro de un programa de computadora. Fundamentalmente, encapsula el estado y el comportamiento del concepto que representa. Encapsula el estado a través de marcadores de datos llamados atributos (o variables miembro o variables de instancia), y encapsula el comportamiento a través de secciones de código reutilizables llamados métodos.

En la programación orientada a objetos, un método es una subrutina/función asociada exclusivamente a una clase (llamados métodos de clase o métodos estáticos) o a un objeto (llamados métodos de instancia).

Más técnicamente, una clase es un conjunto coherente que consiste en un tipo particular de metadatos. Una clase tiene una interfaz y una estructura. La interfaz describe cómo interactuar con la clase y sus instancias con métodos, mientras que la estructura describe cómo los datos se dividen en atributos dentro de una instancia.

Fuente Enlace

Bien,como dice arriba las clases heredan datos de otras clases,en esta entrada no vamos a hablar de herencia ni de todas sus capacidades,solo de como usar y definir una clase normal:

Las clases se definen con la palabra especial class,seguida del nombre de la clase y la herencia entre parentesis,en este caso no heredaremos nada,asi que podemos dejar los paréntesis en blanco o usar la palabra especial object:

Así se define una clase

class Miclase(object):

Y como en python,el algoritmo o el cuerpo del script/programa/exploit/etc debe ir identado:

class Miclase(object):
        # Algoritmo

Las funciones dentro de las clases se llaman métodos,y también tienen un rango de alcance similar al que habíamos comentado en las funciones def,local,global,etc.

En los metodos,siempre se les pasa por lo menos un argumento,self,este argumento lo que hace es que podamos usar todos los datos que se encuentran dentro de la clase desde metodos,para que estos no sean locales y invisibles ante otros métodos de la misma clase,asi definimos una función dentro de una clase(método):

def metodo(self):
Los métodos siguen teniendo todas las funciones de las funciones def,por ejemplo pasar mas argumentos o definiros desde el mismo:

def metodo(self,x,y, z = 1):

También las funciones return,print,etc(ver tutoriales de funciones)


Como bien dije,necesitamos saber el alcance de nuestros datos que están adentro de la clase,ya que existen datos locales para la clase,vistos para toda la clase:

class Miclase(object):
         var = 1 # Variable local vista por toda la clase,
                      # pero no por todo el programa 

También tenemos las variables locales de los metodos:


class Miclase(object):
         var = 1 # Variable local vista por toda la clase,
                      # pero no por todo el programa 
         def metodo(self):
               y = 2 # Variable local vista solo por este metodo
También las variable globales:

z = 0  # Variable global vista en todo el programa

class Miclase(object):
         var = 1 # Variable local vista por toda la clase,
                      # pero no por todo el programa 
         def metodo(self):
               y = 2 # Variable local vista solo por este metodo


Y por ultimo podemos pasar todas las variables,locales,locales de locales(metodos) o globales al uso de la función,con la palabra especial self

Por ejemplo un mal ejemplo:

#!/usr/bin/env python3

z = 0  # Variable global vista en todo el programa

class Miclase(object):
         var = 1 # Variable local vista por toda la clase,
                      # pero no por todo el programa 
         def metodo(self):
               y = 2 # Variable local vista solo por este metodo
         def llamada(self):
                print (y)

objeto = Miclase() # En un momento vemos que es esto
objeto.llamada() # Y esto

Ahora ejecutamos y como vemos da error en la linea 10 que es donde se llama a y:



Nota: si les da otro tipo de error es por la identacion(no hagan copy and paste) o arreglen la identacion.

Como vemos da un error de variable global,ya que python en el primer lugar que busca es en las variables globales, entonces esto se pudo haber resuelto definiendo y como global:

Asi:


#!/usr/bin/env python3


z = 0  # Variable global vista en todo el programa
y = 1 # Variable global
class Miclase(object):
         var = 1 # Variable local vista por toda la clase,
                      # pero no por todo el programa 
         def metodo(self):
               y = 2 # Variable local vista solo por este metodo
         def llamada(self):
                print (y)

objeto = Miclase() # En un momento vemos que es esto
objeto.llamada() # Y esto

O tambien python buscaria en las variables locales del metodo,asi que tambien podriamos solucionar ese error definiendo una variable local llama y:

Asi

#!/usr/bin/env python3

z = 0  # Variable global vista en todo el programa
class Miclase(object):
         var = 1 # Variable local vista por toda la clase,
                      # pero no por todo el programa 
         def metodo(self):
               y = 2 # Variable local vista solo por este metodo
         def llamada(self):
                y = 1 # Variable local

                print (y)

objeto = Miclase() # En un momento vemos que es esto
objeto.llamada() # Y esto

Y vean:


Pueden pensar que también podemos definir la variable como una local de clase:

#!/usr/bin/env python3

z = 0  # Variable global vista en todo el programa
class Miclase(object):
         var = 1 # Variable local vista por toda la clase,
                      # pero no por todo el programa 
         y = 1 # Local de clase
         def metodo(self):
               y = 2 # Variable local vista solo por este metodo
         def llamada(self):
                print (y)

objeto = Miclase() # En un momento vemos que es esto
objeto.llamada() # Y esto

Pero no :(

Porque python busca las variables en las funciones o en las variables,globales,para poder usar esa variable de clase local debemos usar la palabra especial self:


#!/usr/bin/env python3

z = 0  # Variable global vista en todo el programa
class Miclase(object):
         var = 1 # Variable local vista por toda la clase,
                      # pero no por todo el programa 
         y = 1 # Local de clase
         def metodo(self):
               y = 2 # Variable local vista solo por este método
         def llamada(self):
                print (self.y)

objeto = Miclase() # En un momento vemos que es esto
objeto.llamada() # Y esto

Y ahí esta la magia de self,bueno no y no es nada del otro mundo,poder usar esa variable con tan solo poner :

self.variable_de_clase
La magia esta en que podemos usar cualquier variable de la clase o metodo usando self,por ejemplo podemos definir una variable local de metodo y llamarlo,asi:

def metodo1(self);
      y = 1
      print (y)


Pero si en otro método queremos llamar esa variable,va a dar error de variable global:


#!/usr/bin/env python3

class Miclase(object):
    def metodo1(self):
        y = 1
        print (y)
    def metodo2(self):
        print (y) # Error :(

objeto = Miclase() # En un momento vemos que es esto 
objeto.metodo2() # Y esto


Como dije para eso usamos self,pero ahora desde la definición:

#!/usr/bin/env python3

class Miclase(object):
    def metodo1(self):
        self.y = 1 # Definimos una variable de rango self
        print (self.y)
    def metodo2(self):
        print (self.y) # Error aun

objeto = Miclase() # En un momento vemos que es esto 
objeto.metodo2() # Y esto

Las definicones de rango self,son variables locales de clase,por lo cual son visibles en toda la clase,siempre y cuando lleven self,en este caso sigue dando error,porque ?

Porque no hemos construido el objeto y aunque ya se definió la variable y en rango self,aun no la creamos si solo llamamos a metodo2:

Esto se puede arreglar de dos formas,llamando el metodo1 primero:

#!/usr/bin/env python3

class Miclase(object):
    def metodo1(self):
        self.y = 1 # Definimos una variable de rango self
        print (self.y)
    def metodo2(self):
        print (self.y) # Error aun

objeto = Miclase() # En un momento vemos que es esto 
objeto.metodo1() # Y esto
objeto.metodo2() # Y esto

Con esto python guarda en la memoria de la clase la variable de rango self y la podemos llamar desde otra:

Pero esto muchas veces es incomodo y algunas veces mala practica, así que lo que podemos hacer es construir(llamar),los dos metodos desde la misma clase con el metodo constructor __init__() el constructor __init__() ademas de que es el constructor del objeto,es el que le pasa los argumetos desde el script principal,ya que si creian que se pasaban los argumetos desde la clase:

class Miclase(argumeto1,argumeto2,etc):

Pues no,eso se usa para otra cosa que veremos mas adelante,desde __init__() se pasan los argumentos:

class Miclase(object):
         def __init__(self,argumento1,argumeto2):

Estos argumentos se los pasaremos a la hora de instanciar la clase,osea a la hora de crear el objeto:

objeto = Miclase()
 Y aquí justamente le pasamos los argumentos:

#!/usr/bin/env python3

class Miclase(object):
    def __init__(self,x,y):
        print ("%s %s!!!" %(x,y))

objeto = Miclase("Hola","Mundo")




Cabe mencionar que __init__() es el método principal de una clase,por la cual al instaciar no es necesario,llamarla así:

objeto = Miclase()

objeto.__init__()

Solo con usar


objeto = Miclase()

Usamos este método especial.

Asi que el ejemplo de arriba usando un constructor queda asi;

#!/usr/bin/env python3

class Miclase(object):
    def metodo1(self):
        self.y = 1 # Definimos una variable de rango self
        print (self.y)
    def metodo2(self):
        print (self.y) # Ya no hay Error
    def __init__(self): # Construimos la clase
        self.metodo1()
        self.metodo2()

objeto = Miclase() # Creamos el objeto


Aun así sigue teniendo el mismo problema,tiene que llamar los dos metodos para usar uno del otro :(

Si no queremos hacer esto,lo mejor es no usar clases y usar funciones.

En ocasiones,ya que podemos definir las variables como clase local o usar funciones anidadas,o mejor dicho metodos anidados:


#!/usr/bin/env python3

class Miclase(object):
    def metodo1(self):
        self.y = 1 # Definimos una variable de rango self
        return self.y # Devolvemos el valor para usarlo en el futuro
    def metodo2(self):
        print (self.metodo1()) # Llamos un metodo desde otro
       # Ya no hay Error

objeto = Miclase() # Creamos el objeto
objeto.metodo2() # Esta instancia llamara los dos métodos

O también con varibles de clase local como veíamos arriba o variables locales de tipo rango construcción


#!/usr/bin/env python3

class Miclase(object):
    def metodo2(self):
        print (self.metodo1) # Llamos un metodo desde otro
       # Ya no hay Error
   def __init__(self):
       self.y = 1 #Para esto son los constructores

objeto = Miclase() # Creamos el objeto y se llama al constructor
# Que crea la variable
objeto.metodo2() # Esta instancia llamara los dos métodos

pero no esto no demuestra el poder de las clases y de la OPP,ya que eso se puede hacer con funciones def, fácilmente,las clases son para crear objetos y así es como funcionan:

Supongamos que tenemos varias mascotas,las cuales requieren cuidados,limpiar sus gracias,darles de comer,etc lo que se nos ocurra,de ejemplo esas dos cosas,esas mascotas en python las podemos tratar como un objeto para administrarlas:

Ejemplo

Ese ejemplo es solo la idea pero podemos imaginar un poco:

Ejemplo

De momento es todo,luego podremos hacer algo mas interesante pero esa es la introducción.

Leer más...

lunes, 15 de abril de 2013

Como reconocer WIndows en el grub de Archlinux

Bueno no es que use windows,pero pues si,aunque sea Unixero en ocasiones debo usar windows,en muchas ocasiones ya que casi toda la gente que conozco usa windows y a todos los lugares donde voy :O

Pero en fin hay que saber de todo y si usamos Arch también podemos usar Windows así que no hay problemas :D

Tutorial

Windows usa el formato NTFS para su partición y debe estar en una partición primaria , en mi caso tengo Arch,Gentoo y Slackware junto a WIndows 7 ultimate:

En la partición /dev/sda3:





Podemos ver con Gparted o desde consola con:

sudo fdisk -l



Ahora abrimos el archivo  /etc/grub.d/40_custom

sudo nano   /etc/grub.d/40_custom

Y añadimos:


menuentry "Windows 7 Ultimate" {
set root=(hd0,3)
chainloader (hd0,3)+1
}

Explico:

Windows 7 Ultimate Es el nombre que le daremos al sistema.

hd0,3 Es la partición

hd0 es /dev/sda 

o

hd0 es /dev/hda


0 es el numero, en mi caso fue /sda3 y es 3,sda2 es 2,etc:

chainloader Cede el proceso de arranque a su cargador de arranque nativo(inicia windows)


Con eso configurado creamos una nueva configuración:

sudo grub-mkconfig -o /boot/grub/grub.cfg
Y listo :D

Para el EFI vean esta documentacion:

wiki.archlinux.org/index.php/GRUB2
Leer más...

sábado, 13 de abril de 2013

Navegador web python gtk2

Pues ya hice otro navegador y me copie la interfaz de unity,bueno este navegador es sencillo tan solo poco mas de 100 lineas,pero lo hice porque ya presente uno en qt en python,otro en gtk3 en perl y este en python gtk2,sobre el de perl ya no lo he actualizado porque me da vagancia y de todos modos ahi esta el codigo fuente,asi que si lo quieren continuar adelante.

Como decia queria hacer un navegador en gtk2 ya que con python uso qt y gtk2 ademas de que el de gtk3 puede que no lo hayan usado por estar usando lxde o otro DE que no sea compatible con gtk3,pero en fin el programa quedo como tipo Unity:

Es muy muy ligero y muy rapido,tambien el searchbox desaparece y aparece magicamente con una funcion:

Y bueno les dejo el codigo fuente:



Enlace

Para usar necesitan instalar pywebkit y webkit y gtk2python

En ubuntu

sudo apt-get install python-webkit libwebkit-dev pygtk
Para otras distros no se,cual es el nombre de los paquetes,ya que en Gentoo tardaba mucho y en Arch no encontre nada en slackware ya ni me acuerdo :P, y son las distros que uso ademas de ubuntu.

Despues meten el script en un archivo .py y lo ejecutan,asi:

python script.py

o

chmod +x script.py

./script.py
Y listo :D



Leer más...

jueves, 11 de abril de 2013

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

miércoles, 10 de abril de 2013

Como recuperar el grub en Archlinux


Hace poco perdi el grub en Archlinux porque borre Ubuntu,bueno el hecho es que tenia Arch solamente en mi pc y este tenia un grub para el solo,pero despues instale Ubuntu y el grub se quedo a cargo de ubuntu,por ultimo instale Gentoo pero aun asi se quedo el grub a cargo de Ubuntu,luego Ubuntu me fue muy mal,muy muy mal,muy lento,no me detectaba el wifi,de repente se trababa,muchos mensajes de error y bueno,adios Ubuntu y le doy la bienvenida a una vieja conocida,hola Slackware,despues Slackware me instalo Lilo y no estoy muy acustumbrado asi que regrese al primer grub del sistema que aun tenia instalado,al de Arch,porque ademas Lilo no me detectaba ni Gentoo ni Arch,asi que a recuperar el grub:

Tutorial


1.Entra en modo root desde un livedistro:

su
2.Ahora montamos la particion root de Arch,en mi caso elegi la /dev/sda2 en ext4,montaremos en /mnt por ejemplo:

mount -t ext4 /dev/sda2 /mnt
Montamos lo necesario:


mount -t proc   proc  /mnt/proc
mount -t sysfs  sys  /mnt/sys
mount -o bind   /dev  /mnt/dev

Nota: Necesitamos os-prober si no lo tenemos instalado en Arch necesitamos instalarlo,asi que necesitamos pasarle internet a la jaula que vamos a usar:


cp /etc/resolv.conf /mnt/etc/
3.Iniciamos la jaula:

chroot /mnt /bin/bash
Ahora,si tenemos la carpeta /boot en otra particion,tenemos que montarla ya que es donde esta el grub:

mount /boot
4. Instalamos os-prober

pacman -S os-prober
5.Reinstalamos el grub

grub-install /dev/sda
Y creamos un archivo de configuracion

grub-mkconfig -o /boot/grub/grub.cfg 


6.Salimos :

umount -a
exit
cd / 
umount -a

Reiniciamos y listo :D


Referencia y mas info:

wiki.archlinux.org/index.php/Reinstalling_GRUB


Leer más...