1) C'est quoi un algorithme :  Un algorithme est une suite finie d'instructions ou d'étapes permettant de

résoudre un problème ou de réaliser une tâche.

2) Quelle est l'utilité d'un algorithme :  Un algorithme permet de résoudre des problèmes, d'automatiser des
tâches et de prendre des décisions de manière systématique et efficace.
3) Quelle est la différence entre un algorithme récursif et itératif :  *Récursif* : Un algorithme qui s'appelle lui-
même jusqu'à atteindre une condition de base.  *Itératif* : Un algorithme qui utilise des boucles pour répéter
des instructions jusqu'à atteindre une condition.
4) Python est un langage compilé ou bien interprété :  Python est un langage interprété.
5) Donner la différence entre les deux types ( Interprété et Compilé ) :  *Interprété* : Le code est exécuté ligne
par ligne par un interpréteur, ce qui permet une exécution immédiate mais peut être plus lent.
 *Compilé* : Le code source est transformé en code machine par un compilateur avant d'être exécuté, ce qui
peut améliorer la performance mais nécessite une étape de compilation préalable.
6) Quel est le rôle de Python :  Python est un langage de programmation polyvalent utilisé pour le
développement web, l'analyse de données, l'intelligence artificielle, le scripting…, Il est apprécié pour sa
syntaxe simple et sa grande bibliothèque standard .
7) Donner quelques caractéristiques du langage Python :  Syntaxe simple et lisible / Langage interprété et
dynamique / Grande bibliothèque standard / Support pour la programmation orientée objet et fonctionnelle /
Portabilité sur diverses plateformes .
8) Il existe de nombreux testeurs disponibles pour Python :  unittest / pytest / nose / doctest .
9) C'est quoi la différence entre une classe et un objet :  Une classe est un modèle définissant des attributs et
des méthodes, tandis qu'un objet est une instance de cette classe, possédant des valeurs spécifiques pour ses
attributs.
10) Quelle le principe de la programmation orientée objet (POO) :  La programmation orientée objet (POO)
repose sur le concept d'objets, qui encapsulent des données et des comportements. Les principes clés incluent
l'encapsulation, l'héritage et le polymorphisme .
11) Programmation Structurée :  Structurée : Organisation par structures de contrôle / Fonctions autonomes /
Clarté, modularité, simplicité .
12) Donner trois caractéristiques dans la programmation orienté objet :  *Encapsulation :* Regrouper données et
méthodes dans une même structure.  *Héritage :* Une classe dérivée hérite des attributs et méthodes d'une
classe de base.  *Polymorphisme :* Utiliser une interface commune pour des objets de classes différentes.
13) C’est quoi une classe dans la programmation orienté objet :  Une classe dans la programmation orientée ob-
jet est un modèle définissant des attributs et des méthodes pour créer des objets.
14) Quels sont les avantages de l'utilisation des fonctions en programmation :  Réutilisabilité du code / Améliora-
tion de la lisibilité et de la modularité / Facilitation du débogage et de la maintenance / Encapsulation de la lo-
gique pour des tâches spécifiques .
15) Quelle est le rôle des méthodes dans la programmation orientée objet :  Les méthodes permettent de mani-
puler les données des objets et d'interagir avec eux, facilitant la modularité et la réutilisabilité du code .
16) C'est quoi la différence entre un test unitaire et un teste d'intégration :  Un test unitaire vérifie le bon
fonctionnement d'une partie spécifique du code (comme une fonction), tandis qu'un test d'intégration vérifie
que plusieurs composants du système fonctionnent correctement ensemble.
17) Avantages de l'automatisation des tâches :  L'automatisation des tâches permet de gagner du temps,
d'améliorer la précision, de réduire les erreurs humaines et d'augmenter l'efficacité.
18) C'est quoi la différence entre un test d'automatisé et un test manuel :  Un test automatisé est exécuté par un
logiciel qui vérifie les résultats de manière automatique, tandis qu'un test manuel nécessite l'intervention
humaine pour vérifier les résultats .
19) Quel est le rôle du service SSH :  Le service SSH (Secure Shell) permet d'établir des connexions réseau
sécurisées pour le contrôle à distance des machines et le transfert de fichiers.
20) Définir un cronTab :  Le crontab est un fichier de configuration pour le système de planification de tâches cron
sur Unix, permettant d'exécuter des commandes ou scripts à intervalles réguliers.
21) C'est quoi la bibliothèque Logging :  La bibliothèque "logging" de Python est un module standard utilisé pour
le suivi des événements qui se produisent lorsque des logiciels s'exécutent.
22) Donner au moins 4 caractéristiques de la bibliothèque Logging :  Hiérarchie des loggers / Niveaux de
sévérité / Gestion des handlers / Formatage des messages .
23) Intérêt d’utiliser SSH par rapport à Telnet :  SSH est choisi pour ses capacités de sécurité et d'authentification
améliorées par rapport à Telnet, ce qui le rend plus approprié pour administrer et sécuriser des services réseau .
24) Les avantages de l'automatisation des tâches administratives :  Efficacité accrue / Réduction des erreurs
humaines / Économie de temps / Standardisation des processus .
25) Rôle des scripts shell dans l'administration système :  Automatisation des tâches répétitives, gestion des
fichiers, processus et services, et configurations système.
26) Exemple d'utilisation d'un script Python pour l'automatisation :  Surveillance des ressources système et envoi
d'alertes par email en cas de dépassement de seuils .
27) Les différents niveaux de log dans la bibliothèque logging de Python :  DEBUG / INFO / WARNING / ERROR /
CRITICAL .
28)  Instance : Objet créé à partir d'une classe avec ses propres valeurs d'attributs .
29)  Objet : Entité réelle avec attributs (données) et méthodes (comportements) .
30)  *Constructeur :* Méthode spéciale appelée lors de la création d'une instance de classe, initialisant les
attributs .
31)  *Paramètre :* Variable passée à une fonction ou méthode pour fournir des données supplémentaires .
32)  *Attribut :* Variable appartenant à une classe ou une instance, utilisée pour stocker des données .
33) PowerShell et son utilité :  Shell de commande et langage de script pour l'automatisation sur Windows, utilisé
pour gérer les systèmes et applications Windows .
34) Rôle de la bibliothèque os en Python :  Interaction avec le système d'exploitation, gestion des fichiers et
répertoires, exécution de commandes système, gestion des processus .
35) Un algorithme peut être représenté de deux façons :  Organigramme : Représentation graphique utilisant
des symboles pour visualiser un algorithme. Cette méthode est maintenant presque abandonnée .
 Pseudo-code : Représentation textuelle imitant un langage de programmation sans contraintes de syntaxe.
Plus pratique et largement utilisée.
36) Quelles sont les caractéristiques d'un objet en Python :  *Identité :* Adresse mémoire de l'objet.
 *Type :* Intrinsèque ou défini par l'utilisateur.  *Données :* Valeur de l'objet.  *Comparaison :*
L'opérateur is compare l'identité de deux objets, tandis que l'opérateur == compare le contenu de deux objets.
37) Quels sont les modes d'utilisation de Python :  *Mode Interactif :* Les instructions sont exécutées
directement par l'interpréteur Python.  *Mode Script :* Le code est écrit dans un fichier.py et exécuté via une
commande.
38) Héritage multiple : Hériter de plusieurs classes parentes (complexité accrue) .
39) Interfaces : Définir des méthodes sans implémentation (polymorphisme) .
40) *Polymorphisme de paramètre :* Capacité d'une méthode à accepter des paramètres de types différents et à se
comporter différemment selon le type de paramètre .
41) *Classes abstraites :* Classe qui ne peut pas être instanciée directement et qui peut contenir des méthodes
abstraites (méthodes sans implémentation) .
42) *Méthodes de classe :* Méthodes associées à la classe, pouvant accéder aux attributs de classe mais pas aux
attributs d'instance .
43) *Méthodes statiques :* Méthodes associées à la classe elle-même, appelables sans instanciation .
44) *Composition :* Principe où un objet est composé d'autres objets, créant une relation "a un" .
45) Agrégation :* Principe où les objets sont associés de manière moins forte que la composition; l'objet agrégé
peut exister indépendamment .
46) Avantages de la Modélisation Objet :  Clarté : Compréhension aisée du système et de ses interactions .
 Modularité : Code organisé en modules réutilisables .  Flexibilité : Ajout aisé de nouvelles fonctionnalités .
 Maintenance : Modifications ciblées et facilitées .
47) Méthodes d'Accès : (Getters) . /// Et de Modification : (Setters) .
48) Quelle est l’utilité d’un Langage : Un langage de programmation permet de communiquer des instructions à un
ordinateur pour qu'il exécute des tâches spécifiques .
49) Variable en programmation : Les variables sont des espaces de stockage pour les données .
50) Condition en programmation : Les conditions permettent d'exécuter du code en fonction de certaines
conditions .
51) Quelle est l'utilité d'une boucle en programmation : Les boucles permettent de répéter des instructions un
certain nombre de fois Ou tant qu'une condition est vraie .
52) Fonction en programmation : Les fonctions sont des blocs de code réutilisables qui effectuent une tâche
spécifique .
53) Les types élémentaires en Python : int / bool / str / float / NoneType .
1) Ligne de commande PowerShell pour charger le contenu du fichier dans la variable Users :
 $Users = Import-Csv -Path "D:\Employees.csv"
2) Commande PowerShell pour créer un utilisateur local :  New-LocalUser -Name "username" -Password
(ConvertTo-SecureString "password" -AsPlainText -Force) -Description "description"
3) Afficher les services en cours d'exécution sur votre ordinateur :
 Get-Service | Where-Object { $_.Status -eq 'Running' }
4) Afficher tous les services dont le nom commence par « x » :  Get-Service -Name x*
5) Pour arrêter le processus Word :  Stop-Process -Name WINWORD
6) Obtenir les informations du contrôleur vidéo :  Get-WmiObject Win32_VideoController
7) Obtenir les informations du système d'exploitation :  Get-WmiObject Win32_OperatingSystem
8) Afficher la date actuelle :  Get-Date
9) Définir la date et l'heure :  set-date -date "2024-03-12 23:30"
10) Sauvegarder la liste des lecteurs PSDrive dans un fichier :  get-psdrive | out-file -filepath C:\test\nom.txt
11) Afficher des événements Système :  Get-EventLog -LogName System
12) Vérifier si le chemin « nom\new » existe (True or False) :  Test-Path nom\new
13) Renommer l'élément « test » en « new » :  Rename-Item -Path test -NewName new
14) Vérifier la liste des utilisateurs actifs sur votre machine :  Get-LocalUser
15) Créer un utilisateur nommé « Nom » avec le mot de passe "testtest" puis le supprimer :
 $pass = Read-Host -AsSecureString
 New-LocalUser -Name "Nom" -Password $pass
 Remove-LocalUser -Name Nom
16) Créer un groupe local nommé « Groupe-Nom » :  New-LocalGroup -Name "Groupe-Nom"
17) Ajouter l'utilisateur «Nom» au groupe «Groupe» : Add-LocalGroupMember -Name "Groupe" -Member Nom
18) Vérifier si le pare-feu est actif pour les profils Private et Public et afficher uniquement les champs « Name » et «
Enabled » :  Get-NetFirewallProfile -Profile Public, Private | ft Name, Enabled
19) Désactiver le pare-feu pour les profils Private et Domain :
 Set-NetFirewallProfile -Profile Domain, Private -Enabled False
20) Activer le pare-feu pour les profils Private et Domain :
 Set-NetFirewallProfile -Profile Domain, Private -Enabled True
21) Créez un nouveau répertoire nommé Projets sous C:\ :  New-Item -Type Directory -Path C:\Projets
22) Créez deux sous-répertoires Documentation et Code sous C:\Projets :
 New-Item -Type Directory -Path C:\Projets\Documentation, C:\Projets\Code
23) Script Python :
import os

# 1. Créez un nouveau répertoire nommé "test"

test_dir = r"C:\Users\ID\Desktop\test"
os.makedirs(test_dir, exist_ok=True)

# 2. Créez 5 sous-répertoires "rep0" à "rep4" dans le répertoire "test"

for i in range(5):
os.makedirs(rf"{test_dir}\rep{i}", exist_ok=True)

# 3. Créez des fichiers texte "matiere0" à "matiere4" dans chaque répertoire

for i in range(5):
with open(rf"{test_dir}\rep{i}\matiere{i}.txt", "w") as file:
# 4. Écrivez la phrase dans chaque fichier texte
file.write("c'est un nouveau fichier")
24) S
25) D
26) D
27) D
28) D
29) D
30) D
31) Donnez la commande Linux à utiliser pour installer le service openssh :  sudo apt-get install openssh-server
32) 1)  sudo systemctl start ssh
2)  ip a
3) établir une connexion ssh avec l'hôte qui a l'adresse 192.168.1.10 :  ssh [email protected]
33) Comment on peut installer La bibliothèque python-crontab :  pip install python-crontab .
34) Utiliser systemctl pour vérifier l'état d'un service :  systemctl status nom_du_service
35) Nommer la machine avec le nom ISTA :  sudo hostnamectl set-hostname ISTA
36) afficher les 10 premières lignes d'un fichier en Linux :  head -n 10 fichier.txt
37) Python ( Script temps d'execution ) :
import time
start = time.time()
a=0
for i in range(1000):
a += (i**1000)
end = time.time()
print(f"==> Le temps d'execution de programme est : {round(end-start, 4)}")
38) Crontab :
nano test.sh
chmod +x test.sh
crontab -e
*/5 * * * * /usr/bin/bash /home/sirius/Desktop/test.sh
* */1.5 * * 1-5 /usr/bin/bash /home/sirius/Desktop/test.sh
* * * * *
- - - - -
| | | | |
| | | | +Jour de la semaine (0-7) où 0 et 7 sont le dimanche
| | | +Mois (1-12) ou nom
| | +Jour du mois (1-31)
| +Heures (0-23)
+Minutes (0-59)

39) Shell :
#!/bin/bash
# Création du répertoire Exo3 s'il n'existe pas encore
mkdir -p Exo3
# Définition des noms de fichiers et de leur contenu pour "Un" et "Deux"
declare -A files
files=( ["Un"]="Première ligne" ["Deux"]="Deuxième ligne" )
# Boucle pour créer les fichiers "Un" et "Deux" avec leur contenu respectif
for file in "${!files[@]}"; do
echo "${files[$file]}" > Exo3/$file
done
40) Création des sous-répertoires :
#!/bin/bash
# Création des sous-répertoires M1, M2, M3, M4 dans le répertoire MODULES
mkdir -p MODULES/M1 MODULES/M2 MODULES/M3 MODULES/M4
# Création d'un fichier f1 dans le sous-répertoire M1
touch MODULES/M1/f1
# Écriture de la ligne "Bonjour ID" dans le fichier f1
echo "Bonjour ID" > MODULES/M1/f1
41) Compter le nombre de ligne dans le fichier « cities » :  wc -l cities
42) Compter le nombre de mots dans le fichier « cities » :  wc -w cities
43) Compter le nombre de caractères dans le fichier « cities » :  wc -c cities
44) Compter le nombre de (caractères, mots et lignes) :  wc cities
45) #################################### Listes ########################################
46) # ==> Créer une liste vide :
47) my_list = []
48) print(my_list)
49) # ==> Créer une liste d'entiers :
50) int_list = [1, 2, 3, 4, 5]
51) print(int_list)
52) print(int_list[0])
53) # ==> Accéder à un élément en utilisant son index :
54) list = [3, 5, 8, 0]
55) #######[0, 1, 2, 3]#########
56) print(list[0]) # [0] kay3ni lewel f liste li howa fhad l7ala number 3
57) print(list[1]) # [1] kay3ni tani f liste li howa fhad l7ala number 5
58) print(list[2]) # ...
59) # ==> Créer une liste contenant d'autres listes :
60) nested_list = [[1, 2, 3], ["a", "b", "c"], [True, False]]
61) print(nested_list)
62) print(nested_list[1])
63) # ==> Utiliser index() pour obtenir l'index de la première occurrence d'un élément spécifique :
64) list = ["Sirius", "Hamza", "Mohamed", "Sirius"]
65) print(list.index("Sirius"))
66) # ==> Créer une liste de chaînes de caractères :
67) str_list = ["Sirius", "Hamza", "Mohamed"]
68) print(str_list)
69) print(str_list[0])
70) # ==> Liste contenant des types de données différents :
71) mixed_list = [1, "Sirius", 3.14, True]
72) print(mixed_list)
73) # ==> Utiliser append() pour ajouter un élément à la fin de la liste :
74) my_list = []
75) my_list.append("tefa7a")
76) my_list.append("limona")
77) print(my_list)
78) # ==> Utiliser insert() pour ajouter un élément à une position spécifique :
79) my_list = ["tefa7a", "limona"]
80) my_list.insert(1, "banana")
81) print(my_list)
82) # ==> Utiliser remove() pour supprimer la première occurrence d'un élément spécifique :
83) my_list = ["tefa7a", "banana", "limona"]
84) my_list.remove("tefa7a")
85) print(my_list)
86) # ==> Utiliser pop() pour supprimer un élément à une position spécifique :
87) my_list = ["banana", "limona"]
88) my_list.pop(1)
89) print(my_list)
90) # ==> Utiliser del pour supprimer un élément à une position spécifique :
91) my_list.append("dla7a")
92) print(my_list)
93) print(my_list[0]) # ==> my_list[0] fiha banana
94) del my_list[0] # ==> Supprimer banana
95) print(my_list)
96) # ==> Utiliser clear() pour vider complètement la liste :
97) my_list = ["dla7a"]
98) my_list.clear()
99) print(my_list)
100) # ==> Accéder au dernier élément en utilisant un index négatif :
101) list = [3, 5, 8, 6]
102) print(list[-1])
103) # ==> Accéder à une tranche de la liste (slicing) :
104) list = [3, 5, 8, 6]
105) print(list[0:3])
106) # ==> Modifier un élément spécifique :
107) list = [3, 5, 8, 6]
108) list[0] = 9
109) print(list)
110) # ==> Modifier une tranche de la liste :
111) int_list = [3, 7, 1, 4]
112) int_list[1:3] = [20, 30]
113) print(int_list)
114) # ==> Parcourir les éléments de la liste avec une boucle for :
115) str_list = ["Sirius", "Leo", "Messi"]
116) for i in str_list:
117) print(i)
118) # ==> Utiliser in pour vérifier la présence d'un élément (True or False) :
119) str_list = ["Sirius", "Leo", "Messi"]
120) print("Messi" in str_list)
121) print("Ronaldo" in str_list)
122) # ==> Utiliser sort() pour trier la liste de manière permanente :
123) list = [3, 7, 1, 4, 99, 2]
124) list.sort()
125) print(list)
126) # ==> Utiliser reverse() pour inverser la liste de manière permanente :
127) list = [56, 2, 9, 4, 33, 6]
128) list.reverse()
129) print(list)
130) # ==> Utiliser copy() pour copier une liste :
131) old_list = [56, 2, 9, 4, 33, 6]
132) new_list = old_list.copy()
133) print(new_list)
134) # ==> Utiliser split() pour convertir une chaîne en une liste :
135) old_list = "My name is Sirius"
136) split_list = old_list.split(" ")
137) print(split_list)
138) #################################### Tuple ########################################
139) # ==> Créer un tuple vide :
140) my_tuple = ()
141) print(my_tuple)
142) # ==> Créer un tuple avec des éléments :
143) my_tuple = ("Sirius", 10)
144) print(my_tuple)
145) # ==> Accéder à un élément dans un tuple en utilisant son index :
146) my_tuple = (3, "test", 5, 8, 0)
147) print(my_tuple[0])
148) print(my_tuple[1])
149) print(my_tuple[1:4])
150) # ==> Tuples imbriqués :
151) nested_tuple = ((1, 2, 3), ("a", "b", "c"), (True, False))
152) print(nested_tuple)
153) print(nested_tuple[1])
154) # ==> Utiliser index() pour obtenir l'index d'un élément spécifique :
155) my_tuple = ("Sirius", "Hamza", "Mohamed", "Sirius")
156) print(my_tuple.index("Sirius"))
157) # ==> Créer un tuple sans parenthèses :
158) my_tuple = 1, 2, 3
159) print(my_tuple)
160) # ==> Convertir une liste en tuple :
161) my_list = [1, 2, 3, 4, 5, 6]
162) my_tuple = tuple(my_list)
163) print(my_tuple)
164) # ==> Vérifier la présence d'un élément dans un tuple (Test d'appartenance) :
165) my_tuple = ("Sirius", "Leo", "Messi")
166) print("Messi" in my_tuple)
167) print("Ronaldo" in my_tuple)
168) # ==> Utiliser des tuples comme clés dans des dictionnaires (car ils sont immuables) :
169) groupe = {(1, 2): "m3a 8:30", (3, 4): "m3a 11:00"}
170) print(groupe[(1, 2)])
171) # ==> Combiner des tuples :
172) tuple1 = (1, 2, 3)
173) tuple2 = (4, 5, 6)
174) combined_tuple = tuple1 + tuple2
175) print(combined_tuple)
176) # ==> Répéter des éléments d'un tuple :
177) my_tuple = (1, 2, 3)
178) repeated_tuple = my_tuple * 3
179) print(repeated_tuple)
180) # ==> Déballage des valeurs d'un tuple (Unpacking) :
181) my_tuple = ("Sirius", "0799999999", 21)
182) name, number, age = my_tuple
183) print(name)
184) print(number)
185) print(age)
186) #################################### Dictionnaires ########################################
187) # ==> Créer un dictionnaire vide :
188) my_dict = {}
189) print(my_dict)
190) # ==> Créer un dictionnaire avec des éléments :
191) my_dict = {"name": "Sirius", "age": 21, "city": "Space"}
192) print(my_dict)
193) # ==> Accéder à une valeur en utilisant sa clé :
194) my_dict = {"name": "Sirius", "age": 21, "city": "Space"}
195) print(my_dict["name"])
196) print(my_dict["age"])
197) # ==> Ajouter un nouvel élément :
198) my_dict = {"name": "Sirius", "age": 21}
199) my_dict["city"] = "Space" # Ajouter un nouvel élément
200) print(my_dict)
201) # ==> Modifier un élément existant :
202) my_dict = {"name": "Sirius", "age": 20}
203) my_dict["age"] = 22
204) print(my_dict)
205) # ==> Supprimer un élément en utilisant sa clé :
206) my_dict = {"name": "Sirius", "age": 21, "city": "Space"}
207) del my_dict["city"]
208) print(my_dict)
209) # ==> Obtenir toutes les clés, toutes les valeurs et tous les éléments (paires clé-valeur) :
210) my_dict = {"name": "Sirius", "age": 21, "city": "Space"}
211) print(my_dict.keys())
212) print(my_dict.values())
213) print(my_dict.items())
214) # ==> Parcourir les éléments d'un dictionnaire avec une boucle for :
215) my_dict = {"name": "Sirius", "age": 21, "city": "Space"}
216) for key, value in my_dict.items():
217) print(f"{key}: {value}")
218)
219) # ==> Vérifier la présence d'une clé dans un dictionnaire :
220) my_dict = {"name": "Sirius", "age": 21, "city": "Space"}
221) print("name" in my_dict)
222) print("note" in my_dict)
223) # ==> Utiliser un dictionnaire imbriqué (dictionnaire à l'intérieur d'un dictionnaire) :
224) nested_dict = {"student1": {"name": "Sirius", "age": 21}, "student2": {"name": "Anonymous", "age": 22}}
225) # ==> Copier un dictionnaire :
226) my_dict = {"name": "Sirius", "age": 21, "city": "Space"}
227) new_dict = my_dict.copy()
228) print(new_dict)
229) #################################### Ensemble / Sets ########################################
230) # ==> Création d'un ensemble vide :
231) my_set = set()
232) my_new_set = ()
233) print(my_set)
234) print(my_new_set)
235) # ==> Ajouter des éléments à un ensemble :
236) my_set.add("Sirius")
237) my_set.add("Alex")
238) my_set.add("test")
239) my_set.add(10 + 20)
240) my_set.add(100)
241) print(my_set)
242) # ==> Supprimer des éléments d'un ensemble :
243) my_set.remove(100)
244) print(my_set)
245) # or discard() :
246) my_set.discard(100)
247) print(my_set)
248) # ==> Vérifier la présence d'un élément dans l'ensemble (True or False) :
249) print("Sirius" in my_set)
250) print("You" in my_set)
251) # ==> Ensembles comme filtre de recherche (Membership Test / ‫ )التحقق من العضوية‬:
252) if "Sirius" in my_set:
253) print("==> Oui !!")
254) else:
255) print("==> Non !!")
256) # ==> Éliminer les doublons d'une liste à l'aide de set() :
257) doublons = {3, 2, 1, 2, 3, 3, 3, 3, 1}
258) print(set(doublons))
259) # ==> Convertir une liste imbriquée en ensemble :
260) liste_de_listes = [[1, 2], [3, 4], [1, 2]]
261) ensemble_de_listes = set(map(tuple, liste_de_listes))
262) print(ensemble_de_listes)
263) g
264) g