lunes, 27 de diciembre de 2010

Internet Nokia 5130 (Claro Argentina)

Después de actualizar el firmware de este móvil, se me desconfiguró el internet y todo. La verdad que me cansé de buscar por internet para poner una buena configuración y sobre toda las cosas una configuración de internet gratis!
A esta última de momento no eh llegado. Ôò

Bueno, los pasos a seguir son:
Ingresamos a Menú -> Configuraciones -> Configuración -> Ajustes config. pers -> Agregar (Si ya hay alguno agregado, vamos a opciones y agregar nuevo) ->  Punto de acceso.

Punto de Acceso
Nombre de cuenta: Internet (Pueden poner el que quieran).
Config. puntos acceso ->
Portador de datos: Paquete de datos.
Config. de portador ->
Pto. acces. paq. datos: gprs.claro.com.ar.
Tipo de red: IPv4
Tipo de autentificación: Normal.
Nombre de usuario: clarogprs
Contraseña: clarogprs999 (deben ingresarla dos veces por verificación)

Luego regresan a Ajustes config. pers. y verán en una lista el nombre que seleccionaron para Nombre de cuenta, van a opciones y le dan a activar.

Ahora ingresamos a Menú -> Configuraciones -> Conectividad -> Paquete de datos -> Config. paq. datos -> Editar pto. acceso act.
Pto. acces. paq. datos: gprs.claro.com.ar

Y allí tendrían funcionando internet en su claro, aclaro, se consume crédito con esta configuración, pero no es mucho.

En cuanto haya alguna novedad de como poner internet gratis, subo la nota!

jueves, 9 de diciembre de 2010

Programación funcional en Python.

Según Wikipedia un lenguaje de programación funcional es: la programación funcional es un paradigma de programación declarativa basado en la utilización de funciones aritméticas que no maneja datos mutables o de estado.

Ahora bien, Python al ser un lenguaje multiparadigma, nos permite la aplicación de ciertas características de este modelo (PF).
Existen herramientas internas dentro de Python que funcionan teniendo en cuenta este paradigma. Ellas son: filter(), map(), reduce() y lambda.

Veamos un poco que nos dice la ayuda del intérprete.
>>> help(filter)
Help on built-in function filter in module __builtin__:

filter(...)
filter(function or None, sequence) -> list, tuple, or string

Return those items of sequence for which function(item) is true. If
function is None, return the items that are true. If sequence is a tuple
or string, return the same type, else return a list.

filter(func, secuencia) -> Esta función recibe dos parámetros, el primero es una función o None (que es el valor nulo de python) y el segundo una secuencia de valores (lista, tupla o cadena), la función nos retorna una secuencia del mismo tipo, esto quiere decir que si pasamos a secuencia una tupla nos retornara una ... (Adivinaron -¡muy bien!-), por cada func(x) que sea verdadero.

Ejemplo: Nos indica que números de una secuencia son pares. (def incognita retronet)


def incognita(x):
        return not x & 1
 
filter(incognita, range(50))

Ahora veamos que nos dice el intérprete de map()
>>> help(map)
map(...)
    map(function, sequence[, sequence, ...]) -> list
   
    Return a list of the results of applying the function to the items of
    the argument sequence(s).  If more than one sequence is given, the
    function is called with an argument list consisting of the corresponding
    item of each sequence, substituting None for missing values when not all
    sequences have the same length.  If the function is None, return a list of
    the items of the sequence (or a list of tuples if more than one sequence).

map(func, secuencia) -> Esta función retorna una lista con los resultados de aplicar cada elemento de la secuencia como argumento de func.

Ejemplo: 

def cuadrado(x):
        return x*x
 map(cuadrado, range(50))

El turno de reduce()
>>help(reduce)
reduce(...)
    reduce(function, sequence[, initial]) -> value
   
    Apply a function of two arguments cumulatively to the items of a sequence,
    from left to right, so as to reduce the sequence to a single value.
    For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates
    ((((1+2)+3)+4)+5).  If initial is present, it is placed before the items
    of the sequence in the calculation, and serves as a default when the

reduce(func, secuencia) -> Aplica una func de dos argumentos de forma acumulativa a cada elemento de la  secuencia, de izquierda a derecha, a fin de reducir la secuencia a un solo valor.

Por ejemplo: El resultado de la suma de una secuencia.
 
def suma(x+y):
        return x+x
 map(suma, range(50))

Este ejemplo es el mismo que sale en la documentación de la función, pero allí aplica la función lambda que la veremos a continuación.

>>>lambda

Con esta palabra clave se pueden crear pequeñas funciones anónimas para ser utilizadas siempre que se necesite un objeto función.
Nota: "Todo en Python es un objeto, por tal motivo se puede referenciar a este objeto función en una variable"

Ejemplo.

suma = lambda x, y: x + y

suma(2, 3)

lunes, 6 de diciembre de 2010

Shellcode en Python Ôò

hx = ['0x4c', '0x69', '0x6e', '0x75', '0x78', '0x20',
'0x41', '0x70', '0x75', '0x6e', '0x74', '0x65',
'0x73']

print ''.join(map(chr, map(lambda x: int(x, 16), xh )))

Breve introducción a la programación funcional con Python.

jueves, 2 de diciembre de 2010

Cuadro de mensaje. (Primeros pasos - PyQt4)

Por defecto, si clikeamos en el botón x en la
barra de título, el QWidget se cierra. Algunas
veces queremos modificar este comportamiento por
defecto. Por ejemplo, si tenemos un archivo abierto
en un editor para el cual hicimos algunos cambios.
Cuando cerramos este nos muestra un mensaje para
confirmar la acción.

####################################################
#!/usr/bin/python

import sys
from PyQt4 import QtGui

class MessageBox(QtGui.QWidget):

def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)

self.setGeometry(300, 300, 250, 150)

self.setWindowTitle('Cuadro de Mensajes')

def closeEvent(self, event):

reply = QtGui.QMessageBox.question(self, 'Mensaje', 'Deseas salir?',

QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)

if reply == QtGui.QMessageBox.Yes:

event.accept()
else:
event.ignore()

app = QtGui.QApplication(sys.argv)
qb = MessageBox()

qb.show()
sys.exit(app.exec_())


####################################################

Si cerramos el QWidget, este se cierra.
Para modificar el comportamiento del widget necesitamos
reimplementar el controlador de evento closeEvent().

# reply = QtGui.QMessageBox.question(self, 'Message',
"Are you sure to quit?", QtGui.QMessageBox.Yes,
QtGui.QMessageBox.No)

Mostramos un cuadro de mensaje con dos botones (Yes o No).
La primera cadena de texto aparece en la barra de
título. La segunda cadena es un mensaje de texto
mostrado por el diálogo. El valor de retorno es
almacenado en la variable "reply".

# if reply == QtGui.QMessageBox.Yes:
event.accept()
else:
event.ignore()

Aquí probamos el valor de retorno. Si cliqueamos el
botón Yes, aceptamos el evento que conduce a el cierre
de el widget y a la terminación de la aplicación. De
lo contrario ignoramos el evento de cierre.

Cerrando una ventana. (Primeros pasos - PyQt4)

La manera "obvia" de cómo cerrar una ventana es hacer
clic en el signo de x en la barra de título. En el
siguiente ejemplo, vamos a mostrar, cómo mediante
programación puede cerrar la ventana. Vamos a
referirnos brevemente a las señales y los slots.

El siguiente es el constructor de una QPushButton,
que utilizaremos en nuestro ejemplo.

## QPushButton(string text, QWidget parent = None)


El parámetroo texto es un texto que se mostrará en
el botón. El parent (padre) es el Widget en el que
ponemos nuestro botón. En este caso QWidget.

##################################################
#!/usr/bin/python

import sys
from PyQt4 import QtGui, QtCore

class QuitButton(QtGui.QWidget):
def __init__(self, parent=None):

QtGui.QWidget.__init__(self, parent)

self.setGeometry(300, 300, 250, 150)

self.setWindowTitle('Quit button')

quit = QtGui.QPushButton('Cerrar', self)

quit.setGeometry(10, 10, 60, 35)

self.connect(quit, QtCore.SIGNAL('clicked()'), QtGui.qApp, QtCore.SLOT('quit()'))

app = QtGui.QApplication(sys.argv)
qb = QuitButton()

qb.show()
sys.exit(app.exec_())


#####################################
# quit = QtGui.QPuchButton('Cerrar', self)
# quit.setGeometry(10, 10, 60, 35)

Creamos un botón y lo colocamos en el QWidget al
igual que hemos colocado en la posición al QWidget
en la pantalla.


# self.connect(quit, QtCore.SIGNAL('clicked()'), QtGui.qApp, QtCore.SLOT('quit()'))

PyQt4 maneja los eventos que se presenten en una
aplicación con un mecanismo de Señales (SIGNAL) y
Ranuras (SLOT). En este caso cuando hacemos click
sobre el botón se emite una señal de click, el SLOT
relacion a un objeto emisor, en este caso el botón,
con un objeto receptor (la aplicación) con la acción
a realizar dado dicho evento, en este caso cerrar la
aplicación (con el método quit())

El QtCore.QObject.Connect() método que conecta
signals con slots. En nuestro caso el slot es una
función predefinida de PyQt. La comunicación es
hecha entre dos objetos. Un emisor y un receptor. El
emisor es el botón y el receptor es el objeto
aplicación.

Centrando la ventana en la pantalla. (Primeros pasos - PyQt4)

El siguiente guión muestra como podemos centrar la
ventana en la pantalla de escritorio.

#!/usr/bin/python

import sys
from PyQt4 import QtGui

class Center(QtGui.QWidget):

  def __init__(self, parent=None):
      QtGui.QWidget.__init__(self, parent)

      self.setWindowTitle('Center')
      self.resize(250, 150)

      self.center()

  def center(self):

      screen = QtGui.QDesktopWidget().screenGeometry()
      size = self.geometry()

      self.move((screen.width() - size.width())/2, (screen.height() - size.height())/2)

app = QtGui.QApplication(sys.argv)
qb = Center()

qb.show()
sys.exit(app.exec_())

# self.resize(250.150)

Aquí cambiamos el tamaño del QWidget para ser 250px
de ancho y 150px de alto.

# screen = QtGui.QDesktopWidget().screenGeometry()

Calculamos la resolución de pantalla de nuestro
monitor.

# size = self.geometry()

Aquí obtemos el tamaño de nuestro QWidget.

# self.move((screen.width()-size.width())/2, (screen.height()-size.height())/2)

Aquí movemos la ventana al centro de la pantalla.

miércoles, 1 de diciembre de 2010

Una Python NINJA.

Me veo obligado a desarrollar algo para mi "integridad intelectual", broma-broma, y como me gusta desarrollar en python, porque es lo que entiendo y lo que realmente me gusta, encontré un ide que proporciona herramientas para simplificar el desarrollo en Python.
Su nombre es NINJA-IDE (from: "Ninja Is Not Just Another IDE").
- Es una plataforma integrada de desarrollo, especialmente diseñada para construir aplicaciones en Python.

Algunas características hasta el momento son:
  • Resaltado de sintaxis para: Python...
  • Marca las tabulaciones con pequeños puntos
  • Incluye una consola de Python
  • Permite abrir una carpeta, y la explora recursivamente para mostrar luego toda la estructura de la carpeta junto con los archivos Python, HTML, PNG Y JPG incluidos (una especie de detección automática de lo que podría ser un proyecto Python)
  • Funcionalidades de Abrir, Guardar y Guardar Como soportadas.
  • Nos muestra cuando un archivo ha sido modificado y también nos advierte al cerrarlo
  • Indentación automatica
  • F4: Oculta la consola
  • F11: Oculta todo excepto el editor
  • Permite visualizar las imagenes del proyecto dentro del mismo IDE abriendo una pestaña nueva
  • Cierre automatico de los simbolos: ', ", {, [ y (
  • Y algunos más...
Se puede decir que la versión de este programa todavía esta muy verde, pero tengo fé en que los muchachos que lo desarrollan van aportar sus conocimientos para que la aplicación crezca y crezca!

Para los que usen la aplicación hagan reportes de la misma cuando encuentren errores para ayudar a que se mejore!
DESCARGALO


Si sos desarrollador y tenes ganas de desarrollar un plugin para ayudar a estos locos te paso la dirección en donde tenes documentado el como crear plugin para este IDE. (Está en español, así que no tenes excusa!)


Crear plugin


¿Qué necesitas para poder ejecutar el ide?


Python >= 2.5
PyQt >= 4.6


Y para ejecutarlo sólo tenemos que descargarlo del enlace que está arriba (donde dice DESCARGALO), lo descomprimimos y luego en una consola nos situamos en la carpeta que hemos "descomprimido" y tecleamos...

python ninja.py