Python + Lua : comment faire cohabiter deux langages dans un même projet

🤝 Le duo « Python + Lua » combine le riche écosystème de Python et la vitesse/intégrabilité de Lua.

Vous trouverez ci-dessous 3 méthodes d'intégration avec des exemples, des conseils sur l'échange de données et des listes de contrôle pour un démarrage rapide.

🔍 Pourquoi combiner Python et Lua

🎯 Scénarios typiques

• Jeux et simulations : serveur/outils en Python, logique de jeu en Lua.

• Plugins : les utilisateurs écrivent des extensions en Lua, le noyau en Python.

• Automatisation : orchestration Python, scripts Lua pour les tâches.

🛠 Trois façons d'intégrer

1) Intégrer Lua dans Python via lupa (LuaJIT)

pip install lupa

Python → appelle Lua

from lupa import LuaRuntime
lua = LuaRuntime(unpack_returned_tuples=True)

# 1) Obtenir la fonction directement
greet = lua.eval('function(name) return "Hello, " .. name .. "!" end'int(greet("Code"))  # Salut, Kodik !

# 2) Travailler avec le tableau comme avec un objet
Vector = lua.eval('''
  function (x, y)
    return { x = x or 0, y = y or 0,
      len = function(self) return math.sqrt(self.x*self.x + self.y*self.y) end
    }
  end
''')
v = Vector(3, 4)
print(v.len(v))  # 5.0

Lua → appelle Python (appels inversés)

from lupa import LuaRuntime
lua = LuaRuntime()
def py_log(msg): print("[PY]", msg)

lua.globals().py_log = py_log
lua.execute('py_log("Hello from Lua!")'')  # [PY] Bonjour de Lua !

# Nous transmettons la fonction Python à l'algorithme Lua
lua.execute('''
  function apply_twice(fn, x) return fn(fn(x)) end
''')
apply_twice = lua.eval('apply_twice')
print(apply_twice(lambda v: v * 2, 5))  # 20

Avantages : simple, très rapide (LuaJIT), appels bidirectionnels.

Inconvénients : dépendance aux binaires, nuances des types.

2) Exécuter Lua en tant que processus (subprocess + JSON)

Une méthode isolée et compréhensible pour les débutants : nous communiquons via des flux standard et une sérialisation.

Script Lua (stdin → stdout)

-- file: worker.lua
local json = require("dkjson")   -- или cjson, если доступен
local input = io.read("*a")
local req = json.decode(input)

local result = { sum = req.a + req.b, ok = true }
io.write(json.encode(result))

Enveloppe Python

import json, subprocess

payload = json.dumps({"a": 2, "b": 40})
proc = subprocess.run(
    ["lua", "worker.lua"],
    input=payload, text=True, capture_output=True, check=True
)
res = json.loads(proc.stdout)
print(res["sum"])  # 42

Avantages : indépendance des environnements, facile à déboguer/mettre à l'échelle. Inconvénients : IPC est plus cher qu'un appel direct.

3) Avancé : couche C commune/ FFI

Convient lorsqu'il existe un module C/C++ : Python et Lua sont liés au même code natif. Pour commencer, il suffit au débutant de savoir qu'un tel chemin existe ; plus profond — plus tard.

🔄 Échange de données sans douleur

Râteaux fréquents : types flottants (int vs float), encodage de chaîne (UTF-8 !), récursion dans les structures.

🧯 Erreurs et journalisation

Exceptions

• lupa : une erreur Lua déclenchera une exception Python — enveloppez les appels try/except.

• sous-processus : vérifie returncode et analyse stderr.

Journaux

• Faites un préfixe de journal commun : [PY] et [LUA].

• Pour subprocess — enregistrer l'entrée/sortie (en coupant les grandes payloads).

💡 Mini exemple : « règles » en Lua, service en Python

-- rules.lua
return {
  discount = function(price)
    if price >= 100 then return price * 0.9 end
    return price
  end
}

# service.py
from lupa import LuaRuntime
lua = LuaRuntime()
rules = lua.eval("dofile")("rules.lua")

def final_price(x): return rules["discount"](x)
print(final_price(150))  # 135.0

💡 Mini exemple : mini RPC via JSON

-- rpc.lua (Lua-процесс)
local json = require "dkjson"
local fn = {
  hello = function(args) return "Hi, " .. (args.name or "anon") end,
  add   = function(a,b) return a+b end
}
local req = json.decode(io.read("*a"))
local ok, out = pcall(function()
  if req.fn == "add" then return fn.add(req.a, req.b)
  else return fn.hello(req) end
end)
io.write(json.encode({ ok = ok, result = out }))

# py_rpc.py
import json, subprocess
def call(fn, **kw):
    req = json.dumps(dict(fn=fn, **kw))
    p = subprocess.run(["lua","rpc.lua"], input=req, text=True,
                       capture_output=True, check=True)
    return json.loads(p.stdout)["result"]

print(call("hello", name="Code"))
print(call("add", a=2, b=40))

📚 Vous voulez approfondir le sujet ?

Dans l'application Code vous trouverez des leçons détaillées sur Python et Lua, des exercices étape par étape, des analyses d'erreurs et des exercices pratiques directement sur votre téléphone ou votre navigateur.

Et si vous voulez être au courant des nouveautés, des nouvelles fonctionnalités et des contenus utiles, abonnez-vous à notre Chaîne Telegram. C'est confortable, professionnel et avec amour pour le code ❤️

💬 Que vas-tu mettre dans Lua : des règles, des configurations ou des calculs « à chaud » ?