Est-il possible d'écrire une séquence de promesse (ou tâches) en utilisant uniquement Bibliothèque standard Python 3.6.1 ?
Par exemple, une séquence promise en JavaScript s'écrit:
const SLEEP_INTERVAL_IN_MILLISECONDS = 200;
const alpha = function alpha (number) {
return new Promise(function (resolve, reject) {
const fulfill = function() {
return resolve(number + 1);
};
return setTimeout(fulfill, SLEEP_INTERVAL_IN_MILLISECONDS);
});
};
const bravo = function bravo (number) {
return new Promise(function (resolve, reject) {
const fulfill = function() {
return resolve(Math.ceil(1000*Math.random()) + number);
};
return setTimeout(fulfill, SLEEP_INTERVAL_IN_MILLISECONDS);
});
};
const charlie = function charlie (number) {
return new Promise(function (resolve, reject) {
return (number%2 == 0) ? reject(number) : resolve(number);
});
};
function run() {
return Promise.resolve(42)
.then(alpha)
.then(bravo)
.then(charlie)
.then((number) => {
console.log('success: ' + number)
})
.catch((error) => {
console.log('error: ' + error);
});
}
run();
Chaque fonction renvoie également une promesse avec un résultat de traitement asynchrone, qui serait résolu/rejeté par la promesse immédiatement suivante.
Je connais des bibliothèques telles que promises-2.01b
et asyncio 3.4.3
et je cherche une solution Python STL. Ainsi, si j'ai besoin d'importer une bibliothèque non STL, je préfère utiliser RxPython à la place.
Voici un programme similaire utilisant asyncio et le async/await
synthax:
import asyncio
import random
async def alpha(x):
await asyncio.sleep(0.2)
return x + 1
async def bravo(x):
await asyncio.sleep(0.2)
return random.randint(0, 1000) + x
async def charlie(x):
if x % 2 == 0:
return x
raise ValueError(x, 'is odd')
async def run():
try:
number = await charlie(await bravo(await alpha(42)))
except ValueError as exc:
print('error:', exc.args[0])
else:
print('success:', number)
if __name__ == '__main__':
loop = asyncio.get_event_loop()
loop.run_until_complete(run())
loop.close()
EDIT: Si vous êtes intéressé par les flux réactifs, vous pourriez envisager d'utiliser aiostream .
Voici un exemple simple:
import asyncio
from aiostream import stream, pipe
async def main():
# This stream computes 11² + 13² in 1.5 second
xs = (
stream.count(interval=0.1) # Count from zero every 0.1 s
| pipe.skip(10) # Skip the first 10 numbers
| pipe.take(5) # Take the following 5
| pipe.filter(lambda x: x % 2) # Keep odd numbers
| pipe.map(lambda x: x ** 2) # Square the results
| pipe.accumulate() # Add the numbers together
)
print('11² + 13² = ', await xs)
if __name__ == '__main__':
loop = asyncio.get_event_loop()
loop.run_until_complete(main())
loop.close()
Plus d'exemples dans la documentation .
Vous avez de la chance, Python 3.4 et supérieur incluent asyncio
, bien que la fonctionnalité que vous recherchez ( Future ) soit disponible dans Python 3,5 et plus.
À partir de votre propre lien sur asyncio
: "Cette version n'est pertinente que pour Python 3.3, qui n'inclut pas asyncio dans son stdlib."
Exemple:
import asyncio
async def some_coroutine():
await asyncio.sleep(1)
return 'done'
def process_result(future):
print('Task returned:', future.result())
loop = asyncio.get_event_loop()
task = loop.create_task(some_coroutine())
task.add_done_callback(process_result)
loop.run_until_complete()