# Function Reference {% hint style="info" %} The **\[]** symbol in subsection headings marks optional arguments. You can leave them out if the default value suits you. The symbol **>>>** in the examples below marks the user's input, and the line below indicates the result of evaluating this expression. The **#** symbol marks comments (explanations) to the code. {% endhint %} ## General ### len(seq) Returns the length of an array, the number of dictionary keys, or the length of a string. ``` >>> len([1, 2, 3]) 3 >>> len('hello') 6 ``` ### int(v) Converts the argument to an integer. ``` >>> int(10.2) 10 >>> int('10') 10 >>> '10' + 2 102 >>> int('10') + 2 12 ``` ### float(v) Converts the argument to a fractional number. ``` >>> float('10.2') 10.2 ``` ### str(v) Converts the argument to a string. ``` >>> str(10.2) 10.2 ``` ### pretty(container, \[delimiter]) Formats a number, array, or dictionary using delimiter as the element **separator**. ``` >>> 12345678 | pretty 12 345 678 >>> 12345678 | pretty('\'') 12'345'678 >>> ['один', 'два', 'три'] | pretty один, два, три >>> d = dict() >>> d['x'] = 10 >>> d['y'] = 20 >>> d | pretty x: 10 y: 20 ``` ## Arithmetic ### round(v, \[nd]) Rounds **v** to **nd** decimal places. If the second argument is not specified, it rounds up to an integer. ``` >>> round(10.2) 10 >>> round(10.992) 11 >>> round(10.992, 2) 10.99 ``` ### floor(v) Rounds the argument down to an integer. ``` >>> floor(10.9) 10 ``` ### ceil(v) Rounds the argument up to an integer. ``` >>> ceil(10.2) 11 ``` ### abs(v) Returns the absolute value ``` >>> abs(-5) 5 ``` ### min(a, b, ...) Returns the minimum argument. ``` >>> min(1, 2, 3) 1 ``` ### max(a, b, ...) Returns the maximum argument. ``` >>> max(1, 2, 3) 3 ``` ### rand() Returns a fractional number in the half-interval \[0, 1). ``` >>> rand() 0.43463103446060180612420253964955918490886688232421875 ``` ### rand(a, b) Returns an integer in the interval \[a, b]. ``` >>> rand(1, 10) 10 ``` ### rand(arr) Returns a random array element. ``` >>> rand([1, 2, 3]) 3 ``` ## Working with strings ### startswith(container, s) Checks that the string **container** starts with the substring **s**. ``` >>> 'hello world'.startswith('hel') True ``` ### endswith(container, s) Checks that the string **container** ends with the substring **s**. ``` >>> 'hello world'.endswith('rld') True ``` ### **lower(s)** Converts a string to lower case. Convenient for later comparison with another string, case insensitive. ``` >>> 'hello' | lower Hey >>> 'hello' == 'hello' False >>> 'hello' | lower == 'hello' True ``` ### **upper(s)** Converts a string to upper case. ``` >>> 'HeLlO' | upper HELLO ``` ### strip(s) Removes extra spaces at the beginning and end of a string. ``` >>> ' hello ' | strip hello ``` ### split(s, \[\[sep=' ', \[max\_split=-1]]) Converts a string to an array, splitting it at the specified **sep** character (default is a space), you can also specify **max\_split** - the maximum number of divisions. ``` >>> 'one two three' | split ['one two Three'] >>> 'one two three' | split(' ', 1) ['one two Three'] ``` ### replace(s, old, new, \[count=-1]) Replaces the substring **old** in the string s with the string **new**. By default (if **count** is not specified) all occurrences of the substring are replaced. ``` >>> 'Hi, Vasya'.replace('Vasya', 'Peter') Hi Peter >>> 'теxт, теxт, теxт'.replace('теxт', 'test') 'test, test, test' >>> 'теxт, теxт, теxт'.replace('теxт', 'test', 1) 'test, теxт, теxт' ``` ## Regular Expressions Regular expressions allow you to check if a string matches a specified pattern, or to search for a substring by a pattern in another string. This is a rather complicated, but very powerful mechanism. You can read more here: [https://ru.wikipedia.org/wiki/Regular\_expressions ](https://ru.wikipedia.org/wiki/Регулярные_выражения) You can test your regular expressions here: ### match(s, pattern, \[flags]) Finds a substring in the string s that matches the regular expression pattern. If there is no such substring, None is returned. Supported flags: * i - case insensitive * m - multiline matching * s - . (dot) matches line breaks ``` >>> 'hello world' | match(r'world') world >>> 'hello world' | match(r'test') None # search for a number in a string >>> 'top up, 500' | match(r'\d+') 500 # extract email from string >>> 'My email: name@test.com' | match(r'\S+@\S+') name@test.com # search case sensitive (default) >>> 'TEST' | match(r'test') None # case insensitive >>> 'TEST' | match(r'test', 'i') TEST # ^$ means the entire string must match the filter >>> 'top up, 500' | match(r'^refill, \d+$') replenish, 500 # extra text does not match the filter >>> 'fill up, 500 some extra text' | match(r'^refill, \d+$') None ``` ### match\_groups(s, pattern, \[flags]) Finds a substring in the string **s** that matches the regular expression **pattern**. If there is no such substring, **None** is returned. Unlike **match()** returns not a substring, but an array of groups. Moreover, the first element of the array is the entire found substring. Supported flags: * i - case insensitive * m - multiline matching * s - . (dot) matches line breaks ``` # select 2 groups: number and currency >>> 'top up with 100 rubles' | match_groups(r'(\d+) (\w+)') ['100 rubles', '100', 'rubles'] ``` ### match\_all(s, pattern, \[flags]) Finds in the string s all substrings matching the regular expression **pattern**. Supported flags: * i - case insensitive * m - multiline matching * s - . (dot) matches line breaks ``` # find all numbers in a string >>> '1, 2, 3, 4, 5' | match_all(r'\d+') ['1', '2', '3', '4', '5'] ``` ## Working with arrays ### Operators ``` >>> arr = [1, 2, 3] # get value by index >>> arr[0] one # the last element of the array can be obtained like this: >>> arr[-1] 3 # check if the value is in the array >>> 3 in arr True # check for the absence of a value in the array >>> 4 not in arr True # change value by index >>> arr[0] = 100 >>> arr [100, 2, 3] # delete value by index >>> del arr[0] >>> arr [2, 3] ``` ### Slices ``` >>> arr = [1, 2, 3, 4, 5] # array elements starting at the specified index >>> arr[2:] [3, 4, 5] # array elements up to the specified index >>> arr[:2] [12] # every second element of the array >>> arr[::2] [1, 3, 5] # flip the array >>> arr[::-1] [5, 4, 3, 2, 1] ``` ### push(arr, v) Adds the element **v** to the end of the **arr** array. ``` >>> arr = [1, 2] >>> arr.push(3) >>> arr [1, 2, 3] ``` ### pop(arr, \[i]) Removes the element at index **i**. If **i** is not specified, then the last element of the array is removed. ``` >>> arr = [1, 2, 3] >>> arr.pop() >>> arr [1, 2] >>> arr = [1, 2, 3] >>> arr.pop(0) >>> arr [2, 3] ``` ### insert(arr, i, v) Inserts the value **v** in place of **i.** ``` >>> arr = [1, 2, 3] >>> arr.insert(0, 100) >>> arr [100, 1, 2, 3] ``` ### remove(arr, v) Removes the first occurrence of the element with value **v**. ``` >>> arr = [1, 2, 100, 3] >>> arr.remove(100) >>> arr [1, 2, 3] ``` ### sorted(arr) Returns a copy of the array, the values ​​in which are sorted in ascending order. ``` >>> arr = [2, 10, 1] >>> arr | sorted [1, 2, 10] ``` ### sorted(arr, key, reversed=False) Returns a copy of the array in ascending order (or descending if **reversed** is **True**). **key** is a function that returns a value by which to sort. ``` # sort by field 'x' >>> [{'x': 30}, {'x': 10}, {'x': 20}] | sorted(el => el['x']) [{'x': 10}, {'x': 20}, {'x': 30}] # sort by field 'x' backwards >>> [{'x': 30}, {'x': 10}, {'x': 20}] | sorted(el => el['x'], True) [{'x': 30}, {'x': 20}, {'x': 10}] # just sort in descending order [30, 10, 20] | sorted(None, False) [30, 20, 10] ``` ### reversed(arr) Returns a copy of an array whose values ​​are in reverse order. ``` >>> arr = [2, 10, 1] >>> arr | reversed [1, 10, 2] ``` ### enumerate(arr) Returns an array of (index, value) pairs. ``` >>> arr = [2, 10, 1] >>> arr | enumerate [(0, 2), (1, 10), (2, 1)] ``` ### shuffle(arr) Returns a copy of the array sorted randomly. ``` >>> arr = [2, 10, 1] >>> arr | shuffle [10, 1, 2] ``` ### index\_of(arr, value) Returns the index of the first array element equal to the specified **value**. If there is no element with the specified value in the array, **None** is returned. ``` >>> arr = [2, 10, 1] >>> arr | index_of('10') 1 ``` ### join(arr, \[sep]) Concatenates the elements of an array into a single string using the sep separator. ``` >>> arr = [1, 2, 3] >>> arr | join 1 2 3 >>> arr | join(':') 1:2:3 ``` ### sum(arr) Returns the sum of the array elements. ``` >>> [1, 2, 3] | sum 6 ``` ### map(arr, l) Returns a copy of the array resulting from applying the lambda function l to each of its elements. ``` # multiply each element by 2 >>> [1, 2, 3] | map(v => v * 2) [2, 4, 6] ``` ### filter(arr, l) Returns a copy of an array whose elements match the filter specified by the l lambda function. ``` # filter out values ​​greater than 5 >>> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] | filter(v => v > 5) [6, 7, 8, 9, 10] ``` ### reduce(arr, l) Combines the elements of an array into a single entity by calling the passed lambda function **l** on each element. The first argument of the lambda function is the result accumulated at the moment, the second is the next element of the array. ``` # sum value >>> [1, 2, 3] | reduce((acc, v) => acc + v) 6 # product value >>> [1, 2, 3] | reduce((acc, v) => acc * v) 6 # sum of rows >>> [1, 2, 3] | reduce((acc, v) => str(acc) + v) 123 ``` ## Working with dictionaries ### Operators ``` # dictionary declaration >>> cart = {'bread': 3, 'buckwheat': 10} # get value by key >>> basket['bread'] 3 # check if the key exists in the dictionary >>> 'bread' in basket True # change value by key >>> basket['bread'] = 2 >>> shopping cart {'bread': 2, 'buckwheat': 10} # delete value by index >>> del basket['buckwheat'] >>> shopping cart {'bread': 2} ``` ### get(k, \[default]) Returns the value given by the key **k**. If there is no such key in the dictionary, **default** is returned. ``` >>> cart = {'bread': 3, 'buckwheat': 10} >>> cart.get('bread') 3 >>> cart.get('sausages', 100) 100 ``` ### keys(d) Returns an array of dictionary keys. ``` >>> cart = {'bread': 3, 'buckwheat': 10} >>> shopping cart | keys ['bread', 'buckwheat'] ``` ### values(d) Returns an array of dictionary values. ``` >>> cart = {'bread': 3, 'buckwheat': 10} >>> shopping cart | values [3, 10] ``` ### map(d, l) Returns the array resulting from applying the lambda function **l** to each key-value pair (**k, v**). ``` >>> shopping cart | map((k, v) => k + ': ' + v + ' pcs') | join bread: 3 pcs buckwheat: 10 pcs ``` ### sorted(d, key, reversed=False) Returns a copy of the dictionary in ascending order (or descending if **reversed** is **True**). **key** is a function that returns a value by which to sort. ``` # sort by value >>> {'Vasja': 10, 'Tom': 5} | sorted((k, v) => v) {'Tom': 5, 'Vasja': 10} # sort by value (desc) >>> {'Vasja': 10, 'Tom': 5} | sorted((k, v) => v, True) {'Vasja': 10, 'Tom': 5} ``` --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://docs.smartbotpro.io/smartquery/function-reference.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.