Tercer programa de Python (Sentencias de flujo)

Para el tercer programa, decidí fijarme en las sentencias de flujos (las más comunes), recomiendo revisar la Documentación ya que hay muchas cosas interesantes

Una de las cosas que puede llegar a romperte la cabeza son las identaciones del código que pertenece por ejemplo a un if, while, for, etc. ya que al no requerir llaves para
definir los bloques de código, debemos tener sumo cuidado con las tabulaciones.
No es lo mismo
 for i in range(5):
print(i)
print("boo")

que

for i in range(5):
print(i)
print("boo")
pueden ejecutarlo si gustan, en fin; otra cosa importante es recordar que los dos puntos (:) denotan el inicio de la sentencia de flujo, poner atención a ello en el
siguiente código.

#****************************************************************
#Mi tercer programa Python
#Si se abre con IDLE, ejecutar con la tecla F5

#Sentencias de flujo

#IF
a = 10
b = 70

#Importante: las sentencias a ejecutar segun se cumpla la condicion o no; debe
#identarse con un Tab
if (b/a) > 5 :
    print("Alcanza para todos")
    print("tenemos", 70/10)
else:
    print("No alcanza para todos")

#WHILE
#Se pueden omitir los parentesis de la condicion
count = 0

print("Uso del while")
while ( count <= 5 ):
    count += 1
    print("Imprimo " + str(count) + " veces")

#Entrada por teclado con input(""),
#en Python 3 se elimino el raw_input()
    
print ("While infinito, escribe adios para salir")

while True:
    entrada = input("> ")
    if entrada == "adios":
        break
    else:
        print (entrada)

#FOR
#Similar a Java se puede iterar sobre objetos sin necesidad de un contador
        
secuencia = ["uno","dos","tres","cuatro","cinco"]

for e in secuencia:
    print("Salgo en " + e)
#****************************************************************

En resumen:

1. Muy importante tener en cuenta los dos puntos (:) y las tabulaciones para los bloques de código, es vital esto, porque los métodos o funciones funcionan de igual forma
2. Los que estamos acostumbrados a C o Java vamos; por inercia a utilizar parentesis en las condiciones if (1 == i), pero acá los puedes omitir if 1 == i
3. Vimos el uso de la función str (print("Imprimo " + str(count) + " veces")) sin esto no podríamos concatenar el entero al resto de la cadena
4. Otra cosa importante y que me tomó algo darme cuenta, era que en Python 3 se eliminó la función raw_input() para procesar la entrada del teclado, de Python 3.x en adelante debemos usar input()
5. Descubrí que los for son bastante resumidos en comparacion con otros lenguajes

Recuerden revisar la ¡¡¡¡Documentación!!!! de paso les dejo el Cuarto programa

Saludos!

Segundo programa Python (Listas, Tuplas y Diccionarios)

Para el segundo programa vamos a ver las listas, tuplas y diccionarios.
En este punto existen varias cosas interesantes, como la busqueda por rangos, la búsqueda de atras hacia adelante en una lista, y la búsqueda con saltos (no sé como decirle exactamente). Vamos a verlo en el siguiente código.
Copialo y pégalo en el IDLE de Python y pinchale a F5.

#****************************************************************
#Mi segundo programa Python
#Si se abre con IDLE, ejecutar con la tecla F5

#Listas (arrays o vectores)
lista1 = [1, 2, "tres", 4, "cinco", [2,3], 7, "ocho", "nueve", 10]

print("Accediendo a la lista:", lista1[2])
#La sublista esta en el index 5 de la lista principal, accedemos al primer valor
#de ella (sublista)
print("Accediendo a la sublista:", lista1[5][0])

print("Lista original:", lista1)
lista1[0] = 100
print("Modifico 1er elemento (1 por 100):", lista1)

#Uso de numero negativo (busqueda inversa)
#Buscará la 3 posicion de atras hacia adelante de la lista
print(lista1[-3])

#Uso de Slicing (particionado) o busqueda por rango
print(lista1[0:4])

#Uso de saltos (cada n cantidad)
#Buscara solo en la posicion 0 a la 8, saltando 3 elementos en cada item encontrado
print(lista1[0:8:3])

#Tuplas
#Se pueden manejar a las listas
#La gran diferencia es que las tuplas son inmutables
#tupla1[1] = 100 (TypeError: 'tuple' object does not support item assignment) #este es el error que dá si intentas cambir algo, lo puedes descomentar para que lo vivas :)
tupla1 = (1,2,3,4,5)
print("Tupla:", tupla1[:3])

#Diccionarios, la misma vaina que los HashMaps de JAVA :)
diccionario = {"uno":1, "dos":2, "tres":3}
print("Diccionario:", diccionario["uno"])

#****************************************************************

En resumen:

1. Crear una lista es bastante sencillo, de igual forma acceder a sus elementos
2. Si bien las tuplas pueden ser manipuladas como una lista para su consulta, la gran diferencia es que las tuplas son inmutables, es decir que son como una especie de constante, no podemos cambiar los valores que les asignemos al crearlas.
3. Listas se crean con [], las tuplas se crean con ()
4. Y pues los diccionarios son una estructura de clave = valor en la que los valores se acceden por el nombre de la clave, similar a los HashMaps de Java
5. De igual manera, aunque no lo puse aqui (y obviamente) podemos hacer pruebas de recorridos con un for, que por cierto lleva abreviadas muchas cosas para los que estamos acostumbrados a los for de C o los antiguos de Java.

Aqui esta el Tercer programa

Este fué mi primer programa con Python, muy simple realmente. Comento entre líneas lo que estaba haciendo (recordar que los comentarios inician con #)
Copia el contenido a continuación (te sería más instructivo escribirlo pero bueno ...) y pégalo en el IDLE, ejecútalo con F5

#*****************************************************************************
#Mi primer programa Python
#El print recibe cualquier cantidad de parametros separados por coma (,)
#incluyendo expresiones aritmeticas como se muestra a continuacion.
#Si se abre con IDLE, ejecutar con la tecla F5

print ("Si sumas 2 + 3 el resultdo es ",
       2 + 3,
       "\nPero si los restas el resultado es ",
       2 - 3,
       "\nQue cosa no?")

#Variables
#No necesitas declarar de qué tipo son, sólo se declaran (tipo dinamico)
a = "Soy una cadena de texto"
b = 50
c = 25

print(a, "\nOperacion:", b + c)

c = "Como los tipo son dinamicos, puedes cambiar el tipo de dato de tu variable en tiempo de ejecución"
print(c) #Notar que c era un entero (25)

multilinea = """ Esto es cool
                 puedo escribir lineas sin usar carracteres de escape
                 solamente usando las comillas triples :)"""

print(multilinea)

#Las cadenas tambien aceptan operaciones aritmeticas
#Es decir que puedes multiplicar o sumar cadenas de texto
d = "eco"
e = d * 3
f = "sistema"
print("Multiplicacion de cadenas:", e)

e = d + f
print("Suma de cadenas:", e)
#*****************************************************************************

En resumen:

1. Es bastante agradable el metodo print, ya que acepta lo que le pongas y como lo pongas (salvo el caso de los enteros y lo que no sea string. Pero tranquilo! tenemos el método str() que transforma a string lo que le pongas :) Ej.: print(str(25))
2. Vimos que los tipos de datos son dinámicos (c era un entero y luego era un string)
3. Vimos los textos multilinea con """ """", util si no se quiere usar el clásico \n (que puede ser usado)
4. Vimos la multiplicación de cadenas

Un saludo! Cualquier duda, pues a la orden!

Aprendiendo Python

Bueno, hace algunos días decidí hacer cosas con Python para ver que tal, ya que quería aprender un nuevo lenguaje y me decidí por él.
En mi caso venía de trabajar puramente con Java y para mi sorpresa las diferencias son muchas (jejeje lógico no?), pero hay unas que me agradaron muchas.
Visto desde el punto de vista de la línea de aprendizaje pues hacer un programa algo complejo (Conexión a base de datos con Oracle usando ORM SQLAlchemy) no me tardó mucho.
Aunque atribuyo eso a que ya conocía un lenguaje orientado a objetos y que algunas cosas pues son muy similares funcionalmente.

Si me percaté de ciertas diferencias muy notables que dejo a continuación:

1. No tienes que tipar tus variables, el tipo de datos de las mismas es dinámico, es decir que según como la uses el tipo de dato de tu variable cambiará.
2. Los bloques de código no se cierran con llaves, en el caso del for y demás cosas por el estilo, se debe tabular el código (perfecto para mí porque tengo la tecla de la llave cerrando dañada :D)
3. Las funciones se declaran con la palabra def y aunque la función o método retorne datos no necesitas especificarlo en la definición de la función.
4. Debido a lo anterior y a lo del tipo dinámico de datos, la característica de POO sobre polimorfismo pierde un poco su lugar jejejjeeje.
5. Hablando de métodos y constructores todos (nunca se te olvide) llevan el parametro self, que es una forma como de this (de Java)
6. Para imprimir solo usa print!!! (no como ese largo System.out.println balalalalala .... )
7. Existe el try/except en vez de try/catch
8. Leer y escribir archivos ... qué les puedo decir ... es muy fácil!
9. Conectarte a una base de datos tambien es muy fácil, solo debes buscar los módulos indicados :)
10. La herencia es multiple!!! 
11. No! Los comentarios no inician con // inician con #

Bueno y sobre eso un montón de cosas más que aún voy descubriendo, pero por lo general han sido cosas muy buenas e interesantes y se puede decir que ya le tengo cariño.

Antes de iniciar, pues lógicamente debemos instalar Python en muestra máquina para poder usar la consola interactiva (!Si, consola interactiva!)

Partí con Python 3.3, entiendo que va por la 3.4 pero bueno habrá que revisar, ya que mi primer tropiezo fué leer la documentación de Python 2.x y darme cuenta que el print se convirtió en un metodo, por ende se debía llamar con parentesis ()

Para Windows es fácil, solo descargate el instalador (Aquí) y lo instalas (valga la redundancia) y en tu menú de programas aparecerá Python 3.3, para mi fué mas bonito usar la opción IDLE (Python GUI) que está dentro del menú Python 3.3, con este puedes ejecutar tu código presionando la tecla F5

¡Aqui está el primer programa!

Introducción a Android con un ejemplo (y no es HelloWorld)

Esta introducción va a ser diferente, ya que no vamos a ver como instalar ni configurar el SDK o cosas por el estilo y vamos a pasar directo a ver como luce un proyecto de android una vez creado. Además vamos a aplicar algo de programación para hacer una ventana que haga algo más que el clásico HelloWorld.

Primero vamos a crear un nuevo proyecto de Android: File -> New -> Android Application Project (o sus similares en español).
Completa los datos como los ves en la siguiente imagen, los detalles de SDK van a depender de lo que tengas instalado en tu máquina, por lo general suelo definir como SDK mínimo el 2.3, para lo demás uso lo más reciente disponible que tenga; en mi caso el Target lo he colocado API 18 y compilaré
con el API 19

Paso seguido vamos a asegurarnos de marcar las casillas que aparecen en la siguiente imagen:

Desmarco "Create custom launcher icon" porque no me interesa ahora mismo crear un icono para la app.
Dejo marcada "Create activity" porque quiero que me genere y me configure una primera actividad (Pantalla y su controlador) que será la que editaremos más adelante. Presionamos Next

Como decidimos crear una activity nos aparece esta pantalla, asegúrate de configurarla como en la imagen y presiona Next. En la pantalla siguiente colócale un nombre a tu activity (Activity Name), lo demás se autocompleta según lo que coloques. Presiona Finish.

Después de seguidos estos pasos debes tener una estructura de proyecto como la siguiente:

Primero vamos a darle un vistazo al archivo llamado AndroidManifest.xml
Hay muchas cosas que no sabrás con qué se comen, pero por ahora lo que nos interesa conocer es lo siguiente:
Linea 4: es la versión de nuestra app, la podremos ir aumentando según vaya creciendo nuestra app (nuevas versiones)
Lineas 13,14 y 15: Si te fijas verás que la referencia a los componentes están precedidos por un @, esto significa que son recursos de tu aplicación, estos recursos pueden ser manipulados libremente por ti para personalizar tu app a tu gusto. Dáles un vistazo presionando la tecla Ctrl + Click sobre el @ de cada uno.
Linea 17: De esta forma se asocia la activity (XML) con tu código Java, ves que el name del activity es el mismo de la clase que se creo en el package que definimos (es su nombre completo package + class name)
Linea 19: El <intent-filter>  en este caso está indicando que nuestra única activity que tenemos será la primera en aparecer cuando ejecutemos nuestra aplicación, esto se logra con las lineas 20 y 22.

Ahora vamos a editar los ficheros activity_button_event.xml (archivo en donde se diseña la pantalla) y su controlador ButtonEventActivity.java (Que vendria siendo algo asi como el Listener del JFrame en Swing)

Primero editamos el xml para que en vez de un TextView (algo asi como el JLabel de Swing) nos muestr un Button (algo asi como el JButton de Swing), lo haremos de esta forma:

Primero, hemos reemplazado el Layout (similar a como se aplican layouts en Swing) default por un LinearLayout, en la linea 5 vemos que la orientacion es vertical, esto quiere decir que todos los componentes que vayamos agregando se irán apilando uno debajo del otro.
En la linea 12 estamos creando un Button, con su etiqueta o texto (Ver mensaje) y sus propiedades de tamaño, fill_parent le indica al componente que debe extenderse tanto como el tamaño de su contenedor y wrap_content le indica al componente que debe ajustarse al contenido que tenga el componente, en este caso es un texto, asi que se ajustará al texto para extenderse.
En la linea 16 se muestra la forma que ofrece Android para manipular los eventos de los botones (es muy sencilla y practica aunque no es la única forma), si venimos programando con java SE podremos aplicar los mismos mecanismos de manejo de eventos (addActionListener .. etc.). ¿Cómo funciona esto?
Al definir en el onClick la etiqueta "ejecutarEvento", debemos crear en el controlador de la pantalla (archivo .java) una función sin retorno (void) con el mismo nombre de esa etiqueta y que reciba como parámetro un View, así de sencillo.

Veamos el código del controlador:

Las primeras 24 lineas te las debe generar el Eclipse cuando creamos el proyecto, lo nuevo y lo que debemos añadir nosotros son las lineas 29 en adelante (sin olvidar escribir los javadocs, creanme que son muy útiles para quienes tengan que revisar su código posteriormente. Como se dijo, el nombre del método es el mismo al que tiene el Button en el onClick en el XML anterior y lleva un View como argumento.
Lo que hace nuestro botón es mostrarnos un Toast (un pequeño aviso en pantalla) indicando que se ha realizado un click en el botón.

Ahora puedes proceder a ejecutar tu aplicación, en la medida de lo posible usar un teléfono real, ya que el emulador suele ser muy lento :)
Debe quedar algo asi:

Y al presionar el botón debe aparecer esto:

Bien, eso es todo por ahora. En el próximo punto vamos a hacer que nuestra pantalla tenga más componentes, como EditText (algo asi como los JTextField de Swing) y que lo que escribamos en ellos pase a otra pantalla para ser procesado.

Ahi, nos leemos. Recuerda seguirme en las redes sociales. Preguntas y comentarios a la orden, saludos!

Android, ListView dentro de un ScrollView

Aveces, cuando desarrollas antes de leer las teorías pasan cosas como esta.
Hace algunos días, me encontré con una dificultad al desarrollar una aplicación Android, mi caso era el siguiente.
Quería que una de las pantallas de mi aplicación respondiera a los cambios de orientación que el usuario realizara a su teléfono, esto no es mayor problema, por defecto el manifest de la aplicación configura todas las actividades para que esto suceda. Mi problema era que en esa pantalla tenia un ListView que desplegaba una lista de productos. En modo vertical se veía perfecto el ListView pero al girar el teléfono, al ser el espacio vertical más pequeño ahora, no mostraba todos los componentes de la lista, porque quedaban escondidos al girar la pantalla.
La solución: Utilizar, en lugar de un <LinearLayout/> un <ScrollView />, el problema: NO SE PUEDE TENER UN LISTVIEW DENTRO DE UN SCROLLVIEW.
Bueno ... con un pequeño truco si se puede, veamos:

Mi actividad era algo así

En lugar de tenerlo todo en un LinearLayout, debemos tener todo en un ScrollView, para que al girar el dispositivo podamos "scrollear" y poder ver todos los componentes de la GUI de la app.

Primero debemos crear nuestra propia clase que extienda de ScrollView

package com.example.layout.modified;

import android.content.Context;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.widget.ScrollView;

public class VerticalScrollView extends ScrollView {

public VerticalScrollView(Context context) {
super(context);
}

public VerticalScrollView(Context context, AttributeSet attrs) {
super(context, attrs);
}

public VerticalScrollView(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
}

@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
final int action = ev.getAction();
switch (action) {
case MotionEvent.ACTION_DOWN:
super.onTouchEvent(ev);
break;

case MotionEvent.ACTION_MOVE:
return false; // redirect MotionEvents to ourself

case MotionEvent.ACTION_CANCEL:
super.onTouchEvent(ev);
break;

case MotionEvent.ACTION_UP:
return false;

default:
break;
}

return false;
}

@Override
public boolean onTouchEvent(MotionEvent ev) {
super.onTouchEvent(ev);
return true;
}
}

Con esta clase reescribimos el comportamiento de un ScrollView normal, y esto nos evitará el mal funcionamiento de nuestra app al querer hacer scroll sobre la pantalla. Tal cual como esta allí pueden copiarla.
El siguiente paso será utilizar en nuestro xml de la actividad nuestra Custom Class, así:

Observar el inicio del tag del xml ahora, <com.example.layout.modified.VerticalScrollView ... Observar que es muy importante nombrar completamente la clase (nombre de paquete y nombre de clase) ,con esto estamos indicando que queremos usar nuestro custom ScrollView llamado VerticalScrollView, lo segundo es que he colocado el contenido de mi actividad dentro del nuevo ScrollView.

Con esto ya tendremos solucionado nuestro pequeño inconveniente y podremos Scrollear sobre un ScrollView que contiene un ListView.

Dudas a la orden, Saludos!

No todo es programación ... Sleepwalk cover por Rosendo Ropher

También me gusta tocar la guitarra y eso me relaja bastante ...