Notes sur les bases de Python (1)

---

Préface

      Notes sur les bases de python.Cet article implique des points de connaissances tels que : le mappage, les collections, la différence entre __new__ et __init__ en python, le passage de références et le passage de valeurs, ainsi que l'introduction et l'utilisation de ThreadPoolExecutor dans les pools de threads.

---

1. Cartographie

     1) Les types de mappage sont un type de conteneur associatif qui stocke la relation de mappage entre les objets.
     2) Dictionary (dict) est le seul type de mappage en Python. Il s'agit d'un conteneur associatif qui stocke les paires clé-valeur (mappage des clés vers les valeurs). Parmi eux, la clé doit être un objet Python hachable et la valeur peut être n'importe quel objet Python.
     3) Les clés du dictionnaire doivent être hachables.

2. Collecte

     1) Un ensemble est une séquence non ordonnée d’éléments non répétitifs.
     2) Vous pouvez utiliser des accolades { } ou la fonction set() pour créer un ensemble. Remarque : Pour créer un ensemble vide, vous devez utiliser set() au lieu de { }, car { } est utilisé pour créer un dictionnaire vide.
     3) Définir en python détermine la position en fonction de la valeur de hachage de l'élément.

3. La différence entre __new__ et __init__ en python

     1) La méthode __init__ est la méthode d'initialisation, qui est appelée après la création de l'objet d'instance, puis définit certaines valeurs initiales des attributs de l'objet.
     2) __new__ est appelé avant la création de l'instance, car sa tâche est de créer une instance puis de renvoyer l'instance. C'est une méthode statique.
     3) Autrement dit, __new__ est appelé avant __init__. La valeur de retour (instance) de __new__ sera transmise au premier paramètre de la méthode __init__, puis __init__ définira certains paramètres pour cette instance.

4. Passage par référence et passage par valeur

     1) Le passage des paramètres Python utilise uniformément le passage de références. Parce que les objets Python sont divisés en objets mutables (liste, dict, ensemble, etc.) et objets immuables (nombre, chaîne, tuple, etc.).
     2) Les objets mutables sont passés par référence. La valeur d'un objet mutable peut être modifiée, de sorte que l'objet d'origine peut être modifié en modifiant la valeur du paramètre. Semblable au passage par référence en langage C.
     3) Les objets immuables sont transmis par valeur. La variable paramètre et la variable d'origine pointent vers la même adresse mémoire, mais l'objet immuable ne peut pas être modifié, donc la réaffectation du paramètre n'affectera pas l'objet d'origine, similaire au transfert de valeur en langage C.

5. ThreadPoolExécuteur du pool de threads

     1) À partir de Python 3.2, la bibliothèque standard nous fournit le module concurrent.futures. Ce module fournit la classe ThreadPoolExecutor. Les fonctions de cette classe sont les suivantes :

• Les discussions peuvent être programmées automatiquement.
• Le thread principal peut obtenir l'état d'un certain thread (ou tâche) et la valeur de retour.
• Lorsqu'un thread se termine, le thread principal le sait immédiatement.
• Rendre l'interface de codage multi-thread et multi-processus cohérente.

     2) ThreadPoolExecutor propose quatre méthodes de construction :

     3) Correspondant à la quatrième explication de paramètre la plus complète dans la figure ci-dessus :

nom	taper	signification
taille du pool de base	int	Taille du pool de threads principaux
taille maximale de la piscine	int	Taille maximale du pool de threads
garderAliveTime	long	Temps d'inactivité maximum du thread
unité	Unité de temps	unité de temps
file d'attente de travail	BlockingQueue<Exécutable>	file d'attente des threads
filFactory	Usine de discussions	Usine de création de threads
gestionnaire	Gestionnaire d'exécution rejeté	Politique de refus

     4) Utilisez ThreadPoolExecutor pour instancier l’objet pool de threads. Transmettez le paramètre max_workers pour définir le nombre maximum de threads pouvant s'exécuter simultanément dans le pool de threads.
     5) La fonction submit soumet la tâche (nom de la fonction et paramètres) que le thread doit effectuer au pool de threads et renvoie le handle de la tâche (similaire aux fichiers et aux dessins). Notez que submit() ne bloque pas, mais revient immédiatement. Grâce au handle de tâche renvoyé par la fonction submit, la méthode done() peut être utilisée pour déterminer si la tâche est terminée.
     6) Le rôle de la méthode as_completed(). Bien que la méthode ci-dessus fournisse un moyen de déterminer si une tâche est terminée, elle ne peut pas toujours être déterminée dans le thread principal. Parfois, lorsque nous savons qu'une tâche est terminée, nous obtenons le résultat au lieu de juger constamment à chaque fois. La tâche est-elle terminée ? À ce stade, vous pouvez utiliser la méthode as_completed() pour récupérer les résultats de toutes les tâches en même temps.
     7) La méthode as_completed() est un générateur qui se bloquera lorsqu'aucune tâche n'est terminée, à moins qu'un délai d'attente ne soit défini. Lorsqu'une certaine tâche est terminée, la tâche cédera (abandonnera les droits d'exécution de la tâche en cours) et l'instruction sous la boucle for pourra être exécutée, puis continuera à se bloquer jusqu'à ce que toutes les tâches soient terminées. Il ressort également des résultats que la tâche terminée en premier sera d'abord notifiée au thread principal.
     8) Utilisation régulière de cas de pool de threads.

#!/usr/bin/python3
# -*- coding: utf-8 -*-

#线程组件
from concurrent.futures import ThreadPoolExecutor,as_completed
import time

def pingScan(self):
    time.sleep(self)
    print("heiheihei".format(self))
    return self

executor = ThreadPoolExecutor(max_workers=2)
urls = [1,2,3]
all_task = [executor.submit(pingScan, (url)) for url in urls]
for future in as_completed(all_task):
    data = future.result()
    print('the result is {}'.format(data))

     9) Utilisez l'instruction with pour construire une instance via ThreadPoolExecutor.

#线程组件
from concurrent.futures import ThreadPoolExecutor,as_completed
import time

def pingScan(self):
    time.sleep(self)
    print("heiheihei".format(self))
    return self

with ThreadPoolExecutor(max_workers=5) as executor:  # 创建一个最大容纳数量为5的线程池
    task1 = executor.submit(pingScan, 1)
    task2 = executor.submit(pingScan, 2)  # 通过submit提交执行的函数到线程池中
    task3 = executor.submit(pingScan, 3)

    print(f"task1: {
      
      task1.done()}")  # 通过done来判断线程是否完成
    print(f"task2: {
      
      task2.done()}")
    print(f"task3: {
      
      task3.done()}")

    time.sleep(2)
    print(f"task1: {
      
      task1.done()}")
    print(f"task2: {
      
      task2.done()}")
    print(f"task3: {
      
      task3.done()}")
    print(task1.result())  # 通过result来获取返回值