Llegó la hora de Precise Pangolin, Ubuntu 12.04 LTS

Después de unos cuantos días en la cuenta atrás, ya está disponible, al fin, la nueva versión Long Term Support de Ubuntu, Precise Pangolin, Ubuntu 12.04.

Si ya eres usuario de Ubuntu 11.10, no necesitas reinstalar el sistema operativo para disponer de la última versión. La forma más sencilla de actualizarte es directamente desde el Gestor de Actualizaciones. Además de las actualizaciones típicas para instalar encontrarás un nuevo botón que te permitirá hacer un upgrade a la versión 12.04.

Eso sí, tendrás que tener un poco de paciencia, pues deberán descargarse de la red más de mil nuevos paquetes. El proceso de instalación se ocupará de eliminar también todos los paquetes obsoletos.

He incluido este artículo, además, en las categorías MuseScore, Python y MySQL, pues la instalación de Ubuntu 12.04 actualiza las versiones de estos programas respecto a las que estaban disponibles en el Centro de Software de Ubuntu durante la versión 11.10. Hace poco escribí en el blog cómo instalar estas aplicaciones en Ubuntu; ha llegado el momento de actualizarlas.

Concretamente, las nuevas versiones que se instalan son:

– MuseScore 1.2
– MySQL server 5.5.22
– Python 3.2.3

Si estás siguiendo alguna de estas series desde Ubuntu mi consejo es que te actualices haciendo un upgrade a Precise Pangolin cuanto antes (si aún no lo has hecho).

Las versiones LTS (Long Term Support) de Ubuntu están pensadas para todos aquellos que no deseen actualizar sus sistemas operativos cada seis meses, que es el ciclo habitual en el que Canonical publica nuevas versiones. Aparece una nueva versión LTS cada dos años y desde Precise Pangolin el soporte se ha extendido hasta 5 años (tanto en la versión Desktop como en la Server).

Apenas me ha dado tiempo a descubrir los nuevos cambios, como el tan esperado HUD, pues tengo el sistema recién instalado.

Promete ser una experiencia apasionante…

Javier Montero Gabarró


http://elclubdelautodidacta.es/wp/2012/04/llego-la-hora-de-precise-pangolin-ubuntu-12-04-lts/


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 32: Funciones que devuelven varios valores

Python es un lenguaje, cuanto menos, curioso. Acostumbrado a otros lenguajes de programación, estudiar Python ha sido algo que nunca ha estado exento de artificiosas sorpresas. Estoy seguro de que muchos lo adoramos por esa originalidad, esa personalidad propia que lo hace tan especial.

Recuerdo, por ejemplo, cuando me encontré por primera vez con esta sorprendente sentencia:

x,y = y,x

Esta simple línea intercambia los valores de las variables x e y sin necesidad de recurrir a una tercera variable temporal. Reconozco que me dejó un poco descuadrado.

Verifícalo,

>>> x=1
>>> y=2
>>> x,y=y,x
>>> x
2
>>> y
1

O cuando me encontré con una función que devolvía varios valores…

Por ejemplo, diseñemos una función que tome dos argumentos y calcule el cociente y el resto de la división entera del primero entre el segundo:

>>> def desguazar(dividendo, divisor):
  cociente = dividendo//divisor
  resto = dividendo%divisor
  return cociente,resto

Observa como utilizo el operador // para el cociente de la división entera y % para el cálculo del resto.

cociente = dividendo//divisor
resto = dividendo%divisor

Hasta ahí bien, pero la línea en que devuelvo el resultado al exterior parece desafiar a toda lógica:

return cociente,resto

¿Qué es esto, una función que devuelve dos valores? ¿Cómo utilizo esto en el exterior?

Mira qué sencillo:

>>> x,y = desguazar(14,4)
>>> x
3
>>> y
2

Sorprendente.

No fue hasta que me presentaron las tuplas cuando ese misterio comenzó a desentrañarse.

Una función, propiamente hablando, sólo puede devolver un objeto, pero ese objeto puede estar compuesto de otros objetos más simples. Las listas o las tuplas son ejemplos de objetos compuestos.

¿Recuerdas cuando dijimos que la forma de definir una tupla era simplemente separar cada valor entre comas? En el artículo comentamos también que el uso de paréntesis era opcional y sólo era forzosamente exigido en caso de que la construcción se prestara a confusión.

Cuando hacemos algo como

return cociente,resto

lo que estamos haciendo, en realidad, es empaquetar las variables cociente y resto en una tupla. Quizás no habría tenido un efecto visual tan sorprendente si lo hubiéramos escrito así:

return (cociente,resto)

Es exactamente lo mismo, pero ahora resulta más evidente que se trata de una tupla.

Ahora si podemos comprender esto claramente ya:

>>> x,y = desguazar(14,4)
>>> x
3
>>> y
2

La función desguazar nos devuelve una tupla que asignamos a otra tupla, la formada por las variables x e y separadas entre comas (que ya sabes que podríamos haber rodeado entre paréntesis). Observa ahora el fenómemo contrario de desempaquetado.

Si eres un escéptico y no te crees que lo que devuelve return sea una tupla, prueba a ejecutar la función en IDLE:

>>> desguazar(17,3)
(5, 2)

Es una tupla: observa como IDLE muestra la salida de una tupla empleando paréntesis, aunque sean opcionales en su creación.

El empaquetado y desempaquetado de secuencias es sólo uno de los artificios mágicos que tiene Python, pero aún hay muchos más. ¿Te animas a descubrirlos?

Javier Montero Gabarró


http://elclubdelautodidacta.es/wp/2012/04/python-capitulo-32-funciones-que-devuelven-varios-valores/


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 31: Exprimiendo la función print

Si hay que dar el premio a la popularidad a una función, es sin duda print la ganadora. No sólo en Python, sino en cualquier otro lenguaje de programación. ¿Qué sería de nuestros motivantes Hola mundo sin ella?

El uso básico lo aprendimos desde el primer momento, pero hoy vamos a sacarle algo de punta…

Comencemos repasando el comportamiento por defecto. Observa la salida del siguiente comando:

>>> print("pepino","tomate")
pepino tomate

Primer punto a observar: print() separa cada argumento empleando un espacio en blanco.

Fíjate ahora en esto:

>>> print("pepino");print("tomate")
pepino
tomate

Segundo punto: cada impresión con print() concluye con un salto de línea.

Podemos controlar con facilidad ambos comportamientos. Es tan sencillo como indicarlo en la propia función print().

La función print() admite un argumento, llamado sep, que contiene la cadena de caracteres que emplearemos para separar cada elemento. Si no se especifica, toma su valor por defecto, un espacio en blanco, sep=" ". He intercalado un espacio entre ambas comillas y da igual que sean simples o dobles.

Por ejemplo, el siguiente comando separa los distintos elementos empleando un guión:

>>> print("pepino","tomate",sep="-")
pepino-tomate

Este otro separa cada elemento con tres espacios en blanco:

>>> print("pepino","tomate","lechuga",sep="   ")
pepino   tomate   lechuga

Podemos hacer que la separación sea exactamente un tabulador, que ya sabes que se representa con el siguiente carácter de escape: \t.

>>> print("pepino","tomate","lechuga",sep="\t")
pepino  tomate  lechuga

Generemos ahora una salida sin separación entre cada palabra:

>>> print("pepino","tomate","lechuga",sep="")
pepinotomatelechuga

Los dos pares de comillas han sido escritos sin un espacio en blanco entre ellas.

Si queremos separar las palabras elegantemente, podemos utilizar como separador una coma junto con un espacio en blanco:

>>> print("pepino","tomate","lechuga",sep=", ")
pepino, tomate, lechuga

Quiero que te fijes bien en que el separador sólo se coloca entre medias de los elementos, y no al final. Pero puedes indicar también cómo quieres que termine la impresión empleando un nuevo argumento opcional, end. Si no se especifica, toma su valor por defecto, que como hemos dicho, provoca un salto de línea, representando por el carácter de escape \n.

El siguiente ejemplo finaliza la impresión con dos guiones:

>>> print("pepino","tomate","lechuga",end="--")
pepino tomate lechuga--

Si queremos que la salida de un print() no provoque un cambio de línea y nos deje el cursor para que el siguiente print() continúe justo donde acabó el anterior, debemos facilitar el siguiente argumento: end=''. Date cuenta de que no hay ningún espacio en blanco entre ambas comillas (también podría haber empleado comillas dobles en vez de simples).

Observa ahora el resultado de estas dos instrucciones:

>>> print("pepino",end="");print("tomate")
pepinotomate

Tal como era de esperar, ambas palabras han aparecido juntas, continuando la segunda justo donde termina la primera.

Un último ejemplo, para finalizar, en el que combinaremos ambos argumentos:

>>> a='Azul'
>>> b='Verde'
>>> c='Rojo'
>>> print(a,b,c,sep=', ',end='.')
Azul, Verde, Rojo.

No es necesario comentar nada, ¿verdad?

Javier Montero Gabarró


Python – Capítulo 31: Exprimiendo la función print


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 30: Instalación de Python 3 e IDLE en Ubuntu

Si tienes Linux, ponerte a programar en Python es cuestión de un abrir y cerrar de ojos. En este artículo especial veremos cómo instalar Python 3 e IDLE sobre Ubuntu 11.10.

Debes saber, en primer lugar, que en la mayoría de las distribuciones Linux, Python se encuentra ya preinstalado.

Veamos qué nos ofrece Ubuntu 11.10. Observa la figura:

En primer lugar hemos lanzado python, tal cual, y comprobamos que está instalada la versión 2. Pulsamos Ctrl-D para salir y escribimos, ahora, python3. El shell nos devuelve un mensaje indicándonos que no está instalado y nos ofrece una sugerencia de instalación para obtener el paquete básico.

No es que la versión que trae Ubuntu esté obsoleta. A la hora de programar en Python tenemos dos opciones: la versión 2 o la 3. La cuestión es que son incompatibles. La razón de que aún siga existiendo Python 2 es que hay innumerables desarrollos funcionando que necesitarían ser reescritos para la versión 3. Además, hay importantes librerías que aún no han sido migradas a la nueva versión.

Haremos caso omiso de la sugerencia del shell e instalaremos Python de modo que nos incluya además, el entorno de desarrollo IDLE.

Abre el Centro de Software de Ubuntu y escribe, en la lupa de búsqueda, python:

Selecciona IDLE (con Python-3.2) y pulsa sobre el botón Instalar. Será necesario que facilites la contraseña del administrador para poder instalar nuevo software.

Comprobemos que todo ha ido bien. Veamos qué nos contesta el shell ahora:

Ahora sí; hemos instalado Python 3.2.2.

Veamos qué pasa con IDLE.

Abre el Dash de Unity y escribe idle. Te deberá aparecer el icono del programa:

Haz clic sobre él y listo.

Maravilla…

Javier Montero Gabarró


Python – Capítulo 30: Instalación de Python 3 e IDLE en Ubuntu


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 Python #2: Sumando las cifras

El camino hacia la pericia como programadores está plagado de ejercicios que van poniendo a prueba nuestra capacidad. Es absolutamente necesario pasar por ellos: resolviendo los problemas más elementales adquirimos las técnicas que nos permitirán afrontar los más complejos.

El programa de hoy es bien simple. Le pediremos al usuario que introduzca un número entero y nuestra misión será calcular la suma de todas sus cifras.

En el camino veremos cómo recorrer una cadena de caracteres (string) de principio a fin. Los strings son otro tipo de secuencias, como las tuplas o las listas y, como todas las secuencias, podemos acceder a sus elementos individualmente.

Comencemos solicitando la introducción del número y almacenando el dato en una variable:

numero=input('Introduce un número de las cifras que quieras: ')

Este tipo de sentencia ya te es familiar, pero no olvides que la entrada de input es una cadena de caracteres, aunque sólo hayamos introducido cifras numéricas. Es decir, la variable numero referencia a un string.

No estamos tratando, por el momento, los posibles errores de entrada. Confiamos en la buena fe del usuario, que sólo introducirá números.

Inicializamos la variable que contendrá la suma de todas las cifras:

suma=0

Vamos a recorrer ahora el string introducido desde el primer elemento hasta el último. Utilizaremos un bucle for:

for cifra in numero:
    suma+=int(cifra)

La variable cifra recorrerá uno a uno, todos los elementos de la secuencia (un string en este caso) de principio a fin. Por ejemplo, si numero es el string ‘207’, en la primera pasada del bucle, cifra es el carácter ‘2’, en la segunda ‘0’ y en la tercera ‘7’.

Date cuenta de que he rodeado cada cifra entre comillas. Esto es así porque los elementos de un array son caracteres simples, aunque representen un número.

Al ser caracteres simples y no números, para poder sumarlos necesitamos convertirlos a enteros. Para ello utilizamos la función int() que vemos en el bloque del for.

Una vez ha concluido el for tras recorrer todo el string, estamos en condiciones de imprimir el resultado final:

print(suma)

El programa sumacifras.py contiene el código completo de este sencillo ejercicio.

Javier Montero Gabarró


BitBite Python #2: Sumando las cifras


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 29: Tuplas

Ha llegado el momento de que hablemos de una estructura de datos muy similar a las ya conocidas listas: las tuplas.

Al igual que una lista, una tupla es una secuencia ordenada de objetos. La principal diferencia entre ambas es que la primera puede ser modificada mientras que una tupla es inmutable: una vez creada, su contenido no puede modificarse (pero sí sobreescribirse, lo que equivaldría a volver a crear una tupla con el mismo nombre). Recuerda los métodos append(), extend(), remove(), pop(), etc., que, de un modo u otro, afectaban al contenido de una lista. Estos métodos no están disponibles en las tuplas.

Piensa en una tupla como una estructura más ágil que una lista, descargada de parafernalia que no siempre es necesaria. En ocasiones pueden incluso ayudarte a escribir código menos propenso a errores, en el supuesto de que, por accidente, intentes modificar una secuencia de objetos que quieres proteger.

La forma básica de definir una tupla es facilitando una secuencia simple de objetos separados entre comas:

>>> frutas='melon', 'sandía'
>>> frutas
('melon', 'sandía')

Date cuenta que no necesitamos corchetes ni paréntesis de ningún tipo. Sin embargo, al visualizarla, nos aparece con paréntesis.

Llegamos con esto a un aspecto importante: el uso de paréntesis es opcional. Podrías haber creado la tupla encerrando los datos entre paréntesis del mismo modo:

>>> frutas=('melon', 'sandía')
>>> frutas
('melon', 'sandía')

Recuerda que las listas, por el contrario, van encerradas entre corchetes.

Los paréntesis no son necesarios, pero hay ocasiones en las que su uso es obligatorio cuando su falta provoca situaciones ambiguas. Por ejemplo, observa la llamada a esta función:

funcioncilla(1,2,3)

¿Es una función con tres argumentos enteros o uno sólo en forma de tupla? La respuesta es, obviamente, la primera. Si hubiera querido que el argumento fuera una tupla debería haberlo indicado entre paréntesis para solucionar la ambigüedad:

funcioncilla((1,2,3))

Python te ofrece flexibilidad a la hora de representar una tupla. Hay programadores que sólo utilizan los paréntesis cuando no queda más remedio; otros, en cambio, los indican siempre. Hay también un término medio que emplea una notación mixta en función de su propio estilo. Elige el que mejor te plazca.

Al igual que una lista, una tupla puede contener una mezcla de objetos de distintos tipos:

>>> cajon='lunes',5,[2,3]
>>> cajon
('lunes', 5, [2, 3])

El primer elemento es una cadena de caracteres, el segundo un entero y el tercero una lista.

Puedes consultar los elementos de una tupla accediendo a través de su índice:

>>> cajon[1]
5

Recuerda que el primer elemento tiene por índice cero, como en las listas.

Pero observa qué sucede si tratas de modificar la tupla:

>>> cajon[1]=7
Traceback (most recent call last):
  File "<pyshell#8>", line 1, in <module>
    cajon[1]=7
TypeError: 'tuple' object does not support item assignment 

Sencillamente, no te deja.

Debes saber algo más a la hora de crear tuplas. Para crear una tupla vacía, sin elementos, abrimos y cerramos paréntesis sin más:

>>> vacia=()
>>> vacia
()

Si no te crees que esto es una tupla, prueba con la función type() para saber de qué objeto estamos hablando:

>>> type(vacia)
<class 'tuple'>

Para crear una tupla con un único elemento, debemos finalizar la enumeración con una coma:

>>> solo_uno=1,
>>> solo_uno
(1,)
>>> type(solo_uno)
<class 'tuple'>

Naturalmente, esto se podía hecho también con paréntesis:

>>> solo_uno=(1,)

Habría sido un error, si lo que pretendíamos era generar una tupla, escribir lo siguiente:

>>> solo_uno=(1)
>>> type(solo_uno)
<class 'int'>

Date cuenta de que type() nos está devolviendo un entero en vez de una tupla.

En resumidas cuentas, a no ser que crees una tupla vacía, asegúrate de que, al menos, exista una coma, emplees o no paréntesis.

Muchas veces se dice de las tuplas que no disponen de métodos, al ser inmutables. Esto no es cierto: no existen métodos para tuplas que modifiquen su contenido, pero sí otros que no las alteren. Por ejemplo:

>>> cajon.count('lunes')
1

El método count() nos devuelve cuántos elementos existen con una valor determinado.

O también:

>>> cajon.index('lunes')
0

El método index() nos devuelve el índice de la primera ocurriencia que haya del valor buscado.

Al igual que las listas, las tuplas pueden ser troceadas:

>>> cajon[1:]
(5, [2, 3])

Esta instrucción ha generado una nueva tupla tomando los elementos que tienen por índice 1 y sucesivos de la tupla cajon.

Existen muchos usos curiosos de las tuplas que quedan camuflados por el hecho de que pueden aparecer sin paréntesis. Iremos conociéndolos, paciencia…

Javier Montero Gabarró


Python – Capítulo 29: Tuplas


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 Python #1 – Aleatoria

Primera entrega de la nueva serie BitBite Python, dedicada íntegramente a mostrar código diverso en acción. No se puede aprender a programar simplemente leyendo teoría; es necesario arremangarse y ponerse a escribir código, planteando y resolviendo problemas concretos. Pero, al igual que cuando se aprende física o matemáticas, el estudio de problemas resueltos debe servir para enriquecer los recursos disponibles a la hora de enfrentarnos con otros desafíos.

Todo el código que aparecerá en esta serie habrá sido tratado adecuadamente en los capítulos de teoría y deberás remitirte a ellos si algún concepto no lo tuvieses suficientemente claro. Piensa en estos programas como la práctica necesaria que complementa los artículos teóricos. Aunque se puede aprender a programar simplemente estudiando otros programas y programando, estudiar la teoría te allanará y acortará el camino.

En el artículo Productividad Aleatoria, describí una técnica que empleo eventualmente para seguir siendo productivo incluso cuando la indecisión me paraliza a la hora de elegir la próxima tarea a afrontar: eligiéndola al azar.

Para ello, utilizo el generador de números aleatorios de random.org, o el propio widget que he colocado en el pie de página del blog.

Vamos a realizar un programa en Python que se ocupe precisamente de esto mismo: la elección de un número entero al azar dentro de un rango especificado por el usuario.

Comenzamos…

import random

La función clave del programa se encuentra dentro del módulo de la librería de Python, random.py, especializado en el manejo de números aleatorios. Debemos importar el módulo para poder utilizar las funciones que contiene.

min = int(input('Mínimo: '))
max = int(input('Máximo: '))

Introducimos el rango de valores entre los cuales, inclusive, se elegirá el número al azar. Observa la conversión explícita a entero con int, pues input nos devuelve una cadena de caracteres.

aleatorio = random.randint(min, max)

Elegimos un número aleatorio entre min y max y lo almacenamos en la variable aleatorio. La función randint se ocupa de esta elección, cuyos parámetros definen el rango del que se tomará el entero al azar. Fíjate que para poder utilizarla es preciso anteponer al nombre de la función el nombre del módulo al que pertenece, separados por un punto.

Si no hubiésemos convertido min y max a enteros, el programa devolvería un error, pues los parámetros que la función randint requiere deber ser de ese tipo, y no strings.

print('Número aleatorio entre', min, 'y', max, '--> ', aleatorio)

Finalmente, mostramos el resultado de la elección.

El fichero aleatoria.py contiene el código fuente completo del programa.

Javier Montero Gabarró


http://elclubdelautodidacta.es/wp/2012/02/bitbite-python-1-aleatoria/


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 28: Introducción a la librería estándar

Una de las razones que me animaron a estudiar Python, además de la elegancia del lenguaje en sí, fue que incluía una tremenda cantidad de funcionalidad extra que me permitía acometer casi cualquier tipo de proyecto de programación sin necesidad de recurrir a librerías de terceros.

Seguro que has leído alguna vez eso de que Python se distribuye «con pilas incluidas». La expresión hace mención a su famosa librería estándar, una gran colección de módulos repletos de código listos para que hagas uso de ellos.

En el capítulo de hoy mostraremos cómo utilizar la librería estándar a través de un par ejemplos sencillos.

Imagina que queremos hacer un programa que simule la tirada de un dado. Necesitaremos algún tipo de código que sea capaz de generarnos un número aleatorio entre 1 y 6. Dentro de las funciones built-in de Python no existe nada parecido. Sin embargo, en algún lugar de tu disco duro hay un fichero, random.py, que te va a sacar del atolladero.

Ese fichero, como todos los que terminan en .py, constituyen lo que se denomina un módulo. Los programas que tú escribes son también módulos en sí mismos. La diferencia es que random.py es un módulo de la librería de Python. Más que programas típicos que se ejecutan y provocan una salida concreta, lo que un módulo de la librería almacena es un conjunto de variables, funciones, clases (con sus respectivos atributos y métodos) que tú vas a poder incorporar después a tus propios programas.

El primer paso para hacer esto es lo que se conoce como importar el módulo. Para que te hagas una idea, eso es casi como si hubieras copiado el código del módulo de la librería y lo hubieras pegado junto al tuyo.

Esto se realiza con la instrucción:

import random

Observa que no necesito poner la extensión, basta con el nombre del módulo.

Por curiosidad, abre el fichero random.py con un editor de texto y observa su contenido. Cientos de líneas especializadas en la gestión de números aleatorios a tu entera disposición. Entre el amplio conjunto de funciones, existe una, randint(), que es capaz de generarnos un entero aleatorio entre dos valores, ambos inclusive, que indiquemos como parámetros.

Carga IDLE o el intérprete interactivo, que vamos a hacer unas pruebas.

Comenzamos importando el módulo random:

>>> import random

Con el módulo importado, permítete echar un vistazo a la ayuda que trae:

>>> help(random)

Puedes entretenerte un rato leyéndola si te apetece…

Vamos a intentar invocar la función randint():

>>> randint(1,6)
Traceback (most recent call last):
  File "<pyshell#15>", line 1, in <module>
    randint(1,6)
NameError: name 'randint' is not defined

¿Cómo que no está definida? ¿No habíamos dicho que al importar el módulo teníamos a nuestra disposición todas sus funciones?

Así es. Lo que ha fallado ha sido la forma en la que hemos invocado a randint(). El modo correcto de hacerlo es precediendo el nombre de la función por el nombre del módulo al que pertenece, separados por un punto.

>>> random.randint(1,6)
4

Decimos que randint() pertenece a un espacio de nombres diferente al que usamos en nuestro programa principal. En la invocación hay que indicar que randint() está asociada al espacio de nombres random (igual que el nombre del módulo).

De hecho, podríamos tener una propia función randint() en nuestro código y no entraría en conflicto con la de random:

>>> def randint():
  print('hola')

>>> randint()
hola
>>> random.randint(1,6)
3

Veamos un segundo ejemplo:

En la librería estándar, existe un módulo especializado en el tratamiento de fechas: datetime.

Pues bien, entre lo mucho que tiene datetime nos ofrece una clase especial de objeto: date, con todos sus atributos y métodos. Uno de ellos es el método today(), que nos devuelve la fecha actual. Veámoslo en acción:

>>> import datetime
>>> print(datetime.date.today())
2012-01-24

El primer punto separa el espacio de nombres del nombre de la clase. El segundo separa la clase del método.

En próximas entregas veremos cómo crear nuestros propios módulos para ir ampliando nuestra librería personal. Entre tanto, intenta averiguar más cosas que la librería estándar de Python puede hacer por ti.

Javier Montero Gabarró


Python – Capítulo 28: Introducción a la librería estándar


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 Python

Inauguramos una nueva serie que complementará los capítulos teóricos de programación en Python y que estará enfocada al aspecto más práctico del lenguaje: la elaboración de programas que solucionen problemas reales.

Hasta ahora, nos hemos limitado a una exposición «atómica» de los elementos del lenguaje, en la que cada concepto se presentaba, de modo aislado, del modo más simple que permitiera su comprensión. La herramienta principal ha sido el intérprete interactivo, el entorno perfecto y más rápido para experimentar cada técnica.

Bajo el nombre BitBite Python realizaremos programas completos que resolverán problemas comunes con los que se suele enfrentar un programador. No necesariamente todos serán de utilidad práctica directa, pero aún así las técnicas aprendidas enriquerecerán el bagaje de recursos de cada uno y podrán ser aplicadas en otros contextos.

Cada concepto presente en BitBite Python habrá sido tratado previamente dentro de los capítulos teóricos. A medida que vayamos profundizando en estos irán apareciendo en la sección práctica.

Nos vemos en BitBite Python

Javier Montero

Python – Capítulo 27: Funciones con argumentos por defecto

Continuando con el tema de las funciones en Python, voy a mostrarte hoy una técnica interesante que permite facilitar argumentos por defecto a una función. Veamos qué significa esto.

En capítulos anteriores vimos el uso de argumentos en las funciones. Recuerda la función praderazo(), que mostraba un texto detérminado repetidas veces y enmarcado por un símbolo a elegir.

Su definición era la siguiente:

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)

veces y simbolo son los argumentos de la función. Ejemplos de invocación posibles podrían ser:

>>>praderazo(5,'+')

o

>>>praderazo(100,'&')

La función, para ser invocada correctamente, necesita forzosamente dos argumentos. Decimos que veces y simbolo son argumentos requeridos.

Esta llamada generaría un error, como podemos comprobar:

>>> praderazo(5)
Traceback (most recent call last):
  File "<pyshell#4>", line 1, in <module>
    praderazo(5)
TypeError: praderazo() takes exactly 2 arguments (1 given)

Lo que nos dice el mensaje de error es que praderazo() requiere exactamente dos argumentos y sólo uno ha sido facilitado.

Observa ahora esta nueva definición de praderazo():

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)

Fíjate en como está descrito el argumento simbolo, especificando directamente un valor.

Decimos que simbolo es un argumento por defecto y el valor especificado es el valor que tomará por defecto en caso de que no se facilite uno concreto.

Ya no es necesario especificar el segundo argumento, si no queremos. En caso de que no lo hagamos, simbolo tomará el valor por defecto (el signo ‘+’).

>>> 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... +
++++++++++++++++++++++++++++++++++++++++++

Si no queremos usar el valor por defecto, hay que recurrir a la especificación completa:

>>> praderazo(3,'%')
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% La casa de la pradera, pedazo serie... %
% La casa de la pradera, pedazo serie... %
% La casa de la pradera, pedazo serie... %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

Es importante tener en cuenta que los argumentos por defecto deben figurar siempre después de los requeridos, y nunca antes. Supongamos que hubiéramos querido dejar por defecto veces y requerido simbolo:

>>> def praderazo(veces=5,simbolo):
    print(simbolo*42)
    for n in range(veces):
      print(simbolo,'La casa de la pradera, pedazo serie...',simbolo)
    print(simbolo*42)
    
SyntaxError: non-default argument follows default argument

Obtendríamos un error sintáctico reflejando que hay argumentos que no son por defecto después de los que sí lo son. Si no fuera así Python podría liarse a la hora de saber qué argumentos son unos u otros.

La definición correcta habría sido:

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

Veamos un nuevo ejemplo:

>>> def mifuncion(a,b=2,c=3):
  print(a+b+c)

Toma tres parámetros y calcula la suma de ellos. Si no especificamos ni b ni c tomará sus valores por defecto.

Invoquemos a la función de diversas maneras:

>>> mifuncion(4,5,6)
15

>>> mifuncion(6,4)
13

En este segundo ejemplo, los dos primeros argumentos corresponden a a y a b. Como no hemos especificado c, toma su valor por defecto.

>>> mifuncion(5)
10

Aquí hemos indicado sólo a, el único que es requerido. Los demás argumentos toman sus valores por defecto.

Para concluir, te propongo un ejercicio: adapta la función praderazo() para que el texto a enmarcar sea elegible por el usuario como argumento.

Pista: recuerda la función len(), que determina la longitud de una cadena.

Javier Montero


Python – Capítulo 27: Funciones con argumentos por defecto


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