✒️Sintaxis

Información general sobre sintaxis

La sintaxis puede utilizarse en las siguientes ranuras:

• Text: Expresión y Expresión con Estructura de Control se pueden utilizar en el campo Lista de Texto

• Attachment: Las expresiones y las expresiones con estructura de control pueden utilizarse en los campos Fuente y Leyenda.

• Slot Filling: Expresión y Expresión con Estructura de Control pueden utilizarse en el campo Pregunta

• button:La expresión puede utilizarse en el campo Etiqueta

• condition: La expresión puede utilizarse en el campo Condición

• Timer: La expresión puede utilizarse en el campo If

• Memory: Expresión y Expresión con Estructura de Control se pueden utilizar en el campo Clave de contexto

• External Request: Las expresiones y expresiones con estructura de control pueden utilizarse en URL, campos de valor en las pestañas Cabeceras y Parámetros de consulta, campo Datos, campo Nombre en la pestaña Respuesta.

• Incoming Request Slot: Expresión y Expresión con Estructura de Control se pueden utilizar en el campo Valor

• Synonym Slot: Las expresiones y las expresiones con estructura de control pueden utilizarse en el campo Fuente.

La sintaxis de la plataforma utiliza la sintaxis del motor de plantillas Jinja: https://jinja.palletsprojects.com/en/3.0.x/templates/Templates en sintaxis se dividen en 2 conceptos:

1. Expresión. Entre llaves dobles.

2. https://jinja.palletsprojects.com/en/3.0.x/templates/#expressions Ejemplos:

   1. {{ client_message }}

   2. {{ number * 10 }}

   3. {{ chat_id == ‘abcde0123456789’ }}

   4. {{ uuid4() }}

   5. {{ some_variable is defined }}

3. Expresión con estructura de control. Entre llaves con el símbolo %. https://jinja.palletsprojects.com/en/3.0.x/templates/#list-of-control-structures

Ejemplos:

a. {% if client_message == ‘hello’ %}Hi{% else %}Bye{% endif %}

b. {% for number in [1, 2, 3] %}{{ number }}{% endfor %}

Tipos de datos admitidos

Tipo de datos	Memoria	Ejemplos de salida en una ranura de texto	Nota
Strings	{{ 'string' }}{{ "string" }}Empty string: {{ '' }} or {{ "" }}	cadena La cadena vacía se muestra como sin valor	Si una cadena está entre comillas dobles y hay un carácter de comillas dobles dentro de la cadena como signo de puntuación, el carácter de comillas dentro de la cadena debe escaparse con el carácter \ para pasar la Validación de Script y mostrarse correctamente. Ejemplo: **Si una cadena está entre comillas simples y hay un carácter de comilla simple dentro de la cadena como signo de puntuación, el carácter de comilla dentro de la cadena debe escaparse con el carácter \ para pasar la validación de secuencias de comandos y mostrarse correctamente. Ejemplo: **En los casos en que una cadena esté entre comillas dobles y haya un carácter de comilla simple dentro de la cadena, o si una cadena está entre comillas simples y hay un carácter de comilla doble dentro de la cadena, no es necesario escapar.
Numbers	{{ 5 }}{{ 42.23 }}	**5**42.23
Booleans	{{ true }}{{ false }}	TrueFalse
Null values	{{ None }}	Aparece como sin valor
Objects	{{ {"one": 1, "two": 2, "colors": ["red", "green", "blue"]} }}	**{"one": 1, "two": 2, "colors": ["red", "green", "blue"]}**	Los métodos reservados de los objetos están disponibles en la Plataforma
Arrays	Numbers: [1, 2, 3, 4, 5]Strings: ["one", "two", "three"]Arrays: [["one", "two", "three"], ["cat", "dog", "bird"], ["green", "blue", "red"]]	**[1, 2, 3, 4, 5]** **["one", "two", "three"]** **[['one', 'two', 'three'], ['cat', 'dog', 'bird'], ['green', 'blue', 'red']]**	Para acceder a los elementos de una matriz se utiliza un punto (.) Para acceder al número correspondiente de un elemento de la matriz se utilizan números. La numeración de los elementos de una matriz comienza en cero, por lo que el acceso al primer elemento de una matriz se indica como 0. Ejemplos: **{{ array.0 }}**
Dates	Convertir datos a formato de fecha sólo es posible con el filtro string_to_time Ejemplo: {{ "2000-06-15 18:50:47" | string_to_time("%Y-%m-%d %H:%M:%S") }} More details: Deleted Row	2000-06-15 18:50:47	La zona horaria no está almacenada

Métodos reservados de los objetos

Nombre	Disponibilidadon the Platform	Significado	Cómo utilizarlo	Ejemplo
artículos	Sí	Devuelve los pares clave-valor de un diccionario.	{{ data.items() }}	{{ data.items() | list }} Resultado: [('a', 1), ('b', 2)]
llaves	Sí	Reconvierte las claves del diccionario	{{ data.keys() }}	{{ data.keys() | list }} Resultado: ['a', 'b']
valores	Sí	Devuelve los valores del diccionario	{{ data.values() }}	{{ data.values() | list }} Resultado: [1, 2]
borrar	No
copia	No
de llaves	No
consiga	No
pop	No
elemento pop	No
predeterminado	No
actualización	No

Importante: al analizar una ranura de solicitud entrante, una respuesta a una solicitud externa o una notificación, el acceso a la clave del objeto, si su nombre coincide con el nombre de los métodos reservados de los objetos, se produce mediante corchetes y comillas. Ejemplo: {{ datos["claves"] }}

Expresiones

Literales

Operador	Designación	Área de aplicación	Cómo utilizarlo	Example
Línea	"string"	Declaración de cadenas Declaración de una cadena vacía	Declaración de cadenas Línea en blanco {{ '' }} o{{ "" }} Línea no vacía {{ 'str' }} o{{ "str" }} Acceso al carácter de cadena sstr == {{ 'string' }}{{ str[0] }} = s{{ str[1] }} = t...Line slicestr == {{ 'string' }}{{ str[:2] }} = st{{ str[2:] }} = ring{{ str[2:5] }} = rin	{{ 'Hola Mundo' }} Resultado: Hola Mundo. {{ "Hola Mundo" }} Resultado: Hola Mundo. {{ 'Hola Mundo'[1] }} Resultado: e. {{ 'Hola Mundo'[:5] }} Resultado: Hola. {{ 'Hola Mundo'[5:] }} Resultado: Mundial.
Entero	42 123_456	Declaración de un número entero	{{ num }}	{{ 123 }} Result: 123. {{ 1_2_3 }} Result: 123.
Número con un punto	42.23 42.1e2 123_456.789	Declarar un número real	{{ num }}	{{ 42.23 }} Result: 42.23. {{ 42.1e2 }} Result: 4210.0. {{ 4_2.23 }} Result: 42.23.
Listas	['lista', 'o', 'objetos']	Declarar una lista con tipos de objeto arbitrarios Acceso a un elemento de una lista	Declarar una lista Lista vacía {{ [] }} Lista de números {{ [num1, num2, ...] }} Lista de cadenas {{ ['str1','str2', ...] }}{{ ["str1","str2", ...] }} Acceso a los elementos de la lista list = {{ [A, B, ...] }}{{ list[0] }} = A{{ list[1] }} = B...	{{ [1, 2, 3] }} Resultado: [1, 2, 3]. {{ ['uno", "dos"]. }} Resultado: [uno", "dos"]. {{ ['uno", "dos"]. }}[0] Resultado: uno.
Diccionarios	{'dict": "o", "clave": "y", "valor": "pares}	Declaración del diccionario Acceso a un elemento de un diccionario	Declaración de diccionario{{ { clave1:val1, clave2:val2, ... } }}Acceso al diccionario Itemsdict = {{ { clave1:val1, clave2:val2, ... } }}{{ dict[key1] }} = val1{{ dict[key2] }} = val2...	{{ {1:'A', 2:'B', 3:'C'} }} Resultado: {1: 'A', 2: 'B', 3: 'C'}. {{ {1:'A', 2:'B', 3:'C'}[1] }} Resultado: A. {{ {'uno": "A", "dos": "B", "tres": "C} }} Resultado: {uno": "A", "dos": "B", "tres": "C"}. {{ {uno": "A", "dos": "B", "tres": "C"}['tres'] }} Resultado: C.
Matrices	{{ [{'id': 3, 'name': 'O'}, {'id': 1, 'name': 'E'}, {'id': 2, 'name': 'S'}] }}	Declaración de una matriz de datos Acceso a un elemento de una matriz	Declaración de Array{{ [{'id': id1, 'valor': val1 }, {'id': id2, 'valor': val2 }, ...] }}Acceso a Elementos de Arrayarray = {{ [{'id': id1, 'valor': val1 }, {'id': id2, 'valor': val2 }, ...] }}{{ array[0] }} = {'id': id1, 'valor': val1 }...	{{ [{'id': 3, 'nombre': 'O'}, {'id': 1, 'nombre': 'E'}, {'id': 2, 'nombre': 'S'}] }} Resultado: [{'id': 3, 'nombre': 'O'}, {'id': 1, 'nombre': 'E'}, {'id': 2, 'nombre': 'S'}]. {{ [{'id': 3, 'nombre': 'O'}, {'id': 1, 'nombre': 'E'}, {'id': 2, 'nombre': 'S'}] [0] }} Resultado: {'id': 3, 'nombre': 'O'}.
Valores booleanos	true false	Expresiones y variables booleanas	{{ true }} {{ false }}	{{ А == true }} Resultado: Verdadero si la variable booleana A es verdadera. {{ (A == B) == true }} Resultado: Verdadero si la expresión (A == B) es verdadera.

Expresiones matemáticas

Operador	Designación	Área de aplicación	Cómo utilizarlo	Ejemplo
Adición	+	Suma de números enteros y reales Concatenación de cadenas Combinar elementos de una matriz en una sola matriz	{{ num1 + num2 + ... }} {{ 'str1' + 'str2' + ... }} {{ "str1" + "str2" + ... }} {{ mas1 + mas2 + ... }}	{{ 1 + 2 + 3 }} Resultado: 6. {{ 'a' + 'b' + 'c' }} Resultado: abc. {{ 0.5 + 1.5 }} Resultado: 2.0. {{ [0,1,2] + [3,4,5] }} Resultado: [0, 1, 2, 3, 4, 5].
Resta	-	Restar números enteros y reales	{{ num1 - num2 - num3 - ... }}	{{ 4 - 2 - 1 }} Resultado: 1. {{ 0.5 - 1.5 }} Resultado: -1.0.
Division	/	División de números enteros y reales	{{ num1 / num2 / num3 / ... }}	{{ 1 / 2 }} Resultado: 0.5. {{ -1.5 / 0.5 }} Resultado: -3.0. {{ 6 / 3 / 2 }} Resultado: 1.0.
División que devolverá sólo la parte entera del resultado	//	División de números enteros y realesRestricciones: El operador // devuelve un número entero sólo cuando divide números enteros. Si uno de los operandos es un número real, el resultado también será un número real.	{{ num1 // num2 // num3 // ... }}	{{ 6 // 3 // 2 }} Resultado: 1. {{ 1.5 // 0.5 }} Resultado: 3.0.
Calcular el resto de la división	%	Cálculo del resto de la división de números enteros y reales	{{ num1 % num2 }}	{{ 6 % 4 }} Resultado: 2. {{ 1.5 % 0.5 }} Resultado: 0.0.
Multiplicación	*	Multiplicación de números enteros y reales	{{ num1 * num2 * num3 * ... }}	{{ -1.5 * -0.5 }} Resultado: 0.75. {{ -2 * 3 * 4 }} Resultado: -24.

Restricciones:

• El número máximo (módulo) que puede utilizarse en operaciones aritméticas es 4294967296. Si utiliza números grandes, se producirá un error (Falso se almacenará en memoria como una variable, por ejemplo).

• Si añades cadenas/arreglos, la longitud máxima permitida de una cadena/arreglo es 1000. Al intentar añadir/concatenar cadenas/arreglos que producen resultados de más de 1000 caracteres, se escribe el valor "No se permite la adición de objetos con una longitud superior a 1000" en la Variable de contexto de error.

• Para concatenar cadenas/ matrices que produzcan resultados de más de 1000 caracteres, puede utilizar la notación {{ cadena_1 }}{{ cadena_2 }}.

Operaciones de comparación

Operador	Tipo	Designation	Área de aplicación	Cómo utilizarlo	Ejemplo
Pruebas de igualdad	Operaciones de comparación	==	Cualquier variable y valor de contexto	{{ A == B }}	{{ A == B }} Resultado: Verdadero si la variable A es igual a la variable B. {{ A == 1 }} Resultado: Verdadero si la variable A es 1. {{ A == 'uno' }} Resultado: Verdadero si la variable A es igual a 'uno'.
Pruebas de desigualdad	Operaciones de comparación	!=	Cualquier variable y valor de contexto	{{ A != B }}	{{ A != B }} Resultado: Verdadero si la variable A no es igual a la variable B. {{ A != 1 }} Resultado: Verdadero si la variable A no es igual a 1. {{ A != 'uno' }} Resultado: Verdadero si la variable A no es igual a 'uno'.
Comprobación de que el primer operando es mayor que el segundo	Operaciones de comparación	>	Variables numéricas y números	{{ A > B }}	{{ A > B }} Resultado: Verdadero si la variable A es mayor que la variable B. {{ A > 1 }} Resultado: True if variable A is greater than 1.
Comprobación de que el primer operando es mayor o igual que el segundo	Operaciones de comparación	>=	Variables numéricas y números	{{ A >= B }}	{{ A >= B }} Resultado: Verdadero si la variable A es mayor o igual que la variable B. {{ A >= 1 }} Resultado: Verdadero si la variable A es mayor o igual que 1.
Comprobación de que el primer operando es menor que el segundo	Operaciones de comparación	<	Variables numéricas y números	{{ A < B }}	{{ A < B }} Resultado: True si la variable A es menor que la variable B. {{ A < 1 }} Resultado: Verdadero si la variable A es menor que 1.
Comprobación de que el primer operando es menor o igual que el segundo	Operaciones de comparación	<=	Variables numéricas y números	{{ A <= B }}	{{ A <= B }} Resultado: Verdadero si la variable A es menor o igual que la variable B. {{ A <= 1 }} Resultado: Verdadero si la variable A es menor o igual que 1.

Operaciones lógicas

Operador	Designación	Área de aplicación	Cómo utilizarlo	Ejemplo
AND	and	Expresiones y variables booleanas	{{ A and B }}	{{ A and B }} Resultado: Verdadero si ambas variables booleanas A y B son verdaderas.
OR	or	Expresiones y variables booleanas	{{ A or B }}	{{ A or B }} Resultado: Verdadero si una de las variables booleanas A y B son verdaderas.
NOT	not	Expresiones y variables booleanas	{{ not A }}	{{ not A }} Resultado: Verdadero si la variable booleana A es falsa. {{ not A == 1 }} Rresultado: Falso si la variable A es 1.
Paréntesis para agrupar expresiones	(expr)	Expresiones y variables booleanas	{{ (A) }}	{{ (A > 0) and (A < 10) }} Resultado: Verdadero si la variable A es mayor que 0 y menor que 10.

Otras operaciones

Operador	Designación	Área de aplicación	Cómo utilizarlo	Ejemplo
Encontrar el primer operando en el segundo	in	Variables y expresiones contextuales	Línea {{ 's' in 'str' }} Lista de números {{ num in [num1,num2,...] }} Lista de cadenas {{ 'str' in ['str1','str2',...] }} Diccionario {{ key in { key1:val1, key2:val2, ... } }}	{{ 'A' in 'ABC' }} Resultado: Verdadero. {{ 1 in [1,2,3] }} Resultado: Verdadero. {{ 'ABC' in ['ABC','DEF','GHI'] }} Resultado: Verdadero. {{ 1 in {1: 'A', 2: 'B', 3: 'C'} }} Resultado: Verdadero.
Comprobación de un operando para una propiedad	is	Pruebas	{{ A is B }}	Descrito en la tabla: Pruebas
Aplica un filtro a un operando	|	Filtros	{{ A|B }}	Descrito en la tabla: Filtros sintácticos
Convertir operandos en cadenas y concatenarlos	~	Variables de contexto y cadenas	{{ "string" ~ var }} {{ var ~ "string" }}	{{ "Hola " ~ nombre ~ "!" }}Resultado: ¡Hola John! (si la variable nombre contiene el valor Juan).
Obtener el atributo de un objeto	. / []	Cualquier variable de contexto	{{ A.B }} {{ A['B'] }}	{{ ['A','B','C'].0 }} Resultado: A. {{{'uno': 'A', 'dos': 'B', 'tres': 'C'}['dos'] }} Resultado: B.

Test

Prueba	Designación	Cómo utilizarlo	Ejemplo
Comprobación de la existencia de una variable en el contexto	definido	{{ A se define }}	{{ A está definido }}, A existe Resultado: Verdadero. {{ A está definido }}, A no existe Resultado: Falso.
Comprobación de que una variable no existe en el contexto	indefinido	{{ A no está definido}}	{{ A no está definido }}, A existe Resultado: Falso. {{ A no está definido}}, A no existe Resultado: Verdadero.
Comprobación de expresiones regulares	match	{{ A es igual ... }}	{{ A es igual("[expresión_regular]") }} Resultado: Verdadero si A coincide con la expresión regular; False si A NO coincide con la expresión regular; False si A no tiene formato de cadena; Falso si la expresión regular está escrita incorrectamente. Importante: la comprobación distingue entre mayúsculas y minúsculas.
Comprobar que un objeto es un número	número	{{ A es número}}	{{ 5 es número }} Resultado: Verdadero. {{ cinco' es número }} Resultado: Falso.
Comprobar que un objeto es un número par	incluso	{{ A es igualmente}}	{{ 22 es igualmente}} Resultado: Verdadero. {{ 11 es igualmente }} Resultado: Falso.
Comprobar que un objeto es un número impar	Impar	{{ A es impar }}	{{ 46 es impar }} Resultado: Falso. {{ 15 es impar}} Resultado: Verdadero.
Comprobación de que un objeto es un entero	entero	{{ A es entero}}	{{ 1012 es entero }} Resultado: Verdadero. {{ 10.12 es entero }} Resultado: Falso.
Comprobación de que un objeto es un número real	decimal	{{ A es decimal }}	{{ 3.55 es decimal }} Resultado: Verdadero. {{ 35 es decimal }} Resultado: Falso.
Comprobar que un objeto es divisible por un número	divisible por	{{ A es divisiblepor(B) }}Importante: Si A = Verdadero y B = 1, entonces se devolverá Verdadero, ya que Verdadero es 1, y 1 es divisible por 1. Si A = False, entonces se devolverá True, ya que False es 0, y 0 es divisible por cualquier número (excepto 0).	{{ 4 es divisiblepor(2) }} Resultado: Verdadero. {{ 6 es divisiblepor(5) }} Resultado: Falso. {{ 5 es divisiblepor(0) }} Resultado: Falso. {{ true es divisiblepor(1) }} Resultado: Verdadero. {{ false es divisiblepor(10) }} Resultado: Verdadero.
Comprobación de que un objeto es una cadena	cadena	{{ A es una cadena}}	{{ 'uno' es una cadena }} Resultado: Verdadero. {{ 1 es una cadena }} Resultado: Falso.
Comprobación de que una cadena está en minúsculas	inferior	{{ A es inferior}}	{{ 'hello' es inferior }} Resultado: Verdadero. {{ 'Hello' es inferior }} Resultado: Falso. {{ 'HELLO' es inferior }} Resultado: Falso.
Comprobación de que una cadena está en mayúsculas	superior	{{ A es superior }}	{{ 'BYE' es superior }} Resultado: Verdadero. {{ 'Bye' es superior }} Resultado: Falso. {{ 'bye' es superior }} Resultado: Falso.
Comprobación de que un objeto es un diccionario	cartografía	{{ A es la cartografía}}	{{ {1:'A', 2:'B', 3:'C'} es la cartografía }} Resultado: Verdadero. {{ [1, 2, 3] es la cartografía }} Resultado: Falso.
Comprobación de que un objeto es una secuencia (cadena, lista o diccionario)	secuencia	{{ A es la secuencia}}	{{ '12345' es la secuencia }} Resultado: Verdadero.e. {{ [1, 2, 3] es la secuencia }} Resultado: Verdadero. {{ {1:'A', 2:'B', 3:'C'} es la secuencia }} Resultado: Verdadero. {{ 12345 es la secuencia }} Resultado: Falso.
Comprobación de que un objeto es un booleano	booleano	{{ A es booleano}}	{{ A es booleano }}, A = true Resultado: Verdadero. {{ A es booleano }}, A = 4 Resultado: Falso.
Comprobar que un objeto es verdadero	verdadero	{{ A es verdadero}}	{{ A es verdadero }}, A = true Resultado: Verdadero. {{ A es verdadero }}, A = 1 Resultado: Falso.
Comprobar que un objeto es falso	falso	{{ A es falso}}	{{ A es falso }}, A = false Resultado: Verdadero. {{ A es falso }}, A = 2 Resultado: Falso.
Comprobación de que un objeto no tiene valor (el valor es None o Null (convertido a None durante el análisis sintáctico ER))	ninguno	{{ A es ninguno}}	{{ A es ninguno }}, A = none Resultado: Verdadero. {{ A es ninguno }}, A = '' Resultado: Falso.
Prueba de igualdad (equivalente al operador ==)	eq	{{ A es eq B }}	{{ 123 es eq 123 }} Resultado: Verdadero. {{ 'abc' es eq 'ABC' }} Resultado: Falso. {{ 456 es eq '456' }} Resultado: Falso.
Comprobación de la desigualdad (equivalente al operador !=)	ne	{{ A es ne B }}	{{ 123 es ne 124 }} Resultado: Verdadero. {{ 'D' es ne 'D' }} Resultado: Falso.
Comprobación de que el primer operando es mayor que el segundo (equivalente al operador >)	gt	{{A es gt B }}	{{ 5 es gt 3 }} Resultado: Verdadero. {{ (-1.12) es gt 1.13 }} Resultado: Falso. {{ '5a' es gt '33' }} Resultado: Verdadero. {{ '222' es gt '33' }} Resultado: Falso.
Comprobación de que el primer operando es mayor o igual que el segundo (equivalente al operador >=)	ge	{{A es ge B }}	{{ 12.12 es ge 12.1199 }} Resultado: Verdadero. {{ 15 es ge 15 }} Resultado: Verdadero. {{ 0 es ge (-15) }} Resultado: Falso.
Comprobación de que el primer operando es menor que el segundo (equivalente al operador <)	lt	{{ A es lt B }}	{{ 0.001 es lt 1 }} Resultado: Verdadero. {{ (-1) es lt (-1.5) }} Resultado: Falso.
Comprobación de que el primer operando es menor o igual que el segundo (equivalente al operador <=)	le	{{ A es le B }}	{{ 21 es le 22 }} Resultado: Verdadero. {{ (-1.11) es le (-1.11) }} Resultado: Verdadero. {{ (1) es le (-12) }} Resultado: Falso.
Encontrar el primer operando en el segundo	in	{{ A en B }}	Descrito aquí: Encontrar el primer operando en el segundo

Filtro Sintax

Filtros	Designación	Cómo utilizarlo	Ejemplo
Añadir un valor por defecto	por defecto	{{ A|por defecto(B) }} El valor B sólo se utilizará si la variable A no se encuentra en el contexto. {{ A|por defecto(B,true) }} El valor B se utilizará en los casos en que la variable A no se encuentre en el contexto o si la variable A se convierte a False (0, cadena vacía, matriz vacía, lista vacía).	{{ A|por defecto('A no está definido') }}, A = 1 Resultado: 1. {{ A|por defecto('A no está definido') }}, A no existe Resultado: A no está definido. {{ A|por defecto('A está vacío', true) }}, A = '' Resultado: A está vacío. {{ A|por defecto('A no está definido', true) }}, A no existeResultado: A no está definido.
Convertir a entero	int	{{ A|int }}	{{ 2.53|int }} Resultado: 2. {{ '-15'|int }} Resultado: -15. {{ '12abc'|int }} Resultado: 0.
Convertir a número real	float	{{ A|float }}	{{ 2|float }} Resultado: 2.0. {{ '-122'|float }} Resultado: -122.0. {{ '1a'|float }} Resultado: 0.0.
Obtener el valor absoluto de un número	abs	{{ A|abs }}Limitaciones: Funciona sólo con números enteros y reales.	{{ -1|abs }} Resultado: 1. {{ -0.1111|abs }} Resultado: 0.1111.
Redondear un número	redondo	{{ A|redondo }} Redondeo a la parte entera más próxima. {{ A|redondo(B, C) }} B - número de decimales.C - tipo de redondeo:común - redondeo hacia arriba o hacia abajo.ceil - redondeo hacia arriba.floor - redondeo hacia abajo.	{{ 42.12345|redondo }} Resultado: 42.0. {{ -1.538675|redondo(3,'common') }} Resultado: -1.539. {{ 0.5712|redondo(2, 'ceil') }} Resultado: 0.58. {{ 121.67354|redondo(3, 'floor') }} Resultado: 121.673. {{ 0.11111|redondo|int }} Resultado: 0.
Convertir a cadena	cadena	{{ A|cadena }}	{{ 12345|cadena }} Resultado: 12345. {{ [1,2,3,4,5]|cadena }} Resultado: [1, 2, 3, 4, 5] (toda la lista es una cadena). {{ {1: 'A', 2: 'B', 3: 'C'}|cadena }} Resultado: {1: 'A', 2: 'B', 3: 'C'} (todo el diccionario es una cadena).
Convertir en lista	lista	{{ A|lista }}	{{ 'abcdefg'|lista }} Resultado: ['a', 'b', 'c', 'd', 'e', 'f', 'g']. {{ {'one': 'A', 'two': 'B', 'three': 'C'}|lista }} Resultado: ['one', 'two', 'three']. {{ 12345|lista }} Resultado: Falso.
Convertir a minúsculas	inferior	{{ A|inferior }}	{{ 'AbcDefg'|inferior }} Resultado: abcdefg. {{ ['A','B','C']|inferior }} Resultado: ['a', 'b', 'c']. {{ {'one': 'A', 'two': 'B', 'three': 'C'}|inferior}} Resultado: {'one': 'a', 'two': 'b', 'three': 'c'}.
Convertir a mayúsculas	superior	{{ A|superior }}	{{ 'AbcDefg'|superior}} Resultado: ABCDEFG. {{ ['a','b','c']|superior }} Resultado:['A', 'B', 'C']. {{ {'one': 'a', 'two': 'b', 'three': 'c'}|superior }} Resultado:{'ONE': 'A', 'TWO': 'B', 'THREE': 'C'}.
Conversión a mayúsculas de la primera letra de una cadena	capitalizar	{{ A|capitalizar }}Limitaciones: Sólo funciona con cadenas.	{{ 'abc'|capitalizar }} Resultado: Abc.
Convertir a mayúsculas (es decir, las palabras empezarán por mayúsculas, el resto de caracteres irán en minúsculas).	título	{{ A|titulo }}Importante: los elementos de lista y diccionario se convierten a minúsculas.	{{ 'hello'|titulo }} Resultado: Hello. {{ 'hELLO'|titulo }} Resultado: Hello. {{ {'one': 'A', 'two': 'B', 'three': 'C'}|titulo }} Resultado: {'one': 'a', 'two': 'b', 'three': 'c'}.
Primer elemento de una secuencia (cadena, lista o diccionario)	primero	{{ A|primero }}	{{ '12345'|primero }} Resultado: 1. {{ [1, 2, 3]|primero }} Resultado: 1. {{ {1:'A', 2:'B', 3:'C'}|primero }} Resultado: 1. {{ 12345|primero }} Resultado: False.
Último elemento de una secuencia (cadena, lista o diccionario)	último	{{ A|último }}	{{ '12345'|ultimo }} Resultado: 5. {{ [1, 2, 3]|ultimo }} Resultado: 3. {{ {1:'A', 2:'B', 3:'C'}|ultimo }} Resultado: 3. {{ 12345|ultimo }} Resultado: False.
Número de elementos de una secuencia (cadena, lista o diccionario)	longitud	{{ A|longitud }}	{{ 'abcdefg'|longitud }} Resultado: 7. {{ [1, 2, 3]|longitud }} Resultado: 3. {{ {1:'A'}|longitud }} Resultado: 1. {{ 111|longitud }} Resultado: False.
Suma de los elementos de la secuencia	suma	{{ A|suma }}Importante: si la secuencia está vacía, se devuelve 0.	{{ [1,2,3,4,5]|suma }} Resultado: 15. {{ {1: 'A', 2: 'B', 3: 'C'}|suma }} Resultado: 6. {{ ''|suma }} Resultado: 0.
Obtener el valor del elemento más pequeño de una secuencia	min	{{ A|min }}	{{ [1, 0.001, -1]|min }} Resultado: -1. {{ ['1', '0.001', '-1']|min }} Resultado: -1. {{ ['b', 'f', 'a']|min }} Resultado: a. {{ {'1': 'A', '2': 'B', '3': 'C'}|min }} Resultado: 1.
Obtener el mayor valor de elemento de una secuencia	max	{{ A|max }}	{{ [1, 0.001, -1]|max }} Resultado: 1. {{ ['1', '0.001', '-1']|max }} Resultado: 1. {{ ['b', 'f', 'a']|max }} Resultado: f. {{ {'1': 'A', '2': 'B', '3': 'C'}|max }} Resultado: 3.
Obtener un elemento aleatorio	al azar	{{ A|al azar }}Limitaciones: Sólo funciona con listas y matrices.	{{ [-22, 4.110263, 353, 124]|al azar }} Resultado: 4.110263. {{ ['-22', '4.110263', '353', '124']|al azar }} Resultado: -22. {{ ['apple', 'orange', 'banana']|al azar }} Resultado: banana.
Sustitución de un elemento secuencial	sustituir	{{ A|sustituir }}	{{ "Hello World"|sustituir("Hello", "Goodbye") }} Resultado: Goodbye World. {{ ['A','B','C']|sustituir('A', 'D') }} Resultado: ['D', 'B', 'C'].
Replacement of a sequential element	invertir	{{ A|invertir }}Importante: Para invertir una lista o diccionario, debe añadir |list para convertir el resultado en una lista, de lo contrario la variable estará vacía.	{{ 'abcdefg'|invertir }} Resultado: gfedcba. {{ '12345'|invertir }} Resultado: 54321. {{ ['a', 'b', 'c']|invertir|lista }} Resultado: ['c', 'b', 'a']. {{ {'1': 'A', '2': 'B', '3': 'C'}|invertir|lista }} Resultado: ['3', '2', '1'].
Añadir un separador de elementos de secuencia (cadena, lista o diccionario)	union	{{ A|union }} {{ A|union(B) }}	{{ '123'|union(',') }} Resultado: (1, 2, 3). {{ [1, 2, 3]|union }} Resultado: 123. {{ {'one': 'A', 'two': 'B', 'three': 'C'}|union('!') }} Resultado: one!two!three. {{ {1:'A', 2:'B', 3:'C'}.values()|union(", ") }} Resultado: A, B, C. {{ {1:'A', 2:'B', 3:'C'}.keys()|union("!")|lista }} Resultado: ['1', '!', '2', '!', '3'].
Convertir una secuencia en una lista única	unico	{{ A|unico|lista }}Limitaciones: sólo funciona con la adición de |list.	{{ 'abcab'|unico|lista }} Resultado: gfedcba. {{ '12345'|invertir }} Resultado: 54321. {{ ['a', 'b', 'c']|invertir|lista }} Resultado: ['c', 'b', 'a']. {{ {'1': 'A', '2': 'B', '3': 'C'}|invertir|lista }} Resultado: ['3', '2', '1'].
Ordenar una secuencia	sort	{{ A|sort }} {{ A|sort(r, c, a) }} r(reverse) - ordena en orden descendente, no ascendente.c(case_sensitive) - ordena mayúsculas y minúsculas por separado.a(attribute) - valor o clave a ordenar.	{{ [1,4,3,2,5]|sort }} Resultado: [1, 2, 3, 4, 5]. {{ ['b','a','c']|sort(reverse=true) }} Resultado: ['c', 'b', 'a']. {{ [{'id': 3, 'name': 'O'}, {'id': 1, 'name': 'E'}, {'id': 2, 'name': 'S'}]|sort(attribute='name') }} Resultado: [{'id': 1, 'name': 'E'}, {'id': 3, 'name': 'O'}, {'id': 2, 'name': 'S'}]. {{ {4: 'c', 2: 'a', 3: 'b', 1:'d'}.values()|sort }} Resultado: ['a', 'b', 'c', 'd']. {{ {4: 'c', 2: 'a', 3: 'b', 1:'d'}.keys()|sort }} Resultado: [1, 2, 3, 4].
Ordenar un diccionario por clave o valor	dictsort	{{ A|dictsort }} {{ A|dictsort(by='key' }} {{ A|dictsort(by='value' }} Importante: Por defecto, el diccionario se convierte en una cadena.	{% for key, value in {"c": 1, "a": 4, "b": 2, "d": 3}|dictsort %} {{ key }}: {{ value }} {% endfor %} Resultado: aaa: 4 b: 2 c: 1 d: 3. {% for key, value in {"c": 1, "a": 4, "b": 2, "d": 3}|dictsort(by="key") %} {{ key }}: {{ value }} {% endfor %} Resultado: a: 4 b: 2 c: 1 d: 3. {{ {4: 'c', 2: 'a', 3: 'b', 1:'d'}|dictsort(by='value')|list }} Resultado: [(2, 'a'), (3, 'b'), (4, 'c'), (1, 'd')].
Filtrar por atributo	mapa	{{ A|mapa(attribute='B')|mapa(attribute='C'|...|lista }}Importante: si el objeto es una matriz, el resultado debe convertirse en una lista.	{{ [{'name': 'Anna', 'number': '123'}, {'name': 'Olga', 'number': '456'}, {'name': 'Evgeniya', 'number': '789'}]| mapa(attribute='name')|list }} Resultado: ['Anna', 'Olga', 'Evgeniya'].
Agrupación por número de elementos en un bucle	lote	{{ A|lote(l) }} {{ A|lote(l, f) }} l(linecount) - el número de grupos en los que se dividirá el objeto.f(fill_with) - el valor que se utiliza para rellenar los elementos que faltan.	{% for row in ['A','B','C']|lote(5, 'D') %}{{ row }}{% endfor %} Resultado: ['A', 'B', 'C', 'D', 'D']. {% for row in [1, 2, 3, 4]|lote(2) %} {% for i in row %}{{ i }}{% endfor %}{% endfor %}Resultado:1234.
Convertir en una lista de listas	corte	{{ A|corte(s) }} {{ A|corte(s, f) }} s(slices) - el número de listas en las que se dividirá el objeto.f(fill_with) - el valor que se utiliza para rellenar los elementos que faltan.	{{ [1, 2, 3, 4, 5]|corte(2)|lista }} Resultado: [[1, 2, 3], [4, 5]]. {{ 'abc'|corte(5, 'd')|lista }} Resultado: [['a'], ['b'], ['c'], ['d'], ['d']].
Agrupar por atributo	agruparpor	{{ A|agruparpor(a) }} {{ A|agruparpor(a, d) }} a(atributo) - atributo.d(por defecto) - valor por defecto utilizado si un objeto de la lista no tiene este atributo.	items = [ {"name": "james", "type": "green"}, {"name": "john", "type": "blue"}, {"name": "jim", "type": "blue"}, {"name": "jessie", "type": "green"} ] {% for type, items in items|groupby('type') %}{{ type }}:{% for item in items %}{{ item.name }} {% endfor %}{% endfor %} Resultado: blue: john jim green: james jessie.
Eliminación de los elementos de la secuencia que no coinciden con la prueba	seleccion	{{ A|seleccion(B,C)|lista }}B -de la tabla PruebasC es el argumento que se pasa a la prueba B.	{{ [1, 2, 3, 4, 5]|seleccion('odd')|list }} Resultado: [1, 3, 5] (нечетные числа). {{ [1, 2, 3, 4, 5]|seleccion('gt', 3)|list }} Resultado: [4, 5] (числа, которые больше 3).
Eliminación de elementos de secuencia que no coinciden con una prueba de atributo	selectattr	{{ A|selectattr(B,C,D)|lista }}B es el atributo que hay que extraer de la secuencia.C - prueba de la tabla PruebasD es el argumento que se pasa a la prueba C.	users = [ {"name": "james", "email": "[e-mail]", "password": "123"}, {"name": "john", "email": "[e-mail]"}, {"name": "jim", "email": "[e-mail]"}, {"name": "jessie", "email": "[e-mail]", "password": "123"} ] . {{ users|selectattr('password','undefined')| map(attribute='email')|list }}{{ email }}Result: ['[e-mail]', '[e-mail]']. table = [['685697115', 'evpolyntseva', 'Новосибирск'], ['658795243', 'Iourigaha', 'Москва'], ['683128920', 'jarondara', 'Казань'], ['630685929', 'blarar', 'Москва']] . {{ table_all|selectattr(2, 'eq', "Москва")|map(attribute=1)|list }}Result: ['Iourigaha', 'blarar'].
Eliminación de elementos de la secuencia que coinciden con una prueba	reject	{{ A|reject(B,C)|list }}B -de la tabla PruebasC es el argumento que se pasa a la prueba B.	{{ [1, 2, 3, 4, 5]|reject('odd')|list }} Resultado: [2, 4] (не нечетные числа). {{ [1, 2, 3, 4, 5]|reject('gt', 3)|list }} Resultado: [1, 2, 3] (числа, которые не больше 3).
Eliminación de elementos de secuencia que coinciden con una prueba por atributo	rejectattr	{{ A|rejectattr(B)|list }}B es el atributo que hay que extraer de la secuencia.C - test de la tabla TestsD es el argumento que se pasa al test C.	table = [['685697115', 'evpolyntseva', 'Новосибирск'], ['658795243', 'Iourigaha', 'Москва'], ['683128920', 'jarondara', 'Казань'], ['630685929', 'blarar', 'Москва']] . {{ table|selectattr(2, 'eq', "Москва")|map(attribute=1)|list }}Resultado: ['evpolyntseva', 'jarondara'].
Eliminar caracteres al principio y al final de una línea	trim	{{ A|trim }} {{ A|trim(c) }} c(chars) -el carácter o cadena que se eliminará. Por defecto es el espacio.	{{ ' a '|trim }} Resultado: a. {{ 'bbbсbb'|trim('b') }} Resultado: c.
Truncado de cadenas	truncar	{{ A|truncar(len) }} {{ A|truncar(len,k,e,l) }} len(length) - Longitud de la cadena truncada. Por defecto es 255.k(killwords) - Verdadero o Falso. Se especifica True si necesita recortar la cadena por longitud, False si necesita descartar la última palabra recortada.e(end) - signo en el punto de truncado. Por defecto es elipsis.l(leeway) - límite del exceso de longitud.	{{ 'foo bar baz qux'|truncar(9) }} Resultado: foo... . {{ 'foo bar baz qux'|truncar(9, True) }} Resultado: foo ba... . {{ 'foo bar baz qux'|truncar(11, False, '', 0) }} Resultado: foo bar.
Recuento de palabras	recuento de palabras	{{ A|recuento de palabras }}	{{ 'Hello World!'|recuento de palabras}} Resultado: 2. {{ ['a a a','b','c']|recuento de palabras }} Resultado: 5. {{ {'one': 'a', 'two': 'b b b', 'three': 'c'}|recuento de palabras }} Resultado: 8.
Formatear un número al tamaño del archivo	formato de archivo	{{ A|formato de archivo }}	{{ 100000 | formato de archivo }} Resultado: 100.0 kB. {{ 25000000 | formato de archivo }} Resultado: 25.0 MB.
URL encoding	urlencode	{{ A|urlencode }}Importante: sólo funciona con cadenas y diccionarios.	{{ 'привет'|urlencode }} Resultado: %D0%BF%D1%80%D0%B8%D0%B2%D0%B5%D1%82. {{ {"aaa": "привет", "bbb": 1}|urlencode }} Resultado: aaa=%D0%BF%D1%80%D0%B8%D0%B2%D0%B5%D1%82&bbb=1.
Convertir una cadena en una fecha	cadena_a_tiempo	{{ "2000-06-15 18:50:47" | cadena_a_tiempo("%Y-%m-%d %H:%M:%S") }}Después de cadena_a_tiempo, se indica entre paréntesis el formato de fecha requerido. Más información: https://docs.python.org/3/library/datetime.html?highlight=datetime#strftime-and-strptime-format-codes	{{ "2000-06-15 18:50:47" | cadena_a_tiempo("%Y-%m-%d %H:%M:%S") }} Resultado: 2000-06-15 18:50:47 (data type — date)
Convertir una fecha en una cadena	hora_a_cadena	{{ "2000-06-15 18:50:47" | hora_a_cadena("%Y-%m-%d %H:%M:%S") }} Después de time_to_string, se indica entre paréntesis el formato de fecha requerido. Más información: https://docs.python.org/3/library/datetime.html?highlight=datetime#strftime-and-strptime-format-codes	{{ "2000-06-15 18:50:47" | hora_a_cadena("%Y-%m-%d %H:%M:%S") }} Resultado: 2000-06-15 18:50:47 (data type — string)

Expresiones con estructura de control

for

Operador	Designación	Área de aplicación	Cómo utilizarlo	Ejemplo
Recorrer cada elemento de la secuencia	for, in, endfor	Cualquier variable de contexto	{% for A in B %}{{ ... }}{% endfor %}Importante: el bucle puede tener como máximo doble anidamiento. Puede utilizar variables adicionales dentro de los bucles para comprobar los valores:	{% for number in [1, 2, 3] %}{{ number }}{% endfor %}Resultado: 123.

Comprobación de valores de variables dentro de bucles For

Variable	Designación	Cómo utilizarlo	Ejemplo
Número de iteración desde el inicio del bucle (1 indexado)	loop.index	{{ loop.index }}	{% for i in [{'name': 'Milk', 'quantity': '1'}, {'name': 'Apples', 'quantity': '4'}, {'name': 'Cookies' , 'quantity': '1'}] %}{{ loop.index }}{{ ') ' }}{{ i.name }} {{ i.quantity }}{% endfor %}Resultado: 1) Milk 1 2) Apples 4 3) Cookies 1
Número de iteraciones desde el inicio del bucle (0 está indexado)	loop.index0	{{ loop.index0 }}	{% for i in ['A','B','C'] %}{{ loop.index0 }}{{ ': ' }}{{ i }}{% endfor %}Resultado: 0:A1:B2:C.
Número de iteración desde el final del bucle (1 indexado)	loop.revindex	{{ loop.revindex }}	dict = {{ {'one': 'A', 'two': 'B', 'three': 'C'} }}{% for i in dict %}{{ loop.revindex }}{{ ': ' }}{{ i }}{{ ' is ' }}{{ dict[i] }}{% endfor %}Resultado: 3:one is A 2: two is B 1: three is C.
Número de iteración desde el final del bucle (0 está indexado)	loop.revindex0	{{ loop.revindex0 }}	{% for i in ['apple','orange','cherry'] %}{{ loop.revindex0 }}{{ ' | ' }}{{ i }}{% endfor %}Resultado: 2 | apple 1 | orange 0 | cherry.
Verdadero si primera iteración	loop.first	{{ loop.first }}	{% for i in ['a','b','c','d','e'] %}{% if loop.first == true %}{{ i }}{{ ' is first' }}{% endif %}{% endfor %}Resultado: a is first.
Verdadero si la última iteración	loop.last	{{ loop.last }}	{% for i in ['a','b','c','d','e'] %}{% if loop.last == true %}{{ i }}{{ ' is last' }}{% endif %}{% endfor %}Resultado: e is last.
Número de elementos en secuencia	loop.length	{{ loop.length }}	{% for i in ['a','b','c','d','e'] %}{% if loop.last == true %}{{ 'length: '}}{{ loop .length }}{% endif %}{% endfor %}Resultado: length: 5.
Movimiento cíclico dentro de un objeto	loop.cycle	{{ loop.cycle }}	dict = {{ {'one': 'A', 'two': 'B', 'three': 'C'} }}{% for i in dict %}{{ loop.cycle }}{{ dict[i] }}{% endfor %}Resultado: >A>B>C.
Profundidad del bucle recursivo (a partir del nivel 1)	loop.depth	{{ loop.depth }}	{% for i in [1,2,3] %}{% if loop.last == true %}{{ 'depth: '}}{{ loop.depth }}{% endif %}{% endfor %}Resultado: depth: 1.
Profundidad del bucle recursivo (a partir del nivel 0)	loop.depth0	{{ loop.depth0 }}	{% for i in [1,2,3] %}{% if loop.last == true %}{{ 'depth: '}}{{ loop.depth0 }}{% endif %}{% endfor %}Resultado: depth: 0.
Recuperar un valor de una iteración anterior de un bucle	loop.previtem	{{ loop.previtem }}Importante: el elemento es indefinido si la iteración es la primera.	{% for i in [1,2,3] %}{% if loop.first == false %}{{ 'previous element: '}}{{ loop.previtem }}{% endif %}{% endfor %}Resultado:previous element: 1 previous element: 2.
Obtener un valor de la siguiente iteración del bucle	loop.nextitem	{{ loop.nextitem }}Importante: el elemento es indefinido si la iteración es la última.	{% for i in [1,2,3] %}{% if loop.last == false %}{{ 'next item: '}}{{ loop.nextitem }}{% endif %}{% endfor %}Resultado:next element: 2 next element: 3.
Comprobar si el valor de una variable ha cambiado	loop.changed(val)	{{ loop.changed(A) }}	mass = [{'k': 3, 'v': 2}, {'k': 2, 'v': 3}, {'k': 2, 'v': 2}]{% for row in mass %}{% if loop.changed(row.k) == true %}{{ row.k }}{% endif %}{% endfor %}Resultado:3 2.

IF

Operador	Designación	Área de aplicación	Cómo utilizarlo	Ejemplo
Condicionales	if, elif, else	Cualquier variable de contexto	SImplemente estructuras condicionales, por ejemplo, para la ranura de memoria:{{ <hacer algo> if <algo es verdad> else <hacer otra cosa> }}elif y else puede utilizarse.La parte else es opcional: si falta,si no se cumple la condición if , el resultado será 'False'.	{{ 42 if client_message == "Привет" else 111 }} Resultado: ‘42’, si client_message contiene "Привет";‘111’, si client_message contiene cualquier otro valor. {{ 42 if client_message == "Привет"}} Resultado: ‘42’, si client_message contiene "Привет";‘False’, si client_message contiene cualquier otro valor.

Filtros

Operador	Designación	Área de aplicación	Cómo utilizarlo	Example
Aplica un filtro a un bloque de datos de plantilla	filter, endfilter	Cualquier variable de contexto	Similar a las expresiones que utilizan filtros, pero para condiciones más amplias{% filter <filter> %} TEXT{% endfilter %}	{% filter upper %}    Este texto se pone en mayúsculas{% endfilter %} Resultado: ESTE TEXTO SE PONE EN MAYÚSCULAS.

Asignaciones

Operador	Designación	Área de aplicación	Cómo utilizarlo	Ejemplo
Asigna un valor a un operando	set	Cualquier variable de contexto	{% set A = B%}	{% set x = 'manzanas' si la edad es par si no 'naranjas' %}{{ x }} Resultado: 'manzanas', si la variable edad contiene un número par.'naranjas', si la variable edad contiene un número impar.

Métodos útiles de Python disponibles en la plataforma

Método	Descripción	Ejemplo	Nota
capitalize()	Convierte el primer carácter de la cadena en mayúscula	entrada: 'the String'.capitalize() salida: The string
casefold()	Implementa la concordancia de cadenas sin casillas	entrada: 'the String'.casefold() salida: the string
center()	Parámetros: lenght: La longitud de la cadena devuelta carácter (opcional): El carácter para rellenar el espacio que falta en cada lado. Por defecto es " " (espacio) El método alineará al centro la cadena, usando un carácter especificado (el espacio es el predeterminado) como carácter de relleno.	entrada: 'the String'.center(20, 'O') salida: OOOOOthe StringOOOOO
count()	Parámetros: length: longitud de la cadena después de rellenar con los caracteres. fillchar: (opcional) caracteres que necesitan ser rellenados. Si no se proporciona, se toma el espacio como argumento por defecto. Devuelve el número de apariciones de una subcadena en la cadena	entrada: 'the String'.count('S') salida: 1 entrada: 'the String'.count('s') salida: 0	Distingue entre mayúsculas y minúsculas
encode()	Parámetros: codificación: Especifica la codificación en base a la cual debe realizarse la codificación. errores: Decida cómo manejar los errores si se producen, por ejemplo, 'strict' genera un error Unicode en caso de excepción e 'ignore' ignora los errores que se produzcan. Existen seis tipos de respuesta a errores strict - respuesta por defecto que lanza una excepción UnicodeDecodeError en caso de fallo ignore - ignora el unicode no codificable del resultado replace - sustituye el unicode no codificable por un signo de interrogación ? xmlcharrefreplace - inserta una referencia de carácter XML en lugar de unicode no codificable backslashreplace - inserta una secuencia de escape \uNNNNN en lugar de unicode no codificable namereplace - inserta una secuencia de escape \N{...} en lugar de unicode no codificable Devuelve la cadena codificada	entrada: 'строка'.encode('utf-8') salida: b'\xd1\x81\xd1\x82\xd1\x80\xd0\xbe\xd0\xba\xd0\xb0'
endswith()	Parámetros: sufijo: El sufijo no es más que una cadena que hay que comprobar. empezar: Posición inicial desde la que se necesita comprobar el sufijo dentro de la cadena. fin: Posición final + 1 desde donde se necesita comprobar el sufijo dentro de la cadena. Devuelve True si la cadena termina con el sufijo dado, en caso contrario devuelve False.	entrada: 'the string'.endswith('string') salida: True input: 'the string'.endswith('the') salida: False
expandtabs()	Parámetros tabsize: Especifica el espacio que debe sustituirse por el símbolo "\t" en la cadena. Por defecto, el espacio es 8. Devuelve la cadena modificada con los tabuladores sustituidos por el espacio.	entrada: 'the\tstring'.expandtabs() salida: the string entrada: 'the string'.expandtabs(12) salida: the string
find()	Parámetros sub: Subcadena que hay que buscar en la cadena dada. send (opcional): La posición final es el índice del último valor para el rango especificado. Se excluye durante la comprobación. end (optional): The end position is the index of the last value for the specified range. It is excluded during the check. Devuelve el índice más bajo de la subcadena si se encuentra en una cadena dada. Si no se encuentra entonces devuelve -1.	entrada: 'the string'.find('str') salida: 4 entrada: 'the string'.find('other') salida: -1
format()	Parámetros: valor : Puede ser un entero, una constante numérica de coma flotante, una cadena, caracteres o incluso variables. Devuelve una cadena formateada con el valor pasado como parámetro en la posición del marcador de posición.	entrada: 'the {0} is {1}'.format('string', 'long') salida: the string is long
format_map()	Parameters: input_dict: Toma un único parámetro que es el diccionario de entrada. Devuelve los valores de las claves del diccionario de entrada.	entrada: 'the {x} is {y}'.format_map({'x': 'string', 'y': 'long'}) salida: the string is long
index()	Parámetros: subcadena: La cadena a buscar. start (por defecto : 0) : Esta función especifica la posición desde la que debe iniciarse la búsqueda. end (por defecto: longitud de la cadena): Esta función especifica la posición a partir de la cual debe terminar la búsqueda. Devuelve la primera posición de la subcadena encontrada.	entrada: 'the string'.find('str') salida: 4 ientrada: 'the string'.find('other') salida: INTERNAL ERROR - slot: n, info: substring not found	El método index() es similar a find(). La única diferencia es que find() devuelve -1 si no se encuentra la cadena buscada e index() lanza una excepción en este caso.
isalnum()	Comprueba si todos los caracteres de una cadena dada son alfanuméricos o no	entrada: 'the string 1'.isalnum() salida: False entrada: 'thestring1'.isalnum() salida: True
isalpha()	Devuelve "True" si todos los caracteres de la cadena son alfabéticos	entrada: 'the string'.isalpha() salida: False entrada: 'thestring'.isalpha() salida: True
isdecimal()	Devuelve true si todos los caracteres de una cadena son decimales	entrada: 'thestring1'.isdecimal() salida: False entrada:'123'.isdecimal() salida: True
isdigit()	Devuelve "True" si todos los caracteres de la cadena son dígitos	entrada: '²123'.isdigit() salida: True input: '123'.isdigit() salida: True
isidentifier()	Comprobar si una cadena es un identificador válido o no	entrada: 'the string'.isidentifier() salida: False entrada: 'the_string'.isidentifier() salida: True	Se considera que una cadena es un identificador válido si: Sólo consta de caracteres alfanuméricos y guión bajo (_) No empieza por un espacio o un número
islower()	CComprueba si todos los caracteres de la cadena están en minúsculas	entrada: 'the String'.islower() salida: False entrada: 'the string'.islower() salida: True
isnumeric()	Devuelve "True" si todos los caracteres de la cadena son numéricos	entrada: '⅓'.isnumeric() salida: True input: '1.2'.isnumeric() salida: False
isprintable()	Devuelve "True" si todos los caracteres de la cadena son imprimibles o la cadena está vacía	entrada: {{ 'the\nstring'.isprintable() }} salida: False entrada: {{ ''.isprintable() }} salida: True
isspace()	Devuelve "True" si todos los caracteres de la cadena son espacios en blanco	entrada: '\n\t\n'.isspace() salida: True
istitle()	Devuelve "True" si la cadena es una cadena con título	entrada: 'The string'.istitle() salida: False entrada: 'THE string'.istitle() salida: False entrada: 'The String'.istitle() salida: True
isupper()	Comprueba si todos los caracteres de la cadena están en mayúsculas	entrada: 'THE String'.isupper() salida: False entrada: 'THE STRING'.isupper() salida: True
union()	Parámetros: iterable: objetos capaces de devolver sus miembros de uno en uno. El método join() devuelve una cadena concatenada con los elementos de iterable.	entrada: '-'.join(['the', 'string']) salida: the-string
ljust()	Parámetros: length: longitud de la cadena modificada. Si la longitud es menor o igual que la longitud de la cadena original, se devuelve la cadena original. fillchar: (opcional) caracteres que deben rellenarse. Si no se proporciona, se toma el espacio como argumento por defecto. Devuelve una nueva cadena de longitud dada después de sustituir un carácter dado en el lado derecho de la cadena original.	entrada: {{ 'string'.ljust(10, '#') }} salida: string####
inferior()	Convierte todos los caracteres en mayúsculas de una cadena en minúsculas	entrada: 'the String'.lower() salida: the string
lstrip()	Parámetros: caracteres [opcional]: Un conjunto de caracteres a eliminar como caracteres iniciales. Por defecto, utiliza el espacio como carácter a eliminar. Devuelve una copia de la cadena sin los caracteres iniciales.	entrada: 'the string'.lstrip('t') salida: he string
maketrans()	Parámetros : str1 : Especifica la lista de caracteres que deben sustituirse. str2 : Especifica la lista de caracteres con los que deben sustituirse los caracteres. str3 : Especifica la lista de caracteres que hay que eliminar. Devuelve la tabla de traducción que especifica las conversiones que puede utilizar translate()	{% set trans = 'bp' %}{% set repl = 'ts' %}{% set del = 'y' %} {% set table = 'bhey pbring'.maketrans(trans, repl, del) %} entrada: 'bhey pbring'.translate(table) salida: the string
partición()	Divide la cadena en la primera aparición del separador	entrada: 'the string is long'.partition('is') salida: ('the string ', 'is', ' long')
reemplazar()	Parámetros: old - subcadena antigua que desea reemplazar. new - nueva subcadena que sustituiría a la antigua. count - ( Opcional ) el número de veces que quieres reemplazar la subcadena antigua por la nueva subcadena. Devuelve una copia de la cadena en la que todas las apariciones de una subcadena se sustituyen por otra subcadena.	entrada: 'the string'.replace('the', 'new') salida: new string
rfind()	Parámetros: sub: Es la subcadena que hay que buscar en la cadena dada. inicio: Posición inicial donde se necesita comprobar la subcadena dentro de la cadena. end: Posición final donde se necesita comprobar el sufijo dentro de la cadena. Nota: Si no se proporcionan los índices de inicio y fin, por defecto se toman 0 y length-1 como índices de inicio y fin, y los índices finales no se incluyen en la búsqueda. Devuelve el índice situado más a la derecha de la subcadena si se encuentra en la cadena dada; si no se encuentra, devuelve -1.	entrada: 'the string the test'.rfind('the') salida: 11
rindex()	Parámetros: sub : Es la subcadena que hay que buscar en la cadena dada. start : Posición inicial en la que se debe comprobar sub dentro de la cadena. end : Posición final en la que se debe comprobar el sufijo dentro de la cadena. Devuelve el índice más alto de la subcadena dentro de la cadena si se encuentra la subcadena. En caso contrario, lanza una excepción.	entrada: 'the string the test'.rindex('the') salida: 11	El método index() es similar a find(). La única diferencia es que find() devuelve -1 si no se encuentra la cadena buscada e index() lanza una excepción en este caso.
rjust()	Parámetros: length: longitud de la cadena modificada. Si la longitud es menor o igual que la longitud de la cadena original, se devuelve la cadena original. fillchar: (opcional) caracteres que deben rellenarse. Si no se proporciona, se toma el espacio como argumento por defecto. Devuelve una nueva cadena de longitud dada después de sustituir un carácter dado en el lado izquierdo de la cadena original.	entrada: 'string'.rjust(10, '#') salida: ####string
rpartition()	Parámetros: separator - separa la cadena en la primera aparición de la misma. Valor de retorno: Devuelve la parte de la cadena antes del separador, el propio parámetro separador y la parte después del separador si el parámetro separador se encuentra en la cadena. Devuelve dos cadenas vacías, seguidas de la cadena dada si el separador no se encuentra en la cadena.	entrada: 'the string the test'.rpartition('the') salida: ('the string ', 'the', ' test')
rsplit()	Parámetros: separador: Es un delimitador. La cadena se divide en el separador especificado empezando por el lado derecho. Si no se especifica, cualquier espacio en blanco sirve de separador. maxsplit: Es un número, que nos dice que dividamos la cadena en un número máximo de veces proporcionado. Si no se indica, no hay límite. Devuelve una lista de cadenas después de romper la cadena dada desde el lado derecho por el separador especificado. Error: No obtendremos ningún error aunque no pasemos ningún argumento.	entrada: 'the string the test'.rsplit(' ', 2) salida: ['the string', 'the', 'test']
rstrip()	Parámetros: chars (opcional) - una cadena que especifica el conjunto de caracteres a eliminar. Devuelve una copia de la cadena con los caracteres finales eliminados.	entrada: 'the string the test'.rstrip('est') salida: the string the
splitlines()	Parámetros: keepends (opcional): Cuando se establece en True los saltos de línea se incluyen en la lista resultante. Puede ser un número que especifique la posición del salto de línea o cualquier carácter Unicode, como "\n", "\r", "\r\n", etc. como límites para las cadenas. Devuelve una lista de las líneas de la cadena, rompiendo en los límites de línea.	entrada:'the string\nthe test'.splitlines() salida: ['the string', 'the test'] entrada: 'the string\nthe test'.splitlines(True) salida: ['the string\n', 'the test']
startswith()	Parámetros: prefix: prefix ix nada más que una cadena que hay que comprobar. empezar: Posición inicial donde se necesita comprobar el prefijo dentro de la cadena. fin: Posición final donde se necesita comprobar el prefijo dentro de la cadena. Devuelve True si las cadenas empiezan por el prefijo dado, en caso contrario devuelve False.	entrada: 'the string the test'.startswith('the') salida: True
strip()	Parámetro: Sólo tiene un parámetro opcional. chars - una cadena que especifica el conjunto de caracteres que deben eliminarse. Si no se indica el parámetro opcional chars, se eliminarán de la cadena todos los espacios en blanco iniciales y finales. Devuelve una copia de la cadena con los caracteres iniciales y finales eliminados.	entrada: 'the string the test the'.strip('the') salida: string the test
swapcase()	El método swapcase() devuelve una cadena con todos los casos cambiados.	entrada: 'The string THE test'.swapcase() salida: tHE STRING the TEST
título()	Devuelve: cadena, convertida a mayúsculas y minúsculas.	entrada: 'The string THE test'.test() salida: The String The Test
traducir()	Parámetros: Tabla: Mapeo de traducción especificado para realizar las traducciones. delstr: La cadena de borrar se puede especificar como argumento opcional no se menciona en la tabla. Devuelve la cadena del argumento después de realizar las traducciones utilizando la tabla de traducción.	{% set trans = 'bp' %}{% set repl = 'ts' %}{% set del = 'y' %} {% set table = 'bhey pbring'.maketrans(trans, repl, del) %} entrada: 'bhey pbring'.translate(table) salida: the string	Hay dos formas de traducir: Python String translate() con mapeo como diccionario. Mapeo usando maketrans().
superior()	RDevuelve: cadena, convertida a mayúsculas.	entrada: 'The string THE test'.test() salida: THE STRING THE TEST
zfill()	Parametros: length: length es la longitud de la cadena devuelta por zfill() con los dígitos '0' rellenados a la izquierda. Devuelve una copia de la cadena con '0' caracteres rellenados a la izquierda de la cadena dada.	entrada: 'the string'.zfill(15) salida: 00000the string

Errores al renderizar Plantillas

Durante el Entrenamiento de Agentes, en el proceso de Validación de Script, se comprueba la corrección de las Expresiones y Expresiones con Estructura de Control utilizadas en las Ranuras. Si se detectan errores, aparecerá una advertencia:

Formato de texto de advertencia:

Sintaxis de plantilla no válida:Ranura <id de la ranura problemática>. Error "<descripción del error>" en la expresión "<expresión problemática>".

Ejemplo:

Sintaxis de plantilla no válida:Ranura 8848840. Error "unexpected char '@' at 3" in expression "{{ @foo }}"

Explicación del error: se ha detectado un error en la ranura 8848840 - un símbolo '@' extra con el número de secuencia 3 en la expresión {{ @foo }}.

Importante: El recuento de los números de serie de los caracteres en la expresión del problema empieza por 0.