Travailler avec les tableaux et les dictionnaires

nom[index] - accéder à un élément du tableau par index ou par valeur

Regardons quelques exemples de travail avec les tableaux :

Exemple d'accès à un élément du tableau par son index :

Exemple d'obtention du dernier élément du tableau :

/*Accès par index*/
tableauI = [1, "2", 3, 4, 5]
k=tableauI[3]
/*Accès par index depuis un tableau imbriqué*/
tableauV = [[1, "2", 4, 5], "2", 3, 4, 5]
v=tableauV[0][1]

/*Exemple d'obtention du dernier élément*/
tableau = [1, "2", 3, 4, 5]
/*Obtention du dernier élément du tableau*/
dernier = tableau[-1]

nom[index] = valeur - remplacer un élément du tableau par un index donné

Exemple :

Pour remplacer la valeur d'un élément spécifique du tableau, utilisez la syntaxe suivante : nom_tableau[index] = valeur

Réponse :

tableau = [1, "2", 3, 4, 5]

/*Remplacer dans tableau/dictionnaire*/
tableau[2] = 888

/*Ajouter dans dictionnaire   dicts['key'] = 'VVVVVVVVVVV'*/
dicts['m']=nouveau

/*Remplacer dans tableau/dictionnaire par le nombre*/
tableau[3] = int('888')
dicts['a'] = int('555')

in_array(mass, valeur) - pour vérifier si un élément existe dans un tableau.

Paramètres : \ ! mass - tableau \ ! valeur - valeur à rechercher

Renvoie True ou False selon que la valeur est trouvée ou non.

Exemple :

s = ["Mike", "Peter", "Helen"] 
q = if(in_array(s, 'Ann'), 'Trouvé', 'Autre chaîne')

arr_len(mass) - pour connaître la longueur d'un tableau

Paramètre :\ ! mass - tableau

Résultat : Renvoie un nombre - la longueur du tableau.

Soyez prudent lors du passage des paramètres à la fonction ! Si elle est appelée sans paramètres, elle renvoie 0 ; si le paramètre n'est ni un tableau ni un dictionnaire, elle renvoie -1.

Exemple d'utilisation :

Résultat :

s = ["Mike", "Peter", "Helen"] 
q = if(arr_len(s) > 5, 'Le groupe est complet', 'Rejoignez notre équipe !')

append(mass, élément, indicateur) - pour insérer un élément à la fin d'un tableau.

Paramètres :

! mass - tableau\ ! élément - élément à insérer
indicateur - indicateur indiquant s'il s'agit d'un tableau ou d'un dictionnaire

Renvoie le tableau avec la valeur ajoutée à la fin. Pour mettre à jour le tableau d'origine, utilisez l'affectation : mass = append(mass, élément, indicateur)

Par défaut, les données sont insérées sous forme de chaînes. Si vous devez insérer un tableau ou un dictionnaire, passez un paramètre supplémentaire True. Cela indique que vous insérez du JSON.

Exemple d'utilisation :

Exemple d'ajout et de suppression dans un tableau :

Exemple de création d'un tableau avec des tableaux à l'intérieur :

Le résultat de l'exécution de la fonction :

s = ["Mike", "Peter", "Helen"]
q = append(s, 'Max')

insert(mass, index, valeur, indicateur) - pour insérer un élément à une position spécifique dans un tableau.

Paramètres : \ ! mass - tableau\ ! index - position d'insertion\ ! valeur - valeur
indicateur - Indicateur d'ajout à un tableau ou un dictionnaire.

Résultat :
Renvoie un tableau avec la valeur ajoutée à la position spécifiée. En d'autres termes, pour ajouter la valeur au même tableau, utilisez la commande sous la forme suivante : mass = insert(mass, index, valeur, indicateur)

Par défaut, les données sont insérées sous forme de chaînes. Si vous devez insérer un tableau ou un dictionnaire, passez un paramètre supplémentaire True. Cela indique que vous insérez du JSON.

Exemple :

Résultat :

Regardons un exemple plus complexe - ajout d'un dictionnaire t à un tableau s :

Dans la fonction, nous avons indiqué que nous voulions ajouter un dictionnaire à la position 1. Regardons le résultat :

s = ["Mike", "Peter", "Helen"]
q = insert(s, 1, 'Max')

Par index

del(mass, key) - supprime un élément du tableau par son index.

Paramètres : \ ! mass - nom du tableau ;\ ! key - l'index de la valeur à supprimer

Renvoie un nouveau tableau avec l'élément supprimé ; le tableau d'origine reste inchangé. Pour supprimer et mettre à jour le même tableau, utilisez la commande comme :
mass = del(mass, key)

Si votre tableau contient des nombres et que vous souhaitez supprimer un élément par sa valeur, utilisez la fonction remove().

del nom['index'] - suppression d'une valeur d'un tableau par index

Paramètres : \ ! name- nom du tableau ;\ ! index- l'index de la valeur à supprimer

Par valeur

remove(mass, value) - pour supprimer une valeur d'un tableau.

Paramètres : \ ! mass - nom du tableau ; \ ! value - la valeur à supprimer du tableau

Résultat :
Renvoie un tableau modifié, laissant le tableau d'origine inchangé. Pour supprimer un élément et mettre à jour le même tableau, utilisez la commande sous la forme suivante :
mass = remove(mass, key)

Exemple de suppression d'un élément par index :

Exemple de suppression d'un élément de tableau par sa valeur :

/*Suppression d'un élément de tableau par son index :*/
array = ["1",2, 3, "4"]
del array['1']

array1 = ["1",2, 3, "4"]
array1=del(array1,0)


/*Suppression d'un élément de tableau par sa valeur :*/
array = ["1",2, 3, "4"]
array=remove(array, '4') 

array1 = ["1",2, 3, "4"]
array1=remove(array1, 2) 

index(mass, value)

Paramètres : \ ! mass - nom du tableau \ ! value - la valeur dont la position doit être déterminée.

Si l'élément n'est pas dans le tableau, la fonction renverra -1.

Exemple de détermination de la position d'un élément dans un tableau :

Examinons le résultat plus en détail :

Comme nous pouvons le voir, puisque le nombre 5 n'est pas dans le tableau, la fonction a renvoyé -1.

array = ["1",2, 3, "4"]
search1=index(array,"1")
search2=index(array,5)

massive_to_text(massive, header, numbered,delimiter1,delimiter2)

Paramètres :

! massive – le tableau à afficher,
header – un titre qui apparaîtra au début de la sortie
numbered – si une valeur est passée, les éléments du tableau seront numérotés
delimiter1 – le caractère placé à la fin de chaque ligne d'élément (par défaut ';'),
delimiter2 – le caractère utilisé après le numéro d'élément lorsque la numérotation est activée (par défaut ')')

Exemple simple :

En conséquence, le tableau sera affiché sous forme de liste numérotée :

Array1 = [1, 2, 3, "a", "b", "c"] 
text = array_to_text(Array1, 'title', 1) 

except_arr(mas1, mas2)

Paramètres :

! mas1 - le tableau duquel les éléments seront exclus,\ ! mas2 - le tableau contenant les éléments à exclure

Regardons l'exemple :

s1 = [1, 2, 3]
s2 = [2, 3]
s3 = except_arr(s1, s2)

cross_arr(mas1, mas2)

Paramètres :

! mas1 - le tableau dans lequel chercher\ ! mas2 - le tableau contenant les éléments à rechercher

s1 = [1, 2, 3]
s2 = [2, 3]
s3 = cross_arr(s1, s2)

mas1 = ["didn't", "except,", "that", "everything", "is", "so", "simple.", "thanks"]
mas2 = ["everything", "thanks"]
mas3 = cross_arr(mas1, mas2)

Il n'existe pas de fonction intégrée spécifiquement pour fusionner des tableaux, mais cela peut être fait facilement :

Pour combiner des tableaux, effectuez une concaténation de chaînes, puis remplacez '][' par une virgule ','

Ceci est un exemple dans le champ Calculatrice

Ceci est un exemple de fonctionnement d'un bot

a = [1,2,3,4] 
b = [5,6,7] 
sum = a + b 
answer = replace(sum, '][', ',') 

sum_array(array)

Paramètres :

array - le tableau dont les éléments doivent être additionnés

Attention ! La fonction fonctionne avec des tableaux d'un format spécifique.

Formats acceptés : - [1,2,3,4] ou '[1,2,3,4]'.
Si le tableau contient des nombres représentés sous forme de chaînes, ils doivent être placés entre guillemets doubles—par exemple, [1,2,3,"-4"].
Si le tableau contient des chaînes alphabétiques, le calcul échouera.

Exemple d'utilisation incorrecte :
mas = [1,2,3,"a"]
result = sum_array(mas)

Cela entraînera une erreur : array has unsupported elements

Résultat :

mas = [1,2,3,4] 
result = sum_array(mas) 

shuffle_massive(massive)

Paramètres :

massive - le tableau dont les éléments doivent être mélangés.

Résultats d'exécution de la fonction :

Massive1 = [1, 2, 3, "a", "b", "c"]
Massive2 = shuffle_massive(Massive1) 

Tri dans un tableau ou un dictionnaire

sort(mass, b) - trie un tableau par valeur, et un dictionnaire par clé

Paramètres :

! mass - tableau/dictionnaire
b - ordre de tri (False – croissant (par défaut), True – décroissant)

Tri d'un dictionnaire par sa valeur

sort_by_value(dict, b) - trie un dictionnaire par valeurs.

Paramètres :\ ! dict- dictionnaire
b - ordre de tri (False – croissant (par défaut), True – décroissant)

Exemple de tri d'un tableau en ordre décroissant et d'un dictionnaire en ordre croissant :

Tri d'un dictionnaire par valeurs :

Conversion d'un tableau/dictionnaire en boutons

tools_make_button_str_checker(values_list, key, in_line, button_type, checker_with_numbers)

Paramètres :

! values_list - un tableau de chaînes ou de dictionnaires dont les données seront utilisées pour construire un clavier ou une liste numérotée

key - la clé par laquelle la sélection sera effectuée à partir d'un tableau de dictionnaires

in_line - nombre de boutons par ligne (par défaut : 1)

button_type - type de boutons (par défaut : clavier de réponse).
Valeurs possibles :
0 - clavier de réponse,
1 - clavier inline (boutons dans le texte)

checker_with_numbers - s'il faut ajouter les numéros de boutons au tableau "checker".
Valeurs possibles :
0 - ne pas ajouter les numéros,
1 - ajouter les numéros (par défaut : 1 – ajouter les numéros)

Résultat de la fonction — un dictionnaire de la forme :

{"numbered_list":"1. T-shirts\n2. Shorts\n3. Socks\n4. Caps\n","buttons":[{"type":"inline","text":"T-shirts","line":0,"index_in_line":0},{"type":"inline","text":"Shorts","line":0,"index_in_line":1},{"type":"inline","text":"Socks","line":1,"index_in_line":0},{"type":"inline","text":"Caps","line":1,"index_in_line":1}],"checker":"T-shirts;1;Shorts;2;Socks;3;Caps;4;"}

Les valeurs du dictionnaire peuvent ensuite être insérées dans des champs du constructeur :

Obtention d'une valeur de dictionnaire basée sur la sélection du client

tools_check_user_input(values_list, user_input, key, return_key)

Paramètres :

! values_list - un tableau de chaînes ou de dictionnaires dont les données seront utilisées pour construire un clavier ou une liste numérotée\ Exemple de dictionnaire : [{"text":"T-shirts","price":100},{"text":"Shorts","price":150},{"text":"Socks","price":20},{"text":"Caps","price":50}]\ ! user_input - la valeur saisie par l'utilisateur parmi les valeurs de values_list\ Exemple de valeur : Caps
key - la clé utilisée pour la sélection à partir du tableau de dictionnaires values_list\ Exemple de clé : text
return_key - la valeur renvoyée pour la clé spécifiée à partir de values_list\ Exemple de valeur de retour : price

Détaillons l'utilisation de la fonction avec un exemple de panier d'achat :

1.Définissez un tableau et convertissez-le en une liste numérotée, des boutons et une liste de valeurs possibles (pour les messageries sans boutons) à l'aide de la fonction tools_make_button_str_checker().

2.Utilisez les boutons obtenus et les valeurs de numbered_list pour permettre la sélection de produits :

3.Utilisez la liste des valeurs possibles checker pour valider la saisie du client :

4.Enfin, affichez le prix du produit sélectionné au client. Cela est pratique à faire en utilisant la fonction tools_check_user_input()

list = [{"text":"T-shirts","price":100},{"text":"Shorts","price":150},{"text":"Socks","price":20},{"text":"Caps","price":50}]
res = tools_make_button_str_checker(list, "text", "2", "1")
numbered_list = res['numbered_list']
buttons = res['buttons']
checker = res['checker']

res_check = tools_check_user_input(list, user_input, 'text', 'price')

array_slice(array, start_index, end_index)

Paramètres :

! array - tableau \ ! start_index - début de la tranche
end_index - fin de la tranche (par défaut : jusqu'à la fin)

Sélectionnons un sous-tableau à partir du 1er élément :

res sera ["Shorts", "Socks", "Caps"]

Autre exemple de sélection d'un sous-tableau du 0e au 2e élément du tableau :

res sera ["T-shirts", "Shorts"]

list = ["T-shirts", "Shorts", "Socks", "Caps"] 
res = array_slice(list, 1)

res = array_slice(list, 0, 2)

unpack_list(array, var_name) - cette méthode parcourt un tableau et crée une variable distincte pour chaque élément du tableau avec des noms comme var1, var2, var3, etc.

! array - paramètre obligatoire, un tableau d'éléments

var_name - paramètre optionnel, une chaîne. S'il est fourni, il est utilisé pour nommer les éléments dépaquetés. Exemples :

Si var_name est fourni, les noms de variables sont formés en utilisant var_name

var_name doit respecter les règles de nommage des variables.

Exemple 1 :

array1 = ["one", "two", "three"]

ans1 = unpack_list(array1)

Résultat - variables de transaction créées :

var1 = 'one'

var2 = 'two'

var3 = 'three'

Exemple 2 :

array2 = ["one", "two", "three"]

var_name = 'custom'

ans2 = unpack_list(array2, var_name)

Résultat - variables de transaction créées :

custom1 = 'one'

custom2 = 'two'

custom3 = 'three'

remove_duplicates(array) - renvoie une liste sans éléments en double.

! array - paramètre obligatoire. La liste originale d'éléments avec des doublons.

Exemple :

arr = [1, 2, 5, 1, 5, 3]

new_arr = remove_duplicates(arr)

Résultat - la liste [1, 2, 5, 3] sera assignée à la variable new_arr.

Création d'un dictionnaire - déclaration d'un dictionnaire

nom_dictionnaire = {}

Vider - n'est rien d'autre que déclarer un dictionnaire vide.

nom_dictionnaire = {}

nom[clé] - obtenir un élément du dictionnaire par sa clé

Exemple de travail avec un dictionnaire :

Dans ce cas précis, nous accédons à la valeur par la clé "a". Pour récupérer une valeur d'un dictionnaire à l'aide d'une clé spécifique, utilisez le format suivant : nom_dictionnaire["clé"]

Réponse :

dicts = {"a": "11", "d": "hi"}
/*obtention depuis le dictionnaire*/
aa = dicts["a"]

dict_keys_to_array(data) - pour obtenir une liste des clés du dictionnaire data

Exemple : Obtenir une liste de toutes les clés du dictionnaire

Réponse :

v={"A1":"orange","A2":"apricot","A3":"tangerine","A4":"apple","A5":"pear","A6":"kiwi","A7":"banana","A8":"peach"} 
key= dict_keys_to_array(v)

dict_values_to_array(data) - pour obtenir une liste de valeurs d'un dictionnaire

Exemple :

Réponse :

v={"A1":"orange","A2":"apricot","A3":"tangerine","A4":"apple","A5":"pear","A6":"kiwi","A7":"banana","A8":"peach"}
value= dict_values_to_array(v)

get_values_by_key(data, key) - permet d'obtenir les valeurs de la liste de dictionnaires par la clé spécifiée. Renvoie une liste de valeurs.

Exemple : Obtenir les valeurs d'une liste de dictionnaires par clé

Réponse :

data = [{"Product": "Product№1", "Price": 1500}, {"Product": "Product№2", "Price": 6000}]
key = "Product"
result = get_values_by_key(data, key)

nom**['clé'] = valeur** - remplacement de la valeur d'un élément du dictionnaire par la clé spécifiée. Si une clé inexistante est spécifiée, un nouvel élément du dictionnaire sera ajouté.

Exemple :

Pour remplacer la valeur d'un élément spécifique d'un tableau, écrivez une affectation comme nom_tableau*[index] = valeur ou nom_dictionnaire*[clé] = valeur

Réponse :

dicts = {"a": "11", "d": "hi"}

/*Remplacer dans un dictionnaire*/
dicts['d'] = AAAAA

/*Ajouter dans un dictionnaire   dicts['key'] = 'VVVVVVVVVVV'*/
dicts['m']=new

/*Remplacer dans un dictionnaire avec un nombre*/
dicts['a'] = int('555')

nom_dictionnaire***['clé'] = 'valeur'** -* ajout d'une nouvelle valeur au dictionnaire.

Si la clé n'existait pas auparavant, une nouvelle paire clé-valeur sera ajoutée ; sinon, la valeur pour la clé spécifiée sera remplacée.

Ceci est un exemple de code dans le champ de calcul

Réponse

/*ajout d'une nouvelle valeur au dictionnaire dicts['key'] = 'VVVVVVVVVVV'*/
dicts['m']=new

exist_key(mass, key) - pour vérifier si une clé existe dans un dictionnaire.

Paramètres :

mass - dictionnaire

key - la clé à rechercher

Renvoie True ou False selon que la clé a été trouvée.

Exemple d'utilisation :

s = {"1": 123, "2": 234, "q": {"w": "e"}} 
q = if(exist_key(s, 'q'), 'Trouvé', 'Autre ligne')

key_index(mass, key) - pour vérifier la position d'une clé dans un dictionnaire.

Paramètres :
mass - dictionnaire
key - Clé à rechercher.

La position dans un dictionnaire est comptée à partir de 0. Ainsi, le premier élément est 0, le deuxième élément est 1, et ainsi de suite.

Exemple d'utilisation :

Résultat :

s = {"1": 123, "2": 234, "q": {"w": "e"}} 
q = key_index(s, 'q')

arr_len(mass) - pour déterminer la longueur d'un dictionnaire.

Paramètre :
mass - dictionnaire

Résultat : Renvoie un nombre – la longueur du dictionnaire.

Soyez prudent lors du passage d'un paramètre à la fonction : si la fonction est appelée sans paramètres, elle renvoie 0 ; si le paramètre n'est ni une liste ni un dictionnaire, elle renvoie -1.

Exemple d'utilisation :

Réponse :

Par index ou clé

del(mass, key) - pour supprimer un élément d'une liste par index ou d'un dictionnaire par clé.
Prend deux paramètres : la liste/le dictionnaire et l'index/la clé à supprimer.
Renvoie le dictionnaire ou la liste modifié(e) sans modifier l'objet original.

Si les valeurs dans une liste ou un dictionnaire sont des nombres, utilisez la fonction remove() pour supprimer un élément.

Exemple avec un dictionnaire

Résultat

Exemple avec un tableau

Résultat

Exemple avec un dictionnaire

s={"1":123, "2":234, "q":{"w":"e"}}

q=del(s,'q')

Exemple avec un tableau

s=["John", "Ann", "Sophie"]\

q=del(s, 1)

humanize(dict, delimiter, from_i, to_i)

Paramètres :

dict - nom du dictionnaire
delimiter - délimiteur entre les lignes
from_i - index de l'élément à partir duquel commencer la sortie (basé sur 0)
to_i - index de l'élément auquel terminer la sortie (non inclus)

Regardons l'exemple :

Réponse

dict = {"[id146467928|Alex]":"6","[id145255525|Маx]":"20"}
r = humanize(dict, ': ')

Tri de dictionnaire

sort(dict, b) - Trie une liste par valeur, et un dictionnaire par clé

Paramètres :

! dict- dictionnaire

b - direction du tri (False – croissant par défaut, True – décroissant)

Tri de dictionnaire par valeur

sort_by_value(dict, b) - Tri d'un dictionnaire par valeurs.

Paramètres :

! dict- dictionnaire

b - direction du tri (False – croissant par défaut, True – décroissant)

Exemple : tri d'une liste en ordre décroissant et d'un dictionnaire en ordre croissant :

Tri d'un dictionnaire par ses valeurs :

Exemple : tri d'une liste en ordre décroissant et d'un dictionnaire en ordre croissant :

array1=[5,4,0,6,3,0]

array1=sort(array1, True)

dict={"Ann":5, "John":4, "Sophie":0, "Alex":6, "Kate":3, "Harry":0}

dict=sort(dict)

Tri d'un dictionnaire par ses valeurs :

dict={"Ann":5, "John":4, "Sophie":0, "Alex":6, "Kate":3, "Harry":0}

dict=sort_by_value(dict)