TechnologyProfessionTest
Sort by
Newest
Most popular
Last review
Filter by
Published
10
Not published
0
To review
3
TechnologyProfessionTest
Sort by
Newest
Most popular
Last review
Filter by
Published
10
Not published
0
To review
3
13 questions
Medium
1 vote145 runs0 comment
Medium
1 vote132 runs0 comment
Hard
1 vote61 runs0 comment
Easy
1 vote36 runs0 comment
What does the variable `tg` represent in the `first_function` and within the context of the `main` function in the code below that uses `asyncio.TaskGroup`? ```python import asyncio async def second_function(): for _ in range(5): print('Second function iteration') await asyncio.sleep(1) async def first_function(tg: asyncio.TaskGroup): for _ in range(5): tg.create_task(second_function()) print('First function iteration') await asyncio.sleep(5) async def main(): async with asyncio.TaskGroup() as tg: task1 = tg.create_task(first_function(tg)) await task1 asyncio.run(main()) ```
John Pendenqueat Jan 6, 2026
Hard
1 vote33 runs0 comment
Consider both of these asynchronous functions: ```python async def second_function(): requests.get('http://example.com') print('Second function iteration') async def first_function(): requests.get('http://example.com') print('First function iteration') ``` Would you say that the logic behind `first_main` and `second_main` are equivalent to one another? ```python async def first_main(): tasks = [ asyncio.create_task(first_function()), asyncio.create_task(second_function()) ] for task in asyncio.as_completed(tasks): await task ``` ```python async def second_main(): await asyncio.gather(first_function(), second_function()) ``` __Find all the correct answers__
John Pendenqueat Jan 6, 2026
Medium
1 vote24 runs0 comment
What can be asserted about the unittest code below? ```python import unittest from unittest.mock import MagicMock, patch import requests class TestSimpleTest(unittest.TestCase): def test_request(self): with patch('requests.get') as mock_get: mock_response = MagicMock() mock_response.status_code = 200 mock_get.return_value = mock_response response = requests.get('https://example.com') self.assertEqual(response.status_code, 200) ```
John Pendenqueat Jan 6, 2026
Easy
0 vote305 runs0 comment
Hard
0 vote116 runs0 comment
Medium
0 vote64 runs0 comment
Hard
0 vote15 runs0 comment
Consider the two asynchronous functions below: ```python import asyncio async def second_function(): for _ in range(5): print('Second function iteration') await asyncio.sleep(3) async def first_function(): for _ in range(5): print('First function iteration') await asyncio.sleep(5) async def main(): task1 = asyncio.create_task(first_function()) task2 = asyncio.create_task(second_function()) await task1 await task2 asyncio.run(main()) ``` What can you say about the order of execution of these two functions?
John Pendenqueat Jan 6, 2026
Waiting for validation
0 vote0 run0 comment
Waiting for validation
0 vote0 run0 comment
In the code below, how does `ChildEvent` reuse the fields of `ParentEvent`? ```Go package main import "fmt" type ParentEvent struct { IsSet bool } type ChildEvent struct { ParentEvent } func main() { event := ChildEvent{ ParentEvent: ParentEvent{ IsSet: true, }, } fmt.Println(event) } ```
John Pendenqueat Oct 6, 2026
Waiting for validation
0 vote0 run0 comment
In an asynchronous function, what is the role of a `Semaphore`? ```python import asyncio async def request(index, sem): async with sem: print(f'Hello from request {index}!') await asyncio.sleep(3) async def main(): sem = asyncio.Semaphore(3) async with asyncio.TaskGroup() as tg: for index in range(20): tg.create_task(request(index, sem)) if __name__ == "__main__": asyncio.run(main()) ```
John Pendenqueat Oct 6, 2026