Wilson Jimenez

Wilson’s Bookshelves

to-read‎ (52)
currently-reading‎ (2)
read‎ (64)
did-not-finish‎ (0)
nonfiction‎ (55)
psycology‎ (28)
business‎ (27)

science‎ (19)
web-development‎ (19)
software-architecture‎ (18)
software-projects‎ (18)
economics‎ (11)
history‎ (11)
favourites‎ (9)

web-design‎ (9)
productivity‎ (8)
parenting‎ (7)
philosophy‎ (7)
python‎ (6)
ai‎ (5)
dom-rep-easter-2019‎ (4)

fiction‎ (4)
novels‎ (4)
dropped‎ (2)
finance‎ (2)

Stats | More…

Wilson is Currently Reading

Wilson Jimenez is currently reading

Fluent Python: Clear, Concise, and Effective Programming

by Luciano Ramalho (Goodreads Author)

bookshelves: currently-reading, nonfiction, finance, python

Rate this book

Clear rating

1 of 5 stars 2 of 5 stars 3 of 5 stars 4 of 5 stars 5 of 5 stars

Wilson Jimenez said:

This review has been hidden because it contains spoilers. To view it, click here.

" Notes:

Part 1: Data Structures

1. The Python Data Model

- !r is a conversion field in the format string syntax
* __repr__ uses !r underneath and it's called by the debugger to show the representation of the value
* !r will do Vector(1, 2) as opposed to __ Notes:

Part 1: Data Structures

1. The Python Data Model

- !r is a conversion field in the format string syntax
* __repr__ uses !r underneath and it's called by the debugger to show the representation of the value
* !r will do Vector(1, 2) as opposed to __str__ which will do Vector('1', '2')
* f'{value!r}' to use repr instead of str
* if you need to choose, implement __repr__ instead of __str__
- bool() calls __bool__, and __len__ if not implemented
- named tuple: class with only fields
- dict type is ordered, key insertion order is preserved
- writing code implementing special methods enables an expressive coding style the community considers pythonic

2. An Array of Sequences

- array.array hold the values, tuples hold references for those values (ie less memory)
- tuples use less memory than lists of the same length and tend to be more optimised
* tuples hold ref to values, lists copy vals and hold them
* lists hold a pointer to an array of references (which points to the values)
^ the indirection is needed in case the list grows, it makes CPU caches less effective
- capturing excess items (*) can appear in any position
- unpacking (*) can appear multiple times
- nested unpacking: x, y, (foo, bar)
* this unpacks (1, 2, (3, 4))

---Pattern matching
* match the first item(s) in the input sequence, the rest can be constants or variables, if the latter, are then bound to variables (like path params in endpoint definitions).
* the item count is part of the pattern and must match
* in sequence patterns: [] and () can both be used for unpacking/destructuring
* if statements can be used in patterns: case: [x, y] if x > 0:
* str, bytes, bytearray, can't be used as sequence patterns as they're are treated as atomic vals and not sequences
^ need casting first, eg tuple('555-555')
- the underscore (_) symbol matches anything without bounding it to a variable, it can also appear multiple times
- in pattern matching, str() and float() perform type check rather than casting the values like in other contexts
* adds an extra level of matching

- slices can be named for more context, ie my_slice = slice(2,3,4) then my_list[my_slice]
- numpy multidim arrays can take two dimensional slices, ie a[m:n, k:l]
- [1,2] * 2 = [1,2,1,2]
- augmented assignment with sequences
* when __iadd__ is implemented, a += b appends to a, otherwise it creates a new sequence, ie a = a + b
* immutable seq always result in a new reference
- list.sort operates in place, sorted() creates a new sequence (hence works even on immutable types)
- sys.stdout.isatty() checks the file descriptor is a terminal
* when true the encoding usually defaults to utf-8 (sys.stdout.encoding)
* when $ python foo.txt > bar.txt, it switches to locale.getpreferredencoding(), which could be cp1252 in windows

--- Alternatives to List
- arrays are better than lists for large lists of numbers
* saves memory when handling millions of floats
* they hold the machine representation of the values like in the C lang instead of the full float instance
* when creating an array, need to pass the C lang typecode it maps to, ie array('d') for an array of floats
* arrays are good for storing bytes
- deque (double ended queue) is an efficient FIFO data structure
- sets excel at (item in my_set) operations for large lists
* although sets are not sequences cause ordering is not specified
- memoryview allows slices of arrays without coping them, ie same reference
- numpy arrays are great for multi dim lists
- deque allows inserting and poping items from both ends
* .rotate() moves items from one end to another
* when bound to a max length, it drops items from the other end when inserting
- SimpleQueue, Queue, LifoQueue and PriorityQueue are other thread safe queues
* all except the first are bounded to max but don't expel items on insertion
* instead, get blocked until another thread pops an item
* good for thread pools
* asyncio provides its own async implementations of these queues
- heapq is python's min heap where the root el is the min, and last el the max

3. Dictionaries and Sets

- Hash tables for sets


* sets are stored in hash tables, the table has 2 cols: hash and pointer to value
* the algo adds a random salt to each hash to prevent similar values to end up with similar hashes
* the hash table is kept with 30% headroom to prevent index collisions and improved performance
* the table size is known so the index lookup is calculated by hash % table size
^ when index collision occurs, python compares the value, if same, noop, if different, goes to the next index
^ there's a limit to this linear progression, at which point python will randomize a bit more the hash to prevent further perf degradation
^ hash table size is doubled when passed the 2 thirds capacity to reduce index collisions
* hashable objects must implement __hash__ and __eq__ since the same hash can point to different values
* lookups work by hashing the value, then modulus with the table size to find the index, hence O(1) in most cases
^ in practice, most insertions happen with 1-2 collisions at most even in sets with millions of items
* python equality must be kept in sets, so while memory representation of 1 !== 1.00

- setdefault sets the key to a value if not existing and returns the value
- dict implements collections.abc.Mapping and MutableMapping
* isinstance(my_dict, abc.Mapping) == True
- default_factory in defaultdict is only called when dd[k] (ie accessing the __getitem__ method) and not when dd.get(k)
* the factory creates the key and returns the value
* dd = collections.defaultdict(list), assigns a list to missing keys when accessing them and returns the list
- implement __missing__ to handle access to non existing keys, ie it's called from dd[key] (__getitem__)
- caution when implementing __gettitem__ and __missing__ since they could end up in infinite recursion, dd[key] calls missing when non existing, returning dd[key] from missing, calls __getitem__ once again
* calling "k in my_dict" from __contains__ also ends in infinite recursion, use k in self.keys()
^ although k in my_dict is faster
* collections.UserDict calls __missing__ for both dd[k] and dd.get(k), while dict only for the former
- subclass UserDict instead of dict, as subclass of dict will not always call subclass implementations of dunders like __setitem__, __getitem__, etc
* UserDict is intended to be subclassed only, it's just a class implementing the ABC MutableMapping
- dict and OrderedDict are mostly similar nowadays
* the latter can handle frequent reordering better, so better suitable to track recent access, eg LRU
- collections.ChainMap combines mappings access (like prototypal property access)
* lookup = ChainMap(locals(), globals(), vars(builtins))
- MappingProxyType creates a readonly pointer to another dict
- views allow dict operations without copying data
* .keys(), .values(), .items() return readonly projections of the internal data structures holding them inside the dict
* since these are proxies, subsequent changes to the dict data also update any prev variable assignments to these objects
- to save memory, avoid creating instance attributes outside of __init__ as these are stored in an internal __dict__ which means another full dict
- use dict.fromKeys([1,2,2,3,3]).keys() to remove duplicates but preserve ordering of first occurrence
* which set() does not
- dict keys must be hashable
- set items must be hashable
- need to use the set() constructor in order to create an empty set
- the set literal syntax {1,2,3} is faster than the constructor
- frozenset can only be created via the constructor
- sets have more memory overhead due to the internal hash table, although this makes lookups faster for longer lists
* arrays/lists are more compact but lookups are slower on lists longer than a handful of items
- set order depends on insertion but is not reliable since order might change when cpython extends the hash table due to 2 thirds full which happens when adding elements
- set().union() takes any iterable of hasable items
- s.isdisjoint(z) means no elements in common
^ isdisjoint works on dict views: keys and items (only when values are hashable), does not work on values
- s <= z means s is a subset of z
* s.issubset(it) where 'it' is an Iterable
* >= for superset
* superset means all elements, proper superset means all elements plus at least one
- this hack: true, false, null = True, False, None, makes python compatible with json

4. Unicode Text Versus Bytes

- in python 3, strings are made of unicode chars
- in unicode the identity of a char is the same as its code point
* it's a number represented as a 4-6 hex digit prefixed with U+, eg U+20AC
- the bytes representing a char depend on the encoding we use
* utf-8 requires 3 bytes to encode the euro sign, utf-16L requires 2
- bytes type is immutable, bytearray is mutable
- foo = bytes('foo', encoding='utf_8')
- bar = bytearray(foo)
- both these types can be sliced
- unicode displays ascii chars 32-126 (space to tilde) as is, hene bytes sequences often look like strings prefixed with b, b'foo'
- bytes seqs support most str methods including regex
- creating bytes from a buffer like array.array copies the bytes, while memoryview shares memory between binary data structures
- there are UnicodeEncodeError and UnicodeDecodeError, raised when either encoding and decoding
* the former is commonly raised when encoding chars not present in the passed in encoding, ie using ascii to encode an accented vowel
* some legacy encodings do not raise errors and encode/decode gibberish instead
- ascii is a subset of most encodings
- str.decode('utf_8', errors='replace') adds a question mark on non-found chars
- cp1252 is a latin1 superset created by microsoft
- there is a str.isascii() method
- utf-16 and 32 use words of more than one byte when decoding code points so need to specify endianes (little or big endian)
* is not a problem for utf-8 since it uses single byte words
* some windows apps like notepad and excel, expect a BOM (byte ordering mark) as the first byte to determine endianes even for utf-8, while unix systems do not use this for utf-8
- always specify the encoding when reading/writing files as the default is not be utf-8 on all platforms
- can use unicode literals to print characters, eg '\N{DIGIT FIVE}'
- after 3.6 python defaults to utf-8 when .isatty() == True, locale when file
- sys.getfilesystemenconding() is used to encode/decode file names (not contents) when the name is passed a string, when passed as bytes, it's passed as is to the OS
- unicodadata.normalize() for reliable string comparison since 'café' != 'cafe\N{COMBINING ACUTE ACCENT}' even though they are decoded to the same string value
* these are canonical equivalients but python sees different code points
- some chars have more than one unicode code point for compatibility with preexisting standards like the MICRO SIGN (μ) in latin1, which is the greek small letter mu in unicode, both code points are present
- unicode provides str with the handy .isalpha(), isnumeric, isprintable, isdecimal
* these check str against one of the two digit unicode categories, eg Lm, Lt, Lu, etc
- unicodedata.name() returns the official char name in the standard, eg name('A') is LATIN CAPITAL LETTER A
* handy to allow users to search characters by name
- regex support lookup on both str and bytes
- the os module accepts bytes as well as str for filenames, this can find files with weird chars
* eg os.listdir(b'.') instead of os.listdir('.') to find all files in the dir

5. Data Class Builders

- collections.namedtuple, typing.NamedTuple, and dataclass are forms of classes with only fields
- TypedDict is not strictly a class as it cannot be instanciated, only adds types to a dict
- class Coordinate(NamedTuple) is mostly the same as a frozen=True dataclass decorated class
- dataclasses.asdict(x)
- my_named_tuple.asdict()
- new instance with changes: dataclasses.replace(class_instance, ...)
- new class at runtime: dataclasses.make_dataclass(...)
- declaring a dataclass with typehints but no default values does not add them as fields, they're not part of the attributes list until bound to a value
* while subclassing it from NamedTuple does create property descriptors even for unbound fields, readonly since it's a tuple
- dataclass fields declaration order is the same order the fields are passed to the __init__ internal under
- classes can have instance attributes which doesn't exist in the class, and class attributes (static) that are not bound to the instance
- setting new attributes after __init__ in dataclasses also defeats the inner __dict__ key sharing optimisation
- adding eq=True and frozen=True to the @dataclass decorator, makes it hashable
- the hash will use data from all fields that are not individually excluded
- default params by assignment on reference types creates a single value for all instances, eg my_list: list[str] = []
* need to use a field option to provide a different value to each instance, eg my_list: list[str] = field(default_factory=list)
^ the factory is any callable, it'll be called with no arguments on init each instance
^ there's also the default=... option, used in place of the default val assignment when needing to specify other field options
* there is a __post_init__ dunder called after __init__
- need to use typing.ClassVar[] passing in a generic to type class attributes (static fields)
* using the normal colon or field syntax will make the @dataclass decorator create it as an instance field
- can declare init-only variables with the typing.InitVar type
* it instructs the decorator to take it in as an argument to both __init__ and __post_init_ and not add it as a field
- bounding enum.auto() to enum entries, assigns the enum items' int value to the entry
- pattern matching subclass of NamedTuple
* case City(continent='Asia', country=cc) matches Asia and bounds the country
* might work with dataclass as well
* can use positional params as well as keyword
- the __match_args__ dunder defines the order of positional arguments, returns a tuple of params names
- self.__class__ gets the class instance
* fields(cls) gets the fields
- self.__name__ gets the class name
- getattr() gets the class attribute value or default if not existing
- methods are class attributes

6. Object References, Mutability, and Recycling

- for loop variables may cause weak references to survive gc
- list and dict cannot be weakly referenced, unless subclassed
* int and tuple cannot even if subclassed
- in python the object on the right side is created before the assignment happens
* x = my_class() * 10, here the class will be created even if the multiplication raises an error afterwards
- dir() returns all properties and methods of an object, even builtins, can be called without args
- == uses __eq__ while 'is' uses the identity comparison, ie the memory reference
* 'a == b' might be true if objects fields hold the same values but 'a is b' might be false if different references
- 'is' operator is useful when comparing against singletons, like None, ie x is None, x is not None
- sentinel value or object refer to values with a special condition like inexistence
* the standard lib value is None
* can be accessed via the callable: object()
- 'is' is faster than == because it cannot be overloaded so python does not have to find and invoke special methods
- == is syntactic sugar for a.__eq__(b)
- the __eq__ inherited from object performs ID comparisons, same as 'is', but most builtins override it
- == is what you want to use most times, it also works with None, albeit not as fast
- list() constructor and x[:] copy with new reference
- avoid mutable types as default params value like [], it'll be shared by all instances
- del x removes reference not val, if other references, memory is not freed
- t[:] and tuple(t) return a reference to the same object rather than a copy
* same for str, bytes, and frozenset, even fs.copy()
* since it makes little difference to have immutable types with the same reference

Part II. Functions as Objects

7. Functions as First-Class Objects

- use callable() to check if callable
- can make a class callable by implementing __call__
* useful when implementing decorators
- def fn(a, b, /) means all args to the left of the slash are positional only
- operator has several useful utils like itemgetter and attrgetter
* same for functools, like functools.partial and partialmethod()

8. Type Hints in Functions

-mypy, pyright, pyre, are type checkers, pycharm has one as well
- every type subtypes object
- int is consistent with float, float is consistent with complex
- tuple[int, ...] for tuples of unspecified length, any length >= 1
* can't do multi-types of unspecified length
- there is a Number abc
- T = typing.TypeVar('T'), needed for generics
* can be constrained like so NumberT = TypeVar('NumberT', float, Decimal, Fraction)
* HashableT = TypeVar('HashableT', bound=Hashable) allows only instances of Hashable
* from python 3.13, can do it inline def echo[T](value: T) -> T:
* typing.AnyStr is a bultin typevar that accepts str and bytes
- typing.Protocol true duck typing, same as in go with no need to subclass by implementers
* subclass it with the required methods, then set it as the boundary of a TypeVar()
- typing.TYPE_CHECKING, constant that's true when type checking, false at runtime
* enables use of the global reveal_type() of MyPy
- collections.abc has Callable[[param1, param2], returnType]
* has no syntax for optional or kwargs, instead use Callable[..., rt]
* Callable[[], rt] func with no args
- None is consistent with object
- NoReturn is a special type for annotating fns that never return, which usually exist to raise exceptions, eg sys.exit() raises SystemExit to terminate the python process
- def tag(name: str, /, *content: str, **attrs: float) -> str:
* / denotes positional only params (post python 3.8)
* content will be a tuple[str]
* attrs will be a dict[str, float] ...more "

progress:

(page 305 of 850)
— Jul 06, 2025 11:01PM

Jul 06, 2025 11:01PM · see review