Python: Iterando y modificando una lista

Objetivo: presentar técnicas de iteración sobre listas que permitan su modificación in-situ.

Comencemos planteando el siguiente problema: tenemos una lista de números y queremos modificarla de modo que almacene, en lugar del número en sí, su cuadrado.

No parece un problema complejo que no sepamos resolver con lo que ya conocemos:

lista = [1, 2, 3, 4, 5]

for elemento in lista:
    elemento = elemento * elemento
    print(elemento) # Una simple verificación

Si ahora observamos la salida:

>>> 
1
4
9
16
25

Aparenta todo haber ido de maravilla; sin embargo, nos encontramos con un pequeño detalle importante:

>>> lista
[1, 2, 3, 4, 5]

¡La lista no ha cambiado!

¿Cómo es posible? ¿Acaso no hemos comprobado como elemento, que ha pasado sucesivamente por todos y cada uno de los elementos de la lista, ha actualizado su valor a elemento * elemento?

Así es. Pero, lo que sucede, es que elemento no es más que una copia del valor original. Por muchos cambios que efectuemos sobre él no afectaran a la lista.

Necesitamos cambiar de estrategia.

Una forma de salvar el escollo sería reconstruir una lista temporal con los nuevos valores al cuadrado.

lista = [1, 2, 3, 4, 5]

lista_temp = []

for elemento in lista:
    elemento = elemento * elemento
    print(elemento)
    lista_temp.append(elemento)

La lista temporal, lista_temp es, en principio, una lista en blanco. Con cada iteración le agregamos el nuevo valor de elemento mediante el método append().

lista_temp ya tiene la solución buscada:

>>> lista
[1, 2, 3, 4, 5]
>>> lista_temp
[1, 4, 9, 16, 25]

Si lo necesitamos, podemos reasignar hacia dónde apunta lista:

>>> lista = lista_temp
>>> lista
[1, 4, 9, 16, 25]

En un nivel mayor de elegancia (en Python, la elegancia suele coincidir con el menor número de líneas de código), está la siguiente técnica: recorriendo el bucle for a través de el índice de la lista en vez de sus elementos. Es decir, como si fuera un bucle for típico de cualquier otro lenguaje de programación:

lista = [1, 2, 3, 4, 5]

for indice in range(len(lista)):
    lista[indice] = lista[indice] * lista[indice]
    print(lista[indice])

El resultado es el que esperamos:

>>> 
1
4
9
16
25
>>> lista
[1, 4, 9, 16, 25]

No solo la impresión es correcta, sino que la lista ha sido actualizada in-situ. Desde el bucle for, a través del índice, hemos podido acceder directamente a la lista, no a una copia de ella.

Apréndete bien esta técnica, pues es muy común. Itera sobre los elementos o los índices según tu necesidad concreta.

Date cuenta de que, para poder iterar a través de los índices, necesitamos conocer el número de elementos totales de la lista. Esto lo obtenemos con la expresión len(lista). Recuerda que la función len() nos devuelve el total de elementos de una secuencia. A continuación la función range() nos construye un iterable: range(len(lista)) facilitará al bucle for, sucesivamente, todos los valores enteros desde cero hasta uno menos que la longitud de la lista, precisamente el mismo rango que tienen sus índices.

Existe un nivel mayor de elegancia aún, las listas por comprensión, una de las construcciones más fascinantes y poderosas de Python. Son merecedoras de uno o varios artículos por separado, pero no me gustaría despedirme hoy sin que, al menos, y a modo de aperitivo, compruebes su potencia:

lista = [1, 2, 3, 4, 5]
lista = [elemento * elemento for elemento in lista]

Así de elegante:

>>> lista
[1, 4, 9, 16, 25]

Bienvenido a Python.

Javier Montero Gabarró


Python: Iterando y modificando una lista


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.

Construcción de acordes – 21: 7ma mayor con novena y oncena

Objetivo: aprender la fórmula del acorde de séptima mayor con novena y oncena.

Ya que sabemos extender los acordes hasta la novena, podemos proseguir agregando una tercera más, es decir, la oncena.

La 11ª, decimo primera u oncena es la misma nota que la cuarta (11 – 7 = 4), pero una octava más alta. Podemos encontrarla como extensión en dos sabores diferentes: la 11 y la #11 (equivalente a una cuarta justa o aumentada, respectivamente).

Se suele decir que si quieres extender con una oncena un acorde mayor, caracterizado por una tercera mayor, es mejor utilizar la #11 que la 11, para evitar así el fuerte conflicto entre la tercera y la cuarta, a un semitono de distancia.

Aunque realmente no hay un semitono entre 3ª y 11ª, sino un semitono más una octava, es cierto que existe una disonancia entre ambas notas que confunde la modalidad del acorde y que puede evitarse usando la #11 en lugar de la 11. Suele aceptarse más en un acorde de dominante, que también tiene una tercera mayor. Y es que los acordes de dominante se tragan casi todo manteniendo su función: el tritono caracteristico entre la 3 y la b7 da licencia para admitir lo que quieras echarle.

Pero en música los dogmas son ridículos y lo que es lícito o no es algo puramente subjetivo. Escucha ambos acordes, con 11 y con #11, y decide tú mismo si quieres tenerlos en tu repertorio. Ambos provocan sensaciones diferentes, ¿por qué deshacerte del más disonante? Como compositor, nunca digas no a ningún acorde, no mermes tu capacidad creativa.

De modo que hoy veremos al hermano feo, con la 11, y en la siguiente entrega nos ocuparemos de su versión con #11.

El título del artículo, tal como lo he escrito, indica sin ambigüedades la composición de este acorde:

1 – 3 – 5 – 7 – 9 – 11

Es un acorde mayor, con la séptima mayor, la novena mayor y la oncena justa. Puedes encontrarlo escrito de muchas maneras, como maj11 o maj9(11), pero la que te recomiendo es la que describe completamente su composición sin dejar lugar a dudas: maj7(9)(11) (puedes cambiar maj por M, si lo prefieres).

Un pianista no tiene problemas en hacer sonar tantas notas, pero a los guitarristas nos faltan cuerdas y dedos, por lo que solemos omitir algunas. Entre las favoritas están la 5ª, que ya sabes que puede desaparecer sin hacer apenas estragos, la 1ª (especialmente si un bajo se ocupa de hacerla sonar), la séptima (si fuera de dominante la respetaríamos, pero en un acorde mayor es más prescindible) o incluso la novena. Pero NO la tercera, aunque pueda resultar tentador hacerlo para evitar el conflicto con la 11. Normalmente las terceras solemos protegerlas para que el acorde no pierda su «sexo» (es decir, si es mayor o menor), pero, en este caso particular, si lo hiciéramos el acorde sería otro diferente: sus4(maj7)(9). Recuerda que un acorde sus4 es aquel en el que sustituimos la tercera por la cuarta (o la oncena, que es equivalente).

Como siempre, un par de ejemplos para ilustrar la composición de este acorde: Cmaj7(9)(11) y Amaj7(9)(11).

Las escalas mayores respectivas, extendidas hasta la 11ª son:

C --> C - D - E - F - G - A - B - C - D - E - F

A --> A - B - C# - D - E - F# - G# - A - B - C# - E

Tomando los grados de la fórmula, obtenemos:

Cmaj7(9)(11) --> C - E - G - B - D - F

Amaj7(9)(11) --> A - C# - E - G# - B - D

Adopta este acorde, interioriza su sonido algo turbio y úsalo con originalidad.

Javier Montero Gabarró


Construcción de acordes – 21: 7ma mayor con novena y oncena


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


El Club del Autodidacta


Índice de todos los artículos de armonía.

Productividad aleatoria ponderada en Python

Este artículo, que he clasificado en las categorías «Productividad» y «Python» es peculiar porque mata dos pájaros de un tiro: puede resultar útil tanto al lector interesado en lograr un mayor rendimiento como al estudiante de Python. Se explica una técnica de productividad y a continuación se muestra cómo automatizarla utilizando el lenguaje de programación Python.

En Productividad aleatoria describí un método al que recurro con frecuencia para estimular mi rendimiento al enfrentarme a un conjunto de tareas pendientes de índole diversa.

La esencia del método consiste en dejar que sea el azar el que decida cuál será la siguiente tarea a ejecutar. Esto supone los siguientes beneficios:

Evita perder tiempo decidiendo nuestra siguiente ocupación. ¿Eres capaz de evaluar cuánto tiempo malgastas mareando la perdiz a lo largo del día, decidiendo qué hacer? Calcúlalo y quizás te lleves una sorpresa.

– Dota de un componente lúdico a nuestro sistema de productividad, haciéndolo más divertido y motivante. Es un juego que se rige con reglas sencillas: la suerte está echada y nuestra misión consiste en ejecutar la tarea con eficacia y eficiencia, sin rechistar ni cuestionar si otra labor nos resulta más apetecible.

– Todas las tareas, las que nos gustan más y las que no tanto, están incluidas en el bombo de la fortuna. A menudo solemos postergar las menos atractivas, que probablemente son las más importantes, de modo que no encontramos nunca tiempo para hacerlas. El azar no entiende de preferencias personales y poco a poco irás liquidando todas esas tareas ingratas pero necesarias.

En el artículo sugerí un método sencillo para la gestión aleatoria de tareas que sólo precisaba de dos herramientas: un editor de texto plano y un generador de números aleatorios. Recordémoslo con algo más de detalle.

Como editor de texto sirve cualquiera que incluya numeración de líneas, como Notepad++ o gedit, entre muchísimos otros. Para la elección de un número al azar puedes utilizar el widget de random.org que figura en la esquina inferior izquierda de esta página.

La forma de operar es sencilla: una tarea en cada línea del fichero y que el generador de números aleatorios decida cúal elegimos entre el total de líneas existentes.

Por eso me he referido a un editor de texto plano en lugar de un procesador de textos. En un editor de texto plano no hay cambio de línea lógica hasta que no se pulsa ENTER. Aunque el programa divida la línea lógica en más líneas físicas, en el caso de que no quepa entera en el ancho de la ventana, el número de línea sigue siendo el mismo.

Obsérvalo en el siguiente ejemplo:

Las líneas 3 y 6 no caben enteras en el ancho de la ventana establecido, pero el número de línea se mantiene el mismo.

Una vez tenemos el listado de tareas candidatas sólo resta elegir una al azar. En nuestro ejemplo, habría que elegir un número entre 1 y 9:

Localizamos la línea 8 en el fichero y esa será nuestra próxima tarea a realizar: «Revisión y actualización de un artículo del blog con más de un año de antigüedad».

Podemos refinar el método introduciendo la gestión de prioridades. Sería deseable que las tareas más importantes, aquellas que nos hacen avanzar hacia nuestros principales objetivos, tuviesen más «papeletas» en el sorteo que las que menos contribuyen. Para lograr esto basta con repetir la tarea en la lista las veces que consideremos necesarias, aumentando así su peso específico y la probabilidad de que resulten elegidas.

Para ahorrar tiempo, en vez de repetir la tarea, agregaremos líneas en blanco debajo de ella (como cuando usamos pares de comillas bajo de un texto para indicar que es una repetición exacta de él). Basta con tener presente que una línea en blanco hace mención a la tarea encima de ella.

Obsérvalo en el ejemplo:

Hemos dejado un espacio en blanco después de la tarea 3 y dos después de la 8. Esto es lo mismo que si hubiéramos repetido la tarea en esos huecos, pero se tarda menos con una simple pulsación de ENTER. De este modo, estamos indicando que las tareas 3 y 8 tienen un peso específico de 2 y 3, respectivamente; es decir, la tarea 3 tiene dos veces más probabilidades de salir elegida que cualquier otra ordinaria, y la 8 tres veces más.

Si ahora la elección de la linea al azar recayera en una línea en blanco, como la 4, la tarea elegida sería la inmediatamente superior que estuviera ocupada, es decir, la 3: «Preparar un solo para Joe Ibuprofeno y transcribirlo en solfeo y tablatura con Guitar Pro».

Si no estás interesado en la programación en Python, puedes abandonar ya la lectura del artículo, pues lo que resta de él está dedicado a la creación de un pequeño programa que seleccione, entre todas las tareas definidas y ponderadas en el fichero tareas.txt, una al azar.

Nuestra labor será dotar de contenido al fichero, que el programa se ocupará de la elección automáticamente.

Mostraremos algunas técnicas nuevas no presentadas aún en el blog, como:

– Apertura un fichero de texto que emplea una codificación diferente a la del nativa del sistema operativo sobre el que corre el intérprete Python.

– Recuperación de una línea concreta de un fichero de texto.

– Comprobación de si una línea está en blanco o no.

Para la función aleatoria, necesitaremos importar el módulo random, en el que está definida la función randint(), que emplearemos para la elección de un número entero al azar.

import random

Lo primero que realiza el programa es recuperar todas las líneas del fichero de tareas y almacenarlas en una lista:

fichero = open('tareas.txt', encoding = 'utf-8')
tareas = fichero.readlines()
fichero.close()

La primera línea abre el fichero tareas.txt en modo texto y lectura, opciones por omisión cuando no se especifica nada más. Pero fíjate en la novedad, el parámetro encoding = 'utf-8'.

Python, cuando abre un fichero de texto, necesita saber cómo está codificado para poder interpretarlo correctamente. Si no decimos nada en la función open(), Python, por defecto, asume que está codificado en el modo nativo propio del sistema operativo en el que está corriendo el intérprete. Yo suelo emplear utf-8, una de las maneras de codificar caracteres Unicode, pero Python no tiene forma de saber que mi fichero está empleando ese formato salvo que se lo diga expresamente. El parámetro extra que hemos empleado en open() se ocupa de notificárselo.

Vemos en acción, a continuación, el método readlines() que, como sabemos, rellena una lista en la que cada elemento es una línea del fichero.

Esta es una técnica sencilla que debe figurar en tu repertorio para procesar ficheros de texto:

1) Abre el fichero en modo lectura.
2) Carga su contenido en una lista.
3) Cierra el fichero.
4) Procesa la lista con el contenido del fichero.
5) Abre el fichero en modo escritura (destruyendo el anterior).
6) Vuelca la lista procesada al fichero con el método writelines().
7) Cierra el fichero.

En este ejemplo no serán necesarios los tres pasos últimos, pues no vamos a modificar el fichero. Más adelante contruiremos otros programas sencillos que requerirán las siete etapas.

Una advertencia importante: esta técnica no es más que eso, una técnica. Existen otras formas de trabajar con ficheros de texto, como veremos, que serán más adecuadas que esta en determinadas ocasiones. La presentada aquí tiene una limitación: todo el contenido del fichero se vuelca en memoria. Si la memoria de la que dispone Python es inferior al tamaño del fichero el programa no funcionará.

No uses este método para ficheros muy grandes. En estos casos es preferible que la recuperación del archivo se realice en bloques controlados, liberando la memoria cada vez que se cargue un nuevo bloque tras su proceso.

Cerramos el fichero tan pronto hemos terminado con él. No necesitaremos acceder nuevamente a él.

Para elegir un número de línea al azar, primero debemos saber cuántas líneas hay. Como cada elemento de la lista contiene una única línea, el total de elementos será el total de líneas:

len(tareas)

Hay que elegir una de ellas: la primera en la lista tiene por índice cero, por lo que la última tendrá por índice el total de elementos de la lista menos 1:

len(tareas) - 1

Para elegir un entero al azar entre cero y len(tareas) – 1, usamos la función randint() indicando esos extremos como parámetros:

random.randint(0, len(tareas) - 1)

Recuperamos, entonces, el elemento de la lista que tiene ese índice elegido al azar:

tarea_aleatoria = tareas[random.randint(0, len(tareas) - 1)]

Esa sería la línea buscada, si no fuera porque podría suceder que se tratara de una línea en blanco. En ese caso, habría que buscar la inmediatamente superior que no lo esté.

Pero, ¿qué caracteriza una línea en blanco?

El único contenido que tiene una línea en blanco es el cambio de línea \n. Con esto, el siguiente bucle while comprueba que la línea no esté en blanco y, si lo está, trata de recuperar el elemento anterior hasta que encuentre una línea que no lo esté:

while tarea_aleatoria == '\n':
    tarea_aleatoria = tareas[random.randint(0, len(tareas) - 1) - 1]

Una vez localizada, la imprimimos y misión cumplida:

print(tarea_aleatoria)

Te dejo el código completo del programa:

# Productividad aleatoria ponderada

import random

fichero = open('tareas.txt', encoding = 'utf-8')
tareas = fichero.readlines()
fichero.close()

tarea_aleatoria = tareas[random.randint(0, len(tareas) - 1)]

while tarea_aleatoria == '\n':
    tarea_aleatoria = tareas[random.randint(0, len(tareas) - 1) - 1]

print(tarea_aleatoria)

Javier Montero Gabarró


http://elclubdelautodidacta.es/wp/2012/11/productividad-aleatoria-ponderada-en-python/


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


El Club del Autodidacta


Índice completo de los artículos de la categoría Productividad.


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

Python: Los operadores lógicos y sus tablas de verdad

Objetivo: presentar los operadores lógicos de Python e ilustrar el uso de bucles for anidados para mostrar sus tablas de verdad.

Aunque ya hay una amplia colección de artículos dedicados a Python, debemos admitir que hay bastantes elementos del lenguaje que aún no han sido presentados en familia. Es el caso, por ejemplo, de los operadores lógicos, de los que nos ocuparemos hoy. Mostraremos los distintos tipos y dejaremos que Python construya las respectivas tablas de verdad, ejemplo que nos servirá, a su vez, para ilustrar la anidación de un bucle for dentro de otro.

Con toda certeza que te has cruzado alguna vez en tu vida con los operadores lógicos o, como también se los conoce, booleanos. No tengo intención de darte una clase de álgebra booleana, de modo que nos centraremos directamente en su representación en Python.

Los tres operadores lógicos básicos son O, Y y NO, representados en Python por or, and y not, respectivamente.

Podemos incluir también el O EXCLUSIVO, que es verdadero cuando uno y solo uno de los operandos lo es, pero estrictamente debes saber que se deriva a partir de los tres básicos. Su representación es ^, el sombrero o caret.

Como ejercicio práctico, vamos a realizar un programa que construya las tablas de verdad correspondientes.

booleanos = [False, True]

# Tabla de verdad de or

print('x\ty\tx or y')
print('-'*22)
for x in booleanos:
    for y in booleanos:
        print(x, y, x or y, sep = '\t')

print()

# Tabla de verdad de and

print('x\ty\tx and y')
print('-'*22)
for x in booleanos:
    for y in booleanos:
        print(x, y, x and y, sep = '\t')
        
print()

# Tabla de verdad de not

print('x\tnot x')
print('-'*13)
for x in booleanos:
    print(x, not x, sep = '\t')

print()

# Tabla de verdad de ^

print('x\ty\tx ^ y')
print('-'*21)
for x in booleanos:
    for y in booleanos:
        print(x, y, x ^ y, sep = '\t') 

No te preocupes si algo no te queda claro en el código, en breve lo explicaremos. Antes quiero que observes el resultado final:

Las tablas de verdad hablan por sí solas:

– El resultado de or es verdadero cuando cualquiera de los operandos lo es.
– El resultado de and es verdadero solo cuando ambos operandos lo es.
– El operador not invierte el valor del operando.
– La o exclusiva, ^, es cierta cuando uno y solo uno de los operandos lo es.

El programa no debe de suponerte ningún misterio:

Comenzamos creando una lista con los dos posibles valores booleanos, False y True, que utilizaremos para iterar sobre ellos:

booleanos = [False, True]

Observa que no hemos rodeado los elementos entre comillas, pues no son strings.

A continuación imprimimos los títulos para la operación or:

print('x\ty\tx or y')
print('-'*22)

Los \t en la primera línea no son más que tabuladores. La extraña operación de la segunda, multiplicando un string por un número, no hace más que repetir 22 veces el carácter ‘-‘.

El quid de la cuestión recae en la doble iteración usando el bucle for:

for x in booleanos:
    for y in booleanos:
        print(x, y, x or y, sep = '\t')

La variable x recorrerá la lista booleanos, tomando en la primera iteración el valor False y en la siguiente True. Pero, por cada iteración, aparece una nueva variable y que también recorrerá booleanos de izquierda a derecha. Así garantizamos que se alcanzan las cuatro combinaciones posibles de x e y.

En la impresión con print, hemos empleado el argumento sep = ‘t’ para que separe cada elemento mediante un tabulador, en lugar de usar un espacio en blanco, valor por omisión. Aprecia el uso de la expresión x or y para que muestre el resultado del or.

El resto de las tablas se calcula del mismo modo, simplemente teniendo en cuenta que hay que emplear, naturalmente, la expresión lógica adecuada.

Debes saber que los operadores lógicos de Python son del tipo cortocircuitados, término que quizás te resulte familiar si conoces otros lenguajes de programación. Esto significa que, si a partir del primer operando ya se puede deducir el resultado final, Python ni se molestará en evaluar el segundo, con el consiguiente ahorro de tiempo.

En un or, si el primer operando es verdadero, sabemos que el resultado lo será ya, por lo que no es necesario que Python se moleste en comprobar la veracidad del segundo.

Del mismo modo, en un and, si el primer operando es falso, el resultado inmediatamente lo será y tampoco será necesario saber lo que ocurre con el segundo.

Para finalizar, una pequeña advertencia: es un error común confundir los operadores lógicos (or y and) con los operadores de unión e intersección de conjuntos (| y &). No te equivoques.

Javier Montero Gabarró


Python: Los operadores lógicos y sus tablas de verdad


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.

Acordes en la guitarra: habilidades necesarias

Objetivo: indicar los conocimientos y habilidades necesarias para el correcto estudio de acordes en la guitarra.

A lo largo de esta serie vamos a mostrar cientos de acordes; si me apuras, te diría que incluso más de un millar. Pero lo haremos matando muchos pájaros de un tiro cada vez que presentemos uno: a partir de una simple posición razonaremos un buen puñado de acordes, del mismo modo que indicaremos técnicas que te ayudarán a deducirlos y recordarlos.

Hay ciertas habilidades básicas que debes manejar al dedillo:

LA FÓRMULA DE CADA ACORDE

Cada acorde tiene una fórmula que es imprescindible que conozcas. No necesitas hacer un curso previo de armonía si estás empezando ahora a construir acordes en la guitarra, es algo que podrás ir aprendiendo sobre la marcha. Pero cuando te muestre una posición, por ejemplo de un acorde de séptima, debes tener bien claro que su fórmula es:

1 – 3 – 5 – b7

Todos los acordes de séptima tienen esa fórmula.

Si necesitas unas bases teóricas para entender las fórmulas de los acordes, puedo sugerirte la serie dedicada a su construcción que figura en este mismo blog.

Existe también una tabla de referencia, con información sintetizada, a la que puedes remitirte si tienes dudas sobre un acorde concreto. Es una tabla dinámica, en el sentido de que va creciendo conforme voy agregando nuevos acordes a la colección.

LA FÓRMULA DEL ACORDE EN CADA POSICIÓN

No basta con saber la fórmula, debes ser capaz de verla dentro de cada posición.

Por ejemplo, considera el siguiente acorde, correspondiente a un A7 (La séptima):

Es una posición típica construida con una cejilla en el quinto traste (los números indican la digitación sugerida).

Además de saber que un acorde de séptima tiene por fórmula 1 - 3 - 5 - b7 es importante que sepas que, en esa disposición o voicing particular, estos grados se encuentran, de izquierda a derecha, distribuidos del siguiente modo:

1 – 5 – b7 – 3 – 5 – 1

Adquiere la habilidad, cuando toques un acorde, de tener perfectamente localizado cada grado que lo constituye. Cuando improvises sobre una progresión terminarás viendo perfectamente la relación de cada nota sobre el acorde que subyace.

LAS NOTAS DE CADA ACORDE

Muchas veces los guitarristas se quedan en la fórmula. La entienden, pero desconocen qué notas están sonando realmente en cada acorde.

Esta es una suerte de pereza guitarrística. Nos lo ponen tan fácil con estructuras visuales que, en cierto modo, atrofiamos nuestro sentido auditivo. Esto, que a mi juicio es un gran error, no le sucede a los pianistas. Acostúmbrate a poner nombre a cada nota que toques y lograrás una sinestesia auditiva-visual que te hará mejor músico integral.

En la propia serie de construcción de acordes se incluyen ejemplos sobre cálculos concretos de notas. Asegúrate de entenderlos.

Sobre cada disposición, aplica siempre una doble visión. En el ejemplo del A7 anterior dijimos que los grados del acorde estaban dispuestos así:

1 – 5 – b7 – 3 – 5 – 1

Pero además, ten muy claras las notas que se corresponden en la realidad para este acorde en concreto:

A – E – G – C# – E – A

Doy por supuesto que sabes localizar cualquier nota en el mástil de la guitarra. En caso contrario, tal vez la lectura del artículo al que apunta el enlace pueda resultarte de utilidad.

LA MECÁNICA DE CADA ACORDE

Una vez conocido el acorde hay que plasmarlo en realidad y ser capaz de construirlo en la guitarra. Es una cuestión puramente mecánica que se logra con la práctica. Con perseverancia los dedos irán adquiriendo memoria y terminarán asentándose sobre la nota adecuada sin apenas intervención consciente.

En artículos futuros propondré una serie de ejercicios de utilidad para facilitar este tipo de trabajo.

¿LISTO PARA COMENZAR?

Cada acorde que presentemos aparecerá acompañado, además de por un gráfico, por su fórmula, sus notas y la disposición de estas en el gráfico. No obstante, haz los deberes previos sugeridos aquí para poder sacar el máximo provecho a cada posición, de modo que puedas incorporar cada acorde a tu repertorio en el menor tiempo posible.

Javier Montero Gabarró


Acordes en la guitarra: habilidades necesarias


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


El Club del Autodidacta


Índice de la categoría Guitarra.

Índice de la categoría Armonía.

Python: MAYÚSCULAS, minúsculas y ViCeVeRsA

Objetivo: presentar los métodos que ofrece Python para la gestión de mayúsculas y minúsculas en strings.

Entre nuestro repertorio de técnicas pythonistas no pueden faltar las dedicadas al tratamiento de cadenas de caracteres. Es raro el programa que no las utiliza, de modo que cuanto antes las conozcas mejor será para ti. Hoy hablaremos de un subconjunto de ellas especializadas en el trasiego de letras mayúsculas y minúsculas.

Un problema común cuando un programa recibe texto es su normalización para poder realizar después un tratamiento correcto. Por ejemplo, imagínate que estás requiriendo el DNI del usuario. Tu programa debe ser capaz de reconocer que dos DNI con los mismos números y la misma letra final son realmente el mismo, se escriba la letra en mayúsculas o minúsculas.

Juguemos un rato con el intérprete interactivo. Consideremos, por ejemplo, la siguiente cadena de texto:

>>> a = 'La casa de la Pradera'

Para hacer que un string contenga sólo letras minúsculas disponemos del método lower():

>>> a.lower()
'la casa de la pradera'

Esto crea una copia del objeto con minúsculas. Recuerda que los strings son inmutables y los métodos que se apliquen sobre ellos nunca modificarán el objeto original. Si no tienes muy claro el misterio de la inmutabilidad en Python, te recomiendo que leas el artículo al que apunta el enlace.

La operación contraria, la conversión a mayúsculas, se obtiene mediante el método upper():

>>> a.upper()
'LA CASA DE LA PRADERA'

El método capitalize() devuelve un string en el que solo la primera letra estará escrita en mayúsculas:

>>> a.capitalize()
'La casa de la pradera'

Aunque pueda resultar extravagante, a veces es necesaria la inversión de tipos: lo que está en mayúsculas pasarlo a minúsculas, y viceversa. El método swapcase() resuelve el problema:

>>> a.swapcase()
'lA CASA DE LA pRADERA'

El método title() escribe en mayúsculas solo la primera letra de cada palabra, como en los títulos:

<code>>>> a.title()
'La Casa De La Pradera'

Para otro tipo de conversiones será necesario recurrir a algo más de código. Considera el siguiente problema: dada una palabra cualquiera, transformarla para que el tercer carácter esté escrito en letras mayúsculas.

Supongamos, por ejemplo, la siguiente cadena de caracteres:

>>> a = 'pradera'

Pretendemos que el tercer carácter esté en mayúsculas.

Este intento de conversión fallará debido a la inmutabilidad de los strings, que no permiten la modificación in-situ:

>>> a[2] = a[2].upper()   # El tercer carácter tiene por índice 2
Traceback (most recent call last):
  File "<pyshell#26>", line 1, in <module>
    a[2] = a[2].upper()   # El tercer carácter tiene por índice 2
TypeError: 'str' object does not support item assignment

Para resolver el problema podemos recurrir a la creación de substrings mediante la técnica de slicing, que hemos utilizado ya en diversas ocasiones:

>>> a = a[:2] + a[2].upper() + a[3:]
>>> a
'prAdera'

El primer término de la concatenación contiene una copia de a desde el primer elemento (índice cero) hasta el tercero (índice 2) sin incluir. El segundo es una copia del tercer carácter de a. Finalmente, el último contiene lo restante de la cadena, es decir, desde el cuarto elemento (índice 3) hasta el final.

Actividad propuesta: construye una función que acepte como parámetros un string y un número y devuelva un string, con el carácter correspondiente al índice, facilitado por el número, en mayúsculas.

Para finalizar, es útil saber si un string está escrito completamente en letras minúsculas o en mayúsculas. Para ello disponemos de los métodos islower() e isupper(), respectivamente.

>>> a = 'pradera'
>>> a.islower()
True
>>> b = 'PIMiENTO'
>>> b.isupper()
False

El método islower() devuelve True cuando todas las letras están en minúsculas y al menos hay un carácter alfabético. Esto otro, por ejemplo, resultaría False, al no existir ninguna letra en el string:

>>> c = ':;..'
>>> c.islower()
False

En cambio, esto sería True:

>>> d = ':;.a'
>>> d.islower()
True

Lo mismo es aplicable a isupper(): devuelve True cuando todas las letras están en mayúsculas y al menos hay una letra en la cadena.

Son muchos los métodos de los que dipone el objeto string y es tu deber conocerlos. Agruparlos en pequeños bloques, como hemos hoy, facilita su aprendizaje.

Javier Montero Gabarró


Python: MAYÚSCULAS, minúsculas y ViCeVeRsA


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.

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