Java – Los ocho magníficos

lasecreObjetivo: presentar los tipos de datos primitivos en Java.

Antes de que empecemos a fabricar objetos como churros es importante que nos tomemos un tiempo para familiarizarnos con la materia prima de que están hechos, los ladrillos con los que construiremos nuestras nuevas estructuras de datos.

Sabemos que los objetos se componen de atributos, que no son más que un conjunto de variables con sus respectivos valores, y de métodos, las funciones que definen el comportamiento del objeto, lo que se puede hacer con él. Estos métodos, por lo general, procesan y devuelven datos también.

De modo que las variables son la sangre que circula internamente por los objetos.

Java requiere que especifiquemos el tipo de una variable en el momento preciso de declararla. Si recuerdas las clases Coche y Persona de los artículos anteriores, verás que aparecían en ellas algunas instrucciones como las siguientes:

String marca;
int velocidad;
boolean arrancado;
char sexo;
Coche coche;

Se trata de declaraciones de variables, en las que se asocia a cada nombre un tipo. Así pues, la variable marca referenciará una cadena de caracteres para indicar la marca del coche; velocidad contendrá un valor entero para expresar su velocidad; arrancado, de tipo booleano (verdadero o falso) nos hará saber si el vehículo está puesto en marcha o no; sexo contendrá un único carácter para indicar si la persona es un hombre o una mujer; coche, finalmente, es una variable de tipo Coche, un tipo que hemos diseñado nosotros al crear la clase Coche. Recuerda que Java diferencia entre mayúsculas y minúsculas, por eso coche y Coche son identificadores diferentes.

Fijémonos en los tipos de estas variables. Algunas de ellas, como coche, tienen por tipo el nombre de una clase. No es tan obvio eso mismo en la variable marca, pero observa que su tipo, String, comienza escrito por mayúsculas. Ya sabes que los nombres de clases, por convenio, empiezan por mayúsculas. Puedes pensar en Coche y String como tipos de datos compuestos, en oposición a los tipos simples restantes.

Los protagonistas de hoy son esos datos simples, atómicos, que luego utilizamos para construir otros tipos compuestos más elaborados. En Java son ocho y reciben el nombre de tipos primitivos.

Veamos cuáles son, agrupados por categorías.

Para declarar variables que contengan números enteros disponemos de cuatro tipos: byte, short, int y long. Se trata de enteros con signo (para valores positivos y negativos) y la diferencia entre ellos no es otra sino el número de bytes que ocupan en memoria y, por lo tanto, el rango numérico que pueden representar.

byte –> 1 byte (8 bits)
Rango: -128 / +127

short –> 2 bytes (16 bits)
Rango: -32768 / +32767

int –> 4 bytes (32 bits)
Rango: –2147483648 / +2147483647

long –> 8 bytes (64 bits)
Rango: –9223372036854775808 / +9223372036854775807

Como veremos cuando tratemos el tema de los literales, int es el tipo favorito de Java para lidiar con enteros. De ahí que a menudo nos planteemos una cuestión: ¿merece la pena la utilización de tipos como byte o short? Para aplicaciones sencillas, en las que la optimización del uso de memoria puede no ser relevante, no habría inconveniente. Pero imagina, por ejemplo, un programa que tuviera que manipular arrays grandes de enteros tipo byte (hablaremos de los arrays a su debido momento, pero por ahora basta con que sepas que son estructuras que permiten almacenar muchos elementos de un mismo tipo). Utilizar 4 bytes por cada elemento en lugar de 1, cuando son muchos, podría implicar un desperdicio de memoria crítico. Además, definir adecuadamente el tipo de los datos, dimensionándolos a lo estrictamente necesario, ayuda a mejorar la legibilidad y la comprensión del programa.

Para trabajar con números decimales disponemos de los tipos float y double. Están basados en el estándar IEEE 754 de representación en coma flotante. Si no has oído hablar de ese estándar hasta ahora y no sabes qué es eso de la mantisa y el exponente, te recomiendo que hagas una sencilla búsqueda en Google y te informes. Es una lectura que todo el mundo que trabaja con ordenadores debe hacer al menos una vez en su vida.

La diferencia entre float y double estriba, al igual que con las distintas opciones para números enteros, en el tamaño que ocupan: 32 bits el tipo float y 64 el tipo double, representando los números decimales con precisión simple o doble, respectivamente. Esto determinará tanto el máximo valor como el mínimo valor que podremos representar.

float –> 4 bytes (32 bits)
Mínimo: ±1.40239846E-45
Máximo: ±3.40282347E+8

double –> 8 bytes (64 bits)
Mínimo: ±4.94065645841246544E-324
Máximo: ±1.79769313486231570E+308

Aprecia la notación exponencial, no sería práctico escribir aquí un chorizo de trescientas cifras.

El tipo double es el favorito de Java al tratar números decimales. No obstante, como sucedía con los enteros, habrá situaciones en las que el ahorro de memoria puede ser un factor determinante que requiera una declaración de variables austera con float.

Para almacenar un carácter simple, Java dispone del tipo primitivo char, que ocupa 16 bits. Con él podemos representar caracteres Unicode (¡toda una bendición!) comprendidos entre ‘\u0000’ (0) y ‘\uFFFF’ (65535).

El octavo magnífico de nuestra serie es el tipo boolean, que admite dos posibles valores: true o false. Sólo se necesita un bit para almacenar dos estados posibles, pero el tamaño real que ocupa una variable boolean depende de la plataforma y de la implementación particular en Java. No es una cuestión importante pues, como hemos dicho, sólo se utiliza un bit, se guarde como se guarde.

Lo que resulta significativo es el hecho de que Java defina con exactitud el tamaño de sus tipos primitivos (sin contar boolean). No hay que perder de vista que Java está pensado como lenguaje multiplataforma. Si has programado en otros lenguajes y entornos quizás hayas constatado que el tamaño de un entero está muy relacionado con la arquitectura en particular. ¿Cómo es posible que Java logre esa independencia de la plataforma?

La clave es entender que cuando escribes un programa Java no lo estás haciendo directamente para tu sistema, sino para una una abstracción que es la máquina virtual Java (que, naturalmente, sí que es dependiente de la plataforma). Esa es la magia tras el slogan de Java, “escribe una vez, ejecuta en todas partes”, que permite que el código escrito para una plataforma funcione directamente y sin correcciones (en términos generales, no siempre es así) en cualquier otra en la que exista una máquina virtual Java.

Javier Montero Gabarró


http://elclubdelautodidacta.es/wp/2014/05/java-los-ocho-magnificos/


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


Índice completo de artículos sobre Java.

Python – Capítulo 17: Más días festivos a la semana

Objetivo: Ilustrar la modificación de elementos de una lista.

Las listas de Python son estructuras dinámicas y pueden ser modificadas. Hasta ahora hemos accedido a los elementos de una lista simplemente para consultar su valor. En la sesión de hoy modificaremos su contenido.

Empleando el intérprete interactivo de Python, introduzcamos una lista que nos es ya familiar y asignémosla a la variable semana:

>>> semana = ['lunes', 'martes', 'miércoles', 'jueves', 'viernes', 'sábado', 'domingo']

El intérprete se la traga y no devuelve nada, ya que se trata de una asignación. No obstante, verifiquemos que está en memoria:

>>> semana

['lunes', 'martes', 'miércoles', 'jueves', 'viernes', 'sábado', 'domingo']

Lo cantaba Bob Geldof y la mayoría lo suscribimos. ¿A quién le gusta un lunes?

Python es tan poderoso que puede hacer cambiar tu valoración sobre el primer día de la semana. Vamos a transformarlo en un festivo.

Los elementos individuales que constituyen una lista pueden ser modificados in situ accediendo a ellos a través de su índice. Decimos que las listas son estructuras de datos mutables. Más adelante, cuando hablemos de las tuplas, conoceremos otra estructura similar, inmutable, que no permite esta modificación in situ.

>>> semana[0]='fiesta'

Así de simple. Accedemos a los elementos de una lista a través de su índice como si de variables individuales se tratara, asignándoles el valor que deseemos. Recuerda que el primer elemento de una lista tiene por índice cero.

Revisemos nuestra semana tras esta sencilla operación:

>>> semana

['fiesta', 'martes', 'miércoles', 'jueves', 'viernes', 'sábado', 'domingo']

Esto, sin duda, tiene ya otro color, aunque presenta un serio problema: el martes pasa a ser el nuevo día negro, más oscuro aún, si cabe, por el hecho de estar precedido por tres días de ocio.

Nada que no podamos solucionar:

>>> semana[1]='fiesta'

>>> semana

['fiesta', 'fiesta', 'miércoles', 'jueves', 'viernes', 'sábado', 'domingo']

Y ya puestos, presta mucha atención a esta asignación múltiple:

>>>semana[2]=semana[3]=semana[4]=semana[5]='fiesta'

>>> semana

['fiesta', 'fiesta', 'fiesta', 'fiesta', 'fiesta', 'fiesta', 'domingo']

¿Quién dijo eso de que no todos los días eran fiesta?

Javier Montero Gabarró


Fecha de la última revisión: 20 de febrero de 2013


http://elclubdelautodidacta.es/wp/2011/08/python-capitulo-17-mas-dias-festivos-a-la-semana/


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


Consulta el índice completo de artículos relacionados con Python.

HTML #1: Nuestra primera página web

Objetivo: escribir una primera página web.

Comenzamos la nueva serie HTML, englobada dentro de la categoría general Tecnologías Web, en la que mostraremos los rudimentos de la programación web en su forma más primordial e inmediata: el lenguaje de marcado de hipertexto, HTML (HyperText Markup Language).

Al igual que el resto de las series de ECDA, su contenido será fundamentalmente práctico y centrado en un conjunto reducido de conceptos, facilitando así su asimilación y estimulando el apetito por otros conocimientos. La teoría será el cemento que enlace cada pieza del puzzle, pero siempre aparecerá supeditada a los contenidos prácticos, y no a la inversa. No hay otra manera de aprender.

Todo lo que necesitarás, de momento, será un simple editor de textos. Elige el que prefieras.

Crea un nuevo fichero y vuelca en él el siguiente contenido como texto plano:

<!DOCTYPE html>
<html>
<head>
<title>Mi primerísima página web</title>
</head>
<body>
Entre esto y un sitio web completo, no media más que trabajo...
</body>
</html>

Guarda el archivo en una carpeta para tus prácticas y ponle un nombre, como html-1.html, por ejemplo.

Los ficheros HTML tienen por extensión .html o .htm. Elegir una u otra es opcional, aunque no está mal tratar de ser consistente y emplear siempre la misma.

Realiza ahora una segunda copia del fichero y denomínala plantilla.html. Te servirá como modelo y evitará que tengas que escribir siempre la parte común de todo fichero HTML.

Para visualizar en el navegador los ficheros HTML que creemos no será necesario subir las páginas a un servidor. Bastará con acceder a la carpeta que las contiene y hacer doble clic sobre ellas, lo que provocará que se arranque el navegador y muestre el efecto del código contenido en el archivo.

Pruébalo. Si nunca has generado una página web antes, permítete disfrutar de la emoción de la primera vez.

Has dado un gran paso. En la siguiente entrega explicaremos qué significa la simbología que ha hecho posible esta primera página.

Javier Montero Gabarró


Fecha de la última revisión: 5 de octubre de 2012


http://elclubdelautodidacta.es/wp/2011/08/html-1-nuestra-primera-pagina-web/


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


Índice completo de artículos relacionados con HTML.

Tecnologías Web – El primer paso

Tanto si queremos aprender a programar en HTML, enredar en las entrañas de un CMS como WordPress, o experimentar la programación de scripts PHP, lo primero que debemos hacer es prepararnos un entorno de pruebas en condiciones.

Estamos hablando de tecnologías web y esta palabra es la clave de todo. Todo esto cobra sentido únicamente dentro de un servidor web; sin él hay poco que hacer.

Quizás ya dispongamos de un dominio propio en algun hosting. En ese caso ya tendríamos un espacio en el que experimentar con estas tecnologías. Desde luego, con las limitaciones que nos imponga nuestro proveedor, algo siempre a tener en cuenta a la hora de decidirse por uno o por otro.

Pero lo más recomendable es, sin lugar a dudas, que nos instalemos nuestro propio servidor web y configuremos un entorno ágil en el que podamos enredar sin miedo. Si, además, tenemos un hosting, dispondremos de la plataforma experimental perfecta antes de subir los archivos definitivos a la web.

Preparar un servidor web puede ser algo laborioso y no al alcance de cualquiera: hay que instalar, como poco, Apache, la base de datos MySQL y el soporte para el lenguaje PHP (trío conocido como AMP: Apache, MySQL, PHP).

Pero el primer paso no es siempre el más duro, tranquilos… Afortunadamente, existen productos que se ocupan de realizar todas estas tareas por nosotros, de modo que no tengamos que preocuparnos lo más mínimo por esos detalles.

Voy a recomendar dos de ellos y dejo a cada uno la libre elección:

WampServer (Windows)
XAMPP (Multiplataforma, opción recomendada si vais a seguir los cursos desde Linux).

La instalación es sencilla y podéis atreveros con ella sin mucha historia. No obstante, mañana publicaré un artículo indicando el proceso de instalación de WampServer 2.1 para la plataforma Windows.

Javier Montero

Python – Capítulo 15: Índices negativos

Objetivo: demostrar que los índices de una lista también pueden ser negativos.

En entregas anteriores explicamos que accedíamos a los diferentes elementos de una lista a través de su índice. Dijimos también que la cuenta no empezaba en el uno sino en el cero.

Por lo tanto, en una lista como

semana = ['lunes', 'martes', 'miércoles', 'jueves', 'viernes', 'sábado', 'domingo']

referenciamos el primer elemento, 'lunes', con:

semana[0]

mientras que el último, 'domingo', es:

semana[6]

En general, y teniendo en cuenta que el número total de elementos de una lista es len(<em>lista</em>), el último de ellos será referenciado como:

lista[len(lista) - 1]

Hoy aprenderemos una particularidad de Python: los índices pueden ser enteros negativos tambien. El concepto es sencillo:

lista[-1] hace mención al último elemento de la lista; lista[-2] al penúltimo, y así sucesivamente.

Aplicado a nuestra lista semana, tenemos:

semana[-1] corresponde a 'domingo', semana[-2] a 'sábado', etcétera.

¿Cuál sería el índice del primer elemento de la lista utilizando índices negativos?

Empleando la cuenta de la vieja es fácil de encontrar que el primero tiene por índice -7.

En general, si la lista tiene por longitud len(lista), el primer elemento es

lista[-len(lista)]

El siguiente programa ilustra esto:

semana = ['lunes', 'martes', 'miércoles', 'jueves', 'viernes',
   'sábado', 'domingo']

# Primer elemento de la lista desde dos ópticas
print('Primer elemento de la lista empleando índices positivos: ',
   semana[0])
print ('Primer elemento de la lista empleando índices negativos: ',
    semana[-len(semana)])

print ('-------------------------------') # Separador

# Último elemento de la lista desde dos ópticas
print('Último elemento de la lista empleando índices positivos: ',
   semana[len(semana) - 1])
print ('Último elemento de la lista empleando índices negativos: ',
    semana[-1])

Habrá ocasiones en las que agradeceremos esta posibilidad particular que tiene Python de “comenzar la cuenta” desde el final de la lista. Tiempo al tiempo…

Javier Montero Gabarró


Fecha de la última revisión: 19 de diciembre de 2012


http://elclubdelautodidacta.es/wp/2011/08/python-capitulo-15-indices-negativos/


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


Consulta el índice completo de artículos relacionados con Python.

Python – Capítulo 13: Recorriendo una lista con la sentencia FOR

Objetivo: presentar el bucle FOR al estilo de Python.

Supongamos que tenemos una lista sobre la que tenemos que realizar algún tipo de acción que implique acceder secuencialmente a cada uno de sus elementos. Sin ir más lejos, ¿cómo haríamos para imprimir, uno por uno, cada elemento que compone la lista?

Este problema es muy común y debe poder resolverse de un modo sencillo.

Considera, por ejemplo, la siguiente lista de todos los días de la semana:


semana = ['Lunes', 'Martes', 'Miércoles', 'Jueves', 'Viernes', 'Sábado', 'Domingo']

Imprimir el listado sería tan sencillo como hacer


print (semana[0])
print (semana[1])
print (semana[2])
print (semana[3])
print (semana[4])
print (semana[5])
print (semana[6])

Recuerda, tal como explicamos en el capítulo 11, que el primer índice de una lista es el 0, y no el 1; por eso hemos recorrido los siete elementos empezando en el cero y acabando en el seis.

Eso resolvería nuestro problema. Pero, ¿y si la lista tuviera 1000 elementos? ¿Escribiríamos 1000 líneas de código para acceder a la secuencia completa de la lista?

El bucle for nos permite solucionar esto de un modo elegante. Obsérvalo en acción:

semana = ['Lunes', 'Martes', 'Miércoles', 'Jueves', 'Viernes',
 'Sábado', 'Domingo']

for dia in semana:
    print(dia)

---
Lunes
Martes
Miércoles
Jueves
Viernes
Sábado
Domingo

La variable dia, definida ad hoc en el propio bucle, va a tomar, uno a uno, todos los elementos de la lista semana, comenzando por ‘Lunes’ y terminando en ‘Domingo’.

Con cada uno de estos valores realizará las acciones definidas a continuación en el cuerpo del bloque (delimitado por la indentación). En el ejemplo, simplemente imprimirá su valor.

¡Cuánta elegancia! Adoro Python.

Javier Montero Gabarró


Fecha de la última revisión: 11 de noviembre de 2012


Python – Capítulo 13: Recorriendo una lista con la sentencia FOR


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


Consulta el índice completo de artículos relacionados con Python.

Python – Capítulo 12: IDLE

Objetivo: presentar IDLE, un sencillo, pero eficiente entorno de desarrollo integrado en el propio Python.

Existen diversas formas de trabajar con Python. La más común consiste en generar un fichero de texto con nuestro editor favorito, almacenarlo con la extensión .py y ejecutarlo a continuación desde el intérprete de comandos. Otro modo implica la utilización de un IDE.

Un IDE (Integrated Development Enviromment, Entorno de Desarrollo Integrado) es una aplicación que integra en un espacio común todas las herramientas que el programador necesita en cada fase del desarrollo de sus programas, desde la edición del código, hasta la compilación, el depurado y la ejecución, así como un conjunto adicional de funciones que facilitan todas estas labores.

Hay numerosos IDEs para Python. Aquí hablaremos de uno de ellos, IDLE; no porque sea el mejor, sino porque es gratuito y se incluye en el paquete que descargamos desde la página oficial de Python.

Si eres usuario de Windows y tienes Python instalado, ya tienes IDLE también. Algunas distribuciones Linux no lo incluyen por defecto, y habría que instalarlo aparte si estuvieras interesado en su utilización.

El nombre IDLE, en sí, ya tiene su gracia:

Al igual que el nombre Python surge en honor a Monty Python, IDLE (que suena casi a IDE), está inspirado en Eric Idle, uno de los fundadores del grupo de humoristas británico.

IDLE, aunténtico que es, está escrito en Python, apoyándose en Tkinter para todos los aspectos relacionados con la interfaz gráfica de usuario, lo que facilita la interoperabilidad entre distintos sistemas.

Arranca IDLE. Si eres usuario de Windows, localízalo dentro del grupo de programas que aparece tras la instalación de Python.

Aparecerá una ventana, denominada Python Shell, ofreciéndote el prompt de Python >>>, del mismo modo que si lo hubieras invocado desde el intérprete de comandos.

En la parte superior se halla la barra de menús.

A continuación, crea una nueva ventana en la que escribirás un programa simple de ejemplo.

File | New window

Y escribe algo así como:


# Programa desde IDLE
print ("Este programa está creado desde el editor que trae IDLE")

Observa los colores que te aparecen al escribir: IDLE se ocupa de destacar los distintos elementos, de modo que el programa resulta más legible.

Guarda el programa en disco con:

File | Save As...

No te olvides de escribir la extensión .py junto al nombre.

Ejecuta el programa recién creado con:

Run |Run Module (o pulsando la tecla F5)

En la ventana Python Shell se te mostrará el resultado de la ejecución.

También podrías haber cargado un fichero ya existente:

File | Open

No necesitas cerrar la ventana del código anterior, IDLE te permite tener abiertas cuantas necesites.

Entretente enredando con IDLE. Carga alguno de los programas anteriores y juega con ellos. A su debido momento mostraremos otras características de este genuino y divertido IDE que utilizaremos a partir de ahora para seguir aprendiendo Python con comodidad.

Javier Montero Gabarró


Fecha de la última revisión: 31 de octubre de 2012


http://elclubdelautodidacta.es/wp/2011/07/python-capitulo-12-idle/


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


Consulta el índice completo de artículos relacionados con Python.

Python – Capítulo 11: ¡Qué lista que eres!

Objetivo: presentar una de las estructuras de datos estrella de Python: las listas.

En el capítulo de hoy realizaremos una primera aproximación a unas estructuras de datos muy particulares y tremendamente versátiles, las listas. Te anticipo que harás uso extensivo de ellas a lo largo de tu vida como programador en Python. Te encantarán no solo por su flexibilidad para adoptarlas en buen número de situaciones diversas, sino también por su eficiencia, la extremada rapidez de las operaciones efectuadas con ellas.

En esencia, una lista es una secuencia: una colección de objetos ordenados.

He aquí tu primera lista:

['Pera', 'Plátano', 'Manzana', 'Fresa']

Se trata de una lista que consta de cuatro elementos (en este caso, cuatro cadenas de caracteres). El primero es 'Pera' y el último 'Fresa'.

Observa que separamos cada elemento mediante una coma y que el contenedor en conjunto se delimita mediante un par de corchetes.

Los elementos de una lista no tienen por qué ser necesariamente del mismo tipo. En el siguiente ejemplo la lista contiene dos strings y dos números.

['Ajedrez', 7, 3, 'Pepino']

Accedemos a los distintos elementos de la lista a través de su índice, esto es, la posición del elemento dentro de la lista. Es importante tener presente que el primer elemento de la lista no tiene por índice uno, sino cero.

Volvamos a la lista del primer ejemplo, con cuatro elementos en total. El primero de ellos tiene por índice cero; el último tres. Te lo he puesto en negrita para que te lo repitas unas cuantas veces y lo asimiles bien. Es un error común comenzar a contar partiendo desde el 1.

En general, si una lista tiene n elementos, el índice del último será n-1.

Asignamos una variable a una lista del siguiente modo:

frutas = ['Pera', 'Plátano', 'Manzana', 'Fresa']

Para acceder, por ejemplo, al elemento de índice 2, escribiríamos

frutas[2]

Según lo explicado anteriormente, se trataría del tercer elemento, 'Manzana'.

El programa que figura a continuación ilustra de un modo básico el acceso a los elementos de una lista a través de su índice:

semana = ['lunes', 'martes', 'miércoles', 'jueves', 'viernes', 'sábado', 'domingo']

dia = int(input('Introduce un número del 1 al 7: '))

while dia < 1 or dia > 7:
    dia = int(input('Introduce un número del 1 al 7: '))

print('El día elegido se corresponde a un', semana[dia-1])

Su operativa es la siguiente: nos solicita que introduzcamos un número del 1 al 7 y, en función de ese valor, nos devuelve el día de la semana correspondiente (siendo el primero el lunes y el séptimo el domingo).

Comienza con la creación de una lista conteniendo los siete días de la semana. La almacenamos en la variable semana.

Introducimos después un número del 1 al 7 y lo guardamos en la variable dia.

El bucle while que aparece a continuación efectúa una sencilla comprobación: si el número que hemos introducido no está dentro del rango del 1 a 7, se nos solicita que repitamos la operación.

Finalmente, se imprime el día correspondiente. Observa cómo empleamos el índice: puesto que el primer elemento de la lista tiene por índice cero, habrá que restar uno al valor de la variable dia para que se muestre el día correcto. Esto es, el elemento contenido en semana[dia-1].

Y esto es suficiente por hoy. ¿Te han quedado claros los conceptos expuestos en el artículo? Si es así, enhorabuena, has colocado una pieza pequeña pero muy importante en el puzzle.

Javier Montero Gabarró


Fecha de la última revisión: 14 de septiembre de 2013


http://elclubdelautodidacta.es/wp/2011/07/python-capitulo-11-¡que-lista-que-eres/


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


Consulta el índice completo de artículos relacionados con Python.

Python – Capítulo 10: Continúe, por favor

Objetivo: aprender a utilizar la instrucción continue para saltar directamente a la siguiente iteración en un bucle en Python.

En el artículo anterior presentamos la instrucción break, que nos permitía interrumpir la ejecución de un bucle y salir de él. Hoy mostraremos la sentencia continue, muy relacionada con la anterior.

Al igual que break, continue cancela la ejecución de las instrucciones que quedan pendientes del bucle a partir del mismo momento de su aparición.

Pero, a diferencia de break, que ocasionaba, además, la terminación brusca del bucle, dejando de producirse más repeticiones, continue hace que se salte inmediatamente a la siguiente repetición. Es decir, vuelve a comprobarse nuevamente si se cumple la condición y, en caso afirmativo, continúa ejecutándose el bloque desde el principio otra vez.

Para ilustrar su uso, diseñaremos un programa que nos inste a introducir un número. Su misión será calcular la suma de todo lo que vayamos introduciendo, pero sólo teniendo en cuenta los números pares, ignorando los impares.

suma = 0

while True:
    numero = int(input('Introduce un número (0 para terminar):'))
    if numero == 0:
        break
    if numero % 2 != 0:
        continue
    suma = suma + numero

print(suma)

Comenzamos inicializando la variable suma, que contendrá la suma final buscada.

suma = 0

Y nos adentramos en un bucle infinito:

while True:

La condición es cierta siempre, por lo que habrá dotar al programa de mecanismos para interrumpir el bucle.

Introducimos un número, lo convertimos a entero y lo asignamos a la variable numero.

numero = int(input('Introduce un número (0 para terminar):'))

Si el número introducido es cero (el valor centinela) rompemos el bucle con la instrucción break.

if numero == 0:
    break

Pero, si no lo es, nos encontramos con el siguiente bloque if, que contiene la instrucción objeto del artículo de hoy:

if numero % 2 != 0:
    continue

El % es el operador módulo, que calcula el resto de una división. Que el resto de dividir un número entre dos no sea cero significa que el número es impar.

Los números impares, tal como está planteado el problema, debemos ignorarlos y no tenemos que incluirlos en la suma. ¿Qué hacer?

Continuar, así de simple: deja de ejecutarse lo que queda de bucle y vuelve otra vez al comienzo, reevaluando la condición. Eso es precisamente lo que hace la sentencia continue.

Cuando el número introducido es par, entonces si se acumulará a la suma total:

suma = suma + numero

Y así sucesivamente hasta que nos cansemos e introduzcamos el centinela, momento en el cual se rompe el bucle y se prosigue con la primera sentencia fuera de él: la impresión del resultado final.

print(suma)

Vuelve al código completo más arriba y comprueba el programa globalmente. Presta mucha atención a las indentaciones que delimitan cada bloque.

Naturalmente, hay medios de resolver este problema sin emplear una instrucción continue, pero he preferido esta solución, en la que se aprecia claramente el uso y diferencia entre los dos modos de alterar la ejecución de un bucle: break y continue.

Javier Montero Gabarró


Fecha de la última revisión: 24 de septiembre de 2012


http://elclubdelautodidacta.es/wp/2011/07/python-capitulo-10-continue-por-favor/


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


Consulta el índice completo de artículos relacionados con Python.

Python – Capítulo 9: Atrapado en el día de la marmota

Objetivo: presentar la sentencia break, que nos permite abandonar un bucle en cualquier momento.

En el capítulo anterior explicamos la estructura while, gracias a la cual podemos repetir en bucle un determinado conjunto de instrucciones.

El funcionamiento era sencillo: evaluábamos una determinada condición y, si era verdadera, ejecutábamos el bloque completo de instrucciones indentadas bajo la instrucción while. Una vez hecho esto, reevalúabamos la condición y, si esta volvía a ser cierta, repetíamos nuevamente el bloque. Así sucesivamente, finalizando el bucle en el momento en que la evaluación de la condición resultara falsa.

Es importante tener en cuenta que, si la condición es verdadera, el conjunto de instrucciones se ejecutará al completo. Todo, si se cumple; o nada, si no.

Pero, ¿y si deseamos abandonar bruscamente el bucle en cualquier momento, sin esperar a que se haya ejecutado el bloque completo o que la evaluación resulte falsa?

La sentencia break se ocupa de esto. Cuando se ejecuta, se sale completamente del bucle, sin esperar a su conclusión y sin repetir ninguna iteración más.

Observa el siguiente programa:

# coding=latin-1

mayor = 0

while True:
    numero = int(input('Introduce un número natural (0 para terminar): '))
    if numero == 0:
        break
    if numero > mayor:
        mayor = numero

print('El número más alto introducido es ', mayor)

Se nos pide que introduzcamos un conjunto de números naturales (es decir, enteros positivos) y se trata de determinar cuál es el mayor de todos ellos. Cuando no queramos introducir más números escribiremos el valor cero (ajeno al conjunto de los naturales), momento en el que el programa sabrá que ha llegado al final y deberá presentar el resultado.

Comencemos observando la sección con el bucle while:

while True:
    numero = int(input('Introduce un número natural (0 para terminar): '))
    if numero == 0:
        break
    if numero > mayor:
        mayor = numero

Lo primero que debe llamarnos la atención es la condición que hemos utilizado. No es una expresión lógica cualquiera.

Las expresiones lógicas dan como resultado dos posibles valores: True o False (la primera letra ha de escribirse con mayúsculas). Es decir, o son verdaderas o falsas.

La expresión True, tal como está en el bucle es siempre verdad. No hay verdad más verdadera que esa. Por lo tanto, su efecto va a ser provocar un bucle infinito, pues la condición siempre va a ser cierta en cada reevaluación. Estamos atrapados en un ciclo sin fin; ¿cómo podríamos escapar de él?

Analicemos con detalle lo que sucede dentro del bucle while:

numero = int(input('Introduce un número natural (0 para terminar): '))

Introducimos un número, lo convertimos a entero (recordemos que el resultado de input es un string, y no un número) y lo asignamos a la variable numero que, en la primera iteración, queda así inicializada (un término relacionado con la programación) con el valor que introduzcamos.

Prosigue el bucle con:

    if numero == 0:
        break
    if numero > mayor:
        mayor = numero

Si el número introducido, almacenado en numero, es cero, se ejecuta la sentencia break.

La sentencia break es drástica: abandona el bucle directamente, sin esperar a que se repita más veces y sin esperar tampoco a completar el resto de instrucciones pendientes del bloque.

Estamos ante un bucle controlado por centinela. A través de la variable numero, estamos atentos, vigilando cuándo se introduce un valor especial que nos hará salir del bucle. El centinela ha de ser un elemento ajeno al conjunto posible de valores susceptibles de ser procesados, por eso elegimos el cero. Habría servido también cualquier entero negativo.

Llegamos al corazón del algoritmo: si el número introducido (numero) es mayor que el que guarda la variable mayor, hacemos que ésta cambie de valor con ese otro número. De este modo nos aseguramos que mayor tenga siempre el mayor de los números que han ido entrando en escena.

Dijimos que todas las variables habían de ser inicializadas antes de poder utilizar su nombre. Por eso, justo antes de entrar en el bucle while nos encontramos la línea

mayor = 0

en la que inicializamos la variable mayor con el valor 0.

Si no hubiéramos hecho esto, el programa habría devuelto un error, al encontrar, dentro del bucle, una variable sin inicializar.

El bucle se repetirá una y otra vez hasta que introduzcamos un cero, valor que hemos elegido como centinela y que disparará la sentencia break.

Una vez hemos salido del bucle, se ejecuta la última instrucción del programa, que imprime el resultado buscado:

print('El número más alto introducido es ', mayor)

Almacena estas técnicas elementales en tu repertorio y no olvides la sentencia break, no sea que en tu radio un día suene la misma canción cada mañana a la misma hora.

Javier Montero Gabarró


Fecha de la última revisión: 29 de mayo de 2013


http://elclubdelautodidacta.es/wp/2011/07/python-capitulo-9-atrapado-en-el-dia-de-la-marmota/


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


Consulta el índice completo de artículos relacionados con Python.