• "a | b" gives the UNION
• "a & b" gives the INTERSECTION
• "a - b" gives the DIFFERENCE (in a, but not b)
• "a ^ b" gives the SYMMETRIC DIFFERENCE (items in either set, but not both)

When you want to compare the items in two collections, consider whether set arithmetic might help.

For example, to find which required fields are missing:

required = {"name", "email", "password"}
provided = set(form_data.keys())
missing = required - provided

More: https://pym.dev/practical-uses-of-sets/

🧵 (2/2)

If you find yourself doing containment checks inside a loop, your code has an O(n) operation for each step of another O(n) operation, making it O(n*n).

This O(n*n) code may take seconds over a large list:

for word in words:
if word[::-1] in words:
print(word)

While this O(n) code may takes milliseconds:

word_set = set(words)
for word in words:
if word[::-1] in word_set:
print(word)

For more on this topic, see my article on this: (https://pym.dev/time-complexities/

🧵 (4/4)

Here are the ones worth memorizing for Python's built-in data structures:

LISTS:
• Indexing (items[i]): O(1)
• Append/pop from end: O(1)
• Insert/pop from beginning: O(n)
• Containment check (x in items): O(n)
• Sorting: O(n log n)

SETS AND DICTIONARIES:
• Containment check (x in items): O(1)
• Add/remove: O(1)

🧵 (3/4)

Here are the most common time complexities you'll see in Python, from fastest to slowest:

• O(1) (constant): the work doesn't grow with the data, e.g. indexing a list

• O(N) (linear): the work grows with the data, e.g. looping over a list

• O(N LOG N): a bit slower than linear, e.g. sorting a list

• O(n*n) (quadratic): the work grows with the square of the data, e.g. a loop within a loop

🧵 (2/4)