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

Python – Capítulo 18: Creación de sublistas

Objetivo: aprender los conceptos básicos de slicing aplicados a las listas en Python.

Las listas dan mucho de sí; no en vano son uno de los artilugios estrella en la programación en Python. Hoy voy a mostrarte cómo crear sublistas, es decir, listas que son un trozo (en inglés, slice) de otra mayor. Por ejemplo, dada la lista de días de la semana, una sublista sería aquella que contiene los días laborables.

Arrancamos IDLE o el intérprete de comandos de Python e introducimos una lista sencilla sobre la que cacharrearemos:

vocales = ['a','e','i','o','u']
>>>vocales
['a', 'e', 'i', 'o', 'u']

Para extraer una sublista de una lista empleamos la notación:

lista[i:j]

donde i y j son dos índices que separamos por dos puntos (:)

El primer índice, i, corresponde al índice del elemento inicial a partir del cual, incluido, comenzará la sublista. El otro indica el extremo superior, pero esta vez sin incluir.

Todo se entenderá más claro si vocalizamos mejor:

>>> vocales[2:4]
['i', 'o']

Como ves, se nos ha creado una lista (fíjate en los corchetes) que contiene todos los elementos que van desde el que tiene índice 2 (incluido) al de índice 4 (sin incluir), es decir, los de índices 2 y 3. Vuelvo a recordar que el primer elemento tiene por índice cero, por eso el de índice dos corresponde a la ‘i’.

La lista original no se ve afectada por esta operación:

>>> vocales
['a', 'e', 'i', 'o', 'u']

¿Qué provocaría esto?

>>> vocales[2:3]
['i']

En efecto, pues sólo se extraerían los que comienzan por índice 2 y terminan en índice 2 también.

¿Y esto otro?

>>> vocales[2:2]
[]

Observa que obtenemos una lista vacía, sin ningún elemento. Es lógico; el inicio tendría por índice 2 y el final índice 1. No tiene ningún sentido que el extremo derecho sea menor que el izquierdo.

¿Cómo haríamos para extraer una lista que fuera idéntica a la original?

Pensemos… El primer índice es cero, el último es 4. Pero esto no vale:

>>> vocales[0:4]
['a', 'e', 'i', 'o']

porque sólo incluiría los de índices 0, 1, 2 y 3.

Solución: poner como extremo superior 5 o cualquier valor por encima. Probémoslo:

>>> vocales[0:5]
['a', 'e', 'i', 'o', 'u']

>>> vocales[0:100]
['a', 'e', 'i', 'o', 'u']

Esto merece una explicación:

En condiciones normales, cuando referenciamos a una lista a través de un índice fuera de sus límites, como en estos dos últimos ejemplos, obtendríamos un error. Esto no es así para el caso de las sublistas. Debemos pensar en el valor derecho, más que como un índice real, como una cota superior. Todo lo que encuentre entre medias lo extraerá, sin importar que la lista concluya antes.

Para facilitar el trasiego con sublistas Python permite utilizar valores por defecto.

1) Si omitimos el primer valor del slice , Python sobreentiende que el comienzo es desde el principio de la lista:

>>> vocales[:3]
['a', 'e', 'i']

Como ves, el mismo efecto que haber hecho esto otro:

>>> vocales[0:3]
['a', 'e', 'i']

2) Si omitimos el segundo valor del slice Python sobreentiende que se trata del último de la lista:

>>> vocales[3:]
['o', 'u']

La omisión de ambos nos permite, obviamente, recuperar la lista completa, de principio a fin:

>>> vocales[:]
['a', 'e', 'i', 'o', 'u']

Puede parecer algo inútil, pero ya veremos más adelante que este uso puede permitirnos ciertas sutilidades elegantes.

Para finalizar, volvamos a la lista que mencionamos al comienzo:

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

¿Qué comando emplearías para extraer los días laborables y, además, asignar ese resultado a la lista laborables?

Si has comprendido la lección de hoy, seguro que no tendrás dificultad en dar con esto:

>>> laborables = semana[:5]
>>> laborables
['lunes', 'martes', 'miércoles', 'jueves', 'viernes']

Volveremos más adelante con el slicing refinándolo aún más y aprendiendo algunas técnicas comunes. Entre tanto, asegúrate de practicar estos conceptos simples.

Javier Montero Gabarró

Fecha de la última modificación: 21 de junio de 2013.

http://elclubdelautodidacta.es/wp/2011/09/python-capitulo-18-creacion-de-sublistas/

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

El Club del Autodidacta

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

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

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

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

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

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

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

>>> semana

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

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

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

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

>>> semana[0]='fiesta'

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

Revisemos nuestra semana tras esta sencilla operación:

>>> semana

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

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

Nada que no podamos solucionar:

>>> semana[1]='fiesta'

>>> semana

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

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

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

>>> semana

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

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

Javier Montero Gabarró

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

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

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

El Club del Autodidacta

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

Python – Capítulo 16: El intérprete interactivo

Objetivo: mostrar el carácter inmediato del intérprete interactivo de Python.

No siempre que tengamos que practicar un nuevo concepto será necesario que construyamos un programa a la medida. Para realizar pruebas sencillas podemos recurrir directamente al intérprete interactivo de Python.

Desde un terminal o un intérprete de comandos ejecuta python (o python3 en algunos sistemas Linux) sin facilitar como argumento ningún fichero .py.

Deberá aparecerte, majestuoso, el prompt de Python invitándote a sentir su potencia:

>>>

Vamos a jugar un poco con el intérprete. Una particularidad realmente interesante es que, si le facilitas una expresión susceptible de devolver un valor, este te aparecerá directamente en pantalla:

>>> 2+2

4

No ha sido necesario escribir print (2+2).

>>> -5*7

-35

>>> (8+4)*(5-2)

36

>>> 2<3

True

Cuando te canses de utilizar Python como calculadora, prueba a introducir algo de código, como la asignación de una variable:

>>> a = 1

No devuelve nada, pero «se guarda» esa asignación. Comprobémoslo:

>>> a

1

Nuevamente, date cuenta de que no ha sido necesario introducir print(a). Recuerda que, desde el intérprete interactivo, basta con escribir una expresión para que se muestre su valor.

Juguemos ahora con una lista que seguro te resultará ya familiar:

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

Veamos:

>>> semana

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

Accedamos ahora a elementos individuales a través de un índice:

>>> semana[0]

'lunes'

>>> semana[-1]

'domingo'

Desde el intérprete interactivo también puedes trabajar en lo que denomino modo mixto. Puedes cargar un programa externo:

>>>import mi_programa

y se ejecutará su contenido, tras lo cual podrás seguir interactuando desde el intérprete con los objetos de mi_programa.py ya cargados en memoria. Date cuenta de que no ha sido necesario escribir la extensión .py al ejecutar la instrucción import.

Más adelante, cuanto tratemos con más detalle el tema de los módulos en Python, presentaremos import formalmente.

Alternativamente, puedes ejecutar tu programa desde IDLE. Al finalizar su ejecución, la ventana Python Shell nos incita con su prompt a que sigamos interactuando con los objetos del programa, lo cual es muy interesante de cara a la depuración.

Todo lo bueno se acaba. Para abandonar el intérprete interactivo escribe:

>>> exit()

También podrías haber utilizado la función quit(), o incluso la combinación de teclas Ctrl-D (en Linux) o Ctrl-Z (Windows) seguido de Enter.

No puedo evitar recordar mis comienzos en el mundo de la programación, que fueron precisamente con otro lenguaje interpretado, BASIC, corriendo sobre una máquina asombrosa, el Spectrum de 48K.

Artesanía pura…

Javier Montero Gabarró

Fecha de la última revisión: 10 de enero de 2013

Python – Capítulo 16: El intérprete interactivo

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

El Club del Autodidacta

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

Etiqueta: python

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

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

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

Python – Capítulo 18: Creación de sublistas

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

Python – Capítulo 16: El intérprete interactivo

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

Tal vez te interese...

Uso de cookies