Hi I’m learning about python asyncio from book named Using Asyncio in python from o’reilly
in this book there is an example of async for loop
<code># Example 3-26. Easier with an async generator
import asyncio
# Mock Redis interface
class Redis:
async def get(self, key):
await asyncio.sleep(1)
return 'value'
# Mock create_redis
# Real one: aioredis.create_redis
async def create_redis(socket):
await asyncio.sleep(1)
return Redis()
async def do_something_with(value):
await asyncio.sleep(1)
# Our function is now declared with async def , making it a coroutine
# function, and since this function also contains the yield keyword, we refer
# to it as an asynchronous generator function.
async def one_at_a_time(redis, keys):
for k in keys:
# We don’t have to do the convoluted things necessary in the previous
# example with self.ikeys: here, we just loop over the keys directly
# and obtain the value...
value = await redis.get(k)
# ...and then yield it to the caller, just like a normal generator.
yield value
# The main() function is identical to the version in Example 3-25.
async def main():
redis = await create_redis(('localhost', 6379))
keys = ['Americas', 'Africa', 'Europe', 'Asia']
async for value in one_at_a_time(redis, keys):
await do_something_with(value)
start = time.time()
asyncio.run(main())
end = time.time()
print(end - start)
#print result is 9.012349128723145
</code>
<code># Example 3-26. Easier with an async generator
import asyncio
# Mock Redis interface
class Redis:
async def get(self, key):
await asyncio.sleep(1)
return 'value'
# Mock create_redis
# Real one: aioredis.create_redis
async def create_redis(socket):
await asyncio.sleep(1)
return Redis()
async def do_something_with(value):
await asyncio.sleep(1)
# Our function is now declared with async def , making it a coroutine
# function, and since this function also contains the yield keyword, we refer
# to it as an asynchronous generator function.
async def one_at_a_time(redis, keys):
for k in keys:
# We don’t have to do the convoluted things necessary in the previous
# example with self.ikeys: here, we just loop over the keys directly
# and obtain the value...
value = await redis.get(k)
# ...and then yield it to the caller, just like a normal generator.
yield value
# The main() function is identical to the version in Example 3-25.
async def main():
redis = await create_redis(('localhost', 6379))
keys = ['Americas', 'Africa', 'Europe', 'Asia']
async for value in one_at_a_time(redis, keys):
await do_something_with(value)
start = time.time()
asyncio.run(main())
end = time.time()
print(end - start)
#print result is 9.012349128723145
</code>
# Example 3-26. Easier with an async generator
import asyncio
# Mock Redis interface
class Redis:
async def get(self, key):
await asyncio.sleep(1)
return 'value'
# Mock create_redis
# Real one: aioredis.create_redis
async def create_redis(socket):
await asyncio.sleep(1)
return Redis()
async def do_something_with(value):
await asyncio.sleep(1)
# Our function is now declared with async def , making it a coroutine
# function, and since this function also contains the yield keyword, we refer
# to it as an asynchronous generator function.
async def one_at_a_time(redis, keys):
for k in keys:
# We don’t have to do the convoluted things necessary in the previous
# example with self.ikeys: here, we just loop over the keys directly
# and obtain the value...
value = await redis.get(k)
# ...and then yield it to the caller, just like a normal generator.
yield value
# The main() function is identical to the version in Example 3-25.
async def main():
redis = await create_redis(('localhost', 6379))
keys = ['Americas', 'Africa', 'Europe', 'Asia']
async for value in one_at_a_time(redis, keys):
await do_something_with(value)
start = time.time()
asyncio.run(main())
end = time.time()
print(end - start)
#print result is 9.012349128723145
but I think it is not run asynchronously
comparing this code which is my sync code for comparing with above code
<code>class Redis:
def get(self, key):
time.sleep(1)
return 'value'
def create_redis(socket):
time.sleep(1)
return Redis()
def do_something_with(value):
time.sleep(1)
def one_at_a_time(redis, keys):
for k in keys:
value = redis.get(k)
yield value
# The main() function is identical to the version in Example 3-25.
def main():
redis = create_redis(('localhost', 6379))
keys = ['Americas', 'Africa', 'Europe', 'Asia']
tasks = []
for value in one_at_a_time(redis, keys):
do_something_with(value)
start = time.time()
main()
end = time.time()
print(end-start)
# print result 9.025717973709106
</code>
<code>class Redis:
def get(self, key):
time.sleep(1)
return 'value'
def create_redis(socket):
time.sleep(1)
return Redis()
def do_something_with(value):
time.sleep(1)
def one_at_a_time(redis, keys):
for k in keys:
value = redis.get(k)
yield value
# The main() function is identical to the version in Example 3-25.
def main():
redis = create_redis(('localhost', 6379))
keys = ['Americas', 'Africa', 'Europe', 'Asia']
tasks = []
for value in one_at_a_time(redis, keys):
do_something_with(value)
start = time.time()
main()
end = time.time()
print(end-start)
# print result 9.025717973709106
</code>
class Redis:
def get(self, key):
time.sleep(1)
return 'value'
def create_redis(socket):
time.sleep(1)
return Redis()
def do_something_with(value):
time.sleep(1)
def one_at_a_time(redis, keys):
for k in keys:
value = redis.get(k)
yield value
# The main() function is identical to the version in Example 3-25.
def main():
redis = create_redis(('localhost', 6379))
keys = ['Americas', 'Africa', 'Europe', 'Asia']
tasks = []
for value in one_at_a_time(redis, keys):
do_something_with(value)
start = time.time()
main()
end = time.time()
print(end-start)
# print result 9.025717973709106
the code running time is the same
is the first code async code?
I think it is not and I can’t understand why the book says it is async code..
Thanks for reading my question