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