python | 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,'+')

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

Python – Capítulo 26: Funciones que devuelven valores

En entregas anteriores explicamos el concepto de función y diseñamos algunos ejemplos sencillos. Vimos cómo utilizar una función para realizar una determinada tarea que presumiblemente volvería a repetirse, permitiéndonos así la reutilización del mismo código dentro del programa. También ilustramos el paso de argumentos, aquellos datos que facilitábamos a la función y que luego serían procesados dentro de su cuerpo.

Todos los ejemplos compartían algo en común: realizaban una tarea concreta (presentar información en pantalla), pero no devolvían ningún valor al ser invocadas.

Ya conoces algunas funciones en Python que devuelven valores. Por ejemplo, recuerda la función int(), que convertía una cadena de caracteres en un número entero, o la función len(), que devolvía la longitud de una cadena.

Los valores que devuelven las funciones pueden ser capturados y esto típicamente se hace asignando una variable, pudiendo formar parte de una expresión numérica.

longitud = len('La casa de la pradera')

Esta instrucción asignaría el valor numérico 21 a la variable longitud.

Los valores que devuelven las funciones no tienen que ser necesariamente numéricos.

Voy a mostrarte cómo hacer para que una función devuelva un valor. Crearemos una que admita como argumento un número natural y que devuelva la suma de todos los naturales que hay hasta él inclusive. Es decir, si, por ejemplo, le facilitamos como argumento un 5, nos devuelva la suma:

1 + 2 + 3 + 4 + 5 = 15

Podríamos hacer un algoritmo para realizar el cálculo empleando un bucle, pero no va ser necesario. Si recordáis las enseñanzas en la escuela, hay una fórmula directa para calcular la suma de todos los términos de una progresión aritmética de diferencia uno:

$sp=\frac{n(n+1)}{2}$

Ya estamos en condiciones de crear nuestra función:

Abre IDLE o el intérprete interactivo y escribe el siguiente código:

>>> def sumaprogresion(n):
       sp=n*(n+1)//2
       return sp

La función toma como argumento un valor que almacena en la variable n. Este valor es utilizado para el cálculo de la suma, almacenando el resultado en la variable sp.

Fíjate en la instrucción

return sp

Esta línea es la que indica qué valor devolverá la función. En este ejemplo, lo que contenga la variable sp, que es la que almacena el resultado del cálculo de la suma de la progresión.

Para realizar el cálculo he empleado la división entera (//), en vez de la ordinaria (/). Así evito que se escriba el resultado con un punto decimal.

Probémoslo:

>>> sumaprogresion(5)
15

Recuerda que esto es equivalente a hacer

>>>print(sumaprogresion(5))

En el intérprete interactivo te puedes ahorrar el print, pero no así cuando escribas un programa fuera de él.

Veamos otro ejemplo:

>>> print('La suma de los 1000 primeros números naturales es', sumaprogresion(1000))
La suma de los 1000 primeros números naturales es 500500

Así de simple.

Javier Montero

http://elclubdelautodidacta.es/wp/2011/12/python-capitulo-26-funciones-que-devuelven-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 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

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

Python – Capítulo 23: El que ríe el último ríe mejor

El título que he elegido para este artículo contiene un acertijo. ¿De qué crees que hablaremos hoy?

Es complicado, así que te daré otra pista: «los últimos serán los primeros».

En el capítulo de hoy mostraremos cómo organizar una estructura LIFO (una pila o stack) en Python y para ello nos valdremos, una vez más, de nuestras potentes y versátiles listas. ¡Qué sería de nosotros sin ellas!

Aclaremos previamente, por si no lo conoces, qué entendemos por una pila.

Una pila, o stack en inglés, es el término que se emplea en programación para designar una estructura de datos ordenada en la que almacenamos información y la recuperamos del modo que lo último que entre sea lo primero que sale.

De ahí vienen las siglas LIFO: Last In, First Out; el último en entrar, el primero en salir.

Piensa en una montón de papeles que vas apilando uno encima de otro. Cuando los quieres recuperar, accedes en primer lugar al que está arriba de la pila. Una vez lo retiras tienes acceso al siguiente, y así sucesivamente.

El concepto opuesto es el de cola, que es una estructura FIFO: First In, First Out; el primero que entra, el primero que sale. Piensa en la típica cola ante la taquilla de un concierto. El primero que llegó es el que primero tiene derecho a comprar la entrada. El que llegó el último tendrá que esperar a que hayan salido todos los que están delante de él antes de que le toque su turno.

Si quizás has hecho tus pinitos en el mundo de la programación en lenguaje ensamblador, el concepto de pila, o stack, te resultará ya familiar, al igual que las dos instrucciones que se empleaban para introducir y recuperar datos: push y pop, respectivamente. En Python se emplean casi las mismas.

Vamos a ilustrar el concepto pensando en un ascensor como si de una estructura LIFO se tratase: entras en el ascensor y te sitúas atrás para dejar sitio a los demás; cuando llega la hora de salir, el último en entrar es el primero en abandonar el ascensor y tú, que entraste el primero, eres ahora el último en salir.

Al principio el ascensor está vacío. Vamos a crear una lista sin elementos:

>>> ascensor = []
>>> ascensor
[]

Ese par de corchetes tiene hasta forma de ascensor, ¿a que sí?

El método para agregar elementos a una lista, justo después del último, ya lo conoces del capítulo 19. Vamos a emplearlo para hacer que Luis suba en el ascensor:

>>> ascensor.append('Luis')
>>> ascensor
['Luis']

El siguiente en entrar será Pedro:

>>> ascensor.append('Pedro')
>>> ascensor
['Luis', 'Pedro']

Le siguen Marta y Juan:

>>> ascensor.append('Marta')
>>> ascensor.append('Juan')
>>> ascensor
['Luis', 'Pedro', 'Marta', 'Juan']

El ascensor llega a la planta baja y es hora de abandonarlo.

Para extraer el último elemento de una lista, Python dispone del método pop().

>>> ascensor.pop()
'Juan'
>>> ascensor
['Luis', 'Pedro', 'Marta']

Fíjate bien en que pop() hace dos cosas: por un lado, recupera el último elemento, el cual podrías, por ejemplo, presentarlo o asignarlo a una variable; por otro, elimina ese elemento de la lista.

Si vuelvo a hacer un pop(), ¿quién crees que saldrá ahora?

>>> ascensor.pop()
'Marta'

Le sigue Pedro y, a continuación, Luis, que estaba apretujado al fondo:

>>> ascensor.pop()
'Pedro'
>>> ascensor
['Luis']
>>> ascensor.pop()
'Luis'

Si no nos hemos equivocado en las cuentas, el ascensor está ya completamente vacío. En efecto:

>>> ascensor
[]

Con dos sencillos métodos, append() y pop(), hemos diseñado una estructura LIFO en todas las de la ley.

El método pop() podemos utilizarlo aunque nuestra lista no sea LIFO. Veámoslo:

Demos marcha atrás en el tiempo hasta el momento en el que el ascensor estaba completamente lleno:

>>> ascensor=['Luis', 'Pedro', 'Marta', 'Juan']
>>> ascensor
['Luis', 'Pedro', 'Marta', 'Juan']

Se abren las puertas y le toca salir a Juan, que ha sido el último en entrar. Sin dudarlo, considera que sería poco caballeroso por su parte salir el primero y, cortésmente, le cede el paso a Marta.

Cuando al método pop() le facilitamos un índice, extraerá el elemento correspondiente, en lugar del último de la lista.

El índice de Marta en la lista es 2. Por lo tanto:

>>> ascensor.pop(2)
'Marta'
>>> ascensor
['Luis', 'Pedro', 'Juan']

¡Cuánta caballerosidad! No sólo el lenguaje Python es elegante y cortés en sí mismo, ¡incluso los mismos elementos que ilustran como ejemplo sus estructuras de datos!

Javier Montero

Python – Capítulo 23: El que ríe el último ríe mejor

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 22: Comillas simples, dobles y triples

Las cadenas de texto, o strings, las delimitamos en Python encerrándolas entre comillas. Por lo general, estas pueden ser simples o dobles, da igual cuáles empleemos (con la condición de que la comilla que abre sea del mismo tipo que la que cierra, por supuesto). En los ejemplos que he incluido en esta serie me habréis visto usar un tipo u otro indistintamente.

La ventaja de poder elegir entre comillas simples o dobles la encontramos cuando necesitemos anidar unas comillas dentro de otras. Observad el siguiente ejemplo:

>>> >>> print('Una de mis series favoritas era "La casa de la pradera".')
Una de mis series favoritas era "La casa de la pradera".

Esto lo hemos podido conseguir utilizando el par interior de comillas de tipo diferente a la que abre y cierra el string, de modo que Python no puede confundirse a la hora de delimitar el fin de la cadena.

Pero, ¿como haríamos si necesitáramos imprimir las propias comillas simples o dobles, con libertad, dentro de un string?

La solución pasa por utilizar «caracteres de escape». Referenciamos las comillas simples y dobles precediéndolas de un backslash (\), de modo que Python ignore su significado habitual delimitando strings.

Para escribir una comilla simple, emplearíamos \’ y, para una doble, \».

Por ejemplo:

>>> print('Una de mis canciones favoritas de Beatles es "Maxwell\'s silver hammer".')
Una de mis canciones favoritas de Beatles es "Maxwell's silver hammer".

Existe un problema al escribir strings largos, y es que deben estar en la misma línea de código, pues Python interpretaría una pulsación de Enter como una nueva línea de código.

Si, por cuestiones de comodidad, necesitamos «partir» nuestro código, continuando en una nueva línea física, pero que forme parte de la misma línea lógica, podemos hacerlo terminando la línea física con el carácter de escape \ y pulsando Enter a continuación.

Observadlo en este ejemplo:

>>> print('Una de mis canciones favoritas de Beatles \
es "Maxwell\'s silver hammer".')
Una de mis canciones favoritas de Beatles es "Maxwell's silver hammer".

¿Cómo manejaríamos un string que estuviera compuesto por varias líneas? La solución obvia sería emplear un string por línea, pero ¿cómo lo hacemos para que figure todo en la misma cadena?

Existe un carácter de escape para una nueva línea, y es \n. Fijaos en el siguiente código:

>>> print('La receta auténtica del alioli:\n- Ajo\n- Aceite')
La receta auténtica del alioli:
- Ajo
- Aceite

También disponemos de un carácter de escape para el tabulador: \t.

>>> print('Manzana\tPera\tCiruela\nMelón\tSandía\tFresa')
Manzana  Pera    Ciruela
Melón    Sandía  Fresa

No obstante, cuando la cadena es larga, este método de formateo resulta complejo. Ahí es donde surge un nuevo invitado a la escena: la comilla triple.

La comilla triple nos permite insertar un string con todas las líneas que deseemos. Basta que enmarquemos un bloque de texto entre comillas triples (da igual si son simples o dobles) y Python respetará el aspecto y formato completo del texto.

Veámoslo en el siguiente ejemplo:

>>> print("""
Una de mis series favoritas era "La casa de la pradera"
Una de mis canciones favoritas de Beatles es "Maxwell's silver hammer"
Manzana  Pera  Ciruela
Melón  Sandía  Fresa""")

Una de mis series favoritas era "La casa de la pradera"
Una de mis canciones favoritas de Beatles es "Maxwell's silver hammer"
Manzana  Pera    Ciruela
Melón    Sandía  Fresa

Todo eso en un único string.

Observad cómo no he necesitado preocuparme del anidado de comillas, ni tan siquiera de escapar la comilla de Maxwell’s.

Interesante, ¿verdad?

Python está repleto de sutilezas así que hacen que la labor de programar sea un ejercicio eficaz y sumamente divertido a la vez.

Javier Montero

Python – Capítulo 22: Comillas simples, dobles y triples

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 21: Concatenación de listas

En ocasiones necesitaremos combinar varias listas en una única, proceso que denominamos concatenación. La forma de realizar esto en Python es muy simple: podemos concatenar usando el operador de adición o a través del metodo extend().

Abrimos IDLE o el intérprete interactivo y comenzamos creando un par de listas de ejemplo:

>>> lista1 = ['casa', 5, 'manzana']
>>> lista2 = ['lunes', 'martes']

He elegido lista1 a propósito para recordaros que una lista puede estar compuesta por elementos de diferentes tipos.

Podemos sumar ambas listas para obtener una nueva con el contenido de ambas:

>>> lista3 = lista1 + lista2

>>> lista3
['casa', 5, 'manzana', 'lunes', 'martes']

Esta es la forma más básica de proceder. Si hubiésemos querido que lista1 se hubiese extendido con el contenido de lista2, podríamos haber ejecutado esto:

>>> lista1 = lista1 + lista2
>>> lista1
['casa', 5, 'manzana', 'lunes', 'martes']

Esto último lo podríamos haber logrado aplicando el método extend() sobre lista1.

Comencemos restableciendo lista1 a su valor inicial:

>>> lista1 = ['casa', 5, 'manzana']

Extendámosla ahora con el contenido de lista2:

>>> lista1.extend(lista2)
>>> lista1
['casa', 5, 'manzana', 'lunes', 'martes']

obteniendo el mismo resultado que con la suma anterior.

La lista del método extend() la podemos facilitar implícita o explícitamente. Volvamos a extender lista1:

>>> lista1.extend(['parchís', 'oca'])
>>> lista1
['casa', 5, 'manzana', 'lunes', 'martes', 'parchís', 'oca']

Observad como, en vez de facilitar el nombre de la lista al método, indico directamente su definición.

Para concluir la sesión, quiero que prestéis atención a la diferencia entre el método append(), que tratamos en el capítulo 19, y el método extend().

Restablezcamos lista1 a su valor inicial:

>>> lista1 = ['casa', 5, 'manzana']
>>> lista1.append(lista2)

Veamos qué ha sucedido:

>>> lista1
['casa', 5, 'manzana', ['lunes', 'martes']]

El resultado es completamente diferente: las listas no se han concatenado, sino que se ha añadido un nuevo elemento al final de lista1. Ese elemento es lista2.

Esto ilustra algo muy importante: no sólo los elementos de una lista pueden ser de tipos diferentes, sino que, además, pueden tratarse de listas en sí mismas. Es decir, es legítimo tener listas cuyos elementos individuales sean listas.

Listas dentro de listas… Se me ocurren decenas de aplicaciones interesantes.

Javier Montero

http://elclubdelautodidacta.es/wp/2011/10/python-capitulo-21-concatenacion-de-listas/

Si este artículo te ha parecido interesante y crees que puede ser útil a los demás, considera la posibilidad de compartirlo en tus redes sociales favoritas.

Python – Capítulo 20: La función range()

Artículo tras artículo, nuestro maletín de herramientas de Python va cogiendo peso y disponemos de nuevos recursos para afrontar cualquier desafío de programación. En la entrega de hoy hablaremos de la función range(). Si alguien no entiende aún por qué Python es tan especial, que eche una ojeada a esto.

La función range() es muy simple, pero de una potencia tremenda: genera automáticamente una secuencia con una progresión aritmética.

Puede utilizarse con uno, dos o tres parámetros.

Comencemos por su uso básico con uno sólo:

>>> range(5)
range(0, 5)

Este comando, aunque aparente no haber hecho nada, ha generado una secuencia virtual de números enteros ¿No se ve nada?. Para poder hacer de carne y hueso esta secuencia vamos a convertirla en lista con la función list().

>>> list(range(5))
[0, 1, 2, 3, 4]

Ahora sí, ya vemos de qué madera está hecha: se trata de una progresión aritmética de término inicial 0 y final 4, uno menos que el valor del parámetro especificado.

Incluyamos ahora dos parámetros:

>>> list(range(1,8))
[1, 2, 3, 4, 5, 6, 7]

Cuando especificamos dos valores, el primero es el término inicial. El segundo, al igual que en el ejemplo anterior, constituye el término superior no incluido.

Si indicamos tres parámetros, el tercero supone la diferencia de la progresión aritmética (el incremento):

>>> list(range(1,10,2))
[1, 3, 5, 7, 9]

Es decir se trata de una progresión aritmética que comienza en 1, termina en 9 y en la que cada elemento se obtiene sumando 2 al anterior.

Naturalmente, esto también funciona con enteros negativos:

>>> list(range(-3,10))
[-3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

El siguiente programa calcula la suma de todos los números naturales desde el 1 hasta el 1000 (incluido):

suma = 0
for n in range(1001):
    suma+=n
print(suma)

Si lo ejecutamos, obtenemos:

python capitulo20-1.py
500500

Este otro numera automáticamente los elementos de una lista:

# Esta lista ya nos es familiar
semana=['lunes', 'martes', 'miércoles', 'jueves', 
       'viernes', 'sábado', 'domingo']
for n in range(len(semana)):
    print(n+1, semana[n])

Ejecutémoslo:

python capitulo20-2.py

1 lunes
2 martes
3 miércoles
4 jueves
5 viernes
6 sábado
7 domingo

Observad como, en la función print(), he indicado, como parámetro n+1 para que la numeración comience por 1 y no en 0.

Asimilad la función range() y hacedla vuestra. Cada paso que damos nos acerca al objetivo, que no es otro sino ser capaces de hacer practicamente cualquier cosa utilizando Python.

Javier Montero

Python – Capítulo 20: La función range()

Si este artículo te ha parecido interesante y crees que puede ser útil a los demás, considera la posibilidad de compartirlo en tus redes sociales favoritas.

Python – Capítulo 19: Agregando elementos a una lista

Hasta ahora hemos trabajado con listas en las que su longitud se ha mantenido constante desde su creación. En el capítulo de hoy veremos cómo agregar dinámicamente nuevos elementos.

Arranquemos Python IDLE o el intérprete interactivo.

Vamos a crear una lista que emplearemos para gestionar la lista de espera de un vuelo de la compañía Python Airlines.

>>> lista_espera = ['Luis Luisero', 'Pedro Pedrete', 'Javier Javiercín', 'Rosa Rosae']

Si quedan vacantes, Luis será el primero con derecho a ocupar una plaza, seguido de Pedro. Rosa lo va a tener algo más difícil, pues está la última en la cola.

Llega una nueva usuaria, Marta Martínez, y se le informa que debe permanecer en lista de espera, pero que aún tiene a cuatro personas por delante.

Para inscribirla, ejecutamos el siguiente comando:

>>> lista_espera.append('Marta Martínez')

El método append agrega un elemento a una lista en última posición.

Un poco de terminología. Un método es una especie de función que actúa sobre un objeto determinado. En este caso, el método append está acuando sobre lista_espera. El nombre del objeto y el método aparecen separados por un punto.

Comprobemos que ha cumplido con su cometido:

>>> lista_espera
['Luis Luisero', 'Pedro Pedrete', 'Javier Javiercín', 'Rosa Rosae', 'Marta Martínez']

Pero lo va a tener realmente complicado. Al parecer hay rumores de que sólo habrá tres vacantes, aunque no se pierde nada por intentarlo.

De repente llega al mostrador de facturación una conocida del piloto. La meterán en lista de espera, para ser discretos, pero en una posición que asegure que cogerá el avión.

Debemos asegurarnos que esté la tercera en la cola.

Podemos agregar un elemento a una lista en la posición que deseemos aplicando el método insert, facilitando como parámetro adicional el índice en el que quedará ubicado. El elemento que estaba situado en esa posición se desplazará un puesto hacia la derecha.

Puesto que va a ser el tercer elemento, su índice es dos. Recordemos que el primer elemento de una lista tiene por índice cero.

>>> lista_espera.insert(2, 'Helen Chufada')

Veamos qué ha pasado:

>>> lista_espera
['Luis Luisero', 'Pedro Pedrete', 'Helen Chufada', 'Javier Javiercín', 'Rosa Rosae',
 'Marta Martínez']

Volar volará, pero no hay derecho…

Javier Montero

Categoría: python

BitBite Python

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

Python – Capítulo 26: Funciones que devuelven valores

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

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

Python – Capítulo 23: El que ríe el último ríe mejor

Python – Capítulo 22: Comillas simples, dobles y triples

Python – Capítulo 21: Concatenación de listas

Python – Capítulo 20: La función range()

Python – Capítulo 19: Agregando elementos a una lista

Uso de cookies

Tal vez te interese...

Tal vez te interese...

Tal vez te interese...

Tal vez te interese...

Tal vez te interese...

Tal vez te interese...

Tal vez te interese...

Tal vez te interese...

Tal vez te interese...

Uso de cookies