Saltar a contenido

Forma de uso🔗

La construcción de patrones de acordes se realiza utilizando la clase __chord__.

Importe el módulo FoxDotChord:

import FoxDotChord

Esto inyectará en el namespace de nombres del ejecutor la instancia de c utilizada para manipular los acordes.

También puedes hacer: from FoxDotChord import c

Progresiones de acordes🔗

Los acordes se pueden pasar en el mismo objeto y se pueden utilizar de las siguientes maneras:

  • [] con string separada por espacio 
    c['B# Cb E# Fb']
  • () con string separada por espacio 
    c('B# Cb E# Fb')
  • [] con lista de strings 
    c['B#', 'Cb', 'E#', 'Fb']
  • () con lita de strings 
    c('B#', 'Cb', 'E#', 'Fb')

Acordes mayores (C)🔗

La creación de acordes mayores se realiza pasando el cifrado de acorde.

  • Acorde de Do mayor 
    c['C']

Todos los cifrados válidos son:

Natural Bemoles Sostenidos
A Ab A#
B Bb B#
C Cb C#
D Db D#
E Eb E#
F Fb F#
G Gb G#

Acordes menores (Cm)🔗

La creación de acordes menores se realiza pasando la letra m después del cifrado del acorde.

  • Acorde de Do menor 
    c['Cm']

Acordes disminuidos (C⁰)🔗

La creación de acordes disminuidos se realiza pasando el símbolo ⁰ después del número del acorde. Tradicionalmente, la abreviatura dim también se puede utilizar después del cifrado. La biblioteca también permite otras formas de definir acordes disminuidos.

  • ⁰ 
    c['C⁰']
  • dim 
    c['Cdim']
  • o - letra minúscula o 
    c['Co']
  • O - letra mayúscula O 
    c['CO']
  • 0 - cero 
    c['C0']

Acordes suspendidos (Csus4)🔗

Se pueden crear acordes con tercera suspendida con los siguientes acordes:

  • sus - segunda mayor suspendido 
    c['Csus']
c['Csus2']
  • sus4 - cuarta justa suspendida 
    c['Csus4']
c['Csus3+']
c['Csus3#']

Acordes con extensión (Cm7/9b/11#)🔗

Los acordes, tanto mayores como menores, pueden contener la extensión de un determinado intervalo. Para extender el acorde con más de un intervalo, sepárelos con /, por ejemplo, Cm7M/9.

Los rangos aceptados son los siguientes.

2 - segunda maior🔗

  • mayor 
    c['C2']
  • menor 
    c['Cm2']

4 - cuarta justa🔗

  • mayor 
    c['C4']
  • menor 
    c['Cm4']

5 - power chord🔗

  • 5 - power chord 
    c['C5']

5- | 5+ - quinta🔗

  • quinta disminuida

    c['C5-']
c['C5b']

    c['Cm5-']
c['Cm5b']

  • quinta aumentada

    c['C5+']
c['C5#']

    c['Cm5+']
c['Cm5b#]

6 - sexta mayor🔗

  • mayor 
    c['C6']
  • menor 
    c['Cm6']

7 - séptimo🔗

  • 7 - séptimo menor

    c['C7']

    c['Cm7']

  • 7M - séptimo mayor

    c['C7M']
c['C7Maj']
c['C7maj']

    c['Cm7M']
c['Cm7Maj']
c['Cm7maj']

9 - nona🔗

  • 9 - nona menor

    c['C9-']
c['C9b']

    c['Cm9-']
c['Cm9b']

  • 9 - nona aumentada

    c['C9+']
c['C9#']

    c['Cm9+']
c['Cm9#']

  • 9 - nona

    c['C9']

    c['Cm9']

11 - undécimo🔗

  • 11 - undécimo disminuida

    c['C11-']
c['C11b']

    c['Cm11-']
c['Cm11b']

  • 11 - undécimo aumentada

    c['C11+']
c['C11#']

    c['Cm11+']
c['Cm11#']

  • 11 - undécimo

    c['C11']

    c['Cm11']

13 - decimotercero🔗

  • 13 - decimotercero disminuida

    c['C13-']
c['C13b']

    c['Cm13-']
c['Cm13b']

  • 13 - decimotercero aumentada

    c['C13+']
c['C13#']

    c['Cm13+']
c['Cm13#']

  • 13 - decimotercero

    c['C13']

    c['Cm13']

Arpegios🔗

Los arpegios se pueden crear directamente definiendo los acordes colocando una @ al final del mismo, por ejemplo:

  • Arpegio con @ 

    c['C@']

  • Arpegio en un solo acorde en una secuencia 

    c['C@ G']

También es posible utilizar el método .arp() para arpegiar todos los acordes de la secuencia.

  • Método .arp() 
    c['C G'].arp()

El método .arp() puede recibir una lista de enteros. Esto tendrá el mismo comportamiento que el método .arp(seq) de los Patterns renardo o los Patterns FoxDot si los está utilizando.

  • Método .arp(seq) 
    c['C G'].arp([0, 3])

Repetición🔗

Puede utilizar la sintaxis !N para representar que un acorde determinado debe repetirse N veces, donde N es el número de veces que debe sonar ese acorde.

  • Repitiendo los acordes con !

    c['C!4 Dm!2 G7!2']

    var(c['C Dm G7'], [4, 2, 2])

    Toca el primero 4 veces y los otros 2 veces

  • Repetindo os arpegios (@) usando !

    c['C!4 Dm!2 G7!2@']

    var(c['C Dm G7@'], [4, 2, 2, 2, 2, 2])

    Tocarás cada nota del arpa dos veces

  • Repetir (!) el acorde y arpegiar (@) lo que se duplicó

    c['C!4 Dm!2 G7!2@']

    var(c['C Dm G7@ G7@'], [4, 2, 2, 2, 2, 2, 2, 2, 2, 2])

    Duplicará el acorde y arpegiará los duplicados.

Atención

Cuando se utiliza al menos un ! con un valor mayor que 1, el objeto devuelto será un var.

Por lo tanto, algunos métodos como .arp() dejarán de existir.

Padrões de Strings🔗

También es posible utilizar patrones anidados dentro de las strings, como en el sintetizador play().

  • Secuencia simple ()

    >>> c['(D7 Cm)']
P[Chord('D7'), Chord('Cm')]

  • En el mismo ritmo []

    >>> c['[D7 Cm]']
P[P*(Chord('D7'), Chord('Cm'))]

  • Aleatorio {}

    >>> c['{D7 Cm}']
P[PRand(P[Chord('D7'), Chord('Cm')])]

  • Secuencias de capas <><>

    >>> c['<D7><Cm>']
P[P(Chord('D7'), Chord('Cm'))]