docs: update Scripting/Python/POO

Scripting.md

@@ -2,7 +2,7 @@
 title: Scripting
 description: Les différents langage de scripts avec leurs tutoriels !
 published: true
-date: 2021-11-17T10:08:17.543Z
+date: 2022-10-11T14:15:51.173Z
 tags: 
 editor: markdown
 dateCreated: 2021-05-24T14:30:53.085Z
@@ -21,8 +21,9 @@ dateCreated: 2021-05-24T14:30:53.085Z
  - [💎 Conditions et boucles *IF, ELSE, ELIF, WHILE, Comparaisons, etc...*](/Scripting/Python/Conditions-Boucles)
  - [💎 Manipulation de données *Listes, dictionnaires, parcourir des fichiers,...*](/Scripting/Python/Manip-donnees)
   - [💎 Programmation Orientée Objet (POO)*Comprendre la notion d'objet*](/Scripting/Python/POO)
- - [💎 Méthodes (Fonctions)*Fonctions de base, actions sur objet, décorateurs*](/Scripting/Python/Fonctions-Avancées)
+ - [💎 Méthodes (Fonctions)*Utiliser les méthodes*](/Scripting/Python/Fonctions-Avancées)
   - [💎 Gestion des erreurs/exceptions *Anticiper les erreurs*](/Scripting/Python/exceptions)
+  - [💎 Threading *Paralléliser les opérations*](/Scripting/Python/threading)
 {.links-list}
 
 # Powershell

Scripting/Python/Fonctions-Avancées.md

@@ -2,7 +2,7 @@
 title: Python - Fonctions avancées
 description: 
 published: true
-date: 2022-01-26T15:50:50.684Z
+date: 2022-10-11T14:13:14.207Z
 tags: 
 editor: markdown
 dateCreated: 2021-05-24T16:13:51.003Z
@@ -10,7 +10,7 @@ dateCreated: 2021-05-24T16:13:51.003Z
 
 ![Fichier:Python logo and wordmark.svg — Wikipédia](https://upload.wikimedia.org/wikipedia/commons/thumb/f/f8/Python_logo_and_wordmark.svg/1200px-Python_logo_and_wordmark.svg.png)
 
-# Fonction basique
+# Fonctions
 Une fonction (ou méthode), est un bloc d'instructions réutilisable. Si vous venez à réécrire plusieurs fois les mêmes lignes dans votre code, cela signifie que vous pouvez les mettre sous forme de fonction. Votre code sera alors beaucoup plus lisible.
 
 ## Déclarer une fonction 
@@ -115,73 +115,27 @@ if __name__ == '__main__':
 >>> addition : 6
 >>> Il fait beau aujourd'hui
 ```
-
-# Fonction de classe
-
-# Le constructeur
-
-Un constructeur est une méthode spéciale d'une classe qui permet de construire un objet, de lui donner des attributs.
-
-Le nom de cette méthode est “ \_\_init\_\_ ” et prend en premier argument “ self ”, qui représente l'objet courant, qui est cours de création.
-
-*Exemple : je crée un constructeur permettant de définir une personne* 
-
+Mais à quoi sert cette fonction ? Tout simplement à pouvoir utiliser les fonctions du script dans un autre script, à l'aide d'un *import*. Si les instructions sont décrites directement à la racine du code, elles seront exécutées dès l'import.
+Observons la valeur de \_\_name\_\_ lorsque l'on exécute le script directement :
 ```python
-class People:
-    def __init__(self,firstname,lastname,age):
-        self.firstname = firstname
-        self.lastname  = lastname
-        self.age       = age
+#./script1.py
+
+print(__name__)
+
+>>> __main__
 ```
-
-Notre fonction init demande 3 paramètres, “ self ” étant un paramètre spécial. 
-
-Grâce à ce constructeur il ne reste qu'à créer des objets : 
-
+Ici, \_\_name\_\_ est égal à \_\_main\_\_. Maintenant, observons sa valeur lorsque le script est appelé depuis un import :
 ```python
->>> chuck = People("Chuck","Norris",81)
+#./script2.py
+
+import script1
+
+>>> script1
 ```
+Suite à l'import dans *script2*, le print de *script1* s'éxecute puisqu'il est à la racine (tout comme le *if \_\_name\_\_ == '\_\_main\_\_'*). On remarque que cette fois, \_\_name\_\_ est égal à *script1*.
+En vérifiant que \_\_name\_\_ est égal à \_\_main\_\_, on s'assure alors que le script est exécuté directement, et non en tant que module, nous permettant de réutiliser nos méthodes dans d'autres scripts.
 
-L'objet “chuck” a été créé, on peut désormais accéder à ses différents attributs, les lire et les modifier.
-
-```python
->>> chuck.firstname
-'Chuck'
->>> chuck.firstname = "Chucky"
->>> chuck.firstname
-'Chucky'
-```
-
-# Le représentateur
-
-Reprenons l'exemple précédent. Lorsque l'on souhaite afficher notre objet, la valeur retournée n'est pas tout à fait celle attendue.
-
-```python
->>> chuck
-<__main__.People object at 0x03C12820>
-```
-
-Nous allons donc utiliser un représentateur pour mettre en forme l'objet.
-
-Cette méthode se définit “ \_\_repr\_\_ ”.
-
-```python
-class People:
-    def __init__(self,firstname,lastname,age):
-        self.firstname = firstname
-        self.lastname  = lastname
-        self.age       = age
-
-    def __repr__(self):
-        return "Nom : %s , Prenom : %s , Age : %s" % (self.lastname, self.firstname, self.age)
-```
-
-```python
->>> repr(chuck)
-'Nom : Norris , Prenom : Chuck , Age : 81'
-```
-
-# Le décorateur
+## Le décorateur
 
 Le décorateur est une fonction permettant de modifier le comportement d'autres fonctions, évitant la répétition de code. Il est appelé par “ @nom\_décoraeur ”.
 

Scripting/Python/Manip-donnees.html

@@ -2,7 +2,7 @@
 title: Python - Manipulation des données
 description: 
 published: true
-date: 2021-11-17T10:37:48.278Z
+date: 2022-10-11T10:52:08.520Z
 tags: 
 editor: ckeditor
 dateCreated: 2021-06-07T08:01:47.026Z
@@ -37,6 +37,26 @@ python est cool
 C# est cool
 java est cool
 C++ est cool</code></pre>
+<h2>Shallow copy vs Deep copy</h2>
+<p>Lorsqu'on copie une liste, il faut bien faire attention à la méthode employée.</p>
+<p>La première méthode est de simplement affecter à une variable la liste précédente. C'est le shallow copy. Cette méthode ne crée pas une seconde liste, mais renvoie au même index dans la pile. Si on modifie la première liste, ça modifie donc la deuxième aussi !</p>
+<pre><code class="language-python">&gt;&gt;&gt; l1 = [1,2,3]
+&gt;&gt;&gt; l2 = l1
+
+&gt;&gt;&gt; l1[1] = 64
+&gt;&gt;&gt; print(l2)
+
+[1,64,3]</code></pre>
+<p>Si on veut créer une seconde liste indépendante, on réalisera donc une deep copy grâce à la fonction <i>deepcopy</i>.</p>
+<pre><code class="language-python">&gt;&gt;&gt; import copy
+
+&gt;&gt;&gt; l1 = [1,2,3]
+&gt;&gt;&gt; l2 = copy.deepcopy(l1)
+
+&gt;&gt;&gt; l1[1] = 64
+&gt;&gt;&gt; print(l2)
+
+[1,2,3]</code></pre>
 <h1>Les tuples</h1>
 <p>Les tuples ressemblent à des listes mais ne sont pas modifiables après leur création. Ils sont définis avec des parenthèses :</p>
 <pre><code class="language-python">&gt;&gt;&gt; tup = (1,2,3)

Scripting/Python/POO.md

@@ -2,7 +2,7 @@
 title: Python - Programmation Orientée Objet (POO) 
 description: Comprendre la notion de programmation orientée objet
 published: true
-date: 2021-11-17T10:23:19.431Z
+date: 2022-10-11T14:41:40.154Z
 tags: 
 editor: markdown
 dateCreated: 2021-11-17T09:11:34.380Z
@@ -36,5 +36,81 @@ Par exemple, si nous construisons une voiture nous pouvons la définir comme sui
 
 De la même façon, si nous avons construit un objet "maison" avec un garage, nous pourrons les faire interagir entre eux en définissant, par exemple, que le garage reçoit l'information "bip ouverture" et ouvre la porte. L'objet voiture pourra alors avancer (seule puisque c'est une Tesla) à la réception de l'information "pas d'obstacle" (ex : `if front_captor == 0: move(forward)`). Enfin, le garage pourra se fermer après réception du signal "voiture rentrée".
 
-> Cette section présente uniquement le concept de POO. Pour apprendre à créer des objets, voir la rubrique "Méthodes"
-{.is-info}
+# Utilisation des objets
+## Déclarer une classe
+Une classe est tout simplement déclarée par *"class ClassName:"*, puis les méthodes et attributs associés (indentés). Selon les bonnes pratiques, le nom de la classe doit être attaché, sans tiret, avec une majuscule à chaque mot.
+Il est possible de délcarer des attributs de classe :
+```python
+class Demo:
+    var = 1
+
+print(Demo.var)
+
+>>> 1
+```
+> **Attention** : ici nous parlons bien d'un attribut de **classe** et non d'objet. Pour les attributs d'objet, rendez-vous au chapitre suivant sur le constructeur.
+{.is-warning}
+
+## Le constructeur
+
+Un constructeur est une méthode spéciale d'une classe qui permet de construire un objet, de lui donner des attributs.
+
+Le nom de cette méthode est “ \_\_init\_\_ ” et prend en premier argument “ self ”, qui représente l'objet courant, qui est cours de création.
+
+*Exemple : je crée un constructeur permettant de définir une personne* 
+
+```python
+class People:
+    def __init__(self,firstname,lastname,age):
+        self.firstname = firstname
+        self.lastname  = lastname
+        self.age       = age
+```
+
+Notre fonction init demande 3 paramètres, “ self ” étant un paramètre spécial. 
+
+Grâce à ce constructeur il ne reste qu'à créer des objets : 
+
+```python
+>>> chuck = People("Chuck","Norris",81)
+```
+
+L'objet “chuck” a été créé, on peut désormais accéder à ses différents attributs, les lire et les modifier.
+
+```python
+>>> chuck.firstname
+'Chuck'
+>>> chuck.firstname = "Chucky"
+>>> chuck.firstname
+'Chucky'
+```
+
+## Le représentateur
+
+Reprenons l'exemple précédent. Lorsque l'on souhaite afficher notre objet, la valeur retournée n'est pas tout à fait celle attendue.
+
+```python
+>>> chuck
+<__main__.People object at 0x03C12820>
+```
+
+Nous allons donc utiliser un représentateur pour mettre en forme l'objet.
+
+Cette méthode se définit “ \_\_repr\_\_ ”.
+
+```python
+class People:
+    def __init__(self,firstname,lastname,age):
+        self.firstname = firstname
+        self.lastname  = lastname
+        self.age       = age
+
+    def __repr__(self):
+        return "Nom : %s , Prenom : %s , Age : %s" % (self.lastname, self.firstname, self.age)
+```
+
+```python
+>>> repr(chuck)
+'Nom : Norris , Prenom : Chuck , Age : 81'
+```
+

Scripting/Python/threading.md

@@ -0,0 +1,92 @@
+---
+title: Threading
+description: Paralléliser les opérations
+published: true
+date: 2022-10-11T09:37:14.419Z
+tags: 
+editor: markdown
+dateCreated: 2022-10-11T09:10:42.435Z
+---
+
+![Fichier:Python logo and wordmark.svg — Wikipédia](https://upload.wikimedia.org/wikipedia/commons/thumb/f/f8/Python_logo_and_wordmark.svg/1200px-Python_logo_and_wordmark.svg.png)
+
+# Threading
+## Exécuter plusiuers fonctions en même temps
+Certaines fonctions d'un programme peuvent prendre du temps à s'exécuter. Cependant, vous ne souhaitez pas forcément que tout le programme s'arrête pour cette fonction. Pour une interface graphique par exemple ! Si une action requiert un certain temps, vous ne souhaiterez certainement pas planter toute l'interface. C'est là que le multi-threading intervient.
+
+Prenons l'exemple suivant :
+```python
+def wait(duration):
+    time.sleep(duration)
+    print("j'ai attendu")
+
+def hello():
+    print("Hello")
+
+wait(5)
+hello()
+
+>>> j'ai attendu
+>>> Hello
+```
+Dans ce cas, on doit attendre que la fonction "wait" ait terminé son exécution pour passer à la suite. On va donc créer des threads :
+```python
+import threading
+import time
+
+def wait(duration):
+    time.sleep(duration)
+    print("j'ai attendu")
+
+def hello():
+    print("Hello")
+
+wait = threading.Thread(target=wait, args=(2,))
+hello = threading.Thread(target=hello)
+
+wait.start()
+hello.start()
+
+>>> Hello
+>>> j'ai attendu
+```
+Ici, on voit que la fonction "hello" n'a pas attendu la fin de "wait" pour se lancer.
+Pour créer le thread, on appelle la fonction *Thread* de la library *threading* (en l'affectant à une variable) avec les arguments suivants :
+- target : le nom de la fonction à exécuter
+- args (optionnel) : si la fonction a besoin d'arguments, on les donne ici
+Ensuite, on lance le thread avec la fonciton *start*
+> **Attention :** J'attire votre attention sur la virgule après le *2* dans les args. En effet, un tuple est attendu. Si vous n'avez qu'un seul argument à donner, il faut donc mettre une virgule pour indiquer qu'il s'agit d'un tuple.
+{.is-warning}
+
+## Attendre la fin de l'exécution d'un thread
+Si vous ne voulez pas bloquer tout le programme pour une fonciton, il peut tout de même y avoir des dépendances. Il faudra donc préciser que le thread doit être terminé avant de continuer le script à l'aide de la fonction *join*.
+Dans cet exemple, la fonction *end* doit être executée en dernier. On indique alors que les threads doivent avoir terminé leur exécution :
+```python
+import threading
+import time
+
+def wait(duration):
+    time.sleep(duration)
+    print("j'ai attendu")
+
+def hello():
+    print("Hello")
+    
+def end():
+    print("execution terminée")
+
+wait = threading.Thread(target=wait, args=(2,))
+hello = threading.Thread(target=hello)
+
+wait.start()
+hello.start()
+
+wait.join()
+print_stg.join()
+
+end()
+
+>>> Hello
+>>> j'ai attendu
+>>> execution terminée
+```