LaTeX – Capítulo 15: Familias de fuentes genéricas

LaTeX nos permite trabajar con tres familias de fuentes genéricas:

– Con serifas (romanas)
– Sin serifas (sans serif)
– Espaciado fijo (tipo máquina de escribir)

Vamos a explicar un poco en qué consisten.

¿Qué son las serifas?

Las serifas son esos apéndices decorativos que rematan la escritura de cada letra. Las tienes en todas partes, obsérvalas. No hace falta que vayas muy lejos: este mismo blog usa una fuente con serifas para el texto principal.

Las serifas mejoran la legibilidad sobre el papel y sobre pantallas con buena resolución, pues ayudan a guiar la vista a través del texto.

A las fuentes que utilizan serifas también se las conoce como romanas.

I shot the serif

Por el contrario, un tipo de letra sin serifas carece de esa decoración extra y presenta un aspecto más sobrio. Las fuentes sin serifas suelen emplearse para enfatizar texto, como contraste a un tipo con serifas. Quedan muy bien para la escritura de títulos. Son muy útiles, además, para la lectura de texto en pantallas con baja resolución: la pixelación estropea las serifas.

Escritura a máquina

Las fuentes de espaciado fijo tienen la característica, como su nombre indica, de que todas las letras ocupan el mismo tamaño total, tal como hace una máquina de escribir. Los programadores las emplean mucho para escribir código, pues el código fuente suelen presentar muchas indentaciones y les gusta que todo caiga en su sitio y el programa quede legible.

Computer Modern, ¡esto es LaTeX!

LaTeX tiene una familia de fuentes por defecto para cada uno de estos tres tipos:

– Computer Modern Roman (con serifas)
– Computer Modern Sans Serif (sin serifas)
– Computer Modern Typewriter (espaciado fijo)

Ya te has dado cuenta de que, por defecto, LaTeX no utiliza Times, sino Computer Modern, una familia de fuentes que, además, posee variantes para los tres tipos.

Puedes cambiar el tipo base por defecto, si lo deseas. Deberás facilitar una familia adecuada para cada uno de los tres tipos, o elegir un paquete adecuado que lo gestione por ti. Hablaremos de todo esto a su momento en otro artículo.

Por el momento quédate con la idea de que dispones de tres familias básicas que puedes emplear para enfatizar.

¿Recuerdas que podías enfatizar empleando comandos o mediante declaraciones? Revisa los últimos capítulos si se te ha olvidado.

Los comandos

Los comandos para cambiar la familia de la fuente son:

\textrm (fuente romana, con serifas)
\textsf (fuente sin serifas)
\texttt (fuente de espaciado fijo)

Recuerda que cuando utilizabas comandos, el texto afectado se facilitaba como parámetro entre las llaves. Por ejemplo:

\textsf{La casa de la pradera}

escribiría la frase sin serifas.

Las declaraciones

Las declaraciones eran comandos que actuaban como conmutadores. A partir de ellas se activaba un determinado modo de funcionamiento que desaparecía cuando finalizaba el ámbito de actuación u otra declaración activaba un modo diferente incompatible con el anterior.

Las declaraciones para cambiar la familia de la fuente son:

\rmfamily (fuente romana, con serifas)
\sffamily (fuente sin serifas)
\ttfamily (fuente de espaciado fijo)

Seguro que sabes lo que haría el siguiente ejemplo:

\sffamily Y con esto y un bizcocho, \rmfamily hasta mañana a las \ttfamily ocho...

Javier Montero


LaTeX – Capítulo 15: Familias de fuentes genéricas


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

Detección y eliminación de virus con Knoppix

Knoppix es mi navaja suiza en versión software. Siempre suelo llevarlo conmigo por lo que pudiera suceder. En el espacio de un CD tengo a mi alcance un sistema Linux con centenares de herramientas de todo tipo listas para ser ejecutadas en cualquier ordenador sin necesidad de instalar nada en él.

Imagina que un día te llama un amigo con un problema gordo. Esto es algo inevitable para los que nos dedicamos a esto: los amigos se acuerdan de nosotros en estos casos. En fin, ¿para qué estamos si no?

Resulta que tu amigo tiene el ordenador infectado con un virus y no tiene manera de limpiarlo. Un virus activo en memoria puede engañar a un antivirus e incluso evitar que este funcione.

Después de recriminarle por su torpeza, cogemos Knoppix y nos dirigimos a su casa.

Knoppix incluye el antivirus ClamAV entre su conjunto de herramientas fabulosas. Antiguamente lo encontrábamos en la distribución en CD. En las últimas versiones sólo está disponible en el DVD.

En el momento de escribir este artículo la última versión de Knoppix es la 6.7.1.

Arrancamos el ordenador de nuestro amigo con el DVD de Knoppix dentro. El Windows que reside dentro del PC permanecerá dormido, sin arrancar, sin darse cuenta de lo que está sucediendo.

Esta es la gran ventaja de esto: el disco duro del ordenador está «frío». No arrancamos Windows, no hay programas ni procesos suyos cargados. El virus, por lo tanto, también duerme plácidamente dentro de uno o varios ficheros.

Es como visitar a los vampiros en sus tumbas durante el día…

Arrancamos Knoppix directamente en idioma español y en la línea de comandos. No necesitaremos la interfaz gráfica para nada.

Ya sabemos, por artículos anteriores, como hacer esto. En el prompt de Knoppix escribimos:

knoppix 2 lang=es

Una vez arrancado Knoppix lo primero que debemos hacer es montar el disco duro que queremos analizar. Recuerda que, por defecto, el punto de montaje ya está creado en /media con el nombre de las particiones que Knoppix detecta al arrancar.

Veamos qué particiones tenemos a nuestro alcance:

fdisk -l

En el caso del PC de nuestro amigo, este comando nos devuelve la partición /dev/sda1. Es la que debemos montar:

mount /dev/sda1 /media/sda1

Con esto, ya tenemos el disco infectado al alcance de Knoppix dentro de la carpeta especificada.

Quizás te entre una duda ahora: la versión de Knoppix que tenemos puede que tenga varios meses de antigüedad. ¿Qué pasa con los virus nuevos desde esa fecha? ¿No los va a detectar?

Tranquilo; antes de escanear el disco vamos a actualizar el fichero de firmas del antivirus a la más reciente.

Basta con lanzar el siguiente comando:

freshclam

Naturalmente, la máquina debe estar conectada a una red desde la que acceder a internet. Nuestro amigo tiene el PC conectado a un router del que recibe directamente, mediante DHCP, una dirección IP. No ha hecho falta configurar nada, Knoppix, en la mayoría de los casos, se encarga completamente de todo sin necesidad de nuestra intervención. Si debes configurar una IP fija o tienes que conectarte a una Wi-Fi, tendrás que entretenerte un poco para dejar la red en condiciones.

En unos segundos ClamAV estará actualizado con la base de datos de virus más reciente.

Si llevas tiempo ya trabajando con Knoppix, esto que voy a decir te resultará obvio. Si no es así, debes saber que esta base de datos está en unos ficheros que están completamente en memoria. Knoppix es un Live CD y, por lo tanto, no escribe nada en ningún disco del sistema (salvo que así se lo indiquemos, tal y como vamos a hacer ahora limpiando la máquina). Cuando abandones Knoppix, se acabó también esa actualización. Si vuelves a arrancar tendrás que actualizar nuevamente el fichero de firmas.

Y ahora, a cargarnos el virus.

Podemos hacerlo de dos modos: escaneamos el disco, leemos el informe con el resultado, y eliminamos, con el comando rm de Unix, uno a uno, cada fichero infectado por el virus. O también podemos introducir, en el comando, una opción para que los elimine directamente.

Recomiendo la primera vía. Es más prudente que revisemos previamente el informe y después tomemos la decisión de si eliminar el fichero o no. No siempre los antivirus aciertan.

El comando es el siguiente:

clamscan -ir /media/sda1 > resultado

El parámetro -i indica que sólo me muestre resultados de ficheros infectados y obvie los que están sanos. El parámetro -r se utiliza para que la búsqueda se realice en el interior de todos los directorios recursivamente.

Observa como hemos redirigido la salida a un fichero de texto que hemos llamado resultado, que es el que deberemos consultar después para conocer el resultado del escaneo. Lo encontrarás en el mismo directorio en el que lanzas el comando.

Si no quieres molestarte en tomar decisiones de si borrar o no, puedes dejar que lo haga directamente clam con el parámetro remove:

clamscan -ir --remove /media/sda1 > resultado

Sales de Knoppix, guardas de nuevo tu DVD mágico en el bolso y dejas que tu amigo siga disfrutando de su Windows.

¿Qué menos que te invite a unas cervezas después, no?

Javier Montero


Anotación del 3 de abril de 2012: si ha pasado un tiempo desde que descasgaste tu último Knoppix, puede que te encuentres que el motor del antivirus esté desactualizado. Léete este artículo para saber cómo proceder en ese caso.


Detección y eliminación de virus con Knoppix


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

Python – Capítulo 25: Pasando argumentos a las funciones

En el capítulo anterior nos aproximamos al mundo de las funciones y comenzamos por el ejemplo más básico: una función sin argumentos que se limitaba a ejecutar un conjunto de instrucciones.

En el artículo de hoy aprenderemos a facilitar argumentos, que serán utilizados como variables dentro del cuerpo de la función.

Vayamos con el primer ejemplo básico. Arranca el intérprete interactivo y prepárate a introducir algo de código. Me gusta el intérprete interactivo para ilustrar los conceptos simples, sin necesidad de desarrollar un programa completo. Esa es la metodología de esta serie de artículos: los conceptos se explican en el contexto más simple posible. Esa «molecularidad» de la información facilita el aprendizaje. En capítulos posteriores trabajaremos con programas completos y algoritmos que requerirán el despliegue de muchas de estas piezas que ahora aprendemos de forma individual.

Introduce en el intérprete interactivo las dos líneas siguientes:

>>> def megustapython(veces):
  print('Aprender a programar en Python es divertidísimo\n'*veces)

Fíjate cómo, después de introducir la primera y pulsar Enter, automáticamente el cursor aparece indentado, preparado para la introducción del bloque de instrucciones.

Una vez incluida la segunda línea, pulsa Enter dos veces para finalizar la edición de la función y regresar al prompt.

¿Qué hace esta función?

Va a imprimir la línea Aprender a programar en Python es divertidísimo tantas veces como indique la variable veces que facilitamos como argumento.

Observa como el argumento se incluye dentro de los paréntesis en la primera línea de la definición de la función.

El código de impresión no debe suponerte ningún misterio. He vuelto a usar el truco que vimos en el capítulo anterior: multiplicar una cadena de caracteres por un número entero hace que la cadena se repita ese número de veces. Al final del string (usaré indistintamente este término o «cadena de caracteres») he incluido el carácter de escape \n, que ya sabes que introduce un salto de línea.

Vamos a invocar a la función. Por ejemplo:

>>> megustapython(5)
Aprender a programar en Python es divertidísimo
Aprender a programar en Python es divertidísimo
Aprender a programar en Python es divertidísimo
Aprender a programar en Python es divertidísimo
Aprender a programar en Python es divertidísimo

En esta invocación, la variable veces toma el valor 5. Como resultado, la línea de texto se «multiplica» por 5 y aparece 5 veces en la pantalla.

Las funciones pueden admitir más de un argumento y de cualquier tipo, no sólo numérico.

Volvamos a la función praderazo() del capítulo anterior:

def praderazo():
    print('+'*42)
    print('+ La casa de la pradera, pedazo serie... +')
    print('+'*42)

Esta función imprime el texto La casa de la pradera, pedazo de serie…, enmarcado con símbolos de suma.

Vamos a modificarlo para que repita esa frase tantas veces como deseemos y, además, para que podamos elegir el símbolo que emplearemos como marco.

Facilitaremos dos argumentos a la función: veces y simbolo, que contendrán, como su nombre indica, el número de veces a repetir y el símbolo utilizado en el marco.

def praderazo(veces,simbolo):
    print(simbolo*42)
    for n in range(veces):
      print(simbolo,'La casa de la pradera, pedazo serie...',simbolo)
    print(simbolo*42)

Voy a explicar algunas particularidades del código:

La primera línea del cuerpo debe estar clara: imprime 42 veces el símbolo facilitado como parámetro.

Comenzamos a continuación un bucle for que se repetirá tantas veces como hemos indicado en la variable veces. Si no recuerdas el uso de la función range(), puedes revisar el capítulo 20.

En la línea del print se escribe el símbolo, contenido en la variable del mismo nombre que hemos facilitado como argumento, seguido de la frase y cerrando nuevamente con el símbolo. Cuando concatenamos las cadenas separándolas entre comas en print(), Python inserta automáticamente un espacio en blanco entre ellas.

Cerramos el marco, finalmente, imprimiendo nuevamente 42 veces el símbolo.

Invoquemos al genio de la lámpara:

>>>praderazo(5,'?')
??????????????????????????????????????????
? La casa de la pradera, pedazo serie... ?
? La casa de la pradera, pedazo serie... ?
? La casa de la pradera, pedazo serie... ?
? La casa de la pradera, pedazo serie... ?
? La casa de la pradera, pedazo serie... ?
??????????????????????????????????????????

Son ejemplos muy básicos, pero seguro que ya intuyes la tremenda potencia de las funciones…

Javier Montero


Python – Capítulo 25: Pasando argumentos a las funciones


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

Listas anidadas en HTML – 2 de 2

En la primera parte de este artículo combinamos los conocimientos que ya habíamos adquirido sobre las listas para ilustrar el modo de anidarlas.

Lo primero que te propongo es que realices un ejercicio práctico. Observa la siguiente página cuidadósamente y trata de reproducir el código necesario para generarla.

No te dejes intimidar por la profundidad de la lista (hasta cuatro niveles). Recuerda que debes aproximarte de fuera a dentro, comenzando por la más exterior.

Te recomiendo que cada vez que abras una etiqueta la cierres para crearte un contenedor y asegurarte de que no se te olvida por accidente su cierre. Luego prosigue rellenando los espacios entre etiquetas.

Si tienes algún problema, haz clic sobre el enlace con el botón derecho y descárgate el fichero con el código fuente para consultar la solución.

Quiero que te fijes ahora en las listas del ejemplo. Observa que las listas ordenadas anidadas muestran una numeración ascendente con números normales (arábigos) independientemente del nivel en que se encuentren. En cambio, las listas no ordenadas presentan un bolo que dependerá precisamente del nivel de profundidad.

Observa ahora el siguiente ejemplo, en el que he alterado precisamente estos indicadores por defecto, tanto en las listas ordenadas como en las que no lo están.

Fíjate cómo, en las listas ordenadas, además de usar números arábigos para expresar el orden, podemos hacerlo de los siguientes modos:

– Letras mayúsculas
– Letras minúsculas
– Números romanos en mayúsculas
– Números romanos en minúsculas.

Además, disponemos de distintos símbolos para las listas no ordenadas.

Voy a enseñarte cómo hacer esto, pero antes tengo que contarte algo importante relacionado con el modo en que fue evolucionando el lenguaje HTML desde su creación.

En un principio el HTML era caótico. No sé si recordáis la guerra cruenta entre navegadores (sobre todo entre Netscape Navigator y Microsoft Internet Explorer) en la que cada uno añadía nuevas funcionalidades al lenguaje que dificultaban los esfuerzos de estandarización y compatibilidad.

El W3C intentó poner un poco de orden en esta situación y apostó por una versión más estricta del lenguaje inspirada en los rigores de XML, que denominó XHTML.

Además de unas normas sintácticas más severas (como la escritura de las etiquetas en mayúsculas y la necesidad de cerrarlas), introdujo un concepto decisivo: la separación entre contenido y diseño.

Tras la guerra entre navegadores nos encontramos con un buen número de etiquetas y atributos que indicaban cómo se diseñaba el texto: qué tipo de letra, tamaño, color, márgenes, etc…

Con XHTML se desligó la función semántica del lenguaje (dime qué quieres hacer) de los detalles de presentación (cómo quieres verlo). Para eso recurrió a un artilugio denominado hojas de estilo, las cuales se ocupaban de todos los aspectos concretos de visualización.

Como consecuencia XHTML realizó una purga y nombró como obsoletas aquellas etiquetas o atributos que se ocupaban de cuestiones de diseño, pues entendía que todo eso era función de las hojas de estilo. Un ejemplo, entre muchos, es la etiqueta <font>, que se ocupaba de definir el tipo de letra a utilizar.

¿Qué tiene que ver todo esto con las listas anidadas, preguntarás?

Pues bien, antes de que llegase el XHTML escricto, existía un atributo en las etiquetas <ol> y <ul> que permitía definir el tipo de numeración o bolo si no queríamos utilizar los que el navegador proponía por defecto.

XHTML estricto considera que esos atributos están obsoletos, pues insiste en que todos los aspectos de diseño deben realizarse a través de las hojas de estilo.

Pero, a pesar de que estén obsoletos, aún siguen estando activos y te explicaré cómo hacerlo a la antigua usanza hasta que empecemos los artículos de CSS (Cascading Style Sheets), las hojas de estilo con las que resolveremos todas las consideraciones de presentación y diseño de HTML.

¿Recuerdas qué era la famosa etiqueta DOCTYPE que aparece al comienzo de cada página? Compara la del primer ejemplo con la del segundo. Se trata de una DTD (definición de tipo de documento) que indica al navegador, último responsable de la presentación de la página, a qué conjunto de normas se adhiere la página.

El primer ejemplo está usando XHTML estricto con todo lo que eso implica, entre lo que está no usar ni etiquetas ni atributos obsoletos (deprecated).

El segundo usa una versión más relajada denominada Transitional, que en su día se empleó para dar tiempo a los navegadores a que poco a poco fueran migrando a XHTML puro. El XHTML transicional tiene el rigor sintáctico del XHTML, como el cierre de todas las etiquetas y su escritura en minúsculas, pero permite el uso de estas etiquetas obsoletas.

Como he querido usar atributos obsoletos para especificar cómo numeraré las listas ordenadas y qué bolos emplearé en las no ordenadas, en vez de emplear hojas de estilo CSS, he cambiado la DTD del segundo ejemplo a XHTML transicional. Fíjate bien en la primera línea.

Si no lo hubiese puesto podría obtener resultados imprevisibles según el navegador empleado.

Por lo general trabajaremos con XHTML estricto o con HTML5 (la nueva gran revolución) en esta serie, pero resulta interesante también conocer el modo clásico de proceder.

Observa el código fuente del segundo ejemplo y se desvelará el misterio. Con el atributo type dentro de las etiquetas <ol> y <ul> indicamos cómo será la numeración o el bolo:

– orden con letras mayúsculas: type=»A»
– con letras minúsculas: type=»a»
– con números romanos en mayúsculas: type=»I»
– con números romanos en minúsculas: type=»i»
– y, naturalmente, con números arábigos, type=»1″, que no es necesario indicar, pues es el valor por defecto.

Por ejemplo, para una numeración por letras minúsculas, la etiqueta sería:

<ol type="a"> ... </ol>

Con las listas no ordenadas tenemos las siguientes opciones:

– bolo cuadrado: type=»square»
– bolo con punto negro: type=»disc»
– bolo con punto en blanco: type=»circle»

Por ejemplo:

<ul type="disc"> ... </ul>

Es interesante que aprendas esto. Pero pronto te haré desaprenderlo cuando nos metamos en profundidad en el apasionante mundo de las CSS.

Javier Montero


Listas anidadas en HTML – 2 de 2


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

mIRC – Capítulo 15: Mensaje en una botella

En el capítulo 10 de esta serie expliqué cómo utilizar el comando /query para mantener conversaciones privadas. Voy a presentar en este artículo el comando /msg, más general que el anterior y que, entre otras cosas, también puede utilizarse para lo mismo.

Supongamos que el usuario plutonio quiere iniciar una conversación privada con sostenuto. Puede realizar esto de varias maneras empleando comandos:

/query sostenuto ¿Qué tal estás?

/msg sostenuto ¿Qué tal estás?

En ambos casos, sostenuto se da cuenta de que alguien le ha enviado un mensaje, pues lo puede ver tanto en la Switchbar como en la Treebar.

La Switchbar está en la parte superior, justo debajo de la barra de herramientas. Con ella podemos conmutar fácilmente entre todas las ventanas que tengamos abiertas. La Treebar es la barra de navegación que aparece a la izquierda. Ambas pueden ser activadas o desactivadas a través del menú View.

La diferencia entre /query y /msg es que el primero hace que a plutonio, que es quien inicia la conversación, se le abra ya directamente la ventana de chat y se le muestre en primer plano. Es decir, se supone que va a seguir hablando a través de ella. Con /msg esto no sucede: el mensaje se envía a su destino, pero todo lo que plutonio ve es, en la ventana de Status:

*sostenuto* ¿Qué tal estás?

indicando que ese texto ha sido enviado con éxito a sostenuto.

Sólo después de que sostenuto le conteste (si quiere) le aparecerían las señales en la Switchbar y en la Treebar que le permitirían abrir la ventana de la conversación.

El comando /msg tiene otro uso importante, y es que, además de enviar mensajes a usuarios puede enviarlos también a un canal.

Observa a sostenuto mosqueado porque está hablando plutonio en el canal sin ser miembro de él:

Fíjate en la lista de miembros del canal: plutonio no está en ella y, sin embargo, está escribiendo allí.

Para hacer esto, plutonio recurre nuevamente al comando /msg, pero esta vez dirigido contra el canal en vez de contra el usuario:

/msg #probilandia Muy buenas...
/msg #probilandia Soy el fantasma del IRC

El no ve lo que sucede en el canal, obviamente, pues no está en él. Todo lo que tiene son las trazas en la ventana de Status indicando que el comando ha sido realizado con éxito:

*#probilandia* Muy buenas...
*#probilandia* Soy el fantasma del IRC

Que alguien pueda a enviar mensajes desde el exterior a un canal puede llegar a ser un auténtico engorro, pues esa persona no está participando en la conversación. Imagínate, por ejemplo, que se dedica a lanzar mensajes de spam.

¿No hay nada que pueda hacer el operator para evitar que esto suceda en su canal?

Afortunadamente, sostenuto se ha leido este artículo y ejecuta el siguiente comando:

/mode #probilandia +n

¡Otro de los modos del canal! Recuerda la entrega anterior, allí expliqué cómo usar el modificador +t para que sólo los operators de un canal pudieran modificar el topic.

El modificador +n evita la recepción de mensajes externos al canal. Si quisiéramos desactivar esta protección utilizaríamos el mismo comando, pero con el modificador -n.

Si quieres, puedes entrar en Channel Central haciendo doble clic sobre un punto del área de chat y ver cómo el nuevo modo ha sido activado:

En un mismo comando se pueden activar varios modos al mismo tiempo. Así pues, si queremos evitar la recepción de mensajes externos y, a su vez, impedir la modificación del topic, podemos lanzar el siguiente comando:

/mode #probilandia +nt

Una vez hemos activado el modificador +n, el chasco que se lleva plutonio es tremendo. Si ahora hace

/msg #probilandia Voy a seguir incordiando un rato

se queda frustrado, pues recibe, en su ventana de Status, la siguiente traza:

#probilandia Cannot send to channel - No se puede enviar texto al canal

Su gozo en un pozo.

/msg #lectores_del_blog Hasta la próxima amigos...

Javier Montero


mIRC – Capítulo 15: Mensaje en una botella


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

Python – Capítulo 24: Introducción a las funciones

Ha llegado el momento de dar una primera capa a las funciones, concepto clave sobre el que se asienta la modularidad de cualquier lenguaje de programación.

Las funciones nos permiten reutilizar código. Por ejemplo, suponte que tienes que calcular la media aritmética de un conjunto de números. Ya sabes que la media es igual a lo que suman estos números dividido entre el total de estos.

Podrías escribir una expresión numérica que realizase este cálculo. Es posible, incluso, que tuvieras que gestionar un bucle si no conoces de antemano el número de elementos.

En cualquier caso, es un problema sencillo. Pero, ¿y si tuvieras que realizar la operación más veces con diversos conjuntos de números? ¿Volverías a copiar y pegar todo el código cada vez que necesitaras repetir el cálculo?

Gracias a las funciones es suficiente con que escribas el código una única vez. Cada vez que necesites calcular tu media aritmética bastará con que invoques a la función facilitándole, en cada ocasión, como argumentos, el conjunto de números sobre el que efectuarás la operación.

Python trae consigo una biblioteca repleta de funciones predefinidas que ya están inmediatamente a tu disposición. Ya conoces algunas de ellas.

Por ejemplo, la función print() toma como argumento una cadena de texto y realiza una tarea muy concreta: mostrarla en pantalla.

>>> print('Esta es la función print')
Esta es la función print

¿Y qué me dices de la función len(), que nos devolvía la longitud de una cadena de texto?

Fíjate en que he empleado el verbo devolver. La función len() es un ejemplo de función que nos devuelve un valor numérico. Como devuelve un valor, la función puede formar parte de una expresión numérica:

>>> longitud = len('Devuelve la longitud de esta cadena')
>>> longitud
35

A lo largo de esta serie de artículos te mostraré muchas funciones de la biblioteca de Python con las que irás aumentando tu repertorio de recursos, pero ahora de lo que se trata es que aprendas a crear las tuyas propias.

Y vamos a empezar por lo más básico: una simple función que realice una acción determinada. No admitirá parámetros ni devolverá valor alguno; simplemente realizará una acción concreta.

Veamos su definición en el siguiente fragmento de código:

def praderazo():
    print('+'*42)
    print('+ La casa de la pradera, pedazo serie... +')
    print('+'*42)

Lo primero que debes observar es que para definir una función empleamos la palabra reservada def. No podría ser otra, claro…

A continuación de def figura el nombre que le damos a la función. Los distintos argumentos que aceptaría se incluirían entre los paréntesis. En el ejemplo, la función praderazo() no acepta argumentos, por lo que los paréntesis están vaciós (pero deben figurar, aunque no contengan nada).

Tras los paréntesis tenemos los dos puntos que ya hemos visto en las estructuras de control if, while y for. Nos indican que lo que viene a continuación es el cuerpo de la función, su contenido propiamente dicho.

Todo el bloque de instrucciones que la función ejecuta aparece indentado. Como ya sabes, esta es la forma en la que Python reconoce que es un bloque y sabe dónde termina.

La función praderazo() ejecuta tres sentencias. La primera la he puesto para ilustrar una técnica curiosa de Python:

print('+'*42) provoca que se imprima en pantalla 42 veces el símbolo +. Observa qué uso tan interesante.

Es importante entender que el código de la función aún no produciría ninguna salida. Para que esto suceda, hay que invocarla, como si del genio de la lámpara se tratara.

La invoco con su nombre (y los argumentos si los hubiera, pero aquí no es el caso):

praderazo()

Esto provocaría la siguiente salida en pantalla:

++++++++++++++++++++++++++++++++++++++++++
+ La casa de la pradera, pedazo serie... +
++++++++++++++++++++++++++++++++++++++++++

Una regla importante de Python es que el código de definición de la función debe preceder al de la invocación. Es decir, nunca llames a una función que no haya sido definida previamente.

Ahora, en el programa, podrás invocar a la función cuantas veces desees. Cada vez que lo hagas se producirá la misma salida.

Quédate con esto por hoy. Ya sabes lo que es una función y este ejemplo te ha permitido conocer su sintaxis básica. En las próximas entregas seguiremos abundando en esto y empezaremos a jugar con argumentos.

praderazo()

++++++++++++++++++++++++++++++++++++++++++
+ La casa de la pradera, pedazo serie... +
++++++++++++++++++++++++++++++++++++++++++

Javier Montero


http://elclubdelautodidacta.es/wp/2011/11/python-capitulo-24-introduccion-a-las-funciones/


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

Meta-artículos

Intercalaré, de cuando en cuando, meta-artículos explicando qué se trama entre bastidores. No son artículos propiamente dichos, en comparación a los demas textos del blog, sino artículos sobre los artículos, es decir, una serie de noticias breves centradas en el propio blog en sí más que en ninguna temática en concreto.

Están confeccionados utilizando una plantilla diferente al resto. En la página de inicio aparecen sin título y con un tamaño de fuente más pequeño.

En la barra lateral se puede acceder a un historial de los más recientes a través de la sección «Noticias breves».

Javier Montero

MuseScore #13: Tresillos para el salón

No, no hablaremos aquí de mobiliario, descuida.

Continuando con los conceptos básicos de introducción de notas, ha llegado el momento de aprender a escribir tresillos.

Me viene a la cabeza, por ejemplo, esta melodía:

Se trata del comienzo de The fool on the hill (el tonto de la colina), el famoso tema de The Beatles, en Do mayor.

El tresillo de corcheas del primer compás es muy fácil de escribir, como verás a continuación.

Lo primero que debes preguntarte es cuál es la duración del tresillo completo. Puesto que, en el ejemplo, estamos ante un tresillo de corcheas, su duración real es dos veces este valor, es decir una negra.

A continuación, selecciona en la barra de introducción de notas esta figura, la negra (o bien, como ya sabes, pulsa la tecla 5). Asegúrate de que está activado el modo de introducción y no el de selección (la letra N de la barra debe aparecer «pulsada»).

Una vez seleccionada la figura correspondiente a la duración total del tresillo, desplegamos el menú Notas | Grupos irregulares y elegimos el Tresillo. Fíjate que aparece también el atajo de teclado para realizar esto mismo, que es Control – 3.

Esto provoca que nos aparezca ya el esqueleto del tresillo, pero en silencios. Tan sólo falta que lo sobreescribamos con las notas adecuadas. Observa que en la barra se ha seleccionado ya automáticamente la figura de corchea. Si fuera necesario, podríamos cambiar ese valor (por ejemplo, para escribir un tresillo que agrupase una negra con una corchea).

En modo selección el funcionamiento es algo diferente. En este caso, al pulsar Ctrl – 3 se creará el tresillo, pero fragmentando la nota sobre la que está la selección. Por ejemplo, si tenemos seleccionada una nota blanca, se nos creará un tresillo de negras en su lugar. La primera nota del tresillo mantendrá la misma altura; las dos restantes serán silencios que podremos sobreescribir.

Sencillo el tresillo, ¿no?

Day after day, como diría el tresillo de la canción, vamos desentrañando MuseScore. Hasta la próxima.

Javier Montero


MuseScore #13: Tresillos para el salón


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

Listas anidadas en HTML – 1 de 2

En los últimos artículos de esta serie mostramos los tres tipos básicos de listas en HTML: ordenadas, no ordenadas y de defición. Comprendidos estos conceptos, anidar listas será una tarea realmente sencilla.

Comencemos observando el aspecto de una lista anidada.

Date cuenta de que, en un primer nivel, nos encontramos con una lista ordenada. En un segundo aparecen distintas listas no ordenadas.

Veamos cómo diseñar el conjunto.

La forma de atacar una anidación de listas es partiendo desde fuera hacia dentro. Comenzamos esquematizando el primer nivel y a él le añadimos las listas de segundo nivel.

Antes de la lista ordenada de primer nivel nos encontramos con un simple encabezado que sirve de título:

<h2>Menú</h2>

Y comienza la fiesta:

Vamos a crear la estructura de la lista ordenada exterior, pero sin rellenar los campos con los distintos elementos. Esto ayudará a que no nos perdamos en las marañas.

<ol>
    <li>...</li>
    <li>...</li>
    <li>...</li>
</ol>

Se trata de una lista con tres elementos.

Como si de un vídeo de cocina se tratase, vamos preparando las listas no ordenadas de segundo nivel para cuando llegue el momento de agregarlas al sofrito:

Esta vez la detallaremos completas, pues no hay ningún nivel inferior:

La primera:

<ul>
    <li>Macarrones</li>
    <li>Gazpacho</li>
    <li>Judías pintas</li>
</ul

Esto no tiene ningún misterio: una simple lista sin ordenar con tres elementos.

La segunda:

<ul>
    <li>Pollo al ajillo</li>
    <li>Merluza frita</li>
</ul>

Y, finalmente, la última:

<ul>
    <li>Fruta</li>
    <li>Yogur</li>
    <li>Café</li>
</ul>

Hasta aquí todo es muy sencillo. Presta atención ahora, pues llega el momento crítico.

Vamos a analizar ahora los distintos elementos que componen la lista numerada de primer nivel.

Fíjate en el primer elemento (échale un vistazo nuevamente al fichero de ejemplo) y trata de responder a la siguiente pregunta:

¿De qué está compuesto el primer elemento?

La respuesta debe llegarte de un modo inmediato si comprendes que el primer elemento se compone de todo lo que hay entre el número 1 y el número 2.

Es decir, nos encontramos, en primer lugar, con un encabezado:

<h3>Primer plato</h3>

Puesto que para el título empleamos un h2, parece lógico utilizar aquí otro de menor jerarquía como un h3.

Después del encabezado, nos aparece la primera de las listas no ordenadas de segundo nivel que ya cocinamos hace un rato:

<ul>
    <li>Macarrones</li>
    <li>Gazpacho</li>
    <li>Judías pintas</li>
</ul

Por lo tanto, el primer elemento de la lista de primer nivel es, completo:

<h3>Primer plato</h3>
<ul>
    <li>Macarrones</li>
    <li>Gazpacho</li>
    <li>Judías pintas</li>
</ul>

Razonando del mismo modo, el segundo elemento de la lista de primer nivel se compone de todo lo que hay entre el 2 y el 3. Es decir:

<h3>Segundo plato</h3>
<ul>
    <li>Pollo al ajillo</li>
    <li>Merluza frita</li>
</ul>

Finalmente, el tercer elemento es:

<h3>Postre</h3>
<ul>
    <li>Fruta</li>
    <li>Yogur</li>
    <li>Café</li>
</ul>

Ya sólo falta el toque final. Volvemos al esqueleto de la lista de primer nivel y entre cada <li>…</li> insertamos cada una de las piezas.

He aquí nuestro resultado final:

<h2>Menú</h2>
<ol>
    <li>
        <h3>Primer plato</h3>
        <ul>
            <li>Macarrones</li>
            <li>Gazpacho</li>
            <li>Judías pintas</li>
       </ul>
    </li>
    <li>
        <h3>Segundo plato</h3>
        <ul>
        <li>Pollo al ajillo</li>
        <li>Merluza frita</li>
        </ul>
    </li>
    <li>
        <h3>Postre</h3>
        <ul>
            <li>Fruta</li>
            <li>Yogur</li>
            <li>Café</li>
        </ul>
    </li>
</ol>

Ya sabes que la indentación no es necesaria, pero ayuda a esclarecer la estructura del código.

Descárgate el código fuente haciendo clic con el botón derecho sobre el enlace del comienzo del artículo si quieres ver fichero el fichero completo.

Cuando hayas practicado esto un par de veces podrás escribir directamente el código con agilidad. Tómate, entre tanto, el tiempo que haga falta desglosando cada lista de fuera a dentro, tal como hemos hecho aquí.

En el próximo artículo presentaré un nuevo ejemplo, esta vez anidando listas ordenadas entre sí. Veremos las particularidades que tienen este tipo de estructuras.

Javier Montero


Artículos relacionados:

Creación de listas ordenadas en HTML
Listas no ordenadas en HTML
Listas de definición en HTML


Listas anidadas en HTML – 1 de 2


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

BitBite English #27: as like as two peas

It’s been two months since our last BitBite. I hope it’s here to stay with us again.

La palabra inglesa like es, sin duda, gran conocida de todos. La usamos típicamente como verbo:

I don’t like mondays

o como preposición:

Fly like a bird

Su uso como adjetivo es algo más avanzado y es nuestro tema de hoy.

like; similar, parecido

El contrario es unlike; distinto, diferente

La frase del título ilustra este uso:

They are as like as two peas; son como dos gotas de agua

La traducción literal es son tan PARECIDOS como dos guisantes.

También dice as like as two peas in a pod. Pod es la vaina que recubre los guisantes.

Remember the good old school days when you studied Physics:

Like charges repel each other; unlike charges attract each other.

Las cargas del mismo signo se repelen, las de distinto se atraen.

¿Cómo no?

Javier Montero


http://elclubdelautodidacta.es/wp/2011/11/bitbite-english-27-as-like-as-two-peas/


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

Uso de cookies

Este sitio web utiliza cookies para que usted tenga la mejor experiencia de usuario. Si continúa navegando está dando su consentimiento para la aceptación de las mencionadas cookies y la aceptación de nuestra política de cookies, pinche el enlace para mayor información.plugin cookies

ACEPTAR
Aviso de cookies