lunes, 16 de enero de 2012

Python5: Condicionales y bucles

Por el momento ya somos capaces de fabricar nuestros programas, sea como sea y hagan lo que hagan, son programas que el intérprete reconoce como tales, pero ahora vamos a ver un punto interesante de ellos, los condicionales.

Un programa no es demasiado complejo, en especial si tomamos como base el hecho que los programas solo se dedican a tomar decisiones según lo que esté ocurriendo en ese momento o lo que el usuario haya elegido; nuestros programas ya pueden interactuar con variables, mostrarlas por pantalla y muchas cosas bonitas, pero no pueden tomar decisiones por ellos mismos, tal y como estamos en este momento, no es mucha diferencia entre programar algo y ejecutarlo, ya que si quieres que el programa tenga algún comportamiento diferente, se lo has de tener que reprogramar en el código, pero no se permite eso de escribir partes de código que se ejecuten si algo es cierto o falso.

Un buen programa se define en hacer que el usuario tenga una posibilidad de elegir algo, según que sea lo que el usuario haya elegido, el programa dará un valor a una variable, luego, mediante una sentencia especial que ahora mismo veremos, el valor de la variable se compara con otro que ya tiene definido el programa, si el valor de la variable es igual que el que ya tiene el programa, se hace una acción, si es diferente, se compara con otro o se ignora, eso es programable por nosotros en todo el código fuente.

A este tipo de sentencias que se encargan de comparar si algo es cierto o falso se le llaman condicionales, y es lo que vamos a ver aquí.



IF



La sentencia if se da a la tarea de comparar si dos datos son iguales, diferentes o lo que se le indique, para esto también sirven los operadores que habíamos visto en la segunda entrada.

La sintaxis de la sentencia es como sigue:
if 0 == 0:
    código que ejecutará el programa
else:
    otro código


Aquí vemos la simplicidad de if, lo que dice esto es que comparará que 0 sea igual a 0(recuerda que en los operadores los dos signos de igualdad representaban que un dato era igual a otro) y en caso de que sea positivo, es decir, que 0 sea igual a 0, ejecutará el código que se muestra después de los dos puntos y sangrado, es muy importante utilizar la tabulación, espaciado o algún método que haga que Python pueda identificar que es indentado, ya que en eso se basa Python para saber si ese código es el que se debe ejecutar al cumplirse la condición.

El creador de Python sugiere que se tome como indentación espacios antes que tabuladores, es decir, en tiempos antiguos se utilizaba el tabulador para sangrar el código fuente, pero creo que esta convención ha quedado un poco anticuada, así que en lugar de dar una tabulación se sugiere que se utilicen 4 espacios antes del inicio de cada línea de un bloque de código o de una función.

Después de esto, podemos ver una línea que dice “else:”, esto se ejecutará en caso de que la condición que 0 sea igual a 0 sea negativa.

En sentencias como las condicionales o los iteradores, es muy importante no olvidar dos cosas: Primero, que no se debe escribir la sentencia sin olvidar los dos puntos al final y segundo, que después de eso, es necesario pasar un tabulador para poder escribir el bloque de código que se ejecutará al cumplirse la condición.

Vamos a solidificar esto con un útil programa que puede tomar decisiones según una variable que vamos a definir; como ya lo has de saber, ve a tu editor de textos y guarda el ejercicio en la carpeta que has designado para ello, aquí el código:
#!/usr/bin/env python
# -*- coding: utf-8 -*-

variable = 25
if (variable < 10):
    print 'el número que has ingresado es menor a 10'
    print 'número: %i ' % (variable)
    raw_input()
else:
    print 'el número que me has ingresado es mayor a 10'
    print 'número: %i ' % (variable)
    raw_input()


si lo ejecutamos, vamos a ver porqué es tan importante la condicional if, ya que como podemos ver, hacemos que compare el valor de variable y verifique si el número es menor a 10, en caso de que sea menor a 10, se ejecutarán solo las líneas de código que tengan una tabulación, pero también podemos ver lo que usamos en este programa, que fue la sentencia else, viene junto con if y se caracteriza por ser una alternativa, como en este ejemplo, si la condicional comparaba el número 25 que tenía la variable, daba como resultado falso, ya que no es menor a 10, entonces, si el programa no tuviera una condicional else, terminaría y jamás mostraría nada por pantalla, ya que if solo ejecutará su código cuando la condición sea positiva, entonces, al escribir una sentencia else, le decimos al programa “ejecuta este código si no se cumple la condición”.

A muchos nuevos programadores les resulta enredoso meterse de lleno a comparar valores y hacer una u otra cosa según su resultado, a otros no les importa en lo más mínimo y solo con leer la documentación pueden comenzar a probar, no es del todo importante que lo hagas a la primera vez que lo intentas, lo que sí es bastante importante, es que no dejes dudas en nada de este procedimiento, ya que esto puede y muy seguramente va a traer consecuencias muy grabes en tu futuro como aficionado en la programación, así que es mejor dedicarle la cantidad de tiempo que tú creas necesario para que puedas lograr un mejor dominio de las condicionales y los iteradores.

Si el código de el programa queda como lo hemos guardado, significa que jamás se ejecutará el código que tiene if, ya que la variable será siempre mayor de 10, pero no por eso necesitamos eliminarlo, ya que uno como programador no sabe si el usuario tomará una u otra decisión y necesitamos estar preparados para todo.

Solo para comprobar que la condicional está funcionando, cambia el valor de variable a un número como 6 o 5, para que se ejecute el código que tiene if.

Solo una vez que hayas comprendido como utilizar if, pasamos al siguiente párrafo de información, que creo que será bastante útil a la hora de programar.

La sentencia if se encarga de comprobar, pero he aquí una desventaja, imaginemos que necesitamos hacer muchas comprobaciones, por ejemplo, que tenemos un número y necesitamos comprobar que sea mayor que 10 o mayor que 20 o mayor que 30 o mayor que 40 o mayor que 50; con nuestros conocimientos actuales y teniendo en cuenta que existe una variable d nombre num, podríamos resolver el problema de la siguiente manera:
if (num > 10):
    print 'num mayor que 10'
if (num > 20):
    print 'num mayor que 20'
if (num > 30):
    print 'num mayor que 30'
if (num > 40):
    print 'num mayor que 40'
if (num > 50):
    print 'num mayor que 50'
else:
    print 'esto no es un número'


Aquí podemos ver que cada if es un bloque de código diferente, pero aunque ningún if lleve un else, solo es necesario uno para que se pueda tomar una alternativa, de hecho la condición else es opcional al 100%, no pasaría nada si no se escribe, pero necesitamos dar por asumido que el programa jamás cometería errores o que el usuario jamás manipularía de forma equivocada el programa, cosa que es imposible de asegurar.

Como cada if es un código independiente, esto quiere decir que si num toma un valor de 11, será mayor que 10, pero no por ello acabará el código, nosotros como programadores esperaríamos que se mostrara el resultado de que sea mayor que 10 y terminara el programa, y sí, solo mostrará el resultado y cerrará, pero no sin antes hacer comprobaciones inútiles.

Explico: al dar como positivo que num valga mayor que 10, la sentencia no se detendrá, más bien, ejecutará el segundo if(como había dicho, cada if es independiente) y comprobará y dará negativo, luego ejecutará el tercero y así llegará hasta el else y ejecutará su contenido, dando errores en el resultado.

Si decidieras no escribir else por el error ya comentado, aún sería una fuga de memoria ya que aún y cuando los resultados de la primera comprobación indiquen que lógicamente debe de dejar de comparar, lo seguirá haciendo porque cada if se atiende por separado.

En este caso no se notará ningún retraso, pero es difícil acostumbrarse a malos hábitos de programación porque esto al comparar datos complejos sí tardará muchísimo tiempo.

Lo que Python nos brinda para hacer solo una comprobación y cerrar si es positivo es la sentencia elif(else if) y se usa de la misma manera que en los ejemplos anteriores, entonces, en el caso que necesitemos que la condicional termine si un número es mayor a 10, 20, 30, 40 o 50 es hacer el mismo código, pero poniendo elif en lugar de if, así:
if num > 10:
    print 'el número es mayor que 10'
elif num > 20:
    print 'el número es mayor que 20'
...
elif num > 50:
    print 'el número es mayor que 50'
else:
    print 'esto no es un número'

como podemos leer, no se puede usar un “elif” al principio, este solo se puede usar después de poner una sentencia if.

Lo que pasa con esto es que al momento de hacer la comprobación, si el primer resultado(es decir: cuando compara al primer y único if) da negativo pasa a comprobar al elif y sigue con las comprobaciones hasta detenerse en el elif o else, según sea el caso, pero aquí, en el ejemplo que num valga 11, se detendrá en el primer if que dice que num sería mayor que 10 y ya no hará nada, porque todos los demás condicionales forman parte del primero, es como si ahora sí estuvieran unidos y no se tomara a cada una de las líneas de condición como un algo independiente, ahora esas líneas corresponden un todo.

También se puede hacer uso de la anidación para comprobar una condición dentro de otra, en todo caso, podríamos hacer que una condición comprobara que el número sea mayor que 10 y que dentro de esa condición se encuentre otra comprobación que revise si la variable es mayor o menor a 15 de la siguiente manera:
if num > 10:
    if num < 15:
        print 'la variable es menor a 15'
    if num > 15:
        print 'la variable es mayor a 15'
else:
    print 'la variable no se encuentra entre 10 y 15'


En esta condición se puede ver que si se desea meter una condicional dentro de otra solo se necesita de una doble indentación, es decir, indentar en lugar de con 4 espacios con 8 el bloque de código de la segunda condicional, se pueden anidar tantas condicionales como se necesite.



Operadores or y and



Para recordar un poco, los operadores de comparación de valores que se pueden utilizar son la comparación de mayor(Símbolo de >), menor(símbolo de <), igual a(símbolos de ==), mayor o igual que(símbolos de <=), menor o igual que(símbolos de <=), pero existen operadores para elaborar condicionales múltiples, es decir, en el ejemplo anterior, si se deseara que el número fuera evaluado mayor que 10 y menor a 15, puede escribirse una sola condicional en lugar de una condicional con otra dentro de ella.

Para este caso se puede utilizar el operador and, que como puedes imaginar, significa y en inglés, así que puedes hacer dos o más comparaciones de la variable.

La sintaxis de una sentencia if utilizando el operador and es así:
if variable1 == 0 and variable2 == 0:
Esta condicional ejecutará su código interno si las dos variables dan positivo a la evaluación, no es recomendable escribir este tipo de condicionales cuando no se sabe si una de nuestras variables no dará el resultado que esperamos, en este ejemplo, tenemos que estar seguros de que el resultado de ambas variables puede ser 0 para que se ejecute la condición, pero si una de estas dos variables cambia el valor no se ejecutará la condicional.

En el ejemplo que se desee comprobar que num tenga un valor mayor a 10 y menor a 15, se puede escribir una condicional de la siguiente forma:
if num > 10 and num < 15:
    print 'la variable es mayor que 10 y menor que 15'

Las sentencias if no se encuentran limitadas a un número de 2 comprobaciones, se puede usar el operador and tantas veces como se desee, pero no es muy recomendable si una de las variables puede adquirir otro valor; el uso de este tipo de sentencias sería recomendable cuando el cambio de valor de una de las variables comprobadas afectara a todas las demás.

Por último, el operador or se utiliza para dar una opción(or es o en inglés), a la comprobación, también se debe tener cuidado con el número de opciones, por ejemplo, se necesita para saber que se debe hacer si la variable vale una cantidad u otra, se puede usar así:
if var == 'hola' or var == 'que onda':
    print 'Me saludas?'

Esta condicional se utiliza para saber si una variable vale hola o que onda, en caso de ser cierto, se mostrará el mensaje por pantalla.

Cabe decir, sin embargo, que debes de utilizar este tipo de operadores solo cuando sea necesario, no debes de hacer malas costumbres y querer meter todas las verificaciones de datos dentro de una sola condicional.



Bucles.



Sin duda alguna, las condicionales aportan bastante flexibilidad a nuestros programas python, pues pueden hacer que el programa tome una u otra decisión según el valor de una variable, para imaginar más allá, puede que el usuario escoja un valor que se le puede dar a la variable y ese valor sea el que se pase por la condicional... pero muchas veces no queremos que se ejecute un bloque de código una sola vez, en bastantes ocasiones lo que se necesita es que un código se ejecute un número de veces que nosotros elijamos.

Por ejemplo, podríamos tener una variable y querer que desde el número 1, la variable sume uno a su valor y lo muestre por pantalla hasta llegar al número 100, con la condicional if también se puede hacer, y sería algo de la siguiente manera:
if variable < 101:
    print 'la variable vale %i' % variable
    variable +=1
    print 'la variable vale %i' % variable
    variable +=1
    ...

Esta forma obligaría al programador a escribir las dos líneas de código de manera repetitiva por 100 veces, cosa que haría muy pesado el programa, tanto para la ejecución por medio de la computadora como para escribirlo sin cometer errores.

Como una nota antes de seguir, al momento en el cual yo utilicé la sentencia(variable +=1) en sintaxis python significa algo como(variable = variable+1), aunque el segundo procedimiento es perfectamente válido, prefiero utilizar el primero, ya que es muy simple:
se escribe el nombre identificador de la variable, se escribe seguido de un espacio la operación que se realizará con ella, suma, resta, multiplicación, división o alguna otra; se escribe el signo de igual y se escribe el valor que se sumará, restará, multiplicará, dividirá o lo que hará...
Estos ejemplos son bastante válidos:
variable +=2 #suma 2 a variable
variable *=5 #multiplica por 5 el valor original de variable

aunque como dije, no es la obligación de los programadores python adoptar el método que comento, es solo una sugerencia que permite ahorrar un poco de escritura al programador.

Ahora sí podemos proseguir... en promedio para mostrar una cuenta de número desde el 1 hasta el 100 utilizando algún método que no recurra a los bucles se deberían de escribir el programa en 200 líneas de código, bastante si consideramos que el uso de los bucles puede hacer maravillas.



While.



Quizá el bucle más utilizado es el bucle while(mientras) que repetirá un bloque de código mientras se compruebe con éxito el valor de algo.

En este ejemplo podremos ver su funcionamiento, puedes guardarlo en un script para ejecutarlo con el intérprete:
#!/usr/bin/env python
var = 1
while var <= 100:
    print 'valor: %i' % var
    var +=1
raw_input()


El resultado es el que esperamos, quizá de una forma muy rápida, pero a final de cuenta lo es; este programa muestra los valores del 1 al 100.

while se puede usar con todos los operadores, pero es bastante preferible utilizarlo con menor o igual que(<=) o mayor o igual que(<=) por la simple razón de saber que no podemos usar igual a(==), ya que generalmente lo que necesitamos es ir incrementando una variable y si se comprueba su igualdad y no es igual no se ejecutará más el bucle.

Otro de los errores que no podemos permitirnos cometer mientras usamos el bucle while es olvidar incrementar el valor de la variable, ya que si no lo hacemos, el bucle comprobará de nueva cuenta el valor de la variable y como sería el mismo resultado, valdría lo mismo y el bucle jamás terminaría por no poder llegar jamás al valor esperado, a eso en el mundo de la programación se le llama bucle infinito y en el 90% de los usos está mal.

Por ejemplo, puedes volver a hacer el ejercicio del contador que iba hasta el número 100,, pero ahora con este bloque de código en lugar del while anterior:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
var = 1
while var <= 100:
    print 'valor: %i' % var
raw_input()


Si aún y con este claro ejemplo de lo que será un bucle infinito no puedes comprender lo que sucederá, te invito a ejecutar el script para que puedas ver un resultado parecido a este:
valor: 1
valor: 1
valor: 1
valor: 1
valor: 1
...

Ese bucle por eso se considera infinito, el código se repetirá hasta que la variable llegue a 100, pero como puedes ver, eso jamás sucederá, aunque no creas que todos los usos de los bucles infinitos están mal, más adelante veremos la manera de hacer un menú principal para una aplicación gracias a esta característica que aportan los bucles de ser infinitos.

Bien, para la próxima entrada haremos unas cuantas monerías nuevas, a lo que yo llamaré amablemente “introducción a uso de funciones”, veremos los tipos de datos que faltan y que pueden ser algo así como la esencia de Python a lo que llamaré “listas y diccionarios” y veremos el último de los iteradores, pff, tenemos demasiado que ver para una o dos próximas entradas.

Saludos.

jueves, 12 de enero de 2012

Script que apaga la pantalla en Ubuntu(se puede usar con la pantalla apagada)

Hola.

Como había dicho, este año tendría varias actividades que muy posiblemente agoten mis posibilidades de escribir y escribir entradas, pero mientras eso no suceda, aquí he regresado con un pequeño script que ayudaría mucho a algunos sistemas operativos con usuarios de lectores de pantalla.

Se trata de algo bastante simple, es solo un pequeño guión que apaga o enciende la pantalla de la computadora que se encuentra utilizando, pero no la apaga así como cuando se deja de utilizar por 5 minutos, este script se encarga de apagar la pantalla de una forma definitiva, se puede seguir utilizando una vez se haya apagado la pantalla.

Esto a mí me ha sido especialmente útil porque en mi equipo portátil no necesito de estar teniendo el monitor encendido, como mi equipo no aporta algún mecanismo fácil para poder apagar la pantalla, recurro a este interesante script.

La ejecución es simple, al momento de ejecutarlo el guión comprueba que la pantalla se encuentre encendida, si el monitor está apagado, lo enciende y si está encendido lo apaga; utiliza como dependencia espeak para decir si la pantalla está apagándose o encendiéndose, pero eso ya es completamente opcional.


Bien, no dejo el código aquí porque ya he guardado el archivo y lo he dejado disponible para su descarga, si lo quieres hacer, puedes revisar todo lo que quieras ese script, es escrito en bash(vaya, hasta que he dejado python) y no necesita de ningún programa o librería que no exista ya dentro del sistema operativo.

Para proceder a la descarga, debes hacer lo siguiente desde tu terminal(ctrl+alt+t):
Descargar el archivo:
$ wget http://dl.dropbox.com/u/55398785/monitor-toggle
Darle permisos de ejecución:
$sudo chmod a+x monitor-toggle
Moverlo a una carpeta que se encuentre en la variable de entorno path, para que puedas localizarlo solo al teclear el nombre sin necesitar buscarlo por todo el árbol de directorios:
$ sudo mv monitor-toggle /usr/local/bin/monitor-toggle
De manera completamente opcional, puedes añadirlo a una combinación de teclado para que no se necesite entrar a una terminal y escribir el comando.



En Ubuntu11.04 y anteriores, esto se hace así:
Pulsar alt+f1 o hacer click en el panel superior para desplegar el menú de gnome.
Ir hacia el menú sistema, buscar el menú preferencias y de ahí, pulsar con el botón izquierdo del ratón o la tecla enter sobre “combinaciones de teclas”.
Ese apartado es donde se configuran las teclas y las acciones que realizará cuando se pulsa una combinación, busca el botón “añadir combinación” y púlsalo para desplegar la ventana de adición de nuevas combinaciones.
Tiene dos cuadros de texto, “nombre” donde le puedes poner el nombre que tendrá la combinación de teclado, es el nombre con el que se identifica la clave, en este ejemplo puede ser algo así como “apagar y prender pantalla” o lo que te ayude a identificar esta combinación; el segundo cuadro de texto es en el que se escribe el comando que utilizará la combinación, es el comando con el que se activa el guión en la terminal.
Tras pulsar “aplicar”, se regresará a la lista de las combinaciones, con los cursores o haciendo uso del ratón puedes ir hacia abajo, ya que en estas versiones de Ubuntu con gnome2 el gestor de combinaciones de teclado suele mostrar las configuraciones definidas por los usuarios hasta el final de la lista.
Una vez que hayas localizado la combinación de teclado con el nombre que le diste, desplázate hacia la derecha para llegar hacia la columna donde se escriben las combinaciones de teclado, pulsa espacio o enter para activar la función y pulsa ahora la nueva combinación con la que deseas se active esta función.
Una vez terminado este paso, pulsa en cerrar y tendrás la combinación de teclado añadida.



En Ubuntu11.10 con Unity se hace así:
entra al dash(tecla del menú de inicio de Windows del lado izquierdo) y escribe las primeras letras o si no toda la palabra “teclado”, pulsa con la flecha hacia abajo varias veces para que el lector de pantalla(si es tu caso) pueda interpretar la información, uno de los resultados de la búsqueda(en mi caso el único) es “teclado” que ahora tiene una administración más eficaz.

En “teclado” se puede gestionar la escritura como las combinaciones(que ahora se llaman atajos), para nuestro caso, necesitas buscar la lista de pestañas e ir hacia la segunda pestaña, ya que por defecto aparece la ventana sobre la pestaña “escritura”.

Encontrando la pestaña del teclado, también puedes ver que las cosas se acomodan siguiendo otro estilo, ahora no existe una sola lista donde se contenían todas las secciones juntas, ahora hay dos listas, una controla las secciones en las que se encuentra el usuario, y la otra controla todos los atajos de teclado.

Como punto negro para esta versión de ubuntu, si navegas con los tabuladores primero aparece la lista que enlista las acciones, si pulsas otro tabulador, aparece ahora sí la lista de las secciones, es decir, que en mi opinión hubiera sido mejor que primero se mostrara la lista de secciones, pero me imagino que ya se solucionará después.

Para añadir una combinación personalizada es necesario buscar un botón, que en este ejemplo es bastante simple de encontrar, ya que solo dice “botón sombreado”(creo que dejaron muchas cosas sin pulir para el pobre orca en esta versión de ubuntu) y pulsarlo, en seguida aparecerá el cuadro que se mostraba en la versión anterior de esta explicación, igual, con dos cuadros de texto, el nombre de la orden y el comando u orden que se ejecutará en cuestión.

Al guardar pulsando en el botón “aplicar”, busca en la lista de acciones de la sección “combinación personalizada” el nombre que le diste a la combinación y haz lo mismo que en la explicación anterior, dirígete hacia la derecha para ir a la parte donde se escriben las combinaciones de teclado, pulsa espacio o enter e introduce la nueva combinación de teclas.

Una vez finalizado todo esto, ya deberías tener el script funcionando con una combinación a tu elección.

Como nota adicional, no te recomiendo hacer que el script inicie cuando se inicie la sesión de usuario, yo pensé en hacerlo para que la pantalla se apagara al iniciar la sesión, pero ocurre el fallo que no puede hacerla encender de nuevo, aún no sé porqué sucede esto, pero es importante darlo a conocer.

martes, 3 de enero de 2012

personalizando a orca: hacer que lea el estado de la batería

Esta es la primer entrada de “custom” de orca, así que comenzaremos explicando lo que vamos a hacer en este apartado.

Importante: si no sabes qué es la personalización de orca, puedes leer la entrada anterior, aquí lo intento dejar lo más claro posible.

Cuando decimos personalizar a orca, hablamos de poner un archivo de nombre “orca-customizations.py” dentro de la carpeta de configuración de orca(“~.local/share/orca” o “~.orca”) que tenga el código necesario para hacer lo que nosotros le estamos pidiendo.

En este primer acercamiento al como personalizar esta aplicación, vamos a iniciar con algo bastante sencillo pero a la vez una función que por algunas versiones del lector de pantalla se han olvidado de incluir, estoy hablando de la lectura de la batería, de su porcentaje de carga, de su estado(completa, no encontrada, desconocida, cargando, descargando) y del tiempo que restará para que la carga o descarga termine.

Sé que Python puede darnos una manera de hacer esto un poco más limpio, sin necesitar depender de uno de los comandos del sistema, pero como no pude averiguar algún método que pudiera cumplir con estos requisitos, usaré un programa del sistema operativo, aún sabiendo las posibles desventajas que esto podría traer.



Requisitos.



Los requisitos para este procedimiento son orca, una computadora portátil(obvio ¿no?) y un módulo o programa externo que se llama acpi.

Acpi sirve para proporcionar información del sistema relacionada con la temperatura y la batería(aunque en realidad sirve para mostrar información en dispositivos acpi) y nos beneficiaremos de esta utilidad que solo pesa 88KB una vez instalada y que no requiere dependencias extras(solo libc6, pero esa viene ya en el núcleo de GNU/Linux).

En Python haremos uso de la librería commands, que nos permite ejecutar comandos del sistema operativo, para llamar a acpi y trabajar luego con su salida y hacer que orca la muestre de una manera que se pueda comprender.

Para completar con los requisitos de la entrada vamos a empezar instalando acpi, de la siguiente forma en la terminal(alt+ctrl+t):
$ sudo apt-get install acpi
como ya había comentado antes, se trata de un paquete de un tamaño bastante pequeño, así que no debe haber problema alguno en su instalación, de hecho, puede que ya se encuentre instalado en el sistema operativo, si es así es genial, si no, con la orden que puse arriba debe instalarse.

Ahora necesitamos preparar(solo crear) el archivo que guardará el código de personalizaciones de orca, pues es el único archivo al cual hará caso el lector de pantalla para buscar una mejora o modificación a su comportamiento, así que al igual que siempre, ejecuta desde la terminal(alt+ctrl+t):
#si cuentas con la versión 10.04 o alguna inferior de ubuntu con orca 2.30:
$ gedit .orca/orca-customizations.py
#si cuentas con ubuntu 10.10, 11.04 u 11.10 con orca2.32 o superior
$ gedit .local/share/orca/orca-customizations.py

En cualquiera de los dos casos, gedit abrirá si ya existe o creará el archivo donde vamos a guardar el código para personalizar al lector de pantalla.

Si gedit detectó que ya existe ese archivo, seguramente es porque te encuentras utilizando una de las versiones modificadas de Ubuntu o Debian(Linux acessivel, vinux, tifloubuntu), ya que los creadores de dichas versiones personalizadas hacen el trabajo por ti; si es tu caso, no tiene mucho caso que modifiques nada, solo que lo que desees es aprender el funcionamiento de orca, otra cosa que te puede interesar es que en la función que lee la batería de estas versiones de sistemas operativos orca lo interpreta en inglés, cosa que no es muy placentera si tomas en cuenta que suena horrible su pronunciación con una voz de acento español.

Si aún estás interesado en seguir con esta entrada procederemos entonces.

El archivo que sirve para personalizar a orca cuenta con cinco secciones diferentes, las cuales es importante reconocer como la importación de módulos, definición de constantes, creación de funciones para arrojar resultados, creación de funciones útiles para orca y asignación de información a las funciones.

En la sección de importación de módulos solo se toma lo que se necesita de las características de Python, en la sección de definición de constantes se declaran las variables que nunca van a cambiar en todo el cuerpo de este archivo(luego veremos cuales y la gran importancia de esta), en la sección de funciones para arrojar resultados notamos una clara diferencia: todas las funciones de orca necesitan dos argumentos, script e inputEvent, cuando las funciones necesitan un argumento es cuando se deben incluir en la sección de funciones para arrojar resultados, en este ejemplo la sección 3 no se verá, pero en entradas futuras puede aparecer, la cuarta sección, las funciones útiles para orca son las que hacen el trabajo de lectura, donde se manda a mostrar las cosas a orca en voz o braille y en la última sección, es donde se asigna la información a las funciones, tal información es a qué letra del teclado se le asignará esa función y la descripción para mostrar cuando se esté en el modo de aprendizaje de orca, al cual se puede acceder pulsando la tecla modificadora de orca y la letra h.

Ahora, si lo deseas, podemos empezar pegando en el archivo que se acaba de crear todo este código, luego, para los que quieran explicaciones, explicaré.

# -*- coding: utf-8 -*-
#sección 1: importación de módulos.
import orca.input_event, orca.keybindings, orca.orca, orca.speech, orca.braille, commands, string
#sección 2: declaración de constantes.
teclado = orca.keybindings.KeyBindings()

#sección 4: creación de funciones útiles para orca.
def decirBateria(script, inputEvent=None):
    mensaje = commands.getoutput('acpi')
    if mensaje == 0:
        status = "error, no se encuentra instalado el módulo acpi, instálelo por favor"
    else:
        mensaje = string.split(mensaje)
    if mensaje[2] == "Full,":
        status = 'Batería llena y conectada'
    elif mensaje[2] == "Discharging,":
        status = "Batería al %s, %s restante" % (mensaje[3], mensaje[4])
    elif mensaje[2] == "Charging,":
        status = 'Batería cargando al %s, %s restante' % (mensaje[3], mensaje[4])
    elif mensaje[2] == "Unknown,":
        status = 'batería al %s neutral' % (mensaje[3])
    orca.speech.speak(status)
    orca.braille.displayMessage(status)
#sección 5: asignación de información a las funciones.
descripcionBateria = orca.input_event.InputEventHandler(
    decirBateria,
    'habla y muestra en braille la información de la batería')

teclado.add(orca.keybindings.KeyBinding(
    'a',
    1 << orca.settings.MODIFIER_ORCA,
    1 << orca.settings.MODIFIER_ORCA,
    descripcionBateria))

orca.settings.keyBindingsMap["default"] = teclado

Bien, aquí podemos notar las secciones a partir de la segunda línea, que es donde he puesto el comentario con el número de sección(los comentarios son las líneas que comienzan con el símbolo de número) e indicando el nombre de la misma, por ejemplo, aquí vemos que utilizo varios módulos que provee orca, todos ellos son bastante útiles para manejar aspectos como el manejo de los eventos(una pulsación de teclado es un evento), el teclado mismo(para añadir teclas a funciones), el módulo principal de orca(necesario para todo lo que tenga que ver con él), las funciones de voz y el uso de los dispositivos braille, la librería de la que hablé más arriba que permite ejecutar comandos del sistema y por último, la librería que nos permitirá trabajar con cadenas(que después veremos para qué la usaremos).

En la sección 2 solo existe una línea, cuidado con esta, pues esta línea se encarga de entregarnos el objeto de teclado, si no lo tenemos, no podremos modificarlo para que agregue a las combinaciones de teclas la que necesitemos, así que es importante no cambiar ningún valor a esta variable.

En la sección 4(no existe la sección 3) se muestra la función “decirBateria” que hace todo el trabajo pesado por así decirlo, vamos a analizar esta función para ver más o menos de forma detallada lo que hace y como lo hace.

def decirBateria(script, inputEvent=None):
En la línea que define la función, podemos ver que tiene dos parámetros, uno de nombre script y otro que se define en caso de no existir que se llama inputEvent, todas las funciones que usaremos para el archivo que personaliza a orca necesitan llevar estos dos argumentos, al menos si lo que se pretende es asignar el resultado de esta función a una combinación de teclado, ya que al momento de pasarle una combinación de teclado a una función, la primera le pasará estos argumentos a la función, solo así conseguiremos que se puedan ejecutar sin problemas, después veremos esto con detalle en entradas posteriores.

mensaje = commands.getoutput('acpi')
La primera línea del cuerpo de la función se encarga de asignar una variable de nombre mensaje a la salida del comando acpi, como puedes ver, se utiliza una función de la librería commands que es la que hace posible poder ejecutar un comando del sistema como en este caso es acpi.

if mensaje == 0:
status = "error, no se encuentra instalado el módulo acpi, instálelo por favor"
else:
mensaje = string.split(mensaje)
Si la variable mensaje después de ejecutar el comando acpi devuelve un 0, significa que no existe la aplicación instalada o que ocurrió un error, pero en el 99.9% de los casos es lo primero, así que en este bloque de código se comprueba y en caso de que no exista la aplicación, se le notifica al usuario que no existe y se le solicita que la instale; si la variable mensaje devuelve algo que no sea 0, significa que el comando salió bien y que lo que devuelve entonces es el resultado de la batería, pero en este caso con el impedimento de ser en inglés, por lo que la salida del comando sería más o menos así:
Battery 0: Discharging, 80%, 02:30:21 Remaining
Cosa que a mí no me gusta para nada, por lo que usamos el módulo string que habíamos importado en la primer sección para partir por palabras la oración anterior, así, se crea una lista del nombre mensaje(para no gastar demasiadas variables) con las palabras separadas de la oración, para quienes no entiendan de la mejor manera, imagina que ahora cada palabra se convierte en una variable, así, será más simple hacer lo que haremos a continuación.

Ahora,, entre corchetes se puede escribir el número de variable que deseamos llamar de la lista mensaje, cosa que hace muy interesante saber que lo que nos interesa de todo esto se encuentra en mensaje[2], mensaje[3] y mensaje[4]: mensaje[2] tiene el resultado del estado de la batería(Full, Discharging, Charging, Unknown), mensaje[4] tiene el tiempo que tiene restante o que falta para que se termine de cargar y mensaje[3] tiene el porcentaje de carga de la batería, entonces, debido a eso, comprobaremos en las siguientes líneas el valor de mensaje[2] y haremos una acción u otra.

if mensaje[2] == "Full,":
status = 'Batería llena y conectada'
elif mensaje[2] == "Discharging,":
status = "Batería al %s, %s restante" % (mensaje[3], mensaje[4])
elif mensaje[2] == "Charging,":
status = 'Batería cargando al %s, %s restante' % (mensaje[3], mensaje[4])
elif mensaje[2] == "Unknown,":
status = 'batería al %s neutral' % (mensaje[3])
En resumen, comprobamos si mensaje[2] vale cualquiera de los cuatro valores expuestos arriba y según sea el caso, asignaremos a status un mensaje que deberá mostrar con la ayuda de orca.

orca.speech.speak(status)
orca.braille.displayMessage(status)
Las últimas dos líneas de la función hacen que orca hable y muestre en Braille el resultado de la variable status, que debe tomar su valor según lo que haya ocurrido con la comprobación de mensaje[2]

descripcionBateria = orca.input_event.InputEventHandler(
decirBateria,
'habla y muestra en braille la información de la batería')
La sección 5 es casi de rutina, la primer asignación se encarga de crear un objeto que luego será asignado a una combinación de teclado y de rellenar la información del objeto, son solo dos parámetros, el primero le dice lo que se debe decir cuando la combinación de teclado sea pulsada estando en el modo de aprendizaje y la segunda le dice la función que debe ejecutar, debe escribirse sin paréntesis y sin argumentos, tal como en este caso.

teclado.add(orca.keybindings.KeyBinding(
'a',
1 << orca.settings.MODIFIER_ORCA,
1 << orca.settings.MODIFIER_ORCA,
descripcionBateria))
La segunda sentencia se encarga de añadir a la variable que tiene el teclado la información de la nueva combinación de teclas, que en este caso tiene 4 parámetros, el primero es la tecla que se usará para pulsarla con el modificador de orca, en el ejemplo de esta función se puede pulsar tecla orca+a para acceder a la función, el segundo parámetro debe ser el objeto que creamos una sentencia más arriba, y los parámetros 3 y 4 son de rutina, solo copiar y pegar, pero en teoría hablan de que se deben usar las teclas modificadoras de orca laptop y de escritorio.

orca.settings.keyBindingsMap["default"] = teclado
Al finalizar el archivo de personalización de orca, siempre debe ir esta línea, ya que es la que le dice a orca que debe reemplazar la información del teclado que ya tiene por la nueva, ya que la nuestra la hemos modificado y tiene que enterarse de alguna manera.

Ahora sí, guarda y cierra este documento y ejecuta a orca de nuevo, ya que necesita enterarse de los cambios ocurridos, entra en el modo de aprendizaje y pulsa la combinación de teclas que asignaste, deberás escuchar el mensaje que dice que habla y muestra en braille la información de la batería o algo así, si no lo es así, seguramente está mal ubicado el archivo o con un nombre incorrecto, así que vuelve a intentarlo.

Ahora sí, cada vez que ejecutes esta combinación de teclas, escucharás el mensaje de la batería, según sea tu caso.

Antes de finalizar quisiera pedir disculpas a los programadores Python, que seguro que no es lo mejor utilizar una librería como commands, pero intentaré reemplazar esto por subprocess, ya que es lo que debo hacer si quiero que el script no se me quede obsoleto(commands ya tiene poco tiempo de vida en comparación con subprocess, aunque aún no la terminan de retirar por ser una librería que se usa mucho), también por emplear un método que hace uso de las aplicaciones externas del sistema, trataré de buscar una manera que provea Python para no tener que emplear ni a commands ni a acpi, aunque lo veo complicado.

Esta entrada fue exhaustiva para mí, pero siento que de alguna u otra manera debía hacerla, no existe mucha documentación en español así que lo que sea válido para aportar será bueno, en entradas posteriores traeré más funciones, pero intentaré dejar de explicar tanto, que claro que como todo cansa.

Espero que haya sido interesante el método de personalizar a orca, en lo personal perseguí mucho tiempo esta posibilidad y me alegro poder estar aquí compartiendo lo que aprendí.

Saludos y hasta la próxima.

lunes, 2 de enero de 2012

Adiós a las actualizaciones semanales de Python

El motivo de la entrada no es para nada más que para anunciar la hasta ahora continuidad que le estaba intentando poner a las entradas que hablan acerca de la manera de programar en el lenguaje Python.

Si eres seguidor del blog o simplemente un observador, te puedes dar cuenta que desde la segunda entrada del lenguaje de programación he dicho que se sacaría una entrada nueva cada martes de todas las semanas, bien, he tratado de cumplir con este propósito y lo he logrado, pero para mi desgracia, han ocurrido algunos eventos que se escapan un poco de mi poder.

El tema para el cual escribo hoy en el blog simplemente es para anunciar que debido a una serie de proyectos muy personales posiblemente deje de actualizar de la manera que yo quisiera la serie de entradas que hasta ahora llevaba con gusto cada semana.

Ahora, ya se ha iniciado el año y el mío iniciará con una jornada de cosas por hacer, más que a finales del 2011 que fue cuando me planteaba el crear un grupo de entradas que faciliten a los no programadores el aprender un poco acerca de las capacidades de un lenguaje relativamente nuevo y bastante simple.

No dejaré de escribir las entradas que hasta este momento he escrito y que creo yo que no me han quedado demasiado mal para siempre, solo que escribo esta entrada para dejar entender que ya no podré dar una entrada o actualización nueva cada semana, no sé como venga el tiempo libre para estos meces, quizá lo haga cada dos o tres días(tiempo que me tomaría escribir un artículo bien redactado y con ejemplos en promedio), una vez a la semana, cada quincena o hasta puede que sea cada mes, recuerda(si perteneces al amplio mundo de los usuarios de estas plataformas de información) que como cada escritor, por más informal que sea tu espacio de información, que para escribir una entrada decente necesitas estar inspirado o al menos saber y probar de lo que vas a hablar, para eso en ocasiones se batalla y no es tan sencillo hacerlo, al menos que te dediques a poner noticias que salen todos los días, pero en este campo es complicado tener inspiraciones diarias y tiempo para escribir.

Bien, como digo, no será el fin de las entradas y de hecho estoy afinando los últimos toques de la entrada número 5, pero sí será el fin de las actualizaciones de forma periódica.

Solo eso, saludos y espero que hayan pasado un buen fin de año viejo e inicio de año nuevo.

orca: ¿en realidad es tan extensible como dicen?

Esta entrada va para los usuarios de orca, aquel lector de pantalla al que no he prestado mucha atención en estos últimos días.

Como lo has de haber leído, orca es un lector de pantalla libre, personalizable mediante scripts y de código abierto, además de potente, bien, lo que sucede con aplicaciones a las cuales se les puede explotar potencia como esta es que realmente sí cuenta con todas esas capacidades, pero seamos sinceros, ¿quién lo ha demostrado?

Ese fue el argumento que me había planteado uno de los usuarios que se dedican a intentar desprestigiar las prestaciones técnicas de aplicaciones que programa gente que no busca ningún beneficio económico con ello.

Y sí señores, aunque sea complicado creerlo y hacerlo, orca cuenta con dos sistemas bastante interesantes para crear scripts para él(algo que según muchos usuarios solo posee un lector de pantalla comercial) y otro sistema de personalización relativamente más simple que el primero(que ese creo que no lo tiene la aplicación comercial de la que hablaba).

Un script, como ya había explicado en una de las cuantas entradas Python que he realizado es un pequeño archivo que sirve para un procedimiento en específico, cuando se crea una aplicación nueva, en bastantes ocasiones el desarrollador decide crear algunos nuevos elementos de ventanas gráficas, ya que haciendo esto él obtiene mayor flexibilidad y eficiencia a cambio de dejar fuera a aplicaciones que leen los objetos accesibles como orca.

La solución a esta desventaja es crear lo que se le conoce como script, lo cual es un archivo que le indicará a orca lo que debe hacer cuando se tope con esta aplicación, es decir, le dirá a orca como modificar su comportamiento para que lo que fue inaccesible por el programador quede ahora de la mejor manera posible.

Si tú, usuario de GNU/Linux piensas que una aplicación para la que se deba crear un script de orca es un poco inusual estás equivocado, grandes aplicaciones que seguro usas a diario en tu sistema no podrían funcionar bien si no se encontrara creado un script que hace los trabajos necesarios para dejar todo funcionando de forma correcta, ejemplos de ellos y sin mirar la carpeta de scripts pueden ser pidgin(mensajero), nautilus(gestor de archivos), rhythmbox(reproductor de audio), la terminal de gnome, el editor de textos gedit, el cliente de correo evolution y thunderbird, etc.

Orca se encuentra programado utilizando el lenguaje de programación Python, por lo que crear un script tiene como único requisito tener un dominio bueno de este lenguaje y leer la documentación que viene en sus clases y funciones, aunque debo reconocer que al menos para mí no ha sido muy sencillo crear un script, ya que se debe leer también por lo general los métodos de las librerías de accesibilidad y debe estudiar bien la aplicación que falla para modificar apropiadamente las propiedades de orca, cosa que requiere tiempo, además que las grandes aplicaciones ya cuentan con script propio.

El segundo sistema por el cual se puede modificar el comportamiento de orca es la personalización, el cual es más simple de programar(solo se necesita conocimiento básico de las funciones de lectura de orca) y puede hacer que la aplicación lea un comando del sistema o algo así con pulsar una combinación de teclado o algún otro evento.

La diferencia entre un script y el archivo de personalización es que el script se hace para que una aplicación que no es del todo accesible lo sea, mientras que la personalización o modificación de orca se hace cuando lo que se desea es añadir una nueva función, pero que se pueda hacer en cualquier parte del sistema, como puede ser leer la hora, fecha, nivel de carga de la batería, las condiciones climáticas, la temperatura del procesador o algún otro dato del sistema que se puede llegar a leer con este lector de pantalla y sin tener que recurrir a programas externos.

En futuras entradas escribiré funciones que servirán para personalizar a orca y dotarlo de mejores características, haciendo simple que pueda leer alguna información que se podría leer utilizando la terminal o algo más, lo cual será bastante simple, ya que tenemos a Python y tenemos bastantes módulos y funciones que aportarán muchas maneras de hacer uso de ellos para interpretarlos con orca.

Bien, sin más que decir, saludos y esperen las entradas de “customizations” para orca.

miércoles, 28 de diciembre de 2011

GTK Hash: crear sumas MD5 y otros métodos de verificación de archivos

De nuevo intentaré hablar de un tema del que ya había hablado hace algunos meces en esta entrada y que considero muy importante a la hora de verificar los archivos que se poseen.

Vamos primero a ver una explicación de forma sencilla: todos los archivos se encuentran compuestos por bytes, los cuales son la unidad básica de las medidas de informática, pero claro que no pueden contener solo uno o dos, hablamos de que los archivos pueden estar compuestos de cientos de miles de millones de bytes.

Tomando como fundamento esta explicación, no debe hacerse raro que las personas que trabajan muy de cerca con los archivos y por ejemplo, en situaciones en las cuales la integridad de los mismos es más que fundamental, es necesario un método para conocer si los archivos son realmente lo que parecen.

Podemos ir tan lejos como lo desees, puedes imaginarte la creación de un nuevo proyecto millonario, en el cual, un infiltrado de la otra compañía se logra adentrar en el sistema y puede cambiar el contenido de uno o más archivos, comprometiendo el renombre de una empresa o simplemente puede ser un usuario que quiere saber que sus queridos archivos no son virus de Windows que se ven como tales(y ojo que el reemplazo de un archivo por otro es muy común en Windows).

Pero bien, no quiero hacer esta entrada con casos imaginarios y muy probablemente falsos, así que voy a indicar al menos para lo que yo uso este método, que lo que hace es una revisión muy exhaustiva del contenido de un archivo.

A mí me gusta mucho el contenido multimedia de todo tipo, música y series o películas principalmente, pero para el contenido que yo descargo desde la web o que de alguna u otra manera llego a obtener, creo que necesitaría varios discos duros de 2TB para no tener que eliminar contenidos, así que la solución parcial que yo he encontrado es pasar todo a un DVD, por ejemplo, en ocasiones tengo en el disco duro de la computadora películas en imagen ISO(los archivos de los que hablé en esta entrada), pero lo cierto es que aunque se trate de grabar todo desde la computadora hacia un DVD en blanco, las condiciones aún no son suficientes como para poder realizar esta tarea con un 100% de éxito, puede que, por causa del DVD o CD(que sea una pieza defectuosa) no puedan ser escritos algunos sectores, o que por parte de la unidad grabadora(hay muchos problemas con los búferes que estas poseen) no se complete el proceso de grabación de la forma que se espera y lo peor de todo esto es que los sistemas operativos(a excepción de GNU/Linux) no proveen de forma nativa métodos o programas que ayuden a comprobar que en efecto, los datos grabados en un CD o DVD se encuentran intactos.

De una forma más exacta hablo de métodos que haciendo cálculos precisos pueden devolver un número que servirá para compararlo con la misma comprobación realizada días o meces después, si el resultado obtenido es el mismo, significa que los datos no se han modificado para nada, pero si el resultado cambia, eso será indicio que alguien ha modificado los datos que contenía el archivo(o que por causas de otros tipos estos han cambiado).

En la entrada donde mostraba como obtener las sumas md5 de los archivos solo se hablaba del método de comprobación md5, pero existen otros muchos que pueden ser de mayor utilidad para obtener algo más concreto, ya que todos los algoritmos(procedimientos) de comprobación son susceptibles a fallos, por lo que es mejor tener varias comprobaciones disponibles en lugar de solo una.

Un punto débil del método que presenté en la entrada anterior es que depende por completo del nombre del archivo y de su contenido, por lo que si el nombre del archivo llegara a cambiar, el resultado sería otro diferente, pero lo peor del caso es que también depende mucho de la ubicación, por lo que si se modificara la ubicación real del archivo variaría también el resultado que arroje.

En los repositorios de ubuntu existe una aplicación de nombre GTK Hash bastante simple, su propósito es obtener los valores de comprobación de diferentes algoritmos como MD5, SHA1, SHA224, SHA256, SHA512 y algunos otros cuantos más, pero creo que esta aplicación dependerá del nombre del archivo, más no de la ubicación.

Se puede instalar de la siguiente forma desde la terminal(alt+ctrl+t):
$ sudo apt-get install gtkhash
Y su forma de uso es demasiado simple, es una simple ventana gtk con dos botones, uno de nombre “(ninguno)”, donde se pulsará para elegir el archivo del cual se obtendrán los valores y otro de nombre “cerrar”, que no creo que tenga que describirse.

Cuando se tenga un archivo ya seleccionado(la forma de seleccionarlo es la clásica de gnome) se habilitará el uso de un nuevo botón de nombre “hash” que comenzará a calcular los valores del archivo.

Desde el menú “editar” en la opción “preferencias”(creo que es la única opción con la que cuenta hasta ahora) se puede marcar un grupo de casillas las cuales indican los algoritmos que serán utilizados, se pueden elegir todos o ir marcando los que se crean necesarios.

Al momento de tener seleccionado el archivo y haber pulsado el botón “hash” para comenzar la comprobación, se necesitará esperar algo de tiempo o casi nada(dependiendo del archivo) para que se puedan mostrar los resultados, ya que cada algoritmo de comprobación cuenta con un cuadro de solo lectura, pero sin etiqueta, así que lo que se puede hacer para poder leer los resultados de forma correcta es tirar de la revisión plana de orca, cada algoritmo arroja un resultado completamente diferente.

Para saber si el archivo es correcto, solo se necesita hacer dos comprobaciones en tiempo diferente y comparar una de otra, si el resultado de las dos es el mismo, significa que no se ha modificado el archivo, si cambia, quiere decir que los datos en ese momento no son los mismos que cuando se hizo la primer comprobación.

Lo último que puedo recomendar acerca de los métodos de comprobación de archivo es no abusar de ellos y utilizarlos con calma, ya que no en todos los casos se necesitará tener ese tipo de orden, yo en mi caso lo hago porque me quisiera asegurar que los datos que tengo en los DVD sean los mismos que los que se encuentran en la computadora, pero no por conocer como se asegura un archivo se necesita esculcar todo el sistema buscando archivos inconsistentes, así que como dije, calma que no se hace con todos los archivos.

Saludos.

Python4: funciones y algo más

Perdón por lo pasado, pero no quedaba suficiente espacio en la entrada y creo que confundiría mucho las cosas, pero ahora sí vamos a ver los módulos y funciones en esta entrada.

Funciones.



Una función no es nada más que un procedimiento que alguna vez se inventó, con el fin de ayudar a automatizar algo que se debe hacer, que sea muy repetitivo o simplemente para ayudar a hacer el trabajo de varias líneas de código en una sola.

Python trae por defecto un grupo grande de funciones y módulos que le ayudan a operar en perfectas condiciones, todos esos módulos y funciones pueden ser utilizados por nosotros sin ningún problema, ese es su objetivo; a ese grupo de operaciones que puede hacer por defecto el lenguaje se le da el nombre de biblioteca estándar de Python, ya que es ahí donde se puede incluir algunas funciones por defecto que quedarán disponibles sin necesidad de conseguir nada más.

Casi todas las funciones se utilizan para recoger algo que se solicita a la computadora, esto lo veremos más adelante con los valores de retorno. También somos libres de crear nuestras funciones propias, dando la posibilidad al programa de ampliarse y crecer, de hecho, un módulo en parte puede o no estar compuesto por un grupo de funciones.

La forma de utilizar las funciones es escribir el nombre de la función y entre paréntesis el grupo de argumentos que ésta requiere.

Un argumento es el parámetro que la función utilizará en el procedimiento y que necesita para mostrar el resultado, como podemos imaginar, la función suma, en caso de existir como función estándar, necesitaría como argumentos los elementos a sumar, si no se cuenta con dichos argumentos, la función no podría hacer el resultado y posiblemente arroje un error.

Vamos a ver un ejemplo, con una función bastante básica de Python que nos permite saber a qué tipo de datos pertenece algo, la función se llama “type” y la sintaxis es así:
>>>type('hola mundo')

>>>type(21.56)

>>>type(12)


Como puedes notar, al escribir la función, ésta devuelve el tipo al que pertenece lo que está encerrado entre los paréntesis, esto que se encuentra encerrado es un argumento, y existen funciones en Python que ni si quiera necesitan argumentos, pero no por que no necesiten argumentos se debe de escribir sin paréntesis, toda función en Python debe llevar paréntesis, aunque no lleve argumentos, eso hace que el lenguaje reconozca las llamadas a las funciones.

Los argumentos de cualquier función pueden ser un dato ingresado por nosotros, como fue en el caso, o una variable que ya haya sido creada y que contenga algún tipo de datos:
>>>num = 29.999999999
>>>type(num)



Los módulos son archivos escritos por otros programadores que dotan al lenguaje de programación de mas funciones. Como no es posible cargar todos los módulos con los que viene Python al instalarse(especialmente al considerar la instancia de Python en sistemas operativos GNU/Linux), ya que ocasionaría una pérdida considerable de memoria al tener cargados módulos que no se utilizarán jamás, es necesario importar los módulos de los cuales necesitemos funciones.

Para hacerlo, probemos a importar el módulo “sys”, que nos provee muchas funciones, pero de las cuales solo utilizaremos la función salir, aquí también vamos a poder observar un tema importante en Python al que se le llama espacios de nombres, pero allá vamos.

Primero, para importar un módulo se escribe la palabra “import” seguida de el nombre del módulo que se importará, Python tiene una ruta interna en la cual buscará el nombre del módulo que se le solicita, si lo encuentra, lo importará y no mostrará nada por pantalla y si no lo encuentra, desplegará un bonito “ImportError”:
>>>import sys
>>>

Pero si se hubiera escrito de esta manera:
>>>import sysfs
...
ImportError: no module named sysfs

Así que hay que tener cuidado a la hora de escribir los nombres de nuestros módulos.

Dentro de los beneficios que nos aporta sys, podemos mencionar que es una biblioteca que nos da la lista de argumentos utilizados en la línea de comandos y la función para salir del intérprete, hasta ahora hemos estado saliendo a como podemos, cerrando la ventana del terminal, pero Python provee la función exit, que nos permite salir del intérprete.

Es necesario tomar en cuenta los espacios de nombres de los módulos, esto significa que no se puede simplemente llamar a la función de sys sin hacer referencia a él, es decir, sería inválido llamarlo así:
>>>exit()
...
NameError: name exit is not defined

Aquí podemos ver un punto bien hecho y otro no, el punto bien hecho es que como se puede ver en la llamada a la función, aunque no se requieran argumentos, como en exit, no se debe olvidar poner los paréntesis abiertos y cerrados; lo que no está bien, es intentar llamar a exit de esta forma, explico.

En Python es importante decirle al lenguaje de donde se necesita una función, en el caso que necesitemos utilizar la función exit ubicada en el módulo sys, necesitamos utilizar una sintaxis un poco nueva para dar a entender al lenguaje que buscará dentro del paquete sys, es decir: para utilizar una función de algún módulo, se escribe el nombre del módulo, se escribe un punto, y finalmente se escribe el nombre de la función así:
>>>moduloprincipal.funcion(argumentos)
En el caso que necesitemos utilizar la función exit de sys, se escribe lo siguiente(atención, al ejecutarla se cerrará el intérprete):
>>>sys.exit()

De esta forma nos aseguramos de dos cosas, primero, de saber que estamos utilizando un módulo(hay veces que de tantas modificaciones que haces al programa no sabes si aún se utiliza un módulo que antes se usaba) y de no confundirse de los nombres(puede que otro de los módulos traiga una función exit y sería bastante complicado revisar en una base de datos gigante para ver si ya hay una función exit).

Aún así, si lo que deseas es simplicidad, Python, aunque no lo recomiende su creador la puede aportar, existe una sentencia especial, que proviene de import, que no importa todo el módulo, más bien, intenta encontrar e importar únicamente el nombre de la función que se busca, por poner un ejemplo, podemos importar solo la función exit de sys, en lugar de todo el módulo.

Para hacer esto, se sigue una sintaxis así:
>>>from modulo import funcion
siendo modulo el nombre del módulo y funcion el nombre de la función.

En el ejemplo de necesitar solamente a exit, podemos hacer lo siguiente:
>>>from sys import exit
>>>

Ahora, una vez importado exit de esta forma, sí lo podemos utilizar como si no perteneciera a ningún módulo, ya que únicamente se ha mandado traer el código de exit, entonces, ahora, para salir solo haríamos:
>>>exit()

Esto nos tendrá dos consecuencias, una buena y otra mala.

La consecuencia o veneficiobeneficio
Se recomienda mucho la primera opción, es decir, los grandes programadores que trabajan en Python no suelen utilizar para nada, o al menos lo suelen hacer en lo más mínimo la función from import, que es el segundo método de importación que vimos.

Creando nuestros programas.



Ahora sí, es momento de meternos a lo que habíamos estado soñando por varios días, al momento clave de esta serie de entradas, a crear nuestros scripts.

En Python decir programa y decir scripts es lo mismo, técnicamente se supone que son diferentes, pero como a Python se le puede considerar como un lenguaje de programación semi interpretado, puede que valga lo mismo, aunque por jerga los que ya conocemos algo la movida decimos script cuando se trata de archivos que hacen una sola cosa y son automatizados, como un script que muestre la hora, mientras que un programa puede ser un grupo de scripts que haga tareas en conjunto y que se relacionen entre si mismos, como un programa que permita descargar archivos de la web.

Ahora, en teoría un script en Python es solo un archivo plano de texto con el código que ejecutará el intérprete, es un poco(pero solo un poco) diferente el inicio de la creación de un programa o script en sistemas Windows y GNU/Linux, especialmente porque en el primero necesitamos configurar un poco el entorno para que pueda ser capaz de mostrarnos la extensión de los archivos, cosa que se necesita para trabajar, mientras que en el segundo se muestran ya por defecto, por lo cual no es necesario hacer más nada.

En Windows necesitamos configurar, dentro del apartado “opciones de carpeta”, en la pestaña ver, la casilla para mostrar las extensiones de los archivos, ya que de lo contrario nunca conseguiremos que Python ovedezcaobedezca

Una aclaración importante para los amigos que usan Windows: ¿has notado que en los elementos del menú de Python viene un editor? Bien, si eres observador seguramente sí, si no lo eres, te informo que en la versión de Python empaquetada para Windows lleva un editor para dicho lenguaje, la razón para el que no lo haya preferido utilizar para este sistema operativo, aún con todas sus ventajas, es que en su totalidad es inaccesible, ni si quiera pude probarlo, así que no puedo dar indicaciones de este editor, me han dicho que es potente, ya que posee coloreado de sintaxis y cuanta cosa interesante, pero en este blog al menos, no utilizaré el editor, para hacer la cosa más estándar y para no mentir acerca de sus características reales.

Hace algunas dos entradas(o algo así) había comentado que era un poco diferente crear un programa para GNU/Linux que uno para Windows, bien, pues sí, es una línea de diferencia, pero para comenzar mejor veamos la manera de hacer un programa, podemos iniciar, del modo que queramos nuestro editor de textos favorito y por ahora solo escribir(o pegar si se desea el siguiente código), recordaremos un viejo conocido y lo conservaremos para la posterioridad:
#!/usr/bin/env python
print hola mundo
raw_input()


Listo, este es el código fuente de nuestro programa, ahora, lo cerramos y guardamos, pero es muy importante que en los dos sistemas operativos termine guardado con la extensión .py, ya que es el que le indicará a Python que lo puede ejecutar, puede quedar como “ejercicio1.py”, o “hola.py” o “lo que sea.py”.

En Windows se crea automáticamente la asociación de archivo para que el intérprete Python sea quien se encargue de ejecutar los archivos que terminen con esta extensión, por eso es tan importante dejarla, en GNU/Linux, recomiendo que cuando se piense ejecutar un script Python se haga desde la terminal, de lo contrario se debería otorgar permisos de ejecución manualmente a cada programa, para ir hacia un directorio desde la terminal, puedes hacer uso de la función cd, más o menos así:
$ cd programacion/python/
y para ejecutar un script Python estando en la ruta donde se encuentra el mismo, puedes hacerlo así:
$ python ejercicio.py
mientras que en Windows, para ejecutar un script Python solo basta pulsar dos veces con el botón izquierdo del ratón sobre el archivo.

Al ejecutar el script, según sea tu sistema operativo, podrás notar que se muestra el mensaje “hola mundo”, justo como lo hemos hecho al inicio de las entradas, con la única diferencia que ahora lo hace él solito, sin que le tengamos que estar escribiendo esto a cada vez que lo necesitemos mostrar, bien, eso es lo que define el propósito de un programa, hacer algo más sencillo de lo que ya lo es.

Para salir del programa, solo pulsa la tecla enter, y verás(en windows) que la ventana que contenía el mensaje se cerrará o en GNU/Linux que el prompt de la terminal será devuelto, es decir, saldrás de Python.

Es importante ver la diferencia que hay entre lo que necesitamos escribir cuando lo que queríamos era solo mostrar el mensaje anterior con el intérprete Python y lo que escribimos ahora cuando necesitamos que el intérprete se encargue de ejecutar el código.

Veremos paso por paso el programa:
#!/usr/bin/env python
Esta línea es importante para la ejecución del programa en el sistema operativo basado en GNU/Linux o algún otro Unix, en resumen le dice donde debe encontrarse el intérprete que ejecutará el programa, y en especial, esta sentencia le dice al programa que lo intente buscar en las variables de entorno, garantizando que lo encontrará
print 'hola mundo'
el cuerpo del programa, es aquí donde se escribe todo lo que se necesita hacer
raw_input()
esta línea indica que el programa se detenga hasta que el usuario pulse la tecla enter, es útil ahora en los sistemas Windows, ya que el comportamiento por defecto de Python es hacer lo que se le solicita y cerrar el programa, con la velocidad con la que se procesan los datos, en windows no sería capaz de verse el mensaje, solo se vería que se abre y cierra en menos de medio segundo una ventana negra, en GNU/Linux no es así puesto que al ejecutarse desde la terminal, el programa se cerraría, sí, pero se quedaría el resultado impreso en terminal, el programa cerrará cuando el usuario haya pulsado enter.

Es conveniente siempre escribir la primer línea en todos los programas Python que se generan, no es estorbo que la tenga y puede hacer que el código que se escribe sea compatible con múltiples plataformas de sistemas operativos, por lo que en códigos siguientes que se vean en este blog se incluirá la línea de indicación, junto con otra que después veremos que servirá para mostrar las cadenas con todos los caracteres del idioma español.

La última línea no es exclusiva para Windows, pero hace que en ese momento el programa se detenga, conforme avancemos en la creación iremos haciendo programas más y más complejos que irán eliminando el uso de esa última línea, después vamos a entrar en detalle acerca de su funcionamiento real.

Mostrando caracteres uni code.



Todos sabemos que en el idioma español existen algunos caracteres que no son considerados dentro del estándar, por esa y algunas otras cosas, en muchos lenguajes de programación se muestran los caracteres Uni code, esto deja fuera el estándar para nuestros caracteres, que es el utf-8. Es mejor dejarme de tantas explicaciones inentendibles y ver un código Python que lo demuestre, guarda este ejercicio en una carpeta dedicada a las entradas, especialmente para no confundir archivos, y ejecútalo después:
#!/usr/bin/env python
print 'este mensaje generará confusión al buen Python'
raw_input()


Muy posiblemente, dependiendo por completo de la distribución de Python que utilices en tu sistema operativo de Microsoft, no puedas ver el error que mostrará por pantalla, he aquí el resultado:
$ python ej2.py
File “ej2.py”, line 2
SyntaxError: Non-ASCII character '\xc3' on file ej2.py on line 2, but no encoding declared; see http://www.python.org/peps/pep-0263.html for details

Lo que nos quiere decir es que no admite los caracteres con acentos, letra ñ y algunos signos no estándares en el idioma inglés.

Bien, para solucionar este conflicto existe algo a lo que se le llama declaración de codificación que lo que hace es decirle a Python el tipo de códigos que usaremos, es decir, por defecto se utiliza el unicode, el cual no es compatible con los caracteres aquí mencionados, entonces, le indicaremos a Python que en lugar de unicode utilice utf-8 en el caso del español.

Para hacer esto, se debe incluir la siguiente línea justo abajo de la primer línea:
# -*- coding: utf-8 -*-
Para que el programa pueda quedar de la siguiente manera:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
print 'este mensaje generará confusión al buen Python'
raw_input()

tras guardarlo y ejecutarlo, podrás notar que ahora no existe ningún error que pueda afectar al funcionamiento del programa.

Esta línea nueva que acabamos de ver debe incluirse siempre en algún programa en el cual se piense utilizar un caracter que no se utiliza en el idioma inglés.

Bien, hasta aquí llega la información de esta entrada, espero y sea simple hacer nuestros scripts que ya van avanzando poco a poco y que finalmente los convertiremos en un más que interesante programa.

Saludos y nos leemos hasta el próximo martes.

lunes, 26 de diciembre de 2011

Twitter en pidgin

Esta entrada va para los amigos de pidgin; aquel cliente multiplataforma y multiprotocolo cuya versión para Windows no es del todo accesible y que utilizamos muchos usuarios en GNU/Linux.

En anteriores versiones del cliente de mensajería universal existía un plug-in llamado “pidgin microblog” que permitía conectar la cuenta de twitter a pidgin, haciendo simple y cómodo enviar tweets como si en una ventana de chat se tratara. Para desgracia de los usuarios, al cambiar de sistema de autenticación de Twitter el complemento dejó de existir, al menos en dos o varias versiones de Ubuntu(o solo que sea yo quien no pude encontrarlo en las distribuciones 10.04 y 10.10).

ahora con la salida de la más nueva versión de Ubuntu, por mera curiosidad me dio por iniciar una mini búsqueda para poder utilizar el twitter desde algo más cómodo que la web, ya que como sabemos, no es demasiado amigable para el buen orca y me llevé una sorpresa al encontrarme dentro de los repositorios oficiales de ubuntu la actualización de pidgin microblog.

Aquí detallaré su instalación y configuración, para después dejar todo preparado para solamente utilizarlo.

Antes de continuar y como requisito obvio necesitamos dos cosas, la primera es el pidgin ya instalado, lo cual se resuelve en la terminal así:
$ sudo apt-get install pidgin
y lo segundo es una cuenta de twitter ya creada y de preferencia ya siguiendo personas o algo así, ya que no es intención de la entrada explicar estos detalles(puede que más adelante en la semana los explique para los que no se entienden con esto), así que en el transcurso de la entrada daré por asumido que ya hay cuenta twitter, que ya hay pidgin y que se usa una versión 11.04 u 11.10 de Ubuntu(aunque puedes probar si usas alguna anterior, creo que como todo ser humano puedo equivocarme y estaría feliz de ello).

Revisando si existe el complemento.



Esto lo puedes ejecutar si tienes una versión 10 de ubuntu o inferior, en teoría sirve para comprobar si el complemento que necesitamos instalar se encuentra en los repositorios oficiales de ubuntu; todo desde una terminal(aplicaciones>accesorios>terminal o alt+ctrl+t):
$ sudo apt-get update
$ apt-cache search pidgin-microblog

Mostrando entre otras cosas un resultado como este:
pidgin-microblog microblogging plugins for pidgin
Si esto se muestra significa que es positiva la existencia del complemento en los repos oficiales, si la terminal no muestra nada en lo absoluto significa que no se encuentra nada con este tipo de nombre.

Solo si lo anterior dio como resultado que sí existe el complemento para pidgin se puede proceder con el resto de instrucciones de la entrada.

Instalación.



No tiene mayor detalle, con el método que uses para llegar a la terminal(ya no puedo especificar solo uno por culpa del nuevo diseño de la ubuntu más actual) ejecuta esto:
$ sudo apt-get install pidgin-microblog
Y listo, con solo responder que sí al mensaje que se mostrará se estará instalando el complemento para hacer de pidgin un cliente básico de twitter.

Configuración.



Ahora es importante cerrar pidgin si lo tenías abierto, ya que se debe registrar el cambio que supuso la instalación del nuevo plug-in y sigue los pasos a continuación:
  1. Abrir pidgin según sea tu caso desde el menú de gnome(aplicaciones>internet> cliente de mensajería de internet pidgin) o desde unity(escribiendo en el dash pidgin)

  2. Ir a la barra de menú y pulsar la flecha hacia la derecha para encontrar el menú “cuentas”, hacia abajo, buscar “gestionar cuentas” y seleccionarla con enter o la barra espaciadora

  3. Lo que aparece es una ventana que contiene la lista de las cuentas que has registrado para usarlas en el cliente universal; con tabulador encontrarás el botón para “añadir...” una nueva cuenta que será pulsado

  4. Al hacerlo se abrirá una ventana nueva con el foco en el cuadro combinado donde se selecciona el tipo de cuenta que se va a configurar, pulsar la barra espaciadora para poder seleccionar los elementos del cuadro combinado y con los cursores seleccionar el que dice “twitter IM”, para seleccionarlo solo es necesario volver a pulsar la barra espaciadora

  5. Pulsar tabulador y escribir el nombre de usuario, por ejemplo, mi cuenta en twitter es @manuelcortez00, así queda escrita, o al menos así lo hice yo, con el signo de @ y no ha pasado nada, uso twitter desde hace meces con pidgin.

  6. En lo demás no creo que sea necesario explicar, todo se debe mover con tabuladores y en el correspondiente lugar, debe de escribirse la contraseña, en el campo que dice algo como “utilizar este nombre de amigo” o algo así, puedes escribir el nombre con el cual verás tus tweets, para no ver muy seguido tu nombre en la cuenta de twitter, aunque esto es opcional.

  7. Al terminar de hacer todos estos ajustes, pulsa el botón “añadir” que se ubica en la ventana y cierra también la ventana de la gestión de cuentas.

  8. Lo que viene es algo bastante importante para que la cuenta pueda ser autenticada. Se te mostrará un mensaje donde se puede notar un cuadro de texto que servirá para poner el código que te dé la aplicación, casi al mismo tiempo, firefox se abrirá en la ventana de twitter, pidiendo autenticación y permiso para la aplicación; necesitas autenticarte en twitter y buscar el botón “permitir” o “autorizar” para que la aplicación pueda utilizar tu cuenta.

  9. Una vez autorizada, se mostrará otra página donde debes buscar un código numérico de algunos 7 u 8 dígitos, bien, si es posible memorizarlos hazlo, no se pueden seleccionar y copiar y escríbelos en el cuadro que se quedó una ventana atrás, al cual podrás volver pulsando alt+tab.

  10. Una vez escritos los números de forma correcta, solo pulsa en “aceptar” o “enter” para cerrar el mensaje, si todo ha ido bien, en breve se mostrará una ventana de chat que dice “twitter.con” y los mensajes que equivalen al historial de conversación de pidgin ahora son los tweets de las personas a las que sigues.


En la lista de amigos de pidgin aparece un grupo de nombre”twitter” con un único contacto “twitter.com”, la manera de twittear es más que sencilla, solo abres la ventana de chat de ese contacto y escribes como si fueses a enviar un mensaje normal a cualquier contacto, al pulsar enviar o enter se publicará tu tweet.

Puedes utilizar las menciones de la misma forma que las haces en twitter, escribiendo el nombre de contacto que deseas mencionar, lo que no he descubierto pero creo que se puede hacer es seguir o dejar de seguir a alguien, pero eso a su debido tiempo lo buscaré.

Saludos y hasta mañana.

Páginas de interez:
página de pidgin: www.pidgin.im
twitter: Twitter.com
Página del complemento pidgin micro blog(leer si vienes de Windows y te interesa tenerlo): Microblog Purple

martes, 20 de diciembre de 2011

Python3: cadenas y variables

Pasa de nuevo una semana y aquí tienes la pequeña introducción a la programación en Python, dando continuación a lo que habíamos visto en la entrada pasada, pero, esta vez no se hablará de un solo tema.

Las cadenas.



Un último tipo de datos que faltó por ver en la entrada anterior son las cadenas, y es que pudiera parecer que una cadena de texto no ha de tener operadores, es decir: es fácil pensar que como se trata de texto, no se puede sumar, restar, dividir o multiplicar, bien, pues puede que no sea posible, pero igual Python puede hacer bastantísimas cosas con dichas cadenas, pero primero iremos por partes.

Una cadena de caracteres es un texto que debe ir encerrado entre comillas o apóstrofes; como ya vimos en el ejemplo pasado, cualquier cosa que se encuentre encerrado entre comillas o apóstrofes de inmediato será interpretado por Python como una cadena, sin importar que sea algún número o alguna letra.

Python es un lenguaje de alto nivel, y su tipo de datos de cadena proviene posiblemente de muchos tipos char de C, explico: En C, existe el tipo de dato integer, float, pero en lugar de cadena, existe un tipo de dato al que ellos le llaman char, que significa caracter en español, que solo puede guardar una letra, no estoy seguro si sea por aquello del tiempo en el que se usó o por el tema de intentar ahorrar memoria en tiempo de ejecución, pero una cadena de 5 caracteres, para ellos es representado como una matriz de 5 chars, significa que para poner la palabra “hola”, por poner un ejemplo, se almacena en memoria una variable(después más detalles de ellas) en memoria con la letra h, otra con la o, otra con la l y una última con la a; aún y así, se trabajan estupendos programas utilizando al padre de Python, no hay que olvidar que aunque alguna gente lo pueda ver desfasado o viejo, C sigue siendo uno de los más potentes en la relación lenguaje computadora.

Las cadenas solo tienen dos operaciones que se utilizan muy frecuentemente, concatenación y repetición, lo cual son dos cosas diferentes, pero existe una biblioteca que provee Python que lleva más funciones para las cadenas, después, cuando veamos la importación y el uso de módulos veremos con mayor detalle a qué me refiero cuando menciono las bibliotecas del lenguaje.

La concatenación de las cadenas es algo equivalente a la suma de las mismas, podemos tener dos cadenas con diferente contenido(o con el mismo, aunque para estos casos se usaría la repetición) y hacer que se sumen, vamos a ver el ejemplo sobre la marcha ejecutando el siguiente código en el intérprete Python:
>>>print 'hola'+'adios'
olaadios
De nuevo retomo el ideal de que se le debe indicar todo a Python de forma explícita, aquí veamos por qué el ejemplo anterior salió de esta forma.

Como podemos notar, el resultado de concatenar la cadena hola y la cadena adiós salió casi como lo esperaría una persona normal, casi si exceptuamos que el resultado que arroja el intérprete no tiene separación entre las palabras, lo cual, a ojos de un no programador, es algo feo, poco vistoso y con muy pocas posibilidades de ser comprendido por un simple mortal.

Lo que pasa aquí es que la concatenación no garantiza nada, solo toma los elementos de una cadena y los pone uno al lado del otro; como puedes ver, al momento de escribir las palabras “hola” y “adios” no se separaban con ningún espacio, la operación solo juntó todo lo que contenían esas dos cadenas y el resultado fue el que se puede ver arriba, ahora, para hacer que se separe un espacio, nosotros lo tenemos que hacer de forma manual, podemos hacerlo pasando un espacio después de la última letra de la palabra hola, o antes de la primer letra de la palabra adiós; puede hacerse en cualquiera de las dos cadenas, pero hay que tomar en cuenta una cuestión, más que nada para hacer buenas costumbres a la hora de llegar a programar:
me ha pasado que en algunos programas toca concatenar palabras, y es complejo, si lo quieres ver así, que en algunas palabras no puedes saber si será la primera o la última, es decir, puede que por ahora no dé mucho significado lo que digo, pero a la hora de hacer programas dinámicos, pueden adquirir valores muy diferentes y uno como programador siempre debe de evaluar todas las condiciones y los valores que debería tomar un programa(incluso debemos tomar en cuenta qué errores puede lanzar y cuales no), en algún programa recuerdo que se tenía que tomar un grupo de palabras y ordenarlas en base a una oración en inglés, entonces, en determinado momento no se sabía si la palabra que se tenía en la cadena era la primera, segunda, tercera o última, sucede que cuando no podemos saber si la palabra de nuestra cadena es la última, es más recomendable pasar el espacio al final de las palabras que al principio, porque puede dar esa pequeña vista que muchos de los seres humanos no notarán, esta es que la primer palabra de la oración llevará un espacio antes, en cambio, cuando se pasa un espacio al final de la palabra, el espacio que sobra se verá en el final de la oración, lo cual, en cuestiones estéticas, es un poco menos visible; aunque calma, las dos son posibles alternativas y todo dependerá de uno mismo, aquí, por ejemplo, intentaré mostrar la problemática con tres palabras para daros una idea de la simple diferencia:
>>>print 'escribiendo '+'una '+'cadena '
escribiendo una cadena
>>>print ' escribiendo'+' una'+' cadena'
escribiendo una cadena
Los dos son ejemplos válidos, incluso se puede hacer algo como lo siguiente, mezclando las dos formas y poniendo un espacio después de la primer palabra y otro antes de las palabras, para conseguir que la primer palabra se vea sin ningún espacio y que la última tampoco sea afectada:
>>>print 'escribiendo '+'una'+' cadena'
Escribiendo una cadena
en fin, como comento arriba, todo es cuestión de estética y de gustos, de como quiera, si no te gusta en cierta parte un programa, solo debes ir a editarlo para hacer que cambie algo en su comportamiento o en la manera de mostrar las cosas por pantalla.

La repetición de una cadena no creo que se tenga que explicar, pues es eso, las veces que se repetirá, va representado por el mismo asterisco que multiplica los números, y se debe de escribir la cadena, el signo y el número de veces que se repetirá, es decir, su sintaxis puede ser algo como lo siguiente:
>>>print 'hola '*4
hola hola hola hola

pasa lo mismo que con la concatenación, solo se encarga de repetir lo que se indica, por lo que al igual que en su otra operación, es necesario poner un espacio que funcione para separar las palabras.

Como decía, también existe un módulo llamado string, que tiene varias funciones especiales que solo convienen a las cadenas, como convertir una cadena en puras mayúsculas, minúsculas, separar una cadena en una lista de varias palabras, etc, que en un momento más avanzado, cuando nuestros programas tengan alguna interacción con el usuario, podremos necesitar, para que te vayas dando una idea, el módulo se llama string y se encuentra dentro de la biblioteca estándar de Python, luego reservaré un espacio en la siguiente sección para esto.

Variables.



Una variable visto desde un punto matemático es una literal que puede tomar cualquier valor, esto significa que se le puede dar a cualquier letra un valor numérico o de más, en programación, una variable es un espacio en memoria que se guarda, pero el programador puede asignar ese espacio de memoria a una palabra, para eso de recordar mejor las cosas.

Supongamos que tenemos el número PI, el cual es 3.141619, para hacer algo más simple, pregunto yo, ¿No sería más fácil poner solo PI en lugar de 3.141619?
Como la respuesta es sí, se justifica el uso de una variable.

Simplificando podemos decir que al usar una variable, estamos guardando de forma permanente(hasta que nosotros mismos decidamos eliminarlo) un tipo de dato en la memoria de la computadora, por ejemplo, podemos hacer que se guarde el valor de PI y cuando en alguna función se solicite el PI, solo escribir la palabra con la que lo hemos guardado, así se evita el cometer un error y si lo hay, solo se necesitaría cambiar el valor de la variable.

La asignación de una variable en Python es muy fácil, solo mira este ejemplo para complementar:
>>>pi = 3.141619
Aquí podemos ver con claridad, significa que a la palabra pi se le asigne el valor que está a la derecha del signo de igual, luego, si en cualquier parte del programa se quisiera mostrar por pantalla el valor de pi, se puede hacer algo así:
>>>print pi
3.141619

Aquí también vemos el porqué las cadenas se deben encerrar entre apóstrofes, la razón es que si Python encuentra una palabra sin apóstrofes, creerá que es una variable y la intentará buscar en memoria, si no la encuentra, se producirá una excepción, que en resumen es un error que podríamos manejar pero que es mejor intentar evitar, vamos a hacer un ejemplo para ver de lo que hablo:
>>>print pi1
...
NameError: name 'pi1' is not defined

Aquí se intentaba mostrar el valor de pi1, no existe, solo existe pi, por lo que el intérprete devuelve lo que se conoce como un error de nombre(Obvio) y pasa cuando se está intentando llamar a una variable que no se ha creado.

En Python, a diferencia de muchos otros lenguajes de programación, la creación de una variable no necesita nada más que un solo dato, y este es el valor que tomará dicha variable.

La variable puede guardar todos los tipos de datos que hemos revisado hasta hoy, y no puede hacerse nada con los tipos de datos que no se pueda hacer con las variables, de hecho, el resultado será el mismo que si se estuviera utilizando Python sin hacer uso de ninguna variable, pero es bastante más cómodo utilizarlas, porque nos permiten, en cierta forma, recordar datos que puede que no conozcamos nosotros y que el usuario se encargaría de llenar, como el nombre, dirección o de más.

Las variables pueden tener cualquier nombre que se pueda crear con los caracteres de la a a la z(sin utilizar la ñ), sin acentos ni signos que no sean guiones bajos o cortos.

En otros lenguajes de programación, antes de asignar un valor a una variable, primero se debe especificar el tipo de datos que guardará esa variable; es decir, indicar si lo que guardará será un número entero, un número de punto flotante, un caracter o una cadena, en python, sin embargo, la variable al definirse se convierte en lo que diga el valor que se le asigne, esto quiere decir que si yo defino una variable y le asigno el valor 23, la variable se convertirá en una variable de tipo entero, si le asigno la palabra hola, se convertirá en una variable de tipo cadena, así sucesivamente, lo que supone una ventaja y da mucha flexibilidad al lenguaje.

Puede que en algún momento del programa se decida cambiar el tipo de la variable, más que nada para hacer que sea posible realizar alguna operación con ella, debido a que no todas las operaciones son compatibles con varios tipos de datos, por ejemplo, si se hace lo siguiente se estaría asignando un número a una variable de cadena:
>>>num = '25'
como el 25 se encuentra encerrado entre apóstrofes, Python interpreta que es una cadena y la convierte en un tipo string, ahora, si se quisiera multiplicar 25 por 4, se quisiera hacer lo siguiente:
>>>print num*4
25252525v
El resultado es inesperado, 25 por 4 no da tanta cantidad, pero si vemos como lo hace Python, podemos recordar que cuando se trata de una cadena se habla de repetir, entonces, decimos que la cadena 25 se repita 4 veces.

Esto es la consecuencia de que Python sea tan flexible a la hora de permitir que una variable tome cualquier tipo de dato, en otros lenguajes de programación, se debería crear otra variable para solventar el problema, en python, solo se debe convertir, para esto, daremos nuestra breve introducción al uso de una función y hacemos lo siguiente:
num = int(num)

Aquí vamos por partes para notar varias características más.

Una variable puede tomar el valor de otra variable, así mismo, podemos hacer que el valor de una variable sea su mismo valor con alguna clase de modificación, por ejemplo, podríamos crear una variable de nombre numero y hacer que la misma variable numero valga numero + 1, se hace de la siguiente forma:
>>>numero = 2
>>>print numero

2
>>>numero = numero+1
>>>print numero

3
Como vemos, al definir la variable, se puede cambiar de valor, haciendo que tenga otro completamente distinto, en este ejemplo, es como si se dijera en lenguaje simplificado que numero valdrá lo que vale ahora, pero más el 1.

Ahora, vamos con la parte en la que se ve “int(numero)”, bien, int es una función, después vemos que es eso, y lo que se encuentra encerrado en los paréntesis es la variable, int lo que hace con las variables es que las convierte a números enteros, entonces, al valer '25', la convierte en un 25, hagamos la prueba ahora sí, ya que como vemos, ahora la variable num vale 25, sin comillas ni nada, lo que significa que es una variable de tipo int:
>>>pŕint num*4
100

se puede convertir un tipo de dato en otro, ya que Python contiene funciones que hacen ese trabajo, aunque después veremos con más detalle eso, solo puedo decir que int convierte todo a número entero, float a número de punto flotante y .join() a cadena.

Uno de los temas en los que los nuevos programadores cometen errores es en la asignación de variables, pues es importante dar a conocer como trabaja el lenguaje las variables.

Es fácil hacer que una variable tenga otro valor, como ya hemos visto, se puede definir una variable una vez, después se define otra vez y el valor viejo de la variable se elimina:
>>>q = 5
>>>print q

5
>>>q = 24
>>>print q

24
En los dos casos se trataba de la misma variable, pero una vez que se reasigna, se elimina lo que contenía y se cambia el tipo de dato si es necesario.

También es importante resaltar que se debe de evitar hacer uso de esta práctica si en otra parte del programa se desea llamar un valor viejo, ya que no existirá y dará errores de cálculo, debemos asegurarnos de que ya no utilizaremos el valor de esa variable para ahora sí poder eliminarla, de lo contrario, no deberíamos eliminar ningún valor si se tiene una duda de poder o no poder usar el valor actual de alguna variable.

Antes de poder llamar a una variable, se debe definir o declarar, esto como ya lo hemos visto, es solo el decirle a Python el valor que debe tener la variable; hay algunas partes en un programa en las que no se puede declarar una variable, ya que si se hace en dichas partes de un script, puede resultar en un error grabe a la hora de ejecutar el programa, por lo cual es importante tener en mente que una variable se puede declarar vacía, esto es, si la variable será de tipo entero se puede declarar así:
>>>num = 0
Si la variable es de tipo de punto flotante(aunque de todos modos no habría problema, puesto que casi todas las operaciones se hacen con ambos tipos de números) la declararíamos así:
num = 0.0
si la variable es de tipo de cadena, podemos hacer uso del valor None, este valor significa nada o vacía, ya viene definido y lo podemos usar así:
cadena = None
Otra alternativa para crear una variable vacía es esta:
cadena = ''
que en dado caso sería igual de funcional que la cadena declarada con el valor None.

Regresando a la función print, podemos hacer que muestre varias variables como lo hacíamos con las cadenas:
>>>v = 12
>>>w = 14
>>>x = 16
>>>print v, ',', w,', ', x

12, 14, 16

¿Qué es esto? Bien, esta es la forma que los programadores Python no preferimos a la hora de mostrar variables. Como sabemos, una de las metas de Python es ser un lenguaje elegante, sencillo y poderoso, esto no se ve demasiado elegante, ya que se mezcla en cierto punto una variable con una cadena donde se pone una coma, la coma es para dar un orden más fino a los elementos, ya que se vería feo mostrar “12 14 16” sin ton ni son.

Sin dudas, es la forma más lógica y simple de escribir esto, pero deriva en muchas posibilidades de error y por dios, ¿a poco no se ve muy como anti elegante el código?

En Python, cuando se desea mostrar una cadena se suele separar todo, la parte de la cadena sin variable, que en el caso podría ser lo de las comas o en otros casos puede representar un mensaje al usuario por un lado y la parte de variables por el otro, dejamos unas pequeñas marcas que significa que ahí irán las variables, vamos a ver un ejemplo escribiendo esos tres números, pero con un mensaje personalizado al usuario:
>>>print 'serie del 2: ...%i, %i, %i...' % v, w, x
serie del 2: ...12, 14, 16...
El resultado puede que sea el mismo, pero la forma de hacer las cosas es la que cambia la filosofía del lenguaje.

La marca que utilizamos es el “%i”, que le dice a Python “deja un espacio para poner la primer variable que encuentres”, la desventaja quizá de esto es que necesitas saber cuantas variables vas a mostrar, ya que se pone, según sea el tipo %i para las variables de número entero, %s para las cadenas y %f para las variables de punto flotante.

Cuando se crea el mensaje, Python deja el espacio para mostrar esa variable, si puedes observar, cuando terminamos la cadena hay un símbolo de %, ese se pone siempre, y le indica a Python que lo que va a continuación de él son las variables para las que se dejó un espacio dentro del mensaje, deben ser justo las mismas y de los tipos que indiquen los signos de %, es decir, las i deben ser integers, las s deben ser string y las f deben ser float.

Podemos hacer el siguiente ejemplo:
>>>primernombre = 'Manuel'
>>>segundonombre = 'Eduardo'
>>>apellidos = 'Cortéz Vallejo'
print 'hola %s, sé que tu nombre completo es %s %s %s' % (primernombre, primernombre, segundonombre, apellidos)

hola Manuel, sé que tu nombre completo es Manuel Eduardo Cortéz Vallejo
Como vemos, no tiene nada de ciencia hacer esto, y podemos hacer uso de los paréntesis para dar más elegancia a nuestro código, también podemos ver que he utilizado la variable “primernombre” dos veces, lo que nos hace entender que podemos repetir cuantas veces queramos que aparezca el contenido de la variable en nuestro mensaje.

Bien, por ahora abandonamos el tema de variables, y si crees que ya hemos terminado con print, es un error, Python tiene varias posibilidades más de explotar esta función, pero ya vamos a ver propiamente lo que es un módulo y lo que es una función.

Módulos y funciones.

Un módulo es algo.... que veremos la próxima semana, feliz navidad y saludos, hasta el martes!