Esta es una lista no documentada de m茅todos que pueden ser usados con objetos Pattern.
Devuelve el patr贸n con su contenido en un orden aleatorio y n es el n煤mero de permutaciones:
# Una sola permutaci贸n de shuffle
print(P[0, 1, 2, 3].shuffle())
P[0, 3, 2, 1]
# Dos permutaciones
print(P[0, 1, 2, 3].shuffle(2))
P[3, 1, 2, 0, 2, 1, 3, 0]
Devuelve el patr贸n con su contenido en orden inverso. Los patrones / grupos anidados son *no* invertidos. Use Pattern.mirror para obtener ese comportamiento:
# Invierte el orden
P[0, 1, 2, 3].reverse()
P[3, 2, 1, 0]
# El patr贸n anidado no se invierte cuando se usa "reverse"
P[[0, 4], 3, 2, 1].reverse()
P[1, 2, 3, P[0, 4]]
# Usando mirror *does* reverse the nested patron
P[[0, 4], 3, 2, 1].mirror()
P[1, 2, 3, P[4, 0]]
Devuelve un patr贸n con su contenido en orden inverso, incluyendo patrones y grupos anidados:
# Invierte el orden
P[3, 2, 1, 0]
# Invertir patrones anidados y grupos
P[[0, 1], 2, 3, (4, 5)].mirror()
P[P(5, 4), 3, 2, P[1, 0]]
Devuelve un patr贸n con los valores ordenados. Los args y **kwargs son los que se suministran a la funci贸n ordenada integrada de Python pero esto devuelve un Patr贸n en lugar de una lista.
# Ordenar en orden ascendente
print(P[1, 3, 2, 0].sort())
P[0, 1, 2, 3]
# Ordenar por longitud del art铆culo
print(P[(1, 2), (3,), (4, 5, 6, 7), (8, 9, 10)].sort(key=lambda x: len(x)))
P[P(3), P(1, 2), P(8, 9, 10), P(4, 5, 6, 7)]
Devuelve un nuevo patr贸n con cada valor repetido n n煤mero de veces. Si n es un patr贸n en s铆 mismo, entonces cada valor se repite por el n煤mero en el mismo 铆ndice en el patr贸n dado.
# Tartamudean cada valor 3 veces
print(P[0, 1, 2, 3].stutter(3))
P[0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3]
# Tartamudea cada dos valores por dos
print(P[0, 1, 2, 3].stutter([1, 2]))
P[0, 1, 1, 2, 3, 3]
Devuelve un nuevo patr贸n con cada elemento repetido len(seq) veces e incrementado por los valores en seq. 脷til para arpegiar.
# Tartamudea de 2 en 2 y a帽ade 4 a cada segundo de valor.
print(P[0, 1, 2, 3].arp([0, 4]))
P[0, 4, 1, 5, 2, 6, 3, 7]
Toma uno o m谩s patrones para "empalmar" en el patr贸n original. El nuevo patr贸n devuelto se compone de los valores del original y de las secuencias dadas de forma alternada.
# Alternando entre dos secuencias
print(P[0, 1, 2, 3].splice([4, 5, 6, 7]))
P[0, 4, 1, 5, 2, 6, 3, 7]
# Alternando entre tres secuencias
print(P[0, 2, 4].splice([1, 3, 5],[6, 7, 8]))
P[0, 1, 6, 2, 3, 7, 4, 5, 8]
Crea una versi贸n invertida del patr贸n restando sus valores del valor m谩s grande del patr贸n, de modo que el valor m谩s grande del patr贸n se convierte en el m谩s peque帽o (y viceversa) y se intercambia la diferencia entre otros valores y el m铆nimo/m谩ximo:
print(P[2, 5, 1, 11].invert())
P[10, 7, 11, 1]
# Invertir una secuencia lineal lo invertir谩
print(P[0, 1, 2, 3].invert())
P[3, 2, 1, 0]
Devuelve un nuevo patr贸n que contiene el patr贸n original como un PGroup en orden aleatorio de longitud n.
print(P[0, 1, 2, 3].shufflets(3))
P[P(2, 3, 1, 0), P(3, 2, 0, 1), P(2, 1, 0, 3)]
Devuelve un nuevo patr贸n que es una versi贸n invertida del original pero girado de forma que el elemento en el 铆ndice i sigue estando en el mismo lugar.
# En un patr贸n de longitud 5, un pivote a 2 mantendr谩 el elemento del medio en el mismo lugar
print(P[5, 1, 6, 2, 3].pivot(2))
P[3, 2, 6, 1, 5]
Devuelve un patr贸n que es equivalente a la lista de sumas de ese patr贸n hasta ese 铆ndice (el primer valor es siempre 0). El argumento n especifica la longitud del nuevo patr贸n. Cuando n es Ninguno entonces el nuevo patr贸n toma la longitud del original.
#Acumulaci贸n de una serie de valores
print(P[1, 2, 3, 4].accum())
P[0, 1, 3, 6]
# El nuevo valor puede ser m谩s largo que el original
imprimir(P[1, 2, 3, 4].accum(8))
P[0, 1, 3, 6, 10, 11, 13, 16]
Devuelve un patr贸n que se repite hasta que la longitud es igual al tama帽o.
# Estira el patr贸n
print(P[1, 2, 3, 4].stretch(6))
P[1, 2, 3, 4, 1, 2]
El tama帽o puede ser menor que la longitud del original.
print(P[1, 2, 3, 4].stretch(3))
P[1, 2, 3]
Como estirar pero la longitud no puede exceder la longitud del patr贸n original.
# Recorta el patr贸n a la longitud 3
print(P[1, 2, 3, 4, 5].trim(3))
P[1, 2, 3]
# Se ignoran los valores de tama帽o mayores que la longitud
print(P[1, 2, 3, 4, 5].trim(10))
P[1, 2, 3, 4, 5]
Como recortar, pero elimina elementos del inicio del patr贸n, no del final.
print(P[1, 2, 3, 4, 5].ltrim(3))
P[3, 4, 5]
Repite el patr贸n n veces. 脷til cuando se encadenan m煤ltiples patrones. Los patrones anidados se tienen en cuenta cuando se realiza el bucle.
# Repite el patr贸n dos veces
print(P[0, 1, 2, 3].loop(2))
P[0, 1, 2, 3, 0, 1, 2, 3]
# Repite dos veces y encadena con otro patr贸n
print(P[0, 1, 2].loop(2) | P[7, 6])
P[0, 1, 2, 0, 1, 2, 7, 6]
# Looping with nested patterns expands the nests
print(P[0,[1, 2]].loop(2))
P[0, 1, 0, 2, 0, 1, 0, 2]
Como el bucle pero retiene los patrones anidados de tal manera que el primer valor en los nidos se utiliza en la primera iteraci贸n a trav茅s de la secuencia duplicada, etc.
#Mantenga los valores anidados al duplicar
print(P[0,[1, 2]].duplicate(2))
P[0, P[1, 2], 0, P[1, 2]]
Como el bucle, pero no tiene en cuenta los patrones anidados al calcular la longitud.
print(P[0,[1, 2]].iter(2))
P[0, 1, 0, 2]
Cambia los lugares de los valores en el patr贸n. Cuando n es 2 entonces los valores uno al lado del otro son intercambiados, cuando n es 3 entonces los valores siguientes pero 1 son intercambiados, y as铆 sucesivamente.
# Intercambiar valores uno al lado del otro
print(P[0, 1, 2, 3].swap(2))
P[1, 0, 3, 2]
# Intercambiar valores separados por un paso
print(P[0, 1, 2, 3, 4, 5].swap(3))
P[2, 1, 0, 5, 4, 3]
Devuelve un patr贸n con los valores del patr贸n original desplazados a la izquierda en orden por n n煤mero de lugares. Los n煤meros negativos desplazan los valores a la derecha.
#Gira a la izquierda a la 1
print(P[0, 1, 2, 3].rotate(1))
P[1, 2, 3, 0]
# Gira a la derecha por 1
print(P[0, 1, 2, 3].rotate(-1))
P[3, 0, 1, 2]
Devuelve un patr贸n de n-longitud con valores seleccionados aleatoriamente del patr贸n original. La n
print(P[0, 1, 2, 3].sample(3))
P[3, 2, 0]
A帽ade el reverso de un patr贸n sobre s铆 mismo de tal manera que crea un pal铆ndromo de n煤meros.
print(P[0, 1, 2, 3].palindrome())
P[0, 1, 2, 3, 3, 2, 1, 0]
Reemplaza el patr贸n con el de seq. Es 煤til si desea utilizar un patr贸n alternativo y asignarlo utilizando cada m茅todo.
# Reemplaza el patr贸n
print(P[0, 1, 2, 3].alt([4, 5]))
P[4, 5]
#脷til cuando se usa con un Reproductor
p1 >> pads([0, 1, 2, 3]).every(6, "alt", P[4, 5, 6, 7])
Devuelve un patr贸n con todos los valores normalizados de forma que cada valor del nuevo patr贸n est茅 entre 0 y 1.
print(P[0, 1, 2, 3].norm())
P[0.0, 0.3333333333333333, 0.6666666666666666, 1.0]
Elimina cualquier valor duplicado consecutivo para que no haya valores repetidos en el patr贸n.
print(P[0, 1, 1, 1, 1, 2, 2, 3].undup())
P[0, 1, 2, 3]
Devuelve un nuevo patr贸n generado a帽adiendo valores desde el original hasta que func(pattern) exceda el valor. El argumento func debe ser una funci贸n v谩lida, como len o suma.
# Crea un patr贸n cuya suma no sea mayor de 7
print(P[0, 1, 2, 3].limit(sum, 7))
P[0, 1, 2, 3, 0, 1]
Devuelve un nuevo patr贸n con valores iguales a sub reemplazado por repl.
#Sustituye los valores de 0 por 4
print(P[0, 1, 2, 3].replace(0, 4))
P[4, 1, 2, 3]
# Tambi茅n reemplaza valores en grupos y patrones anidados
print(P[0, (1, 0), 2,[3, 0]].replace(0, 4))
Similar a reemplazar pero requiere un diccionario de sub para replicar valores y reemplazar m煤ltiples 铆tems.
# Sustituir 0 por 4 y 1 por 5
print(P[0, 1, 2, 3].submap({0: 4, 1: 5}))
P[4, 5, 2, 3]
Tambi茅n funciona con valores anidados, etc.
print(P[0, (1, 0), 2,[3, 0]].submap({0: 4, 1: 5}))
P[4, P(5, 4), 2, P[3, 4]]
Cierra el patr贸n original con s铆 mismo pero con el m茅todo llamado en s铆 mismo, que debe ser un nombre de cadena de un m茅todo de patr贸n v谩lido (similar a Player.every). Sin embargo, el argumento del m茅todo tambi茅n puede ser una funci贸n (ejemplo a continuaci贸n).
# Patr贸n con cremallera con su reverso
print(P[0, 1, 2, 3].layer("reverse"))
P[P(0, 3), P(1, 2), P(2, 1), P(3, 0)]
# Patr贸n con cremallera con swap(2) llamado en 茅l
print(P[0, 1, 2, 3].layer("swap", 2))
P[P(0, 1), P(1, 0), P(2, 3), P(3, 2)]
# Zipped with a function multiplicando los valores por 2
print(P[0, 1, 2, 3].layer(lambda x: x + 2))
P[P(0, 2), P(1, 3), P(2, 4), P(3, 5)]
# Esto es equivalente a abajo:
print(P[0, 1, 2, 3].layer("__add__", 2))
P[P(0, 2), P(1, 3), P(2, 4), P(3, 5)]
Repite el patr贸n original n veces y aplica el m茅todo Patr贸n (especificado como una cadena) en la 煤ltima repetici贸n con los args y kwargs suministrados.
# Invierta el patr贸n en la tercera repetici贸n
print(P[0, 1, 2, 3].every(3, "mirror"))
P[0, 1, 2, 3, 0, 1, 2, 3, 3, 2, 1, 0]
Devuelve un nuevo Patr贸n con el argumento llamable llamado en cada 铆tem del patr贸n.
# Poner todos los n煤meros pares a 0
print(P[0, 1, 2, 3].map(lambda x: 0 if x % 2 == 0 else x))
P[0, 1, 0, 3]
Extiende el Patr贸n con la secuencia en su lugar, es decir, devuelve Ninguno a diferencia de un nuevo Patr贸n. Esto es m谩s eficiente que el m茅todo concat para combinar m煤ltiples secuencias en un Patr贸n.
pat = P[0, 1, 2, 3]
pat.extend([4, (5, 6), 7])
print(pat)
P[0, 1, 2, 3, 4, P(5, 6), 7]
Devuelve un nuevo Patr贸n con el contenido de seq a帽adido al final del Patr贸n original. El m茅todo especial __or__ (que usa la sintaxis |) tambi茅n llama a este m茅todo.
# Estas dos l铆neas son equivalentes
print(P[0, 1, 2, 3].concat([4, 5, 6]))
P[0, 1, 2, 3, 4, 5, 6]
print(P[0, 1, 2, 3] | [4, 5, 6])
P[0, 1, 2, 3, 4, 5, 6]
Esto es 煤til para combinar varios Patrones dentro de un objeto de Reproductor, pero no es una forma eficaz de crear Patrones grandes usando un bucle. Intenta ejecutar los dos bloques de c贸digo y ver la diferencia.
# esto no es eficiente
pat = P[0, 1, 2]
for n in range(20000):
pat = pat | [0, 1, 2]
print(pat)
# este es eficiente
pat = P[0, 1, 2]
for n in range(20000):
pat.extend([0,1,2])
print(pat)
El "Zipping" es el proceso de combinar dos secuencias en una en la que cada elemento es un grupo que contiene los elementos de cada secuencia en el mismo 铆ndice. Si las secuencias son de diferentes longitudes, entonces se comprimen hasta la longitud del m煤ltiplo com煤n m谩s bajo de ambas longitudes.
print(P[0, 1, 2, 3].zip([4, 5]))
P[P(0, 4), P(1, 5), P(2, 4), P(3, 5)
Agrega valor al Patr贸n, se cierra con el original, y retrasa el valor del cierre usando la clase PGroupPrime.
print(P[0, 1, 2, 3].offadd(2, 0.5))
P[P^(0, 2), P^(1, 3), P^(2, 4), P^(3, 5)]
Similar a offadd pero multiplica los valores en lugar de sumar.
print(P[0, 1, 2, 3].offmul(2, 0.5))
P[P^(0, 0), P^(1, 2), P^(2, 4), P^(3, 6)]
Similar a offadd y offmul pero utiliza un m茅todo o funci贸n especificado por el usuario en lugar de la adici贸n/multiplicaci贸n. El argumento method debe ser un nombre v谩lido de un m茅todo Pattern como cadena o un objeto llamable como una funci贸n. Cualquier argumento extra o argumento de palabra clave se proporciona despu茅s de la duraci贸n para retrasar la capa, por lo tanto, la duraci贸n debe ser suministrada si se suministran argumentos como parte de *args.
# Capa con el m茅todo "rotar" con valores por defecto
print(P[0, 1, 2, 3].offlayer("rotate"))
P[P^(0, 1), P^(1, 2), P^(2, 3), P^(3, 0)]
# Lo siguiente no es una capa con .rotate(2) sino con dur = 2
print(P[0, 1, 2, 3].offlayer("rotate", 2))
P[P^(0, 1), P^(1, 2), P^(2, 3), P^(3, 0)]
# Se debe especificar la duraci贸n para suministrar 2 para rotar
print(P[0, 1, 2, 3].offlayer("rotate", 0.5, 2))
P[P^(0, 2), P^(1, 3), P^(2, 0), P^(3, 1)
# Tambi茅n puede utilizar funciones en lugar de nombres de m茅todos
print(P[0, 1, 2, 3].offlayer(lambda x: (x * 2) + 1))
P[P^(0, 1), P^(1, 3), P^(2, 5), P^(3, 7)]
Replica el ritmo y el orden del famoso "amen break" basado en una secuencia de kick-drum, hi-hat, snare-drum, hi-hat. Escuche el siguiente ejemplo:
p1 >> play("x-o-").every(8, "amen")