développement back-endTutoriel PythonIntroduction détaillée au positionnement et à la destruction dans les threads Python (avec exemples)Introduction détaillée au positionnement et à la destruction dans les threads Python (avec exemples)
Cet article vous apporte une introduction détaillée au positionnement et à la destruction dans les threads Python (avec des exemples). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.
Je sentais que quelque chose n'allait pas avant le début du travail et j'avais l'impression que j'allais en assumer la responsabilité. Non, c’est le troisième jour de travail qui me fait culpabiliser.
Nous avons un programme d'arrière-plan incroyable qui peut charger dynamiquement des modules et les exécuter de manière threadée. De cette manière, les fonctions du plug-in sont réalisées. Lorsque le module est mis à jour, le programme en arrière-plan lui-même ne se fermera pas. Il fermera uniquement le thread correspondant au module, mettra à jour le code puis le démarrera.
J'ai donc écrit un module pour montrer mes compétences, mais j'ai oublié d'écrire la fonction de sortie, ce qui entraînait la création d'un nouveau thread à chaque fois que le module était mis à jour. À moins que le programme ne soit redémarré, ces threads seraient créés. rester en vie.
Ce n'est pas possible. Il faut trouver un moyen de le nettoyer, sinon j'ai peur qu'il explose.
Alors comment le nettoyer ? Tout ce à quoi je pense, c'est deux étapes :
Découvrez le numéro de fil qui doit être nettoyé
Détruisez-les ; 🎜>
#coding: utf8
import threading
import os
import time
def tt():
info = threading.currentThread()
while True:
print 'pid: ', os.getpid()
print info.name, info.ident
time.sleep(3)
t1 = threading.Thread(target=tt)
t1.setName('OOOOOPPPPP')
t1.setDaemon(True)
t1.start()
t2 = threading.Thread(target=tt)
t2.setName('EEEEEEEEE')
t2.setDaemon(True)
t2.start()
t1.join()
t2.join()Sortie :
root@10-46-33-56:~# python t.py pid: 5613 OOOOOPPPPP 139693508122368 pid: 5613 EEEEEEEEE 139693497632512 ...Vous pouvez voir la sortie du nom du thread dans Python C'est exactement comme ce qu'on a mis en place, mais le résultat de Ps me fait douter de la vie :
root@10-46-33-56:~# ps -Tp 5613 PID SPID TTY TIME CMD 5613 5613 pts/2 00:00:00 python 5613 5614 pts/2 00:00:00 python 5613 5615 pts/2 00:00:00 pythonNormalement, ça ne devrait pas être comme ça, je suis un peu confus. Est-ce que je me souviens mal de tout. le long de? Utilisez une autre version linguistique du multi-threading pour tester : Version C du multi-threading
#include<stdio.h>
#include<sys>
#include<sys>
#include<pthread.h>
void *test(void *name)
{
pid_t pid, tid;
pid = getpid();
tid = syscall(__NR_gettid);
char *tname = (char *)name;
// 设置线程名字
prctl(PR_SET_NAME, tname);
while(1)
{
printf("pid: %d, thread_id: %u, t_name: %s\n", pid, tid, tname);
sleep(3);
}
}
int main()
{
pthread_t t1, t2;
void *ret;
pthread_create(&t1, NULL, test, (void *)"Love_test_1");
pthread_create(&t2, NULL, test, (void *)"Love_test_2");
pthread_join(t1, &ret);
pthread_join(t2, &ret);
}</pthread.h></sys></sys></stdio.h>Sortie :
root@10-46-33-56:~# gcc t.c -lpthread && ./a.out pid: 5575, thread_id: 5577, t_name: Love_test_2 pid: 5575, thread_id: 5576, t_name: Love_test_1 pid: 5575, thread_id: 5577, t_name: Love_test_2 pid: 5575, thread_id: 5576, t_name: Love_test_1 ...Vérifiez à nouveau avec la commande PS :
root@10-46-33-56:~# ps -Tp 5575 PID SPID TTY TIME CMD 5575 5575 pts/2 00:00:00 a.out 5575 5576 pts/2 00:00:00 Love_test_1 5575 5577 pts/2 00:00:00 Love_test_2C'est exact, le nom du fil est effectivement visible via PS ! Mais pourquoi ne puis-je pas voir celui de Python ? Puisque le nom du fil est défini via
, jetons un coup d'œil à la définition : setName
[threading.py] class Thread(_Verbose): ... @property def name(self): """A string used for identification purposes only. It has no semantics. Multiple threads may be given the same name. The initial name is set by the constructor. """ assert self.__initialized, "Thread.__init__() not called" return self.__name @name.setter def name(self, name): assert self.__initialized, "Thread.__init__() not called" self.__name = str(name) def setName(self, name): self.name = name ...Ce que vous voyez ici définit simplement les propriétés de l'objet
, et il n'a pas touché les fondamentaux. Ensuite, je ne peux absolument pas le voir ~Thread
ou ps, nous ne pouvons donc le résoudre qu'à l'intérieur. Python. /proc/
peut parfaitement résoudre ce problème ! Pourquoi ?threading.enumerate
objets thread actifs, à l'exclusion de ceux terminés et non démarrés.
[threading.py] def enumerate(): """Return a list of all Thread objects currently alive. The list includes daemonic threads, dummy thread objects created by current_thread(), and the main thread. It excludes terminated threads and threads that have not yet been started. """ with _active_limbo_lock: return _active.values() + _limbo.values()Parce que nous obtenons l'objet Thread, nous pouvons obtenir les informations relatives au fil de discussion grâce à cela ! Veuillez consulter l'exemple de code complet :
#coding: utf8
import threading
import os
import time
def get_thread():
pid = os.getpid()
while True:
ts = threading.enumerate()
print '------- Running threads On Pid: %d -------' % pid
for t in ts:
print t.name, t.ident
print
time.sleep(1)
def tt():
info = threading.currentThread()
pid = os.getpid()
while True:
print 'pid: {}, tid: {}, tname: {}'.format(pid, info.name, info.ident)
time.sleep(3)
return
t1 = threading.Thread(target=tt)
t1.setName('Thread-test1')
t1.setDaemon(True)
t1.start()
t2 = threading.Thread(target=tt)
t2.setName('Thread-test2')
t2.setDaemon(True)
t2.start()
t3 = threading.Thread(target=get_thread)
t3.setName('Checker')
t3.setDaemon(True)
t3.start()
t1.join()
t2.join()
t3.join()Sortie :
root@10-46-33-56:~# python t_show.py pid: 6258, tid: Thread-test1, tname: 139907597162240 pid: 6258, tid: Thread-test2, tname: 139907586672384 ------- Running threads On Pid: 6258 ------- MainThread 139907616806656 Thread-test1 139907597162240 Checker 139907576182528 Thread-test2 139907586672384 ------- Running threads On Pid: 6258 ------- MainThread 139907616806656 Thread-test1 139907597162240 Checker 139907576182528 Thread-test2 139907586672384 ------- Running threads On Pid: 6258 ------- MainThread 139907616806656 Thread-test1 139907597162240 Checker 139907576182528 Thread-test2 139907586672384 ------- Running threads On Pid: 6258 ------- MainThread 139907616806656 Checker 139907576182528 ...Le code semble un peu long, mais la logique est assez simple,
et Thread-test1 Ils affichent tous le pid actuel, l'identifiant du thread et le nom du thread, puis quittent après 3 secondes. Il s'agit de simuler la sortie normale du thread. Thread-test2
génère tous les threads actifs du processus en cours jusqu'à Checker chaque seconde. threading.enumerate
et Thread-test1 sont visibles au début. Lorsqu'ils sortent, il ne reste que Thread-test2 et MainThread eux-mêmes. Checker
soit devenu noir et fou, et que nous devions l'arrêter, alors nous pouvons le résoudre de cette façon : Thread-test2
def _async_raise(tid, exctype):
"""raises the exception, performs cleanup if needed"""
tid = ctypes.c_long(tid)
if not inspect.isclass(exctype):
exctype = type(exctype)
res = ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, ctypes.py_object(exctype))
if res == 0:
raise ValueError("invalid thread id")
elif res != 1:
ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, None)
raise SystemError("PyThreadState_SetAsyncExc failed")
def stop_thread(thread):
_async_raise(thread.ident, SystemExit)
def get_thread():
pid = os.getpid()
while True:
ts = threading.enumerate()
print '------- Running threads On Pid: %d -------' % pid
for t in ts:
print t.name, t.ident, t.is_alive()
if t.name == 'Thread-test2':
print 'I am go dying! Please take care of yourself and drink more hot water!'
stop_thread(t)
print
time.sleep(1) sort
root@10-46-33-56:~# python t_show.py pid: 6362, tid: 139901682108160, tname: Thread-test1 pid: 6362, tid: 139901671618304, tname: Thread-test2 ------- Running threads On Pid: 6362 ------- MainThread 139901706389248 True Thread-test1 139901682108160 True Checker 139901661128448 True Thread-test2 139901671618304 True Thread-test2: I am go dying. Please take care of yourself and drink more hot water! ------- Running threads On Pid: 6362 ------- MainThread 139901706389248 True Thread-test1 139901682108160 True Checker 139901661128448 True Thread-test2 139901671618304 True Thread-test2: I am go dying. Please take care of yourself and drink more hot water! pid: 6362, tid: 139901682108160, tname: Thread-test1 ------- Running threads On Pid: 6362 ------- MainThread 139901706389248 True Thread-test1 139901682108160 True Checker 139901661128448 True // Thread-test2 已经不在了Après une opération, même si nous traitons
comme ça, il se soucie toujours de nous : Thread-test2 Boire plus d'eau chaude ,
;
Nous ne pouvons même pas tuer les threads directement comme tuer des processus via des signaux, car kill ne peut répondre à nos attentes qu'en traitant des processus, mais il n'est évidemment pas possible de traiter les threads, quel que soit le thread qui est tué, l'ensemble du processus. va sortir!
Et à cause du GIL, de nombreux enfants pensent que les threads de Python sont implémentés par Python lui-même et n'existent pas réellement. Python devrait pouvoir les détruire directement, n'est-ce pas ?
Cependant, en fait, les threads de Python sont de vrais threads !
Qu'est-ce que cela signifie ? Les threads Python sont des threads natifs créés par le système d'exploitation via pthread. Python utilise uniquement GIL pour contraindre ces threads afin de décider quand commencer la planification. Par exemple, après avoir exécuté un certain nombre d'instructions, le GIL sera remis. Quant à savoir qui remportera l'oiran, cela dépend du système d'exploitation.
S'il s'agit d'un simple fil de discussion, le système dispose en fait d'un moyen d'y mettre fin, tel que : pthread_exit, pthread_kill ou pthread_cancel Pour plus de détails, veuillez consulter : https://www. cnblogs.com/Creat ..
Quel dommage : Il n'y a pas d'encapsulation de ces méthodes au niveau Python ! Oh mon Dieu, tellement en colère ! Peut-être que les gens pensent que les fils doivent être traités avec douceur.
Comment quitter un fil de discussion en douceur
Si vous voulez quitter un fil de discussion en douceur, c'est presque un non-sens~
Soit quitter après l'exécution, soit définir le bit d'indicateur, et vérifiez fréquemment le bit d'indicateur. Si vous devez quitter, quittez simplement.
Extension
"Comment terminer correctement un thread enfant en cours d'exécution" : https://www.cnblogs.com/Creat...
"Ne détruisez pas grossièrement les threads python" ：http://xiaorui.cc/2017/02/22/...
Bienvenue à tous les experts pour donner des conseils et échanger, groupe de discussion QQ : 258498217
Veuillez noter la réimpression de la source Ming : https://segmentfault.com/a/11...
Introduction détaillée au positionnement et à la destruction dans les threads Python (avec exemples)
Publié il y a 3 jours
Python : Positionnement et destruction des threads
c
linux-
266 lectures Il faut 30 minutes pour lire
ContexteAvant de commencer le travail, je sentais que quelque chose n'allait pas et j'avais l'impression que j'allais en prendre la responsabilité. Non, c’est le troisième jour de travail qui me fait culpabiliser. Nous avons un programme d'arrière-plan incroyable qui peut charger dynamiquement des modules et les exécuter dans des threads. De cette manière, les fonctions du plug-in peuvent être réalisées. Lorsque le module est mis à jour, le programme en arrière-plan lui-même ne se fermera pas. Il fermera uniquement le thread correspondant au module, mettra à jour le code puis le démarrera. J'ai donc écrit un module pour montrer mes compétences, mais j'ai oublié d'écrire la fonction de sortie, ce qui a entraîné la création d'un nouveau thread à chaque fois que le module était mis à jour. À moins que le programme ne soit redémarré, ces threads seraient créés. rester en vie. Ce n'est pas possible. Il faut trouver un moyen de le nettoyer, sinon j'ai peur qu'il explose. Alors comment le nettoyer ? Tout ce à quoi je pense, c'est deux étapes :
Découvrez le numéro de fil qui doit être nettoyé
Détruisez-les ; 🎜>
Découvrez l'ID du filSemblable au dépannage habituel, vérifiez d'abord l'état du fil du processus cible via la commande ps, car le nom du fil a été défini par setName, donc normalement je devrais voir le fil de discussion correspondant. Utilisez directement le code suivant pour simuler ce fil : Version Python du multi-threading- Sortie :
- Vous pouvez voir la sortie du nom du fil dans Python C'est exactement comme ce qu'on a mis en place, mais le résultat de Ps me fait douter de la vie :
Normalement, ça ne devrait pas être comme ça, je suis un peu confus. Est-ce que je me souviens mal de tout. le long de? Utilisez une autre version linguistique du multi-threading pour tester :
Version C du multi-threading
Vérifiez à nouveau avec la commande PS :
#coding: utf8 import threading import os import time def tt(): info = threading.currentThread() while True: print 'pid: ', os.getpid() print info.name, info.ident time.sleep(3) t1 = threading.Thread(target=tt) t1.setName('OOOOOPPPPP') t1.setDaemon(True) t1.start() t2 = threading.Thread(target=tt) t2.setName('EEEEEEEEE') t2.setDaemon(True) t2.start() t1.join() t2.join()C'est exact, le nom du fil est effectivement visible via PS !
root@10-46-33-56:~# python t.py pid: 5613 OOOOOPPPPP 139693508122368 pid: 5613 EEEEEEEEE 139693497632512 ...
Mais pourquoi ne puis-je pas voir celui de Python ? Puisque le nom du fil est défini via, jetons un coup d'œil à la définition :
root@10-46-33-56:~# ps -Tp 5613 PID SPID TTY TIME CMD 5613 5613 pts/2 00:00:00 python 5613 5614 pts/2 00:00:00 python 5613 5615 pts/2 00:00:00 python
Ce que vous voyez ici définit simplement les propriétés de l'objet
, et il n'a pas touché les fondamentaux. Ensuite, je ne peux absolument pas le voir ~Il semble que nous ne puissions plus rechercher les noms de threads python en externe par des moyens tels que#include<stdio.h> #include<sys> #include<sys> #include<pthread.h> void *test(void *name) { pid_t pid, tid; pid = getpid(); tid = syscall(__NR_gettid); char *tname = (char *)name; // 设置线程名字 prctl(PR_SET_NAME, tname); while(1) { printf("pid: %d, thread_id: %u, t_name: %s\n", pid, tid, tname); sleep(3); } } int main() { pthread_t t1, t2; void *ret; pthread_create(&t1, NULL, test, (void *)"Love_test_1"); pthread_create(&t2, NULL, test, (void *)"Love_test_2"); pthread_join(t1, &ret); pthread_join(t2, &ret); }</pthread.h></sys></sys></stdio.h>ou, nous ne pouvons donc le résoudre qu'à l'intérieur. Python.
root@10-46-33-56:~# gcc t.c -lpthread && ./a.out pid: 5575, thread_id: 5577, t_name: Love_test_2 pid: 5575, thread_id: 5576, t_name: Love_test_1 pid: 5575, thread_id: 5577, t_name: Love_test_2 pid: 5575, thread_id: 5576, t_name: Love_test_1 ...
La question devient donc : comment obtenir tous les threads en cours d'exécution dans Python ?root@10-46-33-56:~# ps -Tp 5575 PID SPID TTY TIME CMD 5575 5575 pts/2 00:00:00 a.out 5575 5576 pts/2 00:00:00 Love_test_1 5575 5577 pts/2 00:00:00 Love_test_2
peut parfaitement résoudre ce problème ! Pourquoi ?Parce qu'il est clairement indiqué dans la documentation de la fonction ci-dessous, renvoyant tous lesobjets thread
setNameactifs, à l'exclusion de ceux terminés et non démarrés.[threading.py] class Thread(_Verbose): ... @property def name(self): """A string used for identification purposes only. It has no semantics. Multiple threads may be given the same name. The initial name is set by the constructor. """ assert self.__initialized, "Thread.__init__() not called" return self.__name @name.setter def name(self, name): assert self.__initialized, "Thread.__init__() not called" self.__name = str(name) def setName(self, name): self.name = name ...
Parce que nous obtenons l'objet Thread, nous pouvons obtenir les informations liées au fil de discussion grâce à cela !
Veuillez consulter l'exemple de code complet :Thread
Le code semble un peu long, mais la logique est assez simple,ps/proc/Sortie :et
threading.enumerateIls affichent tous le pid actuel, l'identifiant du thread et le nom du thread, puis quittent après 3 secondes. Il s'agit de simuler la sortie normale du thread.Et le thread génère tous les threads actifs du processus en cours jusqu'à chaque seconde.
[threading.py] def enumerate(): """Return a list of all Thread objects currently alive. The list includes daemonic threads, dummy thread objects created by current_thread(), and the main thread. It excludes terminated threads and threads that have not yet been started. """ with _active_limbo_lock: return _active.values() + _limbo.values()
On voit clairement que les informations deet
sont visibles au début. Lorsqu'ils sortent, il ne reste queet
eux-mêmes.#coding: utf8 import threading import os import time def get_thread(): pid = os.getpid() while True: ts = threading.enumerate() print '------- Running threads On Pid: %d -------' % pid for t in ts: print t.name, t.ident print time.sleep(1) def tt(): info = threading.currentThread() pid = os.getpid() while True: print 'pid: {}, tid: {}, tname: {}'.format(pid, info.name, info.ident) time.sleep(3) return t1 = threading.Thread(target=tt) t1.setName('Thread-test1') t1.setDaemon(True) t1.start() t2 = threading.Thread(target=tt) t2.setName('Thread-test2') t2.setDaemon(True) t2.start() t3 = threading.Thread(target=get_thread) t3.setName('Checker') t3.setDaemon(True) t3.start() t1.join() t2.join() t3.join()Détruisez le fil spécifié
root@10-46-33-56:~# python t_show.py pid: 6258, tid: Thread-test1, tname: 139907597162240 pid: 6258, tid: Thread-test2, tname: 139907586672384 ------- Running threads On Pid: 6258 ------- MainThread 139907616806656 Thread-test1 139907597162240 Checker 139907576182528 Thread-test2 139907586672384 ------- Running threads On Pid: 6258 ------- MainThread 139907616806656 Thread-test1 139907597162240 Checker 139907576182528 Thread-test2 139907586672384 ------- Running threads On Pid: 6258 ------- MainThread 139907616806656 Thread-test1 139907597162240 Checker 139907576182528 Thread-test2 139907586672384 ------- Running threads On Pid: 6258 ------- MainThread 139907616806656 Checker 139907576182528 ...
Maintenant que nous pouvons obtenir le nom et l'identifiant du fil, nous pouvons également tuer le fil spécifié !Thread-test1Supposons maintenant queThread-test2soit devenu noir et fou, et que nous devions l'arrêter, alors nous pouvons le résoudre de cette façon :Sur la base du code ci-dessus, ajoutez et complétez Le code suivant :
sortCheckerthreading.enumerate
, PS : Bien que l'eau chaude soit bonne, huit tasses suffisent, alors ne soyez pas gourmand.Thread-test1Thread-test2Après une opération, même si nous traitonsMainThreadcomme ça, il se soucie toujours de nous :CheckerBoire plus d'eau chaudeRetour à l'histoire principale, la méthode ci-dessus est extrêmement grossière. Pourquoi dites-vous cela ?
Parce que son principe est le suivant : utiliser l'API intégrée de Python pour déclencher une exception sur le thread spécifié, lui permettant de se fermer automatiquement
;
N'utilisez pas cette méthode en dernier recours, car il existe une certaine probabilité de déclencher des problèmes indescriptibles. Souviens-toi! Ne me demandez pas pourquoi je sais...
Pourquoi est-il si difficile d'arrêter un thread ?
Le multithread lui-même est conçu pour la concurrence collaborative dans le cadre du processus. unité de planification. Les threads partagent les ressources, il y aura donc de nombreux mécanismes de verrouillage et contrôles d’état.
Si vous utilisez la force pour tuer des threads, il y a de fortes chances que des bugs inattendus se produisent. Et la libération la plus importante des ressources de verrouillage peut également provoquer des problèmes inattendus.
Nous ne pouvons même pas tuer le thread directement comme tuer le processus via un signal, car kill ne peut répondre à nos attentes qu'en traitant des processus, mais il n'est évidemment pas possible de traiter les threads, quel que soit le thread. est tué, tout le processus se terminera !
Et à cause du GIL, de nombreux enfants pensent que les threads de Python sont implémentés par Python lui-même et n'existent pas réellement. Python devrait pouvoir les détruire directement, n'est-ce pas ?
Cependant, en fait, les threads de Python sont de vrais threads !
Qu'est-ce que cela signifie ? Les threads Python sont des threads natifs créés par le système d'exploitation via pthread. Python utilise uniquement GIL pour contraindre ces threads afin de décider quand commencer la planification. Par exemple, après avoir exécuté un certain nombre d'instructions, le GIL sera remis. Quant à savoir qui remportera l'oiran, cela dépend du système d'exploitation.
S'il s'agit d'un simple fil de discussion, le système dispose en fait d'un moyen d'y mettre fin, tel que :
pthread_exit,pthread_killoupthread_cancelPour plus de détails, veuillez consulter : https://www. cnblogs.com/Creat ..Quel dommage : Il n'y a pas d'encapsulation de ces méthodes au niveau Python ! Oh mon Dieu, tellement en colère ! Peut-être que les gens pensent que les fils doivent être traités avec douceur.
Comment quitter un fil de discussion en douceur
Si vous voulez quitter un fil de discussion en douceur, c'est presque un non-sens~
Soit quitter après l'exécution, soit définir le bit d'indicateur, et vérifiez fréquemment le bit d'indicateur. Si vous devez quitter, quittez simplement.
Extension
"Comment terminer correctement un thread enfant en cours d'exécution" : https://www.cnblogs.com/Creat...
"Ne détruisez pas grossièrement les threads python" ：http://xiaorui.cc/2017/02/22/...Bienvenue à tous les experts pour donner des conseils et échanger, groupe de discussion QQ : 258498217
Veuillez noter la réimpression de la source Ming : https://segmentfault.com/a/11...Tous droits réservés
-
Si vous pensez que mon article vous est utile, n'hésitez pas à le féliciter
Vous pourriez vous sentir intéressé
2 commentaires Tri temporel
Si c'était moi qui pouvais tuer -9, je préférerais en tuer mille par erreur plutôt que d'en laisser un partir, palourde
Répondre
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
En quoi les tableaux Numpy diffèrent-ils des tableaux créés à l'aide du module de tableau?Apr 24, 2025 pm 03:53 PMNumpyArraysarebetterFornumericalOperations andMulti-dimensionaldata, tandis que la réalisation de la réalisation
Comment l'utilisation des tableaux Numpy se compare-t-il à l'utilisation des tableaux de modules de tableau dans Python?Apr 24, 2025 pm 03:49 PMNumpyArraysareBetterForheAVYVumericalComputing, tandis que la réalisation de points contraints de réalisation.1) NumpyArraySoFerversATACTORATIONS ajusté pour les données
Comment le module CTYPES est-il lié aux tableaux dans Python?Apr 24, 2025 pm 03:45 PMCTYPESALLOWSCREATINGAndMANIPulationc-styLearRaySInpython.1) UsectypeStOinterfaceWithClibraryForPerformance.2) Createc-stylearRaysFornumericalComptations.3) PassArrayStocfunction
Définissez 'Array' et 'List' dans le contexte de Python.Apr 24, 2025 pm 03:41 PMInpython, une "liste" isaversatile, mutablesencethatcanholdmixed datatypes, tandis que "tableau" est une cohérence homogène, une séquestre.
Une liste Python est-elle mutable ou immuable? Qu'en est-il d'un tableau Python?Apr 24, 2025 pm 03:37 PMPythonlistsandarraysarebothmutable.1) listsaxiblendupportheterogeneousdatabutarelessmemory-efficace.2) ArraysareMoreMory-EfficientForHomogeneousDatabutlessversatile, nécessitant un niveaumorypecodeusagetoavoiderrors.
Python vs C: Comprendre les principales différencesApr 21, 2025 am 12:18 AMPython et C ont chacun leurs propres avantages, et le choix doit être basé sur les exigences du projet. 1) Python convient au développement rapide et au traitement des données en raison de sa syntaxe concise et de son typage dynamique. 2) C convient à des performances élevées et à une programmation système en raison de son typage statique et de sa gestion de la mémoire manuelle.
Python vs C: Quelle langue choisir pour votre projet?Apr 21, 2025 am 12:17 AMLe choix de Python ou C dépend des exigences du projet: 1) Si vous avez besoin de développement rapide, de traitement des données et de conception du prototype, choisissez Python; 2) Si vous avez besoin de performances élevées, de faible latence et de contrôle matériel, choisissez C.
Atteindre vos objectifs python: la puissance de 2 heures par jourApr 20, 2025 am 12:21 AMEn investissant 2 heures d'apprentissage Python chaque jour, vous pouvez améliorer efficacement vos compétences en programmation. 1. Apprenez de nouvelles connaissances: lire des documents ou regarder des tutoriels. 2. Pratique: Écrivez du code et complétez les exercices. 3. Revue: consolider le contenu que vous avez appris. 4. Pratique du projet: Appliquez ce que vous avez appris dans les projets réels. Un tel plan d'apprentissage structuré peut vous aider à maîtriser systématiquement Python et à atteindre des objectifs de carrière.
Outils d'IA chauds
Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes
AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.
Undress AI Tool
Images de déshabillage gratuites
Clothoff.io
Dissolvant de vêtements AI
Video Face Swap
Échangez les visages dans n'importe quelle vidéo sans effort grâce à notre outil d'échange de visage AI entièrement gratuit !
Article chaud
Outils chauds
ZendStudio 13.5.1 Mac
Puissant environnement de développement intégré PHP
Dreamweaver Mac
Outils de développement Web visuel
VSCode Windows 64 bits Télécharger
Un éditeur IDE gratuit et puissant lancé par Microsoft
Télécharger la version Mac de l'éditeur Atom
L'éditeur open source le plus populaire
Listes Sec
SecLists est le compagnon ultime du testeur de sécurité. Il s'agit d'une collection de différents types de listes fréquemment utilisées lors des évaluations de sécurité, le tout en un seul endroit. SecLists contribue à rendre les tests de sécurité plus efficaces et productifs en fournissant facilement toutes les listes dont un testeur de sécurité pourrait avoir besoin. Les types de listes incluent les noms d'utilisateur, les mots de passe, les URL, les charges utiles floues, les modèles de données sensibles, les shells Web, etc. Le testeur peut simplement extraire ce référentiel sur une nouvelle machine de test et il aura accès à tous les types de listes dont il a besoin.
