Errata

running test.sh
shows
1 items had failures:
2 of 3 in bisect_demo
***Test Failed*** 2 failures.
Traceback (most recent call last):
File "/usr/lib64/python3.10/runpy.py", line 196, in _run_module_as_main
return _run_code(code, main_globals, None,
File "/usr/lib64/python3.10/runpy.py", line 86, in _run_code
exec(code, run_globals)
File "/usr/lib64/python3.10/doctest.py", line 2806, in <module>
sys.exit(_test())
File "/usr/lib64/python3.10/doctest.py", line 2794, in _test
m = __import__(filename[:-3])
ModuleNotFoundError: No module named 'metro_lat_long'
ERROR: usage: pytest [options] [file_or_dir] [file_or_dir] [...]
pytest: error: unrecognized arguments: --nbval
inifile: /data/files/python/fluent/example-code-2e/02-array-seq/pytest.ini
rootdir: /data/files/python/fluent/example-code-2e/02-array-seq

This paragraph includes the sentence:
"We then implemented __hash__ using the recommended technique of xor-ing the hashes of the instance attributes."
However this is not how __hash__ is actually implemented in the chapter:
"The __hash__ special method documentation suggests computing the hash of a tuple with the components, so that’s what we do in Example 11-8."

This text in this warning is based on an early draft of PEP 467 from 2014. Search for 3.6 on this page:

https://mail.python.org/pipermail/python-ideas/2014-March/027376.html

As of August 2022 the status of PEP 467 is still 'draft' and in practice the deprecation and removal have never been implemented.

In Python 3.10 it is still possible to call bytes or bytearray with a single integer to create a binary sequence of that size initialized with null bytes:

>>> bytes(4)
b'\x00\x00\x00\x00'

>>> bytearray(5)
bytearray(b'\x00\x00\x00\x00\x00')

The list in both the tuple and the array contains a period where there should be a comma. Also the formatting of the list in the array is missing a space:

(9.46, 'cat', [2.08. 4.29])

array('d', [9.46,2.08. 4.29])

The keyword argument for itertools.permutations seems to be wrong. In the text, it is presented as permutations(it, out_len=None), where out_len is the key word argument. However, that results in a TypeError for Python 3.10 -

list(itertools.permutations('ABC', out_len=2))
Traceback (most recent call last):
File [FILE_PATH], line 3433, in run_code
exec(code_obj, self.user_global_ns, self.user_ns)
File "<ipython-input-5-2aad04d92073>", line 1, in <module>
list(itertools.permutations('ABC', out_len=2))
TypeError: 'out_len' is an invalid keyword argument for permutations()

This key word argument also does not appear in the itertools documentation. Rather, the correct keyword appears to be 'r':

list(itertools.permutations('ABC', r=2))
Out[9]: [('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')]

The deque implements some of the missing methods starting from python 3.5, see the official documentation:

docs.python.org/3/library/collections.html#collections.deque

These include:
s.__add__
s.__contains__
s.copy()
s.index(e)
s.insert(p, e)
s.__mul__
s.__imul__
s.__rmul__

In the code for Example 5-2, book's output gives the answer False, for
`
>>> issubclass(Coordinate, typing.NamedTuple)
False
`
But in Python version 3.10.8 it is actually a TypeError with the message, issubclass() arg 2 must be a class, a tuple of classes, or a union

Minor error, last sentence of the second paragraph, text is "That is our next subject. *Bold Text*opmod07".

The following example in Chapter 8 ("Types Usable in Annotations" > "Callable") contains a syntax error (extra "]"):

def repl(input_fn: Callable[[Any], str] = input]) -> None:

I think this is the correct function signature:

def repl(input_fn: Callable[[Any], str] = input) -> None:

The output from "avg.__closure__[0].cell_contents" should read "[10, 11, 15]" instead, given we called the "avg" function three times with 10, 11, and 15 respectively in Example 9-9.

but for *, & it should be 1

for the bitwise and operation, the identity value should be 0b11111111... instead of 0b1

Table 16-1 refers to an infix operation "__idivmod__" which does not exist. Unlike the other operators in the table, divmod does not support augmented assignment; see the section "emulating numeric types" of the python data model reference for confirmation of this.

```
Now let’s study the async with statement that appeared in supervisor
(Example 21-2) and get_flag (Example 21-3).
```

But get_flag doesn't contain `async with` statement:
```
async def get_flag(client: AsyncClient, cc: str) -> bytes:
url = f'{BASE_URL}/{cc}/{cc}.gif'.lower()
resp = await client.get(url, timeout=6.1,
follow_redirects=True)
return resp.read()
```

The point where the error is initialised (indicated by point 6) is placed just outside the following for loop:

error: httpx.HTTPError | None = None
for coro in to_do_iter:
...

I believe the initialisation of the "error" variable should happen inside the for loop, so for every coro check it is initially None instead of carrying over the value from previous loop.

Thanks for an amazing book! Really enjoying it, and learning heaps!

If I'm reading it correctly, the text implies that the only difference between using `await` in a list comprehension (e.g. `[await fun() for fun in funcs]`) and using `asyncio.gather` is error handling.

This is misleading, because in the listcomp, coroutines will be executed serially, so it is much slower and not async. Minimal reproducing example:

```
async def async_main():
t0 = time.perf_counter()
await gather()
print(f"Gather took {time.perf_counter() - t0:.2f}s")

t0 = time.perf_counter()
await listcomp()
print(f"listcomp took {time.perf_counter() - t0:.2f}s")

async def gather():
tasks = [do_work(name) for name in names]
await asyncio.gather(*tasks)

async def listcomp():
[await do_work(name) for name in "a b c".split()]

async def do_work(name: str):
await asyncio.sleep(3)
return name

if __name__ == '__main__':
asyncio.run(async_main())
```

Output:
Gather took 3.00s
listcomp took 9.00s

Note #2 of the Example 22-29 says "Using vars to inspect the nutmeg instance". The code example itself doesn't use vars, it reads from the __dict__ property.