Développement Web en Python : Tornado en action

Avec l'essor d'Internet, le développement Web est devenu de plus en plus important dans le domaine informatique. Python, en tant que langage de programmation de haut niveau axé sur l'efficacité du développement, est également devenu populaire dans le domaine du développement Web. Parmi eux, Tornado, un framework réseau léger, occupe une position unique en Python. Il utilise une méthode asynchrone basée sur les E/S, ce qui lui permet de traiter les demandes simultanées plus rapidement que la méthode d'E/S synchrone traditionnelle. Cet article présentera les méthodes et techniques d'utilisation de Tornado pour le développement Web en Python à travers des combats pratiques.

1. Installation et utilisation de base de Tornado

Tout d'abord, nous devons installer Tornado dans l'environnement local. Peut être installé via pip :

pip install tornado

Une fois l'installation terminée, nous pouvons utiliser Tornado pour créer un serveur Web simple.

import tornado.ioloop
import tornado.web

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("Hello, world")

def make_app():
    return tornado.web.Application([
        (r"/", MainHandler),
    ])

if __name__ == "__main__":
    app = make_app()
    app.listen(8888)
    tornado.ioloop.IOLoop.current().start()

Dans le code ci-dessus, nous définissons une classe MainHandler héritée de tornado.web.RequestHandler, qui peut gérer les requêtes GET du client. Dans le constructeur, nous utilisons la méthode self.write() pour renvoyer un message au client. Ensuite, nous définissons la fonction make_app(), qui crée un objet tornado.web.Application. Dans le constructeur de cet objet, nous mappons la route vers la classe MainHandler que nous avons définie et la renvoyons. Enfin, nous créons un objet Application dans le bloc de code if name == "__main__", écoutons sur le port 8888 local et démarrons la boucle IOLoop. Visitez http://localhost:8888 dans votre navigateur local et vous verrez le message « Bonjour tout le monde ».

2. IO asynchrones dans Tornado

En tant que framework Web efficace, le mécanisme basé sur les IO asynchrones de Tornado lui permet de répondre rapidement aux demandes des clients. Dans les opérations d'E/S synchrones traditionnelles, chaque requête doit attendre la fin de la requête précédente avant de passer à la requête suivante. Dans les opérations IO asynchrones, lorsqu'une opération IO est lancée, le thread ne sera pas bloqué pour toujours, mais reviendra immédiatement et continuera à exécuter la requête suivante. Ce mécanisme permet au serveur Web de traiter plusieurs requêtes en même temps, améliorant ainsi les capacités de traitement simultané du système.

Tout d’abord, regardons un exemple d’E/S synchrone.

import tornado.ioloop
import tornado.web
import time

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        time.sleep(5)
        self.write("Hello, world")

def make_app():
    return tornado.web.Application([
        (r"/", MainHandler),
    ])

if __name__ == "__main__":
    app = make_app()
    app.listen(8888)
    tornado.ioloop.IOLoop.current().start()

Dans le code ci-dessus, nous simulons une opération qui prend 5 secondes. Si nous accédons au serveur avec un navigateur, nous constaterons que nous attendrons que la demande soit traitée.

Ensuite, regardons un exemple d'utilisation d'opérations d'E/S asynchrones.

import tornado.ioloop
import tornado.gen
import tornado.web

class MainHandler(tornado.web.RequestHandler):
    @tornado.gen.coroutine
    def get(self):
        yield tornado.gen.sleep(5)
        self.write("Hello, world")

def make_app():
    return tornado.web.Application([
        (r"/", MainHandler),
    ])

if __name__ == "__main__":
    app = make_app()
    app.listen(8888)
    tornado.ioloop.IOLoop.current().start()

Dans le code ci-dessus, nous utilisons le modificateur tornado.gen.coroutine et utilisons l'instruction rendement pour implémenter des opérations d'E/S asynchrones. Cela signifie qu'avant d'exécuter l'instruction rendement, le processeur renverra et traitera immédiatement la requête suivante, et le résultat ne sera renvoyé au client qu'une fois l'opération asynchrone terminée.

3. Multi-threading et multi-processus dans Tornado

En plus de la capacité d'E/S asynchrone, Tornado peut également améliorer les capacités de traitement simultané du serveur grâce à la technologie multi-threading ou multi-processus. Dans Tornado, nous pouvons utiliser deux méthodes pour implémenter le traitement multi-threading ou multi-processus :

1. Utilisez tornado.process.fork_processes() pour activer le mode multi-processus. Cette méthode sera automatiquement allouée à chaque processus en fonction du nombre. des cœurs de processeur correspondant.

import tornado.ioloop
import tornado.web
import tornado.process

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("Hello, world")

def make_app():
    return tornado.web.Application([
        (r"/", MainHandler),
    ])

if __name__ == "__main__":
    app = make_app()
    app.listen(8888)
    tornado.process.fork_processes()
    tornado.ioloop.IOLoop.current().start()

Dans le code ci-dessus, nous utilisons la méthode tornado.process.fork_processes() pour activer le mode multi-processus, afin que nous puissions profiter pleinement du traitement parallèle du CPU.

2. Utilisez tornado.concurrent.futures.ThreadPoolExecutor() pour activer le mode multi-thread.

import tornado.ioloop
import tornado.web
import tornado.concurrent
import concurrent.futures

class MainHandler(tornado.web.RequestHandler):
    executor = concurrent.futures.ThreadPoolExecutor()

    @tornado.concurrent.run_on_executor
    def my_background_task(self):
        # 执行一些耗时的IO操作
        return result

    @tornado.gen.coroutine
    def get(self):
        result = yield self.my_background_task()
        self.write(result)

def make_app():
    return tornado.web.Application([
        (r"/", MainHandler),
    ])

if __name__ == "__main__":
    app = make_app()
    app.listen(8888)
    tornado.ioloop.IOLoop.current().start()

Dans le code ci-dessus, nous utilisons tornado.concurrent.futures.ThreadPoolExecutor() pour activer le mode multi-threading, et utilisons le modificateur @tornado.concurrent.run_on_executor pour transmettre la méthode my_background_task() au pool de threads pour exécution. . De cette façon, nous pouvons gérer plusieurs opérations d’E/S simultanément dans un seul thread.

IV. Résumé

Cet article permet aux lecteurs de comprendre les méthodes et techniques d'utilisation de Tornado pour le développement Web en Python en présentant l'utilisation de base de Tornado, les opérations d'E/S asynchrones, la technologie multithread et multi-processus et des exemples d'utilisation. L'efficacité, la simplicité et la flexibilité de Tornado en font l'un des outils importants pour le développement Web en Python. Bien que Tornado ne soit pas adapté à tous les scénarios Web, dans certains scénarios nécessitant des performances et une concurrence élevées, Tornado montrera ses performances supérieures.

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!