💻 Tuto 20 : Fonctions Avancées – Sorts Puissants ✨

Les fonctions avancées, c’est quoi ?

Yo, prêt à devenir un sorcier cyber légendaire ? Dans Tuto 19, t’as appris à créer des listes en compréhension comme un alchimiste. Maintenant, on va booster tes fonctions (Tuto 11) avec des paramètres par défaut, des arguments variables (*args, **kwargs), et des fonctions lambda. Chaque fonction avancée est un sort puissant qui donne une âme versatile à ton code ! 🪄

Pour un hacker éthique, ces outils sont clés : ils permettent de créer des scripts flexibles, comme un outil de scan qui accepte divers paramètres Nmap. Mais on reste responsable : on code pour apprendre, pas pour causer des soucis !

Astuce Éthique : Tes sorts avancés sont comme des charmes NarcoShield. Utilise-les pour aider, pas pour nuire !

Comment marchent les fonctions avancées ?

Les fonctions avancées ajoutent de la flexibilité :

• Paramètres par défaut : Valeurs automatiques si non fournies (ex. : def scan(port=80)).
• *args : Accepte un nombre variable d’arguments positionnels (ex. : def log(*args)).
• **kwargs : Accepte un nombre variable d’arguments nommés (ex. : def config(**kwargs)).
• Lambda : Fonctions anonymes en une ligne (ex. : lambda x: x*2).

Exemple :

def scan_port(port=80, *args, **kwargs):
    extras = [str(a) for a in args]
    options = [f"{k}={v}" for k, v in kwargs.items()]
    return f"Scan port {port}, extras: {extras}, options: {options}"

print(scan_port())  # Scan port 80, extras: [], options: []
print(scan_port(443, "test", mode="fast"))  # Scan port 443, extras: ['test'], options: ['mode=fast']

double = lambda x: x * 2
print(double(5))  # Affiche 10
            

Analogie : Une fonction avancée, c’est comme un sort cyber amélioré. Les paramètres par défaut sont des ingrédients de base, *args et **kwargs te laissent ajouter ce que tu veux, et une lambda est un sort rapide jeté en un instant !

Hacking tie-in : Un hacker éthique utilise ces outils pour des scripts adaptables, comme un scanner qui gère des ports multiples ou des options variées.

De quoi t’as besoin ?

T’as tout prêt si t’as suivi les tutos précédents :

• Un ordinateur : Avec Python installé (python.org).
• IDLE : Ton atelier pour coder et tester.
• De la magie : Prêt à lancer des sorts cyber puissants !

Si Python ou IDLE coince, check Tuto 1 pour l’installation. Demande à un adulte si besoin !

Astuce : Ouvre IDLE et prépare-toi à invoquer des sorts avancés !

Créer un programme avec des fonctions avancées, étape par étape

Suis ces étapes pour coder un programme qui utilise des fonctions avancées pour simuler un outil de hack flexible. C’est comme forger un sort cyber surpuissant !

1. Ouvre IDLE
   Lance IDLE et clique sur Fichier > Nouveau Fichier pour ouvrir une fenêtre vide, ton nouveau grimoire cyber avancé.
   

   Astuce : Vérifie que t’es dans une nouvelle fenêtre, pas l’interpréteur “>>>”.

2. Écris ton code
   Tape ce code dans la fenêtre :

   def hack_tool(port=80, *targets, **options):
       targets_list = [t for t in targets]  # Liste des cibles
       settings = {k: v for k, v in options.items()}  # Dictionnaire des options
       scan = lambda p: f"Port {p} {'ouvert' if p % 2 == 0 else 'fermé'}"
       result = scan(port)
       return f"Hack sur {port} pour {targets_list} avec {settings}: {result}"
   
   name = input("C’est quoi ton nom ? ")
   try:
       port_input = input("Port à scanner (appuie Entrée pour 80) : ")
       port = int(port_input) if port_input else 80
       targets = input("Cibles séparées par des espaces (ex. : IP1 IP2) : ").split()
       speed = input("Vitesse (ex. : rapide, lente) : ")
       verbose = input("Mode verbeux (oui/non) : ")
       options = {"speed": speed, "verbose": verbose} if speed and verbose else {}
       if port < 1 or port > 65535:
           print("Port invalide, choisis entre 1 et 65535 !")
       else:
           print(hack_tool(port, *targets, **options))
   except ValueError:
       print("Erreur : entre un numéro valide pour le port !")
                       

   Explication : input() (Tuto 5) demande un nom, un port, des cibles, et des options. Une fonction hack_tool (Tuto 11) utilise un paramètre par défaut (port=80), *targets pour des cibles variables, et **options pour des paramètres nommés. Une lambda simule un scan. Des listes en compréhension (Tuto 19) traitent les cibles et options. Un try/except (Tuto 17) gère les erreurs de port, et une if (Tuto 6) valide le port.
   

   Astuce : Respecte l’indentation (4 espaces) après def, try, if, et les compréhensions !

3. Sauvegarde ton programme
   Clique sur Fichier > Enregistrer. Nomme-le “fonctions_avancees.py” et sauve-le dans un dossier (ex. : “Mes Documents”). Note l’emplacement !
   

   Astuce : Choisis un nom simple sans espaces (ex. : “fonctions_avancees.py”).

4. Lance ton programme
   Clique sur Exécuter > Exécuter le Module (ou F5). Une fenêtre s’ouvrira, demandant les entrées. Essaye (ex. : “Jonathan”, “80”, “192.168.1.1 192.168.1.2”, “rapide”, “oui”):

   C’est quoi ton nom ? Jonathan
   Port à scanner (appuie Entrée pour 80) : 80
   Cibles séparées par des espaces (ex. : IP1 IP2) : 192.168.1.1 192.168.1.2
   Vitesse (ex. : rapide, lente) : rapide
   Mode verbeux (oui/non) : oui
   Hack sur 80 pour ['192.168.1.1', '192.168.1.2'] avec {'speed': 'rapide', 'verbose': 'oui'}: Port 80 ouvert
                       

   Teste avec Entrée pour le port par défaut, sans cibles, ou une entrée invalide (ex. : “abc” pour le port). Si ça marche, t’as lancé un sort cyber avancé ! Si non, passe à “Si ça coince”.
   

   Astuce : Teste différentes combinaisons pour voir la flexibilité !

5. Joue avec ton code
   Change le port par défaut (ex. : port=443) ou la lambda (ex. : lambda p: f"Port {p} scanné"). Modifie les options (ex. : ajouter "timeout": 5). Ajuste la validation (ex. : port < 0). Relance (F5) pour tester. Amuse-toi !
   

   Astuce : Essaye des cibles fun, comme “localhost” !

Pourquoi c’est important pour le hacking ?

Les fonctions avancées rendent tes programmes flexibles et puissants :

• Adapter : Gère des entrées variées, comme des IPs ou options multiples.
• Simplifier : Réduit le code avec des lambdas ou des arguments variables.
• Construire : Les fonctions avancées sont la base pour des outils polyvalents, comme des scanners.

Hacking tie-in : Un hacker éthique utilise *args et **kwargs pour des scripts Nmap qui acceptent des cibles et paramètres divers, et des lambdas pour des tests rapides.

Si ça coince : que faire ?

Pas de stress, nomade, les sorts avancés peuvent foirer ! Voici des astuces :

• Erreur “ValueError” ? : Vérifie que try/except gère les entrées non numériques pour int(port_input).
• Résultat bizarre ? : Vérifie que *targets et **options sont bien passés (hack_tool(port, *targets, **options)) et que les compréhensions produisent des listes.
• Lambda échoue ? : Assure-toi que la lambda est simple (ex. : lambda p: f"Port {p}") et appelée correctement.
• Perdu ? : Relis lentement ou pose une question à Bot-Y. Il est ton guide cyber !

Prêt pour la suite ?

Bravo, t’es un sorcier cyber des fonctions avancées ! T’as appris à créer des sorts flexibles comme un pro. Dans le Tuto 21, on va créer un simulateur de scan réseau, un projet final pour tout déchirer. Ouvre IDLE, jeune nomade, et continue à coder comme un hacker éthique ! 💖