Introduction détaillée aux trois modes de fonctionnement développés par python

Cet article présente principalement en détail des informations pertinentes sur les trois modes de fonctionnement du développement Python. Les amis qui en ont besoin peuvent se référer à

Trois modes de fonctionnement de Python

. Python, en tant que langage de script, est utilisé dans un large éventail d'applications. Certains étudiants l'utilisent pour développer des algorithmes, d'autres pour vérifier la logique et certains l'utilisent comme langage adhésif pour lier l'ensemble du processus système. Dans tous les cas, la manière d'utiliser Python dépend de vos propres scénarios commerciaux et de vos propres capacités d'application Python. Personnellement, je pense que Python peut être utilisé à la fois pour le développement commercial et le développement de prototypes de produits. De manière générale, Python fonctionne principalement dans les trois modes suivants.

1. Mode boucle unique

Le mode boucle unique est le plus utilisé, le plus simple, et bien sûr le plus stable. Pourquoi ? Parce que moins de code est écrit dans une seule boucle et qu'il y a moins de risques d'erreurs. Par conséquent, tant que l'interface est écrite correctement, le risque d'erreurs est généralement très faible. Bien entendu, nous ne disons pas qu’une seule boucle est inutile, bien au contraire. Le mode boucle unique est le mode que nous utilisons le plus souvent. Ce type de développement est particulièrement adapté à certains gadgets, petites applications et petites scènes.

#!/usr/bin/python
import os
import sys
import re
import signal
import time

g_exit = 0

def sig_process(sig, frame):
  global g_exit
  g_exit = 1
  print 'catch signal'

def main():
  global g_exit
  signal.signal(signal.SIGINT, sig_process)
  while 0 == g_exit:
    time.sleep(1)

    '''
    module process code
    ''' 

if __name__ == '__main__':
  main()

2. Mode multi-threading

Le mode multi-threading est souvent utilisé dans des situations qui sont sujet au blocage. Par exemple, lecture et écriture de clients multithreads, accès Web multithread, etc. Une caractéristique du multi-threading ici est que chaque thread est créé en fonction du client. Un exemple simple est un socket serveur. Utilisez un socket pour créer un thread, de sorte que s'il y a plusieurs utilisateurs, plusieurs threads se connecteront simultanément. Cette méthode est relativement simple et rapide à utiliser. L'inconvénient est que toutes les activités peuvent être exécutées simultanément et que la protection globale des données est très gênante.

#!/usr/bin/python
import os
import sys
import re
import signal
import time
import threading

g_exit=0

def run_thread():
  global g_exit
  while 0 == g_exit:
    time.sleep(1)

    '''
    do jobs per thread
    '''

def sig_process(sig, frame):
  global g_exit
  g_exit = 1

def main():

  global g_exit

  signal.signal(signal.SIGINT, sig_process)
  g_threads = []
  for i in range(4):
    td = threading.Thread(target = run_thread)
    td.start()
    g_threads.append(td)

  while 0 == g_exit:
    time.sleep(1)

  for i in range(4):
    g_threads[i].join()


if __name__ == '__main__':
  main()

3. Le mode réacteur

Le mode réacteur n'est pas compliqué pour faire simple, il l'est. utiliser le multi-threading pour gérer toutes les activités. Si une activité a été traitée par un thread, les autres threads ne peuvent pas traiter à nouveau l'activité. De cette façon, cela équivaut à résoudre un problème, qui est le problème de verrouillage que nous avons mentionné plus tôt. Par conséquent, pour les développeurs de ce modèle, écrire des affaires est en fait une affaire simple, car tout ce sur quoi ils doivent se concentrer est leur propre tiers d'acre. Le skynet écrit auparavant par Yunfeng était d'un tel modèle, mais il a été développé en utilisant C Lua. En fait, tant que vous comprenez le modèle du réacteur lui-même, le langage que vous utilisez pour le développement n'a pas d'importance. La clé est de comprendre l'essence du réacteur.

S'il est écrit sous forme de code, cela devrait être comme ceci,

#!/usr/bin/python

import os
import sys
import re
import time
import signal
import threading

g_num = 4
g_exit =0
g_threads = []
g_sem = []
g_lock = threading.Lock()
g_event = {}

def add_event(name, data):
  global g_lock
  global g_event

  if '' == name:
    return

  g_lock.acquire()
  if name in g_event:
    g_event[name].append(data)
    g_lock.release()
    return

  g_event[name] = []

  '''
  0 means idle, 1 means busy
  '''
  g_event[name].append(0)
  g_event[name].append(data)
  g_lock.release()

def get_event(name):
  global g_lock
  global g_event

  g_lock.acquire()
  if '' != name:
    if [] != g_event[name]:
      if 1 != len(g_event[name]):
        data = g_event[name][1]
        del g_event[name][1]
        g_lock.release()
        return name, data
      else:
        g_event[name][0] = 0

  for k in g_event:
    if 1 == len(g_event[k]):
      continue

    if 1 == g_event[k][0]:
      continue

    g_event[k][0] =1
    data = g_event[k][1]
    del g_event[k][1]
    g_lock.release()
    return k, data

  g_lock.release()
  return '', -1

def sig_process(sig, frame):
  global g_exit
  g_exit =1
  print 'catch signal'

def run_thread(num):
  global g_exit
  global g_sem
  global g_lock

  name = ''
  data = -1

  while 0 == g_exit:
    g_sem[num].acquire()

    while True: 
      name, data = get_event(name)
      if '' == name:
        break

      g_lock.acquire()
      print name, data
      g_lock.release()


def test_thread():
  global g_exit

  while 0 == g_exit:
    for i in range(100):
      add_event(&#39;1&#39;, (i << 2) + 0)
      add_event(&#39;2&#39;, (i << 2) + 1)
      add_event(&#39;3&#39;, (i << 2) + 2)
      add_event(&#39;4&#39;, (i << 2) + 3)

    time.sleep(1)


def main():
  global g_exit
  global g_num
  global g_threads
  global g_sem

  signal.signal(signal.SIGINT, sig_process)
  for i in range(g_num):
    sem = threading.Semaphore(0)
    g_sem.append(sem)
    td = threading.Thread(target=run_thread, args=(i,))
    td.start()
    g_threads.append(td)

  &#39;&#39;&#39;
  test thread to give data
  &#39;&#39;&#39;
  test = threading.Thread(target=test_thread)
  test.start()

  while 0 == g_exit:
    for i in range(g_num):
      g_sem[i].release()
    time.sleep(1)

  &#39;&#39;&#39;
  call all thread to close
  &#39;&#39;&#39;
  for i in range(g_num):
    g_sem[i].release()

  for i in range(g_num):
    g_threads[i].join()

  test.join()
  print &#39;exit now&#39;

&#39;&#39;&#39;
entry
&#39;&#39;&#39;
if __name__ == &#39;__main__&#39;:
  main()

Merci Reading, j'espère que cela pourra aider tout le monde, merci pour votre soutien à ce site !

Pour une introduction plus détaillée aux trois modes de fonctionnement du développement Python et des articles connexes, veuillez faire attention au site Web PHP chinois !